yggtree 1.4.2 → 1.4.3

package/dist/commands/wt/create.js

@@ -1,13 +1,15 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
+import { getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { ensureAutocompletePrompt } from '../../lib/prompt.js';
+import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
+import { ensureRepoContext } from '../../lib/repo-context.js';
 import { enterCommand } from './enter.js';
-import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
+import { detectInstalledOpenTools, promptOpenActions, resolveOpenToolAction, runOpenActions, } from './open.js';
 import { execa } from 'execa';
 import fs from 'fs-extra';
 function toSlug(value) {
@@ -16,7 +18,7 @@ function toSlug(value) {
         .replace(/[\/\\]/g, '-')
         .replace(/\s+/g, '-');
 }
-async function listBranchCandidates() {
+export async function listBranchCandidates() {
     const [localRefs, remoteRefs] = await Promise.all([
         execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/heads']),
         execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/remotes/origin']),
@@ -32,21 +34,26 @@ async function listBranchCandidates() {
         .filter(ref => ref !== 'origin/HEAD' && !ref.endsWith('/HEAD'))
         .map(ref => ref.replace(/^origin\//, ''));
     const localSet = new Set(localBranches);
-    const remoteOnly = [...new Set(remoteBranches)].filter(branch => !localSet.has(branch));
+    const uniqueRemoteBranches = [...new Set(remoteBranches)];
     const localCandidates = localBranches.map(branchName => ({
         branchName,
         checkoutRef: branchName,
         createLocalBranch: false,
         source: 'local',
+        attachedBranchName: branchName,
+        sourceLabel: 'local',
     }));
-    const remoteCandidates = remoteOnly.map(branchName => ({
+    const remoteCandidates = uniqueRemoteBranches.map(branchName => ({
         branchName,
         checkoutRef: `origin/${branchName}`,
-        createLocalBranch: true,
+        createLocalBranch: !localSet.has(branchName),
         source: 'remote',
+        attachedBranchName: localSet.has(branchName) ? undefined : branchName,
+        sourceLabel: localSet.has(branchName) ? 'remote tip, detached' : 'remote, creates local branch',
     }));
     return [...localCandidates, ...remoteCandidates]
-        .sort((a, b) => a.branchName.localeCompare(b.branchName));
+        .sort((a, b) => a.branchName.localeCompare(b.branchName) ||
+        a.checkoutRef.localeCompare(b.checkoutRef));
 }
 function resolveCandidateFromRef(ref, candidates) {
     const trimmedRef = ref.trim();
@@ -54,18 +61,23 @@ function resolveCandidateFromRef(ref, candidates) {
         return undefined;
     if (trimmedRef.startsWith('origin/')) {
         const branchName = trimmedRef.replace(/^origin\//, '');
-        return candidates.find(candidate => candidate.branchName === branchName);
+        return candidates.find(candidate => candidate.branchName === branchName &&
+            candidate.checkoutRef === trimmedRef);
     }
     return candidates.find(candidate => candidate.branchName === trimmedRef ||
         candidate.checkoutRef === trimmedRef);
 }
+export function findExistingBranchWorktree(worktrees, branchName) {
+    if (!branchName)
+        return undefined;
+    return worktrees.find(wt => wt.branch === branchName &&
+        !wt.prunable &&
+        fs.pathExistsSync(wt.path));
+}
 export async function createCommand(options) {
     try {
-        const repoRoot = await getRepoRoot();
+        const repoRoot = await ensureRepoContext();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
-        if (options.enter !== undefined) {
-            log.warning('`--enter` / `--no-enter` is deprecated. Use `--open` / `--no-open` instead.');
-        }
         // 1. Load branches
         const loadingSpinner = createSpinner('Fetching branches...').start();
         await fetchAll();
@@ -96,10 +108,11 @@ export async function createCommand(options) {
                     source: async (_answers, input = '') => {
                         const term = input.trim().toLowerCase();
                         const filtered = term
-                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term))
+                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term) ||
+                                candidate.checkoutRef.toLowerCase().includes(term))
                             : candidates;
                         return filtered.map(candidate => ({
-                            name: `${chalk.yellow(candidate.branchName)} ${chalk.dim(`(${candidate.source})`)}`,
+                            name: `${chalk.yellow(candidate.checkoutRef)} ${chalk.dim(`(${candidate.sourceLabel})`)}`,
                             value: candidate,
                         }));
                     },
@@ -113,39 +126,54 @@ export async function createCommand(options) {
             return;
         }
         const existingWorktrees = await listWorktrees();
-        const existingManagedWorktree = existingWorktrees.find(wt => wt.branch === selectedBranch.branchName && wt.path.startsWith(WORKTREES_ROOT));
-        if (existingManagedWorktree) {
-            log.info(`Branch ${chalk.cyan(selectedBranch.branchName)} is already active in ${ui.path(existingManagedWorktree.path)}.`);
+        const existingBranchWorktree = findExistingBranchWorktree(existingWorktrees, selectedBranch.attachedBranchName);
+        const shouldEnterShell = options.enter !== false;
+        if (existingBranchWorktree) {
+            log.info(`Branch ${chalk.cyan(selectedBranch.branchName)} is already active in ${ui.path(existingBranchWorktree.path)}.`);
             if (options.exec && options.exec.trim()) {
                 log.info('Reusing the existing worktree and running the requested command...');
-                await enterCommand(existingManagedWorktree.path, { exec: options.exec });
+                await enterCommand(existingBranchWorktree.path, { exec: options.exec });
                 return;
             }
-            const shouldOpenExisting = options.open !== undefined
-                ? options.open
-                : options.enter !== undefined
-                    ? options.enter
+            const shouldOpenExisting = options.tool
+                ? true
+                : options.open !== undefined
+                    ? options.open
                     : (await inquirer.prompt([
                         {
                             type: 'confirm',
                             name: 'shouldOpenTool',
-                            message: 'Open a tool in the existing worktree now? (IDE or agent CLI)',
+                            message: shouldEnterShell
+                                ? 'Open anything before entering the existing worktree shell?'
+                                : 'Open anything in the existing worktree?',
                             default: true,
                         },
                     ])).shouldOpenTool;
             if (!shouldOpenExisting) {
-                log.header(`cd "${existingManagedWorktree.path}"`);
+                if (shouldEnterShell) {
+                    await enterCommand(existingBranchWorktree.path);
+                    return;
+                }
+                log.header(`cd "${existingBranchWorktree.path}"`);
                 return;
             }
             const installedTools = await detectInstalledOpenTools();
-            if (installedTools.length === 0) {
-                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
-                log.header(`cd "${existingManagedWorktree.path}"`);
+            log.info('Opening existing worktree instead of creating a duplicate...');
+            const actions = options.tool
+                ? [await resolveOpenToolAction(options.tool, installedTools)].filter((action) => Boolean(action))
+                : await promptOpenActions(installedTools, {
+                    allowShellAction: shouldEnterShell,
+                    message: shouldEnterShell
+                        ? 'Open anything before entering the existing worktree shell?'
+                        : 'Open anything in the existing worktree?',
+                });
+            if (options.tool && actions.length === 0) {
+                const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                log.error(`Tool "${options.tool}" not found.`);
+                log.dim(`Detected tool commands: ${available}`);
                 return;
             }
-            const selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open in the existing worktree:');
-            log.info('Opening existing worktree instead of creating a duplicate...');
-            await launchOpenTool(selectedTool, existingManagedWorktree.path);
+            await runOpenActions(actions, existingBranchWorktree.path, { enter: shouldEnterShell });
             log.success('Existing worktree opened.');
             return;
         }
@@ -170,26 +198,40 @@ export async function createCommand(options) {
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
-                message: 'Open a tool after creation? (IDE or agent CLI)',
+                message: shouldEnterShell
+                    ? 'Open anything before entering the worktree shell?'
+                    : 'Open anything after creation?',
                 default: false,
-                when: options.exec === undefined && options.open === undefined && options.enter === undefined,
+                when: options.exec === undefined && options.open === undefined && options.tool === undefined,
             },
         ]);
         const name = options.name || answers.name;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const shouldOpenTool = options.open !== undefined
-            ? options.open
-            : options.enter !== undefined
-                ? options.enter
+        const shouldOpenTool = options.tool
+            ? true
+            : options.open !== undefined
+                ? options.open
                 : Boolean(answers.shouldOpenTool);
-        let selectedTool;
+        let openActions = [];
         if (options.exec === undefined && shouldOpenTool) {
             const installedTools = await detectInstalledOpenTools();
-            if (installedTools.length === 0) {
-                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            if (options.tool) {
+                const toolAction = await resolveOpenToolAction(options.tool, installedTools);
+                if (!toolAction) {
+                    const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                    log.error(`Tool "${options.tool}" not found.`);
+                    log.dim(`Detected tool commands: ${available}`);
+                    return;
+                }
+                openActions = [toolAction];
             }
             else {
-                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+                openActions = await promptOpenActions(installedTools, {
+                    allowShellAction: shouldEnterShell,
+                    message: shouldEnterShell
+                        ? 'Open anything before entering the worktree shell?'
+                        : 'Open anything after creation?',
+                });
             }
         }
         const slug = toSlug(name);
@@ -223,6 +265,7 @@ export async function createCommand(options) {
             ]);
             return;
         }
+        await promptAndCopyEnvFiles(repoRoot, wtPath);
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
@@ -243,13 +286,12 @@ export async function createCommand(options) {
                 ]);
             }
         }
-        else if (selectedTool) {
+        else {
             try {
-                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
-                await launchOpenTool(selectedTool, wtPath);
+                await runOpenActions(openActions, wtPath, { enter: shouldEnterShell });
             }
             catch (error) {
-                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+                log.warning(`Could not complete post-checkout action: ${error.message}`);
             }
         }
         // 7. Final Output

package/dist/commands/wt/enter.js

@@ -2,10 +2,10 @@ import inquirer from 'inquirer';
 import { spawn } from 'child_process';
 import { execa } from 'execa';
 import chalk from 'chalk';
-import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { listWorktrees } from '../../lib/git.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';
-import { getValidRegisteredRepos } from '../../lib/registry.js';
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
         return '';
@@ -37,31 +37,7 @@ function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
 }
 export async function enterCommand(wtName, options = {}) {
     try {
-        try {
-            await getRepoRoot();
-        }
-        catch {
-            const validRepos = await getValidRegisteredRepos();
-            const repoNames = Object.keys(validRepos);
-            if (repoNames.length === 0) {
-                log.error('Not inside a git repository and no registered realms found.');
-                log.dim('Run `yggtree` inside an existing git project first to register it.');
-                process.exit(1);
-            }
-            console.log(chalk.bold('\n  Not inside a realm. Pick a known one:'));
-            const { selectedRepoName } = await inquirer.prompt([{
-                    type: 'list',
-                    name: 'selectedRepoName',
-                    message: 'Select a realm:',
-                    choices: Object.entries(validRepos).map(([name, rPath]) => ({
-                        name: `${chalk.bold.yellow(name)} ${chalk.dim(formatWorktreeDisplayPath(rPath))}`,
-                        value: name,
-                    })),
-                    pageSize: 10,
-                }]);
-            const repoPath = validRepos[selectedRepoName];
-            process.chdir(repoPath);
-        }
+        await ensureRepoContext();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {

package/dist/commands/wt/open.js

@@ -9,20 +9,26 @@ import { log, ui } from '../../lib/ui.js';
 import { ensureAutocompletePrompt } from '../../lib/prompt.js';
 import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
 import { enterCommand } from './enter.js';
-const OPEN_TOOL_CANDIDATES = [
-    { id: 'cursor', name: 'Cursor', command: 'cursor', kind: 'ide', aliases: ['cursor'] },
-    { id: 'code', name: 'VS Code', command: 'code', kind: 'ide', aliases: ['vscode', 'code'] },
-    { id: 'windsurf', name: 'Windsurf', command: 'windsurf', kind: 'ide', aliases: ['windsurf'] },
-    { id: 'zed', name: 'Zed', command: 'zed', kind: 'ide', aliases: ['zed'] },
-    { id: 'agy', name: 'Agy', command: 'agy', kind: 'ide', aliases: ['agy'] },
-    { id: 'idea', name: 'IntelliJ IDEA', command: 'idea', kind: 'ide', aliases: ['idea', 'intellij'] },
-    { id: 'webstorm', name: 'WebStorm', command: 'webstorm', kind: 'ide', aliases: ['webstorm'] },
-    { id: 'subl', name: 'Sublime Text', command: 'subl', kind: 'ide', aliases: ['subl', 'sublime'] },
-    { id: 'claude', name: 'Claude Code', command: 'claude', kind: 'agent', aliases: ['claude', 'claude-code'] },
-    { id: 'codex', name: 'Codex', command: 'codex', kind: 'agent', aliases: ['codex'] },
-    { id: 'gemini', name: 'Gemini CLI', command: 'gemini', kind: 'agent', aliases: ['gemini'] },
-    { id: 'opencode', name: 'OpenCode', command: 'opencode', kind: 'agent', aliases: ['opencode'] },
+export const OPEN_TOOL_CANDIDATES = [
+    { id: 'cursor', name: 'Cursor', command: 'cursor', kind: 'editor', aliases: ['cursor'] },
+    { id: 'code', name: 'VS Code', command: 'code', kind: 'editor', aliases: ['vscode', 'code'] },
+    { id: 'windsurf', name: 'Windsurf', command: 'windsurf', kind: 'editor', aliases: ['windsurf'] },
+    { id: 'zed', name: 'Zed', command: 'zed', kind: 'editor', aliases: ['zed'] },
+    { id: 'idea', name: 'IntelliJ IDEA', command: 'idea', kind: 'editor', aliases: ['idea', 'intellij'] },
+    { id: 'webstorm', name: 'WebStorm', command: 'webstorm', kind: 'editor', aliases: ['webstorm'] },
+    { id: 'subl', name: 'Sublime Text', command: 'subl', kind: 'editor', aliases: ['subl', 'sublime'] },
+    {
+        id: 'codex-app',
+        name: 'Codex App',
+        command: 'codex-app',
+        kind: 'app',
+        aliases: ['codex', 'codex-app'],
+        bundleId: 'com.openai.codex',
+    },
 ];
+const OTHER_COMMAND_ACTION = '__other_command__';
+const NO_OPEN_ACTION = '__no_open__';
+const yggtreeAccent = chalk.hex('#DEADED');
 function truncateEnd(value, maxLen) {
     if (maxLen <= 0)
         return '';
@@ -52,6 +58,29 @@ function formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumn
     const typeText = formatWorktreeType(type);
     return `${typeText} ${chalk.yellow(branchText)} ${chalk.cyan(pathText)}`;
 }
+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);
+    const row = `${openRail()}  ${chalk.bold(paddedName)} ${chalk.cyan(paddedCommand)}`;
+    return detail ? `${row} ${chalk.dim(detail)}` : row;
+}
+export function formatOpenToolChoice(tool) {
+    return formatOpenColumns(tool.name, tool.command, '');
+}
+export function formatOpenSpecialChoice(value, allowShellAction) {
+    if (value === OTHER_COMMAND_ACTION) {
+        return formatOpenColumns('Other command', 'custom', 'run first, then stay in shell');
+    }
+    return allowShellAction
+        ? formatOpenColumns('Nothing', 'skip', 'just enter the shell')
+        : formatOpenColumns('Do not open', 'skip', 'return after selection');
+}
 export async function commandExists(command) {
     if (!command)
         return false;
@@ -80,10 +109,29 @@ export async function commandExists(command) {
     }
     return false;
 }
+export async function macOSAppBundleExists(bundleId) {
+    if (process.platform !== 'darwin')
+        return false;
+    try {
+        const result = await execa('/usr/bin/mdfind', [`kMDItemCFBundleIdentifier == '${bundleId}'`]);
+        if (result.stdout.trim().length > 0)
+            return true;
+    }
+    catch {
+        // Fall back to common application roots when Spotlight is unavailable.
+    }
+    const commonAppPaths = [
+        '/Applications/Codex.app',
+        path.join(process.env.HOME || '', 'Applications', 'Codex.app'),
+    ];
+    return commonAppPaths.some(appPath => fs.existsSync(appPath));
+}
 export async function detectInstalledOpenTools() {
     const checks = await Promise.all(OPEN_TOOL_CANDIDATES.map(async (tool) => ({
         tool,
-        exists: await commandExists(tool.command),
+        exists: tool.bundleId
+            ? await macOSAppBundleExists(tool.bundleId)
+            : await commandExists(tool.command),
     })));
     return checks
         .filter(check => check.exists)
@@ -98,35 +146,39 @@ export function resolveOpenToolOption(input, installed) {
         tool.command.toLowerCase() === normalized ||
         tool.aliases?.some(alias => alias.toLowerCase() === normalized));
 }
-export function isAgentTool(tool) {
-    return tool.kind === 'agent';
-}
-export function buildAgentExecCommand(tool) {
-    return tool.command;
+export async function resolveOpenToolAction(input, installed) {
+    let chosenTool = resolveOpenToolOption(input, installed);
+    if (!chosenTool && await commandExists(input)) {
+        chosenTool = {
+            id: 'custom',
+            name: input,
+            command: input,
+            kind: 'editor',
+        };
+    }
+    return chosenTool ? { type: 'tool', tool: chosenTool } : undefined;
 }
 export async function promptOpenToolSelection(installedTools, message = 'Select tool to open:') {
     const ideChoices = installedTools
-        .filter(tool => tool.kind === 'ide')
+        .filter(tool => tool.kind === 'editor')
         .map(tool => ({
-        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        name: formatOpenToolChoice(tool),
         value: tool,
     }));
-    const agentChoices = installedTools
-        .filter(tool => tool.kind === 'agent')
+    const appChoices = installedTools
+        .filter(tool => tool.kind === 'app')
         .map(tool => ({
-        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        name: formatOpenToolChoice(tool),
         value: tool,
     }));
     const choices = [];
     if (ideChoices.length > 0) {
-        choices.push(new inquirer.Separator(chalk.dim('── IDEs ──')));
+        choices.push(new inquirer.Separator(openSectionLabel('Editors & IDEs')));
         choices.push(...ideChoices);
     }
-    if (agentChoices.length > 0) {
-        if (choices.length > 0)
-            choices.push(new inquirer.Separator(" "));
-        choices.push(new inquirer.Separator(chalk.dim('── Agent CLIs ──')));
-        choices.push(...agentChoices);
+    if (appChoices.length > 0) {
+        choices.push(new inquirer.Separator(openSectionLabel('Apps')));
+        choices.push(...appChoices);
     }
     const { selectedTool } = await inquirer.prompt([
         {
@@ -140,16 +192,121 @@ export async function promptOpenToolSelection(installedTools, message = 'Select
     ]);
     return selectedTool;
 }
-export async function launchOpenTool(tool, wtPath) {
-    if (isAgentTool(tool)) {
-        await enterCommand(wtPath, { exec: buildAgentExecCommand(tool) });
-        return;
+export function buildOpenActionsFromSelection(selectedValues, installedTools, otherCommand) {
+    if (selectedValues.includes(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() });
+    }
+    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.';
+    }
+    return true;
+}
+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}`,
+            })));
+        }
     }
-    await execa(tool.command, [wtPath], {
+    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([
+        {
+            type: 'checkbox',
+            name: 'selectedValues',
+            message: options.message || 'Open anything before entering the shell?',
+            choices,
+            loop: false,
+            pageSize: 10,
+            validate: validateOpenActionSelection,
+        },
+    ]);
+    let otherCommand;
+    if (selectedValues.includes(OTHER_COMMAND_ACTION)) {
+        const answer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'otherCommand',
+                message: 'Command to run in the worktree shell:',
+                validate: (input) => input.trim().length > 0 || 'Command is required',
+            },
+        ]);
+        otherCommand = answer.otherCommand;
+    }
+    return buildOpenActionsFromSelection(selectedValues, installedTools, otherCommand);
+}
+export async function launchOpenTool(tool, wtPath) {
+    const { executable, args } = buildOpenToolLaunchCommand(tool, wtPath);
+    await execa(executable, args, {
         cwd: wtPath,
         stdio: 'ignore',
     });
 }
+export function buildOpenToolLaunchCommand(tool, wtPath) {
+    if (tool.bundleId) {
+        return {
+            executable: '/usr/bin/open',
+            args: ['-b', tool.bundleId, wtPath],
+        };
+    }
+    return {
+        executable: tool.command,
+        args: [wtPath],
+    };
+}
+export async function runOpenActions(actions, wtPath, options = {}) {
+    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);
+        }
+    }
+    const shellAction = actions.find(action => action.type === 'other-command');
+    if (shellAction?.command) {
+        await enterCommand(wtPath, { exec: shellAction.command });
+        return;
+    }
+    if (options.enter !== false) {
+        await enterCommand(wtPath);
+    }
+}
 export async function openCommand(wtName, options = {}) {
     try {
         await getRepoRoot();
@@ -208,36 +365,33 @@ export async function openCommand(wtName, options = {}) {
             return;
         }
         const installedTools = await detectInstalledOpenTools();
-        let chosenTool;
         const requestedTool = options.tool;
+        const shouldEnter = options.enter === true;
         if (requestedTool) {
-            chosenTool = resolveOpenToolOption(requestedTool, installedTools);
-            if (!chosenTool && await commandExists(requestedTool)) {
-                chosenTool = {
-                    id: 'custom',
-                    name: requestedTool,
-                    command: requestedTool,
-                    kind: 'ide',
-                };
-            }
-            if (!chosenTool) {
+            const toolAction = await resolveOpenToolAction(requestedTool, installedTools);
+            if (!toolAction) {
                 const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
                 log.error(`Tool "${requestedTool}" not found.`);
                 log.dim(`Detected tool commands: ${available}`);
                 return;
             }
+            await runOpenActions([toolAction], targetWt.path, { enter: shouldEnter });
+            log.success('Worktree opened.');
+            return;
         }
         else {
-            if (installedTools.length === 0) {
-                log.error('No supported open tool command was detected in PATH.');
-                log.dim('Try: yggtree wt open --tool <command> (e.g. --tool cursor, --tool claude)');
+            if (installedTools.length === 0 && !shouldEnter) {
+                log.error('No supported editor command or app was detected.');
+                log.dim('Try: yggtree open --tool <command> (e.g. --tool cursor or --tool codex-app), or yggtree open --enter');
                 return;
             }
-            chosenTool = await promptOpenToolSelection(installedTools);
+            const actions = await promptOpenActions(installedTools, {
+                allowShellAction: shouldEnter,
+                message: shouldEnter ? 'Open anything before entering the shell?' : 'Open anything?',
+            });
+            await runOpenActions(actions, targetWt.path, { enter: shouldEnter });
         }
-        log.info(`Opening ${ui.path(targetWt.path)} in ${chalk.cyan(chosenTool.name)}...`);
-        await launchOpenTool(chosenTool, targetWt.path);
-        log.success(isAgentTool(chosenTool) ? 'Agent launched.' : 'IDE launched.');
+        log.success('Worktree opened.');
     }
     catch (error) {
         log.error(error.message);