edsger 0.76.0 → 0.78.0

package/dist/phases/technical-design/prompts.js

@@ -1,210 +0,0 @@
-import { processConditionals, resolveSkill, substituteVariables, } from '../../services/skill-resolver.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createTechnicalDesignSystemPrompt = async (_config, mcpServerUrl, mcpToken, issueId, projectDir) => {
-    const skill = await resolveSkill('phase/technical-design', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/technical-design');
-    }
-    let { prompt } = skill;
-    prompt = substituteVariables(prompt, {
-        MCP_SERVER_URL: mcpServerUrl || '',
-        MCP_TOKEN: mcpToken || '',
-    });
-    prompt = processConditionals(prompt, {
-        hasMcp: !!(mcpServerUrl && mcpToken && issueId),
-    });
-    return `${prompt}\n\n${OUTPUT_CONTRACTS['technical-design']}`;
-};
-export const createTechnicalDesignPromptWithContext = (issueId, contextInfo, existingTechnicalDesign, isIncrementalUpdate = false) => {
-    // If incremental update mode (existing design + feedbacks), create focused update prompt
-    if (isIncrementalUpdate && existingTechnicalDesign) {
-        return `Update the technical design for issue ID: ${issueId} based on human feedbacks
-
-## Current Technical Design
-
-${existingTechnicalDesign}
-
-## Context and Feedbacks
-
-${contextInfo}
-
-## IMPORTANT: Incremental Update Mode - Feedback-Only Updates
-
-You are in **INCREMENTAL UPDATE** mode. This means:
-
-1. **DO NOT redesign from scratch** - The current technical design is already approved
-2. **Focus ONLY on the feedbacks provided** - Address each feedback point specifically
-3. **Make targeted modifications** - Only change the sections that feedbacks request
-4. **Preserve approved sections** - Keep all parts of the design that are not mentioned in feedbacks
-5. **Track changes** - In your summary, clearly indicate what was modified and why
-
-**CRITICAL RULE**:
-- **ONLY optimize based on feedbacks** - Do NOT make other improvements or optimizations
-- **Do NOT proactively improve** other parts of the design that feedbacks don't mention
-- **Do NOT add issues** that feedbacks don't request
-- **Do NOT refactor** sections that feedbacks don't ask about
-- If you see potential improvements but no feedback requests them, IGNORE them
-- Your job is ONLY to address the specific feedbacks, nothing more
-
-## Update Instructions
-
-Follow this focused approach:
-
-1. **Review Current Design**: Carefully read the existing technical design above
-2. **Analyze Feedbacks**: Understand what specific changes are requested in the feedbacks
-3. **Make Targeted Updates**:
-   - Address each feedback point one by one
-   - Modify only the relevant sections of the design
-   - Preserve the structure and content of unchanged sections
-   - DO NOT touch sections that feedbacks don't mention
-4. **Verify Completeness**: Ensure all feedbacks have been addressed
-
-## Important Notes
-- This is NOT a full redesign - only update what feedbacks specifically request
-- DO NOT make improvements that feedbacks don't ask for
-- Maintain consistency with the existing design's structure and style
-- If a feedback is unclear, make your best interpretation and note it in recommendations
-- Keep all approved content that is not mentioned in feedbacks
-- Your summary should list ONLY the feedbacks addressed and the changes made for each
-
-Begin by reviewing the feedbacks and identifying which sections of the current design need updates.`;
-    }
-    // Default mode: full design (either new design or full redesign)
-    const designMode = existingTechnicalDesign
-        ? 'Update and improve the existing technical design, or redesign if needed'
-        : 'Generate a comprehensive technical design';
-    return `${designMode} for issue ID: ${issueId}
-
-${existingTechnicalDesign ? `## Existing Technical Design\n\n${existingTechnicalDesign}\n\n` : ''}${contextInfo}
-
-## Technical Design Instructions
-
-Follow this systematic approach:
-
-1. **Repository Analysis**: First, analyze the current codebase to understand the technology stack and architecture:
-   - Use Glob to find configuration files: package.json, tsconfig.json, next.config.js, tailwind.config.js
-   - Use Read to examine package.json to understand dependencies and tech stack
-   - Use Glob to understand project structure: src/app/**, src/components/**, src/services/**
-   - Look for database schema files, migration files, and configuration
-   - Examine README.md, CLAUDE.md or other documentation files if they exist
-
-2. **Technical Design Creation**: Create comprehensive technical design documentation that addresses:
-   - **Architecture Overview**: How the issue integrates with the existing system
-   - **Component Design**: Frontend components, backend services, database changes needed
-   - **Data Flow**: How data moves through the system for this issue
-   - **API Design**: Endpoints, request/response formats, error handling
-   - **Database Design**: Schema changes, indexes, relationships, migration strategy
-   - **Security**: Authentication, authorization, data validation requirements
-   - **Performance**: Caching strategies, optimization, scalability considerations
-   - **Testing Strategy**: Unit, integration, and end-to-end testing approaches
-   - **Deployment**: How the issue will be deployed and monitored
-
-3. **Implementation Guidance**: Provide specific implementation recommendations and considerations
-
-## Important Notes
-- Focus on creating detailed architectural specifications
-- Consider the user stories to understand what needs to be built
-- Use test cases to inform testing strategy and validation approaches
-${existingTechnicalDesign ? '- Build upon or improve the existing technical design provided above' : '- Create a complete new technical design from scratch'}
-- Consider integration with existing systems and architecture
-- Address scalability, maintainability, and performance requirements
-
-Begin by analyzing the repository structure to understand the current technology stack, then create the comprehensive technical design.`;
-};
-/**
- * Create a prompt for the technical design agent to improve based on verification feedback
- */
-export const createTechnicalDesignImprovementPrompt = (verificationResult, previousDesign) => {
-    // 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 `# Verification Feedback - Design Improvements Required
-
-Your previous technical design was verified, and **${verificationResult.rejected_count} checklist requirements were NOT SATISFIED** and **${verificationResult.uncertain_count} requirements are PARTIALLY SATISFIED**.
-
-## Verification 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}` : ''}
-
-<!-- PREVIOUS_DESIGN_START -->
-## Your Previous Technical Design
-
-${previousDesign}
-<!-- PREVIOUS_DESIGN_END -->
-
----
-
-## Your Task: Improve Your Technical Design
-
-You need to **revise and improve** your technical design document 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** - they tell you exactly what to add or modify
-3. **Expand and enhance** the technical design document as suggested by the verifier
-4. **Add missing sections, diagrams, or specifications** as indicated
-5. **Ensure each requirement is adequately covered** based on the feedback
-
-**IMPORTANT Guidelines**:
-- **Pay close attention to the 💡 Improvement Suggestions** - these are specific actions you should take
-- You can **keep the good parts** of your existing design
-- **Add NEW sections and details** exactly as suggested to satisfy the unsatisfied requirements
-- **Be specific and technical** - your design will be verified again
-- The suggestions are your roadmap - follow them to ensure verification passes
-- Ensure your design directly addresses the checklist requirements with sufficient technical depth
-
-**CRITICAL - Output Format**:
-You MUST return ONLY the JSON object below. Do NOT include any explanatory text, commentary, or markdown before or after the JSON. Return ONLY the JSON in this exact format:
-
-\`\`\`json
-{
-  "technical_design_result": {
-    "issue_id": "...",
-    "status": "success",
-    "summary": "Improved technical design based on verification feedback",
-    "technical_design": "The COMPLETE improved technical design document in markdown format",
-    "recommendations": "..."
-  }
-}
-\`\`\`
-
-IMPORTANT: Return ONLY the JSON above. Do not add any text explaining what you did or how you improved the design. The JSON should be the complete and only content of your response.`;
-};

package/dist/phases/technical-design-verification/agent.d.ts

@@ -1,53 +0,0 @@
-/**
- * Checklist verification agent for technical design
- * This agent independently reviews checklist compliance to ensure quality
- */
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type FeedbacksContext } from '../../services/feedbacks.js';
-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 FeedbackVerificationResult {
-    feedback_id: string;
-    feedback_title: string;
-    is_addressed: boolean;
-    verification_status: 'confirmed' | 'rejected' | 'uncertain';
-    verification_reason: string;
-    concerns?: string[];
-    improvement_suggestions?: string[];
-}
-export interface ChecklistVerificationResult {
-    all_verified: boolean;
-    total_items: number;
-    confirmed_count: number;
-    rejected_count: number;
-    uncertain_count: number;
-    item_verifications: ChecklistItemVerificationResult[];
-    feedbacks_verified?: boolean;
-    total_feedbacks?: number;
-    feedbacks_confirmed_count?: number;
-    feedbacks_rejected_count?: number;
-    feedbacks_uncertain_count?: number;
-    feedback_verifications?: FeedbackVerificationResult[];
-    summary: string;
-    overall_suggestions?: string[];
-}
-export interface VerifyTechnicalDesignOptions {
-    checklistContext: ChecklistPhaseContext;
-    feedbacksContext?: FeedbacksContext | null;
-    issueId: string;
-    issueName: string;
-    issueDescription?: string;
-    technicalDesign: string;
-    verbose?: boolean;
-}
-/**
- * Verify checklist compliance for technical design using an independent AI agent
- */
-export declare function verifyTechnicalDesignCompliance(options: VerifyTechnicalDesignOptions, _config: EdsgerConfig): Promise<ChecklistVerificationResult>;

package/dist/phases/technical-design-verification/agent.js

@@ -1,186 +0,0 @@
-/**
- * Checklist verification agent for technical design
- * This agent independently reviews checklist compliance to ensure quality
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { createTechnicalDesignVerificationPrompt, createTechnicalDesignVerificationSystemPrompt, } from './prompts.js';
-/**
- * Extract text content from assistant message content array
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractTextFromContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`🔍 ${item.text}`, verbose);
-        }
-    }
-    return text;
-}
-/**
- * Parse the verification result from response text
- */
-function parseVerificationResponse(responseText, checklistContext
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    try {
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const jsonResult = jsonBlockMatch
-            ? JSON.parse(jsonBlockMatch[1])
-            : JSON.parse(responseText);
-        if (jsonResult && jsonResult.verification) {
-            return jsonResult.verification;
-        }
-        throw new Error('Invalid verification JSON structure');
-    }
-    catch (error) {
-        logError(`Failed to parse verification result: ${error}`);
-        return createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
-    }
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(verificationPrompt) {
-    yield userMessage(verificationPrompt);
-}
-/**
- * Verify checklist compliance for technical design using an independent AI agent
- */
-// eslint-disable-next-line complexity -- orchestration function with checklist verification and result processing
-export async function verifyTechnicalDesignCompliance(options, _config) {
-    const { checklistContext, feedbacksContext, issueId, issueName, issueDescription, technicalDesign, verbose, } = options;
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    const totalFeedbacks = feedbacksContext?.feedbacks?.length || 0;
-    const hasFeedbacks = totalFeedbacks > 0;
-    if (verbose) {
-        logInfo('🔍 Starting technical design verification...');
-        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
-        if (hasFeedbacks) {
-            logInfo(`   Verifying ${totalFeedbacks} human feedbacks`);
-        }
-    }
-    try {
-        const systemPrompt = await createTechnicalDesignVerificationSystemPrompt();
-        const verificationPrompt = await createTechnicalDesignVerificationPrompt({
-            checklistContext,
-            feedbacksContext: feedbacksContext || undefined,
-            issueId,
-            issueName,
-            issueDescription,
-            technicalDesign,
-        });
-        let lastAssistantResponse = '';
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('🤖 Starting verification agent query...');
-        }
-        // Use Claude Code SDK for verification
-        for await (const message of query({
-            prompt: prompt(verificationPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 100,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`   Received message type: ${message.type}`);
-            }
-            // Capture assistant responses
-            if (message.type === 'assistant') {
-                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype === 'success') {
-                logInfo('\n✅ Verification completed, parsing results...');
-                verificationResult = parseVerificationResponse(message.result || lastAssistantResponse, checklistContext);
-            }
-            else {
-                logError(`\n⚠️ Verification incomplete: ${message.subtype}`);
-                verificationResult = createUncertainVerificationResult(checklistContext, `Verification incomplete: ${message.subtype}`);
-            }
-        }
-        if (!verificationResult) {
-            verificationResult = createUncertainVerificationResult(checklistContext, 'No verification result received');
-        }
-        if (verbose) {
-            logInfo('\n📊 Verification Summary:');
-            logInfo(`   Total checklist items: ${verificationResult.total_items}`);
-            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
-            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
-            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
-            if (verificationResult.total_feedbacks &&
-                verificationResult.total_feedbacks > 0) {
-                logInfo(`\n   Total feedbacks: ${verificationResult.total_feedbacks}`);
-                logInfo(`   ✅ Confirmed: ${verificationResult.feedbacks_confirmed_count || 0}`);
-                logInfo(`   ❌ Rejected: ${verificationResult.feedbacks_rejected_count || 0}`);
-                logInfo(`   ⚠️  Uncertain: ${verificationResult.feedbacks_uncertain_count || 0}`);
-            }
-            logInfo(`\n   Summary: ${verificationResult.summary}`);
-            if (verificationResult.rejected_count > 0) {
-                logInfo('\n❌ Rejected checklist items:');
-                verificationResult.item_verifications
-                    .filter((v) => v.verification_status === 'rejected')
-                    .forEach((v) => {
-                    logInfo(`   - ${v.checklist_item_id}`);
-                    logInfo(`     Reason: ${v.verification_reason}`);
-                });
-            }
-            if (verificationResult.feedbacks_rejected_count &&
-                verificationResult.feedbacks_rejected_count > 0) {
-                logInfo('\n❌ Rejected feedbacks:');
-                verificationResult.feedback_verifications
-                    ?.filter((v) => v.verification_status === 'rejected')
-                    .forEach((v) => {
-                    logInfo(`   - ${v.feedback_title}`);
-                    logInfo(`     Reason: ${v.verification_reason}`);
-                });
-            }
-        }
-        return verificationResult;
-    }
-    catch (error) {
-        logError(`Technical design verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        return createUncertainVerificationResult(checklistContext, `Verification error: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Create a default "uncertain" verification result when verification fails
- */
-function createUncertainVerificationResult(checklistContext, reason) {
-    // Get all checklist items
-    const allItems = (checklistContext?.checklists ?? []).flatMap((checklist) => checklist.items.map((item) => ({
-        checklist_item_id: item.id,
-    })));
-    return {
-        all_verified: false,
-        total_items: allItems.length,
-        confirmed_count: 0,
-        rejected_count: 0,
-        uncertain_count: allItems.length,
-        item_verifications: allItems.map((item) => ({
-            checklist_item_id: item.checklist_item_id,
-            is_satisfied: false,
-            verification_status: 'uncertain',
-            verification_reason: reason,
-        })),
-        summary: `Verification could not be completed: ${reason}`,
-    };
-}

package/dist/phases/technical-design-verification/index.d.ts

@@ -1,38 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type FeedbacksContext } from '../../services/feedbacks.js';
-import { type EdsgerConfig } from '../../types/index.js';
-import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
-export interface TechnicalDesignResult {
-    issueId: string;
-    technicalDesign: string | null;
-    status: 'success' | 'error';
-    summary: string;
-    verificationResult?: ChecklistVerificationResult;
-    iterations?: number;
-    data?: {
-        checklist_item_results?: unknown[];
-        [key: string]: unknown;
-    };
-}
-interface VerificationCycleResult {
-    passed: boolean;
-    verificationResult: ChecklistVerificationResult | null;
-    nextPrompt?: string;
-}
-/**
- * Perform verification and determine if iteration should continue
- */
-export interface TechnicalDesignVerificationOptions {
-    technicalDesign: string;
-    checklistContext: ChecklistPhaseContext | null;
-    feedbacksContext: FeedbacksContext | null;
-    issueId: string;
-    issueName: string;
-    issueDescription: string | undefined;
-    config: EdsgerConfig;
-    currentIteration: number;
-    maxIterations: number;
-    verbose?: boolean;
-}
-export declare function performVerificationCycle(opts: TechnicalDesignVerificationOptions): Promise<VerificationCycleResult>;
-export {};

package/dist/phases/technical-design-verification/index.js

@@ -1,152 +0,0 @@
-import { logIssueVerificationEvent } from '../../services/audit-logs.js';
-import { processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
-import { resolveFeedbacks, } from '../../services/feedbacks.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createTechnicalDesignImprovementPrompt } from '../technical-design/prompts.js';
-import { verifyTechnicalDesignCompliance, } from '../technical-design-verification/agent.js';
-// eslint-disable-next-line complexity -- orchestration function coordinating design verification and improvement cycles
-export async function performVerificationCycle(opts) {
-    const { technicalDesign, checklistContext, feedbacksContext, issueId, issueName, issueDescription, config, currentIteration, maxIterations, verbose, } = opts;
-    // No verification needed if no checklist context
-    if (!checklistContext || checklistContext.checklists.length === 0) {
-        return { passed: true, verificationResult: null };
-    }
-    if (verbose) {
-        logInfo('🔍 Starting technical design verification...');
-    }
-    const verificationResult = await verifyTechnicalDesignCompliance({
-        checklistContext,
-        feedbacksContext,
-        issueId,
-        issueName,
-        issueDescription,
-        technicalDesign,
-        verbose,
-    }, config);
-    // Verification passed (both checklists and feedbacks)
-    const feedbacksPassed = !verificationResult.feedbacks_rejected_count ||
-        verificationResult.feedbacks_rejected_count === 0;
-    const checklistsPassed = verificationResult.rejected_count === 0;
-    if (checklistsPassed && feedbacksPassed) {
-        if (verbose) {
-            logInfo(`✅ Checklist verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
-            if (verificationResult.total_feedbacks &&
-                verificationResult.total_feedbacks > 0) {
-                logInfo(`✅ Feedback verification passed: ${verificationResult.feedbacks_confirmed_count || 0} confirmed, ${verificationResult.feedbacks_uncertain_count || 0} uncertain`);
-            }
-        }
-        // Log verification success
-        await logIssueVerificationEvent({
-            issueId,
-            phase: 'technical_design',
-            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 }, 'technical_design', checklistItemResults, verbose);
-        // Mark confirmed feedbacks as resolved
-        if (verificationResult.feedback_verifications &&
-            verificationResult.feedback_verifications.length > 0) {
-            const confirmedFeedbackIds = verificationResult.feedback_verifications
-                .filter((fb) => fb.verification_status === 'confirmed')
-                .map((fb) => fb.feedback_id);
-            if (confirmedFeedbackIds.length > 0) {
-                await resolveFeedbacks({ issueId }, confirmedFeedbackIds, verbose);
-            }
-        }
-        return { passed: true, verificationResult };
-    }
-    // Verification failed
-    const errorMessages = [];
-    if (!checklistsPassed) {
-        errorMessages.push(`${verificationResult.rejected_count} checklist items rejected, ${verificationResult.uncertain_count} uncertain`);
-    }
-    if (!feedbacksPassed && verificationResult.feedbacks_rejected_count) {
-        errorMessages.push(`${verificationResult.feedbacks_rejected_count} feedbacks not addressed, ${verificationResult.feedbacks_uncertain_count || 0} uncertain`);
-    }
-    logError(`❌ Iteration ${currentIteration}: Verification FAILED - ${errorMessages.join('; ')}`);
-    // Log verification failure with improvement suggestions
-    await logIssueVerificationEvent({
-        issueId,
-        phase: 'technical_design',
-        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 || [],
-            })),
-            // Include feedback verification results
-            feedbacks_confirmed_count: verificationResult.feedbacks_confirmed_count || 0,
-            feedbacks_rejected_count: verificationResult.feedbacks_rejected_count || 0,
-            feedbacks_uncertain_count: verificationResult.feedbacks_uncertain_count || 0,
-            rejected_feedbacks: verificationResult.feedback_verifications
-                ?.filter((fb) => fb.verification_status === 'rejected')
-                .map((fb) => ({
-                feedback_id: fb.feedback_id,
-                feedback_title: fb.feedback_title,
-                reason: fb.verification_reason || 'No reason provided',
-                concerns: fb.concerns || [],
-                improvement_suggestions: fb.improvement_suggestions || [],
-            })) || [],
-            uncertain_feedbacks: verificationResult.feedback_verifications
-                ?.filter((fb) => fb.verification_status === 'uncertain')
-                .map((fb) => ({
-                feedback_id: fb.feedback_id,
-                feedback_title: fb.feedback_title,
-                reason: fb.verification_reason || 'No reason provided',
-                concerns: fb.concerns || [],
-                improvement_suggestions: fb.improvement_suggestions || [],
-            })) || [],
-            summary: verificationResult.summary,
-            overall_suggestions: verificationResult.overall_suggestions || [],
-        },
-    }, verbose);
-    // Check if we can iterate again
-    if (currentIteration < maxIterations) {
-        if (verbose) {
-            logInfo(`   Will retry with improvement feedback (${maxIterations - currentIteration} attempts remaining)`);
-        }
-        // Create improvement prompt for next iteration
-        const nextPrompt = createTechnicalDesignImprovementPrompt(verificationResult, technicalDesign);
-        return { passed: false, verificationResult, nextPrompt };
-    }
-    // Max iterations reached - create checklist results based on final verification
-    logError(`❌ Maximum iterations (${maxIterations}) reached. Checklist verification still failing.`);
-    // 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 }, 'technical_design', checklistItemResults, verbose);
-    return { passed: false, verificationResult };
-}

package/dist/phases/technical-design-verification/prompts.d.ts

@@ -1,12 +0,0 @@
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import { type FeedbacksContext } from '../../services/feedbacks.js';
-export declare const createTechnicalDesignVerificationSystemPrompt: (projectDir?: string) => Promise<string>;
-export interface TechnicalDesignVerificationPromptOptions {
-    checklistContext: ChecklistPhaseContext;
-    feedbacksContext?: FeedbacksContext;
-    issueId: string;
-    issueName: string;
-    issueDescription?: string;
-    technicalDesign: string;
-}
-export declare const createTechnicalDesignVerificationPrompt: (options: TechnicalDesignVerificationPromptOptions) => Promise<string>;