worktree-flow 0.0.17 → 0.0.19

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,9 +56,9 @@ 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 add [name]`
+### `flow attach [name]`
 
-Add 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.
+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`
 
@@ -81,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.
+Remove workspaces interactively. Displays full workspace status (identical to `flow list`), then excludes any workspaces with uncommitted changes or errors from the selection prompt. Resolve issues before pruning those workspaces.
 
-### `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.
 

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { registerConfigCommand } from './commands/config.js';
-import { registerAddCommand } from './commands/add.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';
@@ -19,13 +20,14 @@ program
     .description('Manage git worktrees across a poly-repo environment')
     .version('0.1.0');
 registerConfigCommand(program);
-registerAddCommand(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/{add.js → attach.js}

@@ -8,7 +8,7 @@ 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 runAdd(branchName, useCases, services, deps) {
+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();
@@ -29,9 +29,9 @@ export async function runAdd(branchName, useCases, services, deps) {
         return;
     }
     // 4. Repo picker (same pattern as branch command)
-    const checkboxChoices = buildRepoCheckboxChoices(availableRepos, services, config, (label) => new Separator(label));
+    const checkboxChoices = buildRepoCheckboxChoices(availableRepos, services, [], (label) => new Separator(label));
     const selected = await deps.checkbox({
-        message: `Select repos to add to "${displayName}":`,
+        message: `Select repos to attach to "${displayName}":`,
         choices: checkboxChoices,
         pageSize: 20,
         loop: false,
@@ -53,7 +53,7 @@ export async function runAdd(branchName, useCases, services, deps) {
             default: true,
         });
     }
-    services.console.log('\nAdding repos to workspace...');
+    services.console.log('\nAttaching repos to workspace...');
     // 7. Fetch selected repos
     await services.fetch.fetchRepos(selected, {
         ttlSeconds: config.fetchCacheTtlSeconds,
@@ -97,20 +97,20 @@ export async function runAdd(branchName, useCases, services, deps) {
     const postCheckoutSuccess = postCheckoutResults.filter((r) => r.postCheckoutSuccess).length;
     const postCheckoutTotal = postCheckoutResults.length;
     // 10. Display results
-    services.console.log(`\nAdded ${successCount}/${totalCount} repos to ${chalk.cyan(workspacePath)}.`);
+    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 registerAddCommand(program) {
+export function registerAttachCommand(program) {
     program
-        .command('add [branch-name]')
-        .description('Add repos to an existing workspace (auto-detects from current directory if branch not provided)')
+        .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 runAdd(branchName, useCases, services, { checkbox, input, confirm });
+            await runAttach(branchName, useCases, services, { checkbox, input, confirm });
         }
         catch (error) {
             services.console.error(error.message);

package/dist/commands/branch.js

@@ -1,118 +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';
-import { buildRepoCheckboxChoices } from './helpers.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 checkboxChoices = buildRepoCheckboxChoices(repos, services, config, (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 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/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}

@@ -1,41 +1,46 @@
+import path from 'node:path';
 import chalk from 'chalk';
 import confirm from '@inquirer/confirm';
 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) {
+import { logStatusFetching, logStatus } from './helpers.js';
+import { StatusService } from '../lib/status.js';
+import { WorkspaceHasIssuesError } from '../lib/errors.js';
+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);
-    services.console.log(`Checking workspace: ${chalk.cyan(workspacePath)}`);
     // Get worktree dirs to show what will be removed
     const worktreeDirs = services.workspaceDir.getWorktreeDirs(workspacePath);
     // Display status check if worktrees exist
     if (worktreeDirs.length > 0) {
+        const workspaceName = path.basename(workspacePath);
+        const repoCount = worktreeDirs.length;
+        // Phase 1: Show header with fetching indicator
+        const loadingLines = logStatusFetching('Workspace:', [{ name: workspaceName, repoCount }], services.console);
+        // Fetch workspace repos (silently)
         await useCases.fetchWorkspaceRepos.execute({
             workspacePath,
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+            silent: true,
+        });
+        const statusResult = await useCases.checkWorkspaceStatus.execute({
+            workspacePath,
         });
-        services.console.log(`\nChecking for uncommitted changes...`);
         // Load workspace config to get per-repo base branches
         const workspaceConfig = services.workspaceConfig.load(workspacePath);
-        const getBaseBranch = (repoName) => workspaceConfig.baseBranches[repoName] || 'master';
-        const results = await services.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
-        for (const { repoName, status } of results) {
-            const baseBranch = getBaseBranch(repoName);
-            const message = StatusService.getStatusMessage(status, baseBranch);
-            if (StatusService.hasIssues(status)) {
-                services.console.log(`${repoName}... ${chalk.red(message)}`);
-            }
-            else {
-                services.console.log(`${repoName}... ${chalk.green(message)}`);
-            }
+        // Phase 2: Clear Phase 1 lines and re-render with full status
+        logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: statusResult.statuses }], loadingLines, (_, repoName) => workspaceConfig.baseBranches[repoName] || 'master', services.console);
+        // Block if any repos have uncommitted changes — user must resolve them first
+        const reposWithIssues = statusResult.statuses.filter(({ status }) => StatusService.hasIssues(status));
+        if (reposWithIssues.length > 0) {
+            throw new WorkspaceHasIssuesError(`${reposWithIssues.length} repo(s) have uncommitted changes or errors. Resolve them before dropping.`);
         }
     }
     else {
-        services.console.log('No worktrees found in workspace.');
+        services.console.log('\nNo worktrees found in workspace.');
     }
     // Show what will be removed
     services.console.log(`\n${chalk.yellow('This will remove:')}`);
@@ -47,7 +52,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 +60,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 +90,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);

package/dist/commands/helpers.js

@@ -53,10 +53,10 @@ export function logStatus(header, workspaces, linesToClear, getBaseBranch, conso
  *
  * @param createSeparator - factory from the display layer (e.g. inquirer's Separator constructor)
  */
-export function buildRepoCheckboxChoices(repos, services, config, createSeparator) {
+export function buildRepoCheckboxChoices(repos, services, preSelected, createSeparator) {
     const choices = services.repos.formatRepoChoices(repos).map((choice) => ({
         ...choice,
-        checked: config.branchAutoSelectRepos.includes(choice.name),
+        checked: preSelected.includes(choice.name),
     }));
     const recentlyUsed = new Set(services.fetchCache.getRecentlyUsedRepos(8));
     const commonlyUsed = choices.filter((c) => recentlyUsed.has(c.name));
@@ -71,34 +71,3 @@ export function buildRepoCheckboxChoices(repos, services, config, createSeparato
     }
     return choices;
 }
-/**
- * Get a human-readable status indicator for a workspace based on its worktree statuses.
- */
-export function getStatusIndicator(workspace) {
-    const hasUncommitted = workspace.statuses.some(s => s.status.type === 'uncommitted');
-    const hasAhead = workspace.statuses.some(s => s.status.type === 'ahead');
-    const hasBehind = workspace.statuses.some(s => s.status.type === 'behind');
-    const hasDiverged = workspace.statuses.some(s => s.status.type === 'diverged');
-    const hasError = workspace.statuses.some(s => s.status.type === 'error');
-    if (hasUncommitted) {
-        return chalk.yellow('uncommitted');
-    }
-    else if (hasDiverged) {
-        return chalk.red('diverged');
-    }
-    else if (hasAhead && hasBehind) {
-        return chalk.yellow('ahead');
-    }
-    else if (hasAhead) {
-        return chalk.yellow('ahead');
-    }
-    else if (hasBehind) {
-        return chalk.blue('behind');
-    }
-    else if (hasError) {
-        return chalk.red('error');
-    }
-    else {
-        return chalk.green('clean');
-    }
-}

package/dist/commands/prune.js

@@ -3,7 +3,8 @@ import checkbox from '@inquirer/checkbox';
 import confirm from '@inquirer/confirm';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-import { getStatusIndicator } from './helpers.js';
+import { logStatusFetching, logStatus } from './helpers.js';
+import { StatusService } from '../lib/status.js';
 export async function runPrune(useCases, services, deps) {
     const { sourcePath, destPath } = services.config.getRequired();
     const config = services.config.load();
@@ -14,11 +15,14 @@ export async function runPrune(useCases, services, deps) {
         services.console.log('No workspaces found.');
         services.process.exit(0);
     }
+    // Phase 1: Show basic list with fetching indicator
+    const loadingLines = logStatusFetching('Workspaces:', basicWorkspaces, services.console);
     // Fetch repos used across all workspaces
     await useCases.fetchUsedRepos.execute({
         destPath,
         sourcePath,
         fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+        silent: true,
     });
     // Get full status for all workspaces
     const result = await useCases.listWorkspacesWithStatus.execute({
@@ -26,12 +30,31 @@ export async function runPrune(useCases, services, deps) {
         sourcePath,
         cwd,
     });
-    // Format choices for checkbox prompt
-    const choices = result.workspaces.map(workspace => {
-        const statusIndicator = getStatusIndicator(workspace);
+    // Phase 2: Clear Phase 1 and re-print with full status (same as `list` command)
+    logStatus('Workspaces:', result.workspaces, loadingLines, (wsPath, repoName) => services.workspaceConfig.load(wsPath).baseBranches[repoName] || 'master', services.console);
+    // Partition workspaces into prunable (no issues) and skipped (has issues)
+    const prunableWorkspaces = result.workspaces.filter(ws => !ws.statuses.some(({ status }) => StatusService.hasIssues(status)));
+    const skippedWorkspaces = result.workspaces.filter(ws => ws.statuses.some(({ status }) => StatusService.hasIssues(status)));
+    // Log skipped workspaces with reason
+    for (const ws of skippedWorkspaces) {
+        const hasUncommitted = ws.statuses.some(s => s.status.type === 'uncommitted');
+        const hasError = ws.statuses.some(s => s.status.type === 'error');
+        const reason = hasUncommitted ? 'uncommitted changes' : hasError ? 'errors' : 'issues';
+        services.console.log(`${chalk.yellow('⚠')} Skipping ${chalk.cyan(ws.name)} (${reason})`);
+    }
+    // Newline if there were skipped workspaces
+    if (skippedWorkspaces.length)
+        console.log('');
+    // If no prunable workspaces remain, exit
+    if (prunableWorkspaces.length === 0) {
+        services.console.log('\nAll workspaces have uncommitted changes or errors. Resolve them before pruning.');
+        services.process.exit(0);
+    }
+    // Format choices for checkbox prompt (only prunable workspaces)
+    const choices = prunableWorkspaces.map(workspace => {
         const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
         return {
-            name: `${chalk.cyan(workspace.name)} ${repoCount} ${statusIndicator}`,
+            name: `${chalk.cyan(workspace.name)} ${repoCount}`,
             value: workspace.name,
         };
     });
@@ -46,7 +69,7 @@ export async function runPrune(useCases, services, deps) {
         services.process.exit(0);
     }
     // Get full workspace objects for selected items
-    const selectedWorkspaces = result.workspaces.filter(w => selected.includes(w.name));
+    const selectedWorkspaces = prunableWorkspaces.filter(w => selected.includes(w.name));
     // Confirm deletion
     const confirmed = await deps.confirm({
         message: `Are you sure you want to prune ${selected.length} workspace(s)?`,
@@ -89,7 +112,6 @@ export async function runPrune(useCases, services, deps) {
 export function registerPruneCommand(program) {
     program
         .command('prune')
-        .alias('clean')
         .description('Select and remove workspaces')
         .action(async () => {
         const services = createServices();

package/dist/commands/quickstart.js

@@ -133,7 +133,7 @@ export async function runQuickstart(services, deps) {
     services.console.log('');
     services.console.log(chalk.bold('  Get started:'));
     services.console.log('');
-    services.console.log(`    ${chalk.cyan('flow branch my-feature')}     Create a new branch across repos`);
+    services.console.log(`    ${chalk.cyan('flow create my-feature')}     Create a new branch across repos`);
     services.console.log(`    ${chalk.cyan('flow checkout my-feature')}   Checkout an existing branch`);
     services.console.log(`    ${chalk.cyan('flow list')}                  See all your workspaces`);
     services.console.log('');

package/dist/commands/tmux.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-export async function runTmuxResume(useCases, services) {
+export async function runTmuxSync(useCases, services) {
     const { destPath } = services.config.getRequired();
     const result = await useCases.resumeTmuxSessions.execute({ destPath });
     if (result.totalWorkspaces === 0) {
@@ -29,13 +29,13 @@ export function registerTmuxCommand(program) {
         .command('tmux')
         .description('Manage tmux sessions for workspaces');
     tmuxCommand
-        .command('resume')
+        .command('sync')
         .description('Create tmux sessions for all workspaces that don\'t have one')
         .action(async () => {
         const services = createServices();
         const useCases = createUseCases(services);
         try {
-            await runTmuxResume(useCases, services);
+            await runTmuxSync(useCases, services);
         }
         catch (error) {
             services.console.error(error.message);

package/dist/lib/workspaceResolver.js

@@ -39,3 +39,16 @@ export function resolveWorkspace(branchName, workspaceDir, config, process) {
         };
     }
 }
+/**
+ * Like resolveWorkspace, but returns null instead of throwing when no workspace
+ * can be resolved. Useful when workspace resolution is optional (e.g. falling back
+ * to a broader operation when not in a workspace).
+ */
+export function tryResolveWorkspace(branchName, workspaceDir, config, process) {
+    try {
+        return resolveWorkspace(branchName, workspaceDir, config, process);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/usecases/createBranch.js

@@ -22,9 +22,13 @@ export class CreateBranchUseCase {
             }
             actualBaseBranch = fallback;
         }
-        // 3. Create the branch from origin/<actualBaseBranch>
-        await this.git.createBranch(params.repoPath, params.branchName, `origin/${actualBaseBranch}`);
-        // 4. Return the actual base branch used
+        // 3. If the target branch already exists, skip creation and use it as-is
+        const targetBranchExists = await this.git.localRemoteBranchExists(params.repoPath, params.branchName);
+        if (!targetBranchExists) {
+            // 4. Create the branch from origin/<actualBaseBranch>
+            await this.git.createBranch(params.repoPath, params.branchName, `origin/${actualBaseBranch}`);
+        }
+        // 5. Return the actual base branch used
         return {
             repoName,
             baseBranch: actualBaseBranch,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-flow",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "Manage git worktrees across a poly-repo environment",
   "type": "module",
   "bin": {