yggtree 1.4.1 → 1.4.2

package/README.md

@@ -218,7 +218,7 @@ Options:
 * `--base <ref>`
 * `--source local|remote`
 * `--no-bootstrap`
-* `--enter / --no-enter`
+* `--open / --no-open`
 * `--exec "<command>"`
 
 Interactive flow:
@@ -253,7 +253,7 @@ 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`
+* `--open / --no-open`
 * `--exec "<command>"`
 
 Interactive flow:
@@ -265,7 +265,7 @@ Interactive flow:
 <summary>Example</summary>
 
 ```bash
-yggtree wt worktree-checkout -n hotfix-auth -r main --no-enter
+yggtree wt worktree-checkout -n hotfix-auth -r main --no-open
 ```
 
 </details>
@@ -281,7 +281,7 @@ 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`
+*   `--open / --no-open`
 *   `--exec "<command>"`
 
 Interactive flow:
@@ -338,6 +338,7 @@ Columns:
 * TYPE (`MAIN`, `MANAGED`, `LINKED`, `SANDBOX`)
 * STATE (clean / dirty)
 * LAST ACTIVE
+* PR (optional — requires [GitHub CLI](https://cli.github.com/))
 * BRANCH
 
 Notes:
@@ -346,6 +347,7 @@ Notes:
 * `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.
+* The **PR** column shows the pull request status for each branch (e.g. `OPEN`, `IN REVIEW`, `APPROVED`, `MERGED`, `DRAFT`, `CHANGES`). It only appears when `gh` CLI is installed and authenticated — otherwise it's silently omitted.
 
 ---
 
@@ -371,6 +373,32 @@ yggtree wt enter feat/new-ui --exec "npm test"
 
 ---
 
+### `yggtree wt close`
+
+Gracefully exit a worktree sub-shell with an option to delete it.
+
+Behavior:
+
+* Only works inside an Yggdrasil sub-shell (entered via `wt enter` or post-creation).
+* Asks whether you want to delete the worktree before leaving.
+* Includes double-confirmation for safety.
+* Main worktree is never offered for deletion.
+
+<details>
+<summary>Example</summary>
+
+```bash
+# Inside a worktree sub-shell:
+yggtree wt close
+# → "Delete this worktree before leaving? (y/N)"
+# → If yes: removes the worktree, then exits
+# → If no: exits normally
+```
+
+</details>
+
+---
+
 ### `yggtree wt open [worktree]`
 
 Open a worktree in an IDE or agent CLI.
@@ -467,7 +495,7 @@ Yggdrasil is ideal when:
 ## 📝 Practical Examples
 
 <details>
-<summary>Create a worktree and enter it immediately</summary>
+<summary>Create a worktree with the guided post-create flow</summary>
 
 **Command:**
 
@@ -480,25 +508,25 @@ yggtree wt create feat/login-flow
 * Creates a new branch if it doesn’t exist (without inheriting base tracking), then publishes it to `origin` when possible
 * Creates a dedicated worktree
 * Runs bootstrap if enabled
-* Drops you into a sub-shell inside the worktree
+* Lets you choose whether to open an IDE or agent after creation
 
 
 </details>
 ---
 
 <details>
-<summary>Create a worktree without bootstrap and without entering</summary>
+<summary>Create a worktree without bootstrap and without opening a tool</summary>
 
 **Command:**
 
 ```
-yggtree wt create feat/cleanup-api --no-bootstrap --no-enter
+yggtree wt create feat/cleanup-api --no-bootstrap --no-open
 ```
 
 **When to use:**
 
 * You just want the folder ready
-* You’ll enter it later
+* You’ll open or enter it later if needed
 * You don’t want installs running automatically
 
 </details>

package/dist/commands/wt/close.js

@@ -0,0 +1,96 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { listWorktrees, removeWorktree, getRepoRoot } from '../../lib/git.js';
+import { log, createSpinner } from '../../lib/ui.js';
+import { detectWorktreeType, formatWorktreeDisplayPath, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
+/**
+ * Terminate the parent sub-shell and exit.
+ * Sends SIGHUP to the parent process (the spawned shell from `wt enter`)
+ * so the user doesn't get stranded in a dead directory.
+ */
+function exitSubShell() {
+    try {
+        process.kill(process.ppid, 'SIGHUP');
+    }
+    catch {
+        log.dim('Type "exit" to leave the sub-shell.');
+    }
+    process.exit(0);
+}
+/**
+ * Close command — gracefully exit a worktree sub-shell.
+ *
+ * When inside an yggtree sub-shell (YGGTREE_SHELL=true), this command:
+ * 1. Asks whether you want to delete the worktree you're leaving.
+ * 2. If yes, removes the worktree via `git worktree remove`.
+ * 3. Terminates the parent sub-shell so the user returns to their original terminal.
+ *
+ * Outside a sub-shell it simply informs the user.
+ */
+export async function closeCommand() {
+    const isSubShell = process.env.YGGTREE_SHELL === 'true';
+    if (!isSubShell) {
+        log.info('Not inside an Yggdrasil sub-shell. Use `exit` to leave your terminal.');
+        return;
+    }
+    try {
+        const currentPath = await getRepoRoot();
+        const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
+        const currentWt = worktrees.find(wt => wt.path === currentPath);
+        if (!currentWt) {
+            log.info('Bye! \ud83d\udc4b');
+            exitSubShell();
+        }
+        const branchName = getWorktreeBranchName(currentWt);
+        const type = await detectWorktreeType(currentWt, mainWorktreePath);
+        const displayPath = formatWorktreeDisplayPath(currentWt.path);
+        const isMain = type === 'MAIN';
+        const isManaged = isManagedWorktreePath(currentWt.path);
+        // Main worktree can't be deleted — just exit
+        if (isMain) {
+            log.info('Bye! \ud83d\udc4b');
+            exitSubShell();
+        }
+        console.log('');
+        log.info(`Leaving worktree: ${chalk.yellow(branchName)} ${chalk.dim(`(${displayPath})`)}`);
+        const { shouldDelete } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'shouldDelete',
+                message: `Delete this worktree before leaving?${isManaged ? '' : chalk.dim(' (external worktree \u2014 will use --force)')}`,
+                default: false,
+            }]);
+        if (shouldDelete) {
+            const { confirmDelete } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirmDelete',
+                    message: `Are you sure? This will remove ${chalk.bold.yellow(branchName)} at ${chalk.cyan(displayPath)}.`,
+                    default: false,
+                }]);
+            if (confirmDelete) {
+                const spinner = createSpinner(`Deleting ${displayPath}...`).start();
+                try {
+                    await removeWorktree(currentWt.path);
+                    spinner.succeed(`Deleted worktree: ${displayPath}`);
+                }
+                catch (e) {
+                    spinner.fail(`Failed to delete ${displayPath}`);
+                    log.actionableError(e.message, `git worktree remove ${currentWt.path} --force`, currentWt.path, [
+                        `Try running manually: git worktree remove ${currentWt.path} --force`,
+                        'Check if any files in the worktree are open or locked',
+                        'Try running yggtree wt prune to clean up git metadata',
+                    ]);
+                }
+            }
+            else {
+                log.info('Deletion cancelled.');
+            }
+        }
+        log.info('Bye! \ud83d\udc4b');
+        exitSubShell();
+    }
+    catch (error) {
+        log.error(error.message);
+        process.exit(1);
+    }
+}

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

@@ -5,14 +5,16 @@ 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 { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
-import { spawn } from 'child_process';
 import fs from 'fs-extra';
 export async function createCommandNew(options) {
     try {
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        if (options.enter !== undefined) {
+            log.warning('`--enter` / `--no-enter` is deprecated. Use `--open` / `--no-open` instead.');
+        }
         // 1. Gather inputs
         const currentBranch = await getCurrentBranch();
         const answers = await inquirer.prompt([
@@ -51,28 +53,25 @@ export async function createCommandNew(options) {
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             },
-            {
-                type: 'confirm',
-                name: 'shouldEnter',
-                message: 'Do you want to enter the new worktree now?',
-                default: true,
-                when: options.enter === undefined,
-            },
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
                 message: 'Open a tool after creation? (IDE or agent CLI)',
                 default: false,
-                when: options.exec === undefined,
+                when: options.exec === undefined && options.open === undefined && options.enter === 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 shouldOpenTool = options.open !== undefined
+            ? options.open
+            : options.enter !== undefined
+                ? options.enter
+                : Boolean(answers.shouldOpenTool);
         let selectedTool;
-        if (options.exec === undefined && answers.shouldOpenTool) {
+        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.');
@@ -81,7 +80,6 @@ export async function createCommandNew(options) {
                 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}`;
@@ -154,23 +152,23 @@ export async function createCommandNew(options) {
             await runBootstrap(wtPath, repoRoot);
         }
         // 5. Exec Command
-        if (execCommandStr && execCommandStr.trim()) {
-            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+        if (options.exec && options.exec.trim()) {
+            log.info(`Executing: ${options.exec} in ${ui.path(wtPath)}`);
             try {
-                await execa(execCommandStr, {
+                await execa(options.exec, {
                     cwd: wtPath,
                     stdio: 'inherit',
                     shell: true
                 });
             }
             catch (error) {
-                log.actionableError(error.message, execCommandStr, wtPath, [
-                    `cd ${wtPath} && ${execCommandStr}`,
+                log.actionableError(error.message, options.exec, wtPath, [
+                    `cd ${wtPath} && ${options.exec}`,
                     'Check your command syntax and environment variables'
                 ]);
             }
         }
-        if (selectedTool && !isAgentTool(selectedTool)) {
+        else if (selectedTool) {
             try {
                 log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
                 await launchOpenTool(selectedTool, wtPath);
@@ -181,21 +179,7 @@ export async function createCommandNew(options) {
         }
         // 6. Final Output
         log.success('Worktree ready!');
-        if (shouldEnter) {
-            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
-            log.dim('Type "exit" to return to the main terminal.');
-            const shell = process.env.SHELL || 'zsh';
-            const child = spawn(shell, [], {
-                cwd: wtPath,
-                stdio: 'inherit',
-            });
-            child.on('close', () => {
-                log.info('Exited sub-shell.');
-            });
-        }
-        else {
-            log.header(`cd "${wtPath}"`);
-        }
+        log.header(`cd "${wtPath}"`);
     }
     catch (error) {
         log.actionableError(error.message, 'yggtree wt create');

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

@@ -6,14 +6,16 @@ import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { generateSandboxName, normalizeSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
-import { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
+import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
-import { spawn } from 'child_process';
 import fs from 'fs-extra';
 export async function createSandboxCommand(options = {}) {
     try {
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        if (options.enter !== undefined) {
+            log.warning('`--enter` / `--no-enter` is deprecated. Use `--open` / `--no-open` instead.');
+        }
         // 1. Auto-detect current branch (no prompt!)
         const currentBranch = await getCurrentBranch();
         if (!currentBranch) {
@@ -61,19 +63,12 @@ export async function createSandboxCommand(options = {}) {
                 default: true,
                 when: options.bootstrap === undefined,
             },
-            {
-                type: 'confirm',
-                name: 'shouldEnter',
-                message: 'Do you want to enter the sandbox now?',
-                default: true,
-                when: options.enter === undefined,
-            },
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
                 message: 'Open a tool after creation? (IDE or agent CLI)',
                 default: false,
-                when: options.exec === undefined,
+                when: options.exec === undefined && options.open === undefined && options.enter === undefined,
             },
         ]);
         const requestedSandboxName = options.name !== undefined ? options.name : answers.name || '';
@@ -89,10 +84,14 @@ export async function createSandboxCommand(options = {}) {
         }
         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 shouldOpenTool = options.open !== undefined
+            ? options.open
+            : options.enter !== undefined
+                ? options.enter
+                : Boolean(answers.shouldOpenTool);
         let selectedTool;
-        if (options.exec === undefined && answers.shouldOpenTool) {
+        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.');
@@ -101,7 +100,6 @@ export async function createSandboxCommand(options = {}) {
                 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 = [];
@@ -187,23 +185,23 @@ export async function createSandboxCommand(options = {}) {
             await runBootstrap(wtPath, repoRoot);
         }
         // 9. Exec command
-        if (execCommandStr && execCommandStr.trim()) {
-            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+        if (options.exec && options.exec.trim()) {
+            log.info(`Executing: ${options.exec} in ${ui.path(wtPath)}`);
             try {
-                await execa(execCommandStr, {
+                await execa(options.exec, {
                     cwd: wtPath,
                     stdio: 'inherit',
                     shell: true
                 });
             }
             catch (error) {
-                log.actionableError(error.message, execCommandStr, wtPath, [
-                    `cd ${wtPath} && ${execCommandStr}`,
+                log.actionableError(error.message, options.exec, wtPath, [
+                    `cd ${wtPath} && ${options.exec}`,
                     'Check your command syntax and environment variables'
                 ]);
             }
         }
-        if (selectedTool && !isAgentTool(selectedTool)) {
+        else if (selectedTool) {
             try {
                 log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
                 await launchOpenTool(selectedTool, wtPath);
@@ -216,21 +214,7 @@ export async function createSandboxCommand(options = {}) {
         log.success('Sandbox ready!');
         log.info(`Use ${chalk.cyan('yggtree wt apply')} to apply changes to origin.`);
         log.info(`Use ${chalk.cyan('yggtree wt unapply')} to undo applied changes.`);
-        if (shouldEnter) {
-            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
-            log.dim('Type "exit" to return to the main terminal.');
-            const shell = process.env.SHELL || 'zsh';
-            const child = spawn(shell, [], {
-                cwd: wtPath,
-                stdio: 'inherit',
-            });
-            child.on('close', () => {
-                log.info('Exited sub-shell.');
-            });
-        }
-        else {
-            log.header(`cd "${wtPath}"`);
-        }
+        log.header(`cd "${wtPath}"`);
     }
     catch (error) {
         log.actionableError(error.message, 'yggtree wt create-sandbox');

package/dist/commands/wt/create.js

@@ -7,9 +7,8 @@ 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 { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
-import { spawn } from 'child_process';
 import fs from 'fs-extra';
 function toSlug(value) {
     return value
@@ -64,6 +63,9 @@ export async function createCommand(options) {
     try {
         const repoRoot = await getRepoRoot();
         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();
@@ -114,12 +116,37 @@ export async function createCommand(options) {
         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) {
+            if (options.exec && options.exec.trim()) {
+                log.info('Reusing the existing worktree and running the requested command...');
+                await enterCommand(existingManagedWorktree.path, { exec: options.exec });
+                return;
+            }
+            const shouldOpenExisting = options.open !== undefined
+                ? options.open
+                : options.enter !== undefined
+                    ? options.enter
+                    : (await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'shouldOpenTool',
+                            message: 'Open a tool in the existing worktree now? (IDE or agent CLI)',
+                            default: true,
+                        },
+                    ])).shouldOpenTool;
+            if (!shouldOpenExisting) {
+                log.header(`cd "${existingManagedWorktree.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}"`);
                 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 enterCommand(existingManagedWorktree.path, { exec: options.exec ?? '' });
+            await launchOpenTool(selectedTool, existingManagedWorktree.path);
+            log.success('Existing worktree opened.');
             return;
         }
         // 3. Gather remaining inputs
@@ -140,26 +167,23 @@ export async function createCommand(options) {
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             },
-            {
-                type: 'confirm',
-                name: 'shouldEnter',
-                message: 'Do you want to enter the new worktree now?',
-                default: true,
-                when: options.enter === undefined,
-            },
             {
                 type: 'confirm',
                 name: 'shouldOpenTool',
                 message: 'Open a tool after creation? (IDE or agent CLI)',
                 default: false,
-                when: options.exec === undefined,
+                when: options.exec === undefined && options.open === undefined && options.enter === undefined,
             },
         ]);
         const name = options.name || answers.name;
-        const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const shouldOpenTool = options.open !== undefined
+            ? options.open
+            : options.enter !== undefined
+                ? options.enter
+                : Boolean(answers.shouldOpenTool);
         let selectedTool;
-        if (options.exec === undefined && answers.shouldOpenTool) {
+        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.');
@@ -168,7 +192,6 @@ export async function createCommand(options) {
                 selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
             }
         }
-        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);
@@ -204,23 +227,23 @@ export async function createCommand(options) {
             await runBootstrap(wtPath, repoRoot);
         }
         // 6. Exec Command
-        if (execCommandStr && execCommandStr.trim()) {
-            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+        if (options.exec && options.exec.trim()) {
+            log.info(`Executing: ${options.exec} in ${ui.path(wtPath)}`);
             try {
-                await execa(execCommandStr, {
+                await execa(options.exec, {
                     cwd: wtPath,
                     stdio: 'inherit',
                     shell: true
                 });
             }
             catch (error) {
-                log.actionableError(error.message, execCommandStr, wtPath, [
-                    `cd ${wtPath} && ${execCommandStr}`,
+                log.actionableError(error.message, options.exec, wtPath, [
+                    `cd ${wtPath} && ${options.exec}`,
                     'Check your command syntax and environment variables'
                 ]);
             }
         }
-        if (selectedTool && !isAgentTool(selectedTool)) {
+        else if (selectedTool) {
             try {
                 log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
                 await launchOpenTool(selectedTool, wtPath);
@@ -231,21 +254,7 @@ export async function createCommand(options) {
         }
         // 7. Final Output
         log.success('Worktree ready!');
-        if (shouldEnter) {
-            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
-            log.dim('Type "exit" to return to the main terminal.');
-            const shell = process.env.SHELL || 'zsh';
-            const child = spawn(shell, [], {
-                cwd: wtPath,
-                stdio: 'inherit',
-            });
-            child.on('close', () => {
-                log.info('Exited sub-shell.');
-            });
-        }
-        else {
-            log.header(`cd "${wtPath}"`);
-        }
+        log.header(`cd "${wtPath}"`);
     }
     catch (error) {
         log.actionableError(error.message, 'yggtree wt worktree-checkout');

package/dist/commands/wt/enter.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
 import { log, ui } from '../../lib/ui.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 '';
@@ -36,7 +37,31 @@ function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
 }
 export async function enterCommand(wtName, options = {}) {
     try {
-        await getRepoRoot();
+        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);
+        }
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {

package/dist/commands/wt/list.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
-import { listWorktrees, getRepoRoot, isGitClean, getLastActivity } from '../../lib/git.js';
+import { listWorktrees, getRepoRoot, isGitClean, getLastActivity, isGhAvailable, getPrStatusBatch } from '../../lib/git.js';
 import { log, timeAgo } from '../../lib/ui.js';
-import { detectWorktreeType, formatWorktreeType, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
+import { detectWorktreeType, formatWorktreeType, formatPrStatus, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
 export async function listCommand() {
     try {
         await getRepoRoot(); // Verify we are in a git repo
@@ -11,10 +11,17 @@ export async function listCommand() {
             log.info('No worktrees found.');
             return;
         }
+        // Determine if PR status column should be shown
+        const ghReady = await isGhAvailable();
+        // Collect branch names for batch PR lookup
+        const branches = worktrees.map(wt => getWorktreeBranchName(wt));
+        const prStatusMap = ghReady ? await getPrStatusBatch(branches) : new Map();
+        const showPr = prStatusMap.size > 0;
         console.log(chalk.bold('\n  Active Worktrees:\n'));
-        // Header
-        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}    ${chalk.dim('BRANCH')}`);
-        console.log(chalk.dim('  ' + '-'.repeat(70)));
+        // Header — PR column only appears when there's data
+        const headerPr = showPr ? `${chalk.dim('PR')}            ` : '';
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}     ${headerPr}${chalk.dim('BRANCH')}`);
+        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),
@@ -27,8 +34,12 @@ export async function listCommand() {
             const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
             const activeLabel = lastActive ? timeAgo(lastActive) : '—';
             const activeText = chalk.magenta(activeLabel.padEnd(14));
+            const prStatus = prStatusMap.get(branchName);
+            const prText = showPr
+                ? (prStatus ? formatPrStatus(prStatus).padEnd(24) : chalk.dim('—'.padEnd(14)))
+                : '';
             return {
-                text: `  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`,
+                text: `  ${type}  ${stateText} ${activeText} ${prText}${chalk.yellow(branchName)}`,
                 sortType: WORKTREE_TYPE_ORDER[typeKey],
                 sortBranch: branchName.toLowerCase(),
                 sortIndex: index,
@@ -39,6 +50,12 @@ export async function listCommand() {
             a.sortBranch.localeCompare(b.sortBranch) ||
             a.sortIndex - b.sortIndex)
             .forEach(row => console.log(row.text));
+        if (ghReady && !showPr) {
+            console.log(chalk.dim('\n  ℹ No open PRs found for any worktree branch.'));
+        }
+        else if (!ghReady) {
+            console.log(chalk.dim('\n  ℹ PR status omitted (gh CLI not found). Install GitHub CLI for PR tracking.'));
+        }
         console.log('');
     }
     catch (error) {

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';
@@ -15,6 +15,7 @@ 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 { closeCommand } from './commands/wt/close.js';
 import { unapplyCommand } from './commands/wt/unapply.js';
 import { getVersion } from './lib/version.js';
 import { findSandboxRoot } from './lib/sandbox.js';
@@ -42,6 +43,7 @@ program
         { 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' },
+        { name: `🔒 Close Realm ${chalk.dim('(exit & optionally delete worktree)')}`, value: 'close' },
     ];
     const sandboxChoices = [
         { name: `✅ Graft Sandbox Changes ${chalk.dim('(apply sandbox changes)')}`, value: 'apply' },
@@ -125,6 +127,9 @@ program
         case 'thor':
             await thorCommand();
             break;
+        case 'close':
+            await closeCommand();
+            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -148,8 +153,10 @@ wt.command('create [branch]')
     .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('--open', 'Open a tool after creation (IDE or agent CLI)')
+    .option('--no-open', 'Skip opening a tool 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({
@@ -170,8 +177,10 @@ wt.command('worktree-checkout [name] [ref]')
     .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('--open', 'Open a tool after creation (IDE or agent CLI)')
+    .option('--no-open', 'Skip opening a tool 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 (name, ref, options) => {
     await createCommand({
@@ -223,8 +232,10 @@ wt.command('create-sandbox')
     .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('--open', 'Open a tool after creation (IDE or agent CLI)')
+    .option('--no-open', 'Skip opening a tool 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);
@@ -232,6 +243,11 @@ wt.command('create-sandbox')
 wt.command('apply')
     .description('Apply sandbox changes to origin directory')
     .action(applyCommand);
+wt.command('close')
+    .description('Exit the sub-shell with an option to delete the worktree')
+    .action(async () => {
+    await closeCommand();
+});
 wt.command('unapply')
     .description('Undo applied sandbox changes in origin')
     .action(unapplyCommand);

package/dist/lib/git.js

@@ -3,10 +3,18 @@ import fs from 'fs-extra';
 import path from 'path';
 import { log } from './ui.js';
 import chalk from 'chalk';
+import { registerRepo } from './registry.js';
+let cachedRepoRoot = null;
 export async function getRepoRoot() {
+    if (cachedRepoRoot)
+        return cachedRepoRoot;
     try {
         const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
-        return stdout.trim();
+        cachedRepoRoot = stdout.trim();
+        // Silently register the repo in the background
+        const name = path.basename(cachedRepoRoot);
+        registerRepo(name, cachedRepoRoot).catch(() => { });
+        return cachedRepoRoot;
     }
     catch (error) {
         throw new Error('Not a git repository');
@@ -130,13 +138,83 @@ export async function publishBranch(wtPath, branchName) {
     log.info(`Publishing ${chalk.cyan(branchName)} → ${chalk.cyan(desiredUpstream)}...`);
     await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
 }
+let ghAvailableCache = null;
 /**
- * Returns the most recent activity date for a worktree by checking two signals:
- * 1. Last commit time (captures committed work)
- * 2. Git index mtime (captures staging, checkouts, uncommitted work)
- *
- * The most recent of the two wins. Returns null if both fail.
+ * Check whether `gh` CLI is installed and authenticated.
+ * Result is cached for the process lifetime.
+ */
+export async function isGhAvailable() {
+    if (ghAvailableCache !== null)
+        return ghAvailableCache;
+    try {
+        await execa('gh', ['auth', 'status'], { stdio: 'ignore' });
+        ghAvailableCache = true;
+    }
+    catch {
+        ghAvailableCache = false;
+    }
+    return ghAvailableCache;
+}
+function derivePrLabel(state, reviewDecision) {
+    if (state === 'merged')
+        return 'MERGED';
+    if (state === 'closed')
+        return 'CLOSED';
+    if (state === 'draft')
+        return 'DRAFT';
+    // state === 'open'
+    if (reviewDecision === 'approved')
+        return 'APPROVED';
+    if (reviewDecision === 'changes_requested')
+        return 'CHANGES';
+    if (reviewDecision === 'review_required')
+        return 'IN REVIEW';
+    return 'OPEN';
+}
+/**
+ * Fetch PR status for a branch using `gh pr view`.
+ * Returns null when `gh` is unavailable or the branch has no PR.
  */
+export async function getPrStatusForBranch(branch, cwd) {
+    if (!branch || branch === 'detached')
+        return null;
+    try {
+        const { stdout } = await execa('gh', ['pr', 'view', branch, '--json', 'state,reviewDecision,isDraft,number'], { cwd, timeout: 10_000 });
+        const data = JSON.parse(stdout);
+        const isDraft = data.isDraft === true;
+        const rawState = (data.state || '').toLowerCase();
+        const state = isDraft && rawState === 'open' ? 'draft' : rawState;
+        const reviewDecision = (data.reviewDecision || '').toLowerCase().replace(/ /g, '_') || null;
+        return {
+            state,
+            reviewDecision,
+            label: derivePrLabel(state, reviewDecision),
+            number: data.number,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Batch-fetch PR statuses for all provided branches (parallelized).
+ * Returns a Map<branchName, PrStatus>.
+ * If `gh` is unavailable, returns an empty map immediately.
+ */
+export async function getPrStatusBatch(branches, cwd) {
+    const map = new Map();
+    if (!(await isGhAvailable()))
+        return map;
+    const results = await Promise.all(branches.map(async (branch) => {
+        const status = await getPrStatusForBranch(branch, cwd);
+        return { branch, status };
+    }));
+    for (const { branch, status } of results) {
+        if (status)
+            map.set(branch, status);
+    }
+    return map;
+}
 export async function getLastActivity(wtPath) {
     const dates = [];
     // Signal 1 — last commit epoch

package/dist/lib/registry.js

@@ -0,0 +1,81 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { YGG_ROOT } from './paths.js';
+const REGISTRY_PATH = path.join(YGG_ROOT, 'registry.json');
+/**
+ * Read the registry, initializing if missing.
+ */
+export async function readRegistry() {
+    try {
+        if (await fs.pathExists(REGISTRY_PATH)) {
+            return await fs.readJson(REGISTRY_PATH);
+        }
+    }
+    catch {
+        // Ignore JSON read errors, just return empty
+    }
+    return { repos: {} };
+}
+/**
+ * Write the registry back to disk.
+ */
+async function writeRegistry(registry) {
+    await fs.ensureDir(YGG_ROOT);
+    await fs.writeJson(REGISTRY_PATH, registry, { spaces: 2 });
+}
+/**
+ * Silently register a repository path.
+ * This is meant to be called in the background (fire-and-forget).
+ */
+export async function registerRepo(repoName, repoRoot) {
+    try {
+        const registry = await readRegistry();
+        // Only write if it actually changed
+        if (registry.repos[repoName] !== repoRoot) {
+            registry.repos[repoName] = repoRoot;
+            await writeRegistry(registry);
+        }
+    }
+    catch {
+        // Fail silently — registry is a nice-to-have, shouldn't crash commands
+    }
+}
+/**
+ * Get a specific repo path from the registry.
+ * Also verifies the path still exists on disk, removing it if not.
+ */
+export async function getRegisteredRepoPath(repoName) {
+    const registry = await readRegistry();
+    const repoPath = registry.repos[repoName];
+    if (!repoPath)
+        return null;
+    // Prune dead links
+    if (!(await fs.pathExists(repoPath))) {
+        delete registry.repos[repoName];
+        await writeRegistry(registry).catch(() => { });
+        return null;
+    }
+    return repoPath;
+}
+/**
+ * Get all registered repos that still exist on disk.
+ */
+export async function getValidRegisteredRepos() {
+    const registry = await readRegistry();
+    const valid = {};
+    let changed = false;
+    // Validate in parallel
+    await Promise.all(Object.entries(registry.repos).map(async ([name, rPath]) => {
+        if (await fs.pathExists(rPath)) {
+            valid[name] = rPath;
+        }
+        else {
+            delete registry.repos[name];
+            changed = true;
+        }
+    }));
+    if (changed) {
+        await writeRegistry(registry).catch(() => { });
+    }
+    return valid;
+}

package/dist/lib/worktree.js

@@ -50,3 +50,15 @@ export function formatWorktreeType(type) {
         return chalk.blue('MAIN   ');
     return chalk.cyan('LINKED ');
 }
+export function formatPrStatus(pr) {
+    switch (pr.label) {
+        case 'MERGED': return chalk.magenta(`#${pr.number} MERGED`);
+        case 'APPROVED': return chalk.green(`#${pr.number} APPROVED`);
+        case 'CHANGES': return chalk.red(`#${pr.number} CHANGES`);
+        case 'IN REVIEW': return chalk.yellow(`#${pr.number} IN REVIEW`);
+        case 'DRAFT': return chalk.dim(`#${pr.number} DRAFT`);
+        case 'OPEN': return chalk.cyan(`#${pr.number} OPEN`);
+        case 'CLOSED': return chalk.dim(`#${pr.number} CLOSED`);
+        default: return chalk.dim(`#${pr.number} ${pr.label}`);
+    }
+}

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "yggtree",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",
+  "repository": {
+    "url": "github.com/leoreisdias/yggdrasil-worktree",
+    "type": "git"
+  },
+  "homepage": "yggtree.logbookfordevs.com",
   "bin": {
     "yggtree": "./bin/yggtree"
   },