edsger 0.2.3 → 0.2.4

package/dist/phases/feature-analysis/analyzer.js

@@ -1,22 +1,10 @@
-import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
-import { saveDataViaHttp } from './http-fallback.js';
 import { fetchFeatureAnalysisContext, } from './context-fetcher.js';
-import { createUserStories } from '../../api/features/index.js';
-import { createTestCases } from '../../api/features/index.js';
 import { formatFeatureAnalysisContext } from '../../prompts/formatters.js';
 import { createFeatureAnalysisSystemPrompt, createFeatureAnalysisPromptWithContext, } from '../../prompts/feature-analysis.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content: content },
-    };
-}
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-    await new Promise((res) => setTimeout(res, 10000));
-}
+import { executeAnalysisQuery, performVerificationCycle, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, deleteArtifacts, buildAnalysisResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 export const analyzeFeatureWithMCP = async (options, config, checklistContext) => {
     const { featureId, mcpServerUrl, mcpToken, verbose } = options;
     if (verbose) {
@@ -24,230 +12,128 @@ export const analyzeFeatureWithMCP = async (options, config, checklistContext) =
         logInfo(`Using MCP server: ${mcpServerUrl}`);
     }
     try {
-        // Fetch all required context information via MCP endpoints
-        if (verbose) {
-            logInfo('Fetching feature analysis context via MCP endpoints...');
-        }
-        const context = await fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, featureId, verbose);
+        // Fetch and prepare context
+        const context = await prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose);
         const systemPrompt = createFeatureAnalysisSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
-        const { content: contextInfo, downloadedImages } = await formatFeatureAnalysisContext(context);
-        if (verbose && downloadedImages.length > 0) {
-            logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
-            downloadedImages.forEach((img) => {
-                logInfo(`  - ${img.url} -> ${img.localPath}`);
-            });
-        }
-        // Add checklist context to the analysis prompt
-        let finalContextInfo = contextInfo;
-        if (checklistContext && checklistContext.checklists.length > 0) {
-            const checklistInfo = formatChecklistsForContext(checklistContext);
-            finalContextInfo = contextInfo + '\n\n' + checklistInfo;
-            if (verbose) {
-                logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
-            }
-        }
-        const analysisPrompt = createFeatureAnalysisPromptWithContext(featureId, finalContextInfo);
-        let lastAssistantResponse = '';
+        const initialAnalysisPrompt = context.analysisPrompt;
+        const maxIterations = options.maxVerificationIterations || 10;
+        let currentIteration = 0;
+        let currentPrompt = initialAnalysisPrompt;
         let structuredAnalysisResult = null;
+        let verificationResult = null;
         if (verbose) {
             logInfo('Starting Claude Code query with pre-fetched information...');
         }
-        // Use Claude Code SDK without MCP servers - all info is pre-fetched
-        for await (const message of query({
-            prompt: prompt(analysisPrompt),
-            options: {
-                appendSystemPrompt: systemPrompt,
-                model: config.claude.model || 'sonnet',
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
+        // Iterative improvement loop: analysis → save draft → verification → update ready or delete → re-analysis
+        let currentDraftUserStoryIds = [];
+        let currentDraftTestCaseIds = [];
+        while (currentIteration < maxIterations) {
+            currentIteration++;
+            if (verbose && currentIteration > 1) {
+                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving analysis based on verification feedback...`);
             }
-            // Stream the analysis process and capture assistant responses
-            if (message.type === 'assistant' && message.message?.content) {
-                for (const content of message.message.content) {
-                    if (content.type === 'text') {
-                        lastAssistantResponse += content.text + '\n';
-                        if (verbose) {
-                            console.log(`\n🤖 ${content.text}`);
-                        }
-                    }
-                    else if (content.type === 'tool_use') {
-                        if (verbose) {
-                            console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
-                        }
-                    }
-                }
+            // Log iteration start (for iterations after the first)
+            if (currentIteration > 1) {
+                await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                    featureId,
+                    eventType: 'phase_started',
+                    phase: 'feature_analysis',
+                    result: 'info',
+                    metadata: {
+                        iteration: currentIteration,
+                        max_iterations: maxIterations,
+                        re_analysis: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
             }
-            if (message.type === 'result') {
-                if (message.subtype === 'success') {
-                    logInfo('\n📊 Feature analysis completed, parsing results...');
-                    try {
-                        // Try to extract JSON from markdown code block or parse directly
-                        const responseText = message.result || lastAssistantResponse;
-                        let jsonResult = null;
-                        // First try to extract JSON from markdown code block
-                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                        if (jsonBlockMatch) {
-                            jsonResult = JSON.parse(jsonBlockMatch[1]);
-                        }
-                        else {
-                            // Try to parse the entire response as JSON
-                            jsonResult = JSON.parse(responseText);
-                        }
-                        if (jsonResult && jsonResult.analysis) {
-                            structuredAnalysisResult = jsonResult.analysis;
-                        }
-                        else {
-                            throw new Error('Invalid JSON structure');
-                        }
-                    }
-                    catch (error) {
-                        logError(`Failed to parse structured analysis result: ${error}`);
-                        structuredAnalysisResult = {
-                            status: 'error',
-                            summary: 'Failed to parse analysis results from Claude Code response',
-                            created_user_stories: [],
-                            created_test_cases: [],
-                        };
-                    }
-                }
-                else {
-                    logError(`\n⚠️  Analysis incomplete: ${message.subtype}`);
-                    if (message.subtype === 'error_max_turns') {
-                        logError('💡 Try increasing timeout or reducing complexity');
-                    }
-                    // Try to parse results from the last assistant response
-                    if (lastAssistantResponse) {
-                        try {
-                            const responseText = lastAssistantResponse;
-                            let jsonResult = null;
-                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                            if (jsonBlockMatch) {
-                                jsonResult = JSON.parse(jsonBlockMatch[1]);
-                                if (jsonResult && jsonResult.analysis) {
-                                    structuredAnalysisResult = jsonResult.analysis;
-                                }
-                            }
-                        }
-                        catch (error) {
-                            logError(`Failed to parse assistant response: ${error}`);
-                        }
-                    }
-                }
+            // Execute analysis query
+            structuredAnalysisResult = await executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose);
+            // No result produced, break out
+            if (!structuredAnalysisResult) {
+                break;
             }
-        }
-        // Save the analysis results if we have them
-        if (structuredAnalysisResult) {
-            const { created_user_stories, created_test_cases, status, checklist_results, checklist_item_results, } = structuredAnalysisResult;
-            if (created_user_stories && created_user_stories.length > 0) {
+            // Log analysis completion for this iteration
+            await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                featureId,
+                eventType: 'phase_completed',
+                phase: 'feature_analysis',
+                result: 'success',
+                metadata: {
+                    iteration: currentIteration,
+                    max_iterations: maxIterations,
+                    analysis_step: 'completed',
+                    user_stories_count: structuredAnalysisResult.created_user_stories?.length || 0,
+                    test_cases_count: structuredAnalysisResult.created_test_cases?.length || 0,
+                    timestamp: new Date().toISOString(),
+                },
+            }, verbose);
+            // Save artifacts as draft and get their IDs
+            const { userStoryIds, testCaseIds } = await saveAnalysisArtifactsAsDraft(mcpServerUrl, mcpToken, featureId, structuredAnalysisResult.created_user_stories || [], structuredAnalysisResult.created_test_cases || [], verbose);
+            currentDraftUserStoryIds = userStoryIds;
+            currentDraftTestCaseIds = testCaseIds;
+            // Perform verification cycle
+            const verificationCycle = await performVerificationCycle(structuredAnalysisResult, checklistContext || null, context.featureContext, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, featureId, verbose);
+            verificationResult = verificationCycle.verificationResult;
+            // If verification passed, update artifacts to ready and exit
+            if (verificationCycle.passed) {
                 if (verbose) {
-                    logInfo('Saving created user stories...');
-                }
-                const userStoriesCreated = await createUserStories(mcpServerUrl, mcpToken, featureId, created_user_stories, verbose);
-                if (!userStoriesCreated && verbose) {
-                    logError('⚠️ Failed to save user stories');
+                    logInfo('✅ Verification passed! Updating artifacts to ready status...');
                 }
+                await updateArtifactsToReady(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                break;
             }
-            if (created_test_cases && created_test_cases.length > 0) {
+            // Verification failed
+            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
+                // We have more iterations - delete draft artifacts and retry
                 if (verbose) {
-                    logInfo('Saving created test cases...');
-                }
-                const testCasesCreated = await createTestCases(mcpServerUrl, mcpToken, featureId, created_test_cases, verbose);
-                if (!testCasesCreated && verbose) {
-                    logError('⚠️ Failed to save test cases');
+                    logInfo('🗑️  Deleting draft artifacts for re-analysis...');
                 }
+                await deleteArtifacts(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
+                // Continue with improvement prompt
+                currentPrompt = verificationCycle.nextPrompt;
             }
-            // Try HTTP fallback if direct save failed
-            if (status === 'error' &&
-                (created_user_stories?.length > 0 || created_test_cases?.length > 0)) {
+            else {
+                // Max iterations reached or no next prompt - exit loop
+                // Draft artifacts remain in database for manual review
                 if (verbose) {
-                    logInfo('Direct save failed, trying HTTP fallback...');
-                }
-                const httpSuccess = await saveDataViaHttp({
-                    mcpServerUrl,
-                    mcpToken,
-                    featureId,
-                    userStories: created_user_stories || [],
-                    testCases: created_test_cases || [],
-                    verbose,
-                });
-                if (httpSuccess) {
-                    logInfo('✅ Successfully saved data via HTTP fallback');
-                    structuredAnalysisResult.status = 'success';
-                    structuredAnalysisResult.summary =
-                        (structuredAnalysisResult.summary || '') +
-                            ' (saved via HTTP fallback)';
+                    logInfo('⚠️  Max iterations reached. Draft artifacts kept for manual review.');
                 }
-                else if (verbose) {
-                    logError('❌ HTTP fallback also failed');
+                break;
+            }
+        }
+        // Handle results
+        if (!structuredAnalysisResult) {
+            return buildNoResultsError(featureId, context.featureContext);
+        }
+        const { created_user_stories, created_test_cases, status, checklist_results, checklist_item_results, } = structuredAnalysisResult;
+        // If no checklist was used, update draft artifacts to ready now
+        if (!checklistContext ||
+            checklistContext.checklists.length === 0 ||
+            !verificationResult) {
+            if (currentDraftUserStoryIds.length > 0 ||
+                currentDraftTestCaseIds.length > 0) {
+                if (verbose) {
+                    logInfo('✅ No checklist verification needed. Updating artifacts to ready status...');
                 }
+                await updateArtifactsToReady(mcpServerUrl, mcpToken, currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
             }
-            return {
-                featureId,
-                productInfo: context.product,
-                featureInfo: context.feature,
-                existingUserStories: context.existing_user_stories.map((story) => ({
-                    ...story,
-                    status: story.status,
-                    created_at: story.created_at || new Date().toISOString(),
-                    updated_at: story.updated_at || new Date().toISOString(),
-                })),
-                existingTestCases: context.existing_test_cases.map((testCase) => ({
-                    ...testCase,
-                    created_at: testCase.created_at || new Date().toISOString(),
-                    updated_at: testCase.updated_at || new Date().toISOString(),
-                })),
-                createdUserStories: (created_user_stories || []).map((story) => ({
-                    id: '',
-                    title: story.title,
-                    description: story.description,
-                    status: story.status || 'draft',
-                    created_at: new Date().toISOString(),
-                    updated_at: new Date().toISOString(),
-                })),
-                createdTestCases: (created_test_cases || []).map((testCase) => ({
-                    id: '',
-                    name: testCase.name,
-                    description: testCase.description,
-                    is_critical: testCase.is_critical || false,
-                    created_at: new Date().toISOString(),
-                    updated_at: new Date().toISOString(),
-                })),
-                summary: structuredAnalysisResult.summary || 'Analysis completed',
-                status: structuredAnalysisResult.status === 'success' ? 'success' : 'error',
-                data: {
-                    checklist_results,
-                    checklist_item_results,
-                },
-            };
         }
-        return {
-            featureId,
-            productInfo: context.product,
-            featureInfo: context.feature,
-            existingUserStories: context.existing_user_stories.map((story) => ({
-                ...story,
-                status: story.status,
-                created_at: story.created_at || new Date().toISOString(),
-                updated_at: story.updated_at || new Date().toISOString(),
-            })),
-            existingTestCases: context.existing_test_cases.map((testCase) => ({
-                ...testCase,
-                created_at: testCase.created_at || new Date().toISOString(),
-                updated_at: testCase.updated_at || new Date().toISOString(),
-            })),
-            createdUserStories: [],
-            createdTestCases: [],
-            summary: 'No analysis results received',
-            status: 'error',
-            data: {
-                checklist_results: undefined,
-                checklist_item_results: undefined,
-            },
-        };
+        // Check if verification failed after all iterations
+        // Note: Artifacts are already saved as draft in the database
+        // If verification failed, they remain as draft for manual review
+        if (verificationResult &&
+            verificationResult.rejected_count > 0 &&
+            checklistContext &&
+            checklistContext.checklists.length > 0) {
+            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
+            logError(`   Draft artifacts (${currentDraftUserStoryIds.length} user stories, ${currentDraftTestCaseIds.length} test cases) kept for manual review`);
+            return buildVerificationFailureResult(featureId, context.featureContext, verificationResult, checklist_results, checklist_item_results, currentIteration);
+        }
+        // Return success result
+        // Note: Artifacts have already been saved and updated to 'ready' status (if verification passed)
+        // or remain as draft (if verification failed)
+        return buildAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
     }
     catch (error) {
         logError(`Feature analysis failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -264,6 +150,33 @@ export const analyzeFeatureWithMCP = async (options, config, checklistContext) =
         };
     }
 };
+/**
+ * Prepare all context information needed for analysis
+ */
+async function prepareAnalysisContext(mcpServerUrl, mcpToken, featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching feature analysis context via MCP endpoints...');
+    }
+    const featureContext = await fetchFeatureAnalysisContext(mcpServerUrl, mcpToken, featureId, verbose);
+    const { content: contextInfo, downloadedImages } = await formatFeatureAnalysisContext(featureContext);
+    if (verbose && downloadedImages.length > 0) {
+        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+        downloadedImages.forEach((img) => {
+            logInfo(`  - ${img.url} -> ${img.localPath}`);
+        });
+    }
+    // Add checklist context to the analysis prompt
+    let finalContextInfo = contextInfo;
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
+        }
+    }
+    const analysisPrompt = createFeatureAnalysisPromptWithContext(featureId, finalContextInfo);
+    return { featureContext, analysisPrompt };
+}
 export const checkFeatureAnalysisRequirements = async () => {
     try {
         // Check if Claude Code SDK is available

package/dist/phases/feature-analysis-verification/index.d.ts

@@ -0,0 +1 @@
+export { verifyChecklistCompliance, type ChecklistItemVerificationResult, type ChecklistVerificationResult, type VerifyChecklistOptions, } from './verifier.js';

package/dist/phases/feature-analysis-verification/index.js

@@ -0,0 +1 @@
+export { verifyChecklistCompliance, } from './verifier.js';

package/dist/phases/feature-analysis-verification/verifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { FeatureAnalysisContext } from '../feature-analysis/context-fetcher.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 {
+    all_verified: boolean;
+    total_items: number;
+    confirmed_count: number;
+    rejected_count: number;
+    uncertain_count: number;
+    item_verifications: ChecklistItemVerificationResult[];
+    summary: string;
+    overall_suggestions?: string[];
+}
+export interface VerifyChecklistOptions {
+    checklistContext: ChecklistPhaseContext;
+    analysisContext: FeatureAnalysisContext;
+    createdUserStories: any[];
+    createdTestCases: any[];
+    verbose?: boolean;
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export declare function verifyChecklistCompliance(options: VerifyChecklistOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;

package/dist/phases/feature-analysis-verification/verifier.js

@@ -0,0 +1,147 @@
+/**
+ * Checklist verification agent for feature analysis
+ * This agent independently reviews checklist compliance to ensure objectivity
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createChecklistVerificationPrompt, createChecklistVerificationSystemPrompt, } from '../../prompts/checklist-verification.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+}
+/**
+ * Verify checklist compliance using an independent AI agent
+ * This agent acts as a "challenger" to validate the claims made by the analysis agent
+ */
+export async function verifyChecklistCompliance(options, config) {
+    const { checklistContext, analysisContext, createdUserStories, createdTestCases, verbose, } = options;
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    if (verbose) {
+        logInfo('🔍 Starting checklist verification...');
+        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
+    }
+    try {
+        const systemPrompt = createChecklistVerificationSystemPrompt(config);
+        const verificationPrompt = createChecklistVerificationPrompt({
+            checklistContext,
+            analysisContext,
+            createdUserStories,
+            createdTestCases,
+        });
+        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: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 100,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`   Received message type: ${message.type}`);
+            }
+            // Capture assistant responses
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n✅ Verification completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        // Try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        let jsonResult = null;
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.verification) {
+                            verificationResult = jsonResult.verification;
+                        }
+                        else {
+                            throw new Error('Invalid verification JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse verification result: ${error}`);
+                        // Return default "uncertain" result
+                        verificationResult = createUncertainVerificationResult(checklistContext, 'Failed to parse verification response');
+                    }
+                }
+                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 items: ${verificationResult.total_items}`);
+            logInfo(`   ✅ Confirmed: ${verificationResult.confirmed_count}`);
+            logInfo(`   ❌ Rejected: ${verificationResult.rejected_count}`);
+            logInfo(`   ⚠️  Uncertain: ${verificationResult.uncertain_count}`);
+            logInfo(`   Summary: ${verificationResult.summary}`);
+            if (verificationResult.rejected_count > 0) {
+                logInfo('\n❌ Rejected items:');
+                verificationResult.item_verifications
+                    .filter((v) => v.verification_status === 'rejected')
+                    .forEach((v) => {
+                    logInfo(`   - ${v.checklist_item_id}`);
+                    logInfo(`     Reason: ${v.verification_reason}`);
+                });
+            }
+        }
+        return verificationResult;
+    }
+    catch (error) {
+        logError(`Checklist 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/pull-request/creator.js

@@ -55,7 +55,8 @@ const switchToMainBranch = (mainBranch = 'main', verbose) => {
 const generatePRTitle = (featureName) => {
     // Remove feature ID prefix if present (e.g., "FEAT-123: Feature Name" -> "Feature Name")
     const cleanName = featureName.replace(/^[A-Z]+-\d+:\s*/, '');
-    return `feat: ${cleanName}`;
+    // Convert to lowercase for conventional commits format
+    return `feat: ${cleanName.toLowerCase()}`;
 };
 /**
  * Generate pull request body with feature details

package/dist/phases/technical-design/analyzer-helpers.d.ts

@@ -0,0 +1,37 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { type ChecklistVerificationResult } from '../technical-design-verification/index.js';
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: ChecklistVerificationResult;
+    iterations?: number;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt?: string;
+}
+/**
+ * Perform verification and determine if iteration should continue
+ */
+export declare function performVerificationCycle(technicalDesign: string, checklistContext: ChecklistPhaseContext | null, featureId: string, featureName: string, featureDescription: string | undefined, config: EdsgerConfig, currentIteration: number, maxIterations: number, mcpServerUrl: string, mcpToken: string, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Build successful design result
+ */
+export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+/**
+ * Build error result when no design was generated
+ */
+export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;
+export {};