edsger 0.28.4 → 0.29.1

package/dist/commands/workflow/workflow-runner.js

@@ -0,0 +1,119 @@
+/**
+ * Feature workflow runner with execution mode support
+ * Main entry point for running workflow pipelines with different execution modes
+ */
+import { runPipelineByMode } from './pipeline-runner.js';
+import { getFeature } from '../../api/features/get-feature.js';
+import { logError, logInfo } from '../../utils/logger.js';
+/**
+ * Run workflow for a feature based on its execution_mode configuration
+ */
+export async function runFeatureWorkflow(options, config) {
+    const { featureId, mcpServerUrl, mcpToken, verbose } = options;
+    try {
+        // 1. Get feature details to check execution_mode
+        if (verbose) {
+            logInfo(`🔍 Fetching feature configuration for: ${featureId}`);
+        }
+        const feature = await getFeature(mcpServerUrl, mcpToken, featureId, verbose);
+        // Debug log raw feature data
+        if (verbose) {
+            logInfo(`🔍 Feature data from API:`);
+            logInfo(`  - execution_mode (raw): ${feature.execution_mode}`);
+            logInfo(`  - execution_mode (type): ${typeof feature.execution_mode}`);
+            logInfo(`  - is valid: ${isValidExecutionMode(feature.execution_mode || '')}`);
+        }
+        // 2. Determine execution mode (default to full_pipeline if not set)
+        const executionMode = isValidExecutionMode(feature.execution_mode || '')
+            ? feature.execution_mode
+            : 'full_pipeline';
+        if (verbose) {
+            logInfo(`📋 Selected execution mode: ${executionMode}`);
+            logInfo(`📋 Mode description: ${getExecutionModeDescription(executionMode)}`);
+        }
+        // 3. Run pipeline based on execution mode
+        return await runPipelineByMode(options, config, executionMode);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to run feature workflow: ${errorMessage}`);
+        // Return error result
+        return [
+            {
+                featureId,
+                phase: 'workflow-initialization',
+                status: 'error',
+                message: `Workflow initialization failed: ${errorMessage}`,
+            },
+        ];
+    }
+}
+/**
+ * Run workflow for a feature with explicit execution mode override
+ */
+export async function runFeatureWorkflowWithMode(options, config, executionMode) {
+    const { featureId, verbose } = options;
+    if (verbose) {
+        logInfo(`🚀 Running workflow with explicit mode: ${executionMode} for feature: ${featureId}`);
+    }
+    try {
+        return await runPipelineByMode(options, config, executionMode);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to run feature workflow with mode ${executionMode}: ${errorMessage}`);
+        return [
+            {
+                featureId,
+                phase: 'workflow-execution',
+                status: 'error',
+                message: `Workflow execution failed: ${errorMessage}`,
+            },
+        ];
+    }
+}
+/**
+ * Get available execution modes
+ */
+export function getAvailableExecutionModes() {
+    return [
+        'full_pipeline',
+        'only_feature_analysis',
+        'only_technical_design',
+        'only_code_implementation',
+        'only_functional_testing',
+        'only_code_refine',
+        'only_code_review',
+        'from_feature_analysis',
+        'from_technical_design',
+        'from_code_implementation',
+        'from_functional_testing',
+        'from_code_review',
+    ];
+}
+/**
+ * Validate execution mode
+ */
+export function isValidExecutionMode(mode) {
+    return getAvailableExecutionModes().includes(mode);
+}
+/**
+ * Get execution mode description
+ */
+export function getExecutionModeDescription(mode) {
+    const descriptions = {
+        full_pipeline: 'Execute complete workflow: analysis → design → implementation → testing',
+        only_feature_analysis: 'Execute only: feature analysis',
+        only_technical_design: 'Execute only: technical design',
+        only_code_implementation: 'Execute only: code implementation',
+        only_functional_testing: 'Execute only: functional testing',
+        only_code_refine: 'Execute only: code refine (address PR review feedback and verify resolution)',
+        only_code_review: 'Execute only: code review (review PR code and create review comments)',
+        from_feature_analysis: 'Execute from feature analysis to end: analysis → design → implementation → testing',
+        from_technical_design: 'Execute from technical design to end: design → implementation → testing',
+        from_code_implementation: 'Execute from code implementation to end: implementation → testing',
+        from_functional_testing: 'Execute from functional testing to end: testing',
+        from_code_review: 'Execute from code review to end: code-review → code-refine → code-refine-verification',
+    };
+    return descriptions[mode] || 'Unknown execution mode';
+}

package/dist/index.js

@@ -11,6 +11,7 @@ import { runRefactor } from './commands/refactor/refactor.js';
 import { runInit } from './commands/init/index.js';
 import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
 import { runAgentWorkflow } from './commands/agent-workflow/index.js';
+import { runTaskWorker } from './commands/task-worker/index.js';
 import { runLogin, runLogout, runStatus } from './auth/login.js';
 // Get package.json version dynamically
 const __filename = fileURLToPath(import.meta.url);
@@ -81,6 +82,7 @@ program
     .option('--init', 'Initialize .edsger directory with project templates')
     .option('--growth-analysis <productId>', 'Run AI-powered growth analysis for a product')
     .option('--product-level', 'Use legacy product-level workflow (requires EDSGER_PRODUCT_ID, EDSGER_MCP_SERVER_URL, EDSGER_MCP_TOKEN env vars)')
+    .option('--watch-tasks <productId>', 'Watch and execute pending tasks for a product')
     .option('--concurrency <number>', 'Max concurrent features to process (default: 3)', parseInt)
     .option('-c, --config <path>', 'Path to config file')
     .option('-v, --verbose', 'Verbose output');
@@ -99,6 +101,11 @@ export const runEdsger = async (options) => {
         await runInit(options);
         return;
     }
+    // Handle task watcher mode
+    if (options.watchTasks) {
+        await runTaskWorker(options);
+        return;
+    }
     // Handle growth analysis mode
     if (options.growthAnalysis) {
         await runGrowthAnalysis(options);

package/dist/phases/chat-processor/context.d.ts

@@ -5,6 +5,7 @@
 import type { ChatMessage } from '../../types/index.js';
 export interface ChatProcessorContext {
     featureId: string;
+    productId: string;
     featureDescription: string;
     featureStatus: string;
     executionMode: string;

package/dist/phases/chat-processor/context.js

@@ -36,6 +36,7 @@ export async function buildChatContext(featureId, channelId, verbose) {
     }));
     return {
         featureId,
+        productId: feature.product_id || '',
         featureDescription: `${feature.name || 'Unknown'}: ${feature.description || 'No description'}`,
         featureStatus: feature.status || 'unknown',
         executionMode: feature.execution_mode || 'unknown',

package/dist/phases/chat-processor/index.js

@@ -94,6 +94,7 @@ export async function processHumanMessages(messages, featureId, config, verbose)
                 '',
                 `## Channel ID: ${channelId}`,
                 `## Feature ID: ${featureId}`,
+                `## Product ID: ${context.productId}`,
                 '',
                 historySection,
                 `## Human Message`,
@@ -196,6 +197,7 @@ export async function processPhaseCompletion(featureId, phase, summary, phaseOut
                 '',
                 `## Channel ID: ${channelId}`,
                 `## Feature ID: ${featureId}`,
+                `## Product ID: ${context.productId}`,
                 '',
                 advisorMessage,
                 '',

package/dist/phases/chat-processor/prompts.d.ts

@@ -5,7 +5,7 @@
  * 1. CHAT_RESPONSE_PROMPT — responding to human messages
  * 2. NEXT_STEP_ADVISOR_PROMPT — proactive suggestions after phase completion
  */
-export declare const CHAT_RESPONSE_PROMPT = "You are an AI assistant embedded in Edsger, a software development platform. You are helping a team develop a feature.\n\n## Your Capabilities\nYou can see the feature's current state, user stories, test cases, workflow phases, and code. You have tools to:\n- Modify feature status, execution mode, and workflow phases\n- Create/update user stories and test cases\n- Read and search source code files\n- Send follow-up messages and present options to the user\n- Trigger phase reruns\n\n## How to Respond\n1. **Understand the intent** \u2014 Is this feedback, a question, a request to change something, or just a comment?\n2. **Take action if needed** \u2014 Use the appropriate tools to make changes\n3. **Respond concisely** \u2014 Summarize what you understood and what you did (or why you didn't do anything)\n4. **Ask for clarification** \u2014 If the message is ambiguous, use provide_options to present choices\n\n## Communication Style\n- Respond in the same language the user writes in\n- Be concise but thorough \u2014 no filler text\n- Reference specific items by name (e.g., \"User Story #3: Login flow\")\n- When making changes, always explain what you changed and why\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (creates or modifies code)\n- **pr-execution**: Syncs already-written code from dev branch to split PR branches (does NOT write new code)\n- **bug-fixing**: Fixes code bugs and test failures\n- To fix bugs or update code \u2192 suggest **code-implementation** or **bug-fixing**, NOT pr-execution\n\n## Important Rules\n- Never make destructive changes without confirmation (deleting stories, resetting phases)\n- For ambiguous feedback, present options rather than guessing\n- If you can't do something, explain why clearly\n";
+export declare const CHAT_RESPONSE_PROMPT = "You are an AI assistant embedded in Edsger, a software development platform. You are helping a team develop a feature.\n\n## Your Capabilities\nYou can see the feature's current state, user stories, test cases, workflow phases, and code. You have tools to:\n- Modify feature status, execution mode, and workflow phases\n- Create/update user stories and test cases\n- Read and search source code files\n- Send follow-up messages and present options to the user\n- Trigger phase reruns\n- Create tasks for team members (human) or AI\n- Look up product team members by name\n\n## How to Respond\n1. **Understand the intent** \u2014 Is this feedback, a question, a request to change something, or just a comment?\n2. **Take action if needed** \u2014 Use the appropriate tools to make changes\n3. **Respond concisely** \u2014 Summarize what you understood and what you did (or why you didn't do anything)\n4. **Ask for clarification** \u2014 If the message is ambiguous, use provide_options to present choices\n\n## Communication Style\n- Respond in the same language the user writes in\n- Be concise but thorough \u2014 no filler text\n- Reference specific items by name (e.g., \"User Story #3: Login flow\")\n- When making changes, always explain what you changed and why\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (creates or modifies code)\n- **pr-execution**: Syncs already-written code from dev branch to split PR branches (does NOT write new code)\n- **bug-fixing**: Fixes code bugs and test failures\n- To fix bugs or update code \u2192 suggest **code-implementation** or **bug-fixing**, NOT pr-execution\n\n## Task Creation\nWhen the user asks to notify someone, assign a review, or request action from a team member:\n1. Use list_product_members to find the person by name\n2. Use create_task with executor=\"human\", the resolved user ID, and the correct action_url\n3. Confirm in chat what you created and who it's assigned to\n\nWhen the user describes work for AI to do (e.g., \"implement X\", \"fix Y\"):\n1. Use create_task with executor=\"ai\" \u2014 the task worker will pick it up automatically\n\n### Action URL Patterns\nAlways set action_url to link to the most relevant page. Available patterns:\n- Product page: `/products/{product_id}`\n- Feature details: `/products/{product_id}/features/{feature_id}`\n- Feature tab (append ?tab=): `/products/{product_id}/features/{feature_id}?tab={tab}`\n\nAvailable feature tabs:\n- `stories` \u2014 User Stories (use for: review user stories, update stories)\n- `test-cases` \u2014 Test Cases (use for: review test cases, verify tests)\n- `technical-design` \u2014 Technical Design (use for: review design, architecture review)\n- `checklists` \u2014 Checklists (use for: review checklists, quality checks)\n- `branches` \u2014 Branches (use for: code review, branch management)\n- `pull-requests` \u2014 Pull Requests (use for: review PRs, merge requests)\n- `test-reports` \u2014 Test Reports (use for: review test results)\n- `feedbacks` \u2014 Feedbacks (use for: provide feedback)\n- `chat` \u2014 Chat (use for: discussion)\n- `details` \u2014 Feature Details (default)\n\nChoose the tab that best matches the task content. For example:\n- \"review user stories\" \u2192 `?tab=stories`\n- \"review technical design\" \u2192 `?tab=technical-design`\n- \"check test results\" \u2192 `?tab=test-reports`\n\n## Important Rules\n- Never make destructive changes without confirmation (deleting stories, resetting phases)\n- For ambiguous feedback, present options rather than guessing\n- If you can't do something, explain why clearly\n- When creating tasks for people, always confirm the person's identity if the name is ambiguous\n";
 export declare const NEXT_STEP_ADVISOR_PROMPT = "You are an AI advisor in Edsger, a software development platform. A workflow phase just completed for a feature you're helping develop.\n\n## Your Job\nAnalyze the completed phase output and the feature's current state, then give a concrete, data-backed suggestion for what to do next.\n\n## Critical Rules\n1. **Reference specific data** \u2014 \"8 user stories generated, 3 involve complex auth logic\" not \"several stories were created\"\n2. **Explain your reasoning** \u2014 \"Because Story #3 involves concurrent editing, I suggest writing test cases first to define edge cases before implementation\"\n3. **Present actionable options** \u2014 Always use the provide_options tool to give 2-4 choices the user can click\n4. **Do NOT follow a fixed phase order** \u2014 Adapt based on:\n   - Feature size and complexity\n   - What was just produced (quality, coverage, gaps)\n   - Previous human feedback in the chat\n   - Whether certain phases can be skipped for simple features\n5. **Flag issues proactively** \u2014 If the phase output has gaps, incomplete coverage, or potential problems, call them out\n\n## Phase Reference (know what each phase does before suggesting it)\n- **code-implementation**: Writes/updates production code (the phase that creates or modifies code)\n- **pr-splitting**: Plans how to split code changes into reviewable PRs\n- **pr-execution**: Syncs already-written code from the dev branch to split PR branches (does NOT write new code)\n- **code-testing**: Writes automated tests for implemented code\n- **functional-testing**: Runs end-to-end tests with Playwright\n- **bug-fixing**: Fixes code bugs and test failures\n- **code-review**: Reviews PR code for issues\n- **code-refine**: Updates code based on PR review feedback\n\n**Important distinctions:**\n- To fix bugs or update code \u2192 use **code-implementation** or **bug-fixing**, NOT pr-execution\n- pr-execution only moves existing code to PR branches \u2014 it never creates or modifies implementation code\n\n## Context You Receive\n- Feature description, size, and current state\n- The completed phase name and its full output\n- Remaining workflow phases (with descriptions)\n- User story and test case counts\n- Code change scope (if applicable)\n- Recent chat history (human feedback)\n\n## Communication Style\n- Respond in the same language as recent chat messages (default to the feature's language context)\n- Be specific and data-driven\n- Structure: brief summary \u2192 reasoning \u2192 options\n";
 /**
  * Phase descriptions so the AI advisor understands what each phase does.

package/dist/phases/chat-processor/prompts.js

@@ -14,6 +14,8 @@ You can see the feature's current state, user stories, test cases, workflow phas
 - Read and search source code files
 - Send follow-up messages and present options to the user
 - Trigger phase reruns
+- Create tasks for team members (human) or AI
+- Look up product team members by name
 
 ## How to Respond
 1. **Understand the intent** — Is this feedback, a question, a request to change something, or just a comment?
@@ -33,10 +35,43 @@ You can see the feature's current state, user stories, test cases, workflow phas
 - **bug-fixing**: Fixes code bugs and test failures
 - To fix bugs or update code → suggest **code-implementation** or **bug-fixing**, NOT pr-execution
 
+## Task Creation
+When the user asks to notify someone, assign a review, or request action from a team member:
+1. Use list_product_members to find the person by name
+2. Use create_task with executor="human", the resolved user ID, and the correct action_url
+3. Confirm in chat what you created and who it's assigned to
+
+When the user describes work for AI to do (e.g., "implement X", "fix Y"):
+1. Use create_task with executor="ai" — the task worker will pick it up automatically
+
+### Action URL Patterns
+Always set action_url to link to the most relevant page. Available patterns:
+- Product page: \`/products/{product_id}\`
+- Feature details: \`/products/{product_id}/features/{feature_id}\`
+- Feature tab (append ?tab=): \`/products/{product_id}/features/{feature_id}?tab={tab}\`
+
+Available feature tabs:
+- \`stories\` — User Stories (use for: review user stories, update stories)
+- \`test-cases\` — Test Cases (use for: review test cases, verify tests)
+- \`technical-design\` — Technical Design (use for: review design, architecture review)
+- \`checklists\` — Checklists (use for: review checklists, quality checks)
+- \`branches\` — Branches (use for: code review, branch management)
+- \`pull-requests\` — Pull Requests (use for: review PRs, merge requests)
+- \`test-reports\` — Test Reports (use for: review test results)
+- \`feedbacks\` — Feedbacks (use for: provide feedback)
+- \`chat\` — Chat (use for: discussion)
+- \`details\` — Feature Details (default)
+
+Choose the tab that best matches the task content. For example:
+- "review user stories" → \`?tab=stories\`
+- "review technical design" → \`?tab=technical-design\`
+- "check test results" → \`?tab=test-reports\`
+
 ## Important Rules
 - Never make destructive changes without confirmation (deleting stories, resetting phases)
 - For ambiguous feedback, present options rather than guessing
 - If you can't do something, explain why clearly
+- When creating tasks for people, always confirm the person's identity if the name is ambiguous
 `;
 export const NEXT_STEP_ADVISOR_PROMPT = `You are an AI advisor in Edsger, a software development platform. A workflow phase just completed for a feature you're helping develop.
 

package/dist/phases/chat-processor/tools.js

@@ -279,6 +279,52 @@ export function createChatMcpServer() {
                     ],
                 };
             }),
+            tool('create_task', 'Create a task for a team member (human) or for AI to execute. Use this when the user asks to assign work, request reviews, or notify someone about something they need to do.', {
+                product_id: z.string().describe('Product ID'),
+                name: z.string().describe('Short task name (e.g., "Review user stories for Login feature")'),
+                description: z.string().optional().describe('Detailed description of what needs to be done'),
+                executor: z.enum(['ai', 'human']).describe('Who should do this: "ai" for automated work, "human" for manual review/approval'),
+                assigned_to: z.string().optional().describe('User ID to assign to (use list_product_members to look up)'),
+                feature_id: z.string().optional().describe('Related feature ID'),
+                action_url: z.string().optional().describe('URL where the assignee should take action. See prompt for URL patterns.'),
+                priority: z.number().optional().describe('1=low, 2=medium, 3=high, 4=urgent'),
+            }, async (args) => {
+                // Get next sequence number
+                const listResult = (await callMcpEndpoint('tasks/list_for_product', {
+                    product_id: args.product_id,
+                }));
+                const text = listResult?.content?.[0]?.text || '[]';
+                const existingTasks = JSON.parse(text);
+                const nextSequence = existingTasks.length + 1;
+                // Use explicit action_url if provided, otherwise auto-generate from feature_id
+                const actionUrl = args.action_url
+                    || (args.feature_id ? `/products/${args.product_id}/features/${args.feature_id}` : null);
+                const result = await callMcpEndpoint('tasks/create', {
+                    product_id: args.product_id,
+                    sequence: nextSequence,
+                    name: args.name,
+                    description: args.description || null,
+                    executor: args.executor,
+                    source: 'system',
+                    assigned_to: args.assigned_to || null,
+                    feature_id: args.feature_id || null,
+                    action_url: actionUrl,
+                    priority: args.priority || (args.executor === 'human' ? 3 : 2),
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
+            tool('list_product_members', 'List all members of a product (owner + developers) with their names, emails, and IDs. Use this to look up a person by name before assigning tasks.', {
+                product_id: z.string().describe('Product ID'),
+            }, async (args) => {
+                const result = await callMcpEndpoint('tasks/product_members', {
+                    product_id: args.product_id,
+                });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }),
             tool('trigger_phase_rerun', 'Reset a workflow phase to pending so it will re-run.', {
                 feature_id: z.string().describe('Feature ID'),
                 phase: z.string().describe('Phase name to reset'),

package/dist/phases/code-implementation/analyzer-helpers.d.ts

@@ -0,0 +1,28 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { ChecklistVerificationResult } from '../code-implementation-verification/agent.js';
+import { CodeImplementationResult } from './index.js';
+export interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt: string | null;
+}
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export declare function performVerificationCycle(branchName: string, baseBranch: string, checklistContext: ChecklistPhaseContext | null, featureId: string, featureName: string, featureDescription: string | undefined, config: EdsgerConfig, currentIteration: number, maxIterations: number, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Build successful implementation result
+ */
+export declare function buildImplementationResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, iterations: number, checklistResults?: any[], checklistItemResults?: any[]): CodeImplementationResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, branchName: string, implementationSummary: string, filesModified: string[], commitHash: string, verificationResult: ChecklistVerificationResult, iterations: number): CodeImplementationResult;
+/**
+ * Build error result for no implementation
+ */
+export declare function buildNoResultsError(featureId: string, branchName: string): CodeImplementationResult;

package/dist/phases/code-implementation/analyzer-helpers.js

@@ -0,0 +1,177 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+import { formatChecklistsForContext, processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { verifyCodeImplementationCompliance, } from '../code-implementation-verification/agent.js';
+import { createCodeImplementationImprovementPrompt } from './prompts.js';
+/**
+ * Perform a complete verification cycle:
+ * 1. Verify code implementation against checklist
+ * 2. Log results to audit logs
+ * 3. Create improvement prompt if verification failed
+ */
+export async function performVerificationCycle(branchName, baseBranch, checklistContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, verbose) {
+    // If no checklist, verification passes automatically
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        if (verbose) {
+            logInfo('ℹ️  No checklists to verify - skipping verification');
+        }
+        return {
+            passed: true,
+            verificationResult: null,
+            nextPrompt: null,
+        };
+    }
+    if (verbose) {
+        logInfo(`\n🔍 Verifying code implementation (iteration ${currentIteration}/${maxIterations})...`);
+    }
+    // Format checklist context for verification
+    const checklistInfo = formatChecklistsForContext(checklistContext);
+    // Perform verification
+    const verificationResult = await verifyCodeImplementationCompliance({
+        featureId,
+        branchName,
+        baseBranch,
+        featureName,
+        featureDescription,
+        checklistContext: checklistInfo,
+        verbose,
+    }, config);
+    // Determine if verification passed
+    const verificationPassed = verificationResult.rejected_count === 0;
+    // Log verification result
+    if (verificationPassed) {
+        if (verbose) {
+            logInfo(`✅ Code verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        await logFeatureVerificationEvent({
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        // Create checklist results based on verification result
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId }, 'code_implementation', checklistItemResults, verbose);
+    }
+    else {
+        logError(`❌ Iteration ${currentIteration}: Code verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+        await logFeatureVerificationEvent({
+            featureId,
+            phase: 'code_implementation',
+            iteration: currentIteration,
+            result: 'error',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                rejected_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'rejected')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                uncertain_items: verificationResult.item_verifications
+                    .filter((item) => item.verification_status === 'uncertain')
+                    .map((item) => ({
+                    checklist_item_id: item.checklist_item_id,
+                    reason: item.verification_reason || 'No reason provided',
+                    concerns: item.concerns || [],
+                    improvement_suggestions: item.improvement_suggestions || [],
+                })),
+                summary: verificationResult.summary,
+                overall_suggestions: verificationResult.overall_suggestions || [],
+            },
+        }, verbose);
+    }
+    // If verification failed and we have iterations left, create improvement prompt
+    let nextPrompt = null;
+    if (!verificationPassed && currentIteration < maxIterations) {
+        nextPrompt = createCodeImplementationImprovementPrompt(verificationResult, branchName, baseBranch);
+        if (verbose) {
+            logInfo(`\n📝 Created improvement prompt for next iteration (${maxIterations - currentIteration} attempts remaining)`);
+        }
+    }
+    else if (!verificationPassed) {
+        // Max iterations reached - create checklist results based on final verification
+        if (verbose) {
+            logInfo(`\n📋 Creating checklist results for final iteration (max iterations reached)`);
+        }
+        // Create checklist results for all items (both passed and failed)
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId }, 'code_implementation', checklistItemResults, verbose);
+    }
+    return {
+        passed: verificationPassed,
+        verificationResult,
+        nextPrompt,
+    };
+}
+/**
+ * Build successful implementation result
+ */
+export function buildImplementationResult(featureId, branchName, implementationSummary, filesModified, commitHash, iterations, checklistResults, checklistItemResults) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'success',
+        message: 'Code implementation completed successfully',
+        filesModified,
+        commitHash,
+        data: {
+            checklist_results: checklistResults,
+            checklist_item_results: checklistItemResults,
+        },
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, branchName, implementationSummary, filesModified, commitHash, verificationResult, iterations) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary,
+        status: 'error',
+        message: `Code implementation verification failed after ${iterations} iterations. Code committed for manual review.`,
+        filesModified,
+        commitHash,
+        data: {
+            verification_failed: true,
+            verification_summary: verificationResult.summary,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            improvement_suggestions: verificationResult.overall_suggestions || [],
+        },
+    };
+}
+/**
+ * Build error result for no implementation
+ */
+export function buildNoResultsError(featureId, branchName) {
+    return {
+        featureId,
+        branchName,
+        implementationSummary: null,
+        status: 'error',
+        message: 'Code implementation failed - no results produced',
+    };
+}

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

@@ -0,0 +1,32 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface CodeImplementationOptions {
+    featureId: string;
+    verbose?: boolean;
+    baseBranch?: string;
+    maxVerificationIterations?: number;
+}
+export interface CodeImplementationResult {
+    featureId: string;
+    branchName: string;
+    implementationSummary: string | null;
+    status: 'success' | 'error';
+    message: string;
+    filesModified?: string[];
+    commitHash?: string;
+    data?: {
+        checklist_results?: Array<{
+            checklist_id: string;
+            satisfied: boolean;
+            notes?: string;
+        }>;
+        checklist_item_results?: Array<{
+            checklist_item_id: string;
+            is_passed: boolean;
+            value?: any;
+            notes?: string;
+        }>;
+        [key: string]: any;
+    };
+}
+export declare const implementFeatureCode: (options: CodeImplementationOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<CodeImplementationResult>;