edsger 0.76.0 → 0.78.0

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

@@ -1,59 +0,0 @@
-/**
- * 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 { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type CodeRefineVerificationResult } from '../code-refine-verification/index.js';
-export declare const MAX_REFINE_ITERATIONS = 10;
-export interface CodeRefineOptions {
-    issueId: string;
-    githubToken: string;
-    verbose?: boolean;
-    checklistContext?: ChecklistPhaseContext | null;
-    verificationFailureContext?: {
-        attempt: number;
-        suggestions: string[];
-        unresolvedCommentDetails: {
-            commentId: string;
-            author: string;
-            file: string;
-            line: number | null;
-            body: string;
-            failureReason: string;
-            url: string;
-        }[];
-        unresolvedReviewDetails?: {
-            reviewId: number;
-            author: string;
-            state: string;
-            body: string | null;
-        }[];
-    };
-}
-export interface CodeRefineResult {
-    issueId: string;
-    status: 'success' | 'error';
-    message: string;
-    summary?: string;
-    filesModified?: string[];
-    commitsCreated?: number;
-    iterations?: number;
-    verificationResult?: CodeRefineVerificationResult;
-    data?: {
-        checklist_item_results?: {
-            checklist_item_id: string;
-            is_passed: boolean;
-            value?: unknown;
-            notes?: string;
-        }[];
-        [key: string]: any;
-    };
-}
-/**
- * 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, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeRefineResult>;

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

@@ -1,348 +0,0 @@
-/**
- * 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 { getGitHubConfig } from '../../api/github.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { getUncommittedFiles, hasUncommittedChanges, prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
-import { gitPushCurrentBranch } from '../../utils/git-push.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { verifyAndResolveComments, } from '../code-refine-verification/index.js';
-import { fetchCodeRefineContext } from './context.js';
-import { executeRefineIteration } from './refine-iteration.js';
-/**
- * Log base branch info for verbose mode
- */
-function logBaseBranchInfo(currentBranch, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
-    if (!verbose) {
-        return;
-    }
-    if (!currentBranch.base_branch_id) {
-        // No base branch - first branch in chain
-    }
-    else if (baseBranchInfo.baseBranchMerged) {
-        logInfo(`   Base branch is merged, will rebase from feat branch: ${baseBranchForRebase}`);
-        if (originalBaseBranchForRebase) {
-            logInfo(`   Using --onto from original base: ${originalBaseBranchForRebase}`);
-        }
-    }
-    else {
-        logInfo(`   Will rebase from base branch: ${baseBranchForRebase}`);
-    }
-}
-// Maximum number of refine + verification iterations
-export const MAX_REFINE_ITERATIONS = 10;
-/**
- * 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, checklistContext) => {
-    const { issueId, githubToken, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting code refine for issue ID: ${issueId}`);
-    }
-    // Resolve the repo's default branch (handles forks where default is master, etc.)
-    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
-    // For multi-branch issues, find the branch that has been reviewed
-    // (status = 'reviewed' after code-review phase) and use its branch_name for refine
-    let branchName = `dev/${issueId}`; // Default for single-branch issues
-    let currentBranch = null;
-    let allBranches = [];
-    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
-    let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
-    let originalBaseBranchForRebase; // For --onto when base was squash-merged
-    let baseBranchCompletedForRebase = false;
-    try {
-        // Get all branches to determine base branch info
-        allBranches = await getBranches({ issueId, verbose });
-        currentBranch = allBranches.find((b) => b.status === 'reviewed') || null;
-        if (currentBranch && currentBranch.branch_name) {
-            // Use branch_name directly (already stored as dev/...)
-            branchName = currentBranch.branch_name;
-            if (verbose) {
-                logInfo(`📋 Found reviewed branch: ${currentBranch.name}`);
-                logInfo(`   Using dev branch: ${branchName}`);
-            }
-            // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
-            // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
-            // - No base branch: returns 'main'
-            // - Base branch merged: returns feat branch (new branches created from feat/xxx)
-            // - Base branch completed: returns main
-            // - Base branch not merged: returns dev branch
-            baseBranchForRebase = baseBranchInfo.baseBranch;
-            // When base branch is merged, rebaseTargetBranch is 'main' (target for --onto)
-            rebaseTargetBranchForRebase = baseBranchInfo.rebaseTargetBranch;
-            // When base branch is merged (squash merge), we need originalBaseBranch for --onto
-            originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
-            baseBranchCompletedForRebase = baseBranchInfo.baseBranchCompleted || false;
-            logBaseBranchInfo(currentBranch, baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose);
-        }
-        else if (verbose) {
-            logInfo(`ℹ️ No reviewed branch found, using default: ${branchName}`);
-        }
-    }
-    catch (_error) {
-        if (verbose) {
-            logInfo(`Note: Could not fetch issue branches, using default branch`);
-        }
-    }
-    // Get PR URL from branch
-    let pullRequestUrl = null;
-    if (currentBranch && currentBranch.pull_request_url) {
-        pullRequestUrl = currentBranch.pull_request_url;
-        if (verbose) {
-            logInfo(`📝 Using PR URL from branch: ${pullRequestUrl}`);
-        }
-    }
-    else if (verbose) {
-        logInfo(`Note: No PR URL found on branch`);
-    }
-    // Sync feat branch to main before rebase to ensure it's up to date
-    // This prevents the PR (dev → feat) from showing extra commits
-    let featSyncedToMain = false;
-    if (branchName.startsWith('dev/')) {
-        try {
-            const githubConfig = await getGitHubConfig(issueId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                const featBranchName = branchName.replace(/^dev\//, 'feat/');
-                if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
-                }
-                featSyncedToMain = await syncFeatBranchWithMain({
-                    featBranch: featBranchName,
-                    githubToken: githubConfig.token,
-                    owner: githubConfig.owner,
-                    repo: githubConfig.repo,
-                    baseBranch: defaultBranch,
-                    verbose,
-                });
-            }
-        }
-        catch (error) {
-            // Don't fail the phase if sync fails
-            if (verbose) {
-                logInfo(`⚠️  Could not sync feat branch: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    // Prepare git environment: switch to the appropriate branch and rebase from correct base
-    // Use async version with automatic conflict resolution
-    const gitEnvResult = currentBranch
-        ? await prepareCustomBranchGitEnvironmentAsync({
-            issueBranch: branchName,
-            baseBranch: baseBranchForRebase,
-            rebaseTargetBranch: rebaseTargetBranchForRebase,
-            originalBaseBranch: originalBaseBranchForRebase,
-            verbose,
-            resolveConflicts: true,
-            conflictResolverConfig: {
-                model: DEFAULT_MODEL,
-            },
-            forcePushAfterRebase: featSyncedToMain,
-            baseBranchCompleted: baseBranchCompletedForRebase,
-            githubToken,
-        })
-        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
-            model: DEFAULT_MODEL,
-        });
-    const cleanupGit = gitEnvResult.cleanup;
-    // Log if conflicts were automatically resolved
-    if (gitEnvResult.conflictsResolved && verbose) {
-        logInfo(`🔧 Automatically resolved ${gitEnvResult.resolvedFiles?.length || 0} conflict(s) during rebase`);
-    }
-    try {
-        // Fetch initial code refine context (PR reviews and comments)
-        if (verbose) {
-            logInfo('Fetching code refine context from GitHub PR...');
-        }
-        const initialContext = await fetchCodeRefineContext(issueId, githubToken, verbose, pullRequestUrl || undefined);
-        // Check if there are any reviews or comments to address
-        if (initialContext.reviews.length === 0 &&
-            initialContext.reviewComments.length === 0) {
-            if (verbose) {
-                logInfo('✅ No review comments or change requests found. Nothing to refine.');
-            }
-            return {
-                issueId,
-                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 ${initialContext.reviews.length} reviews and ${initialContext.reviewComments.length} comments to address`);
-        }
-        // Iterative refine → verification loop
-        let currentIteration = 0;
-        let verificationFailureContext;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let lastRefineResult = null;
-        let lastVerificationResult = null;
-        while (currentIteration < MAX_REFINE_ITERATIONS) {
-            currentIteration++;
-            if (verbose) {
-                const label = currentIteration === 1
-                    ? `\n🔄 Starting refine iteration ${currentIteration}/${MAX_REFINE_ITERATIONS}`
-                    : `\n🔄 Retry iteration ${currentIteration}/${MAX_REFINE_ITERATIONS}: Improving based on verification feedback...`;
-                logInfo(label);
-            }
-            // Execute refine for this iteration
-            const refineResult = await executeRefineIteration({
-                issueId,
-                githubToken,
-                config,
-                pullRequestUrl: pullRequestUrl || undefined,
-                currentBranch,
-                verificationFailureContext,
-                checklistContext,
-                verbose,
-            });
-            if (refineResult.status === 'error') {
-                // Refine failed - return error
-                return {
-                    issueId,
-                    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.
-
-Uncommitted files:
-${uncommittedFiles.join('\n')}
-
-Please ensure Claude Code commits all changes before completing the refine phase.`;
-                logError(`❌ ${errorMsg}`);
-                return {
-                    issueId,
-                    status: 'error',
-                    message: errorMsg,
-                    iterations: currentIteration,
-                };
-            }
-            if (verbose) {
-                logInfo('✅ All changes committed. Pushing to remote...');
-            }
-            try {
-                const pushResult = gitPushCurrentBranch({ token: githubToken, verbose });
-                if (!pushResult.success) {
-                    throw new Error(pushResult.error || 'Push failed');
-                }
-            }
-            catch (pushError) {
-                logError(`Failed to push changes: ${pushError}`);
-                return {
-                    issueId,
-                    status: 'error',
-                    message: `Code refined but failed to push: ${pushError}`,
-                    iterations: currentIteration,
-                };
-            }
-            // Run verification
-            if (verbose) {
-                logInfo('\n🔍 Running verification to check if all comments are addressed...');
-            }
-            const verificationResult = await verifyAndResolveComments({
-                issueId,
-                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 issues
-                if (currentBranch) {
-                    await updateBranch(currentBranch.id, { status: 'refined' }, verbose);
-                    if (verbose) {
-                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'refined'`);
-                    }
-                }
-                return {
-                    issueId,
-                    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,
-                    data: {
-                        checklist_item_results: lastRefineResult.checklist_item_results,
-                    },
-                };
-            }
-            // 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;
-                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 if (verbose) {
-                // Max iterations reached
-                logInfo(`\n⚠️  Maximum iterations (${MAX_REFINE_ITERATIONS}) reached. Verification still failing.`);
-            }
-        }
-        // Return last verification result (which failed)
-        return {
-            issueId,
-            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);
-        logError(`Code refine failed: ${errorMessage}`);
-        return {
-            issueId,
-            status: 'error',
-            message: `Code refine failed: ${errorMessage}`,
-        };
-    }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
-};

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

@@ -1,5 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type CodeRefineContext } from './context.js';
-import { type CodeRefineOptions } from './index.js';
-export declare function createSystemPrompt(checklistContext?: ChecklistPhaseContext | null, projectDir?: string): Promise<string>;
-export declare function createCodeRefinePrompt(issueId: string, context: CodeRefineContext, feedbacksInfo?: string, verificationFailureContext?: CodeRefineOptions['verificationFailureContext'], checklistContext?: ChecklistPhaseContext | null): string;

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

@@ -1,162 +0,0 @@
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-import { formatContextForPrompt } from './context.js';
-export async function createSystemPrompt(checklistContext, projectDir) {
-    const skill = await resolveSkill('phase/code-refine', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/code-refine');
-    }
-    const hasChecklists = !!(checklistContext &&
-        checklistContext.checklists &&
-        checklistContext.checklists.length > 0);
-    const prompt = processConditionals(skill.prompt, { hasChecklists });
-    const contractKey = hasChecklists
-        ? 'code-refine-with-checklists'
-        : 'code-refine';
-    return `${prompt}\n\n${OUTPUT_CONTRACTS[contractKey]}`;
-}
-export function createCodeRefinePrompt(issueId, context, feedbacksInfo, verificationFailureContext, checklistContext) {
-    let contextInfo = formatContextForPrompt(context);
-    if (feedbacksInfo) {
-        contextInfo = `${contextInfo}\n\n${feedbacksInfo}`;
-    }
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        contextInfo = `${contextInfo}\n\n${checklistInfo}`;
-    }
-    // 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}
-   Comment: ${detail.body}
-   **Failure Reason**: ${detail.failureReason}
-   URL: ${detail.url}`)
-            .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 issue: ${issueId}
-${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?
-   - Are there any patterns in the feedback?
-
-2. **Examine Current Code**: Use Read and Glob tools to:
-   - Understand the current implementation
-   - Identify the code sections mentioned in reviews
-   - Review related files and dependencies
-   - Understand the broader context
-
-3. **Plan Your Changes**: Create a systematic plan:
-   - Address each review comment one by one
-   - Prioritize critical feedback
-   - Consider how changes relate to each other
-   - Ensure changes align with technical design
-
-4. **Refine the Code**: Make targeted improvements:
-   - Address each reviewer's concern thoughtfully
-   - Follow code quality best practices
-   - Maintain consistency with existing patterns
-   - Make code more maintainable and readable
-
-5. **Test Your Changes**: Verify everything works:
-   - Run relevant tests
-   - Check that functionality still works
-   - Ensure no regressions were introduced
-
-6. **Commit Your Changes**: Create clear commits:
-   - Write descriptive commit messages
-   - Reference the feedback being addressed
-   - Group related changes logically
-
-7. **Final Verification** - BEFORE generating the JSON result:
-   - Run \`git status\` to check for any uncommitted changes
-   - If there are ANY uncommitted files, commit them immediately
-   - Ensure working directory is completely clean (no output from \`git status --porcelain\`)
-   - Only after confirming everything is committed, generate the final JSON result
-
-## Important Notes
-- Be thorough - address ALL review comments
-- Be respectful - reviewers are trying to help improve the code
-- Be systematic - don't rush through the feedback
-- Test your changes - ensure nothing breaks
-- Communicate clearly in commit messages
-- **CRITICAL**: You MUST commit all changes before finishing - no uncommitted files allowed
-
-## ⚠️ CRITICAL - Pre-Completion Checklist
-BEFORE you generate the final JSON result, you MUST complete this checklist:
-
-1. **Run git status check**:
-   \`\`\`bash
-   git status --porcelain
-   \`\`\`
-   - If this command returns ANY output, you have uncommitted changes
-
-2. **If uncommitted changes exist**:
-   - Review what files are uncommitted
-   - Stage and commit ALL remaining changes with appropriate commit messages
-   - Run \`git status --porcelain\` again to verify it returns empty output
-
-3. **Only generate JSON result when**:
-   - \`git status --porcelain\` returns completely empty output
-   - All tests pass
-   - All review feedback has been addressed
-
-**FAILURE TO COMMIT ALL CHANGES WILL CAUSE THE PIPELINE TO FAIL**
-${checklistContext && checklistContext.checklists.length > 0
-        ? `
-## MANDATORY - Checklist Compliance
-You MUST satisfy ALL checklist items provided in the context and include results in your JSON response.
-- Use the exact UUID from each checklist item's "ID:" field as the "checklist_item_id"
-- Ensure your code refinements satisfy each checklist requirement
-- Set "is_passed" to true if the requirement is met, false otherwise
-- Provide detailed "notes" for any items that are not passed
-- ALL checklist items must be included - missing items will cause pipeline failure
-`
-        : ''}
-You are currently on the \`dev/${issueId}\` branch. Make your changes, commit them, and they will be pushed to the remote repository.
-
-Begin by analyzing all the review feedback and creating a plan to address each comment.`;
-}

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

@@ -1,33 +0,0 @@
-/**
- * Code Refine Iteration
- * Executes a single refine iteration using Claude Code SDK
- */
-import { type Branch } from '../../services/branches.js';
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type CodeRefineOptions } from './index.js';
-export interface ExecuteRefineIterationOptions {
-    issueId: string;
-    githubToken: string;
-    config: EdsgerConfig;
-    pullRequestUrl: string | undefined;
-    currentBranch: Branch | null;
-    verificationFailureContext: CodeRefineOptions['verificationFailureContext'];
-    checklistContext: ChecklistPhaseContext | null | undefined;
-    verbose?: boolean;
-}
-export interface RefineIterationResult {
-    status: 'success' | 'error';
-    summary?: string;
-    files_modified?: string[];
-    commits_created?: number;
-    checklist_item_results?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-    execution_session_id?: string;
-    message?: string;
-}
-export declare function executeRefineIteration(opts: ExecuteRefineIterationOptions): Promise<RefineIterationResult>;