yggtree 1.4.6 → 1.5.0

package/README.md

@@ -16,12 +16,14 @@ For guided workflows, command examples, and safety notes, read the full docs:
 
 ### Installation
 
-Install globally:
+Install the latest release:
 
 ```bash
-npm install -g yggtree
+curl -fsSL https://yggtree.logbookfordevs.com/install.sh | bash
 ```
 
+Prefer npm globals? `npm install -g yggtree` still works.
+
 Or try it without installing:
 
 ```bash
@@ -155,8 +157,8 @@ Started in your main checkout? Carry staged, unstaged, and untracked work into a
 🤖 **AI-friendly isolation**
 One worktree per agent, per experiment, per idea. No shared state, no collisions.
 
-⚡ **Automatic bootstrapping**
-Run installs, submodules, and setup scripts automatically for each worktree.
+⚡ **Configurable bootstrapping**
+Run project setup commands for each worktree when configured.
 
 🚪 **Enter, exec, and exit with ease**
 Enter worktrees, execute commands, or run tasks without changing directories.
@@ -181,7 +183,7 @@ Each command creates:
 
 * A clean folder
 * A dedicated branch
-* A bootstrapped environment
+* Optional bootstrap setup when configured
 
 No stash juggling.
 No branch confusion.
@@ -233,7 +235,8 @@ yggtree handoff --name auth-refactor
 
 ## ⚡ Bootstrapping & Configuration
 
-Yggdrasil automatically prepares each worktree.
+Yggdrasil can prepare each worktree with configured setup commands. If no bootstrap config is found, it skips setup and prints a small tip.
+The first interactive create flow in a repo offers to create `.yggtree/worktree-setup.json`; declining skips the offer on later runs.
 
 Resolution order:
 
@@ -243,21 +246,39 @@ Resolution order:
 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
+7. No setup commands
 
 ### Example configuration
 
 ```json
 {
   "setup-worktree": [
-    "npm install",
+    "pnpm install",
     "git submodule sync --recursive",
     "git submodule update --init --recursive",
-    "echo \"🌳 Realm ready\""
+    "echo \"Realm ready\""
   ]
 }
 ```
 
+Create local setup config in the current directory interactively:
+
+```bash
+yggtree config bootstrap
+```
+
+Or create it non-interactively:
+
+```bash
+yggtree config bootstrap --command "pnpm install" --command "pnpm test"
+```
+
+Clear local setup config from the current directory:
+
+```bash
+yggtree config bootstrap --clear
+```
+
 ---
 
 ## 🗂️ Global Worktree Paths
@@ -574,6 +595,12 @@ Re‑run bootstrap commands for a worktree.
 
 ---
 
+### `yggtree config bootstrap`
+
+Set local bootstrap commands in `.yggtree/worktree-setup.json` under the current directory.
+
+---
+
 ### `yggtree delete [worktrees...]`
 
 Delete worktrees interactively or by explicit name.

package/dist/commands/config.js

@@ -1,4 +1,6 @@
 import chalk from 'chalk';
+import { clearBootstrapCommands, writeBootstrapCommands, } from '../lib/config.js';
+import { promptBootstrapCommands } from '../lib/bootstrap-config-prompt.js';
 import { formatGlobalConfig, getPresetConfig, getWorktreePathConfig, normalizeWorktreesRootInput, readGlobalConfig, writeGlobalConfig, } from '../lib/global-config.js';
 import { log } from '../lib/ui.js';
 export async function configGetCommand() {
@@ -46,6 +48,26 @@ export async function configSetWorktreeLayoutCommand(layout) {
     log.success('Updated worktree layout.');
     await configGetCommand();
 }
+export async function configBootstrapCommand(options) {
+    const targetRoot = process.cwd();
+    if (options.clear) {
+        const configPath = await clearBootstrapCommands(targetRoot);
+        log.success('Cleared local bootstrap commands.');
+        log.dim(`Removed ${chalk.cyan(configPath)} if it existed.`);
+        return;
+    }
+    const commandOptions = options.command?.map(command => command.trim()).filter(Boolean) ?? [];
+    const commands = commandOptions.length > 0
+        ? commandOptions
+        : await promptBootstrapCommands();
+    if (commands.length === 0) {
+        log.info('No bootstrap commands provided.');
+        return;
+    }
+    const configPath = await writeBootstrapCommands(targetRoot, commands);
+    log.success('Updated local bootstrap commands.');
+    log.dim(`Saved to ${chalk.cyan(configPath)}.`);
+}
 export async function configResetCommand() {
     await writeGlobalConfig({});
     log.success('Reset Yggtree config to defaults.');

package/dist/commands/update.js

@@ -0,0 +1,10 @@
+import { execa } from 'execa';
+import { log } from '../lib/ui.js';
+export const INSTALL_COMMAND = 'curl -fsSL https://yggtree.logbookfordevs.com/install.sh | bash';
+export async function updateCommand() {
+    log.info('Installing the latest Yggtree release...');
+    log.dim(`Run: ${INSTALL_COMMAND}`);
+    await execa('bash', ['-c', INSTALL_COMMAND], {
+        stdio: 'inherit',
+    });
+}

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

@@ -3,9 +3,11 @@ import inquirer from 'inquirer';
 import path from 'path';
 import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream, publishBranch } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
+import { maybeOfferBootstrapSetupConfig } from '../../lib/bootstrap-setup-onboarding.js';
 import { buildManagedWorktreePath, getWorktreePathConfig } from '../../lib/global-config.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
+import { readRegistry } from '../../lib/registry.js';
 import { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { enterCommand } from './enter.js';
 import { execa } from 'execa';
@@ -15,11 +17,18 @@ export function shouldEnterCreatedWorktree(options) {
 }
 export async function createCommandNew(options) {
     try {
+        const registeredReposBefore = await readRegistry();
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
         const shouldEnterShell = shouldEnterCreatedWorktree(options);
+        const isInteractiveCreate = !options.branch || !options.base || (!options.base && !options.source);
         // 1. Gather inputs
         const currentBranch = await getCurrentBranch();
+        const bootstrapSetupOnboarding = await maybeOfferBootstrapSetupConfig({
+            interactive: isInteractiveCreate,
+            registeredReposBefore,
+            repoRoot,
+        });
         const answers = await inquirer.prompt([
             {
                 type: 'input',
@@ -52,7 +61,7 @@ export async function createCommandNew(options) {
             {
                 type: 'confirm',
                 name: 'bootstrap',
-                message: 'Run bootstrap? (npm install + submodules)',
+                message: 'Run configured bootstrap commands?',
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             },
@@ -67,7 +76,9 @@ export async function createCommandNew(options) {
         const branchName = options.branch || answers.branch;
         let baseRef = options.base || answers.base;
         const source = options.source || answers.source;
-        const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const shouldBootstrap = bootstrapSetupOnboarding.skipBootstrap
+            ? false
+            : options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
         const shouldOpenTool = options.open !== undefined
             ? options.open
             : Boolean(answers.shouldOpenTool);

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

@@ -44,7 +44,7 @@ export async function createCommandMulti(options) {
             {
                 type: 'confirm',
                 name: 'bootstrap',
-                message: 'Run bootstrap for all worktrees? (npm install + submodules)',
+                message: 'Run configured bootstrap commands for all worktrees?',
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             }

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

@@ -60,7 +60,7 @@ export async function createSandboxCommand(options = {}) {
             {
                 type: 'confirm',
                 name: 'bootstrap',
-                message: 'Run bootstrap? (npm install + submodules)',
+                message: 'Run configured bootstrap commands?',
                 default: true,
                 when: options.bootstrap === undefined,
             },

package/dist/commands/wt/create.js

@@ -3,11 +3,13 @@ import inquirer from 'inquirer';
 import path from 'path';
 import { getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
+import { maybeOfferBootstrapSetupConfig } from '../../lib/bootstrap-setup-onboarding.js';
 import { buildManagedWorktreePath, getWorktreePathConfig } from '../../lib/global-config.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { ensureAutocompletePrompt } from '../../lib/prompt.js';
 import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
 import { ensureRepoContext } from '../../lib/repo-context.js';
+import { readRegistry } from '../../lib/registry.js';
 import { enterCommand } from './enter.js';
 import { detectInstalledOpenTools, promptOpenActions, resolveOpenToolAction, runOpenActions, } from './open.js';
 import { execa } from 'execa';
@@ -100,8 +102,15 @@ export function getWorktreePathCollisionMessage(worktreeName, wtPath, worktrees)
 }
 export async function createCommand(options) {
     try {
+        const registeredReposBefore = await readRegistry();
         const repoRoot = await ensureRepoContext();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        const isInteractiveCreate = !options.ref || !options.name;
+        const bootstrapSetupOnboarding = await maybeOfferBootstrapSetupConfig({
+            interactive: isInteractiveCreate,
+            registeredReposBefore,
+            repoRoot,
+        });
         // 1. Load branches
         const loadingSpinner = createSpinner('Fetching branches...').start();
         await fetchAll();
@@ -223,7 +232,7 @@ export async function createCommand(options) {
             {
                 type: 'confirm',
                 name: 'bootstrap',
-                message: 'Run bootstrap? (npm install + submodules)',
+                message: 'Run configured bootstrap commands?',
                 default: true,
                 when: options.bootstrap !== false && options.bootstrap !== true,
             },
@@ -252,7 +261,9 @@ export async function createCommand(options) {
             ]);
             return;
         }
-        const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const shouldBootstrap = bootstrapSetupOnboarding.skipBootstrap
+            ? false
+            : options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
         const shouldOpenTool = options.tool
             ? true
             : options.open !== undefined

package/dist/index.js

@@ -20,7 +20,8 @@ import { applyCommand } from './commands/wt/apply.js';
 import { unapplyCommand } from './commands/wt/unapply.js';
 import { handoffCommand } from './commands/wt/handoff.js';
 import { copyEnvCommand } from './commands/wt/copy-env.js';
-import { configGetCommand, configResetCommand, configSetWorktreeLayoutCommand, configSetWorktreesRootCommand, configUseCommand, } from './commands/config.js';
+import { updateCommand } from './commands/update.js';
+import { configBootstrapCommand, configGetCommand, configResetCommand, configSetWorktreeLayoutCommand, configSetWorktreesRootCommand, configUseCommand, } from './commands/config.js';
 import { getVersion } from './lib/version.js';
 import { checkForUpdate } from './lib/update-check.js';
 import { findSandboxRoot } from './lib/sandbox.js';
@@ -48,7 +49,7 @@ const mainMenuChoices = {
     list: mainMenuChoice('list', '○', 'Survey realms', 'scan active worktrees and PR state', 'tending'),
     'create-multi': mainMenuChoice('create-multi', '✧', 'Grow many realms', 'create multiple branch worktrees', 'growth'),
     'create-sandbox': mainMenuChoice('create-sandbox', '△', 'Forge sandbox', 'create a local experiment realm', 'sandbox'),
-    bootstrap: mainMenuChoice('bootstrap', '↳', 'Bootstrap realm', 'install dependencies and submodules', 'tending'),
+    bootstrap: mainMenuChoice('bootstrap', '↳', 'Bootstrap realm', 'run configured setup commands', 'tending'),
     exec: mainMenuChoice('exec', '⌁', 'Cast command', 'run a command inside a worktree', 'tending'),
     path: mainMenuChoice('path', '⌖', 'Reveal path', 'print a worktree cd command', 'tending'),
     'copy-env': mainMenuChoice('copy-env', '≋', 'Bring env files', 'copy local env files from main realm', 'tending'),
@@ -112,7 +113,7 @@ function registerWorktreeCommands(parent) {
         .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('--no-bootstrap', 'Skip configured bootstrap commands')
         .option('--open', 'Open an editor after creation')
         .option('--no-open', 'Skip opening an editor after creation')
         .option('--enter', 'Enter the worktree sub-shell after creation')
@@ -130,7 +131,7 @@ function registerWorktreeCommands(parent) {
         .description('Bulk-create official branch-backed worktrees')
         .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('--no-bootstrap', 'Skip configured bootstrap commands')
         .option('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
         .addHelpText('after', createMultiHelp)
         .action(async (options) => {
@@ -141,7 +142,7 @@ function registerWorktreeCommands(parent) {
             .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('--no-bootstrap', 'Skip configured bootstrap commands')
             .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, app, or terminal command to open after checkout (skips open prompt)')
@@ -203,7 +204,7 @@ function registerWorktreeCommands(parent) {
         .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
         .option('--carry', 'Copy uncommitted changes to sandbox')
         .option('--no-carry', 'Do not copy uncommitted changes')
-        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--no-bootstrap', 'Skip configured bootstrap commands')
         .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())
@@ -217,7 +218,7 @@ function registerWorktreeCommands(parent) {
     parent.command('handoff')
         .description('Carry dirty current work into a named sandbox')
         .option('-n, --name <name>', 'Optional handoff name (prompted when omitted)')
-        .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+        .option('--no-bootstrap', 'Skip configured bootstrap commands')
         .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())
@@ -341,6 +342,9 @@ wt.addHelpText('after', intentRouterHelp);
 registerWorktreeCommands(program);
 registerWorktreeCommands(wt);
 program.addHelpCommand(true);
+program.command('update')
+    .description('Install the latest Yggtree release')
+    .action(updateCommand);
 program.command('bifrost')
     .description('Summon the Bifrost (Easter Egg)')
     .action(bifrostCommand);
@@ -360,6 +364,13 @@ config.command('set-worktrees-root <path>')
 config.command('set-worktree-layout <layout>')
     .description('Set the managed worktree path layout (yggtree, codex, or claude)')
     .action(configSetWorktreeLayoutCommand);
+config.command('bootstrap')
+    .description('Set local worktree bootstrap commands in the current directory')
+    .option('-c, --command <command>', 'Add a bootstrap command; repeat for multiple commands', (value, previous) => {
+    return [...(previous ?? []), value];
+})
+    .option('--clear', 'Remove local bootstrap commands from the current directory')
+    .action(configBootstrapCommand);
 config.command('reset')
     .description('Reset global settings to defaults')
     .action(configResetCommand);

package/dist/lib/bootstrap-config-prompt.js

@@ -0,0 +1,26 @@
+import inquirer from 'inquirer';
+export async function promptBootstrapCommands() {
+    const commands = [];
+    let shouldContinue = true;
+    while (shouldContinue) {
+        const { command } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'command',
+                message: commands.length === 0 ? 'Bootstrap command:' : 'Next bootstrap command:',
+                validate: (value) => value.trim().length > 0 || 'Enter a command.',
+            },
+        ]);
+        commands.push(command.trim());
+        const answer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'addAnother',
+                message: 'Add another command?',
+                default: false,
+            },
+        ]);
+        shouldContinue = answer.addAnother;
+    }
+    return commands;
+}

package/dist/lib/bootstrap-setup-onboarding.js

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import { getBootstrapCommands, writeBootstrapCommands } from './config.js';
+import { promptBootstrapCommands } from './bootstrap-config-prompt.js';
+import { hasRegisteredRepoPath, registerRepo } from './registry.js';
+import { log } from './ui.js';
+export async function maybeOfferBootstrapSetupConfig(options) {
+    if (!options.interactive || !process.stdin.isTTY) {
+        return { created: false, skipBootstrap: false };
+    }
+    if (await hasRegisteredRepoPath(options.repoRoot, options.registeredReposBefore)) {
+        return { created: false, skipBootstrap: false };
+    }
+    if (await getBootstrapCommands(options.repoRoot)) {
+        return { created: false, skipBootstrap: false };
+    }
+    const { shouldCreateSetupConfig } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldCreateSetupConfig',
+            message: 'Create .yggtree/worktree-setup.json for this repo?',
+            default: false,
+        },
+    ]);
+    if (!shouldCreateSetupConfig) {
+        await registerRepo(path.basename(options.repoRoot), options.repoRoot);
+        return { created: false, skipBootstrap: true };
+    }
+    const commands = await promptBootstrapCommands();
+    const configPath = await writeBootstrapCommands(options.repoRoot, commands);
+    log.success('Created local bootstrap config.');
+    log.dim(`Saved to ${chalk.cyan(configPath)}.`);
+    return { created: true, skipBootstrap: false };
+}

package/dist/lib/config.js

@@ -2,6 +2,21 @@ import path from 'path';
 import fs from 'fs-extra';
 import { execa } from 'execa';
 import { log, createSpinner } from './ui.js';
+export function getWorktreeSetupConfigPath(root) {
+    return path.join(root, '.yggtree', 'worktree-setup.json');
+}
+async function readBootstrapCommands(configPath) {
+    try {
+        const config = await fs.readJSON(configPath);
+        if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
+            return config['setup-worktree'];
+        }
+    }
+    catch {
+        log.warning(`Failed to parse ${configPath}.`);
+    }
+    return null;
+}
 export async function getBootstrapCommands(repoRoot, wtPath) {
     // repoRoot first (source of truth — where yggtree is run from)
     // wtPath second (per-worktree override if needed)
@@ -9,45 +24,38 @@ export async function getBootstrapCommands(repoRoot, wtPath) {
     if (wtPath && wtPath !== repoRoot)
         searchPaths.push(wtPath);
     for (const searchPath of searchPaths) {
-        const yggtreeConfigPath = path.join(searchPath, '.yggtree', 'worktree-setup.json');
+        const yggtreeConfigPath = getWorktreeSetupConfigPath(searchPath);
         const configPath = path.join(searchPath, 'yggtree-worktree.json');
         const cursorConfigPath = path.join(searchPath, '.cursor', 'worktrees.json');
         if (await fs.pathExists(yggtreeConfigPath)) {
-            try {
-                const config = await fs.readJSON(yggtreeConfigPath);
-                if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
-                    return config['setup-worktree'];
-                }
-            }
-            catch (e) {
-                log.warning(`Failed to parse ${yggtreeConfigPath}.`);
-            }
+            const commands = await readBootstrapCommands(yggtreeConfigPath);
+            if (commands)
+                return commands;
         }
         if (await fs.pathExists(configPath)) {
-            try {
-                const config = await fs.readJSON(configPath);
-                if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
-                    return config['setup-worktree'];
-                }
-            }
-            catch (e) {
-                log.warning(`Failed to parse ${configPath}.`);
-            }
+            const commands = await readBootstrapCommands(configPath);
+            if (commands)
+                return commands;
         }
         if (await fs.pathExists(cursorConfigPath)) {
-            try {
-                const config = await fs.readJSON(cursorConfigPath);
-                if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
-                    return config['setup-worktree'];
-                }
-            }
-            catch (e) {
-                log.warning(`Failed to parse ${cursorConfigPath}.`);
-            }
+            const commands = await readBootstrapCommands(cursorConfigPath);
+            if (commands)
+                return commands;
         }
     }
     return null;
 }
+export async function writeBootstrapCommands(root, commands) {
+    const configPath = getWorktreeSetupConfigPath(root);
+    await fs.ensureDir(path.dirname(configPath));
+    await fs.writeJSON(configPath, { 'setup-worktree': commands }, { spaces: 2 });
+    return configPath;
+}
+export async function clearBootstrapCommands(root) {
+    const configPath = getWorktreeSetupConfigPath(root);
+    await fs.remove(configPath);
+    return configPath;
+}
 export async function runBootstrap(wtPath, repoRoot) {
     const customCommands = await getBootstrapCommands(repoRoot, wtPath);
     if (customCommands) {
@@ -67,47 +75,8 @@ export async function runBootstrap(wtPath, repoRoot) {
                 ]);
             }
         }
+        return;
     }
-    else {
-        // Fallback to default behavior
-        log.info('Running default bootstrap (npm install + submodules)...');
-        // npm install
-        try {
-            await execa('npm', ['--version']);
-            const installSpinner = createSpinner('Running npm install...').start();
-            try {
-                await execa('npm', ['install'], { cwd: wtPath });
-                installSpinner.succeed('Dependencies installed.');
-            }
-            catch (e) {
-                installSpinner.fail('npm install failed.');
-                log.actionableError(e.message, 'npm install', wtPath, [
-                    `cd ${wtPath} && npm install`,
-                    'Check your network connection and package-lock.json'
-                ]);
-            }
-        }
-        catch {
-            log.warning('npm not found, skipping install.');
-        }
-        // Submodules
-        const subSpinner = createSpinner('Syncing submodules...').start();
-        try {
-            await execa('git', ['submodule', 'sync', '--recursive'], { cwd: wtPath });
-            await execa('git', ['submodule', 'update', '--init', '--recursive'], { cwd: wtPath });
-            subSpinner.succeed('Submodules synced.');
-        }
-        catch (e) {
-            subSpinner.fail('Submodule sync failed.');
-            const isAuthError = /permission denied|authentication|publickey/i.test(e.message);
-            const steps = [
-                'git submodule sync --recursive',
-                'git submodule update --init --recursive'
-            ];
-            if (isAuthError) {
-                steps.unshift('ssh -T git@github.com', 'ssh-add --apple-use-keychain ~/.ssh/id_ed25519');
-            }
-            log.actionableError(e.message, 'git submodule update --init --recursive', wtPath, steps);
-        }
-    }
+    log.info('No bootstrap commands configured. Skipping setup.');
+    log.dim('Tip: run yggtree config bootstrap --command "pnpm install" to create .yggtree/worktree-setup.json.');
 }

package/dist/lib/registry.js

@@ -1,4 +1,5 @@
 import fs from 'fs-extra';
+import { realpath } from 'fs/promises';
 import path from 'path';
 import { YGG_ROOT } from './paths.js';
 const REGISTRY_PATH = path.join(YGG_ROOT, 'registry.json');
@@ -79,3 +80,16 @@ export async function getValidRegisteredRepos() {
     }
     return valid;
 }
+async function normalizeRepoPath(repoPath) {
+    try {
+        return await realpath(repoPath);
+    }
+    catch {
+        return path.resolve(repoPath);
+    }
+}
+export async function hasRegisteredRepoPath(repoRoot, registry) {
+    const targetPath = await normalizeRepoPath(repoRoot);
+    const registeredPaths = await Promise.all(Object.values(registry.repos).map(normalizeRepoPath));
+    return registeredPaths.includes(targetPath);
+}

package/dist/lib/ui.js

@@ -62,7 +62,7 @@ function renderUpdateNotice(update) {
     return [
         '',
         `${yggWarn('Update available')} ${yggMuted(`yggtree ${update.currentVersion} -> ${update.latestVersion}`)}`,
-        yggMuted('Run: npm install -g yggtree'),
+        yggMuted('Run: yggtree update'),
     ];
 }
 function badge(value) {

package/dist/lib/update-check.js

@@ -51,5 +51,5 @@ export async function notifyIfUpdateAvailable() {
     if (!result?.updateAvailable)
         return;
     log.warning(`A newer yggtree is available: ${chalk.dim(`v${result.currentVersion}`)} -> ${chalk.green(`v${result.latestVersion}`)}`);
-    log.dim('Update with: npm install -g yggtree');
+    log.dim('Update with: yggtree update');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.4.6",
+  "version": "1.5.0",
   "packageManager": "pnpm@11.0.9",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
@@ -22,10 +22,14 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "dev": "tsc --watch",
+    "release:pack": "./scripts/package-yggtree-release.sh",
     "site:dev": "pnpm --dir apps/site dev",
     "test": "pnpm build && pnpm test:typecheck && vitest run",
     "test:typecheck": "tsc --noEmit -p tsconfig.test.json"
   },
+  "engines": {
+    "node": ">=20"
+  },
   "keywords": [
     "cli",
     "git",