yggtree 1.4.5 → 1.4.6

package/README.md

@@ -286,6 +286,18 @@ That preset creates new managed worktrees like:
 ~/.codex/worktrees/<worktree-slug>/<repo-name>
 ```
 
+Use the Claude Code layout when you want Yggtree-created worktrees to match Claude's native repo-local worktree directory:
+
+```bash
+yggtree config use claude
+```
+
+That preset creates new managed worktrees like:
+
+```bash
+<repo-root>/.claude/worktrees/<worktree-slug>
+```
+
 Set a custom managed root while keeping the Yggtree layout:
 
 ```bash
@@ -298,7 +310,14 @@ Return to defaults:
 yggtree config reset
 ```
 
-Claude and Cursor do not currently have a confirmed native worktree directory pattern in Yggtree. Until that is explicit, use `set-worktrees-root` with the directory you want rather than relying on an unverified preset.
+Use a path preset for one worktree without changing the saved global config:
+
+```bash
+yggtree create feat/agent-native --config claude
+yggtree wc --ref main --name fresh-main --config yggtree
+```
+
+Cursor does not currently have a confirmed native worktree directory pattern in Yggtree. Until that is explicit, use `set-worktrees-root` with the directory you want rather than relying on an unverified preset.
 
 ---
 
@@ -323,6 +342,7 @@ Options:
 * `--open / --no-open`
 * `--enter / --no-enter`
 * `--exec "<command>"`
+* `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 Interactive flow:
 
@@ -364,6 +384,7 @@ Options:
 * `--tool <command>`: open a specific editor, app, or terminal target and skip the open prompt (`cursor`, `code`, `codex-app`, `cmux`, `tmux`)
 * `--no-enter`: finish after create/open and return to the caller
 * `--exec "<command>"`
+* `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 Interactive flow:
 
@@ -401,6 +422,7 @@ Options:
 *   `--no-bootstrap`
 *   `--open / --no-open`
 *   `--exec "<command>"`
+*   `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 Interactive flow:
 
@@ -420,6 +442,7 @@ Options:
 *   `--no-bootstrap`
 *   `--open / --no-open`
 *   `--exec "<command>"`
+*   `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 This is the continuation-focused semantic path for dirty work. It uses sandbox metadata and apply/unapply behavior, but defaults to carrying staged, unstaged, and untracked files.
 
@@ -453,6 +476,7 @@ Options:
 * `--base <ref>`
 * `--source local|remote`
 * `--no-bootstrap`
+* `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 <details>
 <summary>Example</summary>
@@ -550,20 +574,31 @@ Re‑run bootstrap commands for a worktree.
 
 ---
 
-### `yggtree delete`
+### `yggtree delete [worktrees...]`
 
-Interactively delete worktrees.
+Delete worktrees interactively or by explicit name.
 
 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).
+* In direct CLI usage, `--all` includes external worktrees labeled `LINKED` in `yggtree list` (main/current are still excluded for safety).
+* Non-interactive deletion requires explicit targets or `--all`, plus `--yes`.
 * The delete selector shows 6 items per page.
 
 Optional:
 
-* `--all` includes linked worktrees outside the configured managed root (main/current worktree is excluded for safety)
+* `--all` includes external worktrees outside the configured managed root (main/current worktree is excluded for safety)
+* `-y, --yes` confirms deletion without prompts
+
+Examples:
+
+```bash
+yggtree delete my-feature --yes
+yggtree delete my-feature other-feature --yes
+yggtree delete external-feature --all --yes
+yggtree delete --all --yes
+```
 
 ---
 

package/dist/commands/config.js

@@ -15,7 +15,7 @@ export async function configUseCommand(preset) {
     const presetConfig = getPresetConfig(preset);
     if (!presetConfig) {
         log.error(`Unknown config preset "${preset}".`);
-        log.dim('Available presets: default, yggtree, codex');
+        log.dim('Available presets: default, yggtree, codex, claude');
         return;
     }
     await writeGlobalConfig(presetConfig);
@@ -33,9 +33,9 @@ export async function configSetWorktreesRootCommand(root) {
     await configGetCommand();
 }
 export async function configSetWorktreeLayoutCommand(layout) {
-    if (layout !== 'yggtree' && layout !== 'codex') {
+    if (layout !== 'yggtree' && layout !== 'codex' && layout !== 'claude') {
         log.error(`Unknown worktree layout "${layout}".`);
-        log.dim('Available layouts: yggtree, codex');
+        log.dim('Available layouts: yggtree, codex, claude');
         return;
     }
     const currentConfig = await readGlobalConfig();

package/dist/commands/wt/bootstrap.js

@@ -8,9 +8,9 @@ import { runBootstrap } from '../../lib/config.js';
 import { isManagedWorktreePath } from '../../lib/worktree.js';
 export async function bootstrapCommand() {
     try {
-        const _ = await getRepoRoot();
+        const repoRoot = await getRepoRoot();
         const worktrees = await listWorktrees();
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         // 1. Select Worktree
         // Filter managed or just show all? The prompt said "managed", let's prioritize managed but maybe allow all if needed?
         // User requirements say "managed", sticking to that for consistency.
@@ -35,7 +35,6 @@ export async function bootstrapCommand() {
             },
         ]);
         const wtPath = selectedPath;
-        const repoRoot = await getRepoRoot();
         await runBootstrap(wtPath, repoRoot);
         log.success('Bootstrap completed!');
     }

package/dist/commands/wt/copy-env.js

@@ -0,0 +1,31 @@
+import path from 'path';
+import { findLocalEnvFiles, promptAndCopyEnvFiles } from '../../lib/env-files.js';
+import { getRepoRoot, listWorktrees } from '../../lib/git.js';
+import { log } from '../../lib/ui.js';
+export async function copyEnvCommand() {
+    try {
+        const currentWorktreePath = await getRepoRoot();
+        const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path;
+        if (!mainWorktreePath) {
+            log.info('No main worktree found.');
+            return;
+        }
+        if (path.resolve(currentWorktreePath) === path.resolve(mainWorktreePath)) {
+            log.info('Already in the main worktree. Nothing to copy.');
+            return;
+        }
+        const envFiles = await findLocalEnvFiles(mainWorktreePath);
+        if (envFiles.length === 0) {
+            log.info('No local env files found in the main worktree.');
+            return;
+        }
+        await promptAndCopyEnvFiles(mainWorktreePath, currentWorktreePath, envFiles, {
+            promptMessage: `Copy local env file${envFiles.length === 1 ? '' : 's'} from the main worktree to this worktree? (${envFiles.join(', ')})`,
+        });
+    }
+    catch (error) {
+        log.actionableError(error.message, 'yggtree wt copy-env');
+        process.exit(1);
+    }
+}

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

@@ -89,7 +89,7 @@ export async function createCommandNew(options) {
         // e.g. feat/new-button -> feat-new-button
         const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
         const repoName = await getRepoName();
-        const worktreePathConfig = await getWorktreePathConfig();
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
         const wtPath = buildManagedWorktreePath(repoName, slug, worktreePathConfig);
         // 2. Validation
         if (!slug)

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

@@ -70,7 +70,7 @@ export async function createCommandMulti(options) {
         const createdWorktrees = [];
         // 3. Execution for each branch
         const repoName = await getRepoName();
-        const worktreePathConfig = await getWorktreePathConfig();
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
         for (const branchName of branchNames) {
             const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
             const wtPath = buildManagedWorktreePath(repoName, slug, worktreePathConfig);

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

@@ -136,7 +136,7 @@ export async function createSandboxCommand(options = {}) {
         }
         // 5. Create worktree
         const repoName = await getRepoName();
-        const worktreePathConfig = await getWorktreePathConfig();
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
         const wtPath = buildManagedWorktreePath(repoName, sandboxName, worktreePathConfig);
         const spinner = createSpinner('Creating sandbox worktree...').start();
         try {

package/dist/commands/wt/create.js

@@ -204,7 +204,7 @@ export async function createCommand(options) {
         // 3. Gather remaining inputs
         const defaultSlug = toSlug(selectedBranch.branchName);
         const repoName = await getRepoName();
-        const worktreePathConfig = await getWorktreePathConfig();
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
         const resolveWorktreePath = (name) => buildManagedWorktreePath(repoName, toSlug(name), worktreePathConfig);
         const answers = await inquirer.prompt([
             {

package/dist/commands/wt/delete.js

@@ -4,13 +4,52 @@ import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../
 import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log, createSpinner, timeAgo } from '../../lib/ui.js';
 import { detectWorktreeType, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
-export async function deleteCommand(options = {}) {
+function normalizeTarget(value) {
+    return value.trim().toLowerCase();
+}
+function matchesDeleteTarget(wtPath, branchName, displayPath, target) {
+    const normalizedTarget = normalizeTarget(target);
+    return [
+        wtPath,
+        branchName,
+        displayPath,
+        wtPath.split('/').pop() || '',
+    ].some(value => normalizeTarget(value) === normalizedTarget);
+}
+function resolveDeleteWorktrees(worktrees, targets, options) {
+    const eligibleWts = worktrees.filter(wt => {
+        const isMainWorktree = wt.path === options.mainWorktreePath;
+        const isCurrentWorktree = wt.path === options.currentWorktreePath;
+        if (isMainWorktree || isCurrentWorktree)
+            return false;
+        if (options.includeAll) {
+            return true;
+        }
+        return isManagedWorktreePath(wt.path, options.managedRoot);
+    });
+    if (targets.length === 0) {
+        return eligibleWts;
+    }
+    return eligibleWts.filter(wt => {
+        const branchName = getWorktreeBranchName(wt);
+        const displayPath = formatWorktreeDisplayPath(wt.path, options.managedRoot);
+        return targets.some(target => matchesDeleteTarget(wt.path, branchName, displayPath, target));
+    });
+}
+export async function deleteCommand(targets = [], options = {}) {
     try {
         const currentWorktreePath = await getRepoRoot();
         const worktrees = await listWorktrees();
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(currentWorktreePath);
         let showAll = options.all;
-        if (showAll === undefined) {
+        const hasExplicitTargets = targets.length > 0;
+        const isNonInteractive = process.env.CI === 'true' || !process.stdin.isTTY;
+        if (showAll === undefined && !hasExplicitTargets) {
+            if (isNonInteractive) {
+                log.error('Non-interactive delete requires worktree names or --all.');
+                log.dim('Try: yggtree delete <worktree> --yes');
+                return;
+            }
             const { includeExternal } = await inquirer.prompt([
                 {
                     type: 'confirm',
@@ -23,59 +62,76 @@ export async function deleteCommand(options = {}) {
         }
         const includeAll = Boolean(showAll);
         const mainWorktreePath = worktrees[0]?.path;
-        const deletableWts = worktrees.filter(wt => {
-            if (includeAll) {
-                const isMainWorktree = wt.path === mainWorktreePath;
-                const isCurrentWorktree = wt.path === currentWorktreePath;
-                return !isMainWorktree && !isCurrentWorktree;
-            }
-            return isManagedWorktreePath(wt.path, managedRoot);
+        const deletableWts = resolveDeleteWorktrees(worktrees, targets, {
+            includeAll,
+            currentWorktreePath,
+            mainWorktreePath,
+            managedRoot,
         });
         if (deletableWts.length === 0) {
+            if (hasExplicitTargets) {
+                log.error(`No deletable worktrees matched: ${targets.join(', ')}`);
+                log.dim(includeAll
+                    ? 'Main and current worktrees are protected from deletion.'
+                    : 'Use "yggtree delete --all <worktree> --yes" to include linked worktrees outside the managed root.');
+                return;
+            }
             log.info(includeAll
                 ? 'No deletable linked worktrees found.'
                 : 'No managed worktrees found to delete. Use "yggtree wt delete --all" to include external linked worktrees.');
             return;
         }
-        const choices = await Promise.all(deletableWts.map(async (wt) => {
-            const [activity, type] = await Promise.all([
-                getLastActivity(wt.path),
-                detectWorktreeType(wt, mainWorktreePath || '', managedRoot),
+        let selectedPaths = deletableWts.map(wt => wt.path);
+        const shouldPromptForSelection = !hasExplicitTargets && !(options.all === true && options.yes);
+        if (shouldPromptForSelection) {
+            const choices = await Promise.all(deletableWts.map(async (wt) => {
+                const [activity, type] = await Promise.all([
+                    getLastActivity(wt.path),
+                    detectWorktreeType(wt, mainWorktreePath || '', managedRoot),
+                ]);
+                const branchName = getWorktreeBranchName(wt);
+                const active = activity ? chalk.magenta(timeAgo(activity)) : chalk.dim('—');
+                const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
+                return {
+                    name: `${formatWorktreeType(type)} ${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active} ${chalk.dim('·')} ${chalk.dim(displayPath)}`,
+                    value: wt.path,
+                };
+            }));
+            const answer = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'selectedPaths',
+                    message: includeAll ? 'Select worktrees to delete:' : 'Select managed worktrees to delete:',
+                    choices: choices,
+                    pageSize: 10,
+                },
             ]);
-            const branchName = getWorktreeBranchName(wt);
-            const active = activity ? chalk.magenta(timeAgo(activity)) : chalk.dim('—');
-            const displayPath = formatWorktreeDisplayPath(wt.path, managedRoot);
-            return {
-                name: `${formatWorktreeType(type)} ${chalk.bold.yellow(branchName)} ${chalk.dim('·')} ${active} ${chalk.dim('·')} ${chalk.dim(displayPath)}`,
-                value: wt.path,
-            };
-        }));
-        const { selectedPaths } = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'selectedPaths',
-                message: includeAll ? 'Select worktrees to delete:' : 'Select managed worktrees to delete:',
-                choices: choices,
-                pageSize: 10,
-            },
-        ]);
+            selectedPaths = answer.selectedPaths;
+        }
         if (!selectedPaths || selectedPaths.length === 0) {
             log.info('No worktrees selected.');
             return;
         }
         const count = selectedPaths.length;
         const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p, managedRoot));
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: `Are you sure you want to delete ${count > 1 ? `${count} worktrees` : `"${names[0]}"`}?`,
-                default: false,
-            },
-        ]);
-        if (!confirm) {
-            log.info('Deletion aborted.');
-            return;
+        if (!options.yes) {
+            if (isNonInteractive) {
+                log.error('Non-interactive delete requires --yes.');
+                log.dim(`Try: yggtree delete ${targets.join(' ')} --yes`);
+                return;
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Are you sure you want to delete ${count > 1 ? `${count} worktrees` : `"${names[0]}"`}?`,
+                    default: false,
+                },
+            ]);
+            if (!confirm) {
+                log.info('Deletion aborted.');
+                return;
+            }
         }
         for (const wtPath of selectedPaths) {
             const worktreeName = formatWorktreeDisplayPath(wtPath, managedRoot);

package/dist/commands/wt/enter.js

@@ -38,10 +38,10 @@ function formatChoiceLabel(type, branchName, displayPath, terminalColumns) {
 }
 export async function enterCommand(wtName, options = {}) {
     try {
-        await ensureRepoContext();
+        const repoRoot = await ensureRepoContext();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;

package/dist/commands/wt/exec.js

@@ -9,9 +9,9 @@ export async function execCommand(wtName, commandArgs) {
     let command = '';
     let args = [];
     try {
-        await getRepoRoot();
+        const repoRoot = await getRepoRoot();
         const worktrees = await listWorktrees();
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;

package/dist/commands/wt/list.js

@@ -5,10 +5,10 @@ import { log, timeAgo } from '../../lib/ui.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
+        const repoRoot = await getRepoRoot(); // Verify we are in a git repo
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;

package/dist/commands/wt/open.js

@@ -381,10 +381,10 @@ export async function runOpenActions(actions, wtPath, options = {}) {
 }
 export async function openCommand(wtName, options = {}) {
     try {
-        await getRepoRoot();
+        const repoRoot = await getRepoRoot();
         const worktrees = await listWorktrees();
         const mainWorktreePath = worktrees[0]?.path || '';
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;

package/dist/commands/wt/path.js

@@ -5,9 +5,9 @@ import { log } from '../../lib/ui.js';
 import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function pathCommand(wtName) {
     try {
-        await getRepoRoot();
+        const repoRoot = await getRepoRoot();
         const worktrees = await listWorktrees();
-        const managedRoot = await getManagedWorktreesRoot();
+        const managedRoot = await getManagedWorktreesRoot(repoRoot);
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;

package/dist/index.js

@@ -1,8 +1,10 @@
 import { Command, Option } from 'commander';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import path from 'path';
+import { execa } from 'execa';
 import { formatMainMenuChoice, renderMainMenuIntro, welcome, log, } from './lib/ui.js';
-import { applyHelp, checkoutHelp, createHelp, createMultiHelp, createSandboxHelp, handoffHelp, intentRouterHelp, openHelp, unapplyHelp, } from './lib/help.js';
+import { applyHelp, checkoutHelp, createHelp, createMultiHelp, createSandboxHelp, deleteHelp, handoffHelp, intentRouterHelp, openHelp, unapplyHelp, } from './lib/help.js';
 import { listCommand } from './commands/wt/list.js';
 import { createCommand } from './commands/wt/create.js';
 import { createCommandNew } from './commands/wt/create-branch.js';
@@ -17,14 +19,18 @@ import { openCommand } from './commands/wt/open.js';
 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 { getVersion } from './lib/version.js';
 import { checkForUpdate } from './lib/update-check.js';
 import { findSandboxRoot } from './lib/sandbox.js';
 import { bifrostCommand } from './commands/bifrost.js';
 import { thorCommand } from './commands/thor.js';
+import { buildMainMenuEntries, } from './lib/main-menu.js';
+import { getRepoRoot, listWorktrees } from './lib/git.js';
 const program = new Command();
 const argv = process.argv.map((arg) => arg === '-v' || arg === '—version' ? '--version' : arg);
+const DOCS_URL = 'https://yggtree.logbookfordevs.com/docs';
 function mainMenuChoice(value, glyph, label, detail, tone) {
     return {
         name: formatMainMenuChoice({ glyph, label, detail, tone }),
@@ -34,6 +40,62 @@ function mainMenuChoice(value, glyph, label, detail, tone) {
 function mainMenuSeparator(label) {
     return new inquirer.Separator(chalk.dim(`  · ${label}`));
 }
+const mainMenuChoices = {
+    'create-smart': mainMenuChoice('create-smart', '◆', 'Grow new realm', 'create a branch-backed worktree', 'growth'),
+    'worktree-checkout': mainMenuChoice('worktree-checkout', '⇄', 'Check out branch', 'open an existing ref in a new realm', 'travel'),
+    handoff: mainMenuChoice('handoff', '✦', 'Hand off current work', 'carry dirty work into a named sandbox', 'sandbox'),
+    open: mainMenuChoice('open', '◇', 'Open realm', 'jump into an existing worktree', 'travel'),
+    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'),
+    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'),
+    delete: mainMenuChoice('delete', '×', 'Fell realm', 'delete managed worktrees', 'danger'),
+    prune: mainMenuChoice('prune', '⌫', 'Prune stale realms', 'remove stale worktree metadata', 'danger'),
+    apply: mainMenuChoice('apply', '◆', 'Graft sandbox changes', 'apply sandbox changes to origin', 'sandbox'),
+    unapply: mainMenuChoice('unapply', '↶', 'Undo sandbox graft', 'restore origin from sandbox backups', 'sandbox'),
+    bifrost: mainMenuChoice('bifrost', '✺', 'Summon the Bifrost', 'open the long way around', 'lore'),
+    thor: mainMenuChoice('thor', 'ϟ', 'Consult Thor', 'ask the thunder route', 'lore'),
+    docs: mainMenuChoice('docs', '?', 'Open docs', 'read the Yggtree documentation', 'tending'),
+    exit: mainMenuChoice('exit', '·', 'Leave Yggdrasil', 'exit without changing anything', 'exit'),
+};
+async function detectMainMenuContext() {
+    if (await findSandboxRoot(process.cwd())) {
+        return 'sandbox';
+    }
+    try {
+        const repoRoot = await getRepoRoot();
+        const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path;
+        if (mainWorktreePath && path.resolve(repoRoot) !== path.resolve(mainWorktreePath)) {
+            return 'worktree';
+        }
+    }
+    catch {
+        return 'main';
+    }
+    return 'main';
+}
+async function openDocs() {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32'
+        ? ['/c', 'start', '', DOCS_URL]
+        : [DOCS_URL];
+    try {
+        await execa(command, args, { stdio: 'ignore' });
+        log.success(`Opened docs: ${DOCS_URL}`);
+    }
+    catch {
+        log.warning('Could not open the docs in your browser.');
+        log.info(DOCS_URL);
+    }
+}
 function registerWorktreeCommands(parent) {
     parent.command('list')
         .description('List all repo-linked worktrees')
@@ -56,6 +118,7 @@ function registerWorktreeCommands(parent) {
         .option('--enter', 'Enter the worktree sub-shell after creation')
         .option('--no-enter', 'Do not enter the worktree sub-shell after creation')
         .option('--exec <command>', 'Command to execute after creation')
+        .option('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
         .addHelpText('after', createHelp)
         .action(async (branch, options) => {
         await createCommandNew({
@@ -68,6 +131,7 @@ function registerWorktreeCommands(parent) {
         .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('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
         .addHelpText('after', createMultiHelp)
         .action(async (options) => {
         await createCommandMulti(options);
@@ -84,6 +148,7 @@ function registerWorktreeCommands(parent) {
             .addOption(new Option('--enter', 'Enter the worktree sub-shell after checkout/opening').hideHelp())
             .option('--no-enter', 'Do not enter the worktree sub-shell after checkout/opening')
             .option('--exec <command>', 'Command to execute after creation')
+            .option('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
             .addHelpText('after', checkoutHelp)
             .action(async (name, ref, options) => {
             await createCommand({
@@ -95,11 +160,13 @@ function registerWorktreeCommands(parent) {
     };
     registerWorktreeCheckout('worktree-checkout', 'Create a checkout-style worktree from an existing branch');
     registerWorktreeCheckout('wc', 'Alias for worktree-checkout');
-    parent.command('delete')
+    parent.command('delete [worktrees...]')
         .description('Delete managed worktrees')
-        .option('-a, --all', 'Include repo-linked worktrees outside the managed root (except main/current)')
-        .action(async (options) => {
-        await deleteCommand(options);
+        .option('-a, --all', 'Include external LINKED worktrees outside the managed root (except main/current)')
+        .option('-y, --yes', 'Confirm deletion without prompts')
+        .addHelpText('after', deleteHelp)
+        .action(async (worktrees, options) => {
+        await deleteCommand(worktrees, options);
     });
     parent.command('open [worktree]')
         .description('Open a worktree in an editor, supported app, or terminal target')
@@ -128,6 +195,9 @@ function registerWorktreeCommands(parent) {
         .action(async (worktree) => {
         await pathCommand(worktree);
     });
+    parent.command('copy-env')
+        .description('Copy local env files from the main worktree to the current worktree')
+        .action(copyEnvCommand);
     parent.command('create-sandbox')
         .description('Create a local-only disposable experiment sandbox')
         .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
@@ -139,6 +209,7 @@ function registerWorktreeCommands(parent) {
         .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')
+        .option('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
         .addHelpText('after', createSandboxHelp)
         .action(async (options) => {
         await createSandboxCommand(options);
@@ -152,6 +223,7 @@ function registerWorktreeCommands(parent) {
         .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')
+        .option('--config <preset>', 'Use a path preset for this run only (yggtree, codex, claude)')
         .addHelpText('after', handoffHelp)
         .action(async (options) => {
         await handoffCommand(options);
@@ -185,58 +257,14 @@ program
     .action(async () => {
     const update = await checkForUpdate();
     await welcome({ update });
-    const isInSandbox = Boolean(await findSandboxRoot(process.cwd()));
-    const dailyChoices = [
-        mainMenuChoice('create-smart', '◆', 'Grow new realm', 'create a branch-backed worktree', 'growth'),
-        mainMenuChoice('worktree-checkout', '⇄', 'Check out branch', 'open an existing ref in a new realm', 'travel'),
-        mainMenuChoice('handoff', '✦', 'Hand off current work', 'carry dirty work into a named sandbox', 'sandbox'),
-        mainMenuChoice('open', '◇', 'Open realm', 'jump into an existing worktree', 'travel'),
-        mainMenuChoice('list', '○', 'Survey realms', 'scan active worktrees and PR state', 'tending'),
-    ];
-    const growthChoices = [
-        mainMenuChoice('create-multi', '✧', 'Grow many realms', 'create multiple branch worktrees', 'growth'),
-        mainMenuChoice('create-sandbox', '△', 'Forge sandbox', 'create a local experiment realm', 'sandbox'),
-    ];
-    const tendingChoices = [
-        mainMenuChoice('bootstrap', '↳', 'Bootstrap realm', 'install dependencies and submodules', 'tending'),
-        mainMenuChoice('exec', '⌁', 'Cast command', 'run a command inside a worktree', 'tending'),
-        mainMenuChoice('path', '⌖', 'Reveal path', 'print a worktree cd command', 'tending'),
-        mainMenuChoice('delete', '×', 'Fell realm', 'delete managed worktrees', 'danger'),
-        mainMenuChoice('prune', '⌫', 'Prune stale realms', 'remove stale worktree metadata', 'danger'),
-    ];
-    const sandboxChoices = [
-        mainMenuChoice('apply', '◆', 'Graft sandbox changes', 'apply sandbox changes to origin', 'sandbox'),
-        mainMenuChoice('unapply', '↶', 'Undo sandbox graft', 'restore origin from sandbox backups', 'sandbox'),
-    ];
-    const loreChoices = [
-        mainMenuChoice('bifrost', '✺', 'Summon the Bifrost', 'open the long way around', 'lore'),
-        mainMenuChoice('thor', 'ϟ', 'Consult Thor', 'ask the thunder route', 'lore'),
-        mainMenuChoice('exit', '·', 'Leave Yggdrasil', 'exit without changing anything', 'exit'),
-    ];
-    const choices = isInSandbox
-        ? [
-            ...sandboxChoices,
-            mainMenuSeparator('Daily routes'),
-            ...dailyChoices,
-            mainMenuSeparator('Growth and experiments'),
-            ...growthChoices,
-            mainMenuSeparator('Tend realms'),
-            ...tendingChoices,
-            mainMenuSeparator('Lore'),
-            ...loreChoices,
-        ]
-        : [
-            ...dailyChoices,
-            mainMenuSeparator('Growth and experiments'),
-            ...growthChoices,
-            mainMenuSeparator('Tend realms'),
-            ...tendingChoices,
-            mainMenuSeparator('Sandbox grafts'),
-            ...sandboxChoices,
-            mainMenuSeparator('Lore'),
-            ...loreChoices,
-        ];
-    console.log(renderMainMenuIntro({ isInSandbox }));
+    const menuContext = await detectMainMenuContext();
+    const choices = buildMainMenuEntries(menuContext).map((entry) => {
+        if (entry.type === 'separator') {
+            return mainMenuSeparator(entry.label);
+        }
+        return mainMenuChoices[entry.value];
+    });
+    console.log(renderMainMenuIntro({ context: menuContext }));
     const { action } = await inquirer.prompt([
         {
             type: 'list',
@@ -278,6 +306,9 @@ program
         case 'path':
             await pathCommand();
             break;
+        case 'copy-env':
+            await copyEnvCommand();
+            break;
         case 'apply':
             await applyCommand();
             break;
@@ -296,6 +327,9 @@ program
         case 'thor':
             await thorCommand();
             break;
+        case 'docs':
+            await openDocs();
+            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -318,13 +352,13 @@ config.command('get')
     .description('Show resolved global settings')
     .action(configGetCommand);
 config.command('use <preset>')
-    .description('Use a global worktree path preset (default, yggtree, codex)')
+    .description('Use a global worktree path preset (default, yggtree, codex, claude)')
     .action(configUseCommand);
 config.command('set-worktrees-root <path>')
     .description('Set the global managed worktrees root')
     .action(configSetWorktreesRootCommand);
 config.command('set-worktree-layout <layout>')
-    .description('Set the managed worktree path layout (yggtree or codex)')
+    .description('Set the managed worktree path layout (yggtree, codex, or claude)')
     .action(configSetWorktreeLayoutCommand);
 config.command('reset')
     .description('Reset global settings to defaults')

package/dist/lib/global-config.js

@@ -19,8 +19,13 @@ export function formatHome(value) {
         return `~/${path.relative(home, value)}`;
     return value;
 }
-function normalizeRoot(value) {
-    return path.resolve(expandHome(value || YGG_ROOT));
+function normalizeRoot(value, layout, repoRoot) {
+    if (value)
+        return path.resolve(expandHome(value));
+    if (layout === 'claude') {
+        return path.join(path.resolve(repoRoot || process.cwd()), '.claude', 'worktrees');
+    }
+    return path.resolve(YGG_ROOT);
 }
 export function normalizeWorktreesRootInput(value) {
     return path.resolve(expandHome(value));
@@ -28,13 +33,16 @@ export function normalizeWorktreesRootInput(value) {
 function normalizeLayout(value) {
     return value || DEFAULT_WORKTREE_LAYOUT;
 }
+function isWorktreeLayout(value) {
+    return value === 'yggtree' || value === 'codex' || value === 'claude';
+}
 export async function readGlobalConfig() {
     try {
         if (await fs.pathExists(CONFIG_PATH)) {
             const config = await fs.readJSON(CONFIG_PATH);
             return {
                 worktreesRoot: typeof config.worktreesRoot === 'string' ? config.worktreesRoot : undefined,
-                worktreeLayout: config.worktreeLayout === 'codex' ? 'codex' : undefined,
+                worktreeLayout: isWorktreeLayout(config.worktreeLayout) ? config.worktreeLayout : undefined,
             };
         }
     }
@@ -47,21 +55,30 @@ export async function writeGlobalConfig(config) {
     await fs.ensureDir(YGG_ROOT);
     await fs.writeJSON(CONFIG_PATH, config, { spaces: 2 });
 }
-export async function getWorktreePathConfig() {
-    const config = await readGlobalConfig();
+export async function getWorktreePathConfig(repoRoot, presetOverride) {
+    const config = presetOverride === undefined
+        ? await readGlobalConfig()
+        : getPresetConfig(presetOverride);
+    if (!config) {
+        throw new Error(`Unknown config preset "${presetOverride}". Available presets: default, yggtree, codex, claude.`);
+    }
+    const layout = normalizeLayout(config.worktreeLayout);
     return {
-        root: normalizeRoot(config.worktreesRoot),
-        layout: normalizeLayout(config.worktreeLayout),
+        root: normalizeRoot(config.worktreesRoot, layout, repoRoot),
+        layout,
     };
 }
-export async function getManagedWorktreesRoot() {
-    const config = await getWorktreePathConfig();
+export async function getManagedWorktreesRoot(repoRoot) {
+    const config = await getWorktreePathConfig(repoRoot);
     return config.root;
 }
 export function buildManagedWorktreePath(repoName, worktreeSlug, config) {
     if (config.layout === 'codex') {
         return path.join(config.root, worktreeSlug, repoName);
     }
+    if (config.layout === 'claude') {
+        return path.join(config.root, worktreeSlug);
+    }
     return path.join(config.root, repoName, worktreeSlug);
 }
 export function getPresetConfig(preset) {
@@ -75,15 +92,27 @@ export function getPresetConfig(preset) {
             worktreeLayout: 'codex',
         };
     }
+    if (normalized === 'claude') {
+        return {
+            worktreeLayout: 'claude',
+        };
+    }
     return undefined;
 }
+function inferPreset(config) {
+    if (!config.worktreesRoot && !config.worktreeLayout)
+        return 'default';
+    if (!config.worktreesRoot && config.worktreeLayout === 'claude')
+        return 'claude';
+    if (config.worktreesRoot === '~/.codex/worktrees' && config.worktreeLayout === 'codex')
+        return 'codex';
+    return 'custom';
+}
 export function formatGlobalConfig(config, resolved) {
     return [
         `worktreesRoot: ${formatHome(resolved.root)}`,
         `worktreeLayout: ${resolved.layout}`,
         `configFile: ${formatHome(CONFIG_PATH)}`,
-        config.worktreesRoot || config.worktreeLayout
-            ? 'preset: custom'
-            : 'preset: default',
+        `preset: ${inferPreset(config)}`,
     ];
 }

package/dist/lib/help.js

@@ -6,25 +6,38 @@ Choose by intent:
   Disposable local experiment   yggtree create-sandbox
   Copy sandbox files to origin  yggtree apply   # from inside sandbox, not a Git merge
   Bulk official worktrees       yggtree create-multi
+  Agent-native path layout      yggtree config use claude   # or codex
+  Delete without prompts        yggtree delete branch-name --yes
 
 More detail: run yggtree help <command>, for example yggtree help handoff.
 `;
+const agentPathTip = `
+Agent-native paths:
+  Add --config claude for Claude Code's repo-local .claude/worktrees layout.
+  Add --config codex for Codex's ~/.codex/worktrees layout.
+`;
 export const createHelp = `
 Behavior:
   Creates an official branch-backed worktree, publishes the branch to origin, and enters the shell by default.
   Use for real task branches. For disposable experiments, use create-sandbox.
 
+${agentPathTip}
+
 Examples:
   yggtree create feat/new-flow --base main --source remote
   yggtree create feat/background-task --base main --source remote --no-open --no-enter
+  yggtree create feat/claude-layout --base main --source remote --config claude
 `;
 export const createMultiHelp = `
 Behavior:
   Bulk-creates official branch-backed worktrees.
   This does not share create's open/enter/exec lifecycle. Use create for one task branch.
 
+${agentPathTip}
+
 Example:
   yggtree create-multi --base main --source remote
+  yggtree create-multi --base main --source remote --config codex
 `;
 export const checkoutHelp = `
 Behavior:
@@ -32,9 +45,12 @@ Behavior:
   Use for interruptions and branch review. Use create for a new official task branch.
   Enters the worktree shell by default; add --no-enter when automation should return.
 
+${agentPathTip}
+
 Examples:
   yggtree wc --ref hotfix/payment-timeout
   yggtree wc --ref main --name fresh-main --no-open --no-enter
+  yggtree wc --ref main --name fresh-main --config yggtree
 `;
 export const openHelp = `
 Behavior:
@@ -46,14 +62,29 @@ Examples:
   yggtree open my-feature --tool codex-app
   yggtree list --open
 `;
+export const deleteHelp = `
+Behavior:
+  Deletes selected worktrees. Main and current worktrees are always protected.
+  Without arguments, delete stays interactive. For automation, pass explicit targets and --yes.
+  Add --all only when the target is outside Yggtree's managed root and appears as LINKED in list.
+
+Examples:
+  yggtree delete my-feature --yes
+  yggtree delete my-feature other-feature --yes
+  yggtree delete --all --yes
+  yggtree delete external-feature --all --yes
+`;
 export const createSandboxHelp = `
 Behavior:
   Creates a local-only disposable experiment from the current branch.
   For continuing current dirty work, prefer handoff instead of teaching create-sandbox --carry.
 
+${agentPathTip}
+
 Examples:
   yggtree create-sandbox
   yggtree create-sandbox --name ui-option-a --no-open
+  yggtree create-sandbox --name claude-scratch --config claude
 
 Related:
   handoff carries current dirty work into a named sandbox.
@@ -64,8 +95,11 @@ Behavior:
   Carry staged, unstaged, and untracked work into a named sandbox so you can continue there.
   The origin checkout is not cleaned; review or reset it separately if needed.
 
+${agentPathTip}
+
 Example:
   yggtree handoff --name continue-auth-refactor
+  yggtree handoff --name continue-auth-refactor --config codex
 
 Related:
   create-sandbox starts a disposable local experiment.

package/dist/lib/main-menu.js

@@ -0,0 +1,71 @@
+export function buildMainMenuEntries(context) {
+    const dailyChoices = actions([
+        'create-smart',
+        'worktree-checkout',
+        'handoff',
+        'open',
+        'list',
+    ]);
+    const growthChoices = actions([
+        'create-multi',
+        'create-sandbox',
+    ]);
+    const tendingChoices = actions([
+        'bootstrap',
+        'exec',
+        'path',
+        'delete',
+        'prune',
+    ]);
+    const sandboxChoices = actions([
+        'apply',
+        'unapply',
+    ]);
+    const loreChoices = actions([
+        'bifrost',
+        'thor',
+        'docs',
+        'exit',
+    ]);
+    if (context === 'sandbox') {
+        return [
+            ...sandboxChoices,
+            separator('Daily routes'),
+            ...dailyChoices,
+            separator('Growth and experiments'),
+            ...growthChoices,
+            separator('Tend realms'),
+            ...tendingChoices,
+            separator('Lore'),
+            ...loreChoices,
+        ];
+    }
+    if (context === 'worktree') {
+        return [
+            ...actions(['copy-env', 'path', 'exec', 'bootstrap']),
+            separator('Daily routes'),
+            ...dailyChoices,
+            separator('Growth and experiments'),
+            ...growthChoices,
+            separator('Tend realms'),
+            ...actions(['delete', 'prune']),
+            separator('Lore'),
+            ...loreChoices,
+        ];
+    }
+    return [
+        ...dailyChoices,
+        separator('Growth and experiments'),
+        ...growthChoices,
+        separator('Tend realms'),
+        ...tendingChoices,
+        separator('Lore'),
+        ...loreChoices,
+    ];
+}
+function actions(values) {
+    return values.map(value => ({ type: 'action', value }));
+}
+function separator(label) {
+    return { type: 'separator', label };
+}

package/dist/lib/ui.js

@@ -34,9 +34,15 @@ export const welcome = async (options = {}) => {
     console.log(renderWelcome(options));
 };
 export function renderMainMenuIntro(options) {
-    const detail = options.isInSandbox
-        ? 'Sandbox tools appear first because this realm can apply or undo grafted changes.'
-        : 'Create, enter, inspect, or tend your worktrees.';
+    const detail = (() => {
+        if (options.context === 'sandbox') {
+            return 'Sandbox tools appear first because this realm can apply or undo grafted changes.';
+        }
+        if (options.context === 'worktree') {
+            return 'Current-realm tools appear first for this worktree.';
+        }
+        return 'Create, enter, inspect, or tend your worktrees.';
+    })();
     return [
         'Choose the next realm action.',
         yggMuted('Daily routes first. Maintenance and lore wait below.'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "packageManager": "pnpm@11.0.9",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",