ccmanager 3.9.0 → 3.11.0

package/dist/components/NewWorktree.js

@@ -9,18 +9,15 @@ import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { Effect } from 'effect';
+import { describePromptInjection, getPromptInjectionMethod, } from '../utils/presetPrompt.js';
 const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const worktreeConfig = configReader.getWorktreeConfig();
+    const presetsConfig = configReader.getCommandPresets();
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const isAutoUseDefaultBranch = worktreeConfig.autoUseDefaultBranch ?? false;
     const limit = 10;
-    // 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';
@@ -31,17 +28,16 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [baseBranch, setBaseBranch] = useState('');
     const [copyClaudeDirectory, setCopyClaudeDirectory] = useState(true);
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
-    // Loading and error states for branch data
+    const [selectedPresetId, setSelectedPresetId] = useState(presetsConfig.defaultPresetId);
+    const [initialPrompt, setInitialPrompt] = useState('');
     const [isLoadingBranches, setIsLoadingBranches] = useState(true);
     const [branchLoadError, setBranchLoadError] = useState(null);
     const [branches, setBranches] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState('main');
-    // Initialize worktree service and load branches using Effect
     useEffect(() => {
         let cancelled = false;
         const service = new WorktreeService(projectPath);
         const loadBranches = async () => {
-            // Use Effect.all to load branches and defaultBranch in parallel
             const workflow = Effect.all([service.getAllBranchesEffect(), service.getDefaultBranchEffect()], { concurrency: 2 });
             const result = await Effect.runPromise(Effect.match(workflow, {
                 onFailure: (error) => ({
@@ -63,13 +59,9 @@ 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);
+                        setStep(currentStep => currentStep === 'base-branch' ? 'creation-mode' : currentStep);
                     }
                 }
             }
@@ -84,98 +76,142 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
             cancelled = true;
         };
     }, [projectPath, isAutoUseDefaultBranch]);
-    // Create branch items with default branch first (memoized)
     const allBranchItems = useMemo(() => [
         { label: `${defaultBranch} (default)`, value: defaultBranch },
         ...branches
             .filter(br => br !== defaultBranch)
             .map(br => ({ label: br, value: br })),
     ], [branches, defaultBranch]);
-    // Use search mode for base branch selection
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(allBranchItems.length, {
         isDisabled: step !== 'base-branch',
     });
-    // Filter branch items based on search query
     const branchItems = useMemo(() => {
         if (!searchQuery)
             return allBranchItems;
         return allBranchItems.filter(item => item.value.toLowerCase().includes(searchQuery.toLowerCase()));
     }, [allBranchItems, searchQuery]);
+    const presetItems = useMemo(() => presetsConfig.presets.map(preset => ({
+        label: `${preset.name}${preset.id === presetsConfig.defaultPresetId ? ' (default)' : ''}\n    Command: ${preset.command}${preset.args?.length ? ` ${preset.args.join(' ')}` : ''}`,
+        value: preset.id,
+    })), [presetsConfig.defaultPresetId, presetsConfig.presets]);
+    const selectedPreset = useMemo(() => presetsConfig.presets.find(preset => preset.id === selectedPresetId) ||
+        presetsConfig.presets[0], [selectedPresetId, presetsConfig.presets]);
     useInput((input, key) => {
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
         }
-        // Handle arrow key navigation in search mode for base branch selection
         if (step === 'base-branch' && isSearchMode) {
-            // Don't handle any keys here - let useSearchMode handle them
-            // The hook will handle arrow keys for navigation and Enter to exit search mode
             return;
         }
     });
     const handlePathSubmit = (value) => {
-        if (value.trim()) {
-            setPath(value.trim());
-            // 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');
-            }
+        if (!value.trim())
+            return;
+        setPath(value.trim());
+        if (isAutoUseDefaultBranch && defaultBranch) {
+            setBaseBranch(defaultBranch);
+            setStep('creation-mode');
         }
-    };
-    const handleBranchSubmit = (value) => {
-        if (value.trim()) {
-            setBranch(value.trim());
-            setStep('copy-settings');
+        else {
+            setStep('base-branch');
         }
     };
     const handleBaseBranchSelect = (item) => {
         setBaseBranch(item.value);
-        setStep('branch-strategy');
+        setStep('creation-mode');
+    };
+    const handleCreationModeSelect = (item) => {
+        if (item.value === 'manual') {
+            setStep('branch-strategy');
+            return;
+        }
+        setStep('auto-preset');
     };
     const handleBranchStrategySelect = (item) => {
         const useExisting = item.value === 'existing';
         if (useExisting) {
-            // Use the base branch as the branch name for existing branch
             setBranch(baseBranch);
             setStep('copy-settings');
         }
         else {
-            // Need to input new branch name
             setStep('branch');
         }
     };
+    const handleBranchSubmit = (value) => {
+        if (!value.trim())
+            return;
+        setBranch(value.trim());
+        setStep('copy-settings');
+    };
+    const handlePresetSelect = (item) => {
+        setSelectedPresetId(item.value);
+        setStep('auto-prompt');
+    };
+    const handlePromptSubmit = (value) => {
+        if (!value.trim())
+            return;
+        setInitialPrompt(value.trim());
+        setStep('copy-settings');
+    };
     const handleCopySettingsSelect = (item) => {
         setCopyClaudeDirectory(item.value);
         setStep('copy-session');
     };
+    const getResolvedPath = () => {
+        if (!isAutoDirectory) {
+            return path;
+        }
+        const branchForPath = step === 'copy-session' && branch ? branch : 'generated-from-prompt';
+        return generateWorktreeDirectory(projectPath || process.cwd(), branchForPath, worktreeConfig.autoDirectoryPattern);
+    };
     const handleCopySessionSelect = (item) => {
         const shouldCopy = item.value === 'yes';
+        const resolvedPath = getResolvedPath();
         setCopySessionData(shouldCopy);
-        if (isAutoDirectory) {
-            // Generate path from branch name
-            const autoPath = generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern);
-            onComplete(autoPath, branch, baseBranch, shouldCopy, copyClaudeDirectory);
+        if (step !== 'copy-session') {
+            return;
         }
-        else {
-            onComplete(path, branch, baseBranch, shouldCopy, copyClaudeDirectory);
+        if (initialPrompt && selectedPresetId) {
+            onComplete({
+                creationMode: 'prompt',
+                path: isAutoDirectory ? projectPath || process.cwd() : resolvedPath,
+                projectPath: projectPath || process.cwd(),
+                autoDirectoryPattern: isAutoDirectory
+                    ? worktreeConfig.autoDirectoryPattern
+                    : undefined,
+                baseBranch,
+                presetId: selectedPresetId,
+                initialPrompt,
+                copySessionData: shouldCopy,
+                copyClaudeDirectory,
+            });
+            return;
         }
+        onComplete({
+            creationMode: 'manual',
+            path: resolvedPath,
+            branch,
+            baseBranch,
+            copySessionData: shouldCopy,
+            copyClaudeDirectory,
+        });
     };
-    // Calculate generated path for preview (memoized to avoid expensive recalculations)
     const generatedPath = useMemo(() => {
-        return isAutoDirectory && branch
-            ? generateWorktreeDirectory(projectPath || process.cwd(), branch, worktreeConfig.autoDirectoryPattern)
-            : '';
+        if (!isAutoDirectory) {
+            return '';
+        }
+        const branchForPath = branch || (initialPrompt ? 'generated-from-prompt' : '');
+        if (!branchForPath) {
+            return '';
+        }
+        return generateWorktreeDirectory(projectPath || process.cwd(), branchForPath, worktreeConfig.autoDirectoryPattern);
     }, [
         isAutoDirectory,
         branch,
+        initialPrompt,
         worktreeConfig.autoDirectoryPattern,
         projectPath,
     ]);
-    // Format errors using TaggedError discrimination
     const formatError = (error) => {
         switch (error._tag) {
             case 'GitError':
@@ -190,17 +226,28 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                 return `Validation failed for ${error.field}: ${error.constraint}`;
         }
     };
-    // Show loading indicator while branches load
     if (isLoadingBranches) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), _jsx(Box, { children: _jsx(Text, { children: "Loading branches..." }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) })] }));
     }
-    // Show error message if branch loading failed
     if (branchLoadError) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: "Error loading branches:" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "red", children: branchLoadError }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to go back"] }) })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." })] })), isSearchMode && branchItems.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No branches match your search" }) })) : isSearchMode ? (
-                    // In search mode, show the items as a list without SelectInput
-                    _jsx(Box, { flexDirection: "column", children: branchItems.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'branch-strategy' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Choose branch creation strategy:" }) }), _jsx(SelectInput, { items: [
+    const promptHandlingText = selectedPreset
+        ? describePromptInjection(selectedPreset)
+        : '';
+    const promptMethod = selectedPreset
+        ? getPromptInjectionMethod(selectedPreset)
+        : 'stdin';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), isSearchMode && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { children: "Search: " }), _jsx(TextInputWrapper, { value: searchQuery, onChange: setSearchQuery, focus: true, placeholder: "Type to filter branches..." })] })), isSearchMode && branchItems.length === 0 ? (_jsx(Box, { children: _jsx(Text, { color: "yellow", children: "No branches match your search" }) })) : isSearchMode ? (_jsx(Box, { flexDirection: "column", children: branchItems.slice(0, limit).map((item, index) => (_jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', item.label] }, item.value))) })) : (_jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode })), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
+                            {
+                                label: '1. Choose the branch name yourself',
+                                value: 'manual',
+                            },
+                            {
+                                label: '2. Enter a prompt first and let Claude decide the branch name',
+                                value: 'prompt',
+                            },
+                        ], onSelect: handleCreationModeSelect, initialIndex: 0 })] })), step === 'branch-strategy' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Choose branch creation strategy:" }) }), _jsx(SelectInput, { items: [
                             {
                                 label: 'Create new branch from base branch',
                                 value: 'new',
@@ -209,13 +256,13 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                                 label: 'Use existing base branch',
                                 value: 'existing',
                             },
-                        ], onSelect: handleBranchStrategySelect, initialIndex: 0 })] })), step === 'branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enter new branch name (will be created from", ' ', _jsx(Text, { color: "cyan", children: baseBranch }), "):"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })] }), isAutoDirectory && generatedPath && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree will be created at:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) }))] })), step === 'copy-settings' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Copy .claude directory from base branch (", _jsx(Text, { color: "cyan", children: baseBranch }), ")?"] }) }), _jsx(SelectInput, { items: [
+                        ], onSelect: handleBranchStrategySelect, initialIndex: 0 })] })), step === 'branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Enter new branch name (will be created from", ' ', _jsx(Text, { color: "cyan", children: baseBranch }), "):"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: branch, onChange: setBranch, onSubmit: handleBranchSubmit, placeholder: "e.g., feature/new-feature" })] }), isAutoDirectory && generatedPath && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree will be created at:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) }))] })), step === 'auto-preset' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select the preset to use for the first session:" }) }), _jsx(SelectInput, { items: presetItems, onSelect: handlePresetSelect, initialIndex: Math.max(0, presetItems.findIndex(item => item.value === selectedPresetId)) })] })), step === 'auto-prompt' && selectedPreset && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Preset: ", _jsx(Text, { color: "cyan", children: selectedPreset.name })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter the prompt for the new session:" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: promptHandlingText }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Examples: Claude/Codex use the final argument, OpenCode uses `--prompt`, and other commands may receive the prompt over stdin." }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: "yellow", children: "Automatic branch naming requires the `claude` command in your PATH." }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: initialPrompt, onChange: setInitialPrompt, onSubmit: handlePromptSubmit, placeholder: "Describe what you want the agent to do" })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Prompt delivery mode for this preset:", ' ', _jsx(Text, { color: "green", children: promptMethod })] }) })] })), step === 'copy-settings' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Copy .claude directory from base branch (", _jsx(Text, { color: "cyan", children: baseBranch }), ")?"] }) }), initialPrompt ? (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "The branch name will be generated automatically right before the worktree is created." }) })) : null, _jsx(SelectInput, { items: [
                             {
                                 label: 'Yes - Copy .claude directory from base branch',
                                 value: true,
                             },
                             { label: 'No - Start without .claude directory', value: false },
-                        ], onSelect: handleCopySettingsSelect, initialIndex: 0 })] })), step === 'copy-session' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Copy Claude Code session data to the new worktree?" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "This will copy conversation history and context from the current worktree" }) }), _jsx(SelectInput, { items: [
+                        ], onSelect: handleCopySettingsSelect, initialIndex: 0 })] })), step === 'copy-session' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Copy Claude Code session data to the new worktree?" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "This will copy conversation history and context from the current worktree." }) }), isAutoDirectory && generatedPath ? (_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["Worktree path preview:", ' ', _jsx(Text, { color: "green", children: generatedPath })] }) })) : null, _jsx(SelectInput, { items: [
                             { label: '✅ Yes, copy session data', value: 'yes' },
                             { label: '❌ No, start fresh', value: 'no' },
                         ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Press ", shortcutManager.getShortcutDisplay('cancel'), " to cancel"] }) })] }));

package/dist/components/NewWorktree.test.js

@@ -50,6 +50,18 @@ vi.mock('../services/config/configReader.js', () => ({
             autoDirectoryPattern: '../{project}-{branch}',
             copySessionData: true,
         }),
+        getCommandPresets: () => ({
+            presets: [
+                {
+                    id: 'claude',
+                    name: 'Claude',
+                    command: 'claude',
+                    args: ['--resume'],
+                    detectionStrategy: 'claude',
+                },
+            ],
+            defaultPresetId: 'claude',
+        }),
     },
 }));
 vi.mock('../hooks/useSearchMode.js', () => ({
@@ -259,7 +271,7 @@ 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 () => {
+    it('should skip base branch selection and show creation mode 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');
@@ -285,12 +297,13 @@ describe('NewWorktree component Effect integration', () => {
         // 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"
+        // Should skip base-branch step and show the manual/prompt creation mode choice
         expect(output).toContain('Create New Worktree');
         expect(output).toContain('Base branch:');
         expect(output).toContain('main');
-        expect(output).toContain('Choose branch creation strategy');
+        expect(output).toContain('How do you want to create the new worktree?');
+        expect(output).toContain('Choose the branch name yourself');
+        expect(output).toContain('Enter a prompt first');
     });
     it('should show base branch selection when autoUseDefaultBranch is disabled', async () => {
         const { Effect } = await import('effect');

package/dist/services/globalSessionOrchestrator.d.ts

@@ -10,6 +10,7 @@ declare class GlobalSessionOrchestrator {
     getAllActiveSessions(): Session[];
     destroyAllSessions(): void;
     destroyProjectSessions(projectPath: string): void;
+    getProjectPaths(): string[];
     getProjectSessions(projectPath: string): Session[];
 }
 export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;

package/dist/services/globalSessionOrchestrator.js

@@ -53,6 +53,9 @@ class GlobalSessionOrchestrator {
             this.projectManagers.delete(projectPath);
         }
     }
+    getProjectPaths() {
+        return Array.from(this.projectManagers.keys());
+    }
     getProjectSessions(projectPath) {
         const manager = this.projectManagers.get(projectPath);
         if (manager) {

package/dist/services/projectManager.d.ts

@@ -32,9 +32,15 @@ export declare class ProjectManager implements IProjectManager {
      */
     private discoverDirectories;
     /**
-     * Quick check for .git directory without running git commands
+     * Quick check for .git presence (directory or file) without running git commands.
+     * Returns true for both main repositories and worktrees.
      */
     private hasGitDirectory;
+    /**
+     * Check if a directory is a main git repository (not a worktree).
+     * Main repositories have .git as a directory; worktrees have .git as a file.
+     */
+    private isMainGitRepository;
     /**
      * Process directories in parallel using worker pool pattern
      */

package/dist/services/projectManager.js

@@ -167,12 +167,15 @@ export class ProjectManager {
                     // Quick check if this is a git repository
                     const hasGitDir = await this.hasGitDirectory(fullPath);
                     if (hasGitDir) {
-                        // Found a git repository - add to tasks and skip subdirectories
-                        if (!seen.has(fullPath)) {
+                        // Only add main repositories (.git is a directory),
+                        // not worktrees (.git is a file pointing to the main repo)
+                        const isMain = await this.isMainGitRepository(fullPath);
+                        if (isMain && !seen.has(fullPath)) {
                             seen.add(fullPath);
                             tasks.push({ path: fullPath, relativePath });
                         }
-                        return; // Early termination - don't walk subdirectories
+                        // Early termination for any git-related dir
+                        return;
                     }
                     // Not a git repo, continue walking subdirectories
                     await walk(fullPath, depth + 1);
@@ -189,13 +192,28 @@ export class ProjectManager {
         return tasks;
     }
     /**
-     * Quick check for .git directory without running git commands
+     * Quick check for .git presence (directory or file) without running git commands.
+     * Returns true for both main repositories and worktrees.
      */
     async hasGitDirectory(dirPath) {
         try {
             const gitPath = path.join(dirPath, '.git');
             const stats = await fs.stat(gitPath);
-            return stats.isDirectory() || stats.isFile(); // File for worktrees
+            return stats.isDirectory() || stats.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a directory is a main git repository (not a worktree).
+     * Main repositories have .git as a directory; worktrees have .git as a file.
+     */
+    async isMainGitRepository(dirPath) {
+        try {
+            const gitPath = path.join(dirPath, '.git');
+            const stats = await fs.stat(gitPath);
+            return stats.isDirectory();
         }
         catch {
             return false;
@@ -242,11 +260,9 @@ export class ProjectManager {
             name: path.basename(task.path),
         };
         try {
-            // Check if directory has .git (already validated in discoverDirectories)
-            // Double-check here to ensure it's still valid
-            const hasGit = await this.hasGitDirectory(task.path);
-            if (!hasGit) {
-                // Not a git repo, return null to filter it out
+            // Double-check here to ensure it's still a valid main repository
+            const isMain = await this.isMainGitRepository(task.path);
+            if (!isMain) {
                 return null;
             }
         }

package/dist/services/sessionManager.d.ts

@@ -17,6 +17,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private busyTimers;
     private autoApprovalDisabledWorktrees;
     private spawn;
+    private resolvePreset;
     detectTerminalState(session: Session): SessionState;
     detectBackgroundTask(session: Session): number;
     detectTeamMembers(session: Session): number;
@@ -54,7 +55,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * );
      * ```
      */
-    createSessionWithPresetEffect(worktreePath: string, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
+    createSessionWithPresetEffect(worktreePath: string, presetId?: string, initialPrompt?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     private setupDataHandler;
     /**
      * Sets up exit handler for the session process.
@@ -95,7 +96,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
+    createSessionWithDevcontainerEffect(worktreePath: string, devcontainerConfig: DevcontainerConfig, presetId?: string, initialPrompt?: string): Effect.Effect<Session, ProcessError | ConfigError, never>;
     destroy(): void;
     static getSessionCounts(sessions: Session[]): SessionCounts;
     static formatSessionCounts(counts: SessionCounts): string;

package/dist/services/sessionManager.js

@@ -16,6 +16,7 @@ import { Mutex, createInitialSessionStateData } from '../utils/mutex.js';
 import { getBackgroundTaskTag, getTeamMemberTag, } from '../constants/statusIcons.js';
 import { getTerminalScreenContent } from '../utils/screenCapture.js';
 import { injectTeammateMode } from '../utils/commandArgs.js';
+import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const execAsync = promisify(exec);
 const TERMINAL_CONTENT_MAX_LINES = 300;
@@ -34,6 +35,24 @@ export class SessionManager extends EventEmitter {
         };
         return spawn(command, args, spawnOptions);
     }
+    resolvePreset(presetId) {
+        let preset = presetId
+            ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
+            : null;
+        if (!preset) {
+            preset = configReader.getDefaultPreset();
+        }
+        if (!preset) {
+            throw new ConfigError({
+                configPath: 'configuration',
+                reason: 'validation',
+                details: presetId
+                    ? `Preset with ID '${presetId}' not found and no default preset available`
+                    : 'No default preset available',
+            });
+        }
+        return preset;
+    }
     detectTerminalState(session) {
         const stateData = session.stateMutex.getSnapshot();
         const detectedState = session.stateDetector.detectState(session.terminal, stateData.state);
@@ -227,7 +246,7 @@ export class SessionManager extends EventEmitter {
      * );
      * ```
      */
-    createSessionWithPresetEffect(worktreePath, presetId) {
+    createSessionWithPresetEffect(worktreePath, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
                 // Check if session already exists
@@ -235,31 +254,20 @@ export class SessionManager extends EventEmitter {
                 if (existing) {
                     return existing;
                 }
-                // Get preset configuration using Either-based lookup
-                let preset = presetId
-                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
-                    : null;
-                if (!preset) {
-                    preset = configReader.getDefaultPreset();
-                }
-                // Validate preset exists
-                if (!preset) {
-                    throw new ConfigError({
-                        configPath: 'configuration',
-                        reason: 'validation',
-                        details: presetId
-                            ? `Preset with ID '${presetId}' not found and no default preset available`
-                            : 'No default preset available',
-                    });
-                }
+                const preset = this.resolvePreset(presetId);
                 const command = preset.command;
-                const args = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+                const launch = preparePresetLaunch(preset, initialPrompt);
+                const args = launch.args;
                 // Spawn the process - fallback will be handled by setupExitHandler
                 const ptyProcess = await this.spawn(command, args, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, {
+                const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                 });
+                if (launch.stdinPayload) {
+                    session.process.write(launch.stdinPayload);
+                }
+                return session;
             },
             catch: (error) => {
                 // If it's already a ConfigError, return it
@@ -617,7 +625,7 @@ export class SessionManager extends EventEmitter {
      * Create session with devcontainer integration using Effect-based error handling
      * @returns Effect that may fail with ProcessError (container/spawn failure) or ConfigError (invalid preset)
      */
-    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId) {
+    createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
                 // Check if session already exists
@@ -635,37 +643,26 @@ export class SessionManager extends EventEmitter {
                         message: `Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`,
                     });
                 }
-                // Get preset configuration using Either-based lookup
-                let preset = presetId
-                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
-                    : null;
-                if (!preset) {
-                    preset = configReader.getDefaultPreset();
-                }
-                // Validate preset exists
-                if (!preset) {
-                    throw new ConfigError({
-                        configPath: 'configuration',
-                        reason: 'validation',
-                        details: presetId
-                            ? `Preset with ID '${presetId}' not found and no default preset available`
-                            : 'No default preset available',
-                    });
-                }
+                const preset = this.resolvePreset(presetId);
                 // Parse the exec command to extract arguments
                 const execParts = devcontainerConfig.execCommand.split(/\s+/);
                 const devcontainerCmd = execParts[0] || 'devcontainer';
                 const execArgs = execParts.slice(1);
                 // Build the full command: devcontainer exec [args] -- [preset command] [preset args]
-                const presetArgs = injectTeammateMode(preset.command, preset.args || [], preset.detectionStrategy);
+                const launch = preparePresetLaunch(preset, initialPrompt);
+                const presetArgs = launch.args;
                 const fullArgs = [...execArgs, '--', preset.command, ...presetArgs];
                 // Spawn the process within devcontainer
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, {
+                const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
                 });
+                if (launch.stdinPayload) {
+                    session.process.write(launch.stdinPayload);
+                }
+                return session;
             },
             catch: (error) => {
                 // If it's already a ConfigError or ProcessError, return it