yggtree 1.2.1 → 1.4.0

package/dist/commands/wt/open.js

@@ -0,0 +1,245 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import { constants as fsConstants } from 'fs';
+import { execa } from 'execa';
+import { listWorktrees, getRepoRoot } from '../../lib/git.js';
+import { log, ui } from '../../lib/ui.js';
+import { ensureAutocompletePrompt } from '../../lib/prompt.js';
+import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
+import { enterCommand } from './enter.js';
+const OPEN_TOOL_CANDIDATES = [
+    { id: 'cursor', name: 'Cursor', command: 'cursor', kind: 'ide', aliases: ['cursor'] },
+    { id: 'code', name: 'VS Code', command: 'code', kind: 'ide', aliases: ['vscode', 'code'] },
+    { id: 'windsurf', name: 'Windsurf', command: 'windsurf', kind: 'ide', aliases: ['windsurf'] },
+    { id: 'zed', name: 'Zed', command: 'zed', kind: 'ide', aliases: ['zed'] },
+    { id: 'agy', name: 'Agy', command: 'agy', kind: 'ide', aliases: ['agy'] },
+    { id: 'idea', name: 'IntelliJ IDEA', command: 'idea', kind: 'ide', aliases: ['idea', 'intellij'] },
+    { id: 'webstorm', name: 'WebStorm', command: 'webstorm', kind: 'ide', aliases: ['webstorm'] },
+    { id: 'subl', name: 'Sublime Text', command: 'subl', kind: 'ide', aliases: ['subl', 'sublime'] },
+    { id: 'claude', name: 'Claude Code', command: 'claude', kind: 'agent', aliases: ['claude', 'claude-code'] },
+    { id: 'codex', name: 'Codex', command: 'codex', kind: 'agent', aliases: ['codex'] },
+    { id: 'gemini', name: 'Gemini CLI', command: 'gemini', kind: 'agent', aliases: ['gemini'] },
+    { id: 'opencode', name: 'OpenCode', command: 'opencode', kind: 'agent', aliases: ['opencode'] },
+];
+function truncateEnd(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `${value.slice(0, maxLen - 1)}…`;
+}
+function truncateStart(value, maxLen) {
+    if (maxLen <= 0)
+        return '';
+    if (value.length <= maxLen)
+        return value;
+    if (maxLen <= 1)
+        return '…';
+    return `…${value.slice(-(maxLen - 1))}`;
+}
+function formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumns) {
+    const maxRowWidth = Math.max(40, terminalColumns - 10);
+    const typeWidth = 8;
+    const availableWidth = Math.max(22, maxRowWidth - typeWidth);
+    const branchWidth = Math.min(44, Math.max(12, Math.floor(availableWidth * 0.55)));
+    const pathWidth = Math.max(10, availableWidth - branchWidth - 1);
+    const branchText = truncateEnd(branchName, branchWidth).padEnd(branchWidth);
+    const pathText = truncateStart(displayPath, pathWidth);
+    const typeText = formatWorktreeType(type);
+    return `${typeText} ${chalk.yellow(branchText)} ${chalk.cyan(pathText)}`;
+}
+export async function commandExists(command) {
+    if (!command)
+        return false;
+    const isWindows = process.platform === 'win32';
+    const pathEntries = (process.env.PATH || '')
+        .split(path.delimiter)
+        .filter(Boolean);
+    const extensions = isWindows
+        ? (process.env.PATHEXT || '.EXE;.CMD;.BAT')
+            .split(';')
+            .map(ext => ext.toLowerCase())
+        : [''];
+    const hasPathSeparator = command.includes('/') || command.includes('\\');
+    const candidates = hasPathSeparator
+        ? [command]
+        : pathEntries.flatMap(dir => extensions.map(ext => path.join(dir, `${command}${ext}`)));
+    const mode = isWindows ? fsConstants.F_OK : fsConstants.X_OK;
+    for (const candidate of candidates) {
+        try {
+            await fs.access(candidate, mode);
+            return true;
+        }
+        catch {
+            // Continue scanning
+        }
+    }
+    return false;
+}
+export async function detectInstalledOpenTools() {
+    const checks = await Promise.all(OPEN_TOOL_CANDIDATES.map(async (tool) => ({
+        tool,
+        exists: await commandExists(tool.command),
+    })));
+    return checks
+        .filter(check => check.exists)
+        .map(check => check.tool);
+}
+function resolveWorktreeByName(worktrees, wtName) {
+    return findWorktreeByName(worktrees, wtName);
+}
+export function resolveOpenToolOption(input, installed) {
+    const normalized = input.trim().toLowerCase();
+    return installed.find(tool => tool.id === normalized ||
+        tool.command.toLowerCase() === normalized ||
+        tool.aliases?.some(alias => alias.toLowerCase() === normalized));
+}
+export function isAgentTool(tool) {
+    return tool.kind === 'agent';
+}
+export function buildAgentExecCommand(tool) {
+    return tool.command;
+}
+export async function promptOpenToolSelection(installedTools, message = 'Select tool to open:') {
+    const ideChoices = installedTools
+        .filter(tool => tool.kind === 'ide')
+        .map(tool => ({
+        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        value: tool,
+    }));
+    const agentChoices = installedTools
+        .filter(tool => tool.kind === 'agent')
+        .map(tool => ({
+        name: `${tool.name} ${chalk.dim(`(${tool.command})`)}`,
+        value: tool,
+    }));
+    const choices = [];
+    if (ideChoices.length > 0) {
+        choices.push(new inquirer.Separator(chalk.dim('── IDEs ──')));
+        choices.push(...ideChoices);
+    }
+    if (agentChoices.length > 0) {
+        if (choices.length > 0)
+            choices.push(new inquirer.Separator(" "));
+        choices.push(new inquirer.Separator(chalk.dim('── Agent CLIs ──')));
+        choices.push(...agentChoices);
+    }
+    const { selectedTool } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedTool',
+            message,
+            choices,
+            loop: false,
+            pageSize: 10,
+        },
+    ]);
+    return selectedTool;
+}
+export async function launchOpenTool(tool, wtPath) {
+    if (isAgentTool(tool)) {
+        await enterCommand(wtPath, { exec: buildAgentExecCommand(tool) });
+        return;
+    }
+    await execa(tool.command, [wtPath], {
+        cwd: wtPath,
+        stdio: 'ignore',
+    });
+}
+export async function openCommand(wtName, options = {}) {
+    try {
+        await getRepoRoot();
+        const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
+        if (worktrees.length === 0) {
+            log.info('No worktrees found.');
+            return;
+        }
+        let targetWt;
+        if (wtName) {
+            targetWt = resolveWorktreeByName(worktrees, wtName);
+            if (!targetWt) {
+                log.error(`Worktree "${wtName}" not found.`);
+                return;
+            }
+        }
+        else {
+            ensureAutocompletePrompt();
+            const terminalColumns = process.stdout.columns || 100;
+            const candidates = await Promise.all(worktrees.map(async (wt) => {
+                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
+                const rawType = type.toLowerCase();
+                const rawDisplayPath = displayPath.toLowerCase();
+                const rawBranchName = branchName.toLowerCase();
+                return {
+                    worktree: wt,
+                    label: formatWorktreeChoiceLabel(type, branchName, displayPath, terminalColumns),
+                    searchText: `${rawType} ${rawBranchName} ${rawDisplayPath}`,
+                };
+            }));
+            const { selectedWt } = await inquirer.prompt([
+                {
+                    type: 'autocomplete',
+                    name: 'selectedWt',
+                    message: 'Select a worktree to open (type to filter):',
+                    source: async (_answers, input = '') => {
+                        const term = input.trim().toLowerCase();
+                        const filtered = term
+                            ? candidates.filter(candidate => candidate.searchText.includes(term))
+                            : candidates;
+                        return filtered.map(candidate => ({
+                            name: candidate.label,
+                            value: candidate.worktree,
+                        }));
+                    },
+                    pageSize: 10,
+                },
+            ]);
+            targetWt = selectedWt;
+        }
+        if (!targetWt) {
+            log.error('No worktree selected.');
+            return;
+        }
+        const installedTools = await detectInstalledOpenTools();
+        let chosenTool;
+        const requestedTool = options.tool;
+        if (requestedTool) {
+            chosenTool = resolveOpenToolOption(requestedTool, installedTools);
+            if (!chosenTool && await commandExists(requestedTool)) {
+                chosenTool = {
+                    id: 'custom',
+                    name: requestedTool,
+                    command: requestedTool,
+                    kind: 'ide',
+                };
+            }
+            if (!chosenTool) {
+                const available = installedTools.map(tool => tool.command).join(', ') || 'none detected';
+                log.error(`Tool "${requestedTool}" not found.`);
+                log.dim(`Detected tool commands: ${available}`);
+                return;
+            }
+        }
+        else {
+            if (installedTools.length === 0) {
+                log.error('No supported open tool command was detected in PATH.');
+                log.dim('Try: yggtree wt open --tool <command> (e.g. --tool cursor, --tool claude)');
+                return;
+            }
+            chosenTool = await promptOpenToolSelection(installedTools);
+        }
+        log.info(`Opening ${ui.path(targetWt.path)} in ${chalk.cyan(chosenTool.name)}...`);
+        await launchOpenTool(chosenTool, targetWt.path);
+        log.success(isAgentTool(chosenTool) ? 'Agent launched.' : 'IDE launched.');
+    }
+    catch (error) {
+        log.error(error.message);
+    }
+}

package/dist/commands/wt/path.js

@@ -1,8 +1,7 @@
 import inquirer from 'inquirer';
-import path from 'path';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log } from '../../lib/ui.js';
+import { findWorktreeByName, formatWorktreeDisplayPath, getWorktreeBranchName } from '../../lib/worktree.js';
 export async function pathCommand(wtName) {
     try {
         await getRepoRoot();
@@ -13,16 +12,7 @@ export async function pathCommand(wtName) {
         }
         let targetWt;
         if (wtName) {
-            // Find worktree by name (branch name, relative path, or slug/basename)
-            targetWt = worktrees.find(wt => {
-                const branchName = wt.branch || wt.HEAD || '';
-                const relativePath = path.relative(WORKTREES_ROOT, wt.path);
-                const basename = path.basename(wt.path);
-                return branchName === wtName ||
-                    relativePath === wtName ||
-                    wt.path === wtName ||
-                    basename === wtName;
-            });
+            targetWt = findWorktreeByName(worktrees, wtName);
             if (!targetWt) {
                 log.error(`Worktree "${wtName}" not found.`);
                 return;
@@ -31,11 +21,8 @@ export async function pathCommand(wtName) {
         else {
             // Interactive Selection
             const choices = worktrees.map(wt => {
-                const branchName = wt.branch || wt.HEAD || 'detached';
-                const isManaged = wt.path.startsWith(WORKTREES_ROOT);
-                const displayPath = isManaged
-                    ? path.relative(WORKTREES_ROOT, wt.path)
-                    : wt.path.replace(process.env.HOME || '', '~');
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
                 return {
                     name: `${branchName.padEnd(20)} ${displayPath}`,
                     value: wt

package/dist/index.js

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
+import chalk from 'chalk';
 import { welcome, log } from './lib/ui.js';
 import { listCommand } from './commands/wt/list.js';
 import { createCommand } from './commands/wt/create.js';
@@ -12,9 +13,11 @@ 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 { openCommand } from './commands/wt/open.js';
 import { applyCommand } from './commands/wt/apply.js';
 import { unapplyCommand } from './commands/wt/unapply.js';
 import { getVersion } from './lib/version.js';
+import { findSandboxRoot } from './lib/sandbox.js';
 const program = new Command();
 program
     .name('yggtree')
@@ -23,30 +26,48 @@ program
     .action(async () => {
     // Interactive Menu if no command is provided
     await welcome();
+    const isInSandbox = Boolean(await findSandboxRoot(process.cwd()));
+    const realmChoices = [
+        { name: `🌿 Grow New Realm ${chalk.dim('(create worktree)')}`, value: 'create-smart' },
+        { name: `🔀 Traverse to Another Realm ${chalk.dim('(checkout existing branch in new worktree)')}`, value: 'worktree-checkout' },
+        { name: `🌳 Grow Many Realms ${chalk.dim('(create multiple worktrees)')}`, value: 'create-multi' },
+        { name: `🧪 Forge Sandbox Realm ${chalk.dim('(create sandbox worktree)')}`, value: 'create-sandbox' },
+        { name: `🗺️  Survey Realms ${chalk.dim('(list worktrees)')}`, value: 'list' },
+        { name: `🧭 Open Realm in Tool ${chalk.dim('(open worktree in IDE/agent)')}`, value: 'open' },
+        { name: `🪓 Fell a Realm ${chalk.dim('(delete worktree)')}`, value: 'delete' },
+        { name: `🚀 Bless Realm Setup ${chalk.dim('(bootstrap worktree)')}`, value: 'bootstrap' },
+        { name: `🧹 Prune Withered Realms ${chalk.dim('(prune stale worktrees)')}`, value: 'prune' },
+        { name: `🐚 Cast a Command ${chalk.dim('(exec command in worktree)')}`, value: 'exec' },
+        { name: `🚪 Enter Realm Shell ${chalk.dim('(enter worktree)')}`, value: 'enter' },
+        { name: `📍 Reveal Realm Path ${chalk.dim('(show worktree path)')}`, value: 'path' },
+    ];
+    const sandboxChoices = [
+        { name: `✅ Graft Sandbox Changes ${chalk.dim('(apply sandbox changes)')}`, value: 'apply' },
+        { name: `↩️ Undo Sandbox Graft ${chalk.dim('(unapply sandbox changes)')}`, value: 'unapply' },
+    ];
+    const choices = isInSandbox
+        ? [
+            ...sandboxChoices,
+            new inquirer.Separator(),
+            ...realmChoices,
+            new inquirer.Separator(),
+            { name: `🚪 Leave Yggdrasil ${chalk.dim('(exit)')}`, value: 'exit' },
+        ]
+        : [
+            ...realmChoices,
+            new inquirer.Separator(),
+            ...sandboxChoices,
+            new inquirer.Separator(),
+            { name: `🚪 Leave Yggdrasil ${chalk.dim('(exit)')}`, value: 'exit' },
+        ];
     const { action } = await inquirer.prompt([
         {
             type: 'list',
             name: 'action',
             message: 'What would you like to do?',
             loop: false,
-            choices: [
-                { name: '🌿 Create new worktree (Smart Branch)', value: 'create-smart' },
-                { name: '🌳 Create multiple worktrees', value: 'create-multi' },
-                { 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: '🚀 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' },
-            ],
+            pageSize: 12,
+            choices,
         },
     ]);
     switch (action) {
@@ -56,12 +77,15 @@ program
         case 'create-multi':
             await createCommandMulti({ bootstrap: true });
             break;
-        case 'create-slug':
+        case 'worktree-checkout':
             await createCommand({ bootstrap: true });
             break;
         case 'list':
             await listCommand();
             break;
+        case 'open':
+            await openCommand();
+            break;
         case 'delete':
             await deleteCommand();
             break;
@@ -97,8 +121,15 @@ program
 // --- Worktree Commands ---
 const wt = program.command('wt').description('Manage git worktrees');
 wt.command('list')
-    .description('List all worktrees')
-    .action(listCommand);
+    .description('List all repo-linked worktrees')
+    .option('--open', 'Open a worktree in an IDE/agent tool instead of listing')
+    .action(async (options) => {
+    if (options.open) {
+        await openCommand();
+        return;
+    }
+    await listCommand();
+});
 wt.command('create [branch]')
     .description('Create a new worktree (Smart branch detection)')
     .option('-b, --branch <name>', 'Branch name (e.g. feat/new-ui)')
@@ -122,8 +153,8 @@ wt.command('create-multi')
     .action(async (options) => {
     await createCommandMulti(options);
 });
-wt.command('create-slug [name] [ref]')
-    .description('Create a new worktree (Manual slug/ref)')
+wt.command('worktree-checkout [name] [ref]')
+    .description('Create a checkout-style worktree from an existing branch')
     .option('-n, --name <slug>', 'Worktree name (slug)')
     .option('-r, --ref <ref>', 'Existing branch or ref')
     .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')
@@ -138,8 +169,17 @@ wt.command('create-slug [name] [ref]')
     });
 });
 wt.command('delete')
-    .description('Delete a managed worktree')
-    .action(deleteCommand);
+    .description('Delete managed worktrees')
+    .option('-a, --all', 'Include repo-linked worktrees outside ~/.yggtree (except main/current)')
+    .action(async (options) => {
+    await deleteCommand(options);
+});
+wt.command('open [worktree]')
+    .description('Open a worktree in an IDE or agent CLI')
+    .option('--tool <command>', 'Tool command to use (e.g. cursor, code, claude, codex)')
+    .action(async (worktree, options) => {
+    await openCommand(worktree, options);
+});
 wt.command('bootstrap')
     .description('Bootstrap dependencies in a worktree')
     .action(bootstrapCommand);
@@ -167,6 +207,7 @@ wt.command('path [worktree]')
 });
 wt.command('create-sandbox')
     .description('Create a sandbox worktree from current branch')
+    .option('-n, --name <name>', 'Optional sandbox name (auto-generated when omitted)')
     .option('--carry', 'Carry uncommitted changes to sandbox')
     .option('--no-carry', 'Do not carry uncommitted changes')
     .option('--no-bootstrap', 'Skip bootstrap (npm install + submodules)')

package/dist/lib/config.js

@@ -3,13 +3,26 @@ import fs from 'fs-extra';
 import { execa } from 'execa';
 import { log, createSpinner } from './ui.js';
 export async function getBootstrapCommands(repoRoot, wtPath) {
-    const searchPaths = [];
-    if (wtPath)
+    // repoRoot first (source of truth — where yggtree is run from)
+    // wtPath second (per-worktree override if needed)
+    const searchPaths = [repoRoot];
+    if (wtPath && wtPath !== repoRoot)
         searchPaths.push(wtPath);
-    searchPaths.push(repoRoot);
     for (const searchPath of searchPaths) {
+        const yggtreeConfigPath = path.join(searchPath, '.yggtree', 'worktree-setup.json');
         const configPath = path.join(searchPath, 'yggtree-worktree.json');
         const cursorConfigPath = path.join(searchPath, '.cursor', 'worktrees.json');
+        if (await fs.pathExists(yggtreeConfigPath)) {
+            try {
+                const config = await fs.readJSON(yggtreeConfigPath);
+                if (config['setup-worktree'] && Array.isArray(config['setup-worktree'])) {
+                    return config['setup-worktree'];
+                }
+            }
+            catch (e) {
+                log.warning(`Failed to parse ${yggtreeConfigPath}.`);
+            }
+        }
         if (await fs.pathExists(configPath)) {
             try {
                 const config = await fs.readJSON(configPath);
@@ -50,7 +63,7 @@ export async function runBootstrap(wtPath, repoRoot) {
                 spinner.fail(`Failed: ${cmd}`);
                 log.actionableError(e.message, cmd, wtPath, [
                     `Try running the command manually: cd ${wtPath} && ${cmd}`,
-                    'Check your configuration in yggtree-worktree.json'
+                    'Check your configuration in .yggtree/worktree-setup.json or yggtree-worktree.json'
                 ]);
             }
         }

package/dist/lib/git.js

@@ -86,9 +86,12 @@ export async function isGitClean(cwd) {
     }
 }
 /**
- * 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.
+ * Safety net: ensures the branch does NOT track an incorrect upstream
+ * (e.g. origin/main when the branch is feat/new-thing).
+ *
+ * - Correct tracking (origin/<branchName>) → no-op
+ * - No tracking at all → no-op
+ * - Wrong tracking → unsets it
  */
 export async function ensureCorrectUpstream(wtPath, branchName) {
     const desiredUpstream = `origin/${branchName}`;
@@ -98,21 +101,68 @@ export async function ensureCorrectUpstream(wtPath, branchName) {
         currentUpstream = stdout.trim();
     }
     catch {
-        // No upstream set
+        // No upstream set — safe
+        return;
     }
     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 });
+    // Wrong tracking — kill it
+    log.warning(`Incorrect upstream detected: ${chalk.red(currentUpstream)} (expected ${chalk.cyan(desiredUpstream)}). Unsetting...`);
+    await execa('git', ['branch', '--unset-upstream'], { cwd: wtPath });
+}
+/**
+ * Publishes a local branch to origin and sets upstream tracking.
+ * Skips if the branch is already published (origin/<branchName> exists and is tracked).
+ */
+export async function publishBranch(wtPath, branchName) {
+    const desiredUpstream = `origin/${branchName}`;
+    // Check if already tracking the correct remote
+    try {
+        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { cwd: wtPath });
+        if (stdout.trim() === desiredUpstream) {
+            return; // Already published and tracked
+        }
     }
-    // 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.`);
+    catch {
+        // No upstream — expected for new branches
     }
-    log.info(`Publishing branch ${chalk.cyan(branchName)} to ${chalk.cyan(desiredUpstream)}...`);
+    log.info(`Publishing ${chalk.cyan(branchName)} → ${chalk.cyan(desiredUpstream)}...`);
     await execa('git', ['push', '-u', 'origin', 'HEAD'], { cwd: wtPath });
 }
+/**
+ * Returns the most recent activity date for a worktree by checking two signals:
+ * 1. Last commit time (captures committed work)
+ * 2. Git index mtime (captures staging, checkouts, uncommitted work)
+ *
+ * The most recent of the two wins. Returns null if both fail.
+ */
+export async function getLastActivity(wtPath) {
+    const dates = [];
+    // Signal 1 — last commit epoch
+    try {
+        const { stdout } = await execa('git', ['log', '-1', '--format=%ct'], { cwd: wtPath });
+        const epoch = parseInt(stdout.trim(), 10);
+        if (!isNaN(epoch)) {
+            dates.push(new Date(epoch * 1000));
+        }
+    }
+    catch {
+        // no commits reachable — skip
+    }
+    // Signal 2 — git index file mtime
+    try {
+        const { stdout: gitDir } = await execa('git', ['rev-parse', '--git-dir'], { cwd: wtPath });
+        const gitDirPath = gitDir.trim();
+        const resolvedGitDir = path.isAbsolute(gitDirPath) ? gitDirPath : path.join(wtPath, gitDirPath);
+        const indexPath = path.join(resolvedGitDir, 'index');
+        const stat = await fs.stat(indexPath);
+        dates.push(stat.mtime);
+    }
+    catch {
+        // index not found — skip
+    }
+    if (dates.length === 0)
+        return null;
+    return new Date(Math.max(...dates.map(d => d.getTime())));
+}

package/dist/lib/prompt.js

@@ -0,0 +1,9 @@
+import inquirer from 'inquirer';
+import autocompletePrompt from 'inquirer-autocomplete-prompt';
+let autocompleteRegistered = false;
+export function ensureAutocompletePrompt() {
+    if (!autocompleteRegistered) {
+        inquirer.registerPrompt('autocomplete', autocompletePrompt);
+        autocompleteRegistered = true;
+    }
+}

package/dist/lib/sandbox.js

@@ -1,26 +1,42 @@
 import crypto from 'crypto';
 import path from 'path';
 import fs from 'fs-extra';
-export const SANDBOX_META_FILE = '.sandbox-meta.json';
+export const YGGTREE_DIR = '.yggtree';
+export 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}`;
+    return `sandbox-${hash}_${safeBranch}`;
+}
+/**
+ * Normalize a custom sandbox name into a branch-safe slug.
+ * Keeps current sandbox prefix conventions for easier filtering.
+ */
+export function normalizeSandboxName(input) {
+    const cleaned = input
+        .trim()
+        .replace(/[\\/]/g, '-')
+        .replace(/\s+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    if (!cleaned)
+        return '';
+    return cleaned.startsWith('sandbox-') ? cleaned : `sandbox-${cleaned}`;
 }
 /**
  * Get the path to the sandbox metadata file
  */
 export function getSandboxMetaPath(wtPath) {
-    return path.join(wtPath, SANDBOX_META_FILE);
+    return path.join(wtPath, YGGTREE_DIR, SANDBOX_META_FILE);
 }
 /**
  * Write sandbox metadata to the worktree
  */
 export async function writeSandboxMeta(wtPath, meta) {
     const metaPath = getSandboxMetaPath(wtPath);
+    await fs.ensureDir(path.dirname(metaPath));
     await fs.writeJSON(metaPath, meta, { spaces: 2 });
 }
 /**

package/dist/lib/ui.js

@@ -50,3 +50,23 @@ export const ui = {
     code: (cmd) => chalk.bgBlack.white(` ${cmd} `),
     path: (p) => chalk.cyan(p),
 };
+// --- Time helpers ---
+/**
+ * Returns a human-friendly relative time string like "just now", "5 min ago", "3 days ago".
+ */
+export function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return 'just now';
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)} min ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    if (seconds < 604800)
+        return `${Math.floor(seconds / 86400)}d ago`;
+    if (seconds < 2592000)
+        return `${Math.floor(seconds / 604800)}w ago`;
+    if (seconds < 31536000)
+        return `${Math.floor(seconds / 2592000)}mo ago`;
+    return `${Math.floor(seconds / 31536000)}y ago`;
+}