edsger 0.19.9 → 0.19.11

package/dist/commands/workflow/feature-coordinator.js

@@ -16,6 +16,7 @@ import { logPhaseResult } from '../../utils/pipeline-logger.js';
 import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 /**
  * Map workflow phase names (underscore format) to phase runner functions
+ * Note: code_refine includes built-in verification loop (similar to technical_design)
  */
 const PHASE_RUNNERS = {
     feature_analysis: runFeatureAnalysisPhase,

package/dist/phases/code-refine/index.d.ts

@@ -1,8 +1,11 @@
 /**
  * Code Refine Analyzer
  * Processes GitHub PR review feedback and refines code accordingly
+ * Includes built-in verification loop that resolves PR comments and dismisses reviews
  */
 import { EdsgerConfig } from '../../types/index.js';
+import { type CodeRefineVerificationResult } from '../code-refine-verification/index.js';
+export declare const MAX_REFINE_ITERATIONS = 10;
 export interface CodeRefineOptions {
     featureId: string;
     githubToken: string;
@@ -34,8 +37,12 @@ export interface CodeRefineResult {
     summary?: string;
     filesModified?: string[];
     commitsCreated?: number;
+    iterations?: number;
+    verificationResult?: CodeRefineVerificationResult;
 }
 /**
- * Main code refine function
+ * Main code refine function with built-in verification loop
+ * Similar to technical-design, this includes an iterative improvement cycle:
+ * refine → verification → improve → re-refine (if needed)
  */
 export declare const refineCodeFromPRFeedback: (options: CodeRefineOptions, config: EdsgerConfig) => Promise<CodeRefineResult>;

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

@@ -1,6 +1,7 @@
 /**
  * Code Refine Analyzer
  * Processes GitHub PR review feedback and refines code accordingly
+ * Includes built-in verification loop that resolves PR comments and dismisses reviews
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { logInfo, logError } from '../../utils/logger.js';
@@ -10,8 +11,11 @@ import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.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 { getReviewedBranch, updateBranch, } from '../../services/branches.js';
 import { parsePullRequestUrl } from './context.js';
+import { verifyAndResolveComments, } from '../code-refine-verification/index.js';
+// Maximum number of refine + verification iterations
+export const MAX_REFINE_ITERATIONS = 10;
 function userMessage(content) {
     return {
         type: 'user',
@@ -58,29 +62,31 @@ const pushChanges = (verbose) => {
     }
 };
 /**
- * Main code refine function
+ * Main code refine function with built-in verification loop
+ * Similar to technical-design, this includes an iterative improvement cycle:
+ * refine → verification → improve → re-refine (if needed)
  */
 export const refineCodeFromPRFeedback = async (options, config) => {
     const { featureId, githubToken, verbose } = options;
     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/...)
+    // For multi-branch features, find the branch that has been reviewed
+    // (status = 'reviewed' after code-review phase) and use its branch_name for refine
     let branchName = `dev/${featureId}`; // Default for single-branch features
     let currentBranch = null;
     try {
-        currentBranch = await getReadyForReviewBranch({ featureId, verbose });
+        currentBranch = await getReviewedBranch({ 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(`📋 Found reviewed branch: ${currentBranch.name}`);
                 logInfo(`   Using dev branch: ${branchName}`);
             }
         }
         else if (verbose) {
-            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
+            logInfo(`ℹ️ No reviewed branch found, using default: ${branchName}`);
         }
     }
     catch (error) {
@@ -129,13 +135,14 @@ export const refineCodeFromPRFeedback = async (options, config) => {
         ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
         : preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
-        // Fetch code refine context (PR reviews and comments)
+        // Fetch initial code refine context (PR reviews and comments)
         if (verbose) {
             logInfo('Fetching code refine context from GitHub PR...');
         }
-        const context = await fetchCodeRefineContext(featureId, githubToken, verbose, pullRequestUrl || undefined);
+        const initialContext = await fetchCodeRefineContext(featureId, githubToken, verbose, pullRequestUrl || undefined);
         // Check if there are any reviews or comments to address
-        if (context.reviews.length === 0 && context.reviewComments.length === 0) {
+        if (initialContext.reviews.length === 0 &&
+            initialContext.reviewComments.length === 0) {
             if (verbose) {
                 logInfo('✅ No review comments or change requests found. Nothing to refine.');
             }
@@ -144,129 +151,43 @@ export const refineCodeFromPRFeedback = async (options, config) => {
                 status: 'success',
                 message: 'No review feedback to address',
                 summary: 'No change requests or review comments found on the PR',
+                iterations: 0,
             };
         }
         if (verbose) {
-            logInfo(`📋 Found ${context.reviews.length} reviews and ${context.reviewComments.length} comments to address`);
+            logInfo(`📋 Found ${initialContext.reviews.length} reviews and ${initialContext.reviewComments.length} comments to address`);
         }
-        // Fetch additional feedbacks for code-refine phase
-        // For multi-branch features, filter by the current branch to get branch-specific feedbacks
-        let feedbacksInfo;
-        try {
-            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_refine', 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 code refine context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
-                }
-            }
-        }
-        catch (error) {
+        // Iterative refine → verification loop
+        let currentIteration = 0;
+        let verificationFailureContext;
+        let lastRefineResult = null;
+        let lastVerificationResult = null;
+        while (currentIteration < MAX_REFINE_ITERATIONS) {
+            currentIteration++;
             if (verbose) {
-                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-            }
-        }
-        // Feature branch switching is handled by preparePhaseGitEnvironment above
-        // Create prompt for code refine
-        const systemPrompt = createSystemPrompt();
-        const refinePrompt = createCodeRefinePrompt(featureId, context, feedbacksInfo, options.verificationFailureContext);
-        let lastAssistantResponse = '';
-        let structuredRefineResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query for code refine...');
-        }
-        // Use Claude Code SDK to refine the code
-        for await (const message of query({
-            prompt: prompt(refinePrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: config.claude.model || 'sonnet',
-                maxTurns: 2000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            // Stream the code refine process
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const content of message.message.content) {
-                    if (content.type === 'text') {
-                        lastAssistantResponse += content.text + '\n';
-                        if (verbose) {
-                            console.log(`\n🔧 ${content.text}`);
-                        }
-                    }
-                    else if (content.type === 'tool_use') {
-                        if (verbose) {
-                            console.log(`\n🛠️ ${content.name}: ${content.input.description || 'Running...'}`);
-                        }
-                    }
-                }
-            }
-            else if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('\n🛠️ Code refine completed, parsing results...');
-                    try {
-                        const responseText = message.result || lastAssistantResponse;
-                        let jsonResult = null;
-                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                        if (jsonBlockMatch) {
-                            jsonResult = JSON.parse(jsonBlockMatch[1]);
-                        }
-                        else {
-                            jsonResult = JSON.parse(responseText);
-                        }
-                        if (jsonResult && jsonResult.refine_result) {
-                            structuredRefineResult = jsonResult.refine_result;
-                        }
-                        else {
-                            throw new Error('Invalid JSON structure');
-                        }
-                    }
-                    catch (error) {
-                        logError(`Failed to parse structured refine result: ${error}`);
-                        structuredRefineResult = parseCodeRefineResponse(message.result || lastAssistantResponse);
-                    }
+                if (currentIteration === 1) {
+                    logInfo(`\n🔄 Starting refine iteration ${currentIteration}/${MAX_REFINE_ITERATIONS}`);
                 }
                 else {
-                    logError(`\n⚠️  Code refine incomplete: ${message.subtype}`);
-                    if (message.subtype === 'error_max_turns') {
-                        logError('💡 Try simplifying the changes or reducing scope');
-                    }
-                    if (lastAssistantResponse) {
-                        try {
-                            const responseText = lastAssistantResponse;
-                            let jsonResult = null;
-                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                            if (jsonBlockMatch) {
-                                jsonResult = JSON.parse(jsonBlockMatch[1]);
-                                if (jsonResult && jsonResult.refine_result) {
-                                    structuredRefineResult = jsonResult.refine_result;
-                                }
-                            }
-                            else {
-                                structuredRefineResult = parseCodeRefineResponse(lastAssistantResponse);
-                            }
-                        }
-                        catch (error) {
-                            logError(`Failed to parse assistant response: ${error}`);
-                        }
-                    }
+                    logInfo(`\n🔄 Retry iteration ${currentIteration}/${MAX_REFINE_ITERATIONS}: Improving based on verification feedback...`);
                 }
             }
-        }
-        // Push changes to remote
-        if (structuredRefineResult) {
-            // Verify all changes are committed before pushing
+            // Execute refine for this iteration
+            const refineResult = await executeRefineIteration(featureId, githubToken, config, pullRequestUrl || undefined, currentBranch, verificationFailureContext, verbose);
+            if (refineResult.status === 'error') {
+                // Refine failed - return error
+                return {
+                    featureId,
+                    status: 'error',
+                    message: refineResult.message || 'Code refine failed',
+                    iterations: currentIteration,
+                };
+            }
+            lastRefineResult = refineResult;
+            // Push changes before verification
             if (hasUncommittedChanges()) {
                 const uncommittedFiles = getUncommittedFiles();
-                const errorMsg = `Code refine completed but there are uncommitted changes. All changes must be committed before verification.
+                const errorMsg = `Code refine completed but there are uncommitted changes.
 
 Uncommitted files:
 ${uncommittedFiles.join('\n')}
@@ -277,6 +198,7 @@ Please ensure Claude Code commits all changes before completing the refine phase
                     featureId,
                     status: 'error',
                     message: errorMsg,
+                    iterations: currentIteration,
                 };
             }
             if (verbose) {
@@ -284,24 +206,6 @@ Please ensure Claude Code commits all changes before completing the refine phase
             }
             try {
                 pushChanges(verbose);
-                const { summary, files_modified, commits_created } = structuredRefineResult;
-                if (verbose) {
-                    logInfo(`Code refine completed for feature: ${featureId}`);
-                    if (files_modified?.length > 0) {
-                        logInfo(`Files modified: ${files_modified.join(', ')}`);
-                    }
-                    if (commits_created) {
-                        logInfo(`Commits created: ${commits_created}`);
-                    }
-                }
-                return {
-                    featureId,
-                    status: 'success',
-                    message: 'Code successfully refined based on PR feedback',
-                    summary: summary || 'Code refined based on PR review feedback',
-                    filesModified: files_modified || [],
-                    commitsCreated: commits_created || 1,
-                };
             }
             catch (pushError) {
                 logError(`Failed to push changes: ${pushError}`);
@@ -309,16 +213,86 @@ Please ensure Claude Code commits all changes before completing the refine phase
                     featureId,
                     status: 'error',
                     message: `Code refined but failed to push: ${pushError}`,
+                    iterations: currentIteration,
                 };
             }
-        }
-        else {
-            return {
+            // Run verification
+            if (verbose) {
+                logInfo('\n🔍 Running verification to check if all comments are addressed...');
+            }
+            const verificationResult = await verifyAndResolveComments({
                 featureId,
-                status: 'error',
-                message: 'Code refine failed or incomplete',
-            };
+                githubToken,
+                config,
+                verbose,
+            });
+            lastVerificationResult = verificationResult;
+            // If verification passed, we're done!
+            if (verificationResult.status === 'success') {
+                if (verbose) {
+                    logInfo('✅ Verification passed! All PR comments have been addressed and resolved.');
+                }
+                // Update branch status to 'refined' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'refined' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'refined'`);
+                    }
+                }
+                return {
+                    featureId,
+                    status: 'success',
+                    message: verificationResult.message,
+                    summary: lastRefineResult.summary ||
+                        'Code refined based on PR review feedback',
+                    filesModified: lastRefineResult.files_modified || [],
+                    commitsCreated: lastRefineResult.commits_created || 1,
+                    iterations: currentIteration,
+                    verificationResult,
+                };
+            }
+            // Verification failed - prepare context for retry
+            if (currentIteration < MAX_REFINE_ITERATIONS) {
+                const verificationData = verificationResult.data;
+                const suggestions = verificationData.suggestions || [];
+                const unresolvedCommentDetails = verificationData.unresolvedCommentDetails || [];
+                const unresolvedReviewDetails = verificationData.unresolvedReviewDetails;
+                verificationFailureContext = {
+                    attempt: currentIteration + 1,
+                    suggestions,
+                    unresolvedCommentDetails,
+                    unresolvedReviewDetails,
+                };
+                if (verbose) {
+                    logInfo(`\n⚠️  Verification failed: ${verificationResult.message}`);
+                    if (suggestions.length > 0) {
+                        logInfo(`💡 Suggestions for next iteration:`);
+                        suggestions.forEach((suggestion) => {
+                            logInfo(`   ${suggestion}`);
+                        });
+                    }
+                    logInfo(`\n🔄 Will retry... (${MAX_REFINE_ITERATIONS - currentIteration} attempts remaining)`);
+                }
+            }
+            else {
+                // Max iterations reached
+                if (verbose) {
+                    logInfo(`\n⚠️  Maximum iterations (${MAX_REFINE_ITERATIONS}) reached. Verification still failing.`);
+                }
+            }
         }
+        // Return last verification result (which failed)
+        return {
+            featureId,
+            status: 'error',
+            message: lastVerificationResult?.message ||
+                'Verification failed after max iterations',
+            summary: lastRefineResult?.summary,
+            filesModified: lastRefineResult?.files_modified || [],
+            commitsCreated: lastRefineResult?.commits_created || 1,
+            iterations: currentIteration,
+            verificationResult: lastVerificationResult || undefined,
+        };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -334,6 +308,136 @@ Please ensure Claude Code commits all changes before completing the refine phase
         cleanupGit();
     }
 };
+/**
+ * Execute a single refine iteration
+ */
+async function executeRefineIteration(featureId, githubToken, config, pullRequestUrl, currentBranch, verificationFailureContext, verbose) {
+    // Fetch code refine context (PR reviews and comments)
+    const context = await fetchCodeRefineContext(featureId, githubToken, verbose, pullRequestUrl);
+    // Fetch additional feedbacks for code-refine phase
+    let feedbacksInfo;
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_refine', currentBranch?.id);
+        if (feedbacksContext.feedbacks.length > 0) {
+            feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to code refine context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Create prompt for code refine
+    const systemPrompt = createSystemPrompt();
+    const refinePrompt = createCodeRefinePrompt(featureId, context, feedbacksInfo, verificationFailureContext);
+    let lastAssistantResponse = '';
+    let structuredRefineResult = null;
+    if (verbose) {
+        logInfo('Starting Claude Code query for code refine...');
+    }
+    // Use Claude Code SDK to refine the code
+    for await (const message of query({
+        prompt: prompt(refinePrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: config.claude.model || 'sonnet',
+            maxTurns: 2000,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        // Stream the code refine process
+        if (message.type === 'assistant' && message.message?.content) {
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += content.text + '\n';
+                    if (verbose) {
+                        console.log(`\n🔧 ${content.text}`);
+                    }
+                }
+                else if (content.type === 'tool_use') {
+                    if (verbose) {
+                        console.log(`\n🛠️ ${content.name}: ${content.input.description || 'Running...'}`);
+                    }
+                }
+            }
+        }
+        else if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                logInfo('\n🛠️ Code refine completed, parsing results...');
+                try {
+                    const responseText = message.result || lastAssistantResponse;
+                    let jsonResult = null;
+                    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                    if (jsonBlockMatch) {
+                        jsonResult = JSON.parse(jsonBlockMatch[1]);
+                    }
+                    else {
+                        jsonResult = JSON.parse(responseText);
+                    }
+                    if (jsonResult && jsonResult.refine_result) {
+                        structuredRefineResult = jsonResult.refine_result;
+                    }
+                    else {
+                        throw new Error('Invalid JSON structure');
+                    }
+                }
+                catch (error) {
+                    logError(`Failed to parse structured refine result: ${error}`);
+                    structuredRefineResult = parseCodeRefineResponse(message.result || lastAssistantResponse);
+                }
+            }
+            else {
+                logError(`\n⚠️  Code refine incomplete: ${message.subtype}`);
+                if (message.subtype === 'error_max_turns') {
+                    logError('💡 Try simplifying the changes or reducing scope');
+                }
+                if (lastAssistantResponse) {
+                    try {
+                        const responseText = lastAssistantResponse;
+                        let jsonResult = null;
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                            if (jsonResult && jsonResult.refine_result) {
+                                structuredRefineResult = jsonResult.refine_result;
+                            }
+                        }
+                        else {
+                            structuredRefineResult = parseCodeRefineResponse(lastAssistantResponse);
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse assistant response: ${error}`);
+                    }
+                }
+            }
+        }
+    }
+    if (structuredRefineResult) {
+        return {
+            status: 'success',
+            summary: structuredRefineResult.summary,
+            files_modified: structuredRefineResult.files_modified,
+            commits_created: structuredRefineResult.commits_created,
+        };
+    }
+    else {
+        return {
+            status: 'error',
+            message: 'Code refine failed or incomplete',
+        };
+    }
+}
 function parseCodeRefineResponse(response) {
     const summaryMatch = response.match(/## Refine Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
     const summary = summaryMatch

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

@@ -8,7 +8,7 @@ import { Octokit } from '@octokit/rest';
 import { fetchCodeReviewContext, formatContextForPrompt, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { preparePhaseGitEnvironment, prepareCustomBranchGitEnvironment, } from '../../utils/git-branch-manager.js';
-import { getReadyForReviewBranch, } from '../../services/branches.js';
+import { getReadyForReviewBranch, updateBranch, } from '../../services/branches.js';
 import { getFeature } from '../../api/features/get-feature.js';
 function userMessage(content) {
     return {
@@ -319,6 +319,13 @@ export const reviewPullRequest = async (options, config) => {
                         overall_assessment ||
                         'Code review completed. No issues found.',
                 });
+                // Update branch status to 'reviewed' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                    }
+                }
                 return {
                     featureId,
                     status: 'success',
@@ -389,6 +396,13 @@ export const reviewPullRequest = async (options, config) => {
                     body: (summary || overall_assessment || 'Code review completed.') +
                         '\n\n**Note**: Some review comments could not be posted because they referenced lines not present in the diff.',
                 });
+                // Update branch status to 'reviewed' for multi-branch features
+                if (currentBranch) {
+                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                    if (verbose) {
+                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                    }
+                }
                 return {
                     featureId,
                     status: 'success',
@@ -418,6 +432,13 @@ export const reviewPullRequest = async (options, config) => {
                 logInfo(`Review ID: ${review.data.id}`);
                 logInfo(`Comments posted: ${comments.length}`);
             }
+            // Update branch status to 'reviewed' for multi-branch features
+            if (currentBranch) {
+                await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
+                if (verbose) {
+                    logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
+                }
+            }
             return {
                 featureId,
                 status: 'success',

package/dist/services/branches.d.ts

@@ -12,7 +12,7 @@ export interface Branch {
     base_branch_id: string | null;
     pull_request_url: string | null;
     pull_request_number: number | null;
-    status: 'pending' | 'in_progress' | 'ready_for_review' | 'merged' | 'closed';
+    status: 'pending' | 'in_progress' | 'ready_for_review' | 'reviewed' | 'refined' | 'merged' | 'closed';
     created_at: string;
     updated_at: string;
 }
@@ -80,6 +80,11 @@ export declare function getBranchById(branchId: string, verbose?: boolean): Prom
  * Returns the first branch with status 'ready_for_review'
  */
 export declare function getReadyForReviewBranch(options: PipelinePhaseOptions): Promise<Branch | null>;
+/**
+ * Get the branch that has been reviewed (for code-refine phase)
+ * Returns the first branch with status 'reviewed'
+ */
+export declare function getReviewedBranch(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

package/dist/services/branches.js

@@ -95,17 +95,28 @@ export function formatBranchesForContext(branches) {
     if (!branches || branches.length === 0) {
         return 'No branches defined yet.';
     }
+    const getStatusEmoji = (status) => {
+        switch (status) {
+            case 'merged':
+                return '✅';
+            case 'refined':
+                return '🎯';
+            case 'reviewed':
+                return '📝';
+            case 'ready_for_review':
+                return '👀';
+            case 'in_progress':
+                return '🔄';
+            case 'closed':
+                return '❌';
+            case 'pending':
+            default:
+                return '⏳';
+        }
+    };
     const branchList = branches
         .map((b, idx) => {
-        const statusEmoji = b.status === 'merged'
-            ? '✅'
-            : b.status === 'in_progress'
-                ? '🔄'
-                : b.status === 'ready_for_review'
-                    ? '👀'
-                    : b.status === 'closed'
-                        ? '❌'
-                        : '⏳';
+        const statusEmoji = getStatusEmoji(b.status);
         return `${idx + 1}. **${b.name}** ${statusEmoji}
    - Status: ${b.status}
    - Branch: ${b.branch_name || 'Not created'}
@@ -211,6 +222,14 @@ export async function getReadyForReviewBranch(options) {
     const branches = await getBranches(options);
     return branches.find((b) => b.status === 'ready_for_review') || null;
 }
+/**
+ * Get the branch that has been reviewed (for code-refine phase)
+ * Returns the first branch with status 'reviewed'
+ */
+export async function getReviewedBranch(options) {
+    const branches = await getBranches(options);
+    return branches.find((b) => b.status === 'reviewed') || 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

package/package.json

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