yggtree 1.4.3 → 1.4.5

package/dist/commands/wt/delete.js

@@ -1,19 +1,21 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log, createSpinner, timeAgo } from '../../lib/ui.js';
 import { detectWorktreeType, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
 export async function deleteCommand(options = {}) {
     try {
         const currentWorktreePath = await getRepoRoot();
         const worktrees = await listWorktrees();
+        const managedRoot = await getManagedWorktreesRoot();
         let showAll = options.all;
         if (showAll === undefined) {
             const { includeExternal } = await inquirer.prompt([
                 {
                     type: 'confirm',
                     name: 'includeExternal',
-                    message: 'Include external linked worktrees (outside ~/.yggtree)?',
+                    message: 'Include external linked worktrees (outside the managed root)?',
                     default: false,
                 },
             ]);
@@ -27,7 +29,7 @@ export async function deleteCommand(options = {}) {
                 const isCurrentWorktree = wt.path === currentWorktreePath;
                 return !isMainWorktree && !isCurrentWorktree;
             }
-            return isManagedWorktreePath(wt.path);
+            return isManagedWorktreePath(wt.path, managedRoot);
         });
         if (deletableWts.length === 0) {
             log.info(includeAll
@@ -38,11 +40,11 @@ export async function deleteCommand(options = {}) {
         const choices = await Promise.all(deletableWts.map(async (wt) => {
             const [activity, type] = await Promise.all([
                 getLastActivity(wt.path),
-                detectWorktreeType(wt, mainWorktreePath || ''),
+                detectWorktreeType(wt, mainWorktreePath || '', managedRoot),
             ]);
             const branchName = getWorktreeBranchName(wt);
             const active = activity ? chalk.magenta(timeAgo(activity)) : chalk.dim('—');
-            const displayPath = formatWorktreeDisplayPath(wt.path);
+            const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
             return {
                 name: `${formatWorktreeType(type)} ${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active} ${chalk.dim('·')} ${chalk.dim(displayPath)}`,
                 value: wt.path,
@@ -62,7 +64,7 @@ export async function deleteCommand(options = {}) {
             return;
         }
         const count = selectedPaths.length;
-        const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p));
+        const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p, managedRoot));
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
@@ -76,7 +78,7 @@ export async function deleteCommand(options = {}) {
             return;
         }
         for (const wtPath of selectedPaths) {
-            const worktreeName = formatWorktreeDisplayPath(wtPath);
+            const worktreeName = formatWorktreeDisplayPath(wtPath, managedRoot);
             const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
             try {
                 await removeWorktree(wtPath);

package/dist/commands/wt/enter.js

@@ -3,6 +3,7 @@ import { spawn } from 'child_process';
 import { execa } from 'execa';
 import chalk from 'chalk';
 import { listWorktrees } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log, ui } from '../../lib/ui.js';
 import { ensureRepoContext } from '../../lib/repo-context.js';
 import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
@@ -40,13 +41,14 @@ export async function enterCommand(wtName, options = {}) {
         await ensureRepoContext();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
+        const managedRoot = await getManagedWorktreesRoot();
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
         }
         let targetWt;
         if (wtName) {
-            targetWt = findWorktreeByName(worktrees, wtName);
+            targetWt = findWorktreeByName(worktrees, wtName, managedRoot);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -56,9 +58,9 @@ export async function enterCommand(wtName, options = {}) {
             // Interactive Selection
             const terminalColumns = process.stdout.columns || 100;
             const choices = await Promise.all(worktrees.map(async (wt) => {
-                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const type = await detectWorktreeType(wt, mainWorktreePath, managedRoot);
                 const branchName = getWorktreeBranchName(wt);
-                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
                 return {
                     name: formatChoiceLabel(type, branchName, displayPath, terminalColumns),
                     value: wt

package/dist/commands/wt/exec.js

@@ -1,6 +1,7 @@
 import inquirer from 'inquirer';
 import { execa } from 'execa';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log } from '../../lib/ui.js';
 import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function execCommand(wtName, commandArgs) {
@@ -10,12 +11,13 @@ export async function execCommand(wtName, commandArgs) {
     try {
         await getRepoRoot();
         const worktrees = await listWorktrees();
+        const managedRoot = await getManagedWorktreesRoot();
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
         }
         if (wtName) {
-            targetWt = findWorktreeByName(worktrees, wtName);
+            targetWt = findWorktreeByName(worktrees, wtName, managedRoot);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -25,7 +27,7 @@ export async function execCommand(wtName, commandArgs) {
             // Interactive Selection
             const choices = worktrees.map(wt => {
                 const branchName = getWorktreeBranchName(wt);
-                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
                 return {
                     name: `${branchName.padEnd(20)} ${displayPath}`,
                     value: wt

package/dist/commands/wt/handoff.js

@@ -0,0 +1,7 @@
+import { createSandboxCommand } from './create-sandbox.js';
+export async function handoffCommand(options = {}) {
+    await createSandboxCommand({
+        ...options,
+        carry: true,
+    });
+}

package/dist/commands/wt/list.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
 import { listWorktrees, getRepoRoot, isGitClean, getLastActivity, isGhAvailable, getPrStatusBatch } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log, timeAgo } from '../../lib/ui.js';
 import { detectWorktreeType, formatWorktreeType, formatPrStatus, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
 export async function listCommand() {
@@ -7,6 +8,7 @@ export async function listCommand() {
         await getRepoRoot(); // Verify we are in a git repo
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
+        const managedRoot = await getManagedWorktreesRoot();
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
@@ -24,7 +26,7 @@ export async function listCommand() {
         console.log(chalk.dim('  ' + '-'.repeat(showPr ? 90 : 70)));
         const rows = await Promise.all(worktrees.map(async (wt, index) => {
             const [typeKey, isClean, lastActive] = await Promise.all([
-                detectWorktreeType(wt, mainWorktreePath),
+                detectWorktreeType(wt, mainWorktreePath, managedRoot),
                 isGitClean(wt.path),
                 getLastActivity(wt.path),
             ]);

package/dist/commands/wt/open.js

@@ -5,6 +5,7 @@ import fs from 'fs-extra';
 import { constants as fsConstants } from 'fs';
 import { execa } from 'execa';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log, ui } from '../../lib/ui.js';
 import { ensureAutocompletePrompt } from '../../lib/prompt.js';
 import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
@@ -24,10 +25,15 @@ export const OPEN_TOOL_CANDIDATES = [
         kind: 'app',
         aliases: ['codex', 'codex-app'],
         bundleId: 'com.openai.codex',
+        requiredCommand: 'codex',
     },
+    { id: 'cmux', name: 'Cmux Panel', command: 'cmux', kind: 'terminal', aliases: ['cmux', 'cmux-panel'] },
+    { id: 'tmux', name: 'Tmux Session', command: 'tmux', kind: 'terminal', aliases: ['tmux', 'tmux-session'] },
 ];
 const OTHER_COMMAND_ACTION = '__other_command__';
 const NO_OPEN_ACTION = '__no_open__';
+const OPEN_ACTION_PAGE_SIZE = 16;
+const CMUX_TERMINAL_STARTUP_DELAY_MS = 350;
 const yggtreeAccent = chalk.hex('#DEADED');
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
@@ -61,9 +67,6 @@ function formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumn
 function openRail() {
     return yggtreeAccent('│');
 }
-function openSectionLabel(label) {
-    return `${yggtreeAccent('┌')} ${chalk.bold(label)}`;
-}
 function formatOpenColumns(name, command, detail) {
     const paddedName = name.padEnd(16);
     const paddedCommand = command.padEnd(13);
@@ -73,6 +76,51 @@ function formatOpenColumns(name, command, detail) {
 export function formatOpenToolChoice(tool) {
     return formatOpenColumns(tool.name, tool.command, '');
 }
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatTerminalSessionName(wtPath) {
+    const basename = path.basename(wtPath) || 'worktree';
+    const slug = basename.toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+    return `yggtree-${slug || 'worktree'}`.slice(0, 80);
+}
+export function buildTmuxLaunchCommand(wtPath, env = process.env) {
+    const sessionName = formatTerminalSessionName(wtPath);
+    if (env.TMUX) {
+        return {
+            executable: 'tmux',
+            args: ['new-window', '-c', wtPath, '-n', sessionName],
+        };
+    }
+    return {
+        executable: 'tmux',
+        args: ['new-session', '-A', '-s', sessionName, '-c', wtPath],
+    };
+}
+export function buildCmuxNewPaneCommand() {
+    return {
+        executable: 'cmux',
+        args: ['new-pane', '--type', 'terminal', '--direction', 'right', '--focus', 'true'],
+    };
+}
+export function parseCmuxSurfaceRef(output) {
+    return output.match(/\bsurface:\S+/)?.[0];
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function buildCmuxSendCommand(surfaceRef, wtPath) {
+    return {
+        executable: 'cmux',
+        args: ['send', '--surface', surfaceRef, `cd ${shellQuote(wtPath)}`],
+    };
+}
+export function buildCmuxEnterCommand(surfaceRef) {
+    return {
+        executable: 'cmux',
+        args: ['send-key', '--surface', surfaceRef, 'Enter'],
+    };
+}
 export function formatOpenSpecialChoice(value, allowShellAction) {
     if (value === OTHER_COMMAND_ACTION) {
         return formatOpenColumns('Other command', 'custom', 'run first, then stay in shell');
@@ -129,16 +177,27 @@ export async function macOSAppBundleExists(bundleId) {
 export async function detectInstalledOpenTools() {
     const checks = await Promise.all(OPEN_TOOL_CANDIDATES.map(async (tool) => ({
         tool,
-        exists: tool.bundleId
-            ? await macOSAppBundleExists(tool.bundleId)
-            : await commandExists(tool.command),
+        exists: await isOpenToolAvailable(tool),
     })));
     return checks
         .filter(check => check.exists)
         .map(check => check.tool);
 }
-function resolveWorktreeByName(worktrees, wtName) {
-    return findWorktreeByName(worktrees, wtName);
+export async function isOpenToolAvailable(tool, checks = {}) {
+    const hasCommand = checks.commandExists || commandExists;
+    const hasAppBundle = checks.macOSAppBundleExists || macOSAppBundleExists;
+    if (tool.requiredCommand) {
+        const commandAvailable = await hasCommand(tool.requiredCommand);
+        if (!commandAvailable)
+            return false;
+    }
+    if (tool.bundleId) {
+        return hasAppBundle(tool.bundleId);
+    }
+    return hasCommand(tool.command);
+}
+function resolveWorktreeByName(worktrees, wtName, managedRoot) {
+    return findWorktreeByName(worktrees, wtName, managedRoot);
 }
 export function resolveOpenToolOption(input, installed) {
     const normalized = input.trim().toLowerCase();
@@ -146,8 +205,21 @@ export function resolveOpenToolOption(input, installed) {
         tool.command.toLowerCase() === normalized ||
         tool.aliases?.some(alias => alias.toLowerCase() === normalized));
 }
+export function resolveOpenToolCandidate(input) {
+    const normalized = input.trim().toLowerCase();
+    return OPEN_TOOL_CANDIDATES.find(tool => tool.id === normalized ||
+        tool.command.toLowerCase() === normalized ||
+        tool.aliases?.some(alias => alias.toLowerCase() === normalized));
+}
+async function resolveKnownOpenToolOption(input) {
+    const candidate = resolveOpenToolCandidate(input);
+    if (!candidate)
+        return undefined;
+    const exists = await isOpenToolAvailable(candidate);
+    return exists ? candidate : undefined;
+}
 export async function resolveOpenToolAction(input, installed) {
-    let chosenTool = resolveOpenToolOption(input, installed);
+    let chosenTool = resolveOpenToolOption(input, installed) || await resolveKnownOpenToolOption(input);
     if (!chosenTool && await commandExists(input)) {
         chosenTool = {
             id: 'custom',
@@ -159,27 +231,11 @@ export async function resolveOpenToolAction(input, installed) {
     return chosenTool ? { type: 'tool', tool: chosenTool } : undefined;
 }
 export async function promptOpenToolSelection(installedTools, message = 'Select tool to open:') {
-    const ideChoices = installedTools
-        .filter(tool => tool.kind === 'editor')
-        .map(tool => ({
-        name: formatOpenToolChoice(tool),
-        value: tool,
-    }));
-    const appChoices = installedTools
-        .filter(tool => tool.kind === 'app')
+    const choices = installedTools
         .map(tool => ({
         name: formatOpenToolChoice(tool),
         value: tool,
     }));
-    const choices = [];
-    if (ideChoices.length > 0) {
-        choices.push(new inquirer.Separator(openSectionLabel('Editors & IDEs')));
-        choices.push(...ideChoices);
-    }
-    if (appChoices.length > 0) {
-        choices.push(new inquirer.Separator(openSectionLabel('Apps')));
-        choices.push(...appChoices);
-    }
     const { selectedTool } = await inquirer.prompt([
         {
             type: 'list',
@@ -187,79 +243,55 @@ export async function promptOpenToolSelection(installedTools, message = 'Select
             message,
             choices,
             loop: false,
-            pageSize: 10,
+            pageSize: OPEN_ACTION_PAGE_SIZE,
         },
     ]);
     return selectedTool;
 }
-export function buildOpenActionsFromSelection(selectedValues, installedTools, otherCommand) {
-    if (selectedValues.includes(NO_OPEN_ACTION))
+export function buildOpenActionsFromSelection(selectedValue, installedTools, otherCommand) {
+    if (selectedValue === NO_OPEN_ACTION)
         return [];
-    const actions = selectedValues
-        .filter(value => value.startsWith('tool:'))
-        .map(value => installedTools.find(tool => `tool:${tool.id}` === value))
-        .filter((tool) => Boolean(tool))
-        .map(tool => ({ type: 'tool', tool }));
-    if (selectedValues.includes(OTHER_COMMAND_ACTION) && otherCommand?.trim()) {
-        actions.push({ type: 'other-command', command: otherCommand.trim() });
+    if (selectedValue.startsWith('tool:')) {
+        const tool = installedTools.find(candidate => `tool:${candidate.id}` === selectedValue);
+        return tool ? [{ type: 'tool', tool }] : [];
     }
-    return actions;
-}
-export function validateOpenActionSelection(selectedValues) {
-    if (selectedValues.includes(NO_OPEN_ACTION) && selectedValues.length > 1) {
-        return 'Choose either "Nothing" or one or more actions, not both.';
+    if (selectedValue === OTHER_COMMAND_ACTION && otherCommand?.trim()) {
+        return [{ type: 'other-command', command: otherCommand.trim() }];
     }
-    return true;
+    return [];
 }
-export async function promptOpenActions(installedTools, options = {}) {
-    const allowShellAction = options.allowShellAction ?? true;
-    const choices = [];
-    if (installedTools.length > 0) {
-        const editorTools = installedTools.filter(tool => tool.kind === 'editor');
-        const appTools = installedTools.filter(tool => tool.kind === 'app');
-        if (editorTools.length > 0) {
-            choices.push(new inquirer.Separator(openSectionLabel('Editors & IDEs')));
-            choices.push(...editorTools.map(tool => ({
-                name: formatOpenToolChoice(tool),
-                value: `tool:${tool.id}`,
-            })));
-        }
-        if (appTools.length > 0) {
-            choices.push(new inquirer.Separator(openSectionLabel('Apps')));
-            choices.push(...appTools.map(tool => ({
-                name: formatOpenToolChoice(tool),
-                value: `tool:${tool.id}`,
-            })));
-        }
-    }
+export function buildOpenActionChoices(installedTools, allowShellAction) {
+    const choices = installedTools.map(tool => ({
+        name: formatOpenToolChoice(tool),
+        value: `tool:${tool.id}`,
+    }));
     if (allowShellAction) {
-        if (choices.length > 0)
-            choices.push(new inquirer.Separator(' '));
-        choices.push(new inquirer.Separator(openSectionLabel('Shell')));
         choices.push({
             name: formatOpenSpecialChoice(OTHER_COMMAND_ACTION, allowShellAction),
             value: OTHER_COMMAND_ACTION,
         });
     }
-    if (choices.length > 0)
-        choices.push(new inquirer.Separator(' '));
     choices.push({
         name: formatOpenSpecialChoice(NO_OPEN_ACTION, allowShellAction),
         value: NO_OPEN_ACTION,
     });
-    const { selectedValues } = await inquirer.prompt([
+    return choices;
+}
+export async function promptOpenActions(installedTools, options = {}) {
+    const allowShellAction = options.allowShellAction ?? true;
+    const choices = buildOpenActionChoices(installedTools, allowShellAction);
+    const { selectedValue } = await inquirer.prompt([
         {
-            type: 'checkbox',
-            name: 'selectedValues',
+            type: 'list',
+            name: 'selectedValue',
             message: options.message || 'Open anything before entering the shell?',
             choices,
             loop: false,
-            pageSize: 10,
-            validate: validateOpenActionSelection,
+            pageSize: OPEN_ACTION_PAGE_SIZE,
         },
     ]);
     let otherCommand;
-    if (selectedValues.includes(OTHER_COMMAND_ACTION)) {
+    if (selectedValue === OTHER_COMMAND_ACTION) {
         const answer = await inquirer.prompt([
             {
                 type: 'input',
@@ -270,9 +302,39 @@ export async function promptOpenActions(installedTools, options = {}) {
         ]);
         otherCommand = answer.otherCommand;
     }
-    return buildOpenActionsFromSelection(selectedValues, installedTools, otherCommand);
+    return buildOpenActionsFromSelection(selectedValue, installedTools, otherCommand);
 }
 export async function launchOpenTool(tool, wtPath) {
+    if (tool.id === 'cmux') {
+        const newPaneCommand = buildCmuxNewPaneCommand();
+        const newPaneResult = await execa(newPaneCommand.executable, newPaneCommand.args, {
+            cwd: wtPath,
+        });
+        const surfaceRef = parseCmuxSurfaceRef(newPaneResult.stdout);
+        if (!surfaceRef) {
+            throw new Error(`Cmux did not return a terminal surface handle: ${newPaneResult.stdout || '<empty output>'}`);
+        }
+        await delay(CMUX_TERMINAL_STARTUP_DELAY_MS);
+        const sendCommand = buildCmuxSendCommand(surfaceRef, wtPath);
+        await execa(sendCommand.executable, sendCommand.args, {
+            cwd: wtPath,
+            stdio: 'ignore',
+        });
+        const enterCommand = buildCmuxEnterCommand(surfaceRef);
+        await execa(enterCommand.executable, enterCommand.args, {
+            cwd: wtPath,
+            stdio: 'ignore',
+        });
+        return;
+    }
+    if (tool.id === 'tmux') {
+        const { executable, args } = buildTmuxLaunchCommand(wtPath);
+        await execa(executable, args, {
+            cwd: wtPath,
+            stdio: 'inherit',
+        });
+        return;
+    }
     const { executable, args } = buildOpenToolLaunchCommand(tool, wtPath);
     await execa(executable, args, {
         cwd: wtPath,
@@ -280,6 +342,12 @@ export async function launchOpenTool(tool, wtPath) {
     });
 }
 export function buildOpenToolLaunchCommand(tool, wtPath) {
+    if (tool.id === 'codex-app') {
+        return {
+            executable: 'codex',
+            args: ['app', wtPath],
+        };
+    }
     if (tool.bundleId) {
         return {
             executable: '/usr/bin/open',
@@ -292,10 +360,14 @@ export function buildOpenToolLaunchCommand(tool, wtPath) {
     };
 }
 export async function runOpenActions(actions, wtPath, options = {}) {
+    let openedTerminal = false;
     for (const action of actions) {
         if (action.type === 'tool' && action.tool) {
             log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(action.tool.name)}...`);
             await launchOpenTool(action.tool, wtPath);
+            if (action.tool.kind === 'terminal') {
+                openedTerminal = true;
+            }
         }
     }
     const shellAction = actions.find(action => action.type === 'other-command');
@@ -303,7 +375,7 @@ export async function runOpenActions(actions, wtPath, options = {}) {
         await enterCommand(wtPath, { exec: shellAction.command });
         return;
     }
-    if (options.enter !== false) {
+    if (options.enter !== false && !openedTerminal) {
         await enterCommand(wtPath);
     }
 }
@@ -312,13 +384,14 @@ export async function openCommand(wtName, options = {}) {
         await getRepoRoot();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
+        const managedRoot = await getManagedWorktreesRoot();
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
         }
         let targetWt;
         if (wtName) {
-            targetWt = resolveWorktreeByName(worktrees, wtName);
+            targetWt = resolveWorktreeByName(worktrees, wtName, managedRoot);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -328,9 +401,9 @@ export async function openCommand(wtName, options = {}) {
             ensureAutocompletePrompt();
             const terminalColumns = process.stdout.columns || 100;
             const candidates = await Promise.all(worktrees.map(async (wt) => {
-                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const type = await detectWorktreeType(wt, mainWorktreePath, managedRoot);
                 const branchName = getWorktreeBranchName(wt);
-                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
                 const rawType = type.toLowerCase();
                 const rawDisplayPath = displayPath.toLowerCase();
                 const rawBranchName = branchName.toLowerCase();

package/dist/commands/wt/path.js

@@ -1,18 +1,20 @@
 import inquirer from 'inquirer';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log } from '../../lib/ui.js';
 import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function pathCommand(wtName) {
     try {
         await getRepoRoot();
         const worktrees = await listWorktrees();
+        const managedRoot = await getManagedWorktreesRoot();
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
         }
         let targetWt;
         if (wtName) {
-            targetWt = findWorktreeByName(worktrees, wtName);
+            targetWt = findWorktreeByName(worktrees, wtName, managedRoot);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -22,7 +24,7 @@ export async function pathCommand(wtName) {
             // Interactive Selection
             const choices = worktrees.map(wt => {
                 const branchName = getWorktreeBranchName(wt);
-                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
                 return {
                     name: `${branchName.padEnd(20)} ${displayPath}`,
                     value: wt