yggtree 1.2.1 → 1.4.0

package/dist/commands/wt/create.js

@@ -1,48 +1,138 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import path from 'path';
-import { getRepoRoot, getRepoName, verifyRef, createWorktree, fetchAll, getCurrentBranch } from '../../lib/git.js';
+import { getRepoRoot, getRepoName, createWorktree, fetchAll, listWorktrees } 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 { ensureAutocompletePrompt } from '../../lib/prompt.js';
+import { enterCommand } from './enter.js';
+import { buildAgentExecCommand, detectInstalledOpenTools, isAgentTool, launchOpenTool, promptOpenToolSelection, } from './open.js';
 import { execa } from 'execa';
 import { spawn } from 'child_process';
 import fs from 'fs-extra';
+function toSlug(value) {
+    return value
+        .trim()
+        .replace(/[\/\\]/g, '-')
+        .replace(/\s+/g, '-');
+}
+async function listBranchCandidates() {
+    const [localRefs, remoteRefs] = await Promise.all([
+        execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/heads']),
+        execa('git', ['for-each-ref', '--format=%(refname:short)', 'refs/remotes/origin']),
+    ]);
+    const localBranches = localRefs.stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean);
+    const remoteBranches = remoteRefs.stdout
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(ref => ref !== 'origin/HEAD' && !ref.endsWith('/HEAD'))
+        .map(ref => ref.replace(/^origin\//, ''));
+    const localSet = new Set(localBranches);
+    const remoteOnly = [...new Set(remoteBranches)].filter(branch => !localSet.has(branch));
+    const localCandidates = localBranches.map(branchName => ({
+        branchName,
+        checkoutRef: branchName,
+        createLocalBranch: false,
+        source: 'local',
+    }));
+    const remoteCandidates = remoteOnly.map(branchName => ({
+        branchName,
+        checkoutRef: `origin/${branchName}`,
+        createLocalBranch: true,
+        source: 'remote',
+    }));
+    return [...localCandidates, ...remoteCandidates]
+        .sort((a, b) => a.branchName.localeCompare(b.branchName));
+}
+function resolveCandidateFromRef(ref, candidates) {
+    const trimmedRef = ref.trim();
+    if (!trimmedRef)
+        return undefined;
+    if (trimmedRef.startsWith('origin/')) {
+        const branchName = trimmedRef.replace(/^origin\//, '');
+        return candidates.find(candidate => candidate.branchName === branchName);
+    }
+    return candidates.find(candidate => candidate.branchName === trimmedRef ||
+        candidate.checkoutRef === trimmedRef);
+}
 export async function createCommand(options) {
     try {
         const repoRoot = await getRepoRoot();
         log.info(`Repo: ${chalk.dim(repoRoot)}`);
-        // 1. Gather inputs
-        const currentBranch = await getCurrentBranch();
+        // 1. Load branches
+        const loadingSpinner = createSpinner('Fetching branches...').start();
+        await fetchAll();
+        const candidates = await listBranchCandidates();
+        if (candidates.length === 0) {
+            loadingSpinner.fail('No branches found.');
+            log.warning('Create a branch first, then run worktree-checkout again.');
+            return;
+        }
+        loadingSpinner.succeed(`Loaded ${candidates.length} branches.`);
+        // 2. Select branch
+        ensureAutocompletePrompt();
+        let selectedBranch;
+        if (options.ref) {
+            selectedBranch = resolveCandidateFromRef(options.ref, candidates);
+            if (!selectedBranch) {
+                log.error(`Branch "${options.ref}" not found.`);
+                log.warning('Tip: use a local branch name or origin/<branch>.');
+                return;
+            }
+        }
+        else {
+            const { branchChoice } = await inquirer.prompt([
+                {
+                    type: 'autocomplete',
+                    name: 'branchChoice',
+                    message: 'Select branch (type to filter):',
+                    source: async (_answers, input = '') => {
+                        const term = input.trim().toLowerCase();
+                        const filtered = term
+                            ? candidates.filter(candidate => candidate.branchName.toLowerCase().includes(term))
+                            : candidates;
+                        return filtered.map(candidate => ({
+                            name: `${chalk.yellow(candidate.branchName)} ${chalk.dim(`(${candidate.source})`)}`,
+                            value: candidate,
+                        }));
+                    },
+                    pageSize: 10,
+                },
+            ]);
+            selectedBranch = branchChoice;
+        }
+        if (!selectedBranch) {
+            log.error('No branch selected.');
+            return;
+        }
+        const existingWorktrees = await listWorktrees();
+        const existingManagedWorktree = existingWorktrees.find(wt => wt.branch === selectedBranch.branchName && wt.path.startsWith(WORKTREES_ROOT));
+        if (existingManagedWorktree) {
+            log.info(`Branch ${chalk.cyan(selectedBranch.branchName)} is already active in ${ui.path(existingManagedWorktree.path)}.`);
+            if (options.enter === false) {
+                log.header(`cd "${existingManagedWorktree.path}"`);
+                return;
+            }
+            log.info('Opening existing worktree instead of creating a duplicate...');
+            await enterCommand(existingManagedWorktree.path, { exec: options.exec ?? '' });
+            return;
+        }
+        // 3. Gather remaining inputs
+        const defaultSlug = toSlug(selectedBranch.branchName);
         const answers = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'name',
                 message: 'Worktree name (slug):',
-                default: options.name,
+                default: options.name || defaultSlug,
                 when: !options.name,
                 validate: (input) => input.trim().length > 0 || 'Name is required',
             },
-            {
-                type: 'input',
-                name: 'ref',
-                message: 'Base branch name:',
-                default: options.ref || currentBranch,
-                when: !options.ref,
-                validate: (input) => input.trim().length > 0 || 'Ref is required',
-            },
-            {
-                type: 'list',
-                name: 'source',
-                message: 'Base on:',
-                loop: false,
-                choices: [
-                    { name: 'Remote (origin)', value: 'remote' },
-                    { name: 'Local', value: 'local' },
-                ],
-                default: 'remote',
-                when: !options.ref && !options.source,
-            },
             {
                 type: 'confirm',
                 name: 'bootstrap',
@@ -58,61 +148,62 @@ export async function createCommand(options) {
                 when: options.enter === undefined,
             },
             {
-                type: 'input',
-                name: 'exec',
-                message: 'Command to run after creation (optional):',
-                default: options.exec,
+                type: 'confirm',
+                name: 'shouldOpenTool',
+                message: 'Open a tool after creation? (IDE or agent CLI)',
+                default: false,
                 when: options.exec === undefined,
-            }
+            },
         ]);
         const name = options.name || answers.name;
-        let ref = options.ref || answers.ref;
-        const source = options.source || answers.source;
         const shouldEnter = options.enter !== undefined ? options.enter : answers.shouldEnter;
         const shouldBootstrap = options.bootstrap !== undefined ? options.bootstrap : answers.bootstrap;
-        const execCommandStr = options.exec || answers.exec;
-        // Append origin/ if remote is selected and not already present
-        if (!options.ref && source === 'remote' && !ref.startsWith('origin/')) {
-            ref = `origin/${ref}`;
+        let selectedTool;
+        if (options.exec === undefined && answers.shouldOpenTool) {
+            const installedTools = await detectInstalledOpenTools();
+            if (installedTools.length === 0) {
+                log.warning('No IDE/agent tool detected in PATH. Skipping open step.');
+            }
+            else {
+                selectedTool = await promptOpenToolSelection(installedTools, 'Select tool to open:');
+            }
         }
-        const slug = name.replace(/\s+/g, '-');
+        const execCommandStr = options.exec || (selectedTool && isAgentTool(selectedTool) ? buildAgentExecCommand(selectedTool) : undefined);
+        const slug = toSlug(name);
         const repoName = await getRepoName();
         const wtPath = path.join(WORKTREES_ROOT, repoName, slug);
-        // 2. Validation
+        // 4. Validation
         if (!slug)
             throw new Error('Invalid name');
-        if (!ref)
-            throw new Error('Invalid ref');
-        // 3. Execution
-        const spinner = createSpinner('Fetching...').start();
-        await fetchAll();
-        spinner.text = 'Verifying ref...';
-        const exists = await verifyRef(ref);
-        if (!exists) {
-            spinner.fail(`Ref not found: ${ref}`);
-            log.warning(`Tip: try 'origin/${ref}' or check if the branch exists.`);
-            return;
-        }
-        spinner.text = `Creating worktree at ${ui.path(wtPath)}...`;
+        // 5. Execution (checkout-style: attach to selected branch)
+        const spinner = createSpinner(`Creating worktree at ${ui.path(wtPath)}...`).start();
         try {
             await fs.ensureDir(path.dirname(wtPath));
-            await createWorktree(wtPath, ref);
+            if (selectedBranch.createLocalBranch) {
+                await execa('git', ['worktree', 'add', '-b', selectedBranch.branchName, wtPath, selectedBranch.checkoutRef]);
+            }
+            else {
+                await createWorktree(wtPath, selectedBranch.checkoutRef);
+            }
             spinner.succeed('Worktree created.');
         }
         catch (e) {
             spinner.fail('Failed to create worktree.');
-            log.actionableError(e.message, `git worktree add ${wtPath} ${ref}`, wtPath, [
+            const command = selectedBranch.createLocalBranch
+                ? `git worktree add -b ${selectedBranch.branchName} ${wtPath} ${selectedBranch.checkoutRef}`
+                : `git worktree add ${wtPath} ${selectedBranch.checkoutRef}`;
+            log.actionableError(e.message, command, wtPath, [
                 'Check if the folder already exists: ls ' + wtPath,
-                'Check if the branch is already used: git worktree list',
+                `Check if branch "${selectedBranch.branchName}" is already checked out in another worktree: git worktree list`,
                 'Try pruning stale worktrees: yggtree wt prune',
-                `Run manually: git worktree add ${wtPath} ${ref}`
+                `Run manually: ${command}`
             ]);
             return;
         }
         if (shouldBootstrap) {
             await runBootstrap(wtPath, repoRoot);
         }
-        // 5. Exec Command
+        // 6. Exec Command
         if (execCommandStr && execCommandStr.trim()) {
             log.info(`Executing: ${execCommandStr} in ${ui.path(wtPath)}`);
             try {
@@ -129,7 +220,16 @@ export async function createCommand(options) {
                 ]);
             }
         }
-        // 6. Final Output
+        if (selectedTool && !isAgentTool(selectedTool)) {
+            try {
+                log.info(`Opening ${ui.path(wtPath)} in ${chalk.cyan(selectedTool.name)}...`);
+                await launchOpenTool(selectedTool, wtPath);
+            }
+            catch (error) {
+                log.warning(`Could not open ${selectedTool.name}: ${error.message}`);
+            }
+        }
+        // 7. Final Output
         log.success('Worktree ready!');
         if (shouldEnter) {
             log.info(`Spawning sub-shell in ${ui.path(wtPath)}...`);
@@ -148,7 +248,7 @@ export async function createCommand(options) {
         }
     }
     catch (error) {
-        log.actionableError(error.message, 'yggtree wt create');
+        log.actionableError(error.message, 'yggtree wt worktree-checkout');
         process.exit(1);
     }
 }

package/dist/commands/wt/delete.js

@@ -1,32 +1,60 @@
 import chalk from 'chalk';
 import inquirer from 'inquirer';
-import path from 'path';
-import { listWorktrees, removeWorktree, getRepoRoot } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
-import { log, createSpinner } from '../../lib/ui.js';
-export async function deleteCommand() {
+import { listWorktrees, removeWorktree, getRepoRoot, getLastActivity } from '../../lib/git.js';
+import { log, createSpinner, timeAgo } from '../../lib/ui.js';
+import { detectWorktreeType, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, isManagedWorktreePath, } from '../../lib/worktree.js';
+export async function deleteCommand(options = {}) {
     try {
-        const _ = await getRepoRoot();
+        const currentWorktreePath = await getRepoRoot();
         const worktrees = await listWorktrees();
-        // Filter only managed worktrees
-        const managedWts = worktrees.filter(wt => wt.path.startsWith(WORKTREES_ROOT));
-        if (managedWts.length === 0) {
-            log.info('No managed worktrees found to delete.');
+        let showAll = options.all;
+        if (showAll === undefined) {
+            const { includeExternal } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'includeExternal',
+                    message: 'Include external linked worktrees (outside ~/.yggtree)?',
+                    default: false,
+                },
+            ]);
+            showAll = includeExternal;
+        }
+        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);
+        });
+        if (deletableWts.length === 0) {
+            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 = managedWts.map(wt => {
-            const relative = path.relative(WORKTREES_ROOT, wt.path);
+        const choices = await Promise.all(deletableWts.map(async (wt) => {
+            const [activity, type] = await Promise.all([
+                getLastActivity(wt.path),
+                detectWorktreeType(wt, mainWorktreePath || ''),
+            ]);
+            const branchName = getWorktreeBranchName(wt);
+            const active = activity ? chalk.magenta(timeAgo(activity)) : chalk.dim('—');
+            const displayPath = formatWorktreeDisplayPath(wt.path);
             return {
-                name: `${chalk.bold(relative)} (${chalk.dim(wt.branch || wt.HEAD)})`,
+                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: 'Select worktrees to delete:',
+                message: includeAll ? 'Select worktrees to delete:' : 'Select managed worktrees to delete:',
                 choices: choices,
+                pageSize: 10,
             },
         ]);
         if (!selectedPaths || selectedPaths.length === 0) {
@@ -34,7 +62,7 @@ export async function deleteCommand() {
             return;
         }
         const count = selectedPaths.length;
-        const names = selectedPaths.map((p) => path.relative(WORKTREES_ROOT, p));
+        const names = selectedPaths.map((p) => formatWorktreeDisplayPath(p));
         const { confirm } = await inquirer.prompt([
             {
                 type: 'confirm',
@@ -48,7 +76,7 @@ export async function deleteCommand() {
             return;
         }
         for (const wtPath of selectedPaths) {
-            const worktreeName = path.relative(WORKTREES_ROOT, wtPath);
+            const worktreeName = formatWorktreeDisplayPath(wtPath);
             const spinner = createSpinner(`Deleting ${worktreeName}...`).start();
             try {
                 await removeWorktree(wtPath);

package/dist/commands/wt/enter.js

@@ -1,30 +1,51 @@
 import inquirer from 'inquirer';
 import { spawn } from 'child_process';
 import { execa } from 'execa';
-import path from 'path';
+import chalk from 'chalk';
 import { listWorktrees, getRepoRoot } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
 import { log, ui } from '../../lib/ui.js';
+import { detectWorktreeType, findWorktreeByName, formatWorktreeDisplayPath, formatWorktreeType, getWorktreeBranchName, } from '../../lib/worktree.js';
+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 formatChoiceLabel(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 enterCommand(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) {
-            // 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;
@@ -32,38 +53,29 @@ export async function enterCommand(wtName, options = {}) {
         }
         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 terminalColumns = process.stdout.columns || 100;
+            const choices = await Promise.all(worktrees.map(async (wt) => {
+                const type = await detectWorktreeType(wt, mainWorktreePath);
+                const branchName = getWorktreeBranchName(wt);
+                const displayPath = formatWorktreeDisplayPath(wt.path);
                 return {
-                    name: `${branchName.padEnd(20)} ${displayPath}`,
+                    name: formatChoiceLabel(type, branchName, displayPath, terminalColumns),
                     value: wt
                 };
-            });
+            }));
             const { selectedWt } = await inquirer.prompt([
                 {
                     type: 'list',
                     name: 'selectedWt',
                     message: 'Select a worktree to enter:',
                     choices,
-                    loop: false
+                    loop: false,
+                    pageSize: 10,
                 }
             ]);
             targetWt = selectedWt;
         }
-        const { execCommandStr } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'execCommandStr',
-                message: 'Command to run before entering (optional):',
-                default: options.exec,
-                when: options.exec === undefined,
-            }
-        ]);
-        const finalExec = options.exec || execCommandStr;
+        const finalExec = options.exec;
         if (finalExec && finalExec.trim()) {
             log.info(`Executing: ${finalExec} in ${ui.path(targetWt?.path || '')}`);
             try {

package/dist/commands/wt/exec.js

@@ -1,9 +1,8 @@
 import inquirer from 'inquirer';
 import { execa } from 'execa';
-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 execCommand(wtName, commandArgs) {
     let targetWt;
     let command = '';
@@ -16,16 +15,7 @@ export async function execCommand(wtName, commandArgs) {
             return;
         }
         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;
@@ -34,11 +24,8 @@ export async function execCommand(wtName, commandArgs) {
         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/commands/wt/list.js

@@ -1,34 +1,44 @@
 import chalk from 'chalk';
-import path from 'path';
-import { listWorktrees, getRepoRoot, isGitClean } from '../../lib/git.js';
-import { WORKTREES_ROOT } from '../../lib/paths.js';
-import { log } from '../../lib/ui.js';
+import { listWorktrees, getRepoRoot, isGitClean, getLastActivity } from '../../lib/git.js';
+import { log, timeAgo } from '../../lib/ui.js';
+import { detectWorktreeType, formatWorktreeType, getWorktreeBranchName, WORKTREE_TYPE_ORDER, } from '../../lib/worktree.js';
 export async function listCommand() {
     try {
-        const _ = await getRepoRoot(); // Verify we are in a git repo
+        await getRepoRoot(); // Verify we are in a git repo
         const worktrees = await listWorktrees();
+        const mainWorktreePath = worktrees[0]?.path || '';
         if (worktrees.length === 0) {
             log.info('No worktrees found.');
             return;
         }
         console.log(chalk.bold('\n  Active Worktrees:\n'));
         // Header
-        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('BRANCH')}             ${chalk.dim('PATH')}`);
-        console.log(chalk.dim('  ' + '-'.repeat(75)));
-        for (const wt of worktrees) {
-            const isManaged = wt.path.startsWith(WORKTREES_ROOT);
-            const type = isManaged ? chalk.green('MANAGED') : chalk.blue('MAIN   ');
-            const branchName = wt.branch || wt.HEAD || 'detached';
-            let displayPath = wt.path.replace(process.env.HOME || '', '~');
-            if (isManaged) {
-                displayPath = path.relative(WORKTREES_ROOT, wt.path);
-            }
-            const colorPath = isManaged ? chalk.cyan(displayPath) : chalk.dim(displayPath);
-            const isClean = await isGitClean(wt.path);
+        console.log(`  ${chalk.dim('TYPE')}    ${chalk.dim('STATE')}    ${chalk.dim('LAST ACTIVE')}    ${chalk.dim('BRANCH')}`);
+        console.log(chalk.dim('  ' + '-'.repeat(70)));
+        const rows = await Promise.all(worktrees.map(async (wt, index) => {
+            const [typeKey, isClean, lastActive] = await Promise.all([
+                detectWorktreeType(wt, mainWorktreePath),
+                isGitClean(wt.path),
+                getLastActivity(wt.path),
+            ]);
+            const type = formatWorktreeType(typeKey);
+            const branchName = getWorktreeBranchName(wt);
             const stateLabel = (isClean ? 'clean' : 'dirty').padEnd(8);
             const stateText = isClean ? chalk.green(stateLabel) : chalk.yellow(stateLabel);
-            console.log(`  ${type}  ${stateText} ${chalk.yellow(branchName.padEnd(18))} ${colorPath}`);
-        }
+            const activeLabel = lastActive ? timeAgo(lastActive) : '—';
+            const activeText = chalk.magenta(activeLabel.padEnd(14));
+            return {
+                text: `  ${type}  ${stateText} ${activeText} ${chalk.yellow(branchName)}`,
+                sortType: WORKTREE_TYPE_ORDER[typeKey],
+                sortBranch: branchName.toLowerCase(),
+                sortIndex: index,
+            };
+        }));
+        rows
+            .sort((a, b) => a.sortType - b.sortType ||
+            a.sortBranch.localeCompare(b.sortBranch) ||
+            a.sortIndex - b.sortIndex)
+            .forEach(row => console.log(row.text));
         console.log('');
     }
     catch (error) {