ccmanager 3.6.7 → 3.6.10

package/dist/components/ConfigureOther.js

@@ -18,6 +18,7 @@ const ConfigureOther = ({ onComplete }) => {
     const [customCommandDraft, setCustomCommandDraft] = useState(customCommand);
     const [timeout, setTimeout] = useState(autoApprovalConfig.timeout ?? 30);
     const [timeoutDraft, setTimeoutDraft] = useState(timeout);
+    const [clearHistoryOnClear, setClearHistoryOnClear] = useState(autoApprovalConfig.clearHistoryOnClear ?? false);
     // Show if inheriting from global (for project scope)
     const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('autoApproval');
     useInput((input, key) => {
@@ -48,6 +49,10 @@ const ConfigureOther = ({ onComplete }) => {
             label: `⏱️  Set Timeout (${timeout}s)`,
             value: 'timeout',
         },
+        {
+            label: `Clear History on Screen Clear: ${clearHistoryOnClear ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleClearHistory',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -70,11 +75,15 @@ const ConfigureOther = ({ onComplete }) => {
                 setTimeoutDraft(timeout);
                 setView('timeout');
                 break;
+            case 'toggleClearHistory':
+                setClearHistoryOnClear(!clearHistoryOnClear);
+                break;
             case 'save':
                 configEditor.setAutoApprovalConfig({
                     enabled: autoApprovalEnabled,
                     customCommand: customCommand.trim() || undefined,
                     timeout,
+                    clearHistoryOnClear,
                 });
                 onComplete();
                 break;
@@ -104,6 +113,6 @@ const ConfigureOther = ({ onComplete }) => {
             } }));
     }
     const scopeLabel = scope === 'project' ? 'Project' : 'Global';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Other & Experimental Settings (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "\uD83D\uDCCB Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Toggle experimental capabilities and other miscellaneous options." }) }), _jsx(CustomCommandSummary, { command: customCommand }), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to return without saving"] }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Other & Experimental Settings (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "\uD83D\uDCCB Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Toggle experimental capabilities and other miscellaneous options." }) }), _jsx(CustomCommandSummary, { command: customCommand }), clearHistoryOnClear && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Clear History: When enabled, session output history is cleared when a screen clear escape sequence is detected (e.g., /clear command). This prevents excessive scrolling during session restoration." }) })), _jsx(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to return without saving"] }) })] }));
 };
 export default ConfigureOther;

package/dist/components/ConfigureWorktree.js

@@ -15,6 +15,7 @@ const ConfigureWorktree = ({ onComplete }) => {
     const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [sortByLastSession, setSortByLastSession] = useState(worktreeConfig.sortByLastSession ?? false);
+    const [autoUseDefaultBranch, setAutoUseDefaultBranch] = useState(worktreeConfig.autoUseDefaultBranch ?? false);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
     // Show if inheriting from global (for project scope)
@@ -45,6 +46,10 @@ const ConfigureWorktree = ({ onComplete }) => {
             label: `Sort by Last Session: ${sortByLastSession ? '✅ Enabled' : '❌ Disabled'}`,
             value: 'toggleSort',
         },
+        {
+            label: `Auto Use Default Branch: ${autoUseDefaultBranch ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleAutoUseDefault',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -69,6 +74,9 @@ const ConfigureWorktree = ({ onComplete }) => {
             case 'toggleSort':
                 setSortByLastSession(!sortByLastSession);
                 break;
+            case 'toggleAutoUseDefault':
+                setAutoUseDefaultBranch(!autoUseDefaultBranch);
+                break;
             case 'save':
                 // Save the configuration
                 configEditor.setWorktreeConfig({
@@ -76,6 +84,7 @@ const ConfigureWorktree = ({ onComplete }) => {
                     autoDirectoryPattern: pattern,
                     copySessionData,
                     sortByLastSession,
+                    autoUseDefaultBranch,
                 });
                 onComplete();
                 break;

package/dist/components/ConfigureWorktreeHooks.js

@@ -13,6 +13,7 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
     const [worktreeHooks, setWorktreeHooks] = useState(initialWorktreeHooks);
     const [currentCommand, setCurrentCommand] = useState('');
     const [currentEnabled, setCurrentEnabled] = useState(false);
+    const [currentHookType, setCurrentHookType] = useState('post_creation');
     const [showSaveMessage, setShowSaveMessage] = useState(false);
     // Show if inheriting from global (for project scope)
     const isInheriting = scope === 'project' && !configEditor.hasProjectOverride('worktreeHooks');
@@ -32,6 +33,13 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
     const getMenuItems = () => {
         const items = [];
         // Add worktree hook items
+        const preCreationHook = worktreeHooks.pre_creation;
+        const preCreationEnabled = preCreationHook?.enabled ? '✓' : '✗';
+        const preCreationCommand = preCreationHook?.command || '(not set)';
+        items.push({
+            label: `Pre Creation: ${preCreationEnabled} ${preCreationCommand}`,
+            value: 'worktree:pre_creation',
+        });
         const postCreationHook = worktreeHooks.post_creation;
         const postCreationEnabled = postCreationHook?.enabled ? '✓' : '✗';
         const postCreationCommand = postCreationHook?.command || '(not set)';
@@ -64,18 +72,25 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
         else if (item.value === 'cancel') {
             onComplete();
         }
-        else if (!item.value.includes('separator') &&
-            item.value === 'worktree:post_creation') {
+        else if (item.value === 'worktree:pre_creation') {
+            const hook = worktreeHooks.pre_creation;
+            setCurrentCommand(hook?.command || '');
+            setCurrentEnabled(hook?.enabled ?? true);
+            setCurrentHookType('pre_creation');
+            setView('edit');
+        }
+        else if (item.value === 'worktree:post_creation') {
             const hook = worktreeHooks.post_creation;
             setCurrentCommand(hook?.command || '');
             setCurrentEnabled(hook?.enabled ?? true);
+            setCurrentHookType('post_creation');
             setView('edit');
         }
     };
     const handleCommandSubmit = (value) => {
         setWorktreeHooks(prev => ({
             ...prev,
-            post_creation: {
+            [currentHookType]: {
                 command: value,
                 enabled: currentEnabled,
             },
@@ -89,7 +104,10 @@ const ConfigureWorktreeHooks = ({ onComplete, }) => {
         return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "green", children: "\u2713 Configuration saved successfully!" }) }));
     }
     if (view === 'edit') {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Configure Post Worktree Creation Hook" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Command to execute after creating a new worktree:" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(TextInputWrapper, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., npm install && npm run build)" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enabled: ", currentEnabled ? '✓' : '✗', " (Press Tab to toggle)"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Environment variables available: CCMANAGER_WORKTREE_PATH, CCMANAGER_WORKTREE_BRANCH," }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "CCMANAGER_BASE_BRANCH, CCMANAGER_GIT_ROOT" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to save, Tab to toggle enabled, Esc to cancel" }) })] }));
+        const isPreCreation = currentHookType === 'pre_creation';
+        const hookTypeLabel = isPreCreation ? 'Pre' : 'Post';
+        const timingLabel = isPreCreation ? 'before' : 'after';
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure ", hookTypeLabel, " Worktree Creation Hook"] }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Command to execute ", timingLabel, " creating a new worktree:"] }) }), isPreCreation && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "Note: Runs in git root directory. Failures abort worktree creation." }) })), _jsx(Box, { marginBottom: 1, children: _jsx(TextInputWrapper, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., npm install && npm run build)" }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enabled: ", currentEnabled ? '✓' : '✗', " (Press Tab to toggle)"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Environment variables available: CCMANAGER_WORKTREE_PATH, CCMANAGER_WORKTREE_BRANCH," }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "CCMANAGER_BASE_BRANCH, CCMANAGER_GIT_ROOT" }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to save, Tab to toggle enabled, Esc to cancel" }) })] }));
     }
     const scopeLabel = scope === 'project' ? 'Project' : 'Global';
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "green", children: ["Configure Worktree Hooks (", scopeLabel, ")"] }) }), isInheriting && (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "\uD83D\uDCCB Inheriting from global configuration", ' '] }) })), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Set commands to run on worktree events:" }) }), _jsx(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true, limit: 10 }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Esc to go back" }) })] }));

package/dist/components/NewWorktree.js

@@ -12,9 +12,20 @@ import { Effect } from 'effect';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const worktreeConfig = configReader.getWorktreeConfig();
     const isAutoDirectory = worktreeConfig.autoDirectory;
+    const isAutoUseDefaultBranch = worktreeConfig.autoUseDefaultBranch ?? false;
     const limit = 10;
-    // Adjust initial step based on auto directory mode
-    const [step, setStep] = useState(isAutoDirectory ? 'base-branch' : 'path');
+    // Determine initial step based on config options
+    // If autoUseDefaultBranch is enabled, we start at a temporary 'loading' state
+    // and will transition to 'branch-strategy' after branches are loaded
+    const getInitialStep = () => {
+        if (isAutoDirectory) {
+            // With autoDirectory, skip path input
+            // If autoUseDefaultBranch is also enabled, we'll skip base-branch after loading
+            return 'base-branch';
+        }
+        return 'path';
+    };
+    const [step, setStep] = useState(getInitialStep());
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
     const [baseBranch, setBaseBranch] = useState('');
@@ -52,6 +63,14 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                     setBranches(result.branches);
                     setDefaultBranch(result.defaultBranch);
                     setIsLoadingBranches(false);
+                    // If autoUseDefaultBranch is enabled, auto-set the base branch
+                    // and skip to branch-strategy step
+                    if (isAutoUseDefaultBranch && result.defaultBranch) {
+                        setBaseBranch(result.defaultBranch);
+                        // Skip base-branch step, go directly to branch-strategy
+                        // (if we're at base-branch step, which happens with autoDirectory)
+                        setStep(currentStep => currentStep === 'base-branch' ? 'branch-strategy' : currentStep);
+                    }
                 }
             }
         };
@@ -64,7 +83,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
         return () => {
             cancelled = true;
         };
-    }, [projectPath]);
+    }, [projectPath, isAutoUseDefaultBranch]);
     // Create branch items with default branch first (memoized)
     const allBranchItems = useMemo(() => [
         { label: `${defaultBranch} (default)`, value: defaultBranch },
@@ -96,7 +115,15 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const handlePathSubmit = (value) => {
         if (value.trim()) {
             setPath(value.trim());
-            setStep('base-branch');
+            // If autoUseDefaultBranch is enabled and we have the default branch,
+            // skip base-branch selection and go directly to branch-strategy
+            if (isAutoUseDefaultBranch && defaultBranch) {
+                setBaseBranch(defaultBranch);
+                setStep('branch-strategy');
+            }
+            else {
+                setStep('base-branch');
+            }
         }
     };
     const handleBranchSubmit = (value) => {

package/dist/components/NewWorktree.test.js

@@ -259,4 +259,68 @@ describe('NewWorktree component Effect integration', () => {
         // Verify Effect was executed (Effect.match pattern)
         expect(effectExecuted).toBe(true);
     });
+    it('should skip base branch selection when autoUseDefaultBranch is enabled with autoDirectory', async () => {
+        const { Effect } = await import('effect');
+        const { WorktreeService } = await import('../services/worktreeService.js');
+        const { configReader } = await import('../services/config/configReader.js');
+        // Mock config with both autoDirectory and autoUseDefaultBranch enabled
+        vi.spyOn(configReader, 'getWorktreeConfig').mockReturnValue({
+            autoDirectory: true,
+            autoDirectoryPattern: '../{project}-{branch}',
+            copySessionData: true,
+            autoUseDefaultBranch: true,
+        });
+        const mockBranches = ['main', 'feature-1', 'develop'];
+        const mockDefaultBranch = 'main';
+        // Mock WorktreeService to succeed
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed(mockBranches)),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed(mockDefaultBranch)),
+            };
+        });
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        const { lastFrame } = render(_jsx(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        // Wait for Effect to execute and state to update
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Should skip base-branch step and show branch-strategy step
+        // which displays "Base branch:" and "Choose branch creation strategy"
+        expect(output).toContain('Create New Worktree');
+        expect(output).toContain('Base branch:');
+        expect(output).toContain('main');
+        expect(output).toContain('Choose branch creation strategy');
+    });
+    it('should show base branch selection when autoUseDefaultBranch is disabled', async () => {
+        const { Effect } = await import('effect');
+        const { WorktreeService } = await import('../services/worktreeService.js');
+        const { configReader } = await import('../services/config/configReader.js');
+        // Mock config with autoDirectory enabled but autoUseDefaultBranch disabled
+        vi.spyOn(configReader, 'getWorktreeConfig').mockReturnValue({
+            autoDirectory: true,
+            autoDirectoryPattern: '../{project}-{branch}',
+            copySessionData: true,
+            autoUseDefaultBranch: false,
+        });
+        const mockBranches = ['main', 'feature-1', 'develop'];
+        const mockDefaultBranch = 'main';
+        // Mock WorktreeService to succeed
+        vi.mocked(WorktreeService).mockImplementation(function () {
+            return {
+                getAllBranchesEffect: vi.fn(() => Effect.succeed(mockBranches)),
+                getDefaultBranchEffect: vi.fn(() => Effect.succeed(mockDefaultBranch)),
+            };
+        });
+        const onComplete = vi.fn();
+        const onCancel = vi.fn();
+        const { lastFrame } = render(_jsx(NewWorktree, { onComplete: onComplete, onCancel: onCancel }));
+        // Wait for Effect to execute
+        await new Promise(resolve => setTimeout(resolve, 100));
+        const output = lastFrame();
+        // Should show base-branch selection step (not branch-strategy)
+        expect(output).toContain('Create New Worktree');
+        expect(output).toContain('Select base branch');
+        expect(output).toContain('main (default)');
+    });
 });

package/dist/services/config/configEditor.js

@@ -21,41 +21,69 @@ export class ConfigEditor {
     }
     // IConfigEditor implementation - delegates to configEditor with fallback to global
     getShortcuts() {
-        return (this.configEditor.getShortcuts() ?? globalConfigManager.getShortcuts());
+        const globalConfig = globalConfigManager.getShortcuts();
+        const scopedConfig = this.configEditor.getShortcuts();
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setShortcuts(value) {
         this.configEditor.setShortcuts(value);
     }
     getStatusHooks() {
-        return (this.configEditor.getStatusHooks() ?? globalConfigManager.getStatusHooks());
+        const globalConfig = globalConfigManager.getStatusHooks();
+        const scopedConfig = this.configEditor.getStatusHooks();
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setStatusHooks(value) {
         this.configEditor.setStatusHooks(value);
     }
     getWorktreeHooks() {
-        return (this.configEditor.getWorktreeHooks() ??
-            globalConfigManager.getWorktreeHooks());
+        const globalConfig = globalConfigManager.getWorktreeHooks();
+        const scopedConfig = this.configEditor.getWorktreeHooks();
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setWorktreeHooks(value) {
         this.configEditor.setWorktreeHooks(value);
     }
     getWorktreeConfig() {
-        return (this.configEditor.getWorktreeConfig() ??
-            globalConfigManager.getWorktreeConfig());
+        const globalConfig = globalConfigManager.getWorktreeConfig();
+        const scopedConfig = this.configEditor.getWorktreeConfig();
+        // Merge: global config is the base, scoped config fields override
+        // This ensures explicit false values in project config take priority
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setWorktreeConfig(value) {
         this.configEditor.setWorktreeConfig(value);
     }
     getCommandPresets() {
-        return (this.configEditor.getCommandPresets() ??
-            globalConfigManager.getCommandPresets());
+        const globalConfig = globalConfigManager.getCommandPresets();
+        const scopedConfig = this.configEditor.getCommandPresets();
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setCommandPresets(value) {
         this.configEditor.setCommandPresets(value);
     }
     getAutoApprovalConfig() {
-        return (this.configEditor.getAutoApprovalConfig() ??
-            globalConfigManager.getAutoApprovalConfig());
+        const globalConfig = globalConfigManager.getAutoApprovalConfig();
+        const scopedConfig = this.configEditor.getAutoApprovalConfig();
+        return {
+            ...globalConfig,
+            ...(scopedConfig || {}),
+        };
     }
     setAutoApprovalConfig(value) {
         this.configEditor.setAutoApprovalConfig(value);

package/dist/services/config/configEditor.test.js

@@ -238,4 +238,30 @@ describe('ConfigEditor (global scope) - Command Presets', () => {
             expect(presets.defaultPresetId).toBe('1');
         });
     });
+    describe('getWorktreeConfig - field-level merging', () => {
+        it('should return default worktree config values', () => {
+            resetSavedConfig();
+            configEditor.reload();
+            const worktreeConfig = configEditor.getWorktreeConfig();
+            expect(worktreeConfig.autoDirectory).toBe(false);
+            expect(worktreeConfig.copySessionData).toBe(true);
+            expect(worktreeConfig.sortByLastSession).toBe(false);
+            expect(worktreeConfig.autoUseDefaultBranch).toBe(false);
+        });
+        it('should merge worktree config from global when not overridden', () => {
+            mockConfigData.worktree = {
+                autoDirectory: true,
+                autoUseDefaultBranch: true,
+                copySessionData: false,
+                sortByLastSession: true,
+            };
+            resetSavedConfig();
+            configEditor.reload();
+            const worktreeConfig = configEditor.getWorktreeConfig();
+            expect(worktreeConfig.autoDirectory).toBe(true);
+            expect(worktreeConfig.autoUseDefaultBranch).toBe(true);
+            expect(worktreeConfig.copySessionData).toBe(false);
+            expect(worktreeConfig.sortByLastSession).toBe(true);
+        });
+    });
 });

package/dist/services/config/configReader.d.ts

@@ -17,6 +17,7 @@ export declare class ConfigReader implements IConfigReader {
     getConfiguration(): ConfigurationData;
     getAutoApprovalConfig(): NonNullable<ConfigurationData['autoApproval']>;
     isAutoApprovalEnabled(): boolean;
+    isClearHistoryOnClearEnabled(): boolean;
     getDefaultPreset(): CommandPreset;
     getSelectPresetOnStart(): boolean;
     getPresetByIdEffect(id: string): Either.Either<CommandPreset, ValidationError>;

package/dist/services/config/configReader.js

@@ -10,29 +10,52 @@ import { projectConfigManager } from './projectConfigManager.js';
  * Uses the singleton projectConfigManager (cwd-based) for project config.
  */
 export class ConfigReader {
-    // Shortcuts - returns merged value (project > global)
+    // Shortcuts - returns merged value (project fields override global fields)
     getShortcuts() {
-        return (projectConfigManager.getShortcuts() || globalConfigManager.getShortcuts());
+        const globalConfig = globalConfigManager.getShortcuts();
+        const projectConfig = projectConfigManager.getShortcuts();
+        return {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
     }
-    // Status Hooks - returns merged value (project > global)
+    // Status Hooks - returns merged value (project fields override global fields)
     getStatusHooks() {
-        return (projectConfigManager.getStatusHooks() ||
-            globalConfigManager.getStatusHooks());
+        const globalConfig = globalConfigManager.getStatusHooks();
+        const projectConfig = projectConfigManager.getStatusHooks();
+        return {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
     }
-    // Worktree Hooks - returns merged value (project > global)
+    // Worktree Hooks - returns merged value (project fields override global fields)
     getWorktreeHooks() {
-        return (projectConfigManager.getWorktreeHooks() ||
-            globalConfigManager.getWorktreeHooks());
+        const globalConfig = globalConfigManager.getWorktreeHooks();
+        const projectConfig = projectConfigManager.getWorktreeHooks();
+        return {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
     }
-    // Worktree Config - returns merged value (project > global)
+    // Worktree Config - returns merged value (project fields override global fields)
     getWorktreeConfig() {
-        return (projectConfigManager.getWorktreeConfig() ||
-            globalConfigManager.getWorktreeConfig());
+        const globalConfig = globalConfigManager.getWorktreeConfig();
+        const projectConfig = projectConfigManager.getWorktreeConfig();
+        // Merge: global config is the base, project config fields override
+        // This ensures explicit false values in project config take priority
+        return {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
     }
-    // Command Presets - returns merged value (project > global)
+    // Command Presets - returns merged value (project fields override global fields)
     getCommandPresets() {
-        return (projectConfigManager.getCommandPresets() ||
-            globalConfigManager.getCommandPresets());
+        const globalConfig = globalConfigManager.getCommandPresets();
+        const projectConfig = projectConfigManager.getCommandPresets();
+        return {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
     }
     // Get full merged configuration
     getConfiguration() {
@@ -45,21 +68,28 @@ export class ConfigReader {
             autoApproval: this.getAutoApprovalConfig(),
         };
     }
-    // Auto Approval Config - returns merged value (project > global)
+    // Auto Approval Config - returns merged value (project fields override global fields)
     getAutoApprovalConfig() {
+        const globalConfig = globalConfigManager.getAutoApprovalConfig();
         const projectConfig = projectConfigManager.getAutoApprovalConfig();
-        if (projectConfig) {
-            return {
-                ...projectConfig,
-                timeout: projectConfig.timeout ?? 30,
-            };
-        }
-        return globalConfigManager.getAutoApprovalConfig();
+        const merged = {
+            ...globalConfig,
+            ...(projectConfig || {}),
+        };
+        // Ensure timeout has a default value
+        return {
+            ...merged,
+            timeout: merged.timeout ?? 30,
+        };
     }
     // Check if auto-approval is enabled
     isAutoApprovalEnabled() {
         return this.getAutoApprovalConfig().enabled;
     }
+    // Check if clear history on clear is enabled
+    isClearHistoryOnClearEnabled() {
+        return this.getAutoApprovalConfig().clearHistoryOnClear ?? false;
+    }
     // Command Preset methods - delegate to global config for modifications
     getDefaultPreset() {
         const presets = this.getCommandPresets();

package/dist/services/config/configReader.multiProject.test.js

@@ -134,3 +134,98 @@ describe('ConfigReader in multi-project mode', () => {
         expect(worktreeConfig.copySessionData).toBe(true);
     });
 });
+describe('ConfigReader - worktree config field-level merging', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        // Ensure multi-project mode is NOT set
+        delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        mkdirSync.mockImplementation(() => { });
+        writeFileSync.mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should allow project config to override global autoUseDefaultBranch with false', async () => {
+        // Global config has autoUseDefaultBranch: true
+        const globalConfig = {
+            worktree: {
+                autoDirectory: true,
+                autoUseDefaultBranch: true,
+                copySessionData: true,
+                sortByLastSession: false,
+            },
+        };
+        // Project config explicitly sets autoUseDefaultBranch: false
+        const projectConfig = {
+            worktree: {
+                autoDirectory: true,
+                autoUseDefaultBranch: false,
+            },
+        };
+        existsSync.mockImplementation((path) => {
+            return path.includes('.ccmanager.json') || path.includes('config.json');
+        });
+        readFileSync.mockImplementation((path) => {
+            if (path.includes('.ccmanager.json')) {
+                return JSON.stringify(projectConfig);
+            }
+            if (path.includes('config.json')) {
+                return JSON.stringify(globalConfig);
+            }
+            return '{}';
+        });
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        const worktreeConfig = reader.getWorktreeConfig();
+        // Project's explicit false should override global's true
+        expect(worktreeConfig.autoUseDefaultBranch).toBe(false);
+        // Other fields should be merged
+        expect(worktreeConfig.autoDirectory).toBe(true);
+        // Fields only in global should be inherited
+        expect(worktreeConfig.copySessionData).toBe(true);
+        expect(worktreeConfig.sortByLastSession).toBe(false);
+    });
+    it('should inherit global values for fields not set in project config', async () => {
+        // Global config has various settings
+        const globalConfig = {
+            worktree: {
+                autoDirectory: false,
+                autoUseDefaultBranch: true,
+                copySessionData: false,
+                sortByLastSession: true,
+                autoDirectoryPattern: '../{branch}',
+            },
+        };
+        // Project config only overrides autoDirectory
+        const projectConfig = {
+            worktree: {
+                autoDirectory: true,
+            },
+        };
+        existsSync.mockImplementation((path) => {
+            return path.includes('.ccmanager.json') || path.includes('config.json');
+        });
+        readFileSync.mockImplementation((path) => {
+            if (path.includes('.ccmanager.json')) {
+                return JSON.stringify(projectConfig);
+            }
+            if (path.includes('config.json')) {
+                return JSON.stringify(globalConfig);
+            }
+            return '{}';
+        });
+        const { ConfigReader } = await import('./configReader.js');
+        const reader = new ConfigReader();
+        reader.reload();
+        const worktreeConfig = reader.getWorktreeConfig();
+        // Project override
+        expect(worktreeConfig.autoDirectory).toBe(true);
+        // Inherited from global
+        expect(worktreeConfig.autoUseDefaultBranch).toBe(true);
+        expect(worktreeConfig.copySessionData).toBe(false);
+        expect(worktreeConfig.sortByLastSession).toBe(true);
+        expect(worktreeConfig.autoDirectoryPattern).toBe('../{branch}');
+    });
+});

package/dist/services/config/globalConfigManager.js

@@ -63,6 +63,7 @@ class GlobalConfigManager {
                 autoDirectory: false,
                 copySessionData: true,
                 sortByLastSession: false,
+                autoUseDefaultBranch: false,
             };
         }
         if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'copySessionData')) {
@@ -75,6 +76,7 @@ class GlobalConfigManager {
             this.config.autoApproval = {
                 enabled: false,
                 timeout: 30,
+                clearHistoryOnClear: false,
             };
         }
         else {
@@ -84,6 +86,9 @@ class GlobalConfigManager {
             if (!Object.prototype.hasOwnProperty.call(this.config.autoApproval, 'timeout')) {
                 this.config.autoApproval.timeout = 30;
             }
+            if (!Object.prototype.hasOwnProperty.call(this.config.autoApproval, 'clearHistoryOnClear')) {
+                this.config.autoApproval.clearHistoryOnClear = false;
+            }
         }
         // Migrate legacy command config to presets if needed
         this.ensureDefaultPresets();

package/dist/services/sessionManager.js

@@ -277,6 +277,13 @@ export class SessionManager extends EventEmitter {
         session.process.onData((data) => {
             // Write data to virtual terminal
             session.terminal.write(data);
+            // Check for screen clear escape sequence (e.g., from /clear command)
+            // When enabled and detected, clear the output history to prevent replaying old content on restore
+            // This helps avoid excessive scrolling when restoring sessions with large output history
+            if (configReader.isClearHistoryOnClearEnabled() &&
+                data.includes('\x1B[2J')) {
+                session.outputHistory = [];
+            }
             // Store in output history as Buffer
             const buffer = Buffer.from(data, 'utf8');
             session.outputHistory.push(buffer);

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

@@ -41,6 +41,7 @@ vi.mock('./config/configReader.js', () => ({
         getWorktreeLastOpened: vi.fn(() => ({})),
         isAutoApprovalEnabled: vi.fn(() => false),
         setAutoApprovalEnabled: vi.fn(),
+        isClearHistoryOnClearEnabled: vi.fn(() => false),
     },
 }));
 describe('SessionManager - State Persistence', () => {

package/dist/services/sessionManager.test.js

@@ -30,6 +30,7 @@ vi.mock('./config/configReader.js', () => ({
         getWorktreeLastOpened: vi.fn(() => ({})),
         isAutoApprovalEnabled: vi.fn(() => false),
         setAutoApprovalEnabled: vi.fn(),
+        isClearHistoryOnClearEnabled: vi.fn(() => false),
     },
 }));
 // Mock Terminal
@@ -694,6 +695,89 @@ describe('SessionManager', () => {
             expect(session.isPrimaryCommand).toBe(false);
         });
     });
+    describe('clearHistoryOnClear', () => {
+        it('should clear output history when screen clear escape sequence is detected and setting is enabled', async () => {
+            // Setup
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(configReader.isClearHistoryOnClearEnabled).mockReturnValue(true);
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Simulate some data output
+            mockPty.emit('data', 'Hello World');
+            mockPty.emit('data', 'More data');
+            // Verify output history has data
+            expect(session.outputHistory.length).toBe(2);
+            // Simulate screen clear escape sequence
+            mockPty.emit('data', '\x1B[2J');
+            // Verify output history was cleared and only contains the clear sequence
+            expect(session.outputHistory.length).toBe(1);
+            expect(session.outputHistory[0]?.toString()).toBe('\x1B[2J');
+        });
+        it('should not clear output history when screen clear escape sequence is detected but setting is disabled', async () => {
+            // Setup
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(configReader.isClearHistoryOnClearEnabled).mockReturnValue(false);
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Simulate some data output
+            mockPty.emit('data', 'Hello World');
+            mockPty.emit('data', 'More data');
+            // Verify output history has data
+            expect(session.outputHistory.length).toBe(2);
+            // Simulate screen clear escape sequence
+            mockPty.emit('data', '\x1B[2J');
+            // Verify output history was NOT cleared
+            expect(session.outputHistory.length).toBe(3);
+        });
+        it('should not clear output history for normal data when setting is enabled', async () => {
+            // Setup
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(configReader.isClearHistoryOnClearEnabled).mockReturnValue(true);
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Simulate normal data output without screen clear
+            mockPty.emit('data', 'Hello World');
+            mockPty.emit('data', 'More data');
+            mockPty.emit('data', 'Even more data');
+            // Verify output history contains all data
+            expect(session.outputHistory.length).toBe(3);
+        });
+        it('should clear history when screen clear is part of larger data chunk', async () => {
+            // Setup
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(configReader.isClearHistoryOnClearEnabled).mockReturnValue(true);
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            // Create session
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            // Simulate some data output
+            mockPty.emit('data', 'Hello World');
+            mockPty.emit('data', 'More data');
+            // Simulate screen clear as part of larger data chunk (e.g., from /clear command)
+            mockPty.emit('data', 'prefix\x1B[2Jsuffix');
+            // Verify output history was cleared and only contains the new chunk
+            expect(session.outputHistory.length).toBe(1);
+            expect(session.outputHistory[0]?.toString()).toBe('prefix\x1B[2Jsuffix');
+        });
+    });
     describe('static methods', () => {
         describe('getSessionCounts', () => {
             // Helper to create mock session with stateMutex

package/dist/services/stateDetector/claude.js

@@ -7,6 +7,10 @@ export class ClaudeStateDetector extends BaseStateDetector {
         if (lowerContent.includes('ctrl+r to toggle')) {
             return currentState;
         }
+        // Check for search prompt (⌕ Search…) - always idle
+        if (content.includes('⌕ Search…')) {
+            return 'idle';
+        }
         // Check for "Do you want" or "Would you like" pattern with options
         // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
         if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {

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

@@ -273,6 +273,30 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should detect waiting_input from viewport
             expect(state).toBe('waiting_input');
         });
+        it('should detect idle when "⌕ Search…" is present', () => {
+            // Arrange - Search prompt should always be idle
+            terminal = createMockTerminal(['⌕ Search…', 'Some content']);
+            // Act
+            const state = detector.detectState(terminal, 'busy');
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should detect idle when "⌕ Search…" is present even with "esc to cancel"', () => {
+            // Arrange
+            terminal = createMockTerminal(['⌕ Search…', 'esc to cancel']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - Should be idle because search prompt takes precedence
+            expect(state).toBe('idle');
+        });
+        it('should detect idle when "⌕ Search…" is present even with "esc to interrupt"', () => {
+            // Arrange
+            terminal = createMockTerminal(['⌕ Search…', 'Press esc to interrupt']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - Should be idle because search prompt takes precedence
+            expect(state).toBe('idle');
+        });
     });
     describe('detectBackgroundTask', () => {
         it('should return count 1 when "1 background task" is in status bar', () => {

package/dist/services/worktreeService.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
 import { Worktree } from '../types/index.js';
-import { GitError, FileSystemError } from '../types/errors.js';
+import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * Get all worktree last opened timestamps
  */
@@ -326,7 +326,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, never>;
+    createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): Effect.Effect<Worktree, GitError | FileSystemError | ProcessError, never>;
     /**
      * Effect-based deleteWorktree operation
      * May fail with GitError

package/dist/services/worktreeService.js

@@ -6,7 +6,7 @@ import { AmbiguousBranchError, } from '../types/index.js';
 import { GitError, FileSystemError } from '../types/errors.js';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
-import { executeWorktreePostCreationHook } from '../utils/hookExecutor.js';
+import { executeWorktreePostCreationHook, executeWorktreePreCreationHook, } from '../utils/hookExecutor.js';
 import { configReader } from './config/configReader.js';
 const CLAUDE_DIR = '.claude';
 // Module-level state for worktree last opened tracking (runtime state, not persisted)
@@ -776,6 +776,12 @@ export class WorktreeService {
                 },
                 catch: (error) => error,
             }), () => Effect.succeed(false));
+            // Execute pre-creation hook if configured (BEFORE git worktree add)
+            const worktreeHooksConfig = configReader.getWorktreeHooks();
+            if (worktreeHooksConfig.pre_creation?.enabled &&
+                worktreeHooksConfig.pre_creation?.command) {
+                yield* executeWorktreePreCreationHook(worktreeHooksConfig.pre_creation.command, resolvedPath, branch, absoluteGitRoot, baseBranch);
+            }
             // Create the worktree command
             let command;
             if (branchExists) {

package/dist/types/index.d.ts

@@ -76,6 +76,7 @@ export interface WorktreeHook {
     enabled: boolean;
 }
 export interface WorktreeHookConfig {
+    pre_creation?: WorktreeHook;
     post_creation?: WorktreeHook;
 }
 export interface WorktreeConfig {
@@ -83,6 +84,7 @@ export interface WorktreeConfig {
     autoDirectoryPattern?: string;
     copySessionData?: boolean;
     sortByLastSession?: boolean;
+    autoUseDefaultBranch?: boolean;
 }
 export interface CommandPreset {
     id: string;
@@ -111,6 +113,7 @@ export interface ConfigurationData {
         enabled: boolean;
         customCommand?: string;
         timeout?: number;
+        clearHistoryOnClear?: boolean;
     };
 }
 export type ConfigScope = 'project' | 'global';
@@ -118,6 +121,7 @@ export interface AutoApprovalConfig {
     enabled: boolean;
     customCommand?: string;
     timeout?: number;
+    clearHistoryOnClear?: boolean;
 }
 export interface ProjectConfigurationData {
     shortcuts?: ShortcutConfig;
@@ -203,7 +207,7 @@ export interface IWorktreeService {
         sortByLastSession?: boolean;
     }): 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, never>;
+    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>;
     deleteWorktreeEffect(worktreePath: string, options?: {
         deleteBranch?: boolean;
     }): import('effect').Effect.Effect<void, import('../types/errors.js').GitError, never>;

package/dist/utils/hookExecutor.d.ts

@@ -43,6 +43,18 @@ export interface HookEnvironment {
  * ```
  */
 export declare function executeHook(command: string, cwd: string, environment: HookEnvironment): Effect.Effect<void, ProcessError>;
+/**
+ * Execute a worktree pre-creation hook using Effect
+ * Errors propagate to abort worktree creation - this is intentional
+ *
+ * @param {string} command - Shell command to execute
+ * @param {string} worktreePath - Path where the worktree will be created (doesn't exist yet)
+ * @param {string} branch - Branch name for the new worktree
+ * @param {string} gitRoot - Git repository root (working directory for the hook)
+ * @param {string} baseBranch - Optional base branch the worktree is created from
+ * @returns {Effect.Effect<void, ProcessError>} Effect that succeeds on hook completion or fails with ProcessError
+ */
+export declare function executeWorktreePreCreationHook(command: string, worktreePath: string, branch: string, gitRoot: string, baseBranch?: string): Effect.Effect<void, ProcessError>;
 /**
  * Execute a worktree post-creation hook using Effect
  * Errors are caught and logged but do not break the main flow

package/dist/utils/hookExecutor.js

@@ -82,6 +82,30 @@ export function executeHook(command, cwd, environment) {
         });
     });
 }
+/**
+ * Execute a worktree pre-creation hook using Effect
+ * Errors propagate to abort worktree creation - this is intentional
+ *
+ * @param {string} command - Shell command to execute
+ * @param {string} worktreePath - Path where the worktree will be created (doesn't exist yet)
+ * @param {string} branch - Branch name for the new worktree
+ * @param {string} gitRoot - Git repository root (working directory for the hook)
+ * @param {string} baseBranch - Optional base branch the worktree is created from
+ * @returns {Effect.Effect<void, ProcessError>} Effect that succeeds on hook completion or fails with ProcessError
+ */
+export function executeWorktreePreCreationHook(command, worktreePath, branch, gitRoot, baseBranch) {
+    const environment = {
+        CCMANAGER_WORKTREE_PATH: worktreePath,
+        CCMANAGER_WORKTREE_BRANCH: branch,
+        CCMANAGER_GIT_ROOT: gitRoot,
+    };
+    if (baseBranch) {
+        environment.CCMANAGER_BASE_BRANCH = baseBranch;
+    }
+    // Execute in git root (worktree doesn't exist yet)
+    // NO Effect.catchAll - errors must propagate to abort creation
+    return executeHook(command, gitRoot, environment);
+}
 /**
  * Execute a worktree post-creation hook using Effect
  * Errors are caught and logged but do not break the main flow

package/dist/utils/hookExecutor.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { Effect } from 'effect';
-import { executeHook, executeWorktreePostCreationHook, executeStatusHook, } from './hookExecutor.js';
+import { executeHook, executeWorktreePreCreationHook, executeWorktreePostCreationHook, executeStatusHook, } from './hookExecutor.js';
 import { mkdtemp, rm, readFile, realpath } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
@@ -256,6 +256,118 @@ describe('hookExecutor Integration Tests', () => {
             }
         });
     });
+    describe('executeWorktreePreCreationHook (real execution)', () => {
+        it('should execute successfully when command succeeds', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            try {
+                // Act & Assert - should not throw
+                await expect(Effect.runPromise(executeWorktreePreCreationHook('echo "Pre-creation hook executed"', worktreePath, branch, gitRoot, 'main'))).resolves.toBeUndefined();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should propagate ProcessError when command fails (not caught)', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            try {
+                // Act & Assert - should throw (unlike post-creation hook)
+                await expect(Effect.runPromise(executeWorktreePreCreationHook('exit 1', worktreePath, branch, gitRoot, 'main'))).rejects.toThrow();
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should execute in git root directory (not worktree path)', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-cwd-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree', 'does-not-exist');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            const outputFile = join(tmpDir, 'cwd.txt');
+            try {
+                // Act - write current directory to file
+                await Effect.runPromise(executeWorktreePreCreationHook(`pwd > "${outputFile}"`, worktreePath, branch, gitRoot, 'main'));
+                // Read the output
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - should be executed in git root, not worktree path
+                const expectedPath = await realpath(gitRoot);
+                const actualPath = await realpath(output.trim());
+                expect(actualPath).toBe(expectedPath);
+                // Also verify it's not the worktree path
+                expect(output.trim()).not.toBe(worktreePath);
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should pass environment variables correctly', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-env-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            const baseBranch = 'main';
+            const outputFile = join(tmpDir, 'env.txt');
+            try {
+                // Act - write environment variables to file
+                await Effect.runPromise(executeWorktreePreCreationHook(`echo "PATH:$CCMANAGER_WORKTREE_PATH|BRANCH:$CCMANAGER_WORKTREE_BRANCH|ROOT:$CCMANAGER_GIT_ROOT|BASE:$CCMANAGER_BASE_BRANCH" > "${outputFile}"`, worktreePath, branch, gitRoot, baseBranch));
+                // Read the output
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - environment variables should be set correctly
+                expect(output.trim()).toBe(`PATH:${worktreePath}|BRANCH:${branch}|ROOT:${gitRoot}|BASE:${baseBranch}`);
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should include stderr in error message on failure', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-stderr-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            try {
+                // Act & Assert - should include stderr in error
+                await expect(Effect.runPromise(executeWorktreePreCreationHook('>&2 echo "Pre-creation validation failed"; exit 1', worktreePath, branch, gitRoot, 'main'))).rejects.toThrow('Hook exited with code 1\nStderr: Pre-creation validation failed\n');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+        it('should work without baseBranch parameter', async () => {
+            // Arrange
+            const tmpDir = await mkdtemp(join(tmpdir(), 'pre-hook-no-base-test-'));
+            const worktreePath = join(tmpDir, 'new-worktree');
+            const gitRoot = tmpDir;
+            const branch = 'feature-branch';
+            const outputFile = join(tmpDir, 'env.txt');
+            try {
+                // Act - write environment variables to file (without baseBranch)
+                await Effect.runPromise(executeWorktreePreCreationHook(`echo "BASE:$CCMANAGER_BASE_BRANCH" > "${outputFile}"`, worktreePath, branch, gitRoot));
+                // Read the output
+                const output = await readFile(outputFile, 'utf-8');
+                // Assert - base branch should be empty
+                expect(output.trim()).toBe('BASE:');
+            }
+            finally {
+                // Cleanup
+                await rm(tmpDir, { recursive: true });
+            }
+        });
+    });
     describe('executeStatusHook', () => {
         it('should wait for hook execution to complete', async () => {
             // Arrange

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.6.7",
+	"version": "3.6.10",
 	"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": "3.6.7",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.7",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.7",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.6.7",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.6.7"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.6.10",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.6.10",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.6.10",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.6.10",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.6.10"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",
@@ -75,7 +75,7 @@
 		"ink-text-input": "^6.0.0",
 		"meow": "^14.0.0",
 		"react": "^19.2.3",
-		"react-devtools-core": "^7.0.1",
+		"react-devtools-core": "^6.1.2",
 		"react-dom": "^19.2.3",
 		"strip-ansi": "^7.1.0"
 	}