yggtree 1.1.0 → 1.2.0

package/README.md

@@ -95,6 +95,9 @@ Create, manage, and navigate Git worktrees as a primary workflow, not an afterth
 🧠 **Parallel development by default**
 Work on multiple branches at the same time, each in its own isolated environment.
 
+🧪 **Sandbox worktrees for experimentation**
+Prototyping something risky? Create a sandbox with a random name, try different strategies, and apply the winner back to your origin branch.
+
 🤖 **AI-friendly isolation**
 One worktree per agent, per experiment, per idea. No shared state, no collisions.
 
@@ -153,6 +156,21 @@ All in parallel. All reviewable. All isolated.
 
 ---
 
+## 🧪 Sandbox Worktrees
+
+Sometimes you don't want to "commit to a branch" yet. You just want to try something out—or perhaps try three different ways of solving the same problem.
+
+**Sandboxes** are temporary, local-only worktrees designed for this:
+
+1.  **Create**: `yggtree wt create-sandbox` (creates `branch_qes2`).
+2.  **Experiment**: Change files, run tests, try that risky refactor.
+3.  **Apply**: `yggtree wt apply` to "push" those file changes back to your origin directory.
+4.  **Unapply**: Don't like it? `yggtree wt unapply` restores your origin to exactly how it was before.
+
+Sandboxes are **not pushed to remote** and their names are randomly generated because they are meant to be temporary playgrounds.
+
+---
+
 ## ⚡ Bootstrapping & Configuration
 
 Yggdrasil automatically prepares each worktree.
@@ -210,6 +228,35 @@ yggtree wt create feat/new-ui --base main --exec "cursor ."
 
 ---
 
+### `yggtree wt create-sandbox`
+
+Create a temporary sandbox from your current local branch.
+
+Options:
+
+*   `--carry / --no-carry`: Bring uncommitted changes (staged/unstaged/untracked) with you.
+*   `--no-bootstrap`
+*   `--enter / --no-enter`
+*   `--exec "<command>"`
+
+---
+
+### `yggtree wt apply`
+
+Apply changes from the current sandbox back to the origin repository. 
+*   **Backs up** origin files before overwriting.
+*   **Offers to delete** the sandbox after applying.
+
+---
+
+### `yggtree wt unapply`
+
+Undo a previous `apply` operation.
+*   Restores origin files from the sandbox's backup.
+*   *Note: Only works if the sandbox worktree still exists.*
+
+---
+
 ### `yggtree wt create-multi`
 
 Create multiple worktrees at once.
@@ -428,6 +475,27 @@ Useful when you want to manually navigate or copy the path into scripts.
 
 ---
 
+<details>
+<summary>Try a risky refactor in a Sandbox</summary>
+
+**Command:**
+
+```bash
+yggtree wt create-sandbox --carry
+```
+
+**Scenario:**
+
+1.  You have 5 files changed in your main repo but aren't sure about the direction.
+2.  Run `create-sandbox --carry` to move those changes into an isolated `current-branch_a1b2` folder.
+3.  Experiment freely.
+4.  If it works: `yggtree wt apply`.
+5.  If it fails: Just delete the sandbox or `unapply`.
+
+</details>
+
+---
+
 ## 🌍 Philosophy
 
 Branches are ideas.

package/dist/commands/wt/apply.js

@@ -0,0 +1,128 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { log, ui, createSpinner } from '../../lib/ui.js';
+import { findSandboxRoot, readSandboxMeta, writeSandboxMeta } from '../../lib/sandbox.js';
+export async function applyCommand() {
+    try {
+        const cwd = process.cwd();
+        // 1. Find sandbox root
+        const sandboxRoot = await findSandboxRoot(cwd);
+        if (!sandboxRoot) {
+            log.error('Not inside a sandbox worktree.');
+            log.info(`Run ${chalk.cyan('yggtree wt create-sandbox')} to create one first.`);
+            return;
+        }
+        // 2. Read sandbox metadata
+        const meta = await readSandboxMeta(sandboxRoot);
+        if (!meta) {
+            log.error('Could not read sandbox metadata.');
+            return;
+        }
+        log.info(`Sandbox: ${chalk.cyan(path.basename(sandboxRoot))}`);
+        log.info(`Origin: ${chalk.dim(meta.originPath)} (${chalk.yellow(meta.originBranch)})`);
+        // 3. Get list of changed files (including untracked)
+        const spinner = createSpinner('Detecting changes...').start();
+        let changedFiles = [];
+        try {
+            const { stdout: diffFiles } = await execa('git', ['diff', '--name-only', 'HEAD'], { cwd: sandboxRoot });
+            const { stdout: stagedFiles } = await execa('git', ['diff', '--name-only', '--cached'], { cwd: sandboxRoot });
+            const { stdout: untrackedFiles } = await execa('git', ['ls-files', '--others', '--exclude-standard'], { cwd: sandboxRoot });
+            const allChanges = new Set([
+                ...diffFiles.split('\n').filter(Boolean),
+                ...stagedFiles.split('\n').filter(Boolean),
+                ...untrackedFiles.split('\n').filter(Boolean)
+            ]);
+            changedFiles = [...allChanges];
+        }
+        catch (e) {
+            spinner.fail('Failed to detect changes.');
+            log.error(e.message);
+            return;
+        }
+        if (changedFiles.length === 0) {
+            spinner.info('No changes detected.');
+            return;
+        }
+        spinner.succeed(`Found ${changedFiles.length} changed file(s).`);
+        // Show changes
+        console.log(chalk.dim('\n  Changed files:'));
+        for (const file of changedFiles) {
+            console.log(chalk.yellow(`    ${file}`));
+        }
+        console.log('');
+        // 4. Confirm apply
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Apply ${changedFiles.length} file(s) to origin?`,
+                default: true,
+            }
+        ]);
+        if (!confirm) {
+            log.info('Cancelled.');
+            return;
+        }
+        // 5. Backup original files and copy
+        const applySpinner = createSpinner('Applying changes...').start();
+        const backups = [];
+        for (const relativePath of changedFiles) {
+            const originFile = path.join(meta.originPath, relativePath);
+            const sandboxFile = path.join(sandboxRoot, relativePath);
+            // Skip if sandbox file doesn't exist or is a directory
+            if (!await fs.pathExists(sandboxFile)) {
+                continue;
+            }
+            const sandboxStat = await fs.stat(sandboxFile);
+            if (sandboxStat.isDirectory()) {
+                continue; // Skip directories (e.g., submodules)
+            }
+            // Backup original content (or null if didn't exist)
+            let originalContent = null;
+            if (await fs.pathExists(originFile)) {
+                const originStat = await fs.stat(originFile);
+                if (originStat.isFile()) {
+                    originalContent = await fs.readFile(originFile, 'utf-8');
+                }
+            }
+            backups.push({ relativePath, originalContent });
+            // Copy from sandbox to origin
+            await fs.ensureDir(path.dirname(originFile));
+            await fs.copy(sandboxFile, originFile);
+        }
+        // 6. Update metadata with backups
+        meta.appliedFiles = backups;
+        await writeSandboxMeta(sandboxRoot, meta);
+        applySpinner.succeed(`Applied ${changedFiles.length} file(s) to origin.`);
+        log.info(`Use ${chalk.cyan('yggtree wt unapply')} to undo these changes.`);
+        // 7. Offer to delete sandbox
+        log.warning(`If you delete this sandbox, you won't be able to run ${chalk.cyan('unapply')} later.`);
+        const { shouldDelete } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldDelete',
+                message: 'Delete this sandbox worktree?',
+                default: false,
+            }
+        ]);
+        if (shouldDelete) {
+            const deleteSpinner = createSpinner('Deleting sandbox...').start();
+            try {
+                await execa('git', ['worktree', 'remove', sandboxRoot, '--force'], { cwd: meta.originPath });
+                deleteSpinner.succeed('Sandbox deleted.');
+                log.info(`Returning to origin: ${ui.path(meta.originPath)}`);
+            }
+            catch (e) {
+                deleteSpinner.fail('Failed to delete sandbox.');
+                log.warning('You can delete it manually with: yggtree wt delete');
+            }
+        }
+    }
+    catch (error) {
+        log.actionableError(error.message, 'yggtree wt apply');
+        process.exit(1);
+    }
+}

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
@@ -110,7 +110,6 @@ export async function createCommandNew(options) {
             else {
                 await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
             }
-            spinner.succeed('Worktree created.');
         }
         catch (e) {
             spinner.fail('Failed to create worktree.');
@@ -125,6 +124,21 @@ export async function createCommandNew(options) {
             ]);
             return;
         }
+        try {
+            // Strong Safety Mode: Ensure upstream is origin/<branchName> and publish
+            spinner.text = 'Safely publishing branch...';
+            await ensureCorrectUpstream(wtPath, branchName);
+            spinner.succeed('Worktree created and branch published.');
+        }
+        catch (e) {
+            spinner.fail('Worktree created, but branch publication failed.');
+            log.actionableError(e.message, 'git push -u origin HEAD', wtPath, [
+                `cd ${wtPath}`,
+                'Attempt to push manually: git push -u origin HEAD',
+                'Check if the remote branch already exists or if you have push permissions'
+            ]);
+            // We don't return here because the worktree IS created, we just failed to publish
+        }
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }

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

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, verifyRef, fetchAll, getCurrentBranch, ensureCorrectUpstream } from '../../lib/git.js';
 import { runBootstrap } from '../../lib/config.js';
 import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui, createSpinner } from '../../lib/ui.js';
@@ -84,12 +84,6 @@ export async function createCommandMulti(options) {
                 else {
                     await execa('git', ['worktree', 'add', '-b', branchName, wtPath, baseRef]);
                 }
-                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created.`);
-                createdWorktrees.push(wtPath);
-                // 4. Bootstrap
-                if (shouldBootstrap) {
-                    await runBootstrap(wtPath, repoRoot);
-                }
             }
             catch (error) {
                 wtSpinner.fail(`Failed to create worktree for ${branchName}.`);
@@ -102,6 +96,27 @@ export async function createCommandMulti(options) {
                     'Try pruning stale worktrees: yggtree wt prune',
                     `Run manually: ${cmd}`
                 ]);
+                continue;
+            }
+            try {
+                // Strong Safety Mode: Ensure upstream is origin/<branchName> and publish
+                wtSpinner.text = `Safely publishing branch ${branchName}...`;
+                await ensureCorrectUpstream(wtPath, branchName);
+                wtSpinner.succeed(`Worktree for ${chalk.cyan(branchName)} created and published.`);
+                createdWorktrees.push(wtPath);
+            }
+            catch (error) {
+                wtSpinner.fail(`Worktree for ${branchName} created, but publication failed.`);
+                log.actionableError(error.message, 'git push -u origin HEAD', wtPath, [
+                    `cd ${wtPath}`,
+                    'Attempt to push manually: git push -u origin HEAD',
+                    'Check if the remote branch already exists or if you have push permissions'
+                ]);
+                createdWorktrees.push(wtPath); // Still added to list since wt exists
+            }
+            // 4. Bootstrap
+            if (shouldBootstrap) {
+                await runBootstrap(wtPath, repoRoot);
             }
         }
         // 5. Final Output

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

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+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 { log, ui, createSpinner } from '../../lib/ui.js';
+import { generateSandboxName, writeSandboxMeta } from '../../lib/sandbox.js';
+import { execa } from 'execa';
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+export async function createSandboxCommand(options = {}) {
+    try {
+        const repoRoot = await getRepoRoot();
+        log.info(`Repo: ${chalk.dim(repoRoot)}`);
+        // 1. Auto-detect current branch (no prompt!)
+        const currentBranch = await getCurrentBranch();
+        if (!currentBranch) {
+            log.error('Could not detect current branch. Are you in a git repository?');
+            return;
+        }
+        log.info(`Current branch: ${chalk.cyan(currentBranch)}`);
+        // 2. Generate random sandbox name
+        const sandboxName = generateSandboxName(currentBranch);
+        log.info(`Sandbox name: ${chalk.yellow(sandboxName)}`);
+        // 3. Gather remaining inputs
+        const answers = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'carry',
+                message: 'Carry uncommitted changes to sandbox?',
+                default: true,
+                when: options.carry === undefined,
+            },
+            {
+                type: 'confirm',
+                name: 'bootstrap',
+                message: 'Run bootstrap? (npm install + submodules)',
+                default: true,
+                when: options.bootstrap === undefined,
+            },
+            {
+                type: 'confirm',
+                name: 'shouldEnter',
+                message: 'Do you want to enter the sandbox now?',
+                default: true,
+                when: options.enter === undefined,
+            },
+            {
+                type: 'input',
+                name: 'exec',
+                message: 'Command to run after creation (optional):',
+                default: options.exec,
+                when: options.exec === undefined,
+            }
+        ]);
+        const shouldCarry = options.carry !== undefined ? options.carry : answers.carry;
+        const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
+        const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
+        const execCommandStr = options.exec || answers.exec;
+        // 4. Detect uncommitted changes before creating worktree
+        let changedFiles = [];
+        let submodulePaths = [];
+        if (shouldCarry) {
+            try {
+                // Get list of submodules to exclude from carry
+                try {
+                    const { stdout: submodules } = await execa('git', ['config', '--file', '.gitmodules', '--get-regexp', 'path'], { cwd: repoRoot });
+                    submodulePaths = submodules.split('\n')
+                        .filter(Boolean)
+                        .map(line => line.split(' ')[1])
+                        .filter(Boolean);
+                }
+                catch {
+                    // No submodules or .gitmodules doesn't exist
+                }
+                const { stdout: unstaged } = await execa('git', ['diff', '--name-only'], { cwd: repoRoot });
+                const { stdout: staged } = await execa('git', ['diff', '--name-only', '--cached'], { cwd: repoRoot });
+                const { stdout: untracked } = await execa('git', ['ls-files', '--others', '--exclude-standard'], { cwd: repoRoot });
+                const allChanges = new Set([
+                    ...unstaged.split('\n').filter(Boolean),
+                    ...staged.split('\n').filter(Boolean),
+                    ...untracked.split('\n').filter(Boolean)
+                ]);
+                // Filter out files inside submodule directories
+                changedFiles = [...allChanges].filter(file => {
+                    return !submodulePaths.some(subPath => file === subPath || file.startsWith(subPath + '/'));
+                });
+            }
+            catch {
+                // Ignore errors, proceed without carrying
+            }
+        }
+        // 5. Create worktree
+        const repoName = await getRepoName();
+        const wtPath = path.join(WORKTREES_ROOT, repoName, sandboxName);
+        const spinner = createSpinner('Creating sandbox worktree...').start();
+        try {
+            await fs.ensureDir(path.dirname(wtPath));
+            // Create new branch from current HEAD (local branch)
+            await execa('git', ['worktree', 'add', '-b', sandboxName, wtPath, 'HEAD']);
+        }
+        catch (e) {
+            spinner.fail('Failed to create sandbox worktree.');
+            log.actionableError(e.message, `git worktree add -b ${sandboxName} ${wtPath} HEAD`, wtPath, [
+                'Check if the folder already exists: ls ' + wtPath,
+                'Check if the branch is already used: git worktree list',
+                'Try pruning stale worktrees: yggtree wt prune',
+            ]);
+            return;
+        }
+        // 6. Carry over uncommitted changes (excluding submodules)
+        if (shouldCarry && changedFiles.length > 0) {
+            spinner.text = `Carrying ${changedFiles.length} uncommitted file(s)...`;
+            for (const file of changedFiles) {
+                const srcFile = path.join(repoRoot, file);
+                const destFile = path.join(wtPath, file);
+                try {
+                    if (await fs.pathExists(srcFile)) {
+                        await fs.ensureDir(path.dirname(destFile));
+                        await fs.copy(srcFile, destFile);
+                    }
+                }
+                catch {
+                    // Skip files that can't be copied
+                }
+            }
+            log.info(`Carried ${changedFiles.length} uncommitted file(s) to sandbox.`);
+            if (submodulePaths.length > 0) {
+                log.dim(`Submodules excluded (will be initialized by bootstrap): ${submodulePaths.join(', ')}`);
+            }
+        }
+        // 7. Write sandbox metadata (NO remote push for sandbox!)
+        await writeSandboxMeta(wtPath, {
+            originPath: repoRoot,
+            originBranch: currentBranch,
+            createdAt: new Date().toISOString(),
+        });
+        spinner.succeed(`Sandbox created: ${chalk.cyan(sandboxName)}`);
+        log.dim('This is a local sandbox - no remote branch will be pushed.');
+        // 8. Bootstrap
+        if (shouldBootstrap) {
+            await runBootstrap(wtPath, repoRoot);
+        }
+        // 9. Exec command
+        if (execCommandStr && execCommandStr.trim()) {
+            log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
+            try {
+                await execa(execCommandStr, {
+                    cwd: wtPath,
+                    stdio: 'inherit',
+                    shell: true
+                });
+            }
+            catch (error) {
+                log.actionableError(error.message, execCommandStr, wtPath, [
+                    `cd ${wtPath} && ${execCommandStr}`,
+                    'Check your command syntax and environment variables'
+                ]);
+            }
+        }
+        // 10. Final output
+        log.success('Sandbox ready!');
+        log.info(`Use ${chalk.cyan('yggtree wt apply')} to apply changes to origin.`);
+        log.info(`Use ${chalk.cyan('yggtree wt unapply')} to undo applied changes.`);
+        if (shouldEnter) {
+            log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
+            log.dim('Type "exit" to return to the main terminal.');
+            const shell = process.env.SHELL || 'zsh';
+            const child = spawn(shell, [], {
+                cwd: wtPath,
+                stdio: 'inherit',
+            });
+            child.on('close', () => {
+                log.info('Exited sub-shell.');
+            });
+        }
+        else {
+            log.header(`cd "${wtPath}"`);
+        }
+    }
+    catch (error) {
+        log.actionableError(error.message, 'yggtree wt create-sandbox');
+        process.exit(1);
+    }
+}

package/dist/commands/wt/unapply.js

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs-extra';
+import { log, createSpinner } from '../../lib/ui.js';
+import { findSandboxRoot, readSandboxMeta, writeSandboxMeta } from '../../lib/sandbox.js';
+export async function unapplyCommand() {
+    try {
+        const cwd = process.cwd();
+        // 1. Find sandbox root
+        const sandboxRoot = await findSandboxRoot(cwd);
+        if (!sandboxRoot) {
+            log.error('Not inside a sandbox worktree.');
+            log.info(`This command only works inside a sandbox created with ${chalk.cyan('yggtree wt create-sandbox')}.`);
+            return;
+        }
+        // 2. Read sandbox metadata
+        const meta = await readSandboxMeta(sandboxRoot);
+        if (!meta) {
+            log.error('Could not read sandbox metadata.');
+            return;
+        }
+        // 3. Check if there are applied changes to unapply
+        if (!meta.appliedFiles || meta.appliedFiles.length === 0) {
+            log.info('No applied changes to unapply.');
+            log.dim('Use "yggtree wt apply" first to apply changes to origin.');
+            return;
+        }
+        log.info(`Sandbox: ${chalk.cyan(path.basename(sandboxRoot))}`);
+        log.info(`Origin: ${chalk.dim(meta.originPath)} (${chalk.yellow(meta.originBranch)})`);
+        log.info(`Applied files: ${chalk.yellow(meta.appliedFiles.length)}`);
+        // Show files that will be reverted
+        console.log(chalk.dim('\n  Files to revert in origin:'));
+        for (const backup of meta.appliedFiles) {
+            const action = backup.originalContent === null ? '(delete)' : '(restore)';
+            console.log(chalk.yellow(`    ${backup.relativePath} ${chalk.dim(action)}`));
+        }
+        console.log('');
+        // 4. Confirm unapply
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Revert ${meta.appliedFiles.length} file(s) in origin?`,
+                default: true,
+            }
+        ]);
+        if (!confirm) {
+            log.info('Cancelled.');
+            return;
+        }
+        // 5. Restore original files
+        const spinner = createSpinner('Reverting changes in origin...').start();
+        for (const backup of meta.appliedFiles) {
+            const originFile = path.join(meta.originPath, backup.relativePath);
+            if (backup.originalContent === null) {
+                // File was newly created by apply, delete it
+                if (await fs.pathExists(originFile)) {
+                    await fs.remove(originFile);
+                }
+            }
+            else {
+                // Restore original content
+                await fs.ensureDir(path.dirname(originFile));
+                await fs.writeFile(originFile, backup.originalContent, 'utf-8');
+            }
+        }
+        // 6. Clear applied files from metadata
+        const revertedCount = meta.appliedFiles.length;
+        meta.appliedFiles = [];
+        await writeSandboxMeta(sandboxRoot, meta);
+        spinner.succeed(`Reverted ${revertedCount} file(s) in origin.`);
+        log.info('Origin is back to its state before apply.');
+    }
+    catch (error) {
+        log.actionableError(error.message, 'yggtree wt unapply');
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -5,12 +5,15 @@ import { listCommand } from './commands/wt/list.js';
 import { createCommand } from './commands/wt/create.js';
 import { createCommandNew } from './commands/wt/create-branch.js';
 import { createCommandMulti } from './commands/wt/create-multi.js';
+import { createSandboxCommand } from './commands/wt/create-sandbox.js';
 import { deleteCommand } from './commands/wt/delete.js';
 import { bootstrapCommand } from './commands/wt/bootstrap.js';
 import { pruneCommand } from './commands/wt/prune.js';
 import { execCommand } from './commands/wt/exec.js';
 import { enterCommand } from './commands/wt/enter.js';
 import { pathCommand } from './commands/wt/path.js';
+import { applyCommand } from './commands/wt/apply.js';
+import { unapplyCommand } from './commands/wt/unapply.js';
 import { getVersion } from './lib/version.js';
 const program = new Command();
 program
@@ -29,15 +32,19 @@ program
             choices: [
                 { name: '🌿 Create new worktree (Smart Branch)', value: 'create-smart' },
                 { name: '🌳 Create multiple worktrees', value: 'create-multi' },
-                { name: '🌱 Create new worktree (Manual Slug)', value: 'create-slug' },
+                { name: '🧪 Create sandbox worktree', value: 'create-sandbox' },
+                // { name: '🌱 Create new worktree (Manual Slug)', value: 'create-slug' },
                 { name: '📋 List worktrees', value: 'list' },
-                { name: '🗑️  Delete worktree', value: 'delete' },
+                { name: '🪓 Delete worktree', value: 'delete' },
                 { name: '🚀 Bootstrap worktree', value: 'bootstrap' },
                 { name: '🧹 Prune stale worktrees', value: 'prune' },
                 { name: '🐚 Exec command', value: 'exec' },
                 { name: '🚪 Enter worktree', value: 'enter' },
                 { name: '📍 Get worktree path', value: 'path' },
                 new inquirer.Separator(),
+                { name: '✅ Apply sandbox changes', value: 'apply' },
+                { name: '↩️  Unapply sandbox changes', value: 'unapply' },
+                new inquirer.Separator(),
                 { name: '🚪 Exit', value: 'exit' },
             ],
         },
@@ -73,6 +80,15 @@ program
         case 'path':
             await pathCommand();
             break;
+        case 'apply':
+            await applyCommand();
+            break;
+        case 'unapply':
+            await unapplyCommand();
+            break;
+        case 'create-sandbox':
+            await createSandboxCommand({ bootstrap: true });
+            break;
         case 'exit':
             log.info('Bye! 👋');
             process.exit(0);
@@ -149,4 +165,21 @@ wt.command('path [worktree]')
     .action(async (worktree) => {
     await pathCommand(worktree);
 });
+wt.command('create-sandbox')
+    .description('Create a sandbox worktree from current branch')
+    .option('--carry', 'Carry uncommitted changes to sandbox')
+    .option('--no-carry', 'Do not carry uncommitted changes')
+    .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
+    .option('--enter', 'Enter sub-shell after creation')
+    .option('--no-enter', 'Skip entering sub-shell')
+    .option('--exec <command>', 'Command to execute after creation')
+    .action(async (options) => {
+    await createSandboxCommand(options);
+});
+wt.command('apply')
+    .description('Apply sandbox changes to origin directory')
+    .action(applyCommand);
+wt.command('unapply')
+    .description('Undo applied sandbox changes in origin')
+    .action(unapplyCommand);
 program.parse(process.argv);

package/dist/lib/git.js

@@ -1,6 +1,8 @@
 import { execa } from 'execa';
 import fs from 'fs-extra';
 import path from 'path';
+import { log } from './ui.js';
+import chalk from 'chalk';
 export async function getRepoRoot() {
     try {
         const { stdout } = await execa('git', ['rev-parse', '--show-toplevel']);
@@ -83,3 +85,34 @@ export async function isGitClean(cwd) {
         return false;
     }
 }
+/**
+ * Ensures the branch in the given worktree path tracks origin/<branchName>.
+ * If it tracks a different base branch (e.g. origin/main), it unsets it and publishes to origin.
+ * Fails if origin/<branchName> already exists on remote and is not already the upstream.
+ */
+export async function ensureCorrectUpstream(wtPath, branchName) {
+    const desiredUpstream = `origin/${branchName}`;
+    let currentUpstream = '';
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: wtPath });
+        currentUpstream = stdout.trim();
+    }
+    catch {
+        // No upstream set
+    }
+    if (currentUpstream === desiredUpstream) {
+        return; // Already correct
+    }
+    // If it's set to something else, unset it
+    if (currentUpstream) {
+        log.info(`Incorrect upstream detected: ${currentUpstream}. Unsetting...`);
+        await execa('git', ['branch', '--unset-upstream'], { cwd: wtPath });
+    }
+    // Check if remote branch already exists
+    const remoteExists = await verifyRef(desiredUpstream);
+    if (remoteExists) {
+        throw new Error(`Remote branch '${desiredUpstream}' already exists. Cannot publish safely without more info. Use 'git push -u origin HEAD' manually if you want to link them.`);
+    }
+    log.info(`Publishing branch ${chalk.cyan(branchName)} to ${chalk.cyan(desiredUpstream)}...`);
+    await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
+}

package/dist/lib/sandbox.js

@@ -0,0 +1,61 @@
+import crypto from 'crypto';
+import path from 'path';
+import fs from 'fs-extra';
+const SANDBOX_META_FILE = '.sandbox-meta.json';
+/**
+ * Generate a sandbox worktree name: <branch>_<4-char-hash>
+ */
+export function generateSandboxName(branch) {
+    const hash = crypto.randomBytes(2).toString('hex'); // 4 hex chars
+    const safeBranch = branch.replace(/[\\/]/g, '-');
+    return `${safeBranch}_${hash}`;
+}
+/**
+ * Get the path to the sandbox metadata file
+ */
+export function getSandboxMetaPath(wtPath) {
+    return path.join(wtPath, SANDBOX_META_FILE);
+}
+/**
+ * Write sandbox metadata to the worktree
+ */
+export async function writeSandboxMeta(wtPath, meta) {
+    const metaPath = getSandboxMetaPath(wtPath);
+    await fs.writeJSON(metaPath, meta, { spaces: 2 });
+}
+/**
+ * Read sandbox metadata from a worktree
+ */
+export async function readSandboxMeta(wtPath) {
+    const metaPath = getSandboxMetaPath(wtPath);
+    if (await fs.pathExists(metaPath)) {
+        try {
+            return await fs.readJSON(metaPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Check if the current directory is inside a sandbox worktree
+ */
+export async function isSandboxWorktree(cwd) {
+    const meta = await readSandboxMeta(cwd);
+    return meta !== null;
+}
+/**
+ * Find the sandbox root from any subdirectory
+ */
+export async function findSandboxRoot(startPath) {
+    let current = startPath;
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (await fs.pathExists(getSandboxMetaPath(current))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yggtree",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Interactive CLI for managing git worktrees and configs",
   "main": "dist/index.js",
   "type": "module",