yggtree 1.4.1 → 1.4.3

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);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { welcome, log } from './lib/ui.js';
@@ -11,23 +11,148 @@ import { deleteCommand } from './commands/wt/delete.js';
 import { bootstrapCommand } from './commands/wt/bootstrap.js';
 import { pruneCommand } from './commands/wt/prune.js';
 import { execCommand } from './commands/wt/exec.js';
-import { enterCommand } from './commands/wt/enter.js';
 import { pathCommand } from './commands/wt/path.js';
 import { openCommand } from './commands/wt/open.js';
 import { applyCommand } from './commands/wt/apply.js';
 import { unapplyCommand } from './commands/wt/unapply.js';
 import { getVersion } from './lib/version.js';
+import { notifyIfUpdateAvailable } from './lib/update-check.js';
 import { findSandboxRoot } from './lib/sandbox.js';
 import { bifrostCommand } from './commands/bifrost.js';
 import { thorCommand } from './commands/thor.js';
 const program = new Command();
+const argv = process.argv.map((arg) => arg === '-v' || arg === '—version' ? '--version' : arg);
+function registerWorktreeCommands(parent) {
+    parent.command('list')
+        .description('List all repo-linked worktrees')
+        .option('--open', 'Open a worktree in an IDE/agent tool instead of listing')
+        .action(async (options) => {
+        if (options.open) {
+            await openCommand();
+            return;
+        }
+        await listCommand();
+    });
+    parent.command('create [branch]')
+        .description('Create a new worktree (Smart branch detection)')
+        .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
+        .option('--base <ref>', 'Base ref (e.g. main)')
+        .option('--source <type>', 'Base source (local or remote)')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--open', 'Open an editor after creation')
+        .option('--no-open', 'Skip opening an editor after creation')
+        .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
+        .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
+        .option('--exec <command>', 'Command to execute after creation')
+        .action(async (branch, options) => {
+        await createCommandNew({
+            ...options,
+            branch: branch || options.branch
+        });
+    });
+    parent.command('create-multi')
+        .description('Create multiple worktrees (Smart branch detection)')
+        .option('--base <ref>', 'Base ref (e.g. main)')
+        .option('--source <type>', 'Base source (local or remote)')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .action(async (options) => {
+        await createCommandMulti(options);
+    });
+    const registerWorktreeCheckout = (commandName, description) => {
+        parent.command(`${commandName} [name] [ref]`)
+            .description(description)
+            .option('-n, --name <slug>', 'Worktree name (slug)')
+            .option('-r, --ref <ref>', 'Existing branch or ref')
+            .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+            .option('--open', 'Open editors or run a startup command before entering')
+            .option('--no-open', 'Skip opening editors or startup commands before entering')
+            .option('--tool <command>', 'Editor or app command to open after checkout (skips open prompt)')
+            .addOption(new Option('--enter', 'Enter the worktree sub-shell after checkout/opening').hideHelp())
+            .option('--no-enter', 'Do not enter the worktree sub-shell after checkout/opening')
+            .option('--exec <command>', 'Command to execute after creation')
+            .action(async (name, ref, options) => {
+            await createCommand({
+                ...options,
+                name: name || options.name,
+                ref: ref || options.ref
+            });
+        });
+    };
+    registerWorktreeCheckout('worktree-checkout', 'Create a checkout-style worktree from an existing branch');
+    registerWorktreeCheckout('wc', 'Alias for worktree-checkout');
+    parent.command('delete')
+        .description('Delete managed worktrees')
+        .option('-a, --all', 'Include repo-linked worktrees outside ~/.yggtree (except main/current)')
+        .action(async (options) => {
+        await deleteCommand(options);
+    });
+    parent.command('open [worktree]')
+        .description('Open a worktree in an editor or supported app')
+        .option('--tool <command>', 'Editor or app command to use (e.g. cursor, code, codex-app)')
+        .option('--enter', 'Enter the worktree sub-shell after opening')
+        .addOption(new Option('--no-enter', 'Do not enter the worktree sub-shell after opening').hideHelp())
+        .action(async (worktree, options) => {
+        await openCommand(worktree, options);
+    });
+    parent.command('bootstrap')
+        .description('Bootstrap dependencies in a worktree')
+        .action(bootstrapCommand);
+    parent.command('prune')
+        .description('Prune stale worktree information')
+        .action(pruneCommand);
+    parent.command('exec')
+        .description('Execute a command in a worktree')
+        .argument('[worktree]', 'Worktree name or path')
+        .argument('[command...]', 'Command and arguments to execute')
+        .action(async (worktree, command) => {
+        await execCommand(worktree, command);
+    });
+    parent.command('path [worktree]')
+        .description('Show the cd command for a specific worktree')
+        .action(async (worktree) => {
+        await pathCommand(worktree);
+    });
+    parent.command('create-sandbox')
+        .description('Create a sandbox worktree from current branch')
+        .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
+        .option('--carry', 'Carry uncommitted changes to sandbox')
+        .option('--no-carry', 'Do not carry uncommitted changes')
+        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--open', 'Open an editor after creation')
+        .option('--no-open', 'Skip opening an editor after creation')
+        .addOption(new Option('--enter', 'Deprecated alias for --open').hideHelp())
+        .addOption(new Option('--no-enter', 'Deprecated alias for --no-open').hideHelp())
+        .option('--exec <command>', 'Command to execute after creation')
+        .action(async (options) => {
+        await createSandboxCommand(options);
+    });
+    parent.command('apply')
+        .description('Apply sandbox changes to origin directory')
+        .action(applyCommand);
+    parent.command('unapply')
+        .description('Undo applied sandbox changes in origin')
+        .action(unapplyCommand);
+}
+function rejectUnknownTopLevelCommand(args) {
+    const commandArg = args.slice(2).find(arg => !arg.startsWith('-'));
+    if (!commandArg)
+        return;
+    if (commandArg === 'help')
+        return;
+    const knownCommands = new Set(program.commands.flatMap(command => [command.name(), ...command.aliases()]));
+    if (!knownCommands.has(commandArg)) {
+        program.error(`error: unknown command '${commandArg}'`);
+    }
+}
 program
     .name('yggtree')
     .description('Interactive CLI for managing git worktrees and configs')
     .version(getVersion())
+    .allowExcessArguments(false)
     .action(async () => {
     // Interactive Menu if no command is provided
     await welcome();
+    await notifyIfUpdateAvailable();
     const isInSandbox = Boolean(await findSandboxRoot(process.cwd()));
     const realmChoices = [
         { name: `🌿 Grow New Realm ${chalk.dim('(create worktree)')}`, value: 'create-smart' },
@@ -35,12 +160,11 @@ program
         { name: `🌳 Grow Many Realms ${chalk.dim('(create multiple worktrees)')}`, value: 'create-multi' },
         { name: `🧪 Forge Sandbox Realm ${chalk.dim('(create sandbox worktree)')}`, value: 'create-sandbox' },
         { name: `🗺️  Survey Realms ${chalk.dim('(list worktrees)')}`, value: 'list' },
-        { name: `🧭 Open Realm in Tool ${chalk.dim('(open worktree in IDE/agent)')}`, value: 'open' },
+        { name: `🧭 Open Realm in Editor ${chalk.dim('(open worktree in editor)')}`, value: 'open' },
         { name: `🪓 Fell a Realm ${chalk.dim('(delete worktree)')}`, value: 'delete' },
         { name: `🚀 Bless Realm Setup ${chalk.dim('(bootstrap worktree)')}`, value: 'bootstrap' },
         { name: `🧹 Prune Withered Realms ${chalk.dim('(prune stale worktrees)')}`, value: 'prune' },
         { name: `🐚 Cast a Command ${chalk.dim('(exec command in worktree)')}`, value: 'exec' },
-        { name: `🚪 Enter Realm Shell ${chalk.dim('(enter worktree)')}`, value: 'enter' },
         { name: `📍 Reveal Realm Path ${chalk.dim('(show worktree path)')}`, value: 'path' },
     ];
     const sandboxChoices = [
@@ -104,9 +228,6 @@ program
         case 'exec':
             await execCommand();
             break;
-        case 'enter':
-            await enterCommand();
-            break;
         case 'path':
             await pathCommand();
             break;
@@ -132,113 +253,14 @@ program
 });
 // --- Worktree Commands ---
 const wt = program.command('wt').description('Manage git worktrees');
-wt.command('list')
-    .description('List all repo-linked worktrees')
-    .option('--open', 'Open a worktree in an IDE/agent tool instead of listing')
-    .action(async (options) => {
-    if (options.open) {
-        await openCommand();
-        return;
-    }
-    await listCommand();
-});
-wt.command('create [branch]')
-    .description('Create a new worktree (Smart branch detection)')
-    .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
-    .option('--base <ref>', 'Base ref (e.g. main)')
-    .option('--source <type>', 'Base source (local or remote)')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--enter', 'Enter sub-shell after creation')
-    .option('--no-enter', 'Skip entering sub-shell')
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (branch, options) => {
-    await createCommandNew({
-        ...options,
-        branch: branch || options.branch
-    });
-});
-wt.command('create-multi')
-    .description('Create multiple worktrees (Smart branch detection)')
-    .option('--base <ref>', 'Base ref (e.g. main)')
-    .option('--source <type>', 'Base source (local or remote)')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .action(async (options) => {
-    await createCommandMulti(options);
-});
-wt.command('worktree-checkout [name] [ref]')
-    .description('Create a checkout-style worktree from an existing branch')
-    .option('-n, --name <slug>', 'Worktree name (slug)')
-    .option('-r, --ref <ref>', 'Existing branch or ref')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--enter', 'Enter sub-shell after creation')
-    .option('--no-enter', 'Skip entering sub-shell')
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (name, ref, options) => {
-    await createCommand({
-        ...options,
-        name: name || options.name,
-        ref: ref || options.ref
-    });
-});
-wt.command('delete')
-    .description('Delete managed worktrees')
-    .option('-a, --all', 'Include repo-linked worktrees outside ~/.yggtree (except main/current)')
-    .action(async (options) => {
-    await deleteCommand(options);
-});
-wt.command('open [worktree]')
-    .description('Open a worktree in an IDE or agent CLI')
-    .option('--tool <command>', 'Tool command to use (e.g. cursor, code, claude, codex)')
-    .action(async (worktree, options) => {
-    await openCommand(worktree, options);
-});
-wt.command('bootstrap')
-    .description('Bootstrap dependencies in a worktree')
-    .action(bootstrapCommand);
-wt.command('prune')
-    .description('Prune stale worktree information')
-    .action(pruneCommand);
-wt.command('exec')
-    .description('Execute a command in a worktree')
-    .argument('[worktree]', 'Worktree name or path')
-    .argument('[command...]', 'Command and arguments to execute')
-    .action(async (worktree, command) => {
-    await execCommand(worktree, command);
-});
-wt.command('enter')
-    .description('Enter a worktree sub-shell')
-    .argument('[worktree]', 'Worktree name or path')
-    .option('--exec <command>', 'Command to execute before entering')
-    .action(async (worktree, options) => {
-    await enterCommand(worktree, options);
-});
-wt.command('path [worktree]')
-    .description('Show the cd command for a specific worktree')
-    .action(async (worktree) => {
-    await pathCommand(worktree);
-});
-wt.command('create-sandbox')
-    .description('Create a sandbox worktree from current branch')
-    .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
-    .option('--carry', 'Carry uncommitted changes to sandbox')
-    .option('--no-carry', 'Do not carry uncommitted changes')
-    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
-    .option('--enter', 'Enter sub-shell after creation')
-    .option('--no-enter', 'Skip entering sub-shell')
-    .option('--exec <command>', 'Command to execute after creation')
-    .action(async (options) => {
-    await createSandboxCommand(options);
-});
-wt.command('apply')
-    .description('Apply sandbox changes to origin directory')
-    .action(applyCommand);
-wt.command('unapply')
-    .description('Undo applied sandbox changes in origin')
-    .action(unapplyCommand);
+registerWorktreeCommands(program);
+registerWorktreeCommands(wt);
+program.addHelpCommand(true);
 program.command('bifrost')
     .description('Summon the Bifrost (Easter Egg)')
     .action(bifrostCommand);
 program.command('thor')
     .description('Consult the God of Thunder (Easter Egg)')
     .action(thorCommand);
-program.parse(process.argv);
+rejectUnknownTopLevelCommand(argv);
+program.parse(argv);