ccmanager 1.3.1 → 1.4.1

package/README.md

@@ -15,6 +15,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
+- **Copy Claude Code session data** between worktrees to maintain conversation context
 - Configurable keyboard shortcuts
 - Command presets with automatic fallback support
 - Configurable state detection strategies for different CLI tools
@@ -154,6 +155,41 @@ CCManager supports configuring the command and arguments used to run Claude Code
 For detailed configuration options and examples, see [docs/command-config.md](docs/command-config.md).
 
 
+## Session Data Copying
+
+CCManager can copy Claude Code session data (conversation history, context, and project state) when creating new worktrees, allowing you to maintain context across different branches.
+
+### Features
+
+- **Seamless Context Transfer**: Continue conversations in new worktrees without losing context
+- **Configurable Default**: Set whether to copy session data by default
+- **Per-Creation Choice**: Decide on each worktree creation whether to copy data
+- **Safe Operation**: Copying is non-fatal - worktree creation succeeds even if copying fails
+
+### How It Works
+
+When creating a new worktree, CCManager:
+1. Asks whether to copy session data from the current worktree
+2. Copies all session files from `~/.claude/projects/[source-path]` to `~/.claude/projects/[target-path]`
+3. Preserves conversation history, project context, and Claude Code state
+4. Allows immediate continuation of conversations in the new worktree
+
+### Configuration
+
+1. Navigate to **Configuration** → **Configure Worktree**
+2. Toggle **Copy Session Data** to set the default behavior
+3. Save changes
+
+The default choice (copy or start fresh) will be pre-selected when creating new worktrees.
+
+### Use Cases
+
+- **Feature Development**: Copy session data when creating feature branches to maintain project context
+- **Experimentation**: Start fresh when testing unrelated changes
+- **Collaboration**: Share session state across team worktrees
+- **Context Preservation**: Maintain long conversations across multiple development branches
+
+
 ## Status Change Hooks
 
 CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.

package/dist/components/App.js

@@ -150,11 +150,11 @@ const App = ({ devcontainerConfig }) => {
             }
         }, 50); // Small delay to ensure proper cleanup
     };
-    const handleCreateWorktree = async (path, branch, baseBranch, copyClaudeDirectory) => {
+    const handleCreateWorktree = async (path, branch, baseBranch, copySessionData, copyClaudeDirectory) => {
         setView('creating-worktree');
         setError(null);
         // Create the worktree
-        const result = worktreeService.createWorktree(path, branch, baseBranch, copyClaudeDirectory);
+        const result = worktreeService.createWorktree(path, branch, baseBranch, copySessionData, copyClaudeDirectory);
         if (result.success) {
             // Success - return to menu
             handleReturnToMenu();

package/dist/components/ConfigureCommand.js

@@ -246,18 +246,12 @@ const ConfigureCommand = ({ onComplete }) => {
             // In input mode, let TextInput or SelectInput handle it
             return;
         }
-        if (viewMode === 'list' || viewMode === 'edit') {
+        if (viewMode === 'list' ||
+            viewMode === 'edit' ||
+            viewMode === 'delete-confirm') {
             // SelectInput handles navigation and selection
             return;
         }
-        else if (viewMode === 'delete-confirm') {
-            if (key.upArrow || key.downArrow) {
-                setSelectedIndex(prev => (prev === 0 ? 1 : 0));
-            }
-            else if (key.return) {
-                handleDeleteConfirm();
-            }
-        }
     });
     // Render strategy selection
     if (isSelectingStrategy) {
@@ -360,6 +354,19 @@ const ConfigureCommand = ({ onComplete }) => {
     // Render delete confirmation
     if (viewMode === 'delete-confirm') {
         const preset = presets.find(p => p.id === selectedPresetId);
+        const confirmItems = [
+            { label: 'Yes, delete', value: 'yes' },
+            { label: 'Cancel', value: 'cancel' },
+        ];
+        const handleConfirmSelect = (item) => {
+            if (item.value === 'yes') {
+                handleDeleteConfirm();
+            }
+            else {
+                setViewMode('edit');
+                setSelectedIndex(6); // Return to delete option in edit menu
+            }
+        };
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { bold: true, color: "red" }, "Confirm Delete")),
@@ -368,17 +375,15 @@ const ConfigureCommand = ({ onComplete }) => {
                     "Delete preset \"",
                     preset?.name,
                     "\"?")),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: selectedIndex === 0 ? 'red' : undefined },
-                        selectedIndex === 0 ? '> ' : '  ',
-                        "Yes, delete")),
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: selectedIndex === 1 ? 'cyan' : undefined },
-                        selectedIndex === 1 ? '> ' : '  ',
-                        "Cancel"))),
+            React.createElement(SelectInput, { items: confirmItems, onSelect: handleConfirmSelect, initialIndex: 1, indicatorComponent: ({ isSelected }) => (React.createElement(Text, { color: isSelected ? 'red' : undefined }, isSelected ? '>' : ' ')), itemComponent: ({ isSelected, label }) => (React.createElement(Text, { color: label === 'Yes, delete'
+                        ? isSelected
+                            ? 'red'
+                            : undefined
+                        : isSelected
+                            ? 'cyan'
+                            : undefined, inverse: isSelected }, label)) }),
             React.createElement(Box, { marginTop: 1 },
-                React.createElement(Text, { dimColor: true }, "Press \u2191\u2193 to navigate, Enter to confirm"))));
+                React.createElement(Text, { dimColor: true }, "Press \u2191\u2193/j/k to navigate, Enter to confirm"))));
     }
     // Render edit preset view
     if (viewMode === 'edit') {

package/dist/components/ConfigureWorktree.js

@@ -8,6 +8,7 @@ const ConfigureWorktree = ({ onComplete }) => {
     const worktreeConfig = configurationManager.getWorktreeConfig();
     const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
     const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
+    const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
     useInput((input, key) => {
@@ -25,6 +26,10 @@ const ConfigureWorktree = ({ onComplete }) => {
             label: `Pattern: ${pattern}`,
             value: 'pattern',
         },
+        {
+            label: `Copy Session Data: ${copySessionData ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleCopy',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -43,11 +48,15 @@ const ConfigureWorktree = ({ onComplete }) => {
                 setTempPattern(pattern);
                 setEditMode('pattern');
                 break;
+            case 'toggleCopy':
+                setCopySessionData(!copySessionData);
+                break;
             case 'save':
                 // Save the configuration
                 configurationManager.setWorktreeConfig({
                     autoDirectory,
                     autoDirectoryPattern: pattern,
+                    copySessionData,
                 });
                 onComplete();
                 break;
@@ -83,7 +92,7 @@ const ConfigureWorktree = ({ onComplete }) => {
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "green" }, "Configure Worktree Settings")),
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Configure automatic worktree directory generation")),
+            React.createElement(Text, { dimColor: true }, "Configure worktree creation settings")),
         autoDirectory && (React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, null,
                 "Example: branch \"feature/my-feature\" \u2192 directory \"",

package/dist/components/DeleteConfirmation.js

@@ -1,81 +1,61 @@
 import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
 import { shortcutManager } from '../services/shortcutManager.js';
 const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
     // Check if any worktrees have branches
     const hasAnyBranches = worktrees.some(wt => wt.branch);
     const [deleteBranch, setDeleteBranch] = useState(true);
-    const [focusedOption, setFocusedOption] = useState(hasAnyBranches ? 'deleteBranch' : 'confirm');
-    // Helper functions for navigation
-    const isRadioOption = (option) => option === 'deleteBranch' || option === 'keepBranch';
-    const isActionButton = (option) => option === 'confirm' || option === 'cancel';
-    const handleUpArrow = () => {
-        if (!hasAnyBranches) {
-            if (focusedOption === 'cancel')
-                setFocusedOption('confirm');
-            return;
-        }
-        const navigationMap = {
-            keepBranch: 'deleteBranch',
-            confirm: 'keepBranch',
-            cancel: 'keepBranch',
-        };
-        const next = navigationMap[focusedOption];
-        if (next)
-            setFocusedOption(next);
-    };
-    const handleDownArrow = () => {
-        if (!hasAnyBranches) {
-            if (focusedOption === 'confirm')
-                setFocusedOption('cancel');
-            return;
-        }
-        const navigationMap = {
-            deleteBranch: 'keepBranch',
-            keepBranch: 'confirm',
-            confirm: 'cancel',
-        };
-        const next = navigationMap[focusedOption];
-        if (next)
-            setFocusedOption(next);
-    };
-    const handleHorizontalArrow = (direction) => {
-        if (isActionButton(focusedOption)) {
-            setFocusedOption(direction === 'left' ? 'confirm' : 'cancel');
-        }
+    const [view, setView] = useState(hasAnyBranches ? 'options' : 'confirm');
+    const [focusedOption, setFocusedOption] = useState(deleteBranch ? 'deleteBranch' : 'keepBranch');
+    // Menu items for branch options
+    const branchOptions = [
+        {
+            label: `${deleteBranch ? '(•)' : '( )'} Delete the branches too`,
+            value: 'deleteBranch',
+        },
+        {
+            label: `${!deleteBranch ? '(•)' : '( )'} Keep the branches`,
+            value: 'keepBranch',
+        },
+    ];
+    // Menu items for actions
+    const actionOptions = [
+        { label: 'Confirm', value: 'confirm' },
+        { label: 'Cancel', value: 'cancel' },
+    ];
+    const handleBranchSelect = (item) => {
+        // Don't toggle on Enter - only update focused option
+        setFocusedOption(item.value);
     };
-    const handleSelect = () => {
-        if (isRadioOption(focusedOption)) {
-            setDeleteBranch(focusedOption === 'deleteBranch');
-        }
-        else if (focusedOption === 'confirm') {
+    const handleActionSelect = (item) => {
+        if (item.value === 'confirm') {
             onConfirm(deleteBranch);
         }
-        else if (focusedOption === 'cancel') {
+        else {
             onCancel();
         }
     };
     useInput((input, key) => {
-        if (key.upArrow) {
-            handleUpArrow();
-        }
-        else if (key.downArrow) {
-            handleDownArrow();
-        }
-        else if (key.leftArrow) {
-            handleHorizontalArrow('left');
-        }
-        else if (key.rightArrow) {
-            handleHorizontalArrow('right');
+        if (shortcutManager.matchesShortcut('cancel', input, key)) {
+            onCancel();
         }
-        else if (input === ' ' && isRadioOption(focusedOption)) {
-            setDeleteBranch(focusedOption === 'deleteBranch');
+        else if (hasAnyBranches && view === 'options' && key.return) {
+            // Move to confirm view when Enter is pressed in options
+            setView('confirm');
         }
-        else if (key.return) {
-            handleSelect();
+        else if (hasAnyBranches && view === 'confirm' && key.escape) {
+            // Go back to options when Escape is pressed in confirm
+            setView('options');
         }
-        else if (shortcutManager.matchesShortcut('cancel', input, key)) {
-            onCancel();
+        else if (hasAnyBranches && view === 'options' && input === ' ') {
+            // Toggle selection on space for radio buttons
+            if (focusedOption === 'deleteBranch') {
+                setDeleteBranch(true);
+            }
+            else {
+                setDeleteBranch(false);
+            }
         }
     });
     return (React.createElement(Box, { flexDirection: "column" },
@@ -101,33 +81,38 @@ const DeleteConfirmation = ({ worktrees, onConfirm, onCancel, }) => {
                     "... and ",
                     worktrees.length - 8,
                     " more worktrees")))),
-        hasAnyBranches && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+        hasAnyBranches && view === 'options' && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
             React.createElement(Text, { bold: true }, "What do you want to do with the associated branches?"),
-            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: focusedOption === 'deleteBranch' ? 'red' : undefined, inverse: focusedOption === 'deleteBranch' },
-                        deleteBranch ? '(•)' : '( )',
-                        " Delete the branches too")),
-                React.createElement(Box, null,
-                    React.createElement(Text, { color: focusedOption === 'keepBranch' ? 'green' : undefined, inverse: focusedOption === 'keepBranch' },
-                        !deleteBranch ? '(•)' : '( )',
-                        " Keep the branches"))))),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Box, { marginRight: 2 },
-                React.createElement(Text, { color: focusedOption === 'confirm' ? 'green' : 'white', inverse: focusedOption === 'confirm' },
-                    ' ',
-                    "Confirm",
-                    ' ')),
-            React.createElement(Box, null,
-                React.createElement(Text, { color: focusedOption === 'cancel' ? 'red' : 'white', inverse: focusedOption === 'cancel' },
-                    ' ',
-                    "Cancel",
-                    ' '))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(SelectInput, { items: branchOptions, onSelect: handleBranchSelect, onHighlight: (item) => {
+                        setFocusedOption(item.value);
+                    }, initialIndex: deleteBranch ? 0 : 1, indicatorComponent: ({ isSelected }) => (React.createElement(Text, { color: isSelected ? 'red' : undefined }, isSelected ? '>' : ' ')), itemComponent: ({ isSelected, label }) => (React.createElement(Text, { color: isSelected ? 'red' : undefined, inverse: isSelected }, label)) })))),
+        hasAnyBranches && view === 'confirm' && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Branch option selected:"),
+            React.createElement(Text, { color: "yellow" }, deleteBranch ? '✓ Delete the branches too' : '✓ Keep the branches'))),
+        (view === 'confirm' || !hasAnyBranches) && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(SelectInput, { items: actionOptions, onSelect: handleActionSelect, initialIndex: 1, indicatorComponent: ({ isSelected }) => (React.createElement(Text, null, isSelected ? '>' : ' ')), itemComponent: ({ isSelected, label }) => {
+                    const color = label === 'Confirm' ? 'green' : 'red';
+                    return (React.createElement(Text, { color: isSelected ? color : 'white', inverse: isSelected },
+                        ' ',
+                        label,
+                        ' '));
+                } }))),
         React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { dimColor: true },
-                "Use \u2191\u2193 to navigate options, Space/Enter to select,",
+            React.createElement(Text, { dimColor: true }, hasAnyBranches && view === 'options' ? (React.createElement(React.Fragment, null,
+                "Use \u2191\u2193/j/k to navigate, Space to toggle, Enter to continue,",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel")) : view === 'confirm' ? (React.createElement(React.Fragment, null,
+                "Use \u2191\u2193/j/k to navigate, Enter to select",
+                hasAnyBranches ? ', Esc to go back' : '',
+                ",",
+                ' ',
+                shortcutManager.getShortcutDisplay('cancel'),
+                " to cancel")) : (React.createElement(React.Fragment, null,
+                "Use \u2191\u2193/j/k to navigate, Enter to select,",
                 ' ',
                 shortcutManager.getShortcutDisplay('cancel'),
-                " to cancel"))));
+                " to cancel"))))));
 };
 export default DeleteConfirmation;

package/dist/components/DeleteWorktree.js

@@ -1,14 +1,14 @@
 import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
 import { WorktreeService } from '../services/worktreeService.js';
 import DeleteConfirmation from './DeleteConfirmation.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 const DeleteWorktree = ({ onComplete, onCancel, }) => {
     const [worktrees, setWorktrees] = useState([]);
     const [selectedIndices, setSelectedIndices] = useState(new Set());
-    const [focusedIndex, setFocusedIndex] = useState(0);
     const [confirmMode, setConfirmMode] = useState(false);
-    const VIEWPORT_SIZE = 10; // Maximum number of items to display at once
+    const [focusedIndex, setFocusedIndex] = useState(0);
     useEffect(() => {
         const worktreeService = new WorktreeService();
         const allWorktrees = worktreeService.getWorktrees();
@@ -16,23 +16,30 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
         const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
         setWorktrees(deletableWorktrees);
     }, []);
+    // Create menu items from worktrees
+    const menuItems = worktrees.map((worktree, index) => {
+        const branchName = worktree.branch
+            ? worktree.branch.replace('refs/heads/', '')
+            : 'detached';
+        const isSelected = selectedIndices.has(index);
+        return {
+            label: `${isSelected ? '[✓]' : '[ ]'} ${branchName} (${worktree.path})`,
+            value: index.toString(),
+        };
+    });
+    const handleSelect = (item) => {
+        // Don't toggle on Enter - this will be used to confirm
+        // We'll handle Space key separately for toggling
+        const index = parseInt(item.value, 10);
+        setFocusedIndex(index);
+    };
     useInput((input, key) => {
-        if (key.ctrl && input === 'c') {
-            onCancel();
-            return;
-        }
         if (confirmMode) {
             // Confirmation component handles input
             return;
         }
-        if (key.upArrow) {
-            setFocusedIndex(prev => Math.max(0, prev - 1));
-        }
-        else if (key.downArrow) {
-            setFocusedIndex(prev => Math.min(worktrees.length - 1, prev + 1));
-        }
-        else if (input === ' ') {
-            // Toggle selection
+        if (input === ' ') {
+            // Toggle selection on space
             setSelectedIndices(prev => {
                 const newSet = new Set(prev);
                 if (newSet.has(focusedIndex)) {
@@ -44,10 +51,8 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
                 return newSet;
             });
         }
-        else if (key.return) {
-            if (selectedIndices.size > 0) {
-                setConfirmMode(true);
-            }
+        else if (key.return && selectedIndices.size > 0) {
+            setConfirmMode(true);
         }
         else if (shortcutManager.matchesShortcut('cancel', input, key)) {
             onCancel();
@@ -77,40 +82,17 @@ const DeleteWorktree = ({ onComplete, onCancel, }) => {
             React.createElement(Text, { bold: true, color: "red" }, "Delete Worktrees")),
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { dimColor: true }, "Select worktrees to delete (Space to select, Enter to confirm):")),
-        (() => {
-            // Calculate viewport window
-            const viewportStart = Math.max(0, Math.min(focusedIndex - Math.floor(VIEWPORT_SIZE / 2), worktrees.length - VIEWPORT_SIZE));
-            const viewportEnd = Math.min(viewportStart + VIEWPORT_SIZE, worktrees.length);
-            const visibleWorktrees = worktrees.slice(viewportStart, viewportEnd);
-            return (React.createElement(React.Fragment, null,
-                viewportStart > 0 && (React.createElement(Text, { dimColor: true },
-                    "\u2191 ",
-                    viewportStart,
-                    " more...")),
-                visibleWorktrees.map((worktree, relativeIndex) => {
-                    const actualIndex = viewportStart + relativeIndex;
-                    const isSelected = selectedIndices.has(actualIndex);
-                    const isFocused = actualIndex === focusedIndex;
-                    const branchName = worktree.branch
-                        ? worktree.branch.replace('refs/heads/', '')
-                        : 'detached';
-                    return (React.createElement(Box, { key: worktree.path },
-                        React.createElement(Text, { color: isFocused ? 'green' : undefined, inverse: isFocused, dimColor: !isFocused && !isSelected },
-                            isSelected ? '[✓]' : '[ ]',
-                            " ",
-                            branchName,
-                            " (",
-                            worktree.path,
-                            ")")));
-                }),
-                viewportEnd < worktrees.length && (React.createElement(Text, { dimColor: true },
-                    "\u2193 ",
-                    worktrees.length - viewportEnd,
-                    " more..."))));
-        })(),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, onHighlight: (item) => {
+                const index = parseInt(item.value, 10);
+                setFocusedIndex(index);
+            }, limit: 10, indicatorComponent: ({ isSelected }) => (React.createElement(Text, { color: isSelected ? 'green' : undefined }, isSelected ? '>' : ' ')), itemComponent: ({ isSelected, label }) => {
+                // Check if this item is actually selected (checkbox checked)
+                const hasCheckmark = label.includes('[✓]');
+                return (React.createElement(Text, { color: isSelected ? 'green' : undefined, inverse: isSelected, dimColor: !isSelected && !hasCheckmark }, label));
+            } }),
         React.createElement(Box, { marginTop: 1, flexDirection: "column" },
             React.createElement(Text, { dimColor: true },
-                "Controls: \u2191\u2193 Navigate, Space Select, Enter Confirm,",
+                "Controls: \u2191\u2193/j/k Navigate, Space Select, Enter Confirm,",
                 ' ',
                 shortcutManager.getShortcutDisplay('cancel'),
                 " Cancel"),

package/dist/components/NewWorktree.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 interface NewWorktreeProps {
-    onComplete: (path: string, branch: string, baseBranch: string, copyClaudeDirectory: boolean) => void;
+    onComplete: (path: string, branch: string, baseBranch: string, copySessionData: boolean, copyClaudeDirectory: boolean) => void;
     onCancel: () => void;
 }
 declare const NewWorktree: React.FC<NewWorktreeProps>;

package/dist/components/NewWorktree.js

@@ -14,6 +14,8 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     const [path, setPath] = useState('');
     const [branch, setBranch] = useState('');
     const [baseBranch, setBaseBranch] = useState('');
+    const [copyClaudeDirectory, setCopyClaudeDirectory] = useState(true);
+    const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     // Initialize worktree service and load branches (memoized to avoid re-initialization)
     const { branches, defaultBranch } = useMemo(() => {
         const service = new WorktreeService();
@@ -50,30 +52,22 @@ const NewWorktree = ({ onComplete, onCancel }) => {
     };
     const handleBaseBranchSelect = (item) => {
         setBaseBranch(item.value);
-        // Check if .claude directory exists in the base branch
-        const service = new WorktreeService();
-        if (service.hasClaudeDirectoryInBranch(item.value)) {
-            setStep('copy-settings');
-        }
-        else {
-            // Skip copy-settings step and complete with copySettings = false
-            if (isAutoDirectory) {
-                const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-                onComplete(autoPath, branch, item.value, false);
-            }
-            else {
-                onComplete(path, branch, item.value, false);
-            }
-        }
+        setStep('copy-settings');
     };
     const handleCopySettingsSelect = (item) => {
+        setCopyClaudeDirectory(item.value);
+        setStep('copy-session');
+    };
+    const handleCopySessionSelect = (item) => {
+        const shouldCopy = item.value === 'yes';
+        setCopySessionData(shouldCopy);
         if (isAutoDirectory) {
             // Generate path from branch name
             const autoPath = generateWorktreeDirectory(branch, worktreeConfig.autoDirectoryPattern);
-            onComplete(autoPath, branch, baseBranch, item.value);
+            onComplete(autoPath, branch, baseBranch, shouldCopy, copyClaudeDirectory);
         }
         else {
-            onComplete(path, branch, baseBranch, item.value);
+            onComplete(path, branch, baseBranch, shouldCopy, copyClaudeDirectory);
         }
     };
     // Calculate generated path for preview (memoized to avoid expensive recalculations)
@@ -129,6 +123,15 @@ const NewWorktree = ({ onComplete, onCancel }) => {
                     },
                     { label: 'No - Start without .claude directory', value: false },
                 ], onSelect: handleCopySettingsSelect, initialIndex: 0 }))),
+        step === 'copy-session' && (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Copy Claude Code session data to the new worktree?")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { dimColor: true }, "This will copy conversation history and context from the current worktree")),
+            React.createElement(SelectInput, { items: [
+                    { label: '✅ Yes, copy session data', value: 'yes' },
+                    { label: '❌ No, start fresh', value: 'no' },
+                ], onSelect: handleCopySessionSelect, initialIndex: copySessionData ? 0 : 1 }))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "Press ",

package/dist/services/configurationManager.js

@@ -66,8 +66,12 @@ export class ConfigurationManager {
         if (!this.config.worktree) {
             this.config.worktree = {
                 autoDirectory: false,
+                copySessionData: true,
             };
         }
+        if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'copySessionData')) {
+            this.config.worktree.copySessionData = true;
+        }
         if (!this.config.command) {
             this.config.command = {
                 command: 'claude',

package/dist/services/worktreeService.d.ts

@@ -9,7 +9,7 @@ export declare class WorktreeService {
     isGitRepository(): boolean;
     getDefaultBranch(): string;
     getAllBranches(): string[];
-    createWorktree(worktreePath: string, branch: string, baseBranch: string, copyClaudeDirectory?: boolean): {
+    createWorktree(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): {
         success: boolean;
         error?: string;
     };
@@ -27,6 +27,7 @@ export declare class WorktreeService {
         success: boolean;
         error?: string;
     };
+    private copyClaudeSessionData;
     hasClaudeDirectoryInBranch(branchName: string): boolean;
     private copyClaudeDirectoryFromBaseBranch;
 }

package/dist/services/worktreeService.js

@@ -2,6 +2,7 @@ import { execSync } from 'child_process';
 import { existsSync, statSync, cpSync } from 'fs';
 import path from 'path';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
+import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 const CLAUDE_DIR = '.claude';
 export class WorktreeService {
     constructor(rootPath) {
@@ -172,7 +173,7 @@ export class WorktreeService {
             return [];
         }
     }
-    createWorktree(worktreePath, branch, baseBranch, copyClaudeDirectory = false) {
+    createWorktree(worktreePath, branch, baseBranch, copySessionData = false, copyClaudeDirectory = false) {
         try {
             // Resolve the worktree path relative to the git repository root
             const resolvedPath = path.isAbsolute(worktreePath)
@@ -203,6 +204,10 @@ export class WorktreeService {
                 cwd: this.gitRootPath, // Execute from git root to ensure proper resolution
                 encoding: 'utf8',
             });
+            // Copy session data if requested
+            if (copySessionData) {
+                this.copyClaudeSessionData(this.rootPath, resolvedPath);
+            }
             // Store the parent branch in worktree config
             try {
                 setWorktreeParentBranch(resolvedPath, baseBranch);
@@ -348,6 +353,32 @@ export class WorktreeService {
             };
         }
     }
+    copyClaudeSessionData(sourceWorktreePath, targetWorktreePath) {
+        try {
+            const projectsDir = getClaudeProjectsDir();
+            if (!existsSync(projectsDir)) {
+                throw new Error(`Claude projects directory does not exist: ${projectsDir}`);
+            }
+            // Convert paths to Claude's naming convention
+            const sourceProjectName = pathToClaudeProjectName(sourceWorktreePath);
+            const targetProjectName = pathToClaudeProjectName(targetWorktreePath);
+            const sourceProjectDir = path.join(projectsDir, sourceProjectName);
+            const targetProjectDir = path.join(projectsDir, targetProjectName);
+            // Only copy if source project exists
+            if (existsSync(sourceProjectDir)) {
+                cpSync(sourceProjectDir, targetProjectDir, {
+                    recursive: true,
+                    force: true,
+                    errorOnExist: false,
+                    preserveTimestamps: true,
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to copy Claude session data: ${error}`);
+            throw new Error(`Failed to copy Claude session data: ${error}`);
+        }
+    }
     hasClaudeDirectoryInBranch(branchName) {
         // Find the worktree directory for the branch
         const worktrees = this.getWorktrees();

package/dist/types/index.d.ts

@@ -57,6 +57,7 @@ export interface StatusHookConfig {
 export interface WorktreeConfig {
     autoDirectory: boolean;
     autoDirectoryPattern?: string;
+    copySessionData?: boolean;
 }
 export interface CommandConfig {
     command: string;

package/dist/utils/claudeDir.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Utilities for Claude Code directory and project path handling.
+ * Provides functions to get Claude configuration directories respecting the
+ * CLAUDE_CONFIG_DIR environment variable and convert worktree paths to Claude's
+ * project naming convention.
+ */
+/**
+ * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
+ * @returns The Claude directory path
+ */
+export declare function getClaudeDir(): string;
+/**
+ * Get the Claude projects directory path
+ * @returns The Claude projects directory path
+ */
+export declare function getClaudeProjectsDir(): string;
+/**
+ * Convert a worktree path to Claude's project naming convention
+ * @param worktreePath The path to the worktree
+ * @returns The project name used by Claude
+ */
+export declare function pathToClaudeProjectName(worktreePath: string): string;

package/dist/utils/claudeDir.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Utilities for Claude Code directory and project path handling.
+ * Provides functions to get Claude configuration directories respecting the
+ * CLAUDE_CONFIG_DIR environment variable and convert worktree paths to Claude's
+ * project naming convention.
+ */
+import path from 'path';
+import os from 'os';
+/**
+ * Get the Claude directory path, respecting CLAUDE_CONFIG_DIR environment variable
+ * @returns The Claude directory path
+ */
+export function getClaudeDir() {
+    const envConfigDir = process.env['CLAUDE_CONFIG_DIR'];
+    if (envConfigDir) {
+        return envConfigDir.trim();
+    }
+    // Default to ~/.claude for backward compatibility and when not set
+    return path.join(os.homedir(), '.claude');
+}
+/**
+ * Get the Claude projects directory path
+ * @returns The Claude projects directory path
+ */
+export function getClaudeProjectsDir() {
+    return path.join(getClaudeDir(), 'projects');
+}
+/**
+ * Convert a worktree path to Claude's project naming convention
+ * @param worktreePath The path to the worktree
+ * @returns The project name used by Claude
+ */
+export function pathToClaudeProjectName(worktreePath) {
+    // Convert absolute path to Claude's project naming convention
+    // Claude replaces all path separators and dots with dashes
+    const resolved = path.resolve(worktreePath);
+    // Handle both forward slashes (Linux/macOS) and backslashes (Windows)
+    return resolved.replace(/[/\\.]/g, '-');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "1.3.1",
+	"version": "1.4.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",