edsger 0.2.3 → 0.2.4

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

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

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

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

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

@@ -0,0 +1,36 @@
+/**
+ * Checklist verification agent for technical design
+ * This agent independently reviews checklist compliance to ensure quality
+ */
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.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 VerifyTechnicalDesignOptions {
+    checklistContext: ChecklistPhaseContext;
+    featureId: string;
+    featureName: string;
+    featureDescription?: 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/verifier.js

@@ -0,0 +1,147 @@
+/**
+ * Checklist verification agent for technical design
+ * This agent independently reviews checklist compliance to ensure quality
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { createTechnicalDesignVerificationPrompt, createTechnicalDesignVerificationSystemPrompt, } from '../../prompts/technical-design-verification.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(verificationPrompt) {
+    yield userMessage(verificationPrompt);
+}
+/**
+ * Verify checklist compliance for technical design using an independent AI agent
+ */
+export async function verifyTechnicalDesignCompliance(options, config) {
+    const { checklistContext, featureId, featureName, featureDescription, technicalDesign, verbose, } = options;
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    if (verbose) {
+        logInfo('🔍 Starting technical design verification...');
+        logInfo(`   Verifying ${totalChecklistItems} checklist items`);
+    }
+    try {
+        const systemPrompt = createTechnicalDesignVerificationSystemPrompt(config);
+        const verificationPrompt = createTechnicalDesignVerificationPrompt({
+            checklistContext,
+            featureId,
+            featureName,
+            featureDescription,
+            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: {
+                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(`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/prompts/checklist-verification.d.ts

@@ -0,0 +1,11 @@
+import { EdsgerConfig } from '../types/index.js';
+import { ChecklistPhaseContext } from '../services/checklist.js';
+import { FeatureAnalysisContext } from '../phases/feature-analysis/context-fetcher.js';
+export declare const createChecklistVerificationSystemPrompt: (_config: EdsgerConfig) => string;
+export interface ChecklistVerificationPromptOptions {
+    checklistContext: ChecklistPhaseContext;
+    analysisContext: FeatureAnalysisContext;
+    createdUserStories: any[];
+    createdTestCases: any[];
+}
+export declare const createChecklistVerificationPrompt: (options: ChecklistVerificationPromptOptions) => string;

package/dist/prompts/checklist-verification.js

@@ -0,0 +1,153 @@
+export const createChecklistVerificationSystemPrompt = (_config) => {
+    return `You are an independent quality assurance auditor specializing in requirements verification. Your role is to critically evaluate whether generated artifacts (user stories and test cases) satisfy checklist requirements.
+
+**Your Mission**: Verify Artifacts Against Requirements
+- Review the checklist requirements
+- Examine the generated user stories and test cases
+- Determine if the artifacts satisfy each requirement
+- Be CRITICAL and look for gaps, inconsistencies, or missing elements
+- Quality matters - don't accept bare minimum
+
+**Verification Approach**:
+1. **Understand the Requirement**: Read each checklist item and understand what it requires
+2. **Examine the Artifacts**: Look at the user stories and test cases that were created
+3. **Match Requirements to Artifacts**: Determine if the artifacts address the requirement
+4. **Assess Quality**: Ask yourself:
+   - Do the artifacts directly address this requirement?
+   - Is the coverage specific and concrete, or vague and generic?
+   - Is there sufficient depth and quality?
+   - Are there any gaps or missing elements?
+   - Does it meet the standard expected for this requirement?
+
+**Verification Standards**:
+- ✅ **CONFIRMED**: The artifacts clearly and adequately satisfy the requirement
+- ❌ **REJECTED**: The requirement is not addressed, or addressed insufficiently
+- ⚠️ **UNCERTAIN**: The artifacts partially address the requirement but with gaps or ambiguity
+
+**Your Mindset**:
+- Be thorough and systematic
+- Focus on what the artifacts actually contain, not what was claimed
+- Quality matters - ensure requirements are truly met
+- Look for what's MISSING, not just what's present
+- Be fair but rigorous
+
+**CRITICAL - Output Format**:
+You MUST respond with a JSON object in this EXACT format:
+
+\`\`\`json
+{
+  "verification": {
+    "all_verified": true/false,
+    "total_items": number,
+    "confirmed_count": number,
+    "rejected_count": number,
+    "uncertain_count": number,
+    "item_verifications": [
+      {
+        "checklist_item_id": "uuid",
+        "is_satisfied": true/false,
+        "verification_status": "confirmed|rejected|uncertain",
+        "verification_reason": "Detailed explanation of your verification decision",
+        "concerns": ["Optional array of specific concerns or gaps found"],
+        "improvement_suggestions": ["Specific, actionable suggestions for improvement (for rejected/uncertain items)"]
+      }
+    ],
+    "summary": "Overall summary of verification findings",
+    "overall_suggestions": ["High-level suggestions for improving the overall analysis (if there are failures)"]
+  }
+}
+\`\`\`
+
+**For rejected/uncertain items**: Provide specific, actionable improvement_suggestions such as:
+- "Add a user story for X functionality"
+- "Create a test case to verify Y behavior"
+- "Expand test case Z to cover edge case A"
+
+Be thorough, be critical, be fair. Your verification protects quality.`;
+};
+export const createChecklistVerificationPrompt = (options) => {
+    const { checklistContext, analysisContext, createdUserStories, createdTestCases, } = options;
+    // Format all checklist items with their requirements
+    const checklistItemsSection = checklistContext.checklists
+        .flatMap((checklist) => checklist.items.map((item) => {
+        return `### Checklist Item: ${item.title}
+**ID**: ${item.id}
+**Checklist**: ${checklist.name} (${checklist.role})
+**Requirement**: ${item.description}
+**Required**: ${item.is_required ? 'Yes' : 'No'}
+**Type**: ${item.item_type}
+`;
+    }))
+        .join('\n---\n');
+    // Format created user stories
+    const userStoriesSection = createdUserStories.length > 0
+        ? createdUserStories
+            .map((story, index) => `${index + 1}. **${story.title}**
+   ${story.description}
+   Status: ${story.status || 'draft'}`)
+            .join('\n\n')
+        : 'No user stories were created';
+    // Format created test cases
+    const testCasesSection = createdTestCases.length > 0
+        ? createdTestCases
+            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
+   ${testCase.description}`)
+            .join('\n\n')
+        : 'No test cases were created';
+    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
+    return `# Checklist Verification Task
+
+You are verifying that generated artifacts (user stories and test cases) satisfy checklist requirements.
+
+## Feature Context
+
+**Feature**: ${analysisContext.feature.name}
+**Feature ID**: ${analysisContext.feature.id}
+**Description**: ${analysisContext.feature.description || 'No description'}
+**Product**: ${analysisContext.product.name}
+
+## Generated Artifacts
+
+### User Stories (${createdUserStories.length})
+${userStoriesSection}
+
+### Test Cases (${createdTestCases.length})
+${testCasesSection}
+
+## Checklist Requirements to Verify (${totalChecklistItems})
+
+${checklistItemsSection}
+
+---
+
+## Your Verification Task
+
+For EACH checklist item above:
+
+1. **Understand the Requirement**: What does this checklist item require?
+
+2. **Examine the Artifacts**: Look at the user stories and test cases above
+
+3. **Determine Coverage**: Do the artifacts adequately address this requirement?
+   - Do they directly address the requirement?
+   - Is the coverage concrete and specific?
+   - Is there sufficient quality and depth?
+   - Are there any gaps or missing elements?
+
+4. **Make Your Determination**:
+   - **CONFIRMED** (is_satisfied: true): The artifacts clearly and adequately satisfy this requirement
+   - **REJECTED** (is_satisfied: false): The requirement is not addressed, or addressed insufficiently
+   - **UNCERTAIN** (is_satisfied: false): The artifacts partially address the requirement but with gaps
+
+5. **Document Your Reasoning**: Provide specific, detailed reasons for your decision
+
+6. **Provide Improvement Suggestions** (for rejected/uncertain items):
+   - Be specific and actionable
+   - Suggest what user stories or test cases should be added
+   - Indicate what should be expanded or modified
+   - Give concrete examples when possible
+
+Remember: Focus on what the artifacts actually contain, not on claims. Be thorough and fair.
+
+Provide your verification results in the required JSON format with improvement_suggestions for any rejected or uncertain items.`;
+};

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

@@ -0,0 +1,5 @@
+import { ChecklistVerificationResult } from '../phases/code-implementation-verification/index.js';
+/**
+ * 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/prompts/code-implementation-improvement.js

@@ -0,0 +1,108 @@
+/**
+ * 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": {
+    "feature_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/prompts/code-implementation-verification.d.ts

@@ -0,0 +1,3 @@
+import { EdsgerConfig } from '../types/index.js';
+export declare const createCodeImplementationVerificationSystemPrompt: (_config: EdsgerConfig) => string;
+export declare const createCodeImplementationVerificationPrompt: (featureId: string, branchName: string, baseBranch: string, featureName: string, featureDescription: string, checklistContext: string) => string;

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

@@ -0,0 +1,176 @@
+export const createCodeImplementationVerificationSystemPrompt = (_config) => {
+    return `You are an independent senior code reviewer and quality assurance auditor specializing in verifying code implementations against requirements.
+
+**Your Role**: Conduct thorough code review to verify that the implementation satisfies all checklist requirements.
+
+**CRITICAL - You are NOT the implementer**: You are a separate, independent reviewer auditing someone else's work. Your job is to verify compliance, not to implement or fix code.
+
+**Available Tools**:
+- Bash: Git operations to review code changes (git diff, git show, git log)
+- Read: Examine code files in detail
+- Glob: Find files in the repository
+
+**Verification Process**:
+
+1. **Switch to Feature Branch**: The specific branch name (e.g., dev/feature-id) will be provided in the user prompt
+   \`git checkout [branch-name]\`
+
+2. **Review Git Changes**: Use git diff to see what was changed compared to the base branch
+   \`git diff [base-branch]...[feature-branch]\`
+   \`git log [base-branch]..[feature-branch]\`
+
+3. **Read Modified Files**: Use Read tool to examine the actual code implementation in detail
+
+4. **Code Review**: Evaluate the code changes for:
+   - Code quality and best practices
+   - Proper error handling and validation
+   - Security considerations
+   - Performance implications
+   - Test coverage
+   - Documentation and comments
+
+5. **Checklist Verification**: For each checklist item, determine if it is satisfied by the implementation:
+   - **CONFIRMED (✅)**: The code clearly satisfies the requirement with high quality
+   - **REJECTED (❌)**: The requirement is not implemented or implementation is inadequate
+   - **UNCERTAIN (⚠️)**: Partially implemented or quality concerns exist
+
+6. **Provide Improvement Suggestions**: For rejected or uncertain items, give specific, actionable suggestions
+
+**Verification Standards**:
+
+- ✅ **CONFIRMED**: Code clearly implements the requirement with good quality
+  - Implementation is complete and functional
+  - Code follows best practices
+  - Proper error handling and validation
+  - Adequate test coverage
+  - Good documentation
+
+- ❌ **REJECTED**: Requirement is not satisfied
+  - Requirement not implemented at all
+  - Implementation is fundamentally incorrect
+  - Critical quality issues or bugs
+  - Security vulnerabilities
+  - Missing essential error handling
+
+- ⚠️ **UNCERTAIN**: Partial implementation or quality concerns
+  - Basic implementation exists but incomplete
+  - Code works but has quality issues
+  - Missing edge case handling
+  - Insufficient test coverage
+  - Poor documentation or code clarity
+
+**Important Guidelines**:
+- Base your verification on ACTUAL CODE CHANGES, not on claims or summaries
+- Review the git diff to see exactly what was changed
+- Read the modified files to understand the implementation
+- Be thorough and objective in your assessment
+- Provide specific, actionable improvement suggestions
+- Consider integration with existing code
+- Check for potential bugs, security issues, or performance problems
+
+**CRITICAL - Result Format**:
+You MUST return ONLY a JSON object with your verification results. Do NOT include any explanatory text before or after the JSON. Return ONLY the JSON in this EXACT format:
+
+\`\`\`json
+{
+  "verification_result": {
+    "overall_status": "passed" | "failed" | "partial",
+    "summary": "Brief summary of verification findings",
+    "confirmed_count": 0,
+    "rejected_count": 0,
+    "uncertain_count": 0,
+    "item_verifications": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID",
+        "is_satisfied": true | false,
+        "verification_status": "confirmed" | "rejected" | "uncertain",
+        "verification_reason": "Detailed explanation of why this status was assigned",
+        "concerns": ["Specific concern 1", "Specific concern 2"],
+        "improvement_suggestions": ["Actionable suggestion 1", "Actionable suggestion 2"]
+      }
+    ],
+    "overall_suggestions": ["General improvement suggestion 1", "General improvement suggestion 2"]
+  }
+}
+\`\`\`
+
+IMPORTANT: Return ONLY the JSON above. Do not add any text explaining your verification process or findings. The JSON should be the complete and only content of your response.
+
+Focus on objective, thorough code review based on actual implementation artifacts.`;
+};
+export const createCodeImplementationVerificationPrompt = (featureId, branchName, baseBranch, featureName, featureDescription, checklistContext) => {
+    return `# Code Implementation Verification Task
+
+You are verifying the code implementation for feature: **${featureName}**
+
+## Feature Information
+- **Feature ID**: ${featureId}
+- **Description**: ${featureDescription}
+- **Implementation Branch**: ${branchName}
+- **Base Branch**: ${baseBranch}
+
+## Checklist Requirements to Verify
+${checklistContext}
+
+---
+
+## Your Verification Process
+
+Follow these steps systematically:
+
+### Step 1: Switch to Feature Branch
+\`\`\`bash
+git checkout ${branchName}
+\`\`\`
+
+### Step 2: Review Code Changes
+Compare the feature branch with the base branch to see what was changed:
+\`\`\`bash
+git diff ${baseBranch}...${branchName}
+\`\`\`
+
+Also review the commit history:
+\`\`\`bash
+git log ${baseBranch}..${branchName} --oneline
+\`\`\`
+
+### Step 3: Read Modified Files
+Use the Read tool to examine the actual code implementation in detail. Look at:
+- New files created
+- Modified files
+- Implementation logic
+- Error handling
+- Test coverage
+
+### Step 4: Verify Against Checklist
+For each checklist item, evaluate the implementation:
+- Is the requirement implemented?
+- Is the implementation complete and correct?
+- Does it follow best practices?
+- Are there quality concerns?
+
+### Step 5: Assign Verification Status
+For each checklist item:
+- ✅ **CONFIRMED**: Code clearly satisfies the requirement with good quality
+- ❌ **REJECTED**: Requirement not implemented or implementation inadequate
+- ⚠️ **UNCERTAIN**: Partial implementation or quality concerns
+
+### Step 6: Provide Improvement Suggestions
+For rejected or uncertain items, provide specific, actionable suggestions on how to improve the implementation.
+
+---
+
+## Important Notes
+
+- **Review ACTUAL CODE**: Base your verification on the actual code changes in git diff, not on summaries
+- **Be Thorough**: Read the modified files to understand the implementation
+- **Be Objective**: Provide fair, evidence-based assessments
+- **Be Specific**: Give concrete examples and actionable suggestions
+- **Focus on Quality**: Consider code quality, security, performance, and maintainability
+
+## Output Format
+
+Return your verification results in the required JSON format. Include all checklist items with their verification status and improvement suggestions.
+
+Begin your systematic code review now.`;
+};

package/dist/prompts/feature-analysis-improvement.d.ts

@@ -0,0 +1,8 @@
+import { ChecklistVerificationResult } from '../phases/feature-analysis-verification/index.js';
+/**
+ * Create a prompt for the analysis agent to improve based on verification feedback
+ */
+export declare const createImprovementPrompt: (verificationResult: ChecklistVerificationResult, previousAnalysis: {
+    created_user_stories: any[];
+    created_test_cases: any[];
+}) => string;