yggtree 1.3.0 → 1.4.0

package/README.md

@@ -162,7 +162,7 @@ Sometimes you don't want to "commit to a branch" yet. You just want to try somet
 
 **Sandboxes** are temporary, local-only worktrees designed for this:
 
-1.  **Create**: `yggtree wt create-sandbox` (creates `branch_qes2`).
+1.  **Create**: `yggtree wt create-sandbox` (creates something like `sandbox-a3f2_feature-branch`).
 2.  **Experiment**: Change files, run tests, try that risky refactor.
 3.  **Apply**: `yggtree wt apply` to "push" those file changes back to your origin directory.
 4.  **Unapply**: Don't like it? `yggtree wt unapply` restores your origin to exactly how it was before.
@@ -177,10 +177,13 @@ Yggdrasil automatically prepares each worktree.
 
 Resolution order:
 
-1. `yggtree-worktree.json` inside the worktree
-2. `yggtree-worktree.json` in the repo root
-3. `.cursor/worktrees.json`
-4. Fallback: `npm install` + submodules
+1. `.yggtree/worktree-setup.json` in the repo root
+2. `yggtree-worktree.json` in the repo root (legacy fallback)
+3. `.cursor/worktrees.json` in the repo root (legacy fallback)
+4. `.yggtree/worktree-setup.json` inside the worktree (per-worktree fallback)
+5. `yggtree-worktree.json` inside the worktree (legacy fallback)
+6. `.cursor/worktrees.json` inside the worktree (legacy fallback)
+7. Fallback: `npm install` + submodules
 
 ### Example configuration
 
@@ -211,12 +214,18 @@ Create a worktree from a branch.
 
 Options:
 
+* `-b, --branch <name>`
 * `--base <ref>`
 * `--source local|remote`
 * `--no-bootstrap`
 * `--enter / --no-enter`
 * `--exec "<command>"`
 
+Interactive flow:
+
+* Instead of asking for a free-form `exec` command, yggtree now asks if you want to open a tool after creation (IDE or agent CLI).
+* `--exec` remains available as an advanced explicit override.
+
 <details>
 <summary>Example</summary>
 
@@ -228,17 +237,59 @@ yggtree wt create feat/new-ui --base main --exec "cursor ."
 
 ---
 
+### `yggtree wt worktree-checkout [name] [ref]`
+
+Create a checkout-style worktree from an existing branch.
+
+Behavior:
+
+* Prompts a searchable branch picker (type to filter in real time).
+* Attaches the new worktree directly to the selected branch (checkout-style).
+* If you select a remote-only branch (`origin/*`), yggtree creates the local branch in the new worktree automatically.
+* If that branch already has an active yggtree-managed worktree, yggtree falls back to entering that worktree instead of creating a duplicate.
+
+Options:
+
+* `-n, --name <slug>`
+* `-r, --ref <ref>`: skip picker and use a specific branch (`feature/x` or `origin/feature/x`)
+* `--no-bootstrap`
+* `--enter / --no-enter`
+* `--exec "<command>"`
+
+Interactive flow:
+
+* Instead of asking for a free-form `exec` command, yggtree now asks if you want to open a tool after creation (IDE or agent CLI).
+* `--exec` remains available as an advanced explicit override.
+
+<details>
+<summary>Example</summary>
+
+```bash
+yggtree wt worktree-checkout -n hotfix-auth -r main --no-enter
+```
+
+</details>
+
+---
+
 ### `yggtree wt create-sandbox`
 
 Create a temporary sandbox from your current local branch.
 
 Options:
 
+*   `-n, --name <name>`: Optional sandbox name (auto-generated if omitted).
 *   `--carry / --no-carry`: Bring uncommitted changes (staged/unstaged/untracked) with you.
 *   `--no-bootstrap`
 *   `--enter / --no-enter`
 *   `--exec "<command>"`
 
+Interactive flow:
+
+* Prompts for an optional sandbox name (leave empty to auto-generate one from current branch).
+* Instead of asking for a free-form `exec` command, yggtree now asks if you want to open a tool after creation (IDE or agent CLI).
+* `--exec` remains available as an advanced explicit override.
+
 ---
 
 ### `yggtree wt apply`
@@ -261,6 +312,12 @@ Undo a previous `apply` operation.
 
 Create multiple worktrees at once.
 
+Options:
+
+* `--base <ref>`
+* `--source local|remote`
+* `--no-bootstrap`
+
 <details>
 <summary>Example</summary>
 
@@ -274,14 +331,21 @@ yggtree wt create-multi --base main
 
 ### `yggtree wt list`
 
-List all worktrees with state.
+List all repo-linked worktrees with state.
 
 Columns:
 
-* TYPE (MAIN / MANAGED)
+* TYPE (`MAIN`, `MANAGED`, `LINKED`, `SANDBOX`)
 * STATE (clean / dirty)
+* LAST ACTIVE
 * BRANCH
-* PATH
+
+Notes:
+
+* Entries are grouped by `TYPE`.
+* `SANDBOX` and `MANAGED` are worktrees inside `~/.yggtree`.
+* External worktrees are labeled `LINKED`.
+* Use `--open` to switch this flow into "pick and open in tool" mode.
 
 ---
 
@@ -307,6 +371,35 @@ yggtree wt enter feat/new-ui --exec "npm test"
 
 ---
 
+### `yggtree wt open [worktree]`
+
+Open a worktree in an IDE or agent CLI.
+
+Behavior:
+
+* If `[worktree]` is omitted, you can pick from the worktree list with type-to-filter search.
+* Detects available tool commands in your `PATH` (for example: IDEs like `cursor`, `code`, `zed`; agents like `claude`, `codex`, `gemini`, `opencode`).
+* Lets you choose one interactively, or pass `--tool`.
+* If an agent CLI is selected, yggtree opens a sub-shell and launches it there.
+
+Options:
+
+* `--tool <command>`
+
+<details>
+<summary>Examples</summary>
+
+```bash
+yggtree wt open
+yggtree wt open feat/new-ui --tool cursor
+yggtree wt open feat/new-ui --tool claude
+yggtree wt list --open
+```
+
+</details>
+
+---
+
 ### `yggtree wt exec [worktree] -- <command>`
 
 Run a command inside a worktree **without entering**.
@@ -338,7 +431,18 @@ Re‑run bootstrap commands for a worktree.
 
 ### `yggtree wt delete`
 
-Interactively delete managed worktrees.
+Interactively delete worktrees.
+
+Behavior:
+
+* Default flow targets managed worktrees.
+* In interactive mode, yggtree asks whether to include external linked worktrees.
+* In direct CLI usage, `--all` includes external linked worktrees (main/current are still excluded for safety).
+* The delete selector shows 6 items per page.
+
+Optional:
+
+* `--all` includes linked worktrees outside `~/.yggtree` (main/current worktree is excluded for safety)
 
 ---
 
@@ -488,7 +592,7 @@ yggtree wt create-sandbox --carry
 **Scenario:**
 
 1.  You have 5 files changed in your main repo but aren't sure about the direction.
-2.  Run `create-sandbox --carry` to move those changes into an isolated `current-branch_a1b2` folder.
+2.  Run `create-sandbox --carry` to move those changes into an isolated `sandbox-a3f2_feature-branch` folder.
 3.  Experiment freely.
 4.  If it works: `yggtree wt apply`.
 5.  If it fails: Just delete the sandbox or `unapply`.

package/dist/commands/wt/create-branch.js

@@ -5,6 +5,7 @@ import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensure
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
+import { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
@@ -58,19 +59,29 @@ export async function createCommandNew(options) {
                 when: options.enter === undefined,
             },
             {
-                type: 'input',
-                name: 'exec',
-                message: 'Command to run after creation (optional):',
-                default: options.exec,
+                type: 'confirm',
+                name: 'shouldOpenTool',
+                message: 'Open a tool after creation? (IDE or agent CLI)',
+                default: false,
                 when: options.exec === undefined,
-            }
+            },
         ]);
         const branchName = options.branch || answers.branch;
         let baseRef = options.base || answers.base;
         const source = options.source || answers.source;
         const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const execCommandStr = options.exec || answers.exec;
+        let selectedTool;
+        if (options.exec === undefined && answers.shouldOpenTool) {
+            const installedTools = await detectInstalledOpenTools();
+            if (installedTools.length === 0) {
+                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            }
+            else {
+                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+            }
+        }
+        const execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
         // Append origin/ if remote is selected and not already present
         if (!options.base && source === 'remote' && !baseRef.startsWith('origin/')) {
             baseRef = `origin/${baseRef}`;
@@ -159,6 +170,15 @@ export async function createCommandNew(options) {
                 ]);
             }
         }
+        if (selectedTool && !isAgentTool(selectedTool)) {
+            try {
+                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
+                await launchOpenTool(selectedTool, wtPath);
+            }
+            catch (error) {
+                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+            }
+        }
         // 6. Final Output
         log.success('Worktree ready!');
         if (shouldEnter) {

package/dist/commands/wt/create-sandbox.js

@@ -5,7 +5,8 @@ import { getRepoRoot, getRepoName, getCurrentBranch } 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 { generateSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
+import { generateSandboxName, normalizeSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
+import { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
@@ -20,11 +21,32 @@ export async function createSandboxCommand(options = {}) {
             return;
         }
         log.info(`Current branch: ${chalk.cyan(currentBranch)}`);
-        // 2. Generate random sandbox name
-        const sandboxName = generateSandboxName(currentBranch);
-        log.info(`Sandbox name: ${chalk.yellow(sandboxName)}`);
+        // 2. Build default + optional custom name validation
+        const generatedSandboxName = generateSandboxName(currentBranch);
+        const validateSandboxName = async (input) => {
+            if (!input.trim())
+                return true;
+            const normalized = normalizeSandboxName(input);
+            if (!normalized) {
+                return 'Please provide at least one valid character.';
+            }
+            try {
+                await execa('git', ['check-ref-format', '--branch', normalized], { cwd: repoRoot });
+                return true;
+            }
+            catch {
+                return 'Sandbox name is not a valid git branch name.';
+            }
+        };
         // 3. Gather remaining inputs
         const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'name',
+                message: `Sandbox name (optional, leave empty for auto: ${generatedSandboxName}):`,
+                when: options.name === undefined,
+                validate: validateSandboxName,
+            },
             {
                 type: 'confirm',
                 name: 'carry',
@@ -47,17 +69,39 @@ export async function createSandboxCommand(options = {}) {
                 when: options.enter === undefined,
             },
             {
-                type: 'input',
-                name: 'exec',
-                message: 'Command to run after creation (optional):',
-                default: options.exec,
+                type: 'confirm',
+                name: 'shouldOpenTool',
+                message: 'Open a tool after creation? (IDE or agent CLI)',
+                default: false,
                 when: options.exec === undefined,
-            }
+            },
         ]);
+        const requestedSandboxName = options.name !== undefined ? options.name : answers.name || '';
+        const nameValidation = await validateSandboxName(requestedSandboxName);
+        if (nameValidation !== true) {
+            log.error(nameValidation);
+            return;
+        }
+        const normalizedCustomName = normalizeSandboxName(requestedSandboxName);
+        const sandboxName = normalizedCustomName || generatedSandboxName;
+        if (requestedSandboxName.trim() && normalizedCustomName !== requestedSandboxName.trim()) {
+            log.dim(`Normalized sandbox name: ${chalk.yellow(sandboxName)}`);
+        }
+        log.info(`Sandbox name: ${chalk.yellow(sandboxName)}`);
         const shouldCarry = options.carry !== undefined ? options.carry : answers.carry;
         const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const execCommandStr = options.exec || answers.exec;
+        let selectedTool;
+        if (options.exec === undefined && answers.shouldOpenTool) {
+            const installedTools = await detectInstalledOpenTools();
+            if (installedTools.length === 0) {
+                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            }
+            else {
+                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+            }
+        }
+        const execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
         // 4. Detect uncommitted changes before creating worktree
         let changedFiles = [];
         let submodulePaths = [];
@@ -159,6 +203,15 @@ export async function createSandboxCommand(options = {}) {
                 ]);
             }
         }
+        if (selectedTool && !isAgentTool(selectedTool)) {
+            try {
+                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
+                await launchOpenTool(selectedTool, wtPath);
+            }
+            catch (error) {
+                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+            }
+        }
         // 10. Final output
         log.success('Sandbox ready!');
         log.info(`Use ${chalk.cyan('yggtree wt apply')} to apply changes to origin.`);

package/dist/commands/wt/create.js

@@ -1,48 +1,138 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, createWorktree, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { getRepoRoot, 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 { enterCommand } from './enter.js';
+import { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
+function toSlug(value) {
+    return value
+        .trim()
+        .replace(/[\/\\]/g, '-')
+        .replace(/\s+/g, '-');
+}
+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']),
+    ]);
+    const localBranches = localRefs.stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    const remoteBranches = remoteRefs.stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .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 localCandidates = localBranches.map(branchName => ({
+        branchName,
+        checkoutRef: branchName,
+        createLocalBranch: false,
+        source: 'local',
+    }));
+    const remoteCandidates = remoteOnly.map(branchName => ({
+        branchName,
+        checkoutRef: `origin/${branchName}`,
+        createLocalBranch: true,
+        source: 'remote',
+    }));
+    return [...localCandidates, ...remoteCandidates]
+        .sort((a, b) => a.branchName.localeCompare(b.branchName));
+}
+function resolveCandidateFromRef(ref, candidates) {
+    const trimmedRef = ref.trim();
+    if (!trimmedRef)
+        return undefined;
+    if (trimmedRef.startsWith('origin/')) {
+        const branchName = trimmedRef.replace(/^origin\//, '');
+        return candidates.find(candidate => candidate.branchName === branchName);
+    }
+    return candidates.find(candidate => candidate.branchName === trimmedRef ||
+        candidate.checkoutRef === trimmedRef);
+}
 export async function createCommand(options) {
     try {
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
-        // 1. Gather inputs
-        const currentBranch = await getCurrentBranch();
+        // 1. Load branches
+        const loadingSpinner = createSpinner('Fetching branches...').start();
+        await fetchAll();
+        const candidates = await listBranchCandidates();
+        if (candidates.length === 0) {
+            loadingSpinner.fail('No branches found.');
+            log.warning('Create a branch first, then run worktree-checkout again.');
+            return;
+        }
+        loadingSpinner.succeed(`Loaded ${candidates.length} branches.`);
+        // 2. Select branch
+        ensureAutocompletePrompt();
+        let selectedBranch;
+        if (options.ref) {
+            selectedBranch = resolveCandidateFromRef(options.ref, candidates);
+            if (!selectedBranch) {
+                log.error(`Branch "${options.ref}" not found.`);
+                log.warning('Tip: use a local branch name or origin/<branch>.');
+                return;
+            }
+        }
+        else {
+            const { branchChoice } = await inquirer.prompt([
+                {
+                    type: 'autocomplete',
+                    name: 'branchChoice',
+                    message: 'Select branch (type to filter):',
+                    source: async (_answers, input = '') => {
+                        const term = input.trim().toLowerCase();
+                        const filtered = term
+                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term))
+                            : candidates;
+                        return filtered.map(candidate => ({
+                            name: `${chalk.yellow(candidate.branchName)} ${chalk.dim(`(${candidate.source})`)}`,
+                            value: candidate,
+                        }));
+                    },
+                    pageSize: 10,
+                },
+            ]);
+            selectedBranch = branchChoice;
+        }
+        if (!selectedBranch) {
+            log.error('No branch selected.');
+            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)}.`);
+            if (options.enter === false) {
+                log.header(`cd "${existingManagedWorktree.path}"`);
+                return;
+            }
+            log.info('Opening existing worktree instead of creating a duplicate...');
+            await enterCommand(existingManagedWorktree.path, { exec: options.exec ?? '' });
+            return;
+        }
+        // 3. Gather remaining inputs
+        const defaultSlug = toSlug(selectedBranch.branchName);
         const answers = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'name',
                 message: 'Worktree name (slug):',
-                default: options.name,
+                default: options.name || defaultSlug,
                 when: !options.name,
                 validate: (input) => input.trim().length > 0 || 'Name is required',
             },
-            {
-                type: 'input',
-                name: 'ref',
-                message: 'Base branch name:',
-                default: options.ref || currentBranch,
-                when: !options.ref,
-                validate: (input) => input.trim().length > 0 || 'Ref is required',
-            },
-            {
-                type: 'list',
-                name: 'source',
-                message: 'Base on:',
-                loop: false,
-                choices: [
-                    { name: 'Remote (origin)', value: 'remote' },
-                    { name: 'Local', value: 'local' },
-                ],
-                default: 'remote',
-                when: !options.ref && !options.source,
-            },
             {
                 type: 'confirm',
                 name: 'bootstrap',
@@ -58,61 +148,62 @@ export async function createCommand(options) {
                 when: options.enter === undefined,
             },
             {
-                type: 'input',
-                name: 'exec',
-                message: 'Command to run after creation (optional):',
-                default: options.exec,
+                type: 'confirm',
+                name: 'shouldOpenTool',
+                message: 'Open a tool after creation? (IDE or agent CLI)',
+                default: false,
                 when: options.exec === undefined,
-            }
+            },
         ]);
         const name = options.name || answers.name;
-        let ref = options.ref || answers.ref;
-        const source = options.source || answers.source;
         const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const execCommandStr = options.exec || answers.exec;
-        // Append origin/ if remote is selected and not already present
-        if (!options.ref && source === 'remote' && !ref.startsWith('origin/')) {
-            ref = `origin/${ref}`;
+        let selectedTool;
+        if (options.exec === undefined && answers.shouldOpenTool) {
+            const installedTools = await detectInstalledOpenTools();
+            if (installedTools.length === 0) {
+                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            }
+            else {
+                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+            }
         }
-        const slug = name.replace(/\s+/g, '-');
+        const execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
+        const slug = toSlug(name);
         const repoName = await getRepoName();
         const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
-        // 2. Validation
+        // 4. Validation
         if (!slug)
             throw new Error('Invalid name');
-        if (!ref)
-            throw new Error('Invalid ref');
-        // 3. Execution
-        const spinner = createSpinner('Fetching...').start();
-        await fetchAll();
-        spinner.text = 'Verifying ref...';
-        const exists = await verifyRef(ref);
-        if (!exists) {
-            spinner.fail(`Ref not found: ${ref}`);
-            log.warning(`Tip: try 'origin/${ref}' or check if the branch exists.`);
-            return;
-        }
-        spinner.text = `Creating worktree at ${ui.path(wtPath)}...`;
+        // 5. Execution (checkout-style: attach to selected branch)
+        const spinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
         try {
             await fs.ensureDir(path.dirname(wtPath));
-            await createWorktree(wtPath, ref);
+            if (selectedBranch.createLocalBranch) {
+                await execa('git', ['worktree', 'add', '-b', selectedBranch.branchName, wtPath, selectedBranch.checkoutRef]);
+            }
+            else {
+                await createWorktree(wtPath, selectedBranch.checkoutRef);
+            }
             spinner.succeed('Worktree created.');
         }
         catch (e) {
             spinner.fail('Failed to create worktree.');
-            log.actionableError(e.message, `git worktree add ${wtPath} ${ref}`, wtPath, [
+            const command = selectedBranch.createLocalBranch
+                ? `git worktree add -b ${selectedBranch.branchName} ${wtPath} ${selectedBranch.checkoutRef}`
+                : `git worktree add ${wtPath} ${selectedBranch.checkoutRef}`;
+            log.actionableError(e.message, command, wtPath, [
                 'Check if the folder already exists: ls ' + wtPath,
-                'Check if the branch is already used: git worktree list',
+                `Check if branch "${selectedBranch.branchName}" is already checked out in another worktree: git worktree list`,
                 'Try pruning stale worktrees: yggtree wt prune',
-                `Run manually: git worktree add ${wtPath} ${ref}`
+                `Run manually: ${command}`
             ]);
             return;
         }
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
-        // 5. Exec Command
+        // 6. Exec Command
         if (execCommandStr && execCommandStr.trim()) {
             log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
             try {
@@ -129,7 +220,16 @@ export async function createCommand(options) {
                 ]);
             }
         }
-        // 6. Final Output
+        if (selectedTool && !isAgentTool(selectedTool)) {
+            try {
+                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
+                await launchOpenTool(selectedTool, wtPath);
+            }
+            catch (error) {
+                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+            }
+        }
+        // 7. Final Output
         log.success('Worktree ready!');
         if (shouldEnter) {
             log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
@@ -148,7 +248,7 @@ export async function createCommand(options) {
         }
     }
     catch (error) {
-        log.actionableError(error.message, 'yggtree wt create');
+        log.actionableError(error.message, 'yggtree wt worktree-checkout');
         process.exit(1);
     }
 }