yggtree 1.4.4 → 1.4.6

package/README.md

@@ -40,8 +40,8 @@ worktree workflow first, then load the smallest reference they need:
   the work already in progress.
 * **Bootstrap and use a realm**: prepare a worktree, open it in your IDE, or
   run commands inside it.
-* **Run sandbox experiments**: try alternative approaches locally and
-  apply/unapply the winner safely.
+* **Run sandbox experiments**: try alternative approaches locally, then copy the
+  winner back with sandbox-backed apply/unapply.
 
 This skill is especially useful with agents like **Claude Code**,
 **Codex**, **Cursor**, **Gemini CLI**, and other tools that support the open
@@ -110,6 +110,7 @@ All managed worktrees live under:
 ```
 
 This keeps your main repository clean while enabling true parallelism.
+You can change the global managed worktree location with `yggtree config`.
 
 ---
 
@@ -146,7 +147,7 @@ Create, manage, and navigate Git worktrees as a primary workflow, not an afterth
 Work on multiple branches at the same time, each in its own isolated environment.
 
 🧪 **Sandbox worktrees for experimentation**
-Prototyping something risky? Create a sandbox, try different strategies, and apply the winner back to your origin branch.
+Prototyping something risky? Create a sandbox, try different strategies, and copy the winner back to your origin checkout.
 
 🤝 **Handoff current work**
 Started in your main checkout? Carry staged, unstaged, and untracked work into a named sandbox worktree and continue there.
@@ -161,7 +162,7 @@ Run installs, submodules, and setup scripts automatically for each worktree.
 Enter worktrees, execute commands, or run tasks without changing directories.
 
 📍 **Predictable structure**
-All managed worktrees live under `~/.yggtree`, keeping your repository clean.
+Managed worktrees default to `~/.yggtree`, with an optional global path setting for agent-native layouts.
 
 🧭 **Interactive or scriptable**
 Use the interactive UI or drive everything through commands and flags.
@@ -217,12 +218,12 @@ Sometimes you don't want to "commit to a branch" yet. You just want to try somet
 
 1.  **Create**: `yggtree create-sandbox` (creates something like `sandbox-a3f2_feature-branch`).
 2.  **Experiment**: Change files, run tests, try that risky refactor.
-3.  **Apply**: `yggtree apply` to "push" those file changes back to your origin directory.
-4.  **Unapply**: Don't like it? `yggtree unapply` restores your origin to exactly how it was before.
+3.  **Apply**: `yggtree apply` to copy changed sandbox files back to your origin directory with backups.
+4.  **Unapply**: Don't like it? `yggtree unapply` restores those backed-up origin files while the sandbox still exists.
 
 Sandboxes are **not pushed to remote**. Omit the name for a generated temporary sandbox, or provide one when the work needs to be easy to find later.
 
-Use `handoff` when you started in the origin checkout and want to continue that dirty work in a sandbox:
+Use `handoff` when you started in the origin checkout and want to continue that dirty work in a sandbox. This is the taught path for staged, unstaged, or untracked work:
 
 ```bash
 yggtree handoff --name auth-refactor
@@ -259,6 +260,67 @@ Resolution order:
 
 ---
 
+## 🗂️ Global Worktree Paths
+
+By default, managed worktrees use the Yggtree layout:
+
+```bash
+~/.yggtree/<repo-name>/<worktree-slug>
+```
+
+Show the active global setting:
+
+```bash
+yggtree config get
+```
+
+Use the Codex-style layout when you want Yggtree-created worktrees to live under Codex's worktree root:
+
+```bash
+yggtree config use codex
+```
+
+That preset creates new managed worktrees like:
+
+```bash
+~/.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
+yggtree config set-worktrees-root ~/Worktrees
+```
+
+Return to defaults:
+
+```bash
+yggtree config reset
+```
+
+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.
+
+---
+
 ## 🛠️ Command Reference
 
 ### `yggtree`
@@ -280,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:
 
@@ -321,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:
 
@@ -349,15 +413,16 @@ yggtree wc hotfix-auth main --open --no-enter
 
 ### `yggtree create-sandbox`
 
-Create a temporary sandbox from your current local branch.
+Create a temporary local-only sandbox from your current branch.
 
 Options:
 
 *   `-n, --name <name>`: Optional sandbox name (auto-generated if omitted).
-*   `--carry / --no-carry`: Bring uncommitted changes (staged/unstaged/untracked) with you.
+*   `--carry / --no-carry`: Explicitly choose whether to copy uncommitted changes into the sandbox. Prefer `handoff` when the intent is continuing dirty work.
 *   `--no-bootstrap`
 *   `--open / --no-open`
 *   `--exec "<command>"`
+*   `--config <preset>`: use `yggtree`, `codex`, or `claude` path settings for this run only
 
 Interactive flow:
 
@@ -377,36 +442,41 @@ 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 version of `create-sandbox --carry`: it keeps sandbox metadata and apply/unapply behavior, but defaults to carrying staged, unstaged, and untracked files.
+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.
 
 ---
 
 ### `yggtree apply`
 
-Apply changes from the current sandbox back to the origin repository. 
-*   **Backs up** origin files before overwriting.
+Copy changed files from the current sandbox back to the origin checkout.
+*   **Backs up** origin files in sandbox metadata before overwriting.
 *   **Offers to delete** the sandbox after applying.
+*   **Is not a Git merge**: review the origin diff after applying, especially when deletions are involved.
 
 ---
 
 ### `yggtree unapply`
 
 Undo a previous `apply` operation.
-*   Restores origin files from the sandbox's backup.
+*   Restores origin files from the sandbox's backup metadata.
 *   *Note: Only works if the sandbox worktree still exists.*
 
 ---
 
 ### `yggtree create-multi`
 
-Create multiple worktrees at once.
+Create multiple official branch-backed worktrees at once. This is a bulk setup
+command; it does not have the full `create` lifecycle flags such as `--open`,
+`--enter`, or `--exec`.
 
 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>
@@ -434,7 +504,7 @@ Columns:
 Notes:
 
 * Entries are grouped by `TYPE`.
-* `SANDBOX` and `MANAGED` are worktrees inside `~/.yggtree`.
+* `SANDBOX` and `MANAGED` are worktrees inside the configured managed worktree root.
 * 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.
@@ -449,7 +519,7 @@ Behavior:
 
 * If `[worktree]` is omitted, you can pick from the worktree list with type-to-filter search.
 * Detects available editor commands in your `PATH` (for example: `cursor`, `code`, `zed`, `webstorm`).
-* Detects Codex App on macOS and launches it with `open -b com.openai.codex`.
+* Detects Codex App on macOS and launches the selected worktree with `codex app <path>`.
 * Detects Cmux and Tmux when their CLI commands are available.
 * Lets you choose one editor, app, or terminal target interactively, or pass `--tool`.
 * Keeps Cmux, Tmux, and `Other command...` mutually exclusive by using a single action picker.
@@ -504,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 `~/.yggtree` (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
+```
 
 ---
 
@@ -661,7 +742,7 @@ Useful when you want to manually navigate or copy the path into scripts.
 **Command:**
 
 ```bash
-yggtree create-sandbox --carry
+yggtree handoff --name risky-refactor
 ```
 
 **Scenario:**
@@ -670,7 +751,7 @@ yggtree create-sandbox --carry
 2.  Run `handoff --name risky-refactor` to carry those changes into an isolated `sandbox-risky-refactor` folder.
 3.  Experiment freely.
 4.  If it works: `yggtree apply`.
-5.  If it fails: Just delete the sandbox or `unapply`.
+5.  If it fails after applying: run `yggtree unapply` before deleting the sandbox.
 
 </details>
 

package/dist/commands/config.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { formatGlobalConfig, getPresetConfig, getWorktreePathConfig, normalizeWorktreesRootInput, readGlobalConfig, writeGlobalConfig, } from '../lib/global-config.js';
+import { log } from '../lib/ui.js';
+export async function configGetCommand() {
+    const [rawConfig, resolvedConfig] = await Promise.all([
+        readGlobalConfig(),
+        getWorktreePathConfig(),
+    ]);
+    console.log(chalk.bold('\n  Yggtree config\n'));
+    formatGlobalConfig(rawConfig, resolvedConfig)
+        .forEach(line => console.log(`  ${line}`));
+    console.log('');
+}
+export async function configUseCommand(preset) {
+    const presetConfig = getPresetConfig(preset);
+    if (!presetConfig) {
+        log.error(`Unknown config preset "${preset}".`);
+        log.dim('Available presets: default, yggtree, codex, claude');
+        return;
+    }
+    await writeGlobalConfig(presetConfig);
+    log.success(`Using ${preset} worktree layout.`);
+    await configGetCommand();
+}
+export async function configSetWorktreesRootCommand(root) {
+    const currentConfig = await readGlobalConfig();
+    await writeGlobalConfig({
+        ...currentConfig,
+        worktreesRoot: normalizeWorktreesRootInput(root),
+        worktreeLayout: currentConfig.worktreeLayout || 'yggtree',
+    });
+    log.success('Updated worktrees root.');
+    await configGetCommand();
+}
+export async function configSetWorktreeLayoutCommand(layout) {
+    if (layout !== 'yggtree' && layout !== 'codex' && layout !== 'claude') {
+        log.error(`Unknown worktree layout "${layout}".`);
+        log.dim('Available layouts: yggtree, codex, claude');
+        return;
+    }
+    const currentConfig = await readGlobalConfig();
+    await writeGlobalConfig({
+        ...currentConfig,
+        worktreeLayout: layout,
+    });
+    log.success('Updated worktree layout.');
+    await configGetCommand();
+}
+export async function configResetCommand() {
+    await writeGlobalConfig({});
+    log.success('Reset Yggtree config to defaults.');
+    await configGetCommand();
+}

package/dist/commands/wt/bootstrap.js

@@ -2,23 +2,25 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { getManagedWorktreesRoot } from '../../lib/global-config.js';
 import { log } from '../../lib/ui.js';
 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(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.
-        const managedWts = worktrees.filter(wt => wt.path.startsWith(WORKTREES_ROOT));
+        const managedWts = worktrees.filter(wt => isManagedWorktreePath(wt.path, managedRoot));
         if (managedWts.length === 0) {
             log.info('No managed worktrees found to bootstrap.');
             return;
         }
         const choices = managedWts.map(wt => {
-            const relative = path.relative(WORKTREES_ROOT, wt.path);
+            const relative = path.relative(managedRoot, wt.path);
             return {
                 name: `${chalk.bold(relative)} (${chalk.dim(wt.branch || wt.HEAD)})`,
                 value: wt.path,
@@ -33,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

@@ -3,7 +3,7 @@ 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 { WORKTREES_ROOT } from '../../lib/paths.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 { detectInstalledOpenTools, launchOpenTool, promptOpenToolSelection, } from './open.js';
@@ -89,7 +89,8 @@ 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 wtPath = path.join(WORKTREES_ROOT, repoName, slug);
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
+        const wtPath = buildManagedWorktreePath(repoName, slug, worktreePathConfig);
         // 2. Validation
         if (!slug)
             throw new Error('Invalid name');

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

@@ -3,7 +3,7 @@ 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 { WORKTREES_ROOT } from '../../lib/paths.js';
+import { buildManagedWorktreePath, getWorktreePathConfig } from '../../lib/global-config.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { findLocalEnvFiles, promptAndCopyEnvFilesToWorktrees } from '../../lib/env-files.js';
 import { execa } from 'execa';
@@ -70,9 +70,10 @@ export async function createCommandMulti(options) {
         const createdWorktrees = [];
         // 3. Execution for each branch
         const repoName = await getRepoName();
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
         for (const branchName of branchNames) {
             const slug = branchName.replace(/[\/\\]/g, '-').replace(/\s+/g, '-');
-            const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
+            const wtPath = buildManagedWorktreePath(repoName, slug, worktreePathConfig);
             log.header(`Processing: ${branchName}`);
             const wtSpinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
             // Check if target branch already exists

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

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import path from 'path';
 import { getRepoRoot, getRepoName, getCurrentBranch } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
+import { buildManagedWorktreePath, getWorktreePathConfig } from '../../lib/global-config.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
 import { generateSandboxName, normalizeSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
 import { promptAndCopyEnvFiles } from '../../lib/env-files.js';
@@ -136,7 +136,8 @@ export async function createSandboxCommand(options = {}) {
         }
         // 5. Create worktree
         const repoName = await getRepoName();
-        const wtPath = path.join(WORKTREES_ROOT, repoName, sandboxName);
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
+        const wtPath = buildManagedWorktreePath(repoName, sandboxName, worktreePathConfig);
         const spinner = createSpinner('Creating sandbox worktree...').start();
         try {
             await fs.ensureDir(path.dirname(wtPath));

package/dist/commands/wt/create.js

@@ -3,7 +3,7 @@ import inquirer from 'inquirer';
 import path from 'path';
 import { getRepoName, createWorktree, fetchAll, listWorktrees } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
-import { WORKTREES_ROOT } from '../../lib/paths.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';
@@ -204,7 +204,8 @@ export async function createCommand(options) {
         // 3. Gather remaining inputs
         const defaultSlug = toSlug(selectedBranch.branchName);
         const repoName = await getRepoName();
-        const resolveWorktreePath = (name) => path.join(WORKTREES_ROOT, repoName, toSlug(name));
+        const worktreePathConfig = await getWorktreePathConfig(repoRoot, options.config);
+        const resolveWorktreePath = (name) => buildManagedWorktreePath(repoName, toSlug(name), worktreePathConfig);
         const answers = await inquirer.prompt([
             {
                 type: 'input',

package/dist/commands/wt/delete.js

@@ -1,19 +1,60 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../../lib/git.js';
+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(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',
                     name: 'includeExternal',
-                    message: 'Include external linked worktrees (outside ~/.yggtree)?',
+                    message: 'Include external linked worktrees (outside the managed root)?',
                     default: false,
                 },
             ]);
@@ -21,62 +62,79 @@ 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);
+        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 || ''),
+        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);
-            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));
-        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;
+        const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p, managedRoot));
+        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);
+            const worktreeName = formatWorktreeDisplayPath(wtPath, managedRoot);
             const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
             try {
                 await removeWorktree(wtPath);