worktree-flow 0.0.8 → 0.0.10

package/README.md

@@ -73,18 +73,18 @@ Check the status of all repos in a workspace. Shows uncommitted changes, commits
 
 List all workspaces with status indicators. Shows:
 - Active workspace (marked with `*`) based on current directory
-- Overall status: `clean`, `uncommitted`, `ahead`, `behind`, `diverged`, or `mixed`
+- Overall status: `clean`, `uncommitted`, `ahead`, or `mixed`
 - Repo count for each workspace
 
-Fetches all repos before checking status to ensure accurate information.
+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>`
 
-Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted changes and unpushed commits, and prompts for confirmation before removing.
+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.
 
 ### `flow prune` (alias: `clean`)
 
-Remove stale workspaces in bulk. Finds workspaces where all worktrees are clean, fully merged, and haven't been committed to in over 7 days.
+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`
 

package/dist/commands/helpers.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+/**
+ * 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/list.js

@@ -1,34 +1,7 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-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');
-    }
-}
+import { getStatusIndicator } from './helpers.js';
 export async function runList(useCases, services) {
     const { destPath, sourcePath } = services.config.getRequired();
     const config = services.config.load();
@@ -57,7 +30,6 @@ export async function runList(useCases, services) {
     const result = await useCases.listWorkspacesWithStatus.execute({
         destPath,
         sourcePath,
-        mainBranch: config.mainBranch,
         cwd,
     });
     // Phase 4: Clear previous output and re-print with status

package/dist/commands/prune.js

@@ -1,44 +1,55 @@
 import chalk from 'chalk';
+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';
 export async function runPrune(useCases, services, deps) {
     const { sourcePath, destPath } = services.config.getRequired();
     const config = services.config.load();
-    services.console.log('Analyzing workspaces for pruning...\n');
+    const cwd = services.process.cwd();
+    // Check if workspaces exist
+    const basicWorkspaces = services.workspaceDir.listWorkspaces(destPath);
+    if (basicWorkspaces.length === 0) {
+        services.console.log('No workspaces found.');
+        services.process.exit(0);
+    }
     // Fetch repos used across all workspaces
     await useCases.fetchUsedRepos.execute({
         destPath,
         sourcePath,
         fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
     });
-    // Analyze workspaces to find prunable ones
-    const result = await useCases.discoverPrunableWorkspaces.execute({
+    // Get full status for all workspaces
+    const result = await useCases.listWorkspacesWithStatus.execute({
         destPath,
         sourcePath,
-        mainBranch: config.mainBranch,
-        daysOld: 7,
+        cwd,
+    });
+    // Format choices for checkbox prompt
+    const choices = result.workspaces.map(workspace => {
+        const statusIndicator = getStatusIndicator(workspace);
+        const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
+        return {
+            name: `${chalk.cyan(workspace.name)} ${repoCount} ${statusIndicator}`,
+            value: workspace.name,
+        };
     });
-    if (result.prunable.length === 0) {
-        services.console.log('No workspaces to prune.');
-        services.console.log(`\nWorkspaces are prunable when:`);
-        services.console.log(`  - All worktrees have no uncommitted changes`);
-        services.console.log(`  - All worktrees are not ahead of ${config.mainBranch}`);
-        services.console.log(`  - Last commit is more than 7 days old`);
+    // Let user select workspaces to prune
+    const selected = await deps.checkbox({
+        message: 'Select workspaces to prune:',
+        choices,
+        pageSize: 20,
+    });
+    if (selected.length === 0) {
+        services.console.log('No workspaces selected.');
         services.process.exit(0);
     }
-    // Display prunable workspaces
-    services.console.log(`${chalk.yellow('Found')} ${chalk.cyan(result.prunable.length)} ${chalk.yellow('workspace(s) that can be pruned:')}\n`);
-    for (const workspace of result.prunable) {
-        const daysOld = Math.floor((Date.now() - workspace.oldestCommitDate.getTime()) / (1000 * 60 * 60 * 24));
-        services.console.log(`  ${chalk.cyan(workspace.name)}`);
-        services.console.log(`    Repos: ${workspace.repoCount}`);
-        services.console.log(`    Last commit: ${daysOld} days ago`);
-        services.console.log(`    Status: ${chalk.green('clean')}`);
-        services.console.log('');
-    }
+    // Get full workspace objects for selected items
+    const selectedWorkspaces = result.workspaces.filter(w => selected.includes(w.name));
+    // Confirm deletion
     const confirmed = await deps.confirm({
-        message: 'Are you sure you want to prune these workspaces?',
+        message: `Are you sure you want to prune ${selected.length} workspace(s)?`,
         default: false,
     });
     if (!confirmed) {
@@ -49,14 +60,13 @@ export async function runPrune(useCases, services, deps) {
     services.console.log('\nPruning workspaces...\n');
     let successCount = 0;
     let errorCount = 0;
-    for (const workspace of result.prunable) {
+    for (const workspace of selectedWorkspaces) {
         try {
             services.console.log(`Removing ${chalk.cyan(workspace.name)}...`);
             await useCases.removeWorkspace.execute({
                 workspacePath: workspace.path,
                 branchName: workspace.name,
                 sourcePath,
-                mainBranch: config.mainBranch,
                 tmux: config.tmux,
             });
             services.console.log(`  ${chalk.green('✓')} Removed ${workspace.name}`);
@@ -80,12 +90,12 @@ export function registerPruneCommand(program) {
     program
         .command('prune')
         .alias('clean')
-        .description('Remove old workspaces with no uncommitted changes and commits older than 7 days')
+        .description('Select and remove workspaces')
         .action(async () => {
         const services = createServices();
         const useCases = createUseCases(services);
         try {
-            await runPrune(useCases, services, { confirm });
+            await runPrune(useCases, services, { checkbox, confirm });
         }
         catch (error) {
             services.console.error(error.message);

package/dist/commands/remove.js

@@ -18,10 +18,14 @@ export async function runRemove(branchName, useCases, services, deps) {
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
         });
-        services.console.log(`\nChecking for uncommitted changes and commits ahead of ${config.mainBranch}...`);
-        const results = await services.status.checkAllWorktrees(worktreeDirs, config.mainBranch);
+        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 message = StatusService.getStatusMessage(status, config.mainBranch);
+            const baseBranch = getBaseBranch(repoName);
+            const message = StatusService.getStatusMessage(status, baseBranch);
             if (StatusService.hasIssues(status)) {
                 services.console.log(`${repoName}... ${chalk.red(message)}`);
             }
@@ -56,7 +60,6 @@ export async function runRemove(branchName, useCases, services, deps) {
         workspacePath,
         branchName: branchNameForDisplay,
         sourcePath,
-        mainBranch: config.mainBranch,
         tmux: config.tmux,
     });
     // Display worktree removal results

package/dist/commands/status.js

@@ -20,15 +20,18 @@ export async function runStatus(branchName, useCases, services) {
         fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
     });
     services.console.log('');
-    services.console.log(`\nStatus (comparing against ${chalk.cyan(config.mainBranch)}):\n`);
+    services.console.log(`\nStatus:\n`);
     const result = await useCases.checkWorkspaceStatus.execute({
         workspacePath,
-        mainBranch: config.mainBranch,
     });
+    // Load workspace config to get per-repo base branches
+    const workspaceConfig = services.workspaceConfig.load(workspacePath);
+    const getBaseBranch = (repoName) => workspaceConfig.baseBranches[repoName] || 'master';
     let cleanCount = 0;
     let issuesCount = 0;
     for (const { repoName, status } of result.statuses) {
-        const message = StatusService.getStatusMessage(status, config.mainBranch);
+        const baseBranch = getBaseBranch(repoName);
+        const message = StatusService.getStatusMessage(status, baseBranch);
         if (StatusService.hasIssues(status)) {
             services.console.log(`  ${chalk.red('✗')} ${repoName}: ${chalk.red(message)}`);
             issuesCount++;

package/dist/lib/config.js

@@ -8,7 +8,6 @@ const RawConfigSchema = z.object({
     'dest-path': z.string().optional(),
     'copy-files': z.string().optional(),
     'tmux': z.enum(['true', 'false']).optional(),
-    'main-branch': z.string().optional(),
     'post-checkout': z.string().optional(),
     'fetch-cache-ttl-seconds': z.string().optional(),
     'per-repo-post-checkout': z.record(z.string(), z.string()).optional(),
@@ -19,7 +18,6 @@ const ParsedConfigSchema = z.object({
     destPath: z.string().optional(),
     copyFiles: z.string().default('.env'),
     tmux: z.boolean().default(false),
-    mainBranch: z.string().default('master'),
     postCheckout: z.string().optional(),
     fetchCacheTtlSeconds: z.number().default(300),
     perRepoPostCheckout: z.record(z.string(), z.string()).default({}),
@@ -35,14 +33,13 @@ const ConfigValueSchemas = {
     'dest-path': z.string().transform((val) => path.resolve(val)),
     'copy-files': z.string(),
     'tmux': z.enum(['true', 'false']),
-    'main-branch': z.string(),
     'post-checkout': z.string(),
     'fetch-cache-ttl-seconds': z.string().refine((val) => {
         const num = parseInt(val, 10);
         return !isNaN(num) && num >= 0;
     }, { message: 'Must be a non-negative integer' }),
 };
-export const CONFIG_KEYS = ['source-path', 'dest-path', 'copy-files', 'tmux', 'main-branch', 'post-checkout', 'fetch-cache-ttl-seconds'];
+export const CONFIG_KEYS = ['source-path', 'dest-path', 'copy-files', 'tmux', 'post-checkout', 'fetch-cache-ttl-seconds'];
 /**
  * Pure utility functions (no I/O)
  */
@@ -86,7 +83,6 @@ export class ConfigService {
             destPath: raw['dest-path'],
             copyFiles: raw['copy-files'],
             tmux: raw.tmux === 'true',
-            mainBranch: raw['main-branch'],
             postCheckout: raw['post-checkout'],
             fetchCacheTtlSeconds: raw['fetch-cache-ttl-seconds']
                 ? parseInt(raw['fetch-cache-ttl-seconds'], 10)
@@ -130,10 +126,6 @@ export class ConfigService {
                 value: raw.tmux ?? `${config.tmux} (default)`,
                 isDefault: !raw.tmux,
             },
-            'main-branch': {
-                value: raw['main-branch'] ?? `${config.mainBranch} (default)`,
-                isDefault: !raw['main-branch'],
-            },
             'post-checkout': {
                 value: raw['post-checkout'] ?? '(not set)',
                 isDefault: !raw['post-checkout'],

package/dist/lib/git.js

@@ -28,6 +28,14 @@ export class GitService {
             return false;
         }
     }
+    async findFirstExistingBranch(repoPath, candidates) {
+        for (const branch of candidates) {
+            const exists = await this.localRemoteBranchExists(repoPath, branch);
+            if (exists)
+                return branch;
+        }
+        return null;
+    }
     async addWorktreeNewBranch(repoPath, worktreePath, branch, sourceBranch) {
         const args = ['worktree', 'add', '-b', branch, worktreePath];
         if (sourceBranch) {
@@ -87,9 +95,15 @@ export class GitService {
     }
     async isAheadOfMain(repoPath, mainBranch) {
         try {
-            // Check if there's a diff between current branch and main
-            const output = await this.exec(repoPath, ['diff', `origin/${mainBranch}...HEAD`]);
-            return output.length > 0;
+            // Use git cherry to detect if commits exist in main via patch equivalence
+            // cherry outputs nothing if all commits are equivalent to main
+            // Format: "+ hash message" for unmerged, "- hash message" for already merged
+            const output = await this.exec(repoPath, ['cherry', `origin/${mainBranch}`, 'HEAD']);
+            // Filter to only unmerged commits (those starting with +)
+            const unmergedCommits = output
+                .split('\n')
+                .filter(line => line.trim().startsWith('+'));
+            return unmergedCommits.length > 0;
         }
         catch {
             // If we can't determine, assume there are changes to be safe

package/dist/lib/services.js

@@ -6,6 +6,7 @@ import { ConfigService } from './config.js';
 import { GitService } from './git.js';
 import { RepoService } from './repos.js';
 import { WorkspaceDirectoryService } from './workspaceDirectory.js';
+import { WorkspaceConfigService } from './workspaceConfig.js';
 import { WorktreeService } from './worktree.js';
 import { PostCheckoutService } from './postCheckout.js';
 import { FetchService } from './fetch.js';
@@ -31,12 +32,14 @@ export function createServices() {
     const postCheckout = new PostCheckoutService(shell);
     // Focused workspace services
     const workspaceDir = new WorkspaceDirectoryService(fs);
+    const workspaceConfig = new WorkspaceConfigService(fs);
     const worktree = new WorktreeService(fs, git);
     return {
         config,
         git,
         repos,
         workspaceDir,
+        workspaceConfig,
         worktree,
         postCheckout,
         fetch,

package/dist/lib/status.js

@@ -6,32 +6,15 @@ export class StatusService {
     constructor(git) {
         this.git = git;
     }
-    async getWorktreeStatus(worktreePath, mainBranch) {
+    async getWorktreeStatus(worktreePath, baseBranch) {
         try {
-            // Always check for uncommitted changes first
+            // Check for uncommitted changes first
             const hasUncommitted = await this.git.hasUncommittedChanges(worktreePath);
             if (hasUncommitted) {
                 return { type: 'uncommitted' };
             }
-            // Check if origin branch exists
-            const hasOriginBranch = await this.git.originBranchExists(worktreePath);
-            if (hasOriginBranch) {
-                // Compare against origin branch
-                const isAhead = await this.git.isAheadOfOrigin(worktreePath);
-                const isBehind = await this.git.isBehindOrigin(worktreePath);
-                if (isAhead && isBehind) {
-                    return { type: 'diverged', comparedTo: 'origin' };
-                }
-                if (isAhead) {
-                    return { type: 'ahead', comparedTo: 'origin' };
-                }
-                if (isBehind) {
-                    return { type: 'behind', comparedTo: 'origin' };
-                }
-                return { type: 'clean', comparedTo: 'origin' };
-            }
-            // No origin branch, compare against main
-            const isAhead = await this.git.isAheadOfMain(worktreePath, mainBranch);
+            // Compare against base branch using git cherry (handles squash merges)
+            const isAhead = await this.git.isAheadOfMain(worktreePath, baseBranch);
             if (isAhead) {
                 return { type: 'ahead', comparedTo: 'main' };
             }
@@ -44,37 +27,30 @@ export class StatusService {
             };
         }
     }
-    static getStatusMessage(status, mainBranch) {
+    static getStatusMessage(status, baseBranch) {
         switch (status.type) {
             case 'clean':
                 return 'up to date';
             case 'uncommitted':
                 return 'uncommitted changes';
             case 'ahead':
-                return status.comparedTo === 'origin'
-                    ? 'ahead of origin'
-                    : `ahead of ${mainBranch}`;
-            case 'behind':
-                return 'behind origin';
-            case 'diverged':
-                return 'diverged from origin';
+                return `ahead of ${baseBranch}`;
             case 'error':
                 return `error: ${status.error}`;
         }
     }
     static hasIssues(status) {
         return (status.type === 'uncommitted' ||
-            status.type === 'ahead' ||
-            status.type === 'diverged' ||
             status.type === 'error');
     }
     /**
      * Check status of all worktrees in parallel
      */
-    async checkAllWorktrees(worktreeDirs, mainBranch) {
+    async checkAllWorktrees(worktreeDirs, getBaseBranch) {
         const results = await Promise.all(worktreeDirs.map(async (worktreePath) => {
             const repoName = worktreePath.split('/').pop() || worktreePath;
-            const status = await this.getWorktreeStatus(worktreePath, mainBranch);
+            const baseBranch = getBaseBranch(repoName);
+            const status = await this.getWorktreeStatus(worktreePath, baseBranch);
             return { repoName, status };
         }));
         return results;
@@ -82,8 +58,8 @@ export class StatusService {
     /**
      * Find repos with issues (for removal validation)
      */
-    async findReposWithIssues(worktreeDirs, mainBranch) {
-        const results = await this.checkAllWorktrees(worktreeDirs, mainBranch);
+    async findReposWithIssues(worktreeDirs, getBaseBranch) {
+        const results = await this.checkAllWorktrees(worktreeDirs, getBaseBranch);
         return results
             .filter(({ status }) => StatusService.hasIssues(status))
             .map(({ repoName }) => repoName);

package/dist/lib/workspaceConfig.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { z } from 'zod';
+// Schema for workspace config
+const WorkspaceConfigSchema = z.object({
+    baseBranches: z.record(z.string(), z.string()),
+});
+/**
+ * WorkspaceConfigService manages flow-config.json files in workspace directories.
+ * These files track the base branch used for each repository in a workspace.
+ */
+export class WorkspaceConfigService {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    getConfigPath(workspacePath) {
+        return path.join(workspacePath, 'flow-config.json');
+    }
+    exists(workspacePath) {
+        const configPath = this.getConfigPath(workspacePath);
+        return this.fs.existsSync(configPath);
+    }
+    load(workspacePath) {
+        const configPath = this.getConfigPath(workspacePath);
+        if (!this.fs.existsSync(configPath)) {
+            return { baseBranches: {} };
+        }
+        const raw = this.fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return WorkspaceConfigSchema.parse(parsed);
+    }
+    save(workspacePath, config) {
+        const configPath = this.getConfigPath(workspacePath);
+        const validated = WorkspaceConfigSchema.parse(config);
+        this.fs.writeFileSync(configPath, JSON.stringify(validated, null, 2) + '\n');
+    }
+    getBaseBranch(workspacePath, repoName) {
+        const config = this.load(workspacePath);
+        return config.baseBranches[repoName] || 'master';
+    }
+}

package/dist/usecases/checkWorkspaceStatus.js

@@ -3,14 +3,19 @@
  */
 export class CheckWorkspaceStatusUseCase {
     workspaceDir;
+    workspaceConfig;
     status;
-    constructor(workspaceDir, status) {
+    constructor(workspaceDir, workspaceConfig, status) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
         const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
-        const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+        // Load workspace config to get per-repo base branches
+        const config = this.workspaceConfig.load(params.workspacePath);
+        const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
+        const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
         return { statuses };
     }
 }

package/dist/usecases/checkoutWorkspace.js

@@ -7,15 +7,19 @@ import { NoReposFoundError } from '../lib/errors.js';
  */
 export class CheckoutWorkspaceUseCase {
     workspaceDir;
+    workspaceConfig;
     worktree;
     repos;
+    git;
     parallel;
     tmux;
     postCheckout;
-    constructor(workspaceDir, worktree, repos, parallel, tmux, postCheckout) {
+    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, postCheckout) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
         this.repos = repos;
+        this.git = git;
         this.parallel = parallel;
         this.tmux = tmux;
         this.postCheckout = postCheckout;
@@ -43,7 +47,16 @@ export class CheckoutWorkspaceUseCase {
         });
         // 5. Copy AGENTS.md
         this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
-        // 6. Create tmux session if enabled
+        // 6. Detect base branches for each repo
+        const baseBranches = {};
+        for (const repoPath of matching) {
+            const repoName = RepoService.getRepoName(repoPath);
+            const baseBranch = await this.git.findFirstExistingBranch(repoPath, ['master', 'main', 'trunk', 'develop']);
+            baseBranches[repoName] = baseBranch || 'master';
+        }
+        // 7. Save workspace config with base branches
+        this.workspaceConfig.save(workspacePath, { baseBranches });
+        // 8. Create tmux session if enabled
         let tmuxCreated = false;
         if (params.tmux) {
             try {
@@ -55,7 +68,7 @@ export class CheckoutWorkspaceUseCase {
                 // Don't fail
             }
         }
-        // 7. Run post-checkout if configured
+        // 9. Run post-checkout if configured
         let postCheckoutResult;
         if (params.postCheckout || params.perRepoPostCheckout) {
             const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);

package/dist/usecases/createBranchWorkspace.js

@@ -6,15 +6,19 @@ import { RepoService } from '../lib/repos.js';
  */
 export class CreateBranchWorkspaceUseCase {
     workspaceDir;
+    workspaceConfig;
     worktree;
     repos;
+    git;
     parallel;
     tmux;
     postCheckout;
-    constructor(workspaceDir, worktree, repos, parallel, tmux, postCheckout) {
+    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, postCheckout) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
         this.repos = repos;
+        this.git = git;
         this.parallel = parallel;
         this.tmux = tmux;
         this.postCheckout = postCheckout;
@@ -22,17 +26,34 @@ export class CreateBranchWorkspaceUseCase {
     async execute(params) {
         // 1. Create workspace directory
         const workspacePath = this.workspaceDir.createWorkspaceDir(params.destPath, params.branchName);
+        // Track base branches for each repo
+        const baseBranches = {};
         // 2. Create worktrees in parallel
         const successCount = await this.parallel.processInParallel(params.repos, (repoPath) => RepoService.getRepoName(repoPath), async (repoPath) => {
             const name = RepoService.getRepoName(repoPath);
             const worktreeDest = path.join(workspacePath, name);
-            await this.worktree.createWorktreeWithBranch(repoPath, worktreeDest, params.branchName, params.sourceBranch);
+            // Determine which base branch to use
+            let actualBaseBranch = params.sourceBranch;
+            // Try the user-specified source branch first, fall back if it doesn't exist
+            const branchExists = await this.git.localRemoteBranchExists(repoPath, params.sourceBranch);
+            if (!branchExists) {
+                const fallbackBranch = await this.git.findFirstExistingBranch(repoPath, ['master', 'main', 'trunk', 'develop']);
+                if (fallbackBranch) {
+                    actualBaseBranch = fallbackBranch;
+                }
+                // If no fallback found, still try with the original (will fail with clear error)
+            }
+            // Track the actual base branch used
+            baseBranches[name] = actualBaseBranch;
+            await this.worktree.createWorktreeWithBranch(repoPath, worktreeDest, params.branchName, `origin/${actualBaseBranch}`);
             this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
             return 'created';
         });
         // 3. Copy AGENTS.md if exists
         this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
-        // 4. Create tmux session if enabled
+        // 4. Save workspace config with base branches
+        this.workspaceConfig.save(workspacePath, { baseBranches });
+        // 5. Create tmux session if enabled
         let tmuxCreated = false;
         if (params.tmux) {
             try {
@@ -44,7 +65,7 @@ export class CreateBranchWorkspaceUseCase {
                 // Don't fail, just return false
             }
         }
-        // 5. Run post-checkout command if configured
+        // 6. Run post-checkout command if configured
         let postCheckoutResult;
         if (params.postCheckout || params.perRepoPostCheckout) {
             const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);

package/dist/usecases/discoverPrunableWorkspaces.js

@@ -5,10 +5,12 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class DiscoverPrunableWorkspacesUseCase {
     workspaceDir;
+    workspaceConfig;
     status;
     git;
-    constructor(workspaceDir, status, git) {
+    constructor(workspaceDir, workspaceConfig, status, git) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.status = status;
         this.git = git;
     }
@@ -23,8 +25,11 @@ export class DiscoverPrunableWorkspacesUseCase {
             if (!worktreeDirs || worktreeDirs.length === 0) {
                 continue;
             }
+            // Load workspace config to get per-repo base branches
+            const config = this.workspaceConfig.load(workspace.path);
+            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
             // Check status for all worktrees
-            const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
             // Skip if any worktree has issues
             const hasAnyIssues = statuses.some(({ status }) => StatusServiceClass.hasIssues(status));
             if (hasAnyIssues) {

package/dist/usecases/listWorkspacesWithStatus.js

@@ -4,9 +4,11 @@
  */
 export class ListWorkspacesWithStatusUseCase {
     workspaceDir;
+    workspaceConfig;
     status;
-    constructor(workspaceDir, status) {
+    constructor(workspaceDir, workspaceConfig, status) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
@@ -24,8 +26,11 @@ export class ListWorkspacesWithStatusUseCase {
             }
             // Check if this workspace is active (contains current working directory)
             const isActive = this.workspaceDir.detectWorkspace(params.cwd, params.destPath) === workspace.path;
+            // Load workspace config to get per-repo base branches
+            const config = this.workspaceConfig.load(workspace.path);
+            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
             // Check status for all worktrees
-            const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
             workspacesWithStatus.push({
                 name: workspace.name,
                 path: workspace.path,

package/dist/usecases/removeWorkspace.js

@@ -7,12 +7,14 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class RemoveWorkspaceUseCase {
     workspaceDir;
+    workspaceConfig;
     worktree;
     repos;
     status;
     tmux;
-    constructor(workspaceDir, worktree, repos, status, tmux) {
+    constructor(workspaceDir, workspaceConfig, worktree, repos, status, tmux) {
         this.workspaceDir = workspaceDir;
+        this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
         this.repos = repos;
         this.status = status;
@@ -23,17 +25,21 @@ export class RemoveWorkspaceUseCase {
         const issuesFound = [];
         // 1. Check status if worktrees exist
         if (worktreeDirs.length > 0) {
-            const results = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            // Load workspace config to get per-repo base branches
+            const config = this.workspaceConfig.load(params.workspacePath);
+            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
+            const results = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
             for (const { repoName, status } of results) {
                 if (StatusServiceClass.hasIssues(status)) {
+                    const baseBranch = getBaseBranch(repoName);
                     issuesFound.push({
                         repoName,
-                        issue: StatusServiceClass.getStatusMessage(status, params.mainBranch),
+                        issue: StatusServiceClass.getStatusMessage(status, baseBranch),
                     });
                 }
             }
             if (issuesFound.length > 0) {
-                throw new WorkspaceHasIssuesError(`${issuesFound.length} repo(s) have uncommitted or unmerged changes.`);
+                throw new WorkspaceHasIssuesError(`${issuesFound.length} repo(s) have uncommitted changes or errors.`);
             }
         }
         // 2. Remove all worktrees

package/dist/usecases/usecases.js

@@ -19,14 +19,14 @@ export function createUseCases(services) {
         fetchAllRepos: new FetchAllReposUseCase(services.fetch, services.repos),
         fetchWorkspaceRepos: new FetchWorkspaceReposUseCase(services.workspaceDir, services.fetch),
         fetchUsedRepos: new FetchUsedReposUseCase(services.workspaceDir, services.fetch),
-        createBranchWorkspace: new CreateBranchWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.parallel, services.tmux, services.postCheckout),
-        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.parallel, services.tmux, services.postCheckout),
-        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.status, services.tmux),
+        createBranchWorkspace: new CreateBranchWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, services.postCheckout),
+        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, services.postCheckout),
+        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.status, services.tmux),
         pushWorkspace: new PushWorkspaceUseCase(services.workspaceDir, services.git, services.parallel),
         pullWorkspace: new PullWorkspaceUseCase(services.workspaceDir, services.git, services.parallel),
-        checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.status),
-        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.status, services.git),
-        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.status),
+        checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.workspaceConfig, services.status),
+        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.workspaceConfig, services.status, services.git),
+        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.workspaceConfig, services.status),
         resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux),
     };
 }

package/package.json

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