ccmanager 2.1.0 → 2.2.1

package/dist/services/sessionManager.js

@@ -4,8 +4,9 @@ import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { configurationManager } from './configurationManager.js';
-import { WorktreeService } from './worktreeService.js';
+import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 export class SessionManager extends EventEmitter {
@@ -71,10 +72,13 @@ export class SessionManager extends EventEmitter {
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             commandConfig,
             detectionStrategy: options.detectionStrategy ?? 'claude',
-            devcontainerConfig: options.devcontainerConfig,
+            devcontainerConfig: options.devcontainerConfig ?? undefined,
+            pendingState: undefined,
+            pendingStateStart: undefined,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -188,16 +192,39 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // Setup data handler
         this.setupDataHandler(session);
-        // Set up interval-based state detection
+        // Set up interval-based state detection with persistence
         session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
-            const newState = this.detectTerminalState(session);
-            if (newState !== oldState) {
-                session.state = newState;
-                this.executeStatusHook(oldState, newState, session);
-                this.emit('sessionStateChanged', session);
+            const detectedState = this.detectTerminalState(session);
+            const now = Date.now();
+            // If detected state is different from current state
+            if (detectedState !== oldState) {
+                // If this is a new pending state or the pending state changed
+                if (session.pendingState !== detectedState) {
+                    session.pendingState = detectedState;
+                    session.pendingStateStart = now;
+                }
+                else if (session.pendingState !== undefined &&
+                    session.pendingStateStart !== undefined) {
+                    // Check if the pending state has persisted long enough
+                    const duration = now - session.pendingStateStart;
+                    if (duration >= STATE_PERSISTENCE_DURATION_MS) {
+                        // Confirm the state change
+                        session.state = detectedState;
+                        session.pendingState = undefined;
+                        session.pendingStateStart = undefined;
+                        // Execute status hook asynchronously (non-blocking)
+                        void executeStatusHook(oldState, detectedState, session);
+                        this.emit('sessionStateChanged', session);
+                    }
+                }
+            }
+            else {
+                // Detected state matches current state, clear any pending state
+                session.pendingState = undefined;
+                session.pendingStateStart = undefined;
             }
-        }, 100); // Check every 100ms
+        }, STATE_CHECK_INTERVAL_MS);
         // Setup exit handler
         this.setupExitHandler(session);
     }
@@ -205,7 +232,11 @@ export class SessionManager extends EventEmitter {
         // Clear the state check interval
         if (session.stateCheckInterval) {
             clearInterval(session.stateCheckInterval);
+            session.stateCheckInterval = undefined;
         }
+        // Clear any pending state
+        session.pendingState = undefined;
+        session.pendingStateStart = undefined;
         // Update state to idle before destroying
         session.state = 'idle';
         this.emit('sessionStateChanged', session);
@@ -252,36 +283,6 @@ export class SessionManager extends EventEmitter {
     getAllSessions() {
         return Array.from(this.sessions.values());
     }
-    executeStatusHook(oldState, newState, session) {
-        const statusHooks = configurationManager.getStatusHooks();
-        const hook = statusHooks[newState];
-        if (hook && hook.enabled && hook.command) {
-            // Get branch information
-            const worktreeService = new WorktreeService();
-            const worktrees = worktreeService.getWorktrees();
-            const worktree = worktrees.find(wt => wt.path === session.worktreePath);
-            const branch = worktree?.branch || 'unknown';
-            // Execute the hook command in the session's worktree directory
-            exec(hook.command, {
-                cwd: session.worktreePath,
-                env: {
-                    ...process.env,
-                    CCMANAGER_OLD_STATE: oldState,
-                    CCMANAGER_NEW_STATE: newState,
-                    CCMANAGER_WORKTREE: session.worktreePath,
-                    CCMANAGER_WORKTREE_BRANCH: branch,
-                    CCMANAGER_SESSION_ID: session.id,
-                },
-            }, (error, _stdout, stderr) => {
-                if (error) {
-                    console.error(`Failed to execute ${newState} hook: ${error.message}`);
-                }
-                if (stderr) {
-                    console.error(`Hook stderr: ${stderr}`);
-                }
-            });
-        }
-    }
     async createSessionWithDevcontainer(worktreePath, devcontainerConfig, presetId) {
         // Check if session already exists
         const existing = this.sessions.get(worktreePath);

package/dist/services/sessionManager.statePersistence.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+import { EventEmitter } from 'events';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+vi.mock('node-pty');
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getConfig: vi.fn().mockReturnValue({
+            commands: [
+                {
+                    id: 'test',
+                    name: 'Test',
+                    command: 'test',
+                    args: [],
+                },
+            ],
+            defaultCommandId: 'test',
+        }),
+        getPresetById: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getDefaultPreset: vi.fn().mockReturnValue({
+            id: 'test',
+            name: 'Test',
+            command: 'test',
+            args: [],
+        }),
+        getHooks: vi.fn().mockReturnValue({}),
+        getStatusHooks: vi.fn().mockReturnValue({}),
+    },
+}));
+describe('SessionManager - State Persistence', () => {
+    let sessionManager;
+    let mockPtyInstances;
+    let eventEmitters;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        sessionManager = new SessionManager();
+        mockPtyInstances = new Map();
+        eventEmitters = new Map();
+        // Create mock PTY process factory
+        spawn.mockImplementation((command, args, options) => {
+            const path = options.cwd;
+            const eventEmitter = new EventEmitter();
+            eventEmitters.set(path, eventEmitter);
+            const mockPty = {
+                onData: vi.fn((callback) => {
+                    eventEmitter.on('data', callback);
+                    return { dispose: vi.fn() };
+                }),
+                onExit: vi.fn((callback) => {
+                    eventEmitter.on('exit', callback);
+                    return { dispose: vi.fn() };
+                }),
+                write: vi.fn(),
+                resize: vi.fn(),
+                kill: vi.fn(),
+                process: 'test',
+                pid: 12345 + mockPtyInstances.size,
+            };
+            mockPtyInstances.set(path, mockPty);
+            return mockPty;
+        });
+    });
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+        vi.clearAllMocks();
+    });
+    it('should not change state immediately when detected state changes', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // State should still be busy, but pending state should be set
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+    });
+    it('should change state after persistence duration is met', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+        // Advance time to exceed persistence duration
+        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        // State should now be changed
+        expect(session.state).toBe('idle');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+        expect(stateChangeHandler).toHaveBeenCalledWith(session);
+    });
+    it('should cancel pending state if detected state changes again before persistence', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        // Simulate output that would trigger waiting_input state
+        eventEmitter.emit('data', '│ Do you want to continue?');
+        // Advance time to trigger another check
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // Pending state should now be waiting_input, not idle
+        expect(session.state).toBe('busy'); // Still original state
+        expect(session.pendingState).toBe('waiting_input');
+    });
+    it('should clear pending state if detected state returns to current state', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+        // Simulate output that would trigger busy state again (back to original)
+        eventEmitter.emit('data', 'ESC to interrupt');
+        // Advance time to trigger another check
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS);
+        // Pending state should be cleared
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBeUndefined();
+        expect(session.pendingStateStart).toBeUndefined();
+    });
+    it('should not confirm state changes that do not persist long enough', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.state).toBe('busy');
+        // Try to change to idle
+        eventEmitter.emit('data', 'Some idle output\n');
+        // Wait for detection but not full persistence (less than 200ms)
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Should have pending state but not confirmed
+        expect(session.state).toBe('busy');
+        expect(session.pendingState).toBe('idle');
+        // Now change to a different state before idle persists
+        // Clear terminal first and add waiting prompt
+        eventEmitter.emit('data', '\x1b[2J\x1b[H│ Do you want to continue?\n');
+        // Advance time to detect new state but still less than persistence duration from first change
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS); // Another 100ms, total 200ms exactly at threshold
+        // Pending state should have changed to waiting_input
+        expect(session.state).toBe('busy'); // Still original state
+        expect(session.pendingState).toBe('waiting_input');
+        // Since states kept changing before persisting, no state change should have been confirmed
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
+    it('should properly clean up pending state when session is destroyed', async () => {
+        const session = await sessionManager.createSessionWithPreset('/test/path');
+        const eventEmitter = eventEmitters.get('/test/path');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time less than persistence duration
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        expect(session.pendingState).toBe('idle');
+        expect(session.pendingStateStart).toBeDefined();
+        // Destroy the session
+        sessionManager.destroySession('/test/path');
+        // Check that pending state is cleared
+        const destroyedSession = sessionManager.getSession('/test/path');
+        expect(destroyedSession).toBeUndefined();
+    });
+    it('should handle multiple sessions with independent state persistence', async () => {
+        const session1 = await sessionManager.createSessionWithPreset('/test/path1');
+        const session2 = await sessionManager.createSessionWithPreset('/test/path2');
+        const eventEmitter1 = eventEmitters.get('/test/path1');
+        const eventEmitter2 = eventEmitters.get('/test/path2');
+        // Both should start as busy
+        expect(session1.state).toBe('busy');
+        expect(session2.state).toBe('busy');
+        // Simulate different outputs for each session
+        // Session 1 goes to idle
+        eventEmitter1.emit('data', 'Idle output for session 1');
+        // Session 2 goes to waiting_input
+        eventEmitter2.emit('data', '│ Do you want to continue?');
+        // Advance time to check but not confirm
+        vi.advanceTimersByTime(STATE_CHECK_INTERVAL_MS * 2);
+        // Both should have pending states but not changed yet
+        expect(session1.state).toBe('busy');
+        expect(session1.pendingState).toBe('idle');
+        expect(session2.state).toBe('busy');
+        expect(session2.pendingState).toBe('waiting_input');
+        // Advance time to confirm both
+        vi.advanceTimersByTime(STATE_PERSISTENCE_DURATION_MS);
+        // Both should now be in their new states
+        expect(session1.state).toBe('idle');
+        expect(session1.pendingState).toBeUndefined();
+        expect(session2.state).toBe('waiting_input');
+        expect(session2.pendingState).toBeUndefined();
+    });
+});

package/dist/services/worktreeService.d.ts

@@ -10,10 +10,10 @@ export declare class WorktreeService {
     getGitRootPath(): string;
     getDefaultBranch(): string;
     getAllBranches(): string[];
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Promise<{
         success: boolean;
         error?: string;
-    };
+    }>;
     deleteWorktree(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): {

package/dist/services/worktreeService.js

@@ -3,6 +3,8 @@ import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
+import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
+import { configurationManager } from './configurationManager.js';
 const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
@@ -188,7 +190,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
+    async createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -239,6 +241,21 @@ export class WorktreeService {
                     console.error('Warning: Failed to copy .claude directory:', error);
                 }
             }
+            // Execute post-creation hook if configured
+            const worktreeHooks = configurationManager.getWorktreeHooks();
+            if (worktreeHooks.post_creation?.enabled &&
+                worktreeHooks.post_creation?.command) {
+                // Create a worktree object for the hook
+                const newWorktree = {
+                    path: resolvedPath,
+                    branch: branch,
+                    isMainWorktree: false,
+                    hasSession: false,
+                };
+                // Execute the hook synchronously (blocking)
+                // Wait for the hook to complete before returning
+                await executeWorktreePostCreationHook(worktreeHooks.post_creation.command, newWorktree, this.gitRootPath, baseBranch);
+            }
             return { success: true };
         }
         catch (error) {

package/dist/services/worktreeService.test.js

@@ -1,7 +1,9 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
 import { existsSync, statSync } from 'fs';
+import { configurationManager } from './configurationManager.js';
+import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
 // Mock child_process module
 vi.mock('child_process');
 // Mock fs module
@@ -14,10 +16,22 @@ vi.mock('./worktreeConfigManager.js', () => ({
         reset: vi.fn(),
     },
 }));
+// Mock configurationManager
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getWorktreeHooks: vi.fn(),
+    },
+}));
+// Mock HookExecutor
+vi.mock('../utils/hookExecutor.js', () => ({
+    executeWorktreePostCreationHook: vi.fn(),
+}));
 // Get the mocked function with proper typing
 const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
+const mockedGetWorktreeHooks = vi.mocked(configurationManager.getWorktreeHooks);
+const mockedExecuteHook = vi.mocked(executeWorktreePostCreationHook);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
@@ -29,6 +43,8 @@ describe('WorktreeService', () => {
             }
             throw new Error('Command not mocked: ' + cmd);
         });
+        // Default mock for getWorktreeHooks to return empty config
+        mockedGetWorktreeHooks.mockReturnValue({});
         service = new WorktreeService('/fake/path');
     });
     describe('getGitRootPath', () => {
@@ -177,7 +193,7 @@ origin/feature/test
         });
     });
     describe('createWorktree', () => {
-        it('should create worktree with base branch when branch does not exist', () => {
+        it('should create worktree with base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -190,11 +206,11 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'develop');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "develop"', expect.any(Object));
         });
-        it('should create worktree without base branch when branch exists', () => {
+        it('should create worktree without base branch when branch exists', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -207,11 +223,11 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
+            const result = await service.createWorktree('/path/to/worktree', 'existing-feature', 'main');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add "/path/to/worktree" "existing-feature"', expect.any(Object));
         });
-        it('should create worktree from specified base branch when branch does not exist', () => {
+        it('should create worktree from specified base branch when branch does not exist', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
                     if (cmd === 'git rev-parse --git-common-dir') {
@@ -224,7 +240,7 @@ origin/feature/test
                 }
                 throw new Error('Unexpected command');
             });
-            const result = service.createWorktree('/path/to/worktree', 'new-feature', 'main');
+            const result = await service.createWorktree('/path/to/worktree', 'new-feature', 'main');
             expect(result).toEqual({ success: true });
             expect(execSync).toHaveBeenCalledWith('git worktree add -b "new-feature" "/path/to/worktree" "main"', expect.any(Object));
         });
@@ -389,4 +405,143 @@ branch refs/heads/other-branch
             expect(existsSync).toHaveBeenCalledWith('/fake/path/.claude');
         });
     });
+    describe('Worktree Hook Execution', () => {
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should execute post-creation hook when worktree is created', async () => {
+            // Arrange
+            const hookCommand = 'echo "Worktree created: $CCMANAGER_WORKTREE_PATH"';
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: hookCommand,
+                    enabled: true,
+                },
+            });
+            mockedExecuteHook.mockResolvedValue(undefined);
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).toHaveBeenCalledWith(hookCommand, expect.objectContaining({
+                path: '/fake/path/feature-branch-dir',
+                branch: 'feature-branch',
+                isMainWorktree: false,
+                hasSession: false,
+            }), '/fake/path', 'main');
+        });
+        it('should not execute hook when disabled', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: 'echo "Should not run"',
+                    enabled: false,
+                },
+            });
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).not.toHaveBeenCalled();
+        });
+        it('should not execute hook when not configured', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({});
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedGetWorktreeHooks).toHaveBeenCalled();
+            expect(mockedExecuteHook).not.toHaveBeenCalled();
+        });
+        it('should not fail worktree creation if hook execution fails', async () => {
+            // Arrange
+            mockedGetWorktreeHooks.mockReturnValue({
+                post_creation: {
+                    command: 'failing-command',
+                    enabled: true,
+                },
+            });
+            // The real executeWorktreePostCreationHook doesn't throw, it catches errors internally
+            // So the mock should resolve, not reject
+            mockedExecuteHook.mockResolvedValue(undefined);
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('git worktree list')) {
+                        return 'worktree /fake/path\nHEAD abc123\nbranch refs/heads/main\n';
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git rev-parse --verify')) {
+                        throw new Error('Branch not found');
+                    }
+                }
+                return '';
+            });
+            // Act
+            const result = await service.createWorktree('feature-branch-dir', 'feature-branch', 'main', false, false);
+            // Allow async operations to complete
+            await new Promise(resolve => setTimeout(resolve, 10));
+            // Assert
+            expect(result.success).toBe(true);
+            expect(mockedExecuteHook).toHaveBeenCalled();
+        });
+    });
 });