worktree-flow 0.0.19 → 0.0.21

package/dist/adapters/node.js

@@ -24,6 +24,9 @@ export class NodeFileSystem {
     copyFileSync(src, dest) {
         fs.copyFileSync(src, dest);
     }
+    cpSync(src, dest, options) {
+        fs.cpSync(src, dest, options);
+    }
     rmSync(path, options) {
         fs.rmSync(path, options);
     }

package/dist/cli.js

@@ -19,18 +19,23 @@ program
     .name('flow')
     .description('Manage git worktrees across a poly-repo environment')
     .version('0.1.0');
+// Getting Started
+registerQuickstartCommand(program);
 registerConfigCommand(program);
+// Workspaces
 registerCreateCommand(program);
-registerAttachCommand(program);
-registerBranchCommand(program);
 registerCheckoutCommand(program);
 registerListCommand(program);
-registerPullCommand(program);
-registerPushCommand(program);
+registerAttachCommand(program);
 registerDropCommand(program);
-registerStatusCommand(program);
 registerPruneCommand(program);
+// Git Operations
+registerStatusCommand(program);
+registerPullCommand(program);
+registerPushCommand(program);
 registerFetchCommand(program);
+// Extras
 registerTmuxCommand(program);
-registerQuickstartCommand(program);
+// Deprecated
+registerBranchCommand(program);
 program.parse();

package/dist/commands/attach.js

@@ -105,6 +105,7 @@ export async function runAttach(branchName, useCases, services, deps) {
 export function registerAttachCommand(program) {
     program
         .command('attach [branch-name]')
+        .helpGroup('Workspaces')
         .description('Attach repos to an existing workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/branch.js

@@ -3,6 +3,7 @@ import { createServices } from '../lib/services.js';
 export function registerBranchCommand(program) {
     program
         .command('branch <branch-name>')
+        .helpGroup('Deprecated')
         .description(chalk.dim('Deprecated: use "flow create <branch-name>" instead'))
         .action(async () => {
         const services = createServices();

package/dist/commands/checkout.js

@@ -6,16 +6,9 @@ import { createUseCases } from '../usecases/usecases.js';
 export async function runCheckout(branchName, useCases, services, deps) {
     const { sourcePath, destPath } = services.config.getRequired();
     const config = services.config.load();
-    let shouldRunPostCheckout = false;
-    if (config.postCheckout) {
-        shouldRunPostCheckout = await deps.confirm({
-            message: `Run "${config.postCheckout}" in all workspaces?`,
-            default: true,
-        });
-    }
-    services.console.log('\nChecking for branch...');
     try {
         // 1. Fetch all repos from source-path
+        services.console.log('\nFetching repos...');
         await useCases.fetchAllRepos.execute({
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
@@ -25,7 +18,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
             sourcePath,
             branchName,
         });
-        // 3. Display per-repo branch check results
+        // 3. Display only repos that have changes (matching or errored)
         for (const checkResult of discoverResult.branchCheckResults) {
             if (checkResult.error) {
                 services.console.log(`${checkResult.repoName}... ${chalk.red(`error: ${checkResult.error}`)}`);
@@ -33,15 +26,20 @@ export async function runCheckout(branchName, useCases, services, deps) {
             else if (checkResult.hasBranch) {
                 services.console.log(`${checkResult.repoName}... ${chalk.green('found')}`);
             }
-            else {
-                services.console.log(`${checkResult.repoName}... ${chalk.dim('no branch')}`);
-            }
         }
         // 4. Throw error if no repos match
         if (discoverResult.matchingRepos.length === 0) {
             throw new Error(`Branch "${branchName}" not found in any repo.`);
         }
-        // 5. Create workspace directory, placeholder config, AGENTS.md, tmux session
+        // 5. Prompt for post-checkout
+        let shouldRunPostCheckout = false;
+        if (config.postCheckout) {
+            shouldRunPostCheckout = await deps.confirm({
+                message: `Run "${config.postCheckout}" in all workspaces?`,
+                default: true,
+            });
+        }
+        // 6. Create workspace directory, placeholder config, AGENTS.md, tmux session
         const workspaceResult = await useCases.createWorkspace.execute({
             branchName,
             sourcePath,
@@ -50,7 +48,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
         });
         const { workspacePath, tmuxCreated } = workspaceResult;
         const sessionName = tmuxCreated ? branchName : undefined;
-        // 6. For each matching repo in parallel: detect base branch, then addToWorkspace
+        // 7. For each matching repo in parallel: detect base branch, then addToWorkspace
         const results = await Promise.allSettled(discoverResult.matchingRepos.map(async (repoPath) => {
             const repoName = path.basename(repoPath);
             // Resolve per-repo post-checkout command
@@ -80,7 +78,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
             .filter((r) => r.postCheckoutRan);
         const postCheckoutSuccess = postCheckoutResults.filter((r) => r.postCheckoutSuccess).length;
         const postCheckoutTotal = postCheckoutResults.length;
-        // 7. Display results
+        // 8. 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)}`);
@@ -101,6 +99,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
 export function registerCheckoutCommand(program) {
     program
         .command('checkout <branch-name>')
+        .helpGroup('Workspaces')
         .description('Checkout an existing branch across repos')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/config.js

@@ -5,6 +5,7 @@ import { createServices } from '../lib/services.js';
 export function registerConfigCommand(program) {
     const configCmd = program
         .command('config')
+        .helpGroup('Getting Started')
         .description('Manage flow configuration');
     configCmd
         .command('set <key> <value>')

package/dist/commands/create.js

@@ -103,6 +103,7 @@ export async function runCreate(branchName, useCases, services, deps) {
 export function registerCreateCommand(program) {
     program
         .command('create <branch-name>')
+        .helpGroup('Workspaces')
         .description('Create branches and worktrees for selected repos')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/drop.js

@@ -29,10 +29,8 @@ export async function runDrop(branchName, useCases, services, deps) {
         const statusResult = await useCases.checkWorkspaceStatus.execute({
             workspacePath,
         });
-        // Load workspace config to get per-repo base branches
-        const workspaceConfig = services.workspaceConfig.load(workspacePath);
         // 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);
+        logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: statusResult.statuses }], loadingLines, 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) {
@@ -95,6 +93,7 @@ export async function runDrop(branchName, useCases, services, deps) {
 export function registerDropCommand(program) {
     program
         .command('drop [branch-name]')
+        .helpGroup('Workspaces')
         .description('Drop a workspace and all its worktrees (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/fetch.js

@@ -28,6 +28,7 @@ export async function runFetch(branchName, useCases, services) {
 export function registerFetchCommand(program) {
     program
         .command('fetch [branch-name]')
+        .helpGroup('Git Operations')
         .description('Fetch repos (workspace-scoped if branch provided, all workspaces otherwise)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/helpers.js

@@ -3,15 +3,11 @@ import { StatusService } from '../lib/status.js';
 /**
  * Format a single repo's status as a display line, consistent across list and status commands.
  */
-export function formatRepoStatusLine(repoName, status, baseBranch) {
-    const statusMessage = StatusService.getStatusMessage(status, baseBranch);
+export function formatRepoStatusLine(repoName, status) {
+    const statusMessage = StatusService.getStatusMessage(status);
     const hasIssues = StatusService.hasIssues(status);
-    const indicator = hasIssues ? chalk.red('✗') : chalk.green('✓');
     const message = hasIssues ? chalk.red(statusMessage) : chalk.green(statusMessage);
-    const trackingInfo = status.upstreamBranch
-        ? chalk.dim(` → ${status.upstreamBranch}`)
-        : chalk.dim(' (no upstream)');
-    return `    ${indicator} ${chalk.yellow(repoName)}: ${message}${trackingInfo}`;
+    return `    ${chalk.yellow(repoName)}: ${message}`;
 }
 /**
  * Render Phase 1: print a header and workspace rows with a "fetching..." indicator.
@@ -30,7 +26,7 @@ export function logStatusFetching(header, workspaces, console) {
 /**
  * Render Phase 2: clear the Phase 1 lines then print the header and full workspace status.
  */
-export function logStatus(header, workspaces, linesToClear, getBaseBranch, console) {
+export function logStatus(header, workspaces, linesToClear, console) {
     for (let i = 0; i < linesToClear; i++) {
         console.write('\x1b[1A'); // Move cursor up one line
         console.write('\x1b[2K'); // Clear entire line
@@ -41,8 +37,7 @@ export function logStatus(header, workspaces, linesToClear, getBaseBranch, conso
         const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
         console.log(`${activeIndicator}${chalk.cyan(workspace.name)} ${repoCount}`);
         for (const { repoName, status } of workspace.statuses) {
-            const baseBranch = getBaseBranch(workspace.path, repoName);
-            console.log(formatRepoStatusLine(repoName, status, baseBranch));
+            console.log(formatRepoStatusLine(repoName, status));
         }
         console.log('');
     }

package/dist/commands/list.js

@@ -27,12 +27,13 @@ export async function runList(useCases, services) {
         cwd,
     });
     // Phase 4: Clear previous output and re-print with full status
-    logStatus('Workspaces:', result.workspaces, loadingLines, (wsPath, repoName) => services.workspaceConfig.load(wsPath).baseBranches[repoName] || 'master', services.console);
+    logStatus('Workspaces:', result.workspaces, loadingLines, services.console);
 }
 export function registerListCommand(program) {
     program
         .command('list')
         .alias('ls')
+        .helpGroup('Workspaces')
         .description('List all workspaces with status indicators')
         .action(async () => {
         const services = createServices();

package/dist/commands/prune.js

@@ -31,15 +31,15 @@ export async function runPrune(useCases, services, deps) {
         cwd,
     });
     // 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);
+    logStatus('Workspaces:', result.workspaces, loadingLines, 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 hasDirty = ws.statuses.some(s => s.status.type === 'dirty');
         const hasError = ws.statuses.some(s => s.status.type === 'error');
-        const reason = hasUncommitted ? 'uncommitted changes' : hasError ? 'errors' : 'issues';
+        const reason = hasDirty ? 'uncommitted changes' : hasError ? 'errors' : 'issues';
         services.console.log(`${chalk.yellow('⚠')} Skipping ${chalk.cyan(ws.name)} (${reason})`);
     }
     // Newline if there were skipped workspaces
@@ -112,6 +112,7 @@ export async function runPrune(useCases, services, deps) {
 export function registerPruneCommand(program) {
     program
         .command('prune')
+        .helpGroup('Workspaces')
         .description('Select and remove workspaces')
         .action(async () => {
         const services = createServices();

package/dist/commands/pull.js

@@ -16,6 +16,7 @@ export async function runPull(branchName, useCases, services) {
 export function registerPullCommand(program) {
     program
         .command('pull [branch-name]')
+        .helpGroup('Git Operations')
         .description('Pull all repos in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/push.js

@@ -16,6 +16,7 @@ export async function runPush(branchName, useCases, services) {
 export function registerPushCommand(program) {
     program
         .command('push [branch-name]')
+        .helpGroup('Git Operations')
         .description('Push all repos in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/quickstart.js

@@ -143,6 +143,7 @@ export async function runQuickstart(services, deps) {
 export function registerQuickstartCommand(program) {
     program
         .command('quickstart')
+        .helpGroup('Getting Started')
         .description('Interactive setup wizard for first-time configuration')
         .action(async () => {
         const services = createServices();

package/dist/commands/status.js

@@ -26,14 +26,13 @@ export async function runStatus(branchName, useCases, services) {
     const result = await useCases.checkWorkspaceStatus.execute({
         workspacePath,
     });
-    // Load workspace config to get per-repo base branches
-    const workspaceConfig = services.workspaceConfig.load(workspacePath);
     // Phase 2: Clear Phase 1 lines and re-render with full status
-    logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: result.statuses }], loadingLines, (_, repoName) => workspaceConfig.baseBranches[repoName] || 'master', services.console);
+    logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: result.statuses }], loadingLines, services.console);
 }
 export function registerStatusCommand(program) {
     program
         .command('status [branch-name]')
+        .helpGroup('Git Operations')
         .description('Show status of all worktrees in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/tmux.js

@@ -27,6 +27,7 @@ export async function runTmuxSync(useCases, services) {
 export function registerTmuxCommand(program) {
     const tmuxCommand = program
         .command('tmux')
+        .helpGroup('Extras')
         .description('Manage tmux sessions for workspaces');
     tmuxCommand
         .command('sync')

package/dist/lib/git.js

@@ -36,6 +36,15 @@ export class GitService {
             }
         }
     }
+    async remoteTrackingBranchExists(repoPath, branch) {
+        try {
+            await this.exec(repoPath, ['rev-parse', '--verify', `origin/${branch}`]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async findFirstExistingBranch(repoPath, candidates) {
         for (const branch of candidates) {
             const exists = await this.localRemoteBranchExists(repoPath, branch);
@@ -76,55 +85,36 @@ export class GitService {
             return null;
         }
     }
-    async hasUncommittedChanges(repoPath) {
+    async getStatusCounts(repoPath) {
         const output = await this.exec(repoPath, ['status', '--porcelain']);
-        return output.length > 0;
-    }
-    async originBranchExists(repoPath) {
-        try {
-            const branch = await this.getCurrentBranch(repoPath);
-            await this.exec(repoPath, ['rev-parse', '--verify', `origin/${branch}`]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async isAheadOfOrigin(repoPath) {
-        try {
-            const branch = await this.getCurrentBranch(repoPath);
-            const output = await this.exec(repoPath, ['rev-list', '--count', `origin/${branch}..HEAD`]);
-            return parseInt(output, 10) > 0;
-        }
-        catch {
-            return false;
+        const lines = output.split('\n').filter(line => line.length > 0);
+        let untracked = 0;
+        let uncommitted = 0;
+        for (const line of lines) {
+            if (line.startsWith('??')) {
+                untracked++;
+            }
+            else {
+                uncommitted++;
+            }
         }
+        return { untracked, uncommitted };
     }
-    async isBehindOrigin(repoPath) {
+    async getUnpushedCommitCount(repoPath) {
         try {
             const branch = await this.getCurrentBranch(repoPath);
-            const output = await this.exec(repoPath, ['rev-list', '--count', `HEAD..origin/${branch}`]);
-            return parseInt(output, 10) > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async isAheadOfMain(repoPath, mainBranch) {
-        try {
-            // 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;
+            try {
+                const output = await this.exec(repoPath, ['rev-list', '--count', `origin/${branch}..HEAD`]);
+                return parseInt(output.trim(), 10);
+            }
+            catch {
+                // origin/<branch> doesn't exist yet — count commits not reachable from any remote ref
+                const output = await this.exec(repoPath, ['rev-list', '--count', 'HEAD', '--not', '--remotes']);
+                return parseInt(output.trim(), 10);
+            }
         }
         catch {
-            // If we can't determine, assume there are changes to be safe
-            return true;
+            return 0;
         }
     }
     async createBranch(repoPath, branchName, startPoint) {

package/dist/lib/status.js

@@ -6,54 +6,56 @@ export class StatusService {
     constructor(git) {
         this.git = git;
     }
-    async getWorktreeStatus(worktreePath, baseBranch) {
+    async getWorktreeStatus(worktreePath) {
         try {
-            // Get branch information
             const currentBranch = await this.git.getCurrentBranch(worktreePath);
             const upstreamBranch = await this.git.getUpstreamBranch(worktreePath);
-            // Check for uncommitted changes first
-            const hasUncommitted = await this.git.hasUncommittedChanges(worktreePath);
-            if (hasUncommitted) {
-                return { type: 'uncommitted', currentBranch, upstreamBranch };
-            }
-            // 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', currentBranch, upstreamBranch };
-            }
-            return { type: 'clean', comparedTo: 'main', currentBranch, upstreamBranch };
+            const { untracked, uncommitted } = await this.git.getStatusCounts(worktreePath);
+            const unpushed = await this.git.getUnpushedCommitCount(worktreePath);
+            const type = untracked > 0 || uncommitted > 0 ? 'dirty' : 'clean';
+            return { type, untracked, uncommitted, unpushed, currentBranch, upstreamBranch };
         }
         catch (err) {
             return {
                 type: 'error',
+                untracked: 0,
+                uncommitted: 0,
+                unpushed: 0,
                 error: err.stderr || err.message,
             };
         }
     }
-    static getStatusMessage(status, baseBranch) {
-        switch (status.type) {
-            case 'clean':
-                return 'up to date';
-            case 'uncommitted':
-                return 'uncommitted changes';
-            case 'ahead':
-                return `ahead of ${baseBranch}`;
-            case 'error':
-                return `error: ${status.error}`;
+    static getStatusMessage(status) {
+        if (status.type === 'error') {
+            return `error: ${status.error}`;
         }
+        if (status.type === 'clean' && status.unpushed === 0) {
+            return 'clean';
+        }
+        const parts = [];
+        if (status.untracked > 0) {
+            parts.push(`${status.untracked} untracked`);
+        }
+        if (status.uncommitted > 0) {
+            parts.push(`${status.uncommitted} modified`);
+        }
+        if (status.unpushed > 0) {
+            parts.push(`${status.unpushed} unpushed commit${status.unpushed === 1 ? '' : 's'}`);
+        }
+        return parts.length > 0 ? parts.join(', ') : 'clean';
     }
     static hasIssues(status) {
-        return (status.type === 'uncommitted' ||
+        return (status.untracked > 0 ||
+            status.uncommitted > 0 ||
             status.type === 'error');
     }
     /**
      * Check status of all worktrees in parallel
      */
-    async checkAllWorktrees(worktreeDirs, getBaseBranch) {
+    async checkAllWorktrees(worktreeDirs) {
         const results = await Promise.all(worktreeDirs.map(async (worktreePath) => {
             const repoName = worktreePath.split('/').pop() || worktreePath;
-            const baseBranch = getBaseBranch(repoName);
-            const status = await this.getWorktreeStatus(worktreePath, baseBranch);
+            const status = await this.getWorktreeStatus(worktreePath);
             return { repoName, status };
         }));
         return results;
@@ -61,8 +63,8 @@ export class StatusService {
     /**
      * Find repos with issues (for removal validation)
      */
-    async findReposWithIssues(worktreeDirs, getBaseBranch) {
-        const results = await this.checkAllWorktrees(worktreeDirs, getBaseBranch);
+    async findReposWithIssues(worktreeDirs) {
+        const results = await this.checkAllWorktrees(worktreeDirs);
         return results
             .filter(({ status }) => StatusService.hasIssues(status))
             .map(({ repoName }) => repoName);

package/dist/lib/tmux.js

@@ -54,18 +54,14 @@ export class TmuxService {
         ]);
     }
     async addPane(sessionName, worktreePath) {
-        await this.shell.execFile('tmux', [
+        const { stdout } = await this.shell.execFile('tmux', [
             'split-window',
             '-t',
             sessionName,
             '-c',
             worktreePath,
-        ]);
-        const { stdout } = await this.shell.execFile('tmux', [
-            'display-message',
-            '-p',
-            '-t',
-            sessionName,
+            '-P',
+            '-F',
             '#{pane_index}',
         ]);
         await this.shell.execFile('tmux', [

package/dist/lib/workspaceDirectory.js

@@ -23,6 +23,12 @@ export class WorkspaceDirectoryService {
             this.fs.copyFileSync(agentsPath, path.join(workspacePath, 'AGENTS.md'));
         }
     }
+    copyDevcontainer(sourcePath, workspacePath) {
+        const devcontainerPath = path.join(sourcePath, '.devcontainer');
+        if (this.fs.existsSync(devcontainerPath)) {
+            this.fs.cpSync(devcontainerPath, path.join(workspacePath, '.devcontainer'), { recursive: true });
+        }
+    }
     detectWorkspace(cwd, destPath) {
         const normalizedCwd = path.resolve(cwd);
         const normalizedDest = path.resolve(destPath);

package/dist/usecases/checkWorkspaceStatus.js

@@ -3,19 +3,14 @@
  */
 export class CheckWorkspaceStatusUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
-    constructor(workspaceDir, workspaceConfig, status) {
+    constructor(workspaceDir, status) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
         const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
-        // 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);
+        const statuses = await this.status.checkAllWorktrees(worktreeDirs);
         return { statuses };
     }
 }

package/dist/usecases/createBranch.js

@@ -25,8 +25,10 @@ export class CreateBranchUseCase {
         // 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}`);
+            // 4. Prefer origin/<actualBaseBranch> as start point; fall back to local branch
+            const originExists = await this.git.remoteTrackingBranchExists(params.repoPath, actualBaseBranch);
+            const startPoint = originExists ? `origin/${actualBaseBranch}` : actualBaseBranch;
+            await this.git.createBranch(params.repoPath, params.branchName, startPoint);
         }
         // 5. Return the actual base branch used
         return {

package/dist/usecases/createWorkspace.js

@@ -1,6 +1,6 @@
 /**
  * Use case for creating a new workspace directory with initial config, AGENTS.md copy,
- * and an optional tmux session (root pane only, no worktrees yet).
+ * .devcontainer copy, and an optional tmux session (root pane only, no worktrees yet).
  */
 export class CreateWorkspaceUseCase {
     workspaceDir;
@@ -18,7 +18,9 @@ export class CreateWorkspaceUseCase {
         this.workspaceConfig.savePlaceholder(workspacePath);
         // 3. Copy AGENTS.md if it exists in source-path
         this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
-        // 4. Create tmux session (root pane only) if enabled
+        // 4. Copy .devcontainer if it exists in source-path
+        this.workspaceDir.copyDevcontainer(params.sourcePath, workspacePath);
+        // 5. Create tmux session (root pane only) if enabled
         let tmuxCreated = false;
         if (params.tmux) {
             try {

package/dist/usecases/discoverPrunableWorkspaces.js

@@ -5,12 +5,10 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class DiscoverPrunableWorkspacesUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
     git;
-    constructor(workspaceDir, workspaceConfig, status, git) {
+    constructor(workspaceDir, status, git) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
         this.git = git;
     }
@@ -25,11 +23,8 @@ 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, getBaseBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs);
             // Skip if any worktree has issues
             const hasAnyIssues = statuses.some(({ status }) => StatusServiceClass.hasIssues(status));
             if (hasAnyIssues) {

package/dist/usecases/listWorkspacesWithStatus.js

@@ -4,11 +4,9 @@
  */
 export class ListWorkspacesWithStatusUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
-    constructor(workspaceDir, workspaceConfig, status) {
+    constructor(workspaceDir, status) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
@@ -26,11 +24,8 @@ 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, getBaseBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs);
             workspacesWithStatus.push({
                 name: workspace.name,
                 path: workspace.path,

package/dist/usecases/removeWorkspace.js

@@ -7,14 +7,12 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class RemoveWorkspaceUseCase {
     workspaceDir;
-    workspaceConfig;
     worktree;
     repos;
     status;
     tmux;
-    constructor(workspaceDir, workspaceConfig, worktree, repos, status, tmux) {
+    constructor(workspaceDir, worktree, repos, status, tmux) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
         this.repos = repos;
         this.status = status;
@@ -25,16 +23,12 @@ export class RemoveWorkspaceUseCase {
         const issuesFound = [];
         // 1. Check status if worktrees exist
         if (worktreeDirs.length > 0) {
-            // 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);
+            const results = await this.status.checkAllWorktrees(worktreeDirs);
             for (const { repoName, status } of results) {
                 if (StatusServiceClass.hasIssues(status)) {
-                    const baseBranch = getBaseBranch(repoName);
                     issuesFound.push({
                         repoName,
-                        issue: StatusServiceClass.getStatusMessage(status, baseBranch),
+                        issue: StatusServiceClass.getStatusMessage(status),
                     });
                 }
             }

package/dist/usecases/usecases.js

@@ -21,12 +21,12 @@ 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),
-        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.status, services.tmux),
+        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, 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.workspaceConfig, services.status),
-        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.workspaceConfig, services.status, services.git),
-        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.workspaceConfig, services.status),
+        checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.status),
+        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.status, services.git),
+        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.status),
         resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux),
         createWorkspace: new CreateWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.tmux),
         createBranch: new CreateBranchUseCase(services.git),

package/package.json

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