worktree-flow 0.0.16 → 0.0.18

package/README.md

@@ -26,7 +26,7 @@ npm install -g worktree-flow
 flow quickstart
 
 # Create a workspace with new branches
-flow branch TICKET-123
+flow create TICKET-123
 # → Select repos interactively, creates branches + worktrees
 
 # Or checkout an existing branch
@@ -48,7 +48,7 @@ Working on features that span multiple repositories means manually creating bran
 
 ## Commands
 
-### `flow branch <name>`
+### `flow create <name>`
 
 Create a new branch across selected repos. Interactively select which repos to include, then creates branches and worktrees in a new workspace directory.
 
@@ -56,6 +56,10 @@ Create a new branch across selected repos. Interactively select which repos to i
 
 Checkout an existing branch. Fetches all repos, detects which have the branch, and creates worktrees.
 
+### `flow attach [name]`
+
+Attach repos to an existing workspace. Discovers available repos not yet in the workspace, presents an interactive picker, creates worktrees with new branches, copies config files, and runs post-checkout commands. Auto-detects the workspace from the current directory, or specify a branch name explicitly.
+
 ### `flow pull`
 
 Pull latest changes for all repos in the current workspace. Run from anywhere inside a workspace.
@@ -77,15 +81,19 @@ List all workspaces with status indicators. Shows:
 
 Fetches all repos before checking status to ensure accurate information. The status check uses git's patch-id comparison, which correctly handles squash-merged branches.
 
-### `flow remove <name>`
+### `flow drop <name>`
 
-Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted changes, and prompts for confirmation before removing. Committed changes are safe to remove since they're preserved in git history.
+Drop a workspace and all its worktrees. Fetches latest, checks for uncommitted changes, and prompts for confirmation before removing. Committed changes are safe to drop since they're preserved in git history.
 
-### `flow prune` (alias: `clean`)
+### `flow prune`
 
 Remove workspaces interactively. Shows all workspaces with their status (similar to `flow list`) and lets you select which ones to prune. Only workspaces with no uncommitted changes can be successfully removed.
 
-### `flow tmux resume`
+### `flow fetch [name]`
+
+Fetch repos for a specific workspace (when branch name provided), or fetch all repos used across all workspaces (when no branch given). Always bypasses the fetch cache.
+
+### `flow tmux sync`
 
 Create tmux sessions for all workspaces that don't already have one. Each session is created with split panes (one for the workspace root and one for each worktree that matches a repo from source-path) using a tiled layout. Skips workspaces that already have active sessions.
 
@@ -126,6 +134,22 @@ Repos with per-repo commands use those; others fall back to the global `post-che
 
 When tmux is enabled, post-checkout commands run in the corresponding tmux panes instead of executing directly. This lets you see the output in real-time within your tmux session.
 
+### Repo-level configuration
+
+Individual repos can define a `flow-config.json` at their root to override global settings:
+
+```json
+{
+  "copy-files": ".env,.env.local",
+  "post-checkout": "yarn install"
+}
+```
+
+Both fields are optional. Precedence (highest to lowest):
+
+- **post-checkout**: repo's `flow-config.json` > global `post-checkout`
+- **copy-files**: repo's `flow-config.json` > global `copy-files`
+
 ## AGENTS.md
 
 If an `AGENTS.md` file exists at the root of your source-path, it will be copied into each workspace. This is useful for providing AI coding agents with context about your multi-repo setup.

package/dist/cli.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { registerConfigCommand } from './commands/config.js';
+import { registerCreateCommand } from './commands/create.js';
+import { registerAttachCommand } from './commands/attach.js';
 import { registerBranchCommand } from './commands/branch.js';
 import { registerCheckoutCommand } from './commands/checkout.js';
 import { registerListCommand } from './commands/list.js';
 import { registerPullCommand } from './commands/pull.js';
 import { registerPushCommand } from './commands/push.js';
-import { registerRemoveCommand } from './commands/remove.js';
+import { registerDropCommand } from './commands/drop.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerPruneCommand } from './commands/prune.js';
 import { registerFetchCommand } from './commands/fetch.js';
@@ -18,12 +20,14 @@ program
     .description('Manage git worktrees across a poly-repo environment')
     .version('0.1.0');
 registerConfigCommand(program);
+registerCreateCommand(program);
+registerAttachCommand(program);
 registerBranchCommand(program);
 registerCheckoutCommand(program);
 registerListCommand(program);
 registerPullCommand(program);
 registerPushCommand(program);
-registerRemoveCommand(program);
+registerDropCommand(program);
 registerStatusCommand(program);
 registerPruneCommand(program);
 registerFetchCommand(program);

package/dist/commands/attach.js

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import checkbox, { Separator } from '@inquirer/checkbox';
+import input from '@inquirer/input';
+import confirm from '@inquirer/confirm';
+import chalk from 'chalk';
+import { createServices } from '../lib/services.js';
+import { createUseCases } from '../usecases/usecases.js';
+import { NoReposFoundError } from '../lib/errors.js';
+import { resolveWorkspace } from '../lib/workspaceResolver.js';
+import { buildRepoCheckboxChoices } from './helpers.js';
+export async function runAttach(branchName, useCases, services, deps) {
+    // 1. Resolve workspace (from arg or cwd)
+    const { workspacePath, displayName } = resolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
+    const { sourcePath } = services.config.getRequired();
+    const config = services.config.load();
+    // 2. Discover all repos
+    const repos = services.repos.discoverRepos(sourcePath);
+    if (repos.length === 0) {
+        throw new NoReposFoundError(sourcePath);
+    }
+    // 3. Filter out repos already in the workspace
+    const existingWorktrees = services.workspaceDir
+        .getWorktreeDirs(workspacePath)
+        .map((dir) => path.basename(dir));
+    const existingSet = new Set(existingWorktrees);
+    const availableRepos = repos.filter((repoPath) => !existingSet.has(path.basename(repoPath)));
+    if (availableRepos.length === 0) {
+        services.console.log('All repos are already in this workspace.');
+        return;
+    }
+    // 4. Repo picker (same pattern as branch command)
+    const checkboxChoices = buildRepoCheckboxChoices(availableRepos, services, [], (label) => new Separator(label));
+    const selected = await deps.checkbox({
+        message: `Select repos to attach to "${displayName}":`,
+        choices: checkboxChoices,
+        pageSize: 20,
+        loop: false,
+    });
+    if (selected.length === 0) {
+        services.console.log('No repos selected.');
+        return;
+    }
+    // 5. Ask for source branch
+    const sourceBranch = await deps.input({
+        message: 'Branch from which branch?',
+        default: 'master',
+    });
+    // 6. Post-checkout confirmation
+    let shouldRunPostCheckout = false;
+    if (config.postCheckout) {
+        shouldRunPostCheckout = await deps.confirm({
+            message: `Run "${config.postCheckout}" in new workspaces?`,
+            default: true,
+        });
+    }
+    services.console.log('\nAttaching repos to workspace...');
+    // 7. Fetch selected repos
+    await services.fetch.fetchRepos(selected, {
+        ttlSeconds: config.fetchCacheTtlSeconds,
+    });
+    // 8. For each selected repo in parallel: createBranch then addToWorkspace
+    // If tmux is enabled, use the workspace branch name as session name
+    const sessionName = config.tmux ? displayName : undefined;
+    const results = await Promise.allSettled(selected.map(async (repoPath) => {
+        const repoName = path.basename(repoPath);
+        // Resolve per-repo post-checkout command
+        const repoConf = services.repoConfig.load(repoPath);
+        const resolvedPostCheckout = shouldRunPostCheckout
+            ? services.repoConfig.resolvePostCheckout(repoName, config.perRepoPostCheckout, repoConf, config.postCheckout)
+            : undefined;
+        // a. Create branch in source repo
+        const branchResult = await useCases.createBranch.execute({
+            repoPath,
+            branchName: displayName,
+            sourceBranch,
+        });
+        // b. Add repo to workspace (creates worktree, copies files, tmux pane, post-checkout)
+        return useCases.addToWorkspace.execute({
+            repoPath,
+            workspacePath,
+            branchName: displayName,
+            baseBranch: branchResult.baseBranch,
+            sessionName,
+            copyFiles: config.copyFiles,
+            postCheckout: resolvedPostCheckout,
+        });
+    }));
+    // 9. Track usage
+    services.fetchCache.trackBranchUsage(selected.map((r) => path.basename(r)));
+    // Tally results
+    const successCount = results.filter((r) => r.status === 'fulfilled').length;
+    const totalCount = results.length;
+    const postCheckoutResults = results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((r) => r.postCheckoutRan);
+    const postCheckoutSuccess = postCheckoutResults.filter((r) => r.postCheckoutSuccess).length;
+    const postCheckoutTotal = postCheckoutResults.length;
+    // 10. Display results
+    services.console.log(`\nAttached ${successCount}/${totalCount} repos to ${chalk.cyan(workspacePath)}.`);
+    if (postCheckoutTotal > 0) {
+        services.console.log(`\nCompleted post-checkout in ${postCheckoutSuccess}/${postCheckoutTotal} workspace(s).`);
+    }
+}
+export function registerAttachCommand(program) {
+    program
+        .command('attach [branch-name]')
+        .description('Attach repos to an existing workspace (auto-detects from current directory if branch not provided)')
+        .action(async (branchName) => {
+        const services = createServices();
+        const useCases = createUseCases(services);
+        try {
+            await runAttach(branchName, useCases, services, { checkbox, input, confirm });
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

package/dist/commands/branch.js

@@ -1,104 +1,11 @@
-import path from 'node:path';
-import checkbox, { Separator } from '@inquirer/checkbox';
-import input from '@inquirer/input';
-import confirm from '@inquirer/confirm';
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
-import { createUseCases } from '../usecases/usecases.js';
-import { NoReposFoundError } from '../lib/errors.js';
-export async function runBranch(branchName, useCases, services, deps) {
-    const { sourcePath, destPath } = services.config.getRequired();
-    const config = services.config.load();
-    const repos = services.repos.discoverRepos(sourcePath);
-    if (repos.length === 0) {
-        throw new NoReposFoundError(sourcePath);
-    }
-    // User prompts
-    const choices = services.repos.formatRepoChoices(repos).map((choice) => ({
-        ...choice,
-        checked: config.branchAutoSelectRepos.includes(choice.name),
-    }));
-    const recentlyUsed = new Set(services.fetchCache.getRecentlyUsedRepos(8));
-    const commonlyUsed = choices.filter((c) => recentlyUsed.has(c.name));
-    let checkboxChoices;
-    if (commonlyUsed.length > 0) {
-        const commonlyUsedNames = new Set(commonlyUsed.map((c) => c.name));
-        const remaining = choices.filter((c) => !commonlyUsedNames.has(c.name));
-        checkboxChoices = [
-            new Separator('Recently Used'),
-            ...commonlyUsed,
-            ...(remaining.length > 0 ? [new Separator(), ...remaining] : []),
-        ];
-    }
-    else {
-        checkboxChoices = choices;
-    }
-    const selected = await deps.checkbox({
-        message: `Select repos for branch "${branchName}":`,
-        choices: checkboxChoices,
-        pageSize: 20,
-        loop: false,
-    });
-    if (selected.length === 0) {
-        services.console.log('No repos selected.');
-        return;
-    }
-    const sourceBranch = await deps.input({
-        message: 'Branch from which branch?',
-        default: 'master',
-    });
-    let shouldRunPostCheckout = false;
-    if (config.postCheckout) {
-        shouldRunPostCheckout = await deps.confirm({
-            message: `Run "${config.postCheckout}" in all workspaces?`,
-            default: true,
-        });
-    }
-    services.console.log('\nCreating workspace...');
-    // Fetch all selected repos
-    await services.fetch.fetchRepos(selected, {
-        ttlSeconds: config.fetchCacheTtlSeconds,
-    });
-    // Execute use case
-    const result = await useCases.createBranchWorkspace.execute({
-        repos: selected,
-        branchName,
-        sourceBranch,
-        sourcePath,
-        destPath,
-        copyFiles: config.copyFiles,
-        tmux: config.tmux,
-        postCheckout: shouldRunPostCheckout ? config.postCheckout : undefined,
-        perRepoPostCheckout: shouldRunPostCheckout ? config.perRepoPostCheckout : {},
-    });
-    // Track which repos were branched from
-    services.fetchCache.trackBranchUsage(selected.map((r) => path.basename(r)));
-    // Display results
-    services.console.log(`\nCreated workspace at ${chalk.cyan(result.workspacePath)} with ${result.successCount}/${result.totalCount} repos.`);
-    if (result.tmuxCreated) {
-        services.console.log(`Created tmux session: ${chalk.cyan(branchName)}`);
-    }
-    if (result.postCheckoutSuccess !== undefined) {
-        services.console.log(`\nCompleted post-checkout in ${result.postCheckoutSuccess}/${result.postCheckoutTotal} workspace(s).`);
-    }
-    else if (!config.postCheckout) {
-        services.console.log('\nTip: Configure a post-checkout command to run automatically after branching/checkout.');
-        services.console.log('  Example: flow config set post-checkout "npm ci"');
-    }
-}
 export function registerBranchCommand(program) {
     program
         .command('branch <branch-name>')
-        .description('Create branches and worktrees for selected repos')
-        .action(async (branchName) => {
+        .description(chalk.dim('Deprecated: use "flow create <branch-name>" instead'))
+        .action(async () => {
         const services = createServices();
-        const useCases = createUseCases(services);
-        try {
-            await runBranch(branchName, useCases, services, { checkbox, input, confirm });
-        }
-        catch (error) {
-            services.console.error(error.message);
-            services.process.exit(1);
-        }
+        services.console.log(chalk.yellow('⚠ "flow branch" is deprecated. Use "flow create" instead.'));
     });
 }

package/dist/commands/checkout.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import confirm from '@inquirer/confirm';
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
@@ -14,23 +15,18 @@ export async function runCheckout(branchName, useCases, services, deps) {
     }
     services.console.log('\nChecking for branch...');
     try {
-        // Fetch all repos from source-path
+        // 1. Fetch all repos from source-path
         await useCases.fetchAllRepos.execute({
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
         });
-        // Execute use case
-        const result = await useCases.checkoutWorkspace.execute({
-            branchName,
+        // 2. Discover repos and find which ones have the branch
+        const discoverResult = await useCases.discoverReposWithBranch.execute({
             sourcePath,
-            destPath,
-            copyFiles: config.copyFiles,
-            tmux: config.tmux,
-            postCheckout: shouldRunPostCheckout ? config.postCheckout : undefined,
-            perRepoPostCheckout: shouldRunPostCheckout ? config.perRepoPostCheckout : {},
+            branchName,
         });
-        // Display branch check results
-        for (const checkResult of result.branchCheckResults) {
+        // 3. Display per-repo branch check results
+        for (const checkResult of discoverResult.branchCheckResults) {
             if (checkResult.error) {
                 services.console.log(`${checkResult.repoName}... ${chalk.red(`error: ${checkResult.error}`)}`);
             }
@@ -41,12 +37,56 @@ export async function runCheckout(branchName, useCases, services, deps) {
                 services.console.log(`${checkResult.repoName}... ${chalk.dim('no branch')}`);
             }
         }
-        services.console.log(`\nCreated workspace at ${chalk.cyan(result.workspacePath)} with ${result.successCount}/${result.totalCount} repos.`);
-        if (result.tmuxCreated) {
+        // 4. Throw error if no repos match
+        if (discoverResult.matchingRepos.length === 0) {
+            throw new Error(`Branch "${branchName}" not found in any repo.`);
+        }
+        // 5. Create workspace directory, placeholder config, AGENTS.md, tmux session
+        const workspaceResult = await useCases.createWorkspace.execute({
+            branchName,
+            sourcePath,
+            destPath,
+            tmux: config.tmux,
+        });
+        const { workspacePath, tmuxCreated } = workspaceResult;
+        const sessionName = tmuxCreated ? branchName : undefined;
+        // 6. For each matching repo in parallel: detect base branch, then addToWorkspace
+        const results = await Promise.allSettled(discoverResult.matchingRepos.map(async (repoPath) => {
+            const repoName = path.basename(repoPath);
+            // Resolve per-repo post-checkout command
+            const repoConf = services.repoConfig.load(repoPath);
+            const resolvedPostCheckout = shouldRunPostCheckout
+                ? services.repoConfig.resolvePostCheckout(repoName, config.perRepoPostCheckout, repoConf, config.postCheckout)
+                : undefined;
+            // Detect base branch for this repo
+            const baseBranch = await services.git.findFirstExistingBranch(repoPath, ['master', 'main', 'trunk', 'develop']) ?? 'master';
+            // Add repo to workspace (creates worktree, copies files, tmux pane, post-checkout)
+            return useCases.addToWorkspace.execute({
+                repoPath,
+                workspacePath,
+                branchName,
+                baseBranch,
+                sessionName,
+                copyFiles: config.copyFiles,
+                postCheckout: resolvedPostCheckout,
+            });
+        }));
+        // Tally results
+        const successCount = results.filter((r) => r.status === 'fulfilled').length;
+        const totalCount = results.length;
+        const postCheckoutResults = results
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value)
+            .filter((r) => r.postCheckoutRan);
+        const postCheckoutSuccess = postCheckoutResults.filter((r) => r.postCheckoutSuccess).length;
+        const postCheckoutTotal = postCheckoutResults.length;
+        // 7. Display results
+        services.console.log(`\nCreated workspace at ${chalk.cyan(workspacePath)} with ${successCount}/${totalCount} repos.`);
+        if (tmuxCreated) {
             services.console.log(`Created tmux session: ${chalk.cyan(branchName)}`);
         }
-        if (result.postCheckoutSuccess !== undefined) {
-            services.console.log(`\nCompleted post-checkout in ${result.postCheckoutSuccess}/${result.postCheckoutTotal} workspace(s).`);
+        if (postCheckoutTotal > 0) {
+            services.console.log(`\nCompleted post-checkout in ${postCheckoutSuccess}/${postCheckoutTotal} workspace(s).`);
         }
         else if (!config.postCheckout) {
             services.console.log('\nTip: Configure a post-checkout command to run automatically after branching/checkout.');

package/dist/commands/create.js

@@ -0,0 +1,118 @@
+import path from 'node:path';
+import checkbox, { Separator } from '@inquirer/checkbox';
+import input from '@inquirer/input';
+import confirm from '@inquirer/confirm';
+import chalk from 'chalk';
+import { createServices } from '../lib/services.js';
+import { createUseCases } from '../usecases/usecases.js';
+import { NoReposFoundError } from '../lib/errors.js';
+import { buildRepoCheckboxChoices } from './helpers.js';
+export async function runCreate(branchName, useCases, services, deps) {
+    const { sourcePath, destPath } = services.config.getRequired();
+    const config = services.config.load();
+    const repos = services.repos.discoverRepos(sourcePath);
+    if (repos.length === 0) {
+        throw new NoReposFoundError(sourcePath);
+    }
+    // User prompts
+    const checkboxChoices = buildRepoCheckboxChoices(repos, services, config.branchAutoSelectRepos, (label) => new Separator(label));
+    const selected = await deps.checkbox({
+        message: `Select repos for branch "${branchName}":`,
+        choices: checkboxChoices,
+        pageSize: 20,
+        loop: false,
+    });
+    if (selected.length === 0) {
+        services.console.log('No repos selected.');
+        return;
+    }
+    const sourceBranch = await deps.input({
+        message: 'Branch from which branch?',
+        default: 'master',
+    });
+    let shouldRunPostCheckout = false;
+    if (config.postCheckout) {
+        shouldRunPostCheckout = await deps.confirm({
+            message: `Run "${config.postCheckout}" in all workspaces?`,
+            default: true,
+        });
+    }
+    services.console.log('\nCreating workspace...');
+    // Fetch all selected repos
+    await services.fetch.fetchRepos(selected, {
+        ttlSeconds: config.fetchCacheTtlSeconds,
+    });
+    // 1. Create workspace directory, placeholder config, AGENTS.md, tmux session
+    const workspaceResult = await useCases.createWorkspace.execute({
+        branchName,
+        sourcePath,
+        destPath,
+        tmux: config.tmux,
+    });
+    const { workspacePath, tmuxCreated } = workspaceResult;
+    const sessionName = tmuxCreated ? branchName : undefined;
+    // 2. For each selected repo in parallel: createBranch then addToWorkspace
+    const results = await Promise.allSettled(selected.map(async (repoPath) => {
+        const repoName = path.basename(repoPath);
+        // Resolve per-repo post-checkout command
+        const repoConf = services.repoConfig.load(repoPath);
+        const resolvedPostCheckout = shouldRunPostCheckout
+            ? services.repoConfig.resolvePostCheckout(repoName, config.perRepoPostCheckout, repoConf, config.postCheckout)
+            : undefined;
+        // a. Create branch in source repo
+        const branchResult = await useCases.createBranch.execute({
+            repoPath,
+            branchName,
+            sourceBranch,
+        });
+        // b. Add repo to workspace (creates worktree, copies files, tmux pane, post-checkout)
+        return useCases.addToWorkspace.execute({
+            repoPath,
+            workspacePath,
+            branchName,
+            baseBranch: branchResult.baseBranch,
+            sessionName,
+            copyFiles: config.copyFiles,
+            postCheckout: resolvedPostCheckout,
+        });
+    }));
+    // Track which repos were branched from
+    services.fetchCache.trackBranchUsage(selected.map((r) => path.basename(r)));
+    // Tally results
+    const successCount = results.filter((r) => r.status === 'fulfilled').length;
+    const totalCount = results.length;
+    const postCheckoutResults = results
+        .filter((r) => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((r) => r.postCheckoutRan);
+    const postCheckoutSuccess = postCheckoutResults.filter((r) => r.postCheckoutSuccess).length;
+    const postCheckoutTotal = postCheckoutResults.length;
+    // Display results
+    services.console.log(`\nCreated workspace at ${chalk.cyan(workspacePath)} with ${successCount}/${totalCount} repos.`);
+    if (tmuxCreated) {
+        services.console.log(`Created tmux session: ${chalk.cyan(branchName)}`);
+    }
+    if (postCheckoutTotal > 0) {
+        services.console.log(`\nCompleted post-checkout in ${postCheckoutSuccess}/${postCheckoutTotal} workspace(s).`);
+    }
+    else if (!config.postCheckout) {
+        services.console.log('\nTip: Configure a post-checkout command to run automatically after branching/checkout.');
+        services.console.log('  Example: flow config set post-checkout "npm ci"');
+    }
+}
+export function registerCreateCommand(program) {
+    program
+        .command('create <branch-name>')
+        .description('Create branches and worktrees for selected repos')
+        .action(async (branchName) => {
+        const services = createServices();
+        const useCases = createUseCases(services);
+        try {
+            await runCreate(branchName, useCases, services, { checkbox, input, confirm });
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

package/dist/commands/{remove.js → drop.js}

@@ -4,7 +4,7 @@ import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
 import { StatusService } from '../lib/status.js';
 import { resolveWorkspace } from '../lib/workspaceResolver.js';
-export async function runRemove(branchName, useCases, services, deps) {
+export async function runDrop(branchName, useCases, services, deps) {
     const { sourcePath } = services.config.getRequired();
     const config = services.config.load();
     const { workspacePath, displayName: branchNameForDisplay } = resolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
@@ -47,7 +47,7 @@ export async function runRemove(branchName, useCases, services, deps) {
         services.console.log(`  Tmux session: ${chalk.cyan(branchNameForDisplay)}`);
     }
     const confirmed = await deps.confirm({
-        message: 'Are you sure you want to remove this workspace?',
+        message: 'Are you sure you want to drop this workspace?',
         default: false,
     });
     if (!confirmed) {
@@ -55,7 +55,7 @@ export async function runRemove(branchName, useCases, services, deps) {
         services.process.exit(0);
     }
     // Execute use case (will throw if there are issues)
-    services.console.log('\nRemoving workspace...');
+    services.console.log('\nDropping workspace...');
     const result = await useCases.removeWorkspace.execute({
         workspacePath,
         branchName: branchNameForDisplay,
@@ -85,17 +85,17 @@ export async function runRemove(branchName, useCases, services, deps) {
     if (result.tmuxKilled) {
         services.console.log(`${chalk.green('Killed tmux session:')} ${branchNameForDisplay}`);
     }
-    services.console.log(`\n${chalk.green('Successfully removed workspace:')} ${branchNameForDisplay}`);
+    services.console.log(`\n${chalk.green('Successfully dropped workspace:')} ${branchNameForDisplay}`);
 }
-export function registerRemoveCommand(program) {
+export function registerDropCommand(program) {
     program
-        .command('remove [branch-name]')
-        .description('Remove a workspace and all its worktrees (auto-detects from current directory if branch not provided)')
+        .command('drop [branch-name]')
+        .description('Drop a workspace and all its worktrees (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();
         const useCases = createUseCases(services);
         try {
-            await runRemove(branchName, useCases, services, { confirm });
+            await runDrop(branchName, useCases, services, { confirm });
         }
         catch (error) {
             services.console.error(error.message);

package/dist/commands/fetch.js

@@ -1,26 +1,39 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-export async function runFetch(useCases, services) {
+import { tryResolveWorkspace } from '../lib/workspaceResolver.js';
+export async function runFetch(branchName, useCases, services) {
     const { destPath, sourcePath } = services.config.getRequired();
-    services.console.log('Fetching all repos used across workspaces...\n');
-    await useCases.fetchUsedRepos.execute({
-        destPath,
-        sourcePath,
-        fetchCacheTtlSeconds: 0, // Bypass cache
-        silent: false,
-    });
+    const workspace = tryResolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
+    if (workspace) {
+        services.console.log(`Fetching repos for workspace ${chalk.cyan(workspace.displayName)}...\n`);
+        await useCases.fetchWorkspaceRepos.execute({
+            workspacePath: workspace.workspacePath,
+            sourcePath,
+            fetchCacheTtlSeconds: 0,
+            silent: false,
+        });
+    }
+    else {
+        services.console.log('Fetching all repos used across workspaces...\n');
+        await useCases.fetchUsedRepos.execute({
+            destPath,
+            sourcePath,
+            fetchCacheTtlSeconds: 0,
+            silent: false,
+        });
+    }
     services.console.log(`\n${chalk.green('✓')} Fetch complete`);
 }
 export function registerFetchCommand(program) {
     program
-        .command('fetch')
-        .description('Fetch all repos used across workspaces (bypasses cache)')
-        .action(async () => {
+        .command('fetch [branch-name]')
+        .description('Fetch repos (workspace-scoped if branch provided, all workspaces otherwise)')
+        .action(async (branchName) => {
         const services = createServices();
         const useCases = createUseCases(services);
         try {
-            await runFetch(useCases, services);
+            await runFetch(branchName, useCases, services);
         }
         catch (error) {
             services.console.error(error.message);