edsger 0.76.0 → 0.78.0

package/dist/phases/code-implementation/outcome.d.ts

@@ -1,47 +0,0 @@
-import { type ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
-import { type CodeImplementationResult } from './index.js';
-export interface VerificationCycleResult {
-    passed: boolean;
-    verificationResult: ChecklistVerificationResult | null;
-    nextPrompt: string | null;
-}
-export interface BuildImplementationResultOptions {
-    issueId: string;
-    branchName: string;
-    implementationSummary: string;
-    filesModified: string[];
-    commitHash: string;
-    iterations: number;
-    checklistResults?: {
-        checklist_id: string;
-        satisfied: boolean;
-        notes?: string;
-    }[];
-    checklistItemResults?: {
-        checklist_item_id: string;
-        is_passed: boolean;
-        value?: unknown;
-        notes?: string;
-    }[];
-}
-/**
- * Build successful implementation result
- */
-export declare function buildImplementationResult(opts: BuildImplementationResultOptions): CodeImplementationResult;
-export interface BuildVerificationFailureResultOptions {
-    issueId: string;
-    branchName: string;
-    implementationSummary: string;
-    filesModified: string[];
-    commitHash: string;
-    verificationResult: ChecklistVerificationResult;
-    iterations: number;
-}
-/**
- * Build verification failure result
- */
-export declare function buildVerificationFailureResult(opts: BuildVerificationFailureResultOptions): CodeImplementationResult;
-/**
- * Build error result for no implementation
- */
-export declare function buildNoResultsError(issueId: string, branchName: string): CodeImplementationResult;

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

@@ -1,53 +0,0 @@
-/**
- * Build successful implementation result
- */
-export function buildImplementationResult(opts) {
-    const { issueId, branchName, implementationSummary, filesModified, commitHash, checklistResults, checklistItemResults, } = opts;
-    return {
-        issueId,
-        branchName,
-        implementationSummary,
-        status: 'success',
-        message: 'Code implementation completed successfully',
-        filesModified,
-        commitHash,
-        data: {
-            checklist_results: checklistResults,
-            checklist_item_results: checklistItemResults,
-        },
-    };
-}
-/**
- * Build verification failure result
- */
-export function buildVerificationFailureResult(opts) {
-    const { issueId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations, } = opts;
-    return {
-        issueId,
-        branchName,
-        implementationSummary,
-        status: 'error',
-        message: `Code implementation verification failed after ${iterations} iterations. Code committed for manual review.`,
-        filesModified,
-        commitHash,
-        data: {
-            verification_failed: true,
-            verification_summary: verificationResult.summary,
-            rejected_count: verificationResult.rejected_count,
-            uncertain_count: verificationResult.uncertain_count,
-            improvement_suggestions: verificationResult.overall_suggestions || [],
-        },
-    };
-}
-/**
- * Build error result for no implementation
- */
-export function buildNoResultsError(issueId, branchName) {
-    return {
-        issueId,
-        branchName,
-        implementationSummary: null,
-        status: 'error',
-        message: 'Code implementation failed - no results produced',
-    };
-}

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

@@ -1,8 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-import { type ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
-export declare const createCodeImplementationSystemPrompt: (_config: EdsgerConfig, baseBranch: string, projectDir?: string) => Promise<string>;
-export declare const createCodeImplementationPromptWithContext: (issueId: string, contextInfo: string, baseBranch: string) => string;
-/**
- * Create a prompt for the implementation agent to improve code based on verification feedback
- */
-export declare const createCodeImplementationImprovementPrompt: (verificationResult: ChecklistVerificationResult, branchName: string, baseBranch: string) => string;

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

@@ -1,166 +0,0 @@
-import { resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createCodeImplementationSystemPrompt = async (_config, baseBranch, projectDir) => {
-    const skill = await resolveSkill('phase/code-implementation', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/code-implementation');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, { BASE_BRANCH: baseBranch });
-    return `${prompt}\n\n${OUTPUT_CONTRACTS['code-implementation']}`;
-};
-export const createCodeImplementationPromptWithContext = (issueId, contextInfo, baseBranch) => {
-    return `Implement the complete issue for issue ID: ${issueId}
-
-${contextInfo}
-
-## Implementation Instructions
-
-Follow this systematic approach:
-
-1. **Git Setup**:
-   - Checkout ${baseBranch} and pull latest changes: git pull origin ${baseBranch} --rebase
-   - Create a new issue branch: git checkout -b dev/${issueId}
-
-2. **Codebase Analysis**:
-   - Use Glob to understand the project structure and find relevant files
-   - Use Read to examine existing code patterns and conventions
-   - Understand the technology stack and dependencies
-
-3. **Implementation**:
-   - Follow the technical design specifications provided above
-   - Implement ALL user stories listed above
-   - Create new files and modify existing files as needed
-   - Follow existing code patterns and conventions
-
-4. **Validation**:
-   - Fix any lint or formatting issues
-   - Ensure the code builds successfully
-
-5. **Commit Changes**:
-   - Stage all changes: git add .
-   - Commit with descriptive message: git commit -m "feat: implement [issue description]"
-   - Handle any pre-commit hook issues appropriately
-
-## Important Implementation Notes:
-- Focus on production-ready, maintainable code
-- Follow the technical design specifications closely
-- Implement complete functionality, not just partial issues
-- Handle error cases and edge scenarios appropriately
-- Use proper TypeScript types and interfaces
-- Add appropriate validation and error handling
-- Follow the existing code patterns in the repository
-- Focus on implementation only - automated tests will be written in a separate phase
-
-Begin implementation based on the technical design and requirements provided above.`;
-};
-/**
- * Create a prompt for the implementation agent to improve code based on verification feedback
- */
-export const createCodeImplementationImprovementPrompt = (verificationResult, branchName, baseBranch) => {
-    // Format rejected items with specific feedback and improvement suggestions
-    const rejectedItemsSection = verificationResult.item_verifications
-        .filter((v) => v.verification_status === 'rejected')
-        .map((v, index) => {
-        return `### Rejected Requirement ${index + 1}
-**Checklist Item ID**: ${v.checklist_item_id}
-**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '❌ Not Satisfied'}
-**Verification Result**: ❌ REJECTED
-**Reason**: ${v.verification_reason}
-${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
-${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
-`;
-    })
-        .join('\n---\n');
-    // Format uncertain items with improvement suggestions
-    const uncertainItemsSection = verificationResult.item_verifications
-        .filter((v) => v.verification_status === 'uncertain')
-        .map((v, index) => {
-        return `### Uncertain Requirement ${index + 1}
-**Checklist Item ID**: ${v.checklist_item_id}
-**Satisfaction Status**: ${v.is_satisfied ? '✅ Satisfied' : '⚠️ Partially Satisfied'}
-**Verification Result**: ⚠️ UNCERTAIN
-**Reason**: ${v.verification_reason}
-${v.concerns && v.concerns.length > 0 ? `**Specific Concerns**:\n${v.concerns.map((c) => `- ${c}`).join('\n')}` : ''}
-${v.improvement_suggestions && v.improvement_suggestions.length > 0 ? `\n**💡 Improvement Suggestions**:\n${v.improvement_suggestions.map((s) => `- ${s}`).join('\n')}` : ''}
-`;
-    })
-        .join('\n---\n');
-    return `# Code Review Feedback - Improvements Required
-
-Your code implementation was reviewed by an independent code reviewer, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
-
-## Code Review Summary
-${verificationResult.summary}
-
-## Results Breakdown
-- ✅ Satisfied: ${verificationResult.confirmed_count}
-- ❌ Not Satisfied: ${verificationResult.rejected_count}
-- ⚠️ Partially Satisfied: ${verificationResult.uncertain_count}
-
-${verificationResult.overall_suggestions && verificationResult.overall_suggestions.length > 0 ? `## 💡 Overall Improvement Suggestions\n\n${verificationResult.overall_suggestions.map((s) => `- ${s}`).join('\n')}\n\n` : ''}
-
-${verificationResult.rejected_count > 0 ? `## ❌ Unsatisfied Requirements\n\n${rejectedItemsSection}` : ''}
-
-${verificationResult.uncertain_count > 0 ? `## ⚠️ Partially Satisfied Requirements\n\n${uncertainItemsSection}` : ''}
-
----
-
-## Your Task: Improve Your Code Implementation
-
-You are currently on branch **${branchName}** (based on ${baseBranch}). You need to **improve your code** to satisfy the checklist requirements.
-
-**What You Should Do**:
-
-1. **Review the improvement suggestions** provided above for each rejected/uncertain requirement
-2. **Follow the specific, actionable suggestions** from the code reviewer
-3. **Modify your code** to address the concerns and implement the suggested improvements
-4. **Fix code quality issues**, bugs, or security concerns identified
-5. **Ensure all requirements are adequately satisfied** based on the feedback
-6. **Commit your improvements** to the same branch
-
-**IMPORTANT Guidelines**:
-- **Pay close attention to the 💡 Improvement Suggestions** - these tell you exactly what to fix
-- **Address all concerns** raised by the reviewer
-- **Test your changes** to ensure they work correctly
-- **Follow best practices** for code quality, security, and performance
-- **Commit your improvements** with a clear message explaining what was fixed
-- The code will be reviewed again after your improvements
-
-**Git Workflow**:
-1. You are already on branch ${branchName}
-2. Make the necessary code changes based on feedback
-3. Run tests to ensure everything works
-4. Commit your improvements: \`git commit -m "fix: address code review feedback - <brief description>"\`
-
-**CRITICAL - Output Format**:
-You MUST return ONLY the JSON object below after completing your improvements. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
-
-\`\`\`json
-{
-  "implementation_result": {
-    "issue_id": "...",
-    "branch_name": "${branchName}",
-    "files_modified": ["list", "of", "modified", "files"],
-    "commit_hash": "new commit hash after improvements",
-    "summary": "Brief description of improvements made based on code review feedback",
-    "tests_passed": true,
-    "pre_commit_passed": true,
-    "checklist_item_results": [
-      {
-        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
-        "is_passed": true,
-        "value": "Result value based on item type",
-        "notes": "Optional notes about this checklist item"
-      }
-    ]
-  }
-}
-\`\`\`
-
-IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the code. The JSON should be the complete and only content of your response.
-
-Begin improving your code implementation based on the code review feedback.`;
-};

package/dist/phases/code-implementation-verification/agent.d.ts

@@ -1,32 +0,0 @@
-import { type EdsgerConfig } from '../../types/index.js';
-export interface ChecklistItemVerificationResult {
-    checklist_item_id: string;
-    is_satisfied: boolean;
-    verification_status: 'confirmed' | 'rejected' | 'uncertain';
-    verification_reason: string;
-    concerns?: string[];
-    improvement_suggestions?: string[];
-}
-export interface ChecklistVerificationResult {
-    overall_status: 'passed' | 'failed' | 'partial';
-    summary: string;
-    confirmed_count: number;
-    rejected_count: number;
-    uncertain_count: number;
-    item_verifications: ChecklistItemVerificationResult[];
-    overall_suggestions?: string[];
-    feedbacks_rejected_count?: number;
-}
-export interface VerifyCodeImplementationOptions {
-    issueId: string;
-    branchName: string;
-    baseBranch: string;
-    issueName: string;
-    issueDescription?: string;
-    checklistContext: string;
-    verbose?: boolean;
-}
-/**
- * Verify code implementation against checklist requirements by reviewing git diff
- */
-export declare function verifyCodeImplementationCompliance(options: VerifyCodeImplementationOptions, _config: EdsgerConfig): Promise<ChecklistVerificationResult>;

package/dist/phases/code-implementation-verification/agent.js

@@ -1,225 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { createCodeImplementationVerificationPrompt, createCodeImplementationVerificationSystemPrompt, } from './prompts.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(verificationPrompt) {
-    yield userMessage(verificationPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-const FAILED_VERIFICATION = {
-    overall_status: 'failed',
-    summary: 'Verification failed',
-    confirmed_count: 0,
-    rejected_count: 1,
-    uncertain_count: 0,
-    item_verifications: [],
-};
-/**
- * Find the start index of a JSON object containing the target key
- */
-function findJsonStartIndex(text, targetKey) {
-    if (!text.includes(targetKey)) {
-        return -1;
-    }
-    const targetIndex = text.indexOf(targetKey);
-    for (let i = targetIndex; i >= 0; i--) {
-        if (text[i] === '{') {
-            return i;
-        }
-    }
-    return -1;
-}
-/**
- * Find the matching closing brace for a JSON object starting at startIndex
- */
-function findMatchingCloseBrace(text, startIndex) {
-    let braceCount = 0;
-    let endIndex = startIndex;
-    let inString = false;
-    let escapeNext = false;
-    for (let i = startIndex; i < text.length; i++) {
-        const char = text[i];
-        if (escapeNext) {
-            escapeNext = false;
-            continue;
-        }
-        if (char === '\\' && inString) {
-            escapeNext = true;
-            continue;
-        }
-        if (char === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString) {
-            continue;
-        }
-        if (char === '{') {
-            braceCount++;
-        }
-        else if (char === '}') {
-            braceCount--;
-            if (braceCount === 0) {
-                endIndex = i;
-                break;
-            }
-        }
-    }
-    return endIndex;
-}
-/**
- * Extract a JSON result from response text using multiple strategies
- */
-function extractJsonFromResponse(responseText) {
-    // Strategy 1: markdown code block
-    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonBlockMatch) {
-        return JSON.parse(jsonBlockMatch[1]);
-    }
-    // Strategy 2: find JSON object containing "verification_result"
-    const jsonStartIndex = findJsonStartIndex(responseText, '"verification_result"');
-    if (jsonStartIndex !== -1) {
-        const endIndex = findMatchingCloseBrace(responseText, jsonStartIndex);
-        const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
-        try {
-            return JSON.parse(jsonStr);
-        }
-        catch (parseError) {
-            logError(`Failed to parse extracted JSON: ${parseError}`);
-            return JSON.parse(responseText);
-        }
-    }
-    // Strategy 3: parse entire response
-    return JSON.parse(responseText);
-}
-/**
- * Parse the verification result from a successful agent response
- */
-function parseVerificationResult(responseText, verbose) {
-    if (verbose) {
-        logInfo('\n✅ Code verification completed, parsing results...');
-    }
-    try {
-        const jsonResult = extractJsonFromResponse(responseText);
-        if (jsonResult?.verification_result) {
-            return jsonResult.verification_result;
-        }
-        throw new Error('Invalid JSON structure');
-    }
-    catch (error) {
-        logError(`Failed to parse verification result: ${error}`);
-        return {
-            ...FAILED_VERIFICATION,
-            summary: 'Verification failed due to parse error',
-        };
-    }
-}
-/**
- * Process assistant messages to accumulate response text
- */
-function processAssistantContent(
-// SDK 0.2.124+ tightened the BetaContentBlock union; accept the wider
-// shape and narrow at use sites. This helper only reads fields that
-// exist on the `text` and `tool_use` variants.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-content, responseAccumulator, verbose) {
-    if (content.type === 'text' && content.text) {
-        responseAccumulator.text += `${content.text}\n`;
-        logDebug(`🔍 ${content.text}`, verbose);
-    }
-    else if (content.type === 'tool_use') {
-        logDebug(`🔧 ${content.name}: ${content.input?.description || 'Running...'}`, verbose);
-    }
-}
-/**
- * Verify code implementation against checklist requirements by reviewing git diff
- */
-export async function verifyCodeImplementationCompliance(options, _config) {
-    const { issueId, branchName, baseBranch, issueName, issueDescription, checklistContext, verbose, } = options;
-    if (verbose) {
-        logInfo(`\n🔍 Starting code implementation verification for issue: ${issueName}`);
-        logInfo(`   Branch: ${branchName}`);
-        logInfo(`   Base: ${baseBranch}`);
-    }
-    try {
-        const systemPrompt = await createCodeImplementationVerificationSystemPrompt();
-        const verificationPrompt = createCodeImplementationVerificationPrompt({
-            issueId,
-            branchName,
-            baseBranch,
-            issueName,
-            issueDescription: issueDescription || '',
-            checklistContext,
-        });
-        const responseAccumulator = { text: '' };
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('🤖 Starting verification agent query...');
-        }
-        for await (const message of query({
-            prompt: prompt(verificationPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`   Received message type: ${message.type}`);
-            }
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const content of message.message.content) {
-                    processAssistantContent(content, responseAccumulator, verbose);
-                }
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype === 'success') {
-                const responseText = message.result || responseAccumulator.text;
-                verificationResult = parseVerificationResult(responseText, verbose);
-            }
-            else {
-                logError(`\n⚠️  Verification incomplete: ${message.subtype}`);
-                verificationResult = {
-                    ...FAILED_VERIFICATION,
-                    summary: 'Verification incomplete',
-                };
-            }
-        }
-        if (!verificationResult) {
-            return {
-                ...FAILED_VERIFICATION,
-                summary: 'No verification result received',
-            };
-        }
-        if (verbose) {
-            logInfo('\n📊 Verification Results:');
-            logInfo(`   Status: ${verificationResult.overall_status}`);
-            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
-            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
-            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
-        }
-        return verificationResult;
-    }
-    catch (error) {
-        logError(`Code verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            ...FAILED_VERIFICATION,
-            summary: `Verification error: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}

package/dist/phases/code-implementation-verification/index.d.ts

@@ -1,27 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
-export interface VerificationCycleResult {
-    passed: boolean;
-    verificationResult: ChecklistVerificationResult | null;
-    nextPrompt: string | null;
-}
-/**
- * Perform a complete verification cycle:
- * 1. Verify code implementation against checklist
- * 2. Log results to audit logs
- * 3. Create improvement prompt if verification failed
- */
-export interface PerformVerificationCycleOptions {
-    branchName: string;
-    baseBranch: string;
-    checklistContext: ChecklistPhaseContext | null;
-    issueId: string;
-    issueName: string;
-    issueDescription: string | undefined;
-    config: EdsgerConfig;
-    currentIteration: number;
-    maxIterations: number;
-    verbose?: boolean;
-}
-export declare function performVerificationCycle(opts: PerformVerificationCycleOptions): Promise<VerificationCycleResult>;

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

@@ -1,121 +0,0 @@
-import { logIssueVerificationEvent } from '../../services/audit-logs.js';
-import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createCodeImplementationImprovementPrompt } from '../code-implementation/prompts.js';
-import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/agent.js';
-export async function performVerificationCycle(opts) {
-    const { branchName, baseBranch, checklistContext, issueId, issueName, issueDescription, config, currentIteration, maxIterations, verbose, } = opts;
-    // If no checklist, verification passes automatically
-    if (!checklistContext || checklistContext.checklists.length === 0) {
-        if (verbose) {
-            logInfo('ℹ️  No checklists to verify - skipping verification');
-        }
-        return {
-            passed: true,
-            verificationResult: null,
-            nextPrompt: null,
-        };
-    }
-    if (verbose) {
-        logInfo(`\n🔍 Verifying code implementation (iteration ${currentIteration}/${maxIterations})...`);
-    }
-    // Format checklist context for verification
-    const checklistInfo = formatChecklistsForContext(checklistContext);
-    // Perform verification
-    const verificationResult = await verifyCodeImplementationCompliance({
-        issueId,
-        branchName,
-        baseBranch,
-        issueName,
-        issueDescription,
-        checklistContext: checklistInfo,
-        verbose,
-    }, config);
-    // Determine if verification passed
-    const verificationPassed = verificationResult.rejected_count === 0;
-    // Log verification result
-    if (verificationPassed) {
-        if (verbose) {
-            logInfo(`✅ Code verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
-        }
-        await logIssueVerificationEvent({
-            issueId,
-            phase: 'code_implementation',
-            iteration: currentIteration,
-            result: 'success',
-            verificationData: {
-                confirmed_count: verificationResult.confirmed_count,
-                rejected_count: verificationResult.rejected_count,
-                uncertain_count: verificationResult.uncertain_count,
-                summary: verificationResult.summary,
-            },
-        }, verbose);
-        // Create checklist results based on verification result
-        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
-            checklist_item_id: item.checklist_item_id,
-            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
-            value: item.verification_status,
-            notes: item.verification_reason || undefined,
-        }));
-        await processChecklistItemResultsFromResponse({ issueId }, 'code_implementation', checklistItemResults, verbose);
-    }
-    else {
-        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
-        await logIssueVerificationEvent({
-            issueId,
-            phase: 'code_implementation',
-            iteration: currentIteration,
-            result: 'error',
-            verificationData: {
-                confirmed_count: verificationResult.confirmed_count,
-                rejected_count: verificationResult.rejected_count,
-                uncertain_count: verificationResult.uncertain_count,
-                rejected_items: verificationResult.item_verifications
-                    .filter((item) => item.verification_status === 'rejected')
-                    .map((item) => ({
-                    checklist_item_id: item.checklist_item_id,
-                    reason: item.verification_reason || 'No reason provided',
-                    concerns: item.concerns || [],
-                    improvement_suggestions: item.improvement_suggestions || [],
-                })),
-                uncertain_items: verificationResult.item_verifications
-                    .filter((item) => item.verification_status === 'uncertain')
-                    .map((item) => ({
-                    checklist_item_id: item.checklist_item_id,
-                    reason: item.verification_reason || 'No reason provided',
-                    concerns: item.concerns || [],
-                    improvement_suggestions: item.improvement_suggestions || [],
-                })),
-                summary: verificationResult.summary,
-                overall_suggestions: verificationResult.overall_suggestions || [],
-            },
-        }, verbose);
-    }
-    // If verification failed and we have iterations left, create improvement prompt
-    let nextPrompt = null;
-    if (!verificationPassed && currentIteration < maxIterations) {
-        nextPrompt = createCodeImplementationImprovementPrompt(verificationResult, branchName, baseBranch);
-        if (verbose) {
-            logInfo(`\n📝 Created improvement prompt for next iteration (${maxIterations - currentIteration} attempts remaining)`);
-        }
-    }
-    else if (!verificationPassed) {
-        // Max iterations reached - create checklist results based on final verification
-        if (verbose) {
-            logInfo(`\n📋 Creating checklist results for final iteration (max iterations reached)`);
-        }
-        // Create checklist results for all items (both passed and failed)
-        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
-            checklist_item_id: item.checklist_item_id,
-            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
-            value: item.verification_status,
-            notes: item.verification_reason || undefined,
-        }));
-        await processChecklistItemResultsFromResponse({ issueId }, 'code_implementation', checklistItemResults, verbose);
-    }
-    return {
-        passed: verificationPassed,
-        verificationResult,
-        nextPrompt,
-    };
-}