worktree-flow 0.0.7 → 0.0.9

package/README.md

@@ -4,6 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/worktree-flow)](https://www.npmjs.com/package/worktree-flow)
 [![npm downloads](https://img.shields.io/npm/dm/worktree-flow)](https://www.npmjs.com/package/worktree-flow)
+[![Build](https://github.com/simonpratt/worktree-flow/actions/workflows/build.yml/badge.svg)](https://github.com/simonpratt/worktree-flow/actions/workflows/build.yml)
 [![license](https://img.shields.io/npm/l/worktree-flow)](https://github.com/simonpratt/worktree-flow/blob/master/LICENSE)
 
 Stop juggling branches across repos. `flow` creates isolated workspaces with git worktrees from multiple repositories, all on the same branch, with a single command.
@@ -72,10 +73,10 @@ 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>`
 
@@ -85,6 +86,12 @@ Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted
 
 Remove stale workspaces in bulk. Finds workspaces where all worktrees are clean, fully merged, and haven't been committed to in over 7 days.
 
+### `flow tmux resume`
+
+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) using a tiled layout. Skips workspaces that already have active sessions.
+
+Requires `tmux` to be installed and the `tmux` config option to be enabled.
+
 ### `flow config set <key> <value>`
 
 Configure flow settings. See [Configuration](#configuration) below.

package/dist/cli.js

@@ -10,6 +10,7 @@ import { registerRemoveCommand } from './commands/remove.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerPruneCommand } from './commands/prune.js';
 import { registerFetchCommand } from './commands/fetch.js';
+import { registerTmuxCommand } from './commands/tmux.js';
 const program = new Command();
 program
     .name('flow')
@@ -25,4 +26,5 @@ registerRemoveCommand(program);
 registerStatusCommand(program);
 registerPruneCommand(program);
 registerFetchCommand(program);
+registerTmuxCommand(program);
 program.parse();

package/dist/commands/config.js

@@ -45,6 +45,16 @@ export function registerConfigCommand(program) {
             const displayValue = isDefault ? chalk.gray(value) : chalk.green(value);
             services.console.log(`  ${chalk.cyan(key)}: ${displayValue}`);
         }
+        // Display per-repo post-checkout commands
+        const perRepoCommands = displayConfig.perRepoPostCheckout;
+        if (Object.keys(perRepoCommands).length > 0) {
+            services.console.log('');
+            services.console.log(chalk.bold('Per-repo post-checkout commands:'));
+            services.console.log('');
+            for (const [repo, command] of Object.entries(perRepoCommands)) {
+                services.console.log(`  ${chalk.cyan(repo)}: ${chalk.green(command)}`);
+            }
+        }
         services.console.log('');
     });
 }

package/dist/commands/list.js

@@ -57,7 +57,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

@@ -16,14 +16,13 @@ export async function runPrune(useCases, services, deps) {
     const result = await useCases.discoverPrunableWorkspaces.execute({
         destPath,
         sourcePath,
-        mainBranch: config.mainBranch,
         daysOld: 7,
     });
     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(`  - All worktrees are not ahead of their base branch`);
         services.console.log(`  - Last commit is more than 7 days old`);
         services.process.exit(0);
     }
@@ -56,7 +55,6 @@ export async function runPrune(useCases, services, deps) {
                 workspacePath: workspace.path,
                 branchName: workspace.name,
                 sourcePath,
-                mainBranch: config.mainBranch,
                 tmux: config.tmux,
             });
             services.console.log(`  ${chalk.green('✓')} Removed ${workspace.name}`);

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 and commits ahead of base branch...`);
+        // 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/commands/tmux.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import { createServices } from '../lib/services.js';
+import { createUseCases } from '../usecases/usecases.js';
+export async function runTmuxResume(useCases, services) {
+    const { destPath } = services.config.getRequired();
+    const result = await useCases.resumeTmuxSessions.execute({ destPath });
+    if (result.totalWorkspaces === 0) {
+        services.console.log('No workspaces found.');
+        return;
+    }
+    // Display results
+    if (result.sessionsCreated > 0) {
+        services.console.log(chalk.green(`✓ Created ${result.sessionsCreated} tmux session${result.sessionsCreated === 1 ? '' : 's'}`));
+    }
+    if (result.sessionsSkipped > 0) {
+        services.console.log(chalk.blue(`○ Skipped ${result.sessionsSkipped} existing session${result.sessionsSkipped === 1 ? '' : 's'}`));
+    }
+    if (result.errors.length > 0) {
+        services.console.log(chalk.red('\nErrors:'));
+        for (const error of result.errors) {
+            services.console.log(chalk.red(`  ${error.workspace}: ${error.error}`));
+        }
+    }
+    // Summary
+    services.console.log(chalk.dim(`\nTotal: ${result.totalWorkspaces} workspace${result.totalWorkspaces === 1 ? '' : 's'}`));
+}
+export function registerTmuxCommand(program) {
+    const tmuxCommand = program
+        .command('tmux')
+        .description('Manage tmux sessions for workspaces');
+    tmuxCommand
+        .command('resume')
+        .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);
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

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'],
@@ -142,6 +134,7 @@ export class ConfigService {
                 value: raw['fetch-cache-ttl-seconds'] ?? `${config.fetchCacheTtlSeconds} (default)`,
                 isDefault: !raw['fetch-cache-ttl-seconds'],
             },
+            perRepoPostCheckout: config.perRepoPostCheckout,
         };
     }
 }

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,20 +27,14 @@ 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}`;
         }
@@ -65,16 +42,16 @@ export class StatusService {
     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 +59,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, 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,12 +25,16 @@ 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),
                     });
                 }
             }

package/dist/usecases/resumeTmuxSessions.js

@@ -0,0 +1,47 @@
+/**
+ * Use case for resuming tmux sessions across all workspaces.
+ * Creates sessions for workspaces that don't already have one.
+ */
+export class ResumeTmuxSessionsUseCase {
+    workspaceDir;
+    tmux;
+    constructor(workspaceDir, tmux) {
+        this.workspaceDir = workspaceDir;
+        this.tmux = tmux;
+    }
+    async execute(params) {
+        // 1. List all workspaces
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        let sessionsCreated = 0;
+        let sessionsSkipped = 0;
+        const errors = [];
+        // 2. Try to create tmux session for each workspace
+        for (const workspace of workspaces) {
+            try {
+                const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
+                // Try to create session - will throw on duplicate session
+                await this.tmux.createSession(workspace.path, workspace.name, worktreeDirs);
+                sessionsCreated++;
+            }
+            catch (error) {
+                // Check if session already exists
+                if (error.message?.includes('duplicate session')) {
+                    sessionsSkipped++;
+                }
+                else {
+                    // Other error
+                    errors.push({
+                        workspace: workspace.name,
+                        error: error.message || 'Unknown error',
+                    });
+                }
+            }
+        }
+        return {
+            totalWorkspaces: workspaces.length,
+            sessionsCreated,
+            sessionsSkipped,
+            errors,
+        };
+    }
+}

package/dist/usecases/usecases.js

@@ -9,6 +9,7 @@ import { ListWorkspacesWithStatusUseCase } from './listWorkspacesWithStatus.js';
 import { FetchAllReposUseCase } from './fetchAllRepos.js';
 import { FetchWorkspaceReposUseCase } from './fetchWorkspaceRepos.js';
 import { FetchUsedReposUseCase } from './fetchUsedRepos.js';
+import { ResumeTmuxSessionsUseCase } from './resumeTmuxSessions.js';
 /**
  * Factory function for creating all use cases with their service dependencies.
  * Use cases orchestrate workflows by coordinating multiple services.
@@ -18,13 +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.7",
+  "version": "0.0.9",
   "description": "Manage git worktrees across a poly-repo environment",
   "type": "module",
   "bin": {