edsger 0.3.3 → 0.4.1

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

@@ -9,6 +9,23 @@ export interface CodeRefineOptions {
     mcpToken: string;
     githubToken: string;
     verbose?: boolean;
+    verificationFailureContext?: {
+        attempt: number;
+        suggestions: string[];
+        unresolvedCommentDetails: Array<{
+            commentId: number;
+            author: string;
+            file: string;
+            line: number | null;
+            body: string;
+        }>;
+        unresolvedReviewDetails?: Array<{
+            reviewId: number;
+            author: string;
+            state: string;
+            body: string | null;
+        }>;
+    };
 }
 export interface CodeRefineResult {
     featureId: string;

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

@@ -142,7 +142,7 @@ export const refineCodeFromPRFeedback = async (options, config) => {
         pullLatestChanges(verbose);
         // Create prompt for code refine
         const systemPrompt = createSystemPrompt(config);
-        const refinePrompt = createCodeRefinePrompt(featureId, context, feedbacksInfo);
+        const refinePrompt = createCodeRefinePrompt(featureId, context, feedbacksInfo, options.verificationFailureContext);
         let lastAssistantResponse = '';
         let structuredRefineResult = null;
         if (verbose) {
@@ -336,20 +336,60 @@ You MUST end your response with a JSON object containing the code refine results
 
 Focus on systematic code refinement based on the provided PR review feedback.`;
 }
-function createCodeRefinePrompt(featureId, context, feedbacksInfo) {
+function createCodeRefinePrompt(featureId, context, feedbacksInfo, verificationFailureContext) {
     let contextInfo = formatContextForPrompt(context);
     if (feedbacksInfo) {
         contextInfo = contextInfo + '\n\n' + feedbacksInfo;
     }
-    return `Refine code based on PR review feedback for feature: ${featureId}
+    // Add verification failure context if this is a retry
+    let verificationSection = '';
+    if (verificationFailureContext) {
+        verificationSection = `
+
+## ⚠️ PREVIOUS ATTEMPT FAILED VERIFICATION (Attempt ${verificationFailureContext.attempt})
+
+Your previous code refine attempt did NOT successfully address all the review feedback.
+The verification phase found the following unresolved issues:
+
+### Verification Failure Summary
+${verificationFailureContext.suggestions.map((s) => `- ${s}`).join('\n')}
 
+### Unresolved Comments Still Needing Attention
+${verificationFailureContext.unresolvedCommentDetails
+            .map((detail, idx) => `${idx + 1}. **${detail.file}${detail.line ? `:${detail.line}` : ''}** by @${detail.author}
+   ${detail.body}`)
+            .join('\n\n')}
+
+${verificationFailureContext.unresolvedReviewDetails &&
+            verificationFailureContext.unresolvedReviewDetails.length > 0
+            ? `
+### Unresolved Reviews Still Requesting Changes
+${verificationFailureContext.unresolvedReviewDetails
+                .map((review, idx) => `${idx + 1}. Review by @${review.author} (${review.state})
+   ${review.body || 'No review body provided'}`)
+                .join('\n\n')}
+`
+            : ''}
+
+**CRITICAL**: You MUST address all the above issues in this iteration. Pay special attention to:
+1. Read each unresolved comment carefully and understand what change is being requested
+2. Locate the exact file and line mentioned
+3. Make the specific changes requested by the reviewer
+4. Test your changes to ensure they work correctly
+5. Do not skip or overlook any comments - address ALL of them
+`;
+    }
+    return `Refine code based on PR review feedback for feature: ${featureId}
+${verificationFailureContext ? '\n🔄 **This is a RETRY after verification failure**\n' : ''}
 ${contextInfo}
+${verificationSection}
 
 ## Code Refine Instructions
 
 Follow this systematic approach:
 
 1. **Analyze All Feedback**: Study all review comments and change requests above:
+   ${verificationFailureContext ? '   - **FOCUS ON THE UNRESOLVED COMMENTS listed in the verification failure section**' : ''}
    - What specific concerns were raised?
    - Which files and code sections need changes?
    - What are the underlying issues?

package/dist/phases/code-refine/retry-handler.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Code refine retry handler for pipeline execution
+ * Handles verification failures and retries code refine with suggestions
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { PipelinePhaseOptions, PipelineResult } from '../../types/pipeline.js';
+export declare const MAX_REFINE_ATTEMPTS = 10;
+export interface CodeRefineRetryOptions {
+    options: PipelinePhaseOptions;
+    config: EdsgerConfig;
+    results: PipelineResult[];
+    verbose?: boolean;
+}
+/**
+ * Handle code refine verification failures with automatic retry
+ */
+export declare function handleCodeRefineWithRetry({ options, config, results, verbose, }: CodeRefineRetryOptions): Promise<PipelineResult>;

package/dist/phases/code-refine/retry-handler.js

@@ -0,0 +1,123 @@
+/**
+ * Code refine retry handler for pipeline execution
+ * Handles verification failures and retries code refine with suggestions
+ */
+import { logPhaseResult } from '../../utils/pipeline-logger.js';
+import { runCodeRefinePhase, runCodeRefineVerificationPhase, } from '../../workflow-runner/executors/phase-executor.js';
+import { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+export const MAX_REFINE_ATTEMPTS = 10;
+/**
+ * Handle code refine verification failures with automatic retry
+ */
+export async function handleCodeRefineWithRetry({ options, config, results, verbose, }) {
+    let verificationResult;
+    let refineAttempt = 0;
+    let verificationFailureContext;
+    do {
+        // 1. Run code refine phase (with verification context if this is a retry)
+        const enhancedOptions = verificationFailureContext
+            ? { ...options, verificationFailureContext }
+            : options;
+        const codeRefineResult = await runCodeRefinePhase(enhancedOptions, config);
+        results.push(logPhaseResult(codeRefineResult, verbose));
+        // If code refine failed, stop immediately
+        if (codeRefineResult.status === 'error') {
+            if (verbose) {
+                console.log(`❌ Code refine failed: ${codeRefineResult.message}. Cannot proceed to verification.`);
+            }
+            return codeRefineResult;
+        }
+        // 2. Run code refine verification
+        verificationResult = await runCodeRefineVerificationPhase(options, config);
+        results.push(logPhaseResult(verificationResult, verbose));
+        // If verification passed, we're done
+        if (verificationResult.status === 'success') {
+            if (verbose) {
+                console.log(`✅ Code refine verification passed. All PR comments have been addressed.`);
+            }
+            break;
+        }
+        // Verification failed - check if we should retry
+        if (refineAttempt < MAX_REFINE_ATTEMPTS) {
+            refineAttempt++;
+            if (verbose) {
+                console.log(`⚠️  Code refine verification failed. Retrying... (Attempt ${refineAttempt}/${MAX_REFINE_ATTEMPTS})`);
+            }
+            // Extract verification failure details
+            const verificationData = verificationResult.data;
+            const unresolvedComments = verificationData?.unresolvedComments ||
+                verificationData?.unresolved_comments ||
+                0;
+            const suggestions = verificationData?.suggestions || [];
+            const unresolvedCommentDetails = verificationData?.unresolvedCommentDetails ||
+                verificationData?.unresolved_comment_details ||
+                [];
+            const unresolvedReviewDetails = verificationData?.unresolvedReviewDetails ||
+                verificationData?.unresolved_review_details;
+            // Prepare verification failure context for next code-refine attempt
+            verificationFailureContext = {
+                attempt: refineAttempt + 1, // Next attempt number
+                suggestions,
+                unresolvedCommentDetails,
+                unresolvedReviewDetails,
+            };
+            // Log audit event for verification failure with suggestions
+            await logFeaturePhaseEvent(options.mcpServerUrl, options.mcpToken, {
+                featureId: options.featureId,
+                eventType: 'phase_failed',
+                phase: 'code_refine_verification',
+                result: 'error',
+                metadata: {
+                    attempt: refineAttempt,
+                    unresolved_comments: unresolvedComments,
+                    suggestions: suggestions,
+                    unresolved_comment_details: unresolvedCommentDetails,
+                    unresolved_review_details: unresolvedReviewDetails,
+                    will_retry: true,
+                },
+                errorMessage: verificationResult.message,
+            }, verbose);
+            if (verbose && suggestions.length > 0) {
+                console.log(`\n💡 Suggestions for next iteration:`);
+                suggestions.forEach((suggestion) => {
+                    console.log(`   ${suggestion}`);
+                });
+                console.log('');
+            }
+            // Remove the failed verification result - we'll add the new one after retry
+            results.pop();
+            // Update status to indicate we're retrying code refine
+            await updateFeatureStatusForPhase({ mcpServerUrl: options.mcpServerUrl, mcpToken: options.mcpToken }, options.featureId, 'code-refine', verbose);
+            // Also remove the code refine result so it can be retried
+            results.pop();
+        }
+        else {
+            // Max attempts reached
+            if (verbose) {
+                console.log(`⚠️  Maximum refine attempts (${MAX_REFINE_ATTEMPTS}) reached. Verification still failing.`);
+            }
+            // Log final failure with all details
+            const verificationData = verificationResult.data;
+            const suggestions = verificationData?.suggestions || [];
+            const unresolvedDetails = verificationData?.unresolvedCommentDetails ||
+                verificationData?.unresolved_comment_details ||
+                [];
+            await logFeaturePhaseEvent(options.mcpServerUrl, options.mcpToken, {
+                featureId: options.featureId,
+                eventType: 'phase_failed',
+                phase: 'code_refine_verification',
+                result: 'error',
+                metadata: {
+                    attempt: refineAttempt,
+                    max_attempts_reached: true,
+                    suggestions: suggestions,
+                    unresolved_comment_details: unresolvedDetails,
+                },
+                errorMessage: `Max attempts reached: ${verificationResult.message}`,
+            }, verbose);
+            break;
+        }
+    } while (refineAttempt <= MAX_REFINE_ATTEMPTS);
+    return verificationResult;
+}

package/dist/phases/code-refine-verification/verifier.d.ts

@@ -9,14 +9,34 @@ export interface CodeRefineVerificationOptions {
     githubToken: string;
     verbose?: boolean;
 }
-export interface CodeRefineVerificationResult {
+export interface CodeRefineVerificationData {
     featureId: string;
-    status: 'success' | 'error';
-    message: string;
+    totalReviews: number;
+    unresolvedReviews: number;
     totalComments: number;
     resolvedComments: number;
     unresolvedComments: number;
     commentsMarkedResolved?: number;
+    suggestions?: string[];
+    unresolvedReviewDetails?: Array<{
+        reviewId: number;
+        author: string;
+        state: string;
+        body: string | null;
+        submittedAt: string | null;
+    }>;
+    unresolvedCommentDetails?: Array<{
+        commentId: number;
+        author: string;
+        file: string;
+        line: number | null;
+        body: string;
+    }>;
+}
+export interface CodeRefineVerificationResult {
+    status: 'success' | 'error';
+    message: string;
+    data: CodeRefineVerificationData;
 }
 /**
  * Verify and resolve PR review comments

package/dist/phases/code-refine-verification/verifier.js

@@ -4,7 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from '../../utils/logger.js';
-import { parsePullRequestUrl, fetchPRReviewComments, } from '../code-refine/context-fetcher.js';
+import { parsePullRequestUrl, fetchPRReviews, fetchPRReviewComments, } from '../code-refine/context-fetcher.js';
 import { getFeature } from '../../api/features/get-feature.js';
 /**
  * Check if a review comment thread is resolved
@@ -107,36 +107,65 @@ export async function verifyAndResolveComments(options) {
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Fetch all review comments
-        const reviewComments = await fetchPRReviewComments(octokit, owner, repo, prNumber, verbose);
-        if (reviewComments.length === 0) {
+        // Fetch all reviews requesting changes and review comments
+        const [reviews, reviewComments] = await Promise.all([
+            fetchPRReviews(octokit, owner, repo, prNumber, verbose),
+            fetchPRReviewComments(octokit, owner, repo, prNumber, verbose),
+        ]);
+        if (reviews.length === 0 && reviewComments.length === 0) {
             if (verbose) {
-                logInfo('✅ No review comments found. Verification complete.');
+                logInfo('✅ No reviews or review comments found. Verification complete.');
             }
             return {
-                featureId,
                 status: 'success',
-                message: 'No review comments to verify',
-                totalComments: 0,
-                resolvedComments: 0,
-                unresolvedComments: 0,
+                message: 'No reviews or review comments to verify',
+                data: {
+                    featureId,
+                    totalReviews: 0,
+                    unresolvedReviews: 0,
+                    totalComments: 0,
+                    resolvedComments: 0,
+                    unresolvedComments: 0,
+                },
             };
         }
         // Check which comments are resolved
         if (verbose) {
-            logInfo(`🔍 Checking ${reviewComments.length} review comments...`);
+            if (reviews.length > 0) {
+                logInfo(`🔍 Checking ${reviews.length} reviews requesting changes...`);
+            }
+            if (reviewComments.length > 0) {
+                logInfo(`🔍 Checking ${reviewComments.length} review comments...`);
+            }
         }
-        const commentStatus = await Promise.all(reviewComments.map(async (comment) => {
+        // Filter out already resolved comments (position is null but original_position exists)
+        // This is a heuristic - when code is modified at comment location, GitHub sets position to null
+        const unresolvedCommentsCandidates = reviewComments.filter((comment) => 
+        // Include comments where position is still set (not yet addressed)
+        // OR where both position and original_position are null (general comments)
+        comment.position !== null ||
+            (comment.position === null && comment.original_position === null));
+        if (verbose && unresolvedCommentsCandidates.length < reviewComments.length) {
+            logInfo(`📊 Filtered out ${reviewComments.length - unresolvedCommentsCandidates.length} likely resolved comments (position changed from original)`);
+        }
+        // Check review comments resolution status for the candidates
+        const commentStatus = await Promise.all(unresolvedCommentsCandidates.map(async (comment) => {
             const isResolved = await isCommentThreadResolved(octokit, owner, repo, prNumber, comment.id, verbose);
             return { comment, isResolved };
         }));
         const resolvedComments = commentStatus.filter((c) => c.isResolved);
         const unresolvedComments = commentStatus.filter((c) => !c.isResolved);
+        // Check reviews - they need to be dismissed or re-reviewed
+        // We consider reviews as "unresolved" if they are still in CHANGES_REQUESTED state
+        const unresolvedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
         if (verbose) {
-            logInfo(`📊 Status: ${resolvedComments.length} resolved, ${unresolvedComments.length} unresolved`);
+            logInfo(`📊 Comments: ${resolvedComments.length} resolved, ${unresolvedComments.length} unresolved`);
+            if (reviews.length > 0) {
+                logInfo(`📊 Reviews: ${reviews.length - unresolvedReviews.length} addressed, ${unresolvedReviews.length} still requesting changes`);
+            }
         }
-        // If all comments are resolved, mark them as resolved on GitHub
-        if (unresolvedComments.length === 0) {
+        // If all comments are resolved AND no reviews requesting changes, success
+        if (unresolvedComments.length === 0 && unresolvedReviews.length === 0) {
             if (verbose) {
                 logInfo('✅ All comments have been addressed! Marking them as resolved...');
             }
@@ -150,34 +179,95 @@ export async function verifyAndResolveComments(options) {
             if (verbose) {
                 logInfo(`✅ Marked ${markedCount} comments as resolved on GitHub`);
             }
+            const successMessage = reviews.length > 0
+                ? 'All reviews and review comments have been addressed and resolved'
+                : 'All review comments have been addressed and resolved';
             return {
-                featureId,
                 status: 'success',
-                message: 'All review comments have been addressed and resolved',
-                totalComments: reviewComments.length,
-                resolvedComments: resolvedComments.length,
-                unresolvedComments: 0,
-                commentsMarkedResolved: markedCount,
+                message: successMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: 0,
+                    totalComments: reviewComments.length,
+                    resolvedComments: resolvedComments.length,
+                    unresolvedComments: 0,
+                    commentsMarkedResolved: markedCount,
+                },
             };
         }
         else {
             if (verbose) {
-                logInfo(`⚠️  ${unresolvedComments.length} comments still need to be addressed`);
-                unresolvedComments.forEach(({ comment }) => {
-                    logInfo(`  - Comment ${comment.id} by @${comment.user.login}`);
-                    if (comment.path) {
-                        logInfo(`    File: ${comment.path}:${comment.line || '?'}`);
-                    }
-                    logInfo(`    ${comment.body.substring(0, 100)}...`);
-                });
+                if (unresolvedReviews.length > 0) {
+                    logInfo(`⚠️  ${unresolvedReviews.length} reviews still requesting changes`);
+                    unresolvedReviews.forEach((review) => {
+                        logInfo(`  - Review ${review.id} by @${review.user.login}`);
+                        if (review.body) {
+                            logInfo(`    ${review.body.substring(0, 100)}...`);
+                        }
+                    });
+                }
+                if (unresolvedComments.length > 0) {
+                    logInfo(`⚠️  ${unresolvedComments.length} comments still need to be addressed`);
+                    unresolvedComments.forEach(({ comment }) => {
+                        logInfo(`  - Comment ${comment.id} by @${comment.user.login}`);
+                        if (comment.path) {
+                            logInfo(`    File: ${comment.path}:${comment.line || '?'}`);
+                        }
+                        logInfo(`    ${comment.body.substring(0, 100)}...`);
+                    });
+                }
+            }
+            // Build concise suggestions for code-refine phase (similar to technical-design)
+            const suggestions = [];
+            suggestions.push('Verification failed - address the following issues:');
+            if (unresolvedReviews.length > 0) {
+                suggestions.push(`1. ${unresolvedReviews.length} review(s) still requesting changes - address the overall concerns raised by reviewers`);
+            }
+            if (unresolvedComments.length > 0) {
+                suggestions.push(`${unresolvedReviews.length > 0 ? '2' : '1'}. ${unresolvedComments.length} unresolved comment(s) - carefully address each specific feedback point`);
+            }
+            suggestions.push(`${unresolvedReviews.length > 0 || unresolvedComments.length > 0 ? (unresolvedReviews.length > 0 && unresolvedComments.length > 0 ? '3' : '2') : '2'}. Review the unresolved_comment_details in metadata for specific locations and feedback`);
+            suggestions.push(`${unresolvedReviews.length > 0 || unresolvedComments.length > 0 ? (unresolvedReviews.length > 0 && unresolvedComments.length > 0 ? '4' : '3') : '3'}. Test your changes thoroughly before committing`);
+            // Build detailed unresolved info
+            const unresolvedCommentDetails = unresolvedComments.map(({ comment }) => ({
+                commentId: comment.id,
+                author: comment.user.login,
+                file: comment.path || 'unknown',
+                line: comment.line,
+                body: comment.body,
+            }));
+            const unresolvedReviewDetails = unresolvedReviews.map((review) => ({
+                reviewId: review.id,
+                author: review.user.login,
+                state: review.state,
+                body: review.body,
+                submittedAt: review.submitted_at,
+            }));
+            let errorMessage = '';
+            if (unresolvedReviews.length > 0 && unresolvedComments.length > 0) {
+                errorMessage = `${unresolvedReviews.length} reviews and ${unresolvedComments.length} comments still need to be addressed`;
+            }
+            else if (unresolvedReviews.length > 0) {
+                errorMessage = `${unresolvedReviews.length} reviews still requesting changes`;
+            }
+            else {
+                errorMessage = `${unresolvedComments.length} review comments still need to be addressed`;
             }
             return {
-                featureId,
                 status: 'error',
-                message: `${unresolvedComments.length} review comments still need to be addressed`,
-                totalComments: reviewComments.length,
-                resolvedComments: resolvedComments.length,
-                unresolvedComments: unresolvedComments.length,
+                message: errorMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: unresolvedReviews.length,
+                    totalComments: reviewComments.length,
+                    resolvedComments: resolvedComments.length,
+                    unresolvedComments: unresolvedComments.length,
+                    suggestions,
+                    unresolvedReviewDetails,
+                    unresolvedCommentDetails,
+                },
             };
         }
     }
@@ -185,12 +275,20 @@ export async function verifyAndResolveComments(options) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`Code refine verification failed: ${errorMessage}`);
         return {
-            featureId,
             status: 'error',
             message: `Verification failed: ${errorMessage}`,
-            totalComments: 0,
-            resolvedComments: 0,
-            unresolvedComments: 0,
+            data: {
+                featureId,
+                totalReviews: 0,
+                unresolvedReviews: 0,
+                totalComments: 0,
+                resolvedComments: 0,
+                unresolvedComments: 0,
+                suggestions: [
+                    `Verification failed with error: ${errorMessage}`,
+                    'Please check the error message and try again',
+                ],
+            },
         };
     }
 }

package/dist/workflow-runner/executors/phase-executor.js

@@ -173,15 +173,36 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
             }, verbose);
         }
         else {
+            // Extract additional failure details from result data
+            const failureMetadata = {
+                duration_ms: phaseDuration,
+            };
+            // For verification phases, include suggestions and details
+            if (name.includes('verification') &&
+                result.data &&
+                typeof result.data === 'object') {
+                const data = result.data;
+                if (data.suggestions) {
+                    failureMetadata.suggestions = data.suggestions;
+                }
+                if (data.unresolvedCommentDetails ||
+                    data.unresolved_comment_details) {
+                    failureMetadata.unresolved_comment_details =
+                        data.unresolvedCommentDetails || data.unresolved_comment_details;
+                }
+                if (data.unresolvedComments !== undefined ||
+                    data.unresolved_comments !== undefined) {
+                    failureMetadata.unresolved_comments =
+                        data.unresolvedComments ?? data.unresolved_comments;
+                }
+            }
             await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
                 featureId,
                 eventType: 'phase_failed',
                 phase: name.replace(/-/g, '_'),
                 result: 'error',
-                metadata: {
-                    duration_ms: phaseDuration,
-                },
-                errorMessage: result.summary || 'Phase execution failed',
+                metadata: failureMetadata,
+                errorMessage: result.summary || result.message || 'Phase execution failed',
             }, verbose);
         }
         return {

package/dist/workflow-runner/pipeline-runner.js

@@ -4,9 +4,10 @@
  * Uses functional programming principles
  */
 import { updateFeatureStatusForPhase } from '../api/features/index.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../phases/functional-testing/test-retry-handler.js';
+import { handleCodeRefineWithRetry } from '../phases/code-refine/retry-handler.js';
 import { handlePullRequestCreation } from '../phases/pull-request/handler.js';
 /**
  * Run pipeline based on execution mode
@@ -267,19 +268,18 @@ const runFromFunctionalTesting = async (options, config) => {
 };
 /**
  * Run only code refine phase (refine code based on PR feedback)
+ * Includes automatic retry loop for verification failures
  */
 const runOnlyCodeRefine = async (options, config) => {
     const { featureId, verbose } = options;
     logPipelineStart(featureId, verbose);
     const results = [];
-    // 1. Code Refine - Address PR review feedback
-    const codeRefineResult = await runCodeRefinePhase(options, config);
-    results.push(logPhaseResult(codeRefineResult, verbose));
-    if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
-    }
-    // 2. Code Refine Verification - Verify all comments are addressed
-    const verificationResult = await runCodeRefineVerificationPhase(options, config);
-    results.push(logPhaseResult(verificationResult, verbose));
+    // Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
     return logPipelineComplete(results, verbose);
 };

package/package.json

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