ccmanager 4.3.0 → 4.3.2

package/dist/components/SessionActions.test.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { useInput } from 'ink';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import SessionActions from './SessionActions.js';
+const makeKey = (overrides = {}) => ({
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    home: false,
+    end: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+    ...overrides,
+});
+// Mock ink to avoid stdin issues and to capture the hotkey handler
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label))),
+    };
+});
+const getLastInputHandler = () => {
+    const calls = vi.mocked(useInput).mock.calls;
+    const handler = calls[calls.length - 1]?.[0];
+    expect(handler).toBeDefined();
+    return handler;
+};
+describe('SessionActions', () => {
+    beforeEach(() => {
+        vi.mocked(useInput).mockClear();
+    });
+    it('should show session actions and the delete entry for a deletable worktree', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo/worktrees/feature", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Session Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Rename this session');
+        expect(frame).toContain('Close session');
+        expect(frame).toContain('Delete this worktree');
+    });
+    it('should hide session-specific actions for a worktree without a session', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Worktree Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Delete this worktree');
+        expect(frame).not.toContain('Rename this session');
+        expect(frame).not.toContain('Close session');
+    });
+    it('should hide the delete entry when the worktree cannot be deleted', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: vi.fn(), onCancel: vi.fn() }));
+        expect(lastFrame()).not.toContain('Delete this worktree');
+    });
+    it('should dispatch deleteWorktree on the D hotkey when deletion is offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: onSelect, onCancel: vi.fn() }));
+        getLastInputHandler()('d', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('deleteWorktree');
+    });
+    it('should ignore hotkeys of actions that are not offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: onSelect, onCancel: vi.fn() }));
+        const handler = getLastInputHandler();
+        handler('d', makeKey());
+        expect(onSelect).not.toHaveBeenCalled();
+        handler('x', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('kill');
+    });
+    it('should cancel on Escape', () => {
+        const onCancel = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: onCancel }));
+        getLastInputHandler()('', makeKey({ escape: true }));
+        expect(onCancel).toHaveBeenCalled();
+    });
+});

package/dist/services/worktreeService.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import { Worktree, CreateWorktreeResult, AmbiguousBranchError, MergeConfig } from '../types/index.js';
+import { Worktree, CreateWorktreeResult, AmbiguousBranchError, BaseBranchResolution, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
@@ -54,6 +54,21 @@ export declare class WorktreeService {
      */
     private resolveBranchReference;
     private resolveBranchReferenceEffect;
+    /**
+     * Classifies a base branch picked in the UI, without throwing.
+     *
+     * Unlike resolveBranchReference(), this is meant to run right after the
+     * user selects a base branch so that:
+     * - a local branch is confirmed immediately (never routed to the
+     *   ambiguous-remote confirmation), and
+     * - an ambiguous branch (same name in multiple remotes) can be
+     *   disambiguated right away instead of failing later at creation time.
+     *
+     * @param {string} branchName - Branch name or remote-qualified ref
+     *   (e.g. "feature/x" or "origin/feature/x") selected as base branch
+     * @returns {BaseBranchResolution} Classification result (see type docs)
+     */
+    resolveBaseBranch(branchName: string): BaseBranchResolution;
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *
@@ -140,6 +155,18 @@ export declare class WorktreeService {
      * @throws {FileSystemError} When copying the directory fails
      */
     private copyClaudeDirectoryFromBaseBranchEffect;
+    /**
+     * Effect-based copyWorktreeIncludeFiles operation.
+     * Copies the gitignored files a `.worktreeinclude` file at the repository
+     * root selects (see src/utils/worktreeInclude.ts) into the new worktree.
+     * A no-op when no `.worktreeinclude` file exists, so this always runs
+     * unconditionally rather than being gated by a config flag.
+     *
+     * @param {string} gitRoot - Absolute path to the main checkout
+     * @param {string} targetWorktreePath - Path of the newly created worktree
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that completes successfully or fails with FileSystemError
+     */
+    private copyWorktreeIncludeFilesEffect;
     /**
      * Effect-based getDefaultBranch operation
      * Returns Effect that may fail with GitError

package/dist/services/worktreeService.js

@@ -7,6 +7,7 @@ import { GitError, FileSystemError } from '../types/errors.js';
 import { setWorktreeParentBranch } from '../utils/worktreeConfig.js';
 import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeDir.js';
 import { executeWorktreePostCreationHook, executeWorktreePreCreationHook, } from '../utils/hookExecutor.js';
+import { copyWorktreeIncludeFiles } from '../utils/worktreeInclude.js';
 import { configReader } from './config/configReader.js';
 import { logger } from '../utils/logger.js';
 const CLAUDE_DIR = '.claude';
@@ -174,6 +175,79 @@ export class WorktreeService {
             },
         });
     }
+    /**
+     * Classifies a base branch picked in the UI, without throwing.
+     *
+     * Unlike resolveBranchReference(), this is meant to run right after the
+     * user selects a base branch so that:
+     * - a local branch is confirmed immediately (never routed to the
+     *   ambiguous-remote confirmation), and
+     * - an ambiguous branch (same name in multiple remotes) can be
+     *   disambiguated right away instead of failing later at creation time.
+     *
+     * @param {string} branchName - Branch name or remote-qualified ref
+     *   (e.g. "feature/x" or "origin/feature/x") selected as base branch
+     * @returns {BaseBranchResolution} Classification result (see type docs)
+     */
+    resolveBaseBranch(branchName) {
+        // Local branch has the highest priority
+        try {
+            execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, {
+                cwd: this.rootPath,
+                encoding: 'utf8',
+            });
+            return { kind: 'local', ref: branchName, localName: branchName };
+        }
+        catch {
+            // Not a local branch, check remotes below
+        }
+        const remotes = this.getAllRemotes();
+        // Already remote-qualified (e.g. "origin/feature/x" selected from the
+        // remote section of the branch list): not ambiguous by construction.
+        for (const remote of remotes) {
+            const prefix = `${remote}/`;
+            if (!branchName.startsWith(prefix))
+                continue;
+            try {
+                execSync(`git show-ref --verify --quiet refs/remotes/${branchName}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                return {
+                    kind: 'remote',
+                    ref: branchName,
+                    localName: branchName.slice(prefix.length),
+                };
+            }
+            catch {
+                // Not an existing remote-tracking ref; fall through to matching
+            }
+        }
+        const matches = [];
+        for (const remote of remotes) {
+            try {
+                execSync(`git show-ref --verify --quiet refs/remotes/${remote}/${branchName}`, {
+                    cwd: this.rootPath,
+                    encoding: 'utf8',
+                });
+                matches.push({
+                    remote,
+                    branch: branchName,
+                    fullRef: `${remote}/${branchName}`,
+                });
+            }
+            catch {
+                // This remote doesn't have the branch, continue
+            }
+        }
+        if (matches.length === 1) {
+            return { kind: 'remote', ref: matches[0].fullRef, localName: branchName };
+        }
+        if (matches.length > 1) {
+            return { kind: 'ambiguous', branchName, matches };
+        }
+        return { kind: 'none', ref: branchName, localName: branchName };
+    }
     /**
      * SYNCHRONOUS HELPER: Gets all git remotes for this repository.
      *
@@ -375,6 +449,27 @@ export class WorktreeService {
             });
         });
     }
+    /**
+     * Effect-based copyWorktreeIncludeFiles operation.
+     * Copies the gitignored files a `.worktreeinclude` file at the repository
+     * root selects (see src/utils/worktreeInclude.ts) into the new worktree.
+     * A no-op when no `.worktreeinclude` file exists, so this always runs
+     * unconditionally rather than being gated by a config flag.
+     *
+     * @param {string} gitRoot - Absolute path to the main checkout
+     * @param {string} targetWorktreePath - Path of the newly created worktree
+     * @returns {Effect.Effect<void, FileSystemError, never>} Effect that completes successfully or fails with FileSystemError
+     */
+    copyWorktreeIncludeFilesEffect(gitRoot, targetWorktreePath) {
+        return Effect.try({
+            try: () => copyWorktreeIncludeFiles(gitRoot, targetWorktreePath),
+            catch: (error) => new FileSystemError({
+                operation: 'write',
+                path: targetWorktreePath,
+                cause: String(error),
+            }),
+        });
+    }
     /**
      * Effect-based getDefaultBranch operation
      * Returns Effect that may fail with GitError
@@ -831,7 +926,13 @@ export class WorktreeService {
                 command = `git worktree add -b "${branch}" "${resolvedPath}" "${baseBranch}"`;
             }
             else {
-                const resolvedRef = yield* self.resolveBranchReferenceEffect(branch);
+                // The new branch name itself may match remote branches (checkout
+                // semantics: typing "feature/x" checks out origin/feature/x when it
+                // exists on exactly one remote). When the name exists on MULTIPLE
+                // remotes, don't fail with AmbiguousBranchError: the user already
+                // chose baseBranch explicitly, so create the new branch from
+                // baseBranch instead of asking which remote to track.
+                const resolvedRef = yield* Effect.catchAll(self.resolveBranchReferenceEffect(branch), () => Effect.succeed(branch));
                 const isRemoteBranch = resolvedRef !== branch;
                 const startPoint = isRemoteBranch
                     ? resolvedRef
@@ -888,6 +989,14 @@ export class WorktreeService {
                     return Effect.succeed(undefined);
                 });
             }
+            // Copy files selected by a .worktreeinclude file, if one exists at
+            // the repository root. Runs unconditionally (no config flag) and
+            // before the post-creation hook, so hook commands can rely on the
+            // copied files (e.g. .env) already being in place.
+            yield* Effect.catchAll(self.copyWorktreeIncludeFilesEffect(absoluteGitRoot, resolvedPath), (error) => {
+                console.error('Warning: Failed to copy .worktreeinclude files:', error);
+                return Effect.succeed(undefined);
+            });
             // Execute post-creation hook if configured
             const worktreeHooks = configReader.getWorktreeHooks();
             logger.info('Worktree hook config after creation', {

package/dist/services/worktreeService.test.js

@@ -1,7 +1,8 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { WorktreeService } from './worktreeService.js';
 import { execSync } from 'child_process';
-import { existsSync, statSync } from 'fs';
+import { existsSync, statSync, cpSync, mkdirSync } from 'fs';
+import path from 'path';
 import { configReader } from './config/configReader.js';
 import { Effect } from 'effect';
 import { GitError, ProcessError } from '../types/errors.js';
@@ -33,11 +34,20 @@ vi.mock('../utils/hookExecutor.js', () => ({
 const mockedExecSync = vi.mocked(execSync);
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedStatSync = vi.mocked(statSync);
+const mockedCpSync = vi.mocked(cpSync);
+const mockedMkdirSync = vi.mocked(mkdirSync);
 const mockedGetWorktreeHooks = vi.mocked(configReader.getWorktreeHooks);
 describe('WorktreeService', () => {
     let service;
     beforeEach(() => {
         vi.clearAllMocks();
+        // vi.clearAllMocks() clears call history but not custom implementations,
+        // so a test-specific existsSync/statSync mock (e.g. in
+        // hasClaudeDirectoryInBranchEffect below) would otherwise leak into
+        // every later test in this file. Reset them to the automock default
+        // (returns undefined) so each test starts from a clean slate.
+        mockedExistsSync.mockReset();
+        mockedStatSync.mockReset();
         // Mock git rev-parse --git-common-dir to return a predictable path
         mockedExecSync.mockImplementation((cmd, _options) => {
             if (typeof cmd === 'string' && cmd === 'git rev-parse --git-common-dir') {
@@ -425,6 +435,133 @@ origin/feature/test
             }
         });
     });
+    describe('resolveBaseBranch', () => {
+        it('should classify a local branch as local without checking remotes', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git show-ref --verify --quiet refs/heads/feature/x') {
+                        return ''; // Local branch exists
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'local',
+                ref: 'feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a remote-qualified ref as remote with the short local name', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd ===
+                        'git show-ref --verify --quiet refs/remotes/origin/feature/x') {
+                        return '';
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('origin/feature/x');
+            expect(result).toEqual({
+                kind: 'remote',
+                ref: 'origin/feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a branch existing on a single remote as remote', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd ===
+                        'git show-ref --verify --quiet refs/remotes/origin/feature/x') {
+                        return '';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        throw new Error('Remote branch not found');
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'remote',
+                ref: 'origin/feature/x',
+                localName: 'feature/x',
+            });
+        });
+        it('should classify a branch existing on multiple remotes as ambiguous', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Local branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nupstream\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        return ''; // Both remotes have the branch
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const result = service.resolveBaseBranch('feature/x');
+            expect(result).toEqual({
+                kind: 'ambiguous',
+                branchName: 'feature/x',
+                matches: [
+                    { remote: 'origin', branch: 'feature/x', fullRef: 'origin/feature/x' },
+                    {
+                        remote: 'upstream',
+                        branch: 'feature/x',
+                        fullRef: 'upstream/feature/x',
+                    },
+                ],
+            });
+        });
+        it('should classify an unknown branch as none', () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\n';
+                    }
+                }
+                throw new Error('Branch not found');
+            });
+            const result = service.resolveBaseBranch('nonexistent');
+            expect(result).toEqual({
+                kind: 'none',
+                ref: 'nonexistent',
+                localName: 'nonexistent',
+            });
+        });
+    });
     describe('hasClaudeDirectoryInBranchEffect', () => {
         it('should return Effect with true when .claude directory exists in branch worktree', async () => {
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -710,6 +847,50 @@ branch refs/heads/feature
                 isMainWorktree: false,
             });
         });
+        it('should copy .worktreeinclude files from the main checkout into the new worktree', async () => {
+            mockedExistsSync.mockImplementation(filePath => {
+                const target = String(filePath);
+                if (target.endsWith('.worktreeinclude'))
+                    return true;
+                // The source .env lives in the main checkout (gitRoot); the same
+                // relative path under the new worktree must not exist yet.
+                if (target === path.join('/fake/path', '.env'))
+                    return true;
+                return false;
+            });
+            mockedStatSync.mockImplementation(() => ({ isFile: () => true }));
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        throw new Error('Remote branch not found');
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
+                    }
+                    if (cmd.includes('git ls-files --others --ignored')) {
+                        return '.env\0';
+                    }
+                    if (cmd === 'git check-ignore --stdin -z') {
+                        return '.env\0';
+                    }
+                }
+                return '';
+            });
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'main');
+            const result = await Effect.runPromise(effect);
+            expect(result.worktree.path).toBe('/path/to/worktree');
+            expect(mockedMkdirSync).toHaveBeenCalledWith(path.dirname(path.join('/path/to/worktree', '.env')), { recursive: true });
+            expect(mockedCpSync).toHaveBeenCalledWith(path.join('/fake/path', '.env'), path.join('/path/to/worktree', '.env'), { recursive: true, preserveTimestamps: true });
+        });
         it('should create local branch from remote ref when only remote branch exists', async () => {
             const executedCommands = [];
             mockedExecSync.mockImplementation((cmd, _options) => {
@@ -751,12 +932,18 @@ branch refs/heads/feature
             expect(worktreeAddCmd).toContain('-b "feature/remote-only"');
             expect(worktreeAddCmd).toContain('"origin/feature/remote-only"');
         });
-        it('should return Effect Left with AmbiguousBranchError when branch exists in multiple remotes', async () => {
+        it('should fall back to baseBranch when the new branch name exists in multiple remotes', async () => {
+            const executedCommands = [];
             mockedExecSync.mockImplementation((cmd, _options) => {
                 if (typeof cmd === 'string') {
+                    executedCommands.push(cmd);
                     if (cmd === 'git rev-parse --git-common-dir') {
                         return '/fake/path/.git\n';
                     }
+                    // baseBranch "main" exists locally; the new branch does not
+                    if (cmd === 'git show-ref --verify --quiet refs/heads/main') {
+                        return '';
+                    }
                     if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
                         throw new Error('Branch not found');
                     }
@@ -764,13 +951,49 @@ branch refs/heads/feature
                         return 'origin\nkbwo-fork\n';
                     }
                     if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
-                        return ''; // Both remotes have the branch
+                        return ''; // Both remotes have the new branch name
+                    }
+                    if (cmd.includes('git worktree add')) {
+                        return '';
                     }
                 }
-                throw new Error('Command not mocked: ' + cmd);
+                return '';
             });
+            // The user explicitly chose "main" as base branch; the ambiguity of
+            // "feature/feed-mention" across remotes must not fail the creation.
             const effect = service.createWorktreeEffect('/path/to/worktree', 'feature/feed-mention', 'main');
             const result = await Effect.runPromise(Effect.either(effect));
+            expect(result._tag).toBe('Right');
+            const worktreeAddCmd = executedCommands.find(c => c.includes('git worktree add'));
+            expect(worktreeAddCmd).toContain('-b "feature/feed-mention"');
+            expect(worktreeAddCmd).toContain('"main"');
+        });
+        it('should return Effect Left with AmbiguousBranchError when baseBranch exists in multiple remotes', async () => {
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/heads/')) {
+                        throw new Error('Branch not found');
+                    }
+                    if (cmd === 'git remote') {
+                        return 'origin\nkbwo-fork\n';
+                    }
+                    // Only the baseBranch exists on the remotes; the new branch
+                    // name matches nothing anywhere.
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/origin/feature/feed-mention') ||
+                        cmd.includes('show-ref --verify --quiet refs/remotes/kbwo-fork/feature/feed-mention')) {
+                        return '';
+                    }
+                    if (cmd.includes('show-ref --verify --quiet refs/remotes/')) {
+                        throw new Error('Remote branch not found');
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.createWorktreeEffect('/path/to/worktree', 'new-feature', 'feature/feed-mention');
+            const result = await Effect.runPromise(Effect.either(effect));
             expect(result._tag).toBe('Left');
             if (result._tag === 'Left') {
                 expect(result.left).toBeInstanceOf(AmbiguousBranchError);

package/dist/types/index.d.ts

@@ -75,8 +75,8 @@ export type MenuAction = {
     sessionId: string;
 } | {
     type: 'sessionActions';
-    session: Session;
-    worktreePath: string;
+    worktree: Worktree;
+    session?: Session;
 } | {
     type: 'deleteWorktree';
 } | {
@@ -249,6 +249,33 @@ export interface RemoteBranchMatch {
     branch: string;
     fullRef: string;
 }
+/**
+ * Result of classifying a base branch the user picked in the UI.
+ *
+ * - 'local': branch exists locally; `ref` is the branch name as-is.
+ * - 'remote': resolved to exactly one remote-tracking ref; `ref` is the full
+ *   ref (e.g. "origin/foo") and `localName` the short branch name to use when
+ *   creating a local branch from it.
+ * - 'ambiguous': branch exists in multiple remotes; the user must pick one.
+ * - 'none': nothing matched; pass `ref` through and let git report errors.
+ */
+export type BaseBranchResolution = {
+    kind: 'local';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'remote';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'none';
+    ref: string;
+    localName: string;
+} | {
+    kind: 'ambiguous';
+    branchName: string;
+    matches: RemoteBranchMatch[];
+};
 export declare class AmbiguousBranchError extends Error {
     readonly _tag: "AmbiguousBranchError";
     branchName: string;

package/dist/utils/worktreeInclude.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Filename for the convention shared across worktree-aware tools (Claude Code,
+ * Conductor, OpenAI Codex, git-worktreeinclude, worktrunk): a gitignore-syntax
+ * file at the repository root that lists gitignored files to carry into every
+ * new worktree.
+ */
+export declare const WORKTREE_INCLUDE_FILENAME = ".worktreeinclude";
+/**
+ * Resolves which files a `.worktreeinclude` file selects, relative to `gitRoot`.
+ *
+ * A file is selected only when both hold:
+ * - it matches a pattern in `.worktreeinclude` (gitignore syntax: comments,
+ *   negation with `!`, anchoring with `/`, `**` globs)
+ * - Git already ignores it (nested `.gitignore` files, `.git/info/exclude`,
+ *   and `core.excludesfile` all apply)
+ *
+ * This mirrors the safety rule every tool that supports `.worktreeinclude`
+ * documents: listing a pattern never makes a tracked file eligible, and it
+ * never makes an otherwise-untracked-but-not-ignored file eligible either.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @returns Repository-relative paths (forward-slash separated, as Git reports them)
+ */
+export declare function resolveWorktreeIncludeFiles(gitRoot: string): string[];
+/**
+ * Copies the files a `.worktreeinclude` file selects from the main checkout
+ * into a freshly created worktree. No-ops when no `.worktreeinclude` file
+ * exists. Never overwrites a file that already exists at the destination.
+ *
+ * @param gitRoot - Absolute path to the main checkout (repository root)
+ * @param targetWorktreePath - Absolute path to the newly created worktree
+ */
+export declare function copyWorktreeIncludeFiles(gitRoot: string, targetWorktreePath: string): void;