@hyperdrive.bot/gut 0.1.12 → 0.1.14-alpha.0

package/README.md

@@ -18,7 +18,7 @@ $ npm install -g @hyperdrive.bot/gut
 $ gut COMMAND
 running command...
 $ gut (--version)
-@hyperdrive.bot/gut/0.1.12 linux-x64 node-v22.22.1
+@hyperdrive.bot/gut/0.1.14-alpha.0 linux-x64 node-v22.22.2
 $ gut --help [COMMAND]
 USAGE
   $ gut COMMAND
@@ -290,13 +290,21 @@ Show current focus context with entity details
 
 ```
 USAGE
-  $ gut context
+  $ gut context [--all] [--json]
+
+FLAGS
+  --all   Include all registered entities, not just focused ones (implies --json or adds to text output)
+  --json  Emit structured JSON for programmatic consumption (includes per-entity branch + hasUncommitted)
 
 DESCRIPTION
   Show current focus context with entity details
 
 EXAMPLES
   $ gut context
+
+  $ gut context --json
+
+  $ gut context --json --all
 ```
 
 ## `gut contexts`
@@ -1180,15 +1188,18 @@ Create mirrored worktrees for super-repo and focused entities
 
 ```
 USAGE
-  $ gut worktree create NAME [--base-dir <value>] [--from <value>] [--install]
+  $ gut worktree create NAME [--base-dir <value>] [--entity <value>...] [--from <value>] [--install]
 
 ARGUMENTS
   NAME  Branch name for the worktree
 
 FLAGS
-  --base-dir=<value>  [default: /tmp/gut-worktrees] Root directory for worktrees
-  --from=<value>      Base branch to create from (defaults to current branch)
-  --install           Run pnpm install after creation
+  --base-dir=<value>   [default: /root/.local/share/gut/worktrees] Root directory for worktrees (default:
+                       ~/.local/share/gut/worktrees, override via GUT_WORKTREE_DIR env var; explicit --base-dir wins)
+  --entity=<value>...  Entity to include, optionally pinned to a branch via "name:branch". Repeatable. Overrides current
+                       focus when provided.
+  --from=<value>       Base branch to create from (defaults to current branch)
+  --install            Run pnpm install after creation
 
 DESCRIPTION
   Create mirrored worktrees for super-repo and focused entities
@@ -1199,5 +1210,9 @@ EXAMPLES
   $ gut worktree create workflow/deploy-batch --from master --install
 
   $ gut worktree create feature/story-42 --base-dir /home/user/worktrees
+
+  $ gut worktree create seo-lake --entity serverless-api:feature/seo-lake --entity sign
+
+  GUT_WORKTREE_DIR=/tmp/gut-worktrees gut worktree create feature/ci-run
 ```
 <!-- commandsstop -->

package/dist/commands/context.d.ts

@@ -2,5 +2,9 @@ import { BaseCommand } from '../base-command.js';
 export default class Context extends BaseCommand {
     static description: string;
     static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/context.js

@@ -1,3 +1,4 @@
+import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 import path from 'node:path';
 import { BaseCommand } from '../base-command.js';
@@ -5,22 +6,106 @@ export default class Context extends BaseCommand {
     static description = 'Show current focus context with entity details';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
+        '<%= config.bin %> <%= command.id %> --json --all',
     ];
+    static flags = {
+        all: Flags.boolean({
+            default: false,
+            description: 'Include all registered entities, not just focused ones (implies --json or adds to text output)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Emit structured JSON for programmatic consumption (includes per-entity branch + hasUncommitted)',
+        }),
+    };
     async run() {
-        await this.parse(Context);
+        const { flags } = await this.parse(Context);
+        const workspaceRoot = this.configService.getWorkspaceRoot();
         const focusedEntities = await this.focusService.getFocusedEntities();
-        if (focusedEntities.length === 0) {
+        const focus = await this.focusService.getCurrentFocus();
+        const focusedNames = new Set(focusedEntities.map(e => e.name));
+        // For JSON or --all, resolve the full entity set. For normal text output,
+        // keep the existing behavior (focused only).
+        const includeAll = flags.json || flags.all;
+        const entitiesToReport = includeAll
+            ? this.entityService.getAllEntities()
+            : focusedEntities;
+        // Enrich each entity with branch + uncommitted status. Entities may not
+        // exist on disk (not cloned), so be defensive.
+        const enriched = [];
+        for (const entity of entitiesToReport) {
+            const relativePath = entity.path.replace(/^\.\//, '');
+            const absolutePath = path.isAbsolute(entity.path)
+                ? entity.path
+                : path.join(workspaceRoot, relativePath);
+            let currentBranch = null;
+            let hasUncommitted = false;
+            let pathExists = false;
+            try {
+                const { existsSync } = await import('node:fs');
+                pathExists = existsSync(path.join(absolutePath, '.git')) || existsSync(absolutePath);
+            }
+            catch {
+                pathExists = false;
+            }
+            if (pathExists) {
+                try {
+                    currentBranch = await this.gitService.getCurrentBranch(absolutePath);
+                }
+                catch {
+                    currentBranch = null;
+                }
+                try {
+                    hasUncommitted = await this.gitService.hasChanges(absolutePath);
+                }
+                catch {
+                    hasUncommitted = false;
+                }
+            }
+            enriched.push({
+                currentBranch,
+                focused: focusedNames.has(entity.name),
+                hasUncommitted,
+                name: entity.name,
+                path: relativePath,
+                pathExists,
+                type: entity.type,
+            });
+        }
+        if (flags.json) {
+            const payload = {
+                entities: enriched,
+                focus: {
+                    entities: [...focusedNames],
+                    mode: focus?.mode ?? null,
+                },
+                workspaceRoot,
+            };
+            // Emit compact, machine-readable JSON on stdout. No chalk, no decoration.
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        if (focusedEntities.length === 0 && !flags.all) {
             this.log(chalk.yellow('No entities are currently focused'));
             this.log(chalk.dim('Use "gut focus <entity>" to set focus'));
             return;
         }
-        const workspaceRoot = this.configService.getWorkspaceRoot();
         this.log(chalk.bold('\n📍 Current Focus Context'));
         this.log(chalk.dim('─'.repeat(50)));
-        for (const entity of focusedEntities) {
-            this.log(`\n${chalk.green('▸')} ${chalk.bold(entity.name)}`);
+        for (const entity of enriched) {
+            if (!flags.all && !entity.focused)
+                continue;
+            const marker = entity.focused ? chalk.green('▸') : chalk.dim('·');
+            this.log(`\n${marker} ${chalk.bold(entity.name)}`);
             this.log(`  ${chalk.dim('Type:')} ${entity.type}`);
-            this.log(`  ${chalk.dim('Path:')} ${path.relative(workspaceRoot, entity.path)}`);
+            this.log(`  ${chalk.dim('Path:')} ${entity.path}`);
+            if (entity.pathExists) {
+                this.log(`  ${chalk.dim('Branch:')} ${entity.currentBranch ?? chalk.red('(unknown)')}${entity.hasUncommitted ? chalk.yellow(' *dirty') : ''}`);
+            }
+            else {
+                this.log(`  ${chalk.dim('Branch:')} ${chalk.dim('(not checked out)')}`);
+            }
         }
         this.log(chalk.dim('\n─'.repeat(50)));
         this.log(`${chalk.dim('Total focused entities:')} ${focusedEntities.length}`);

package/dist/commands/focus.js

@@ -125,6 +125,9 @@ export default class Focus extends BaseCommand {
                     this.log(`  ${this.getTypeEmoji(entity.type)} ${entity.name} (${entity.type})`);
                 }
             }
+            // Machine-readable confirmation line for programmatic callers (e.g.,
+            // bmad-workflow execSync). Always printed, grep-friendly format.
+            this.log(`FOCUSED: ${entities.map(e => e.name).join(',')}`);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);

package/dist/commands/worktree/create.d.ts

@@ -7,6 +7,7 @@ export default class WorktreeCreate extends BaseCommand {
     static examples: string[];
     static flags: {
         'base-dir': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        entity: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         from: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         install: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/worktree/create.js

@@ -2,8 +2,11 @@ import { Args, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { BaseCommand } from '../../base-command.js';
+import { parseEntitySpecs } from '../../utils/entity-spec.js';
+const xdgDefaultBaseDir = path.join(os.homedir(), '.local', 'share', 'gut', 'worktrees');
 export default class WorktreeCreate extends BaseCommand {
     static args = {
         name: Args.string({ description: 'Branch name for the worktree', required: true }),
@@ -13,17 +16,37 @@ export default class WorktreeCreate extends BaseCommand {
         '<%= config.bin %> worktree create workflow/deploy-batch',
         '<%= config.bin %> worktree create workflow/deploy-batch --from master --install',
         '<%= config.bin %> worktree create feature/story-42 --base-dir /home/user/worktrees',
+        '<%= config.bin %> worktree create seo-lake --entity serverless-api:feature/seo-lake --entity sign',
+        'GUT_WORKTREE_DIR=/tmp/gut-worktrees <%= config.bin %> worktree create feature/ci-run',
     ];
     static flags = {
-        'base-dir': Flags.string({ default: '/tmp/gut-worktrees', description: 'Root directory for worktrees' }),
+        'base-dir': Flags.string({
+            default: async () => process.env.GUT_WORKTREE_DIR ?? xdgDefaultBaseDir,
+            description: 'Root directory for worktrees (default: ~/.local/share/gut/worktrees, override via GUT_WORKTREE_DIR env var; explicit --base-dir wins)',
+        }),
+        entity: Flags.string({
+            description: 'Entity to include, optionally pinned to a branch via "name:branch". Repeatable. Overrides current focus when provided.',
+            multiple: true,
+        }),
         from: Flags.string({ description: 'Base branch to create from (defaults to current branch)' }),
         install: Flags.boolean({ default: false, description: 'Run pnpm install after creation' }),
     };
     async run() {
         const { args, flags } = await this.parse(WorktreeCreate);
+        const stale = this.worktreeService.findStale();
+        if (stale.length > 0) {
+            this.log(chalk.yellow('⚠️  Stale worktree records detected (path does not exist on disk):'));
+            for (const record of stale) {
+                this.log(chalk.yellow(`  - ${record.name}  ${record.path}`));
+            }
+            this.log(chalk.yellow('Run `gut worktree prune` to remove them.'));
+        }
         const workspaceRoot = this.configService.getWorkspaceRoot();
         const slug = args.name.replace(/\//g, '-');
         const wtPath = path.join(flags['base-dir'], slug);
+        // Ensure the base directory exists — git worktree add creates the target
+        // dir, but the parent (the base dir itself) must already exist.
+        fs.mkdirSync(flags['base-dir'], { recursive: true });
         const baseBranch = flags.from ?? await this.gitService.getCurrentBranch(workspaceRoot);
         // --- Validation (AC: 7) ---
         const existing = this.worktreeService.get(args.name);
@@ -35,10 +58,35 @@ export default class WorktreeCreate extends BaseCommand {
         if (branchCollision) {
             this.error(`Branch "${args.name}" already has a worktree at ${branchCollision.path}. Remove it first or use a different name.`);
         }
-        // --- Validation (AC: 8) ---
-        const focusedEntities = await this.focusService.getFocusedEntities();
-        if (focusedEntities.length === 0) {
-            this.error('No entities focused. Use "gut focus <entity>" first.');
+        // --- Resolve entity set: --entity flag overrides focus ---
+        let entitySpecs;
+        try {
+            entitySpecs = parseEntitySpecs(flags.entity);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.error(message);
+        }
+        let selectedEntities;
+        const branchOverrides = new Map();
+        if (entitySpecs.length > 0) {
+            selectedEntities = [];
+            for (const spec of entitySpecs) {
+                const entity = this.entityService.findEntity(spec.name);
+                if (!entity) {
+                    this.error(`Entity "${spec.name}" not found in workspace config. Run \`gut entity list\` to see available entities.`);
+                }
+                selectedEntities.push(entity);
+                if (spec.branch) {
+                    branchOverrides.set(entity.name, spec.branch);
+                }
+            }
+        }
+        else {
+            selectedEntities = await this.focusService.getFocusedEntities();
+            if (selectedEntities.length === 0) {
+                this.error('No entities focused and no --entity flag provided. Use "gut focus <entity>" first, or pass --entity <name> (repeatable).');
+            }
         }
         // --- Create worktrees with atomic rollback (AC: 1, 2, 9) ---
         const createdWorktrees = [];
@@ -49,14 +97,18 @@ export default class WorktreeCreate extends BaseCommand {
             createdWorktrees.push({ repoPath: workspaceRoot, wtPath });
             this.log(chalk.green('✓ Super-repo worktree created at ' + wtPath));
             // Per-entity worktrees (AC: 2)
-            for (const entity of focusedEntities) {
+            for (const entity of selectedEntities) {
                 const entityRelativePath = entity.path.replace(/^\.\//, '');
                 const entityWtPath = path.join(wtPath, entityRelativePath);
                 const entityMainPath = path.join(workspaceRoot, entityRelativePath);
-                // Always use the entity's current branch as base — the super-repo branch
-                // may exist but be stale (e.g., api has master but works on develop)
-                const entityBaseBranch = await this.gitService.getCurrentBranch(entityMainPath);
-                if (entityBaseBranch !== baseBranch) {
+                // Branch override from --entity name:branch wins; otherwise use entity's
+                // current branch in the main repo.
+                const override = branchOverrides.get(entity.name);
+                const entityBaseBranch = override ?? await this.gitService.getCurrentBranch(entityMainPath);
+                if (override) {
+                    this.log(chalk.cyan(`  Branch override: ${entity.name} → ${override}`));
+                }
+                else if (entityBaseBranch !== baseBranch) {
                     this.log(chalk.yellow(`⚠ Entity "${entity.name}" is on "${entityBaseBranch}" (super-repo: "${baseBranch}")`));
                 }
                 // Remove submodule stub
@@ -64,7 +116,7 @@ export default class WorktreeCreate extends BaseCommand {
                 // Create entity worktree
                 await this.gitService.worktreeAdd(entityMainPath, entityWtPath, args.name, entityBaseBranch);
                 createdWorktrees.push({ repoPath: entityMainPath, wtPath: entityWtPath });
-                this.log(chalk.green(`✓ Entity worktree: ${entity.name} → ${args.name}`));
+                this.log(chalk.green(`✓ Entity worktree: ${entity.name} → ${args.name} (from ${entityBaseBranch})`));
                 entityRecords.push({
                     branch: args.name,
                     entityName: entity.name,
@@ -79,7 +131,7 @@ export default class WorktreeCreate extends BaseCommand {
                 await this.gitService.worktreeRemove(entry.repoPath, entry.wtPath, true).catch(() => { });
             }
             await this.gitService.worktreePrune(workspaceRoot).catch(() => { });
-            for (const entity of focusedEntities) {
+            for (const entity of selectedEntities) {
                 const entityRelativePath = entity.path.replace(/^\.\//, '');
                 const entityMainPath = path.join(workspaceRoot, entityRelativePath);
                 await this.gitService.worktreePrune(entityMainPath).catch(() => { });

package/dist/commands/worktree/gc.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command.js';
+export default class WorktreeGc extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'older-than': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private countDirtyChanges;
+    private hasDirtyEntity;
+}

package/dist/commands/worktree/gc.js

@@ -0,0 +1,126 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import { BaseCommand } from '../../base-command.js';
+import { parseDuration } from '../../utils/duration.js';
+const DAY_MS = 86_400_000;
+export default class WorktreeGc extends BaseCommand {
+    static description = 'Remove worktrees older than a given duration (garbage collection)';
+    static examples = [
+        '<%= config.bin %> worktree gc --older-than 7d',
+        '<%= config.bin %> worktree gc --older-than 14d --force',
+        '<%= config.bin %> worktree gc --older-than 7d --dry-run',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            char: 'n',
+            default: false,
+            description: 'List candidates without removing anything',
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            default: false,
+            description: 'Remove even worktrees with uncommitted changes',
+        }),
+        'older-than': Flags.string({
+            char: 'o',
+            description: "Duration threshold (e.g. '7d', '24h', '30m', '90s')",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorktreeGc);
+        const olderThanInput = flags['older-than'];
+        let thresholdMs;
+        try {
+            thresholdMs = parseDuration(olderThanInput);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        const state = this.worktreeService.loadState();
+        const now = Date.now();
+        const candidates = state.worktrees.filter(w => now - w.createdAt > thresholdMs);
+        if (candidates.length === 0) {
+            this.log(chalk.dim(`No worktrees older than ${olderThanInput}`));
+            return;
+        }
+        // Collect per-candidate dirty state up front (used by both dry-run and real run)
+        const dirtyFlags = await Promise.all(candidates.map(async (record) => this.hasDirtyEntity(record)));
+        if (flags['dry-run']) {
+            this.log(chalk.bold(`\nWorktrees older than ${olderThanInput}:`));
+            for (const [i, record] of candidates.entries()) {
+                const ageDays = Math.floor((now - record.createdAt) / DAY_MS);
+                const dirtyLabel = dirtyFlags[i] ? chalk.yellow(' [dirty]') : '';
+                this.log(`  ${record.name}  ${ageDays}d old${dirtyLabel}`);
+            }
+            this.log(chalk.dim(`\n${candidates.length} candidate(s)`));
+            return;
+        }
+        this.log(chalk.bold(`\n🧹 Garbage collecting worktrees older than ${olderThanInput}...`));
+        let removed = 0;
+        let skippedDirty = 0;
+        let skippedMissing = 0;
+        for (const [i, record] of candidates.entries()) {
+            if (dirtyFlags[i] && !flags.force) {
+                // eslint-disable-next-line no-await-in-loop
+                const changeCount = await this.countDirtyChanges(record);
+                this.log(chalk.yellow(`  ⚠ ${record.name}: skipped (${changeCount} uncommitted changes)`));
+                skippedDirty++;
+                continue;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            const result = await this.worktreeService.removeWorktreeRecord(record.name, {
+                force: flags.force,
+                logger: (msg) => {
+                    if (msg.includes('⚠'))
+                        this.log(chalk.yellow(msg));
+                    else if (msg.includes('○'))
+                        this.log(chalk.dim(msg));
+                    else if (msg.includes('✓'))
+                        this.log(chalk.green(msg));
+                    else
+                        this.log(msg);
+                },
+            });
+            if (result.skippedDueToDirty) {
+                skippedDirty++;
+                continue;
+            }
+            removed++;
+            if (result.removedEntities === 0 && result.skippedEntities > 0) {
+                skippedMissing++;
+            }
+        }
+        this.log(chalk.dim('─'.repeat(50)));
+        this.log(chalk.green(`✓ Garbage collected ${removed} worktree(s)`));
+        this.log(chalk.dim(`  Removed:          ${removed}`));
+        this.log(chalk.dim(`  Skipped (dirty):  ${skippedDirty}`));
+        this.log(chalk.dim(`  Skipped (missing):${skippedMissing}`));
+        this.log(chalk.dim(`  Candidates:       ${candidates.length}`));
+    }
+    async countDirtyChanges(record) {
+        let total = 0;
+        for (const entity of record.entities) {
+            if (!fs.existsSync(entity.worktreePath))
+                continue;
+            // eslint-disable-next-line no-await-in-loop
+            const status = await this.gitService.getStatus(entity.worktreePath);
+            if (status.hasChanges) {
+                total += status.changes.length + status.untracked.length;
+            }
+        }
+        return total;
+    }
+    async hasDirtyEntity(record) {
+        for (const entity of record.entities) {
+            if (!fs.existsSync(entity.worktreePath))
+                continue;
+            // eslint-disable-next-line no-await-in-loop
+            const status = await this.gitService.getStatus(entity.worktreePath);
+            if (status.hasChanges)
+                return true;
+        }
+        return false;
+    }
+}

package/dist/commands/worktree/list.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command.js';
+export declare const MS_PER_DAY: number;
+export declare const STALE_DAYS = 7;
+export declare function formatWorktreeAge(createdAt: number, now: number): {
+    isStale: boolean;
+    text: string;
+};
+export default class WorktreeList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/worktree/list.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import chalk from 'chalk';
+import { BaseCommand } from '../../base-command.js';
+export const MS_PER_DAY = 1000 * 60 * 60 * 24;
+export const STALE_DAYS = 7;
+export function formatWorktreeAge(createdAt, now) {
+    if (typeof createdAt !== 'number' || Number.isNaN(createdAt)) {
+        return { isStale: false, text: 'unknown age' };
+    }
+    const ageMs = now - createdAt;
+    if (ageMs <= 0) {
+        return { isStale: false, text: 'less than a day old' };
+    }
+    const ageDays = Math.floor(ageMs / MS_PER_DAY);
+    const isStale = ageMs / MS_PER_DAY > STALE_DAYS;
+    let text;
+    if (ageDays === 0) {
+        text = 'less than a day old';
+    }
+    else if (ageDays === 1) {
+        text = '1 day old';
+    }
+    else {
+        text = `${ageDays} days old`;
+    }
+    return { isStale, text };
+}
+export default class WorktreeList extends BaseCommand {
+    static description = 'List all active worktrees with metadata and staleness detection';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const stale = this.worktreeService.findStale();
+        if (stale.length > 0) {
+            this.log(chalk.yellow('⚠️  Stale worktree records detected (path does not exist on disk):'));
+            for (const record of stale) {
+                this.log(chalk.yellow(`  - ${record.name}  ${record.path}`));
+            }
+            this.log(chalk.yellow('Run `gut worktree prune` to remove them.'));
+        }
+        const worktrees = this.worktreeService.list();
+        if (worktrees.length === 0) {
+            this.log(`No active worktrees. Create one with: ${chalk.cyan('gut worktree create <branch-name>')}`);
+            return;
+        }
+        this.log(chalk.bold('\nActive worktrees:\n'));
+        for (const record of worktrees) {
+            const isStale = !fs.existsSync(record.path);
+            const formattedDate = new Date(record.createdAt).toISOString().replace('T', ' ').slice(0, 16);
+            const entityNames = record.entities.map(e => e.entityName).join(', ');
+            const age = formatWorktreeAge(record.createdAt, Date.now());
+            const ageLine = age.isStale
+                ? chalk.yellow(`    Age:      ⚠ (${age.text}) — consider removing`)
+                : `    Age:      (${age.text})`;
+            this.log(`  ${chalk.bold(record.name)}`);
+            this.log(`    Path:     ${record.path}${isStale ? chalk.yellow(' [stale]') : ''}`);
+            this.log(`    Branch:   ${chalk.cyan(record.name)}`);
+            this.log(`    Created:  ${chalk.dim(formattedDate)}`);
+            this.log(ageLine);
+            this.log(`    Entities: ${entityNames}`);
+            this.log('');
+        }
+    }
+}

package/dist/commands/worktree/list.test.d.ts

@@ -0,0 +1 @@
+export {};