edsger 0.19.5 → 0.19.6

package/dist/phases/branch-planning/context.d.ts

@@ -1,12 +1,12 @@
 import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
 import { type ProductInfo } from '../../api/products.js';
-import { type FeatureBranch } from '../../services/feature-branches.js';
+import { type Branch } from '../../services/branches.js';
 export interface BranchPlanningContext {
     feature: FeatureInfo;
     product: ProductInfo;
     user_stories: UserStory[];
     test_cases: TestCase[];
-    existing_branches: FeatureBranch[];
+    existing_branches: Branch[];
 }
 /**
  * Fetch all context information needed for branch planning via MCP endpoints

package/dist/phases/branch-planning/context.js

@@ -1,7 +1,7 @@
 import { logInfo, logError } from '../../utils/logger.js';
 import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
 import { getProduct } from '../../api/products.js';
-import { getFeatureBranches, } from '../../services/feature-branches.js';
+import { getBranches } from '../../services/branches.js';
 /**
  * Fetch all context information needed for branch planning via MCP endpoints
  */
@@ -15,7 +15,7 @@ export async function fetchBranchPlanningContext(featureId, verbose) {
             getFeature(featureId, verbose),
             getUserStories(featureId, verbose),
             getTestCases(featureId, verbose),
-            getFeatureBranches({ featureId, verbose }).catch(() => []),
+            getBranches({ featureId, verbose }).catch(() => []),
         ]);
         const product = await getProduct(feature.product_id, verbose);
         if (verbose) {

package/dist/phases/branch-planning/index.js

@@ -3,7 +3,7 @@ import { logInfo, logError } from '../../utils/logger.js';
 import { fetchBranchPlanningContext } from './context.js';
 import { createBranchPlanningSystemPrompt, createBranchPlanningPromptWithContext, createImprovementPrompt, formatContextForPrompt, formatExistingBranchesForPrompt, } from './prompts.js';
 import { buildSuccessResult, buildErrorResult, buildNoChangeResult, validatePlannedBranches, sortBranchesByDependency, } from './outcome.js';
-import { createFeatureBranches, clearFeatureBranches, } from '../../services/feature-branches.js';
+import { createBranches, clearBranches, } from '../../services/branches.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 function userMessage(content) {
@@ -73,7 +73,7 @@ export const planFeatureBranches = async (options, config) => {
             if (verbose) {
                 logInfo(`Clearing ${context.existing_branches.length} existing branches for full re-plan...`);
             }
-            await clearFeatureBranches({ featureId, verbose }, true);
+            await clearBranches({ featureId, verbose }, true);
         }
         // Format context for prompt
         const contextInfo = formatContextForPrompt(context.feature, context.product, context.user_stories, context.test_cases);
@@ -125,7 +125,7 @@ export const planFeatureBranches = async (options, config) => {
             if (verbose) {
                 logInfo(`🔄 Clearing ${context.existing_branches.length} existing branches for incremental update...`);
             }
-            await clearFeatureBranches({ featureId, verbose: false }, true);
+            await clearBranches({ featureId, verbose: false }, true);
         }
         // Create branches in database with proper dependencies
         // We need to create them one by one to get IDs for base_branch_id
@@ -148,7 +148,9 @@ export const planFeatureBranches = async (options, config) => {
                 base_branch_id: baseBranchId,
                 status: 'pending',
             };
-            const [created] = await createFeatureBranches({ featureId, verbose: false }, [branchInput]);
+            const [created] = await createBranches({ featureId, verbose: false }, [
+                branchInput,
+            ]);
             if (created) {
                 createdBranches.push(created);
                 if (branch.branch_name) {

package/dist/phases/branch-planning/prompts.js

@@ -17,10 +17,12 @@ Your task is to analyze the technical design and split the feature implementatio
 ## Branch Naming Convention
 
 Branch names should follow this pattern:
-- \`feat/{featureId}/1-{short-description}\`
-- \`feat/{featureId}/2-{short-description}\`
+- \`dev/{featureId}/1-{short-description}\`
+- \`dev/{featureId}/2-{short-description}\`
 - etc.
 
+The \`dev/\` prefix indicates this is a development branch. A PR will be created from \`dev/...\` to \`feat/...\` after implementation.
+
 Feature ID for this feature: ${featureId}
 
 ## Output Format
@@ -39,7 +41,7 @@ You MUST respond with a valid JSON object in this exact format:
       {
         "name": "Short descriptive name",
         "description": "Detailed description of what this branch implements",
-        "branch_name": "feat/${featureId}/1-short-name",
+        "branch_name": "dev/${featureId}/1-short-name",
         "depends_on_branch_name": null,
         "scope": [
           "List of specific items to implement"
@@ -58,12 +60,12 @@ You MUST respond with a valid JSON object in this exact format:
 
 Use \`depends_on_branch_name\` to specify which branch must be completed before this one can start:
 - First branch: \`"depends_on_branch_name": null\` (starts from main)
-- Subsequent branches: \`"depends_on_branch_name": "feat/${featureId}/1-database"\` (starts from the specified branch)
+- Subsequent branches: \`"depends_on_branch_name": "dev/${featureId}/1-database"\` (starts from the specified branch)
 
 Example for a typical feature:
 1. Branch 1 (Database): depends_on_branch_name = null (starts from main)
-2. Branch 2 (API): depends_on_branch_name = "feat/${featureId}/1-database" (starts from branch 1)
-3. Branch 3 (Frontend): depends_on_branch_name = "feat/${featureId}/2-api" (starts from branch 2)
+2. Branch 2 (API): depends_on_branch_name = "dev/${featureId}/1-database" (starts from branch 1)
+3. Branch 3 (Frontend): depends_on_branch_name = "dev/${featureId}/2-api" (starts from branch 2)
 
 This allows parallel development - Branch 2 can start before Branch 1 is merged, based on Branch 1's code.
 

package/dist/phases/code-implementation/branch-pr-creator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Branch PR Creator for multi-branch feature development
+ * Creates pull requests from dev/ branches to feat/ branches
+ */
+export interface BranchPullRequestConfig {
+    readonly githubToken: string;
+    readonly owner: string;
+    readonly repo: string;
+    readonly verbose?: boolean;
+}
+export interface BranchPullRequestResult {
+    readonly success: boolean;
+    readonly pullRequestUrl?: string;
+    readonly pullRequestNumber?: number;
+    readonly error?: string;
+}
+/**
+ * Convert a feat/ branch name to a dev/ branch name
+ * e.g., "feat/abc123/1-database" -> "dev/abc123/1-database"
+ */
+export declare function featBranchToDevBranch(featBranchName: string): string;
+/**
+ * Convert a dev/ branch name to a feat/ branch name
+ * e.g., "dev/abc123/1-database" -> "feat/abc123/1-database"
+ */
+export declare function devBranchToFeatBranch(devBranchName: string): string;
+/**
+ * Create a pull request from a dev/ branch to its corresponding feat/ branch
+ * This is used after code implementation in multi-branch features
+ */
+export declare function createBranchPullRequest(config: BranchPullRequestConfig, devBranchName: string, featureName: string, branchDescription: string, baseBranch?: string): Promise<BranchPullRequestResult>;

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -0,0 +1,187 @@
+/**
+ * Branch PR Creator for multi-branch feature development
+ * Creates pull requests from dev/ branches to feat/ branches
+ */
+import { Octokit } from '@octokit/rest';
+import { execSync } from 'child_process';
+import { logInfo, logError } from '../../utils/logger.js';
+/**
+ * Convert a feat/ branch name to a dev/ branch name
+ * e.g., "feat/abc123/1-database" -> "dev/abc123/1-database"
+ */
+export function featBranchToDevBranch(featBranchName) {
+    if (featBranchName.startsWith('feat/')) {
+        return 'dev/' + featBranchName.slice(5);
+    }
+    // If already dev/ or other format, return as-is
+    return featBranchName;
+}
+/**
+ * Convert a dev/ branch name to a feat/ branch name
+ * e.g., "dev/abc123/1-database" -> "feat/abc123/1-database"
+ */
+export function devBranchToFeatBranch(devBranchName) {
+    if (devBranchName.startsWith('dev/')) {
+        return 'feat/' + devBranchName.slice(4);
+    }
+    // If already feat/ or other format, return as-is
+    return devBranchName;
+}
+/**
+ * Push a branch to remote
+ */
+async function pushBranch(branchName, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`📤 Pushing branch ${branchName} to remote...`);
+        }
+        // Try to push with -u flag (sets upstream if not already set)
+        try {
+            execSync(`git push -u origin ${branchName}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+            return { success: true };
+        }
+        catch (error) {
+            // If push fails, try without -u flag
+            try {
+                execSync(`git push origin ${branchName}`, {
+                    encoding: 'utf-8',
+                    stdio: verbose ? 'inherit' : 'pipe',
+                });
+                return { success: true };
+            }
+            catch (retryError) {
+                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
+                return { success: false, error: errorMessage };
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: errorMessage };
+    }
+}
+/**
+ * Create a pull request from a dev/ branch to its corresponding feat/ branch
+ * This is used after code implementation in multi-branch features
+ */
+export async function createBranchPullRequest(config, devBranchName, featureName, branchDescription, baseBranch = 'main') {
+    const { githubToken, owner, repo, verbose } = config;
+    if (!devBranchName.startsWith('dev/')) {
+        return {
+            success: false,
+            error: `Expected dev/ branch name, got: ${devBranchName}`,
+        };
+    }
+    const featBranchName = devBranchToFeatBranch(devBranchName);
+    try {
+        const octokit = new Octokit({ auth: githubToken });
+        // Push the dev branch to remote first
+        if (verbose) {
+            logInfo(`📤 Pushing ${devBranchName} to remote...`);
+        }
+        const pushResult = await pushBranch(devBranchName, verbose);
+        if (!pushResult.success) {
+            return {
+                success: false,
+                error: `Failed to push dev branch: ${pushResult.error}`,
+            };
+        }
+        // Create the feat/ branch from base branch (main) if it doesn't exist
+        if (verbose) {
+            logInfo(`📝 Ensuring target branch ${featBranchName} exists...`);
+        }
+        try {
+            // Get the base branch (main) SHA
+            const { data: baseBranchData } = await octokit.repos.getBranch({
+                owner,
+                repo,
+                branch: baseBranch,
+            });
+            // Create the feat/ branch from main
+            await octokit.git.createRef({
+                owner,
+                repo,
+                ref: `refs/heads/${featBranchName}`,
+                sha: baseBranchData.commit.sha,
+            });
+            if (verbose) {
+                logInfo(`✅ Created target branch ${featBranchName} from ${baseBranch}`);
+            }
+        }
+        catch (error) {
+            // If branch already exists, that's fine
+            if (!error.message?.includes('Reference already exists')) {
+                throw error;
+            }
+            if (verbose) {
+                logInfo(`ℹ️ Target branch ${featBranchName} already exists`);
+            }
+        }
+        // Check if PR already exists
+        if (verbose) {
+            logInfo(`🔍 Checking for existing PR from ${devBranchName} to ${featBranchName}...`);
+        }
+        const { data: existingPRs } = await octokit.pulls.list({
+            owner,
+            repo,
+            head: `${owner}:${devBranchName}`,
+            base: featBranchName,
+            state: 'open',
+        });
+        if (existingPRs.length > 0) {
+            const existingPR = existingPRs[0];
+            if (verbose) {
+                logInfo(`ℹ️ Found existing PR #${existingPR.number}: ${existingPR.html_url}`);
+            }
+            return {
+                success: true,
+                pullRequestUrl: existingPR.html_url,
+                pullRequestNumber: existingPR.number,
+            };
+        }
+        // Generate PR title and body
+        const title = `feat: ${featureName}`;
+        const body = `## Branch Implementation
+
+${branchDescription}
+
+---
+**Branch**: \`${devBranchName}\` → \`${featBranchName}\`
+**Created by**: Automated Workflow
+`;
+        if (verbose) {
+            logInfo(`📝 Creating PR from ${devBranchName} to ${featBranchName}...`);
+        }
+        // Create the pull request
+        const { data: newPR } = await octokit.pulls.create({
+            owner,
+            repo,
+            title,
+            body,
+            head: devBranchName,
+            base: featBranchName,
+            draft: false,
+        });
+        if (verbose) {
+            logInfo(`✅ Pull request created: ${newPR.html_url}`);
+        }
+        return {
+            success: true,
+            pullRequestUrl: newPR.html_url,
+            pullRequestNumber: newPR.number,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            logError(`❌ Failed to create pull request: ${errorMessage}`);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}

package/dist/phases/code-implementation/index.js

@@ -7,7 +7,8 @@ import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { buildImplementationResult, buildVerificationFailureResult, buildNoResultsError, } from './outcome.js';
 import { performVerificationCycle } from '../code-implementation-verification/index.js';
 import { prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
-import { getCurrentBranch, updateFeatureBranch, getFeatureBranches, getBaseBranchInfo, } from '../../services/feature-branches.js';
+import { getCurrentBranch, updateBranch, getBranches, getBaseBranchInfo, } from '../../services/branches.js';
+import { createBranchPullRequest, } from './branch-pr-creator.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -25,14 +26,14 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         logInfo(`Base branch: ${baseBranch}`);
     }
     // Check for feature branches - use current branch if available
-    let currentFeatureBranch = null;
+    let currentBranch = null;
     try {
-        currentFeatureBranch = await getCurrentBranch({ featureId, verbose });
-        if (currentFeatureBranch && verbose) {
-            logInfo(`📋 Using feature branch: ${currentFeatureBranch.name}`);
-            logInfo(`   Branch name: ${currentFeatureBranch.branch_name || 'To be created'}`);
-            logInfo(`   Status: ${currentFeatureBranch.status}`);
-            logInfo(`   Description: ${currentFeatureBranch.description || 'No description'}`);
+        currentBranch = await getCurrentBranch({ featureId, verbose });
+        if (currentBranch && verbose) {
+            logInfo(`📋 Using feature branch: ${currentBranch.name}`);
+            logInfo(`   Branch name: ${currentBranch.branch_name || 'To be created'}`);
+            logInfo(`   Status: ${currentBranch.status}`);
+            logInfo(`   Description: ${currentBranch.description || 'No description'}`);
         }
     }
     catch (error) {
@@ -42,9 +43,9 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         }
     }
     // Update feature branch status to in_progress if we have one
-    if (currentFeatureBranch && currentFeatureBranch.status === 'pending') {
+    if (currentBranch && currentBranch.status === 'pending') {
         try {
-            await updateFeatureBranch(currentFeatureBranch.id, { status: 'in_progress' }, verbose);
+            await updateBranch(currentBranch.id, { status: 'in_progress' }, verbose);
             if (verbose) {
                 logInfo(`✅ Updated feature branch status to in_progress`);
             }
@@ -59,18 +60,18 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     // If the current feature branch depends on another branch, use that as the base
     let actualBaseBranch = baseBranch;
     let needsRebase = false;
-    if (currentFeatureBranch && currentFeatureBranch.base_branch_id) {
+    if (currentBranch && currentBranch.base_branch_id) {
         try {
-            const allBranches = await getFeatureBranches({
+            const allBranches = await getBranches({
                 featureId,
                 verbose: false,
             });
-            const baseBranchInfo = await getBaseBranchInfo(currentFeatureBranch, allBranches, baseBranch);
+            const baseBranchInfo = await getBaseBranchInfo(currentBranch, allBranches, baseBranch);
             actualBaseBranch = baseBranchInfo.baseBranch;
             needsRebase = baseBranchInfo.needsRebase;
             if (verbose) {
                 logInfo(`🔗 Branch chaining detected:`);
-                logInfo(`   Current branch: ${currentFeatureBranch.name}`);
+                logInfo(`   Current branch: ${currentBranch.name}`);
                 logInfo(`   Base branch: ${actualBaseBranch}`);
                 if (baseBranchInfo.baseBranchMerged) {
                     logInfo(`   Parent branch merged: yes (using main)`);
@@ -91,9 +92,13 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         }
     }
     // Prepare git environment: switch to feature branch and rebase with base
-    // Use custom branch environment if we have a specific feature branch name
-    const featureBranchName = currentFeatureBranch?.branch_name || `dev/${featureId}`;
-    const cleanupGit = prepareCustomBranchGitEnvironment(featureBranchName, actualBaseBranch, verbose);
+    // Branch names are stored as dev/... (development branch)
+    // PR will be created from dev/... to feat/... after implementation
+    const devBranchName = currentBranch?.branch_name || `dev/${featureId}`;
+    if (verbose && currentBranch) {
+        logInfo(`🔄 Using dev branch for development: ${devBranchName}`);
+    }
+    const cleanupGit = prepareCustomBranchGitEnvironment(devBranchName, actualBaseBranch, verbose);
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {
@@ -104,12 +109,12 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         // For multi-branch features, filter by the current branch to get branch-specific feedbacks
         let feedbacksInfo;
         try {
-            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_implementation', currentFeatureBranch?.id // Pass branch_id if we have a current branch
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_implementation', currentBranch?.id // Pass branch_id if we have a current branch
             );
             if (feedbacksContext.feedbacks.length > 0) {
                 feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
                 if (verbose) {
-                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context${currentFeatureBranch ? ` (including branch-specific for "${currentFeatureBranch.name}")` : ''}`);
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
                 }
             }
         }
@@ -119,12 +124,12 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
             }
         }
-        // Determine branch name: use feature branch if available, otherwise default
-        const branchName = currentFeatureBranch?.branch_name || `dev/${featureId}`;
+        // Use the dev branch name for development (already computed above)
+        const branchName = devBranchName;
         const systemPrompt = createSystemPrompt(config, actualBaseBranch, // Use computed base branch for branch chaining
         featureId, branchName);
         const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, actualBaseBranch, // Use computed base branch for branch chaining
-        checklistContext, verbose, feedbacksInfo, currentFeatureBranch);
+        checklistContext, verbose, feedbacksInfo, currentBranch);
         const maxIterations = options.maxVerificationIterations || 10;
         let currentIteration = 0;
         let currentPrompt = initialImplementationPrompt;
@@ -404,12 +409,54 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             logError(`   Code committed for manual review`);
             return buildVerificationFailureResult(featureId, branch_name || branchName, summary || 'Implementation completed with verification failures', files_modified || [], commit_hash || '', verificationResult, currentIteration);
         }
+        // Create pull request from dev/ branch to feat/ branch if this is a multi-branch feature
+        let pullRequestUrl = null;
+        let pullRequestNumber = null;
+        if (currentBranch && devBranchName.startsWith('dev/')) {
+            // Get GitHub configuration from environment
+            const githubToken = process.env.GITHUB_TOKEN || process.env.EDSGER_GITHUB_TOKEN;
+            const repoUrl = process.env.GITHUB_REPOSITORY || '';
+            const [owner, repo] = repoUrl.split('/').slice(-2);
+            if (githubToken && owner && repo) {
+                const prConfig = {
+                    githubToken,
+                    owner,
+                    repo,
+                    verbose,
+                };
+                // Derive feat/ branch name from dev/ branch name for PR target
+                const { devBranchToFeatBranch } = await import('./branch-pr-creator.js');
+                const featBranchName = devBranchToFeatBranch(devBranchName);
+                if (verbose) {
+                    logInfo(`📝 Creating pull request from ${devBranchName} to ${featBranchName}...`);
+                }
+                const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Feature branch implementation', baseBranch);
+                if (prResult.success) {
+                    pullRequestUrl = prResult.pullRequestUrl || null;
+                    pullRequestNumber = prResult.pullRequestNumber || null;
+                    if (verbose) {
+                        logInfo(`✅ Pull request created: ${pullRequestUrl}`);
+                    }
+                }
+                else if (verbose) {
+                    logError(`⚠️ Failed to create pull request: ${prResult.error}`);
+                    logInfo('   Implementation is complete, but PR was not created.');
+                }
+            }
+            else if (verbose) {
+                logInfo('⚠️ GitHub configuration not available, skipping PR creation');
+                logInfo('   Set GITHUB_TOKEN and GITHUB_REPOSITORY to enable automatic PR creation');
+            }
+        }
         // Update feature branch status to ready_for_review if we have one
-        if (currentFeatureBranch) {
+        if (currentBranch) {
             try {
-                await updateFeatureBranch(currentFeatureBranch.id, {
+                // Note: branch_name is stored as dev/... and used directly by all phases.
+                // The feat/ branch name is derived at runtime using devBranchToFeatBranch() for PR targets.
+                await updateBranch(currentBranch.id, {
                     status: 'ready_for_review',
-                    branch_name: branch_name || branchName,
+                    pull_request_url: pullRequestUrl,
+                    pull_request_number: pullRequestNumber,
                 }, verbose);
                 if (verbose) {
                     logInfo(`✅ Updated feature branch status to ready_for_review`);

package/dist/phases/code-refine/index.js

@@ -8,8 +8,9 @@ import { execSync } from 'child_process';
 import { fetchCodeRefineContext, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.js';
-import { preparePhaseGitEnvironment, hasUncommittedChanges, getUncommittedFiles, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, hasUncommittedChanges, getUncommittedFiles, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { getFeature } from '../../api/features/get-feature.js';
+import { getReadyForReviewBranch } from '../../services/branches.js';
 import { parsePullRequestUrl } from './context.js';
 function userMessage(content) {
     return {
@@ -64,6 +65,29 @@ export const refineCodeFromPRFeedback = async (options, config) => {
     if (verbose) {
         logInfo(`Starting code refine for feature ID: ${featureId}`);
     }
+    // For multi-branch features, find the branch that is ready for review
+    // and use its branch_name for refine (branch_name is stored as dev/...)
+    let branchName = `dev/${featureId}`; // Default for single-branch features
+    let currentBranch = null;
+    try {
+        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        if (currentBranch && currentBranch.branch_name) {
+            // Use branch_name directly (already stored as dev/...)
+            branchName = currentBranch.branch_name;
+            if (verbose) {
+                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
+                logInfo(`   Using dev branch: ${branchName}`);
+            }
+        }
+        else if (verbose) {
+            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`Note: Could not fetch feature branches, using default branch`);
+        }
+    }
     // Sync feat branch with main before preparing git environment
     // This prevents extra commits from appearing in PR when dev branch is rebased
     try {
@@ -81,8 +105,10 @@ export const refineCodeFromPRFeedback = async (options, config) => {
         }
         // Continue even if sync fails - it's not critical
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
+    // Prepare git environment: switch to the appropriate branch
+    const cleanupGit = currentBranch
+        ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
+        : preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         // Fetch code refine context (PR reviews and comments)
         if (verbose) {

package/dist/phases/code-review/index.js

@@ -7,7 +7,8 @@ import { logInfo, logError } from '../../utils/logger.js';
 import { Octokit } from '@octokit/rest';
 import { fetchCodeReviewContext, formatContextForPrompt, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
+import { getReadyForReviewBranch } from '../../services/branches.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -120,8 +121,33 @@ export const reviewPullRequest = async (options, config) => {
     if (verbose) {
         logInfo(`Starting code review for feature ID: ${featureId}`);
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
+    // For multi-branch features, find the branch that is ready for review
+    // and use its branch_name for review (branch_name is stored as dev/...)
+    let branchName = `dev/${featureId}`; // Default for single-branch features
+    let currentBranch = null;
+    try {
+        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        if (currentBranch && currentBranch.branch_name) {
+            // Use branch_name directly (already stored as dev/...)
+            branchName = currentBranch.branch_name;
+            if (verbose) {
+                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
+                logInfo(`   Using dev branch: ${branchName}`);
+            }
+        }
+        else if (verbose) {
+            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`Note: Could not fetch feature branches, using default branch`);
+        }
+    }
+    // Prepare git environment: switch to the appropriate branch
+    const cleanupGit = currentBranch
+        ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
+        : preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         // Fetch code review context (PR data, files, commits)
         if (verbose) {

package/dist/phases/functional-testing/analyzer.js

@@ -6,7 +6,8 @@ import { saveFunctionalTestResultsWithRetry } from './http-fallback.js';
 import { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
 import { updateFeatureStatus } from '../../api/features/index.js';
 import { createTestReport, } from './test-report-creator.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
+import { getReadyForReviewBranch } from '../../services/branches.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -22,8 +23,33 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
     if (verbose) {
         logInfo(`Starting functional testing for feature ID: ${featureId}`);
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
+    // For multi-branch features, find the branch that is ready for review
+    // and use its branch_name for testing (branch_name is stored as dev/...)
+    let branchName = `dev/${featureId}`; // Default for single-branch features
+    let currentBranch = null;
+    try {
+        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        if (currentBranch && currentBranch.branch_name) {
+            // Use branch_name directly (already stored as dev/...)
+            branchName = currentBranch.branch_name;
+            if (verbose) {
+                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
+                logInfo(`   Using dev branch: ${branchName}`);
+            }
+        }
+        else if (verbose) {
+            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`Note: Could not fetch feature branches, using default branch`);
+        }
+    }
+    // Prepare git environment: switch to the appropriate branch
+    const cleanupGit = currentBranch
+        ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
+        : preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {

package/dist/services/branches.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Branches service for pipeline integration
+ * Allows phases to manage branches via MCP
+ */
+import { PipelinePhaseOptions } from '../types/pipeline.js';
+export interface Branch {
+    id: string;
+    feature_id: string;
+    name: string;
+    description: string | null;
+    branch_name: string | null;
+    base_branch_id: string | null;
+    pull_request_url: string | null;
+    pull_request_number: number | null;
+    status: 'pending' | 'in_progress' | 'ready_for_review' | 'merged' | 'closed';
+    created_at: string;
+    updated_at: string;
+}
+export interface CreateBranchInput {
+    name: string;
+    description?: string;
+    branch_name?: string;
+    base_branch_id?: string;
+    status?: Branch['status'];
+}
+/**
+ * List all branches for a feature
+ */
+export declare function getBranches(options: PipelinePhaseOptions): Promise<Branch[]>;
+/**
+ * Get the current active branch for a feature
+ */
+export declare function getCurrentBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
+/**
+ * Create branches
+ */
+export declare function createBranches(options: PipelinePhaseOptions, branches: CreateBranchInput[]): Promise<Branch[]>;
+/**
+ * Update a branch
+ */
+export declare function updateBranch(branchId: string, updates: Partial<Omit<Branch, 'id' | 'feature_id' | 'created_at' | 'updated_at'>>, verbose?: boolean): Promise<Branch>;
+/**
+ * Clear all branches for a feature (used before re-planning)
+ */
+export declare function clearBranches(options: PipelinePhaseOptions, force?: boolean): Promise<number>;
+/**
+ * Format branches for context (to include in prompts)
+ */
+export declare function formatBranchesForContext(branches: Branch[]): string;
+/**
+ * Check if feature has multiple branches planned
+ */
+export declare function hasMultipleBranches(options: PipelinePhaseOptions): Promise<boolean>;
+/**
+ * Get next pending branch to work on
+ */
+export declare function getNextPendingBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
+/**
+ * Check if all branches are completed
+ */
+export declare function allBranchesCompleted(options: PipelinePhaseOptions): Promise<boolean>;
+/**
+ * Get the base branch information for a branch.
+ * Returns:
+ * - If base_branch_id is set and that branch is merged: use main
+ * - If base_branch_id is set and that branch is not merged: use that branch's branch_name
+ * - If base_branch_id is null: use main
+ */
+export declare function getBaseBranchInfo(branch: Branch, allBranches: Branch[], mainBranch?: string): Promise<{
+    baseBranch: string;
+    needsRebase: boolean;
+    baseBranchMerged: boolean;
+}>;
+/**
+ * Get branch by ID
+ */
+export declare function getBranchById(branchId: string, verbose?: boolean): Promise<Branch | null>;
+/**
+ * Get the branch that is ready for review (for post-implementation phases)
+ * Returns the first branch with status 'ready_for_review'
+ */
+export declare function getReadyForReviewBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
+/**
+ * Get the branch that is in progress (in_progress or ready_for_review)
+ * Useful for phases that need to work on the current active branch
+ */
+export declare function getActiveBranch(options: PipelinePhaseOptions): Promise<Branch | null>;

package/dist/services/branches.js

@@ -0,0 +1,230 @@
+/**
+ * Branches service for pipeline integration
+ * Allows phases to manage branches via MCP
+ */
+import { callMcpEndpoint } from '../api/mcp-client.js';
+/**
+ * List all branches for a feature
+ */
+export async function getBranches(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Fetching branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('branches/list', {
+        feature_id: featureId,
+    }));
+    const branches = result?.branches || [];
+    if (verbose) {
+        console.log(`✅ Found ${branches.length} branches`);
+    }
+    return branches;
+}
+/**
+ * Get the current active branch for a feature
+ */
+export async function getCurrentBranch(options) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Getting current branch for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('branches/current', {
+        feature_id: featureId,
+    }));
+    return result?.current_branch || null;
+}
+/**
+ * Create branches
+ */
+export async function createBranches(options, branches) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Creating ${branches.length} branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('branches/create', {
+        feature_id: featureId,
+        branches: branches,
+    }));
+    const createdBranches = result?.created_branches || [];
+    if (verbose) {
+        console.log(`✅ Created ${createdBranches.length} branches`);
+        createdBranches.forEach((b, idx) => {
+            console.log(`   ${idx + 1}. ${b.name} (status: ${b.status})`);
+        });
+    }
+    return createdBranches;
+}
+/**
+ * Update a branch
+ */
+export async function updateBranch(branchId, updates, verbose) {
+    if (verbose) {
+        console.log(`📋 Updating branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('branches/update', {
+        branch_id: branchId,
+        ...updates,
+    }));
+    if (verbose) {
+        console.log(`✅ Branch updated successfully`);
+    }
+    return result?.branch;
+}
+/**
+ * Clear all branches for a feature (used before re-planning)
+ */
+export async function clearBranches(options, force = false) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        console.log(`📋 Clearing branches for feature: ${featureId}`);
+    }
+    const result = (await callMcpEndpoint('branches/clear', {
+        feature_id: featureId,
+        force: force,
+    }));
+    const deletedCount = result?.deleted_count || 0;
+    if (verbose) {
+        console.log(`✅ Cleared ${deletedCount} branches`);
+    }
+    return deletedCount;
+}
+/**
+ * Format branches for context (to include in prompts)
+ */
+export function formatBranchesForContext(branches) {
+    if (!branches || branches.length === 0) {
+        return 'No branches defined yet.';
+    }
+    const branchList = branches
+        .map((b, idx) => {
+        const statusEmoji = b.status === 'merged'
+            ? '✅'
+            : b.status === 'in_progress'
+                ? '🔄'
+                : b.status === 'ready_for_review'
+                    ? '👀'
+                    : b.status === 'closed'
+                        ? '❌'
+                        : '⏳';
+        return `${idx + 1}. **${b.name}** ${statusEmoji}
+   - Status: ${b.status}
+   - Branch: ${b.branch_name || 'Not created'}
+   - PR: ${b.pull_request_url || 'Not created'}
+   - Description: ${b.description || 'No description'}`;
+    })
+        .join('\n\n');
+    return `# Branches
+
+${branchList}
+
+Total: ${branches.length} branches
+Merged: ${branches.filter((b) => b.status === 'merged').length}
+In Progress: ${branches.filter((b) => b.status === 'in_progress').length}
+Pending: ${branches.filter((b) => b.status === 'pending').length}`;
+}
+/**
+ * Check if feature has multiple branches planned
+ */
+export async function hasMultipleBranches(options) {
+    const branches = await getBranches(options);
+    return branches.length > 1;
+}
+/**
+ * Get next pending branch to work on
+ */
+export async function getNextPendingBranch(options) {
+    const branches = await getBranches(options);
+    return branches.find((b) => b.status === 'pending') || null;
+}
+/**
+ * Check if all branches are completed
+ */
+export async function allBranchesCompleted(options) {
+    const branches = await getBranches(options);
+    if (branches.length === 0)
+        return true;
+    return branches.every((b) => b.status === 'merged' || b.status === 'closed');
+}
+/**
+ * Get the base branch information for a branch.
+ * Returns:
+ * - If base_branch_id is set and that branch is merged: use main
+ * - If base_branch_id is set and that branch is not merged: use that branch's branch_name
+ * - If base_branch_id is null: use main
+ */
+export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
+    // No base branch - start from main
+    if (!branch.base_branch_id) {
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Find the base branch
+    const baseBranch = allBranches.find((b) => b.id === branch.base_branch_id);
+    if (!baseBranch) {
+        // Base branch not found - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: true,
+        };
+    }
+    // Check if base branch is merged
+    if (baseBranch.status === 'merged') {
+        // Base branch is merged to main - we should base on main and rebase if needed
+        return { baseBranch: mainBranch, needsRebase: true, baseBranchMerged: true };
+    }
+    // Base branch is not merged - we should base on that branch
+    if (!baseBranch.branch_name) {
+        // Base branch doesn't have a git branch yet - fall back to main
+        return {
+            baseBranch: mainBranch,
+            needsRebase: false,
+            baseBranchMerged: false,
+        };
+    }
+    return {
+        baseBranch: baseBranch.branch_name,
+        needsRebase: false,
+        baseBranchMerged: false,
+    };
+}
+/**
+ * Get branch by ID
+ */
+export async function getBranchById(branchId, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching branch: ${branchId}`);
+    }
+    const result = (await callMcpEndpoint('branches/get', {
+        branch_id: branchId,
+    }));
+    return result?.branch || null;
+}
+/**
+ * Get the branch that is ready for review (for post-implementation phases)
+ * Returns the first branch with status 'ready_for_review'
+ */
+export async function getReadyForReviewBranch(options) {
+    const branches = await getBranches(options);
+    return branches.find((b) => b.status === 'ready_for_review') || null;
+}
+/**
+ * Get the branch that is in progress (in_progress or ready_for_review)
+ * Useful for phases that need to work on the current active branch
+ */
+export async function getActiveBranch(options) {
+    const branches = await getBranches(options);
+    // First try to find ready_for_review (after implementation)
+    const readyBranch = branches.find((b) => b.status === 'ready_for_review');
+    if (readyBranch)
+        return readyBranch;
+    // Then try in_progress
+    const inProgressBranch = branches.find((b) => b.status === 'in_progress');
+    if (inProgressBranch)
+        return inProgressBranch;
+    // Fall back to pending
+    return branches.find((b) => b.status === 'pending') || null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.19.5",
+  "version": "0.19.6",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"