ccmanager 4.3.1 → 4.4.0

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') {
@@ -837,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) => {

package/dist/types/index.d.ts

@@ -40,6 +40,7 @@ export interface Session {
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;
+    presetId: string | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
     /**
@@ -75,8 +76,8 @@ export type MenuAction = {
     sessionId: string;
 } | {
     type: 'sessionActions';
-    session: Session;
-    worktreePath: string;
+    worktree: Worktree;
+    session?: Session;
 } | {
     type: 'deleteWorktree';
 } | {

package/dist/utils/configDir.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Path of ccmanager's configuration/state directory. Does not touch the
+ * filesystem.
+ */
+export declare function getConfigDir(): string;
+/**
+ * Path of ccmanager's configuration/state directory, creating it first if it
+ * does not exist yet.
+ */
+export declare function ensureConfigDir(): string;

package/dist/utils/configDir.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Single source of truth for the location of ccmanager's own
+ * configuration/state directory (`~/.config/ccmanager`, or the Windows
+ * equivalent under APPDATA). Every module that needs to read or write a file
+ * belonging to ccmanager itself resolves the directory through here so the
+ * location is defined in exactly one place.
+ */
+import { homedir } from 'os';
+import path from 'path';
+import { existsSync, mkdirSync } from 'fs';
+/**
+ * Path of ccmanager's configuration/state directory. Does not touch the
+ * filesystem.
+ */
+export function getConfigDir() {
+    const homeDir = homedir();
+    return process.platform === 'win32'
+        ? path.join(process.env['APPDATA'] || path.join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+        : path.join(homeDir, '.config', 'ccmanager');
+}
+/**
+ * Path of ccmanager's configuration/state directory, creating it first if it
+ * does not exist yet.
+ */
+export function ensureConfigDir() {
+    const configDir = getConfigDir();
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    return configDir;
+}

package/dist/utils/errorMessage.d.ts

@@ -0,0 +1,7 @@
+import { type AppError } from '../types/errors.js';
+/**
+ * Human-readable one-line rendering of an application error, for display in the
+ * TUI and for log lines. Each error type carries different fields, so the text
+ * is composed per type via the `_tag` discriminator.
+ */
+export declare function formatErrorMessage(error: AppError): string;

package/dist/utils/errorMessage.js

@@ -0,0 +1,19 @@
+/**
+ * Human-readable one-line rendering of an application error, for display in the
+ * TUI and for log lines. Each error type carries different fields, so the text
+ * is composed per type via the `_tag` discriminator.
+ */
+export function formatErrorMessage(error) {
+    switch (error._tag) {
+        case 'ProcessError':
+            return `Process error: ${error.message}`;
+        case 'ConfigError':
+            return `Configuration error (${error.reason}): ${error.details}`;
+        case 'GitError':
+            return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+        case 'FileSystemError':
+            return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+        case 'ValidationError':
+            return `Validation failed for ${error.field}: ${error.constraint}`;
+    }
+}

package/dist/utils/filterByQuery.test.js

@@ -8,6 +8,7 @@ const makeItem = (searchableName, path) => ({
         hasSession: false,
     },
     baseLabel: searchableName,
+    status: '',
     searchableName,
     fileChanges: '',
     aheadBehind: '',
@@ -15,6 +16,7 @@ const makeItem = (searchableName, path) => ({
     lastCommitDate: '',
     lengths: {
         base: 0,
+        status: 0,
         fileChanges: 0,
         aheadBehind: 0,
         parentBranch: 0,

package/dist/utils/gitUtils.d.ts

@@ -15,3 +15,4 @@ export declare function hasUncommittedChanges(worktreePath: string): boolean;
  * @returns The absolute path to the git repository root, or null if not in a git repo
  */
 export declare function getGitRepositoryRoot(cwd: string): string | null;
+export declare function getCurrentRepositoryRoot(): string;

package/dist/utils/gitUtils.js

@@ -62,3 +62,18 @@ export function getGitRepositoryRoot(cwd) {
         return null;
     }
 }
+/**
+ * Repository root of the directory ccmanager was started in.
+ *
+ * Cached after the first call: it cannot change while the process runs, and
+ * both the code that records sessions for restore and the code that looks them
+ * up need the exact same value to agree on which project a session belongs to.
+ */
+let currentRepositoryRoot;
+export function getCurrentRepositoryRoot() {
+    if (currentRepositoryRoot === undefined) {
+        const cwd = process.cwd();
+        currentRepositoryRoot = getGitRepositoryRoot(cwd) ?? path.resolve(cwd);
+    }
+    return currentRepositoryRoot;
+}

package/dist/utils/hookExecutor.test.js

@@ -393,6 +393,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -453,6 +454,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -511,6 +513,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -571,6 +574,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),

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;

package/dist/utils/worktreeInclude.js

@@ -0,0 +1,100 @@
+import { execSync } from 'child_process';
+import { existsSync, statSync, mkdirSync, cpSync } from 'fs';
+import path from 'path';
+import { logger } from './logger.js';
+/**
+ * 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 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 function resolveWorktreeIncludeFiles(gitRoot) {
+    const includeFilePath = path.join(gitRoot, WORKTREE_INCLUDE_FILENAME);
+    if (!existsSync(includeFilePath) || !statSync(includeFilePath).isFile()) {
+        return [];
+    }
+    let candidatesOutput;
+    try {
+        // --exclude-from applies ONLY .worktreeinclude's own patterns (no
+        // --exclude-standard), so this lists untracked files matching those
+        // patterns regardless of whether the repository's real .gitignore
+        // covers them.
+        candidatesOutput = execSync(`git ls-files --others --ignored --exclude-from="${WORKTREE_INCLUDE_FILENAME}" -z`, { cwd: gitRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    }
+    catch (error) {
+        logger.error('Failed to resolve .worktreeinclude candidates', {
+            gitRoot,
+            error: String(error),
+        });
+        return [];
+    }
+    const candidates = candidatesOutput
+        .split('\0')
+        .filter(entry => entry.length > 0);
+    if (candidates.length === 0) {
+        return [];
+    }
+    // Confirm each candidate against the repository's real ignore rules.
+    // git check-ignore --stdin echoes back only the paths it is asked about
+    // that ARE ignored, so this is the second half of the intersection.
+    let ignoredOutput;
+    try {
+        ignoredOutput = execSync('git check-ignore --stdin -z', {
+            cwd: gitRoot,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            input: candidates.join('\0') + '\0',
+        });
+    }
+    catch (error) {
+        // Exit code 1 (no matches) surfaces as a thrown error; anything already
+        // written to stdout before that is still the correct partial result.
+        const execError = error;
+        ignoredOutput = execError.stdout ?? '';
+    }
+    return ignoredOutput.split('\0').filter(entry => entry.length > 0);
+}
+/**
+ * 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 function copyWorktreeIncludeFiles(gitRoot, targetWorktreePath) {
+    const relativePaths = resolveWorktreeIncludeFiles(gitRoot);
+    for (const relativePath of relativePaths) {
+        const sourcePath = path.join(gitRoot, relativePath);
+        const targetPath = path.join(targetWorktreePath, relativePath);
+        if (!existsSync(sourcePath)) {
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            logger.warn('Skipping .worktreeinclude copy, destination already exists', {
+                relativePath,
+                targetPath,
+            });
+            continue;
+        }
+        mkdirSync(path.dirname(targetPath), { recursive: true });
+        cpSync(sourcePath, targetPath, { recursive: true, preserveTimestamps: true });
+    }
+}

package/dist/utils/worktreeInclude.test.d.ts

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

package/dist/utils/worktreeInclude.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { resolveWorktreeIncludeFiles, copyWorktreeIncludeFiles, } from './worktreeInclude.js';
+describe('worktreeInclude', () => {
+    const testDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'ccmanager-worktreeinclude-test-')));
+    let repoCount = 0;
+    let gitRoot;
+    beforeEach(() => {
+        repoCount += 1;
+        gitRoot = path.join(testDir, `repo-${repoCount}`);
+        fs.mkdirSync(gitRoot, { recursive: true });
+        execSync('git init', { cwd: gitRoot });
+        execSync('git config user.email "test@test.com"', { cwd: gitRoot });
+        execSync('git config user.name "Test User"', { cwd: gitRoot });
+        fs.writeFileSync(path.join(gitRoot, 'README.md'), '# repo');
+        execSync('git add README.md', { cwd: gitRoot });
+        execSync('git commit -m "initial commit"', { cwd: gitRoot });
+    });
+    afterAll(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it('returns an empty list when no .worktreeinclude file exists', () => {
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('selects a file that matches .worktreeinclude and is gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual(['.env']);
+    });
+    it('excludes a file that matches .worktreeinclude but is not gitignored', () => {
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'notes.txt\n');
+        fs.writeFileSync(path.join(gitRoot, 'notes.txt'), 'not ignored');
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('excludes a tracked file even when it matches .worktreeinclude', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'tracked.env\n');
+        fs.writeFileSync(path.join(gitRoot, 'tracked.env'), 'SECRET=1');
+        execSync('git add -f tracked.env', { cwd: gitRoot });
+        execSync('git commit -m "track tracked.env"', { cwd: gitRoot });
+        expect(resolveWorktreeIncludeFiles(gitRoot)).toEqual([]);
+    });
+    it('resolves every file under a directory glob pattern', () => {
+        fs.writeFileSync(path.join(gitRoot, '.gitignore'), 'certs/\n');
+        fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), 'certs/local/**\n');
+        fs.mkdirSync(path.join(gitRoot, 'certs', 'local', 'nested'), {
+            recursive: true,
+        });
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+        fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'nested', 'key.pem'), 'key');
+        expect(resolveWorktreeIncludeFiles(gitRoot).sort()).toEqual([
+            'certs/local/cert.pem',
+            'certs/local/nested/key.pem',
+        ]);
+    });
+    describe('copyWorktreeIncludeFiles', () => {
+        it('copies selected files into the target worktree, recreating nested directories', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\ncerts/\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\ncerts/local/**\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SECRET=1');
+            fs.mkdirSync(path.join(gitRoot, 'certs', 'local'), { recursive: true });
+            fs.writeFileSync(path.join(gitRoot, 'certs', 'local', 'cert.pem'), 'cert');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('SECRET=1');
+            expect(fs.readFileSync(path.join(targetWorktreePath, 'certs', 'local', 'cert.pem'), 'utf8')).toBe('cert');
+        });
+        it('does not overwrite a file that already exists at the destination', () => {
+            fs.writeFileSync(path.join(gitRoot, '.gitignore'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.worktreeinclude'), '.env\n');
+            fs.writeFileSync(path.join(gitRoot, '.env'), 'SOURCE');
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            fs.writeFileSync(path.join(targetWorktreePath, '.env'), 'EXISTING');
+            copyWorktreeIncludeFiles(gitRoot, targetWorktreePath);
+            expect(fs.readFileSync(path.join(targetWorktreePath, '.env'), 'utf8')).toBe('EXISTING');
+        });
+        it('is a no-op when no .worktreeinclude file exists', () => {
+            const targetWorktreePath = path.join(testDir, `target-${repoCount}`);
+            fs.mkdirSync(targetWorktreePath, { recursive: true });
+            expect(() => copyWorktreeIncludeFiles(gitRoot, targetWorktreePath)).not.toThrow();
+            expect(fs.readdirSync(targetWorktreePath)).toEqual([]);
+        });
+    });
+});

package/dist/utils/worktreeUtils.d.ts

@@ -6,6 +6,7 @@ export interface SessionItem {
     worktree: Worktree;
     session?: Session;
     baseLabel: string;
+    status: string;
     searchableName: string;
     fileChanges: string;
     aheadBehind: string;
@@ -14,6 +15,7 @@ export interface SessionItem {
     error?: string;
     lengths: {
         base: number;
+        status: number;
         fileChanges: number;
         aheadBehind: number;
         parentBranch: number;
@@ -66,15 +68,47 @@ export declare function prepareSessionItems(worktrees: Worktree[], sessions: Ses
     sortByLastSession?: boolean;
 }): SessionItem[];
 /**
- * Calculates column positions based on content widths.
+ * Column start positions for one rendered list, plus how the session state tag
+ * (e.g. "[○ Idle]") is placed.
  */
-export declare function calculateColumnPositions(items: SessionItem[]): {
+export interface ColumnPositions {
     fileChanges: number;
     aheadBehind: number;
     parentBranch: number;
+    status: number;
     lastCommitDate: number;
-};
+    /**
+     * true: the state tag gets its own column at `status`, so every row's tag
+     * starts at the same horizontal position, directly left of the commit date.
+     * false: the state tag is appended right after the branch name (the layout
+     * used before this column existed), because the aligned layout would not fit
+     * the terminal width given to calculateColumnPositions.
+     */
+    alignStatus: boolean;
+}
+/**
+ * Calculates column positions based on content widths.
+ *
+ * `availableWidth` is the number of terminal columns the label may occupy
+ * (i.e. terminal width minus whatever prefix the caller prepends). When the
+ * aligned-status layout would not fit in it, the layout falls back to appending
+ * the state tag to the name, which is narrower. Omit it to always align.
+ */
+export declare function calculateColumnPositions(items: SessionItem[], availableWidth?: number): ColumnPositions;
 /**
  * Assembles the final worktree label with proper column alignment
  */
-export declare function assembleSessionLabel(item: SessionItem, columns: ReturnType<typeof calculateColumnPositions>): string;
+export declare function assembleSessionLabel(item: SessionItem, columns: ColumnPositions): string;
+/**
+ * Whether a worktree may be deleted by CCManager.
+ *
+ * Two worktrees are off limits:
+ * - the main worktree, because git refuses to remove it and the repository
+ *   would be left without a checkout;
+ * - the worktree that contains the current working directory, because removing
+ *   the directory CCManager is running in breaks the running process.
+ *
+ * Single source of truth for the rule, shared by the multi-select delete screen
+ * and the per-row delete action.
+ */
+export declare function isDeletableWorktree(worktree: Pick<Worktree, 'path' | 'isMainWorktree'>, cwd?: string): boolean;