aiag-cli 1.5.1 → 1.6.2

package/dist/commands/auto.js

@@ -5,6 +5,65 @@ import { readFeatureList, writeFeatureList, getProgress } from '../utils/feature
 import { appendToProgress, recordWorkCompleted, updateProgressSummary, updateNextSteps, } from '../utils/progress.js';
 import { printHeader, printError, printSuccess, printWarning, printSection, colors, icons, } from '../utils/output.js';
 import { PRIORITY_ORDER } from '../types.js';
+/**
+ * 알려진 실패 패턴 (Common failure patterns)
+ */
+const KNOWN_PATTERNS = [
+    {
+        pattern: /Cannot find module ['"](.+?)['"]/i,
+        category: 'import-error',
+        suggestedFix: 'Missing import or dependency. Check package.json and import statements.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /Module ['"](.+?)['"] has no exported member ['"](.+?)['"]/i,
+        category: 'export-error',
+        suggestedFix: 'Incorrect import. Verify the export exists in the target module.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /TypeError: Cannot read propert(?:y|ies) ['"](.+?)['"] of (undefined|null)/i,
+        category: 'null-reference',
+        suggestedFix: 'Add null/undefined check before accessing property. Use optional chaining (?.).',
+        shouldRetry: true,
+    },
+    {
+        pattern: /SyntaxError|Unexpected token/i,
+        category: 'syntax-error',
+        suggestedFix: 'Fix syntax error. Check for missing brackets, quotes, or semicolons.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /Test.*timeout|ETIMEDOUT/i,
+        category: 'test-timeout',
+        suggestedFix: 'Async operation not awaited or infinite loop. Add await or increase timeout.',
+        shouldRetry: false, // Timeout은 재시도해도 같은 결과
+    },
+    {
+        pattern: /Self-verification failed|Not all acceptance criteria/i,
+        category: 'incomplete-implementation',
+        suggestedFix: 'Implementation incomplete. Review acceptance criteria and implement missing features.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /Type ['"](.+?)['"] is not assignable to type ['"](.+?)['"]/i,
+        category: 'type-error',
+        suggestedFix: 'Type mismatch. Check TypeScript types and fix the assignment.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /ENOENT.*no such file or directory/i,
+        category: 'file-not-found',
+        suggestedFix: 'File or directory missing. Create the required file or fix the path.',
+        shouldRetry: true,
+    },
+    {
+        pattern: /expected.*to.*but got/i,
+        category: 'assertion-failed',
+        suggestedFix: 'Test assertion failed. Review test expectations and implementation logic.',
+        shouldRetry: true,
+    },
+];
 /**
  * aiag auto [count] - 자동 연속 구현 모드
  * --loop: 무한 루프 모드 (Ctrl+C로 중단)
@@ -17,6 +76,7 @@ export async function auto(count = '5', options = {}) {
     const maxFeatures = isLoopMode ? Infinity : (parseInt(count, 10) || 5);
     const cooldownMs = (options.cooldown || 5) * 1000;
     const claudeTimeout = (options.timeout || 10) * 60 * 1000; // 기본 10분
+    const maxAttempts = parseInt(String(options.maxAttempts || 3), 10); // 기본 최대 3회 시도
     // verbose 로그 헬퍼
     const verboseLog = (message) => {
         if (isVerbose) {
@@ -30,10 +90,18 @@ export async function auto(count = '5', options = {}) {
     }
     // --resume 옵션: 진행 중인 작업 확인
     let resumeFeature;
+    let resumeContext;
     if (options.resume) {
         resumeFeature = getInProgressFeature(baseDir, featureList);
         if (resumeFeature) {
+            resumeContext = getFeatureContext(baseDir, resumeFeature.id);
             console.log(colors.info(`Resuming in-progress feature: ${resumeFeature.id}`));
+            if (resumeContext.attemptNumber > 1) {
+                console.log(colors.warning(`  Attempt #${resumeContext.attemptNumber}`));
+                if (resumeContext.previousError) {
+                    console.log(colors.dim(`  Previous error: ${resumeContext.previousError.substring(0, 100)}...`));
+                }
+            }
             console.log('');
         }
     }
@@ -48,11 +116,14 @@ export async function auto(count = '5', options = {}) {
         console.log(colors.dim(`  Working directory: ${baseDir}`));
         console.log(colors.dim(`  Claude timeout: ${claudeTimeout / 1000}s`));
         console.log(colors.dim(`  Cooldown: ${cooldownMs / 1000}s`));
+        console.log(colors.dim(`  Max retry attempts: ${maxAttempts}`));
         console.log('');
     }
     const initialProgress = getProgress(baseDir);
     const results = [];
     const startTime = Date.now();
+    const sessionId = generateSessionId();
+    const sessionStartTime = new Date().toISOString();
     // Ctrl+C 핸들링 (loop 모드용)
     let shouldStop = false;
     const handleSignal = () => {
@@ -64,18 +135,22 @@ export async function auto(count = '5', options = {}) {
         process.on('SIGINT', handleSignal);
         process.on('SIGTERM', handleSignal);
     }
-    // 자동화 시작 로그
+    // 자동화 시작 로그 (세션 메타데이터 강화)
     const autoStartLog = `
 ---
 
-## Auto Session: ${new Date().toISOString()}
+## Auto Session: ${sessionId}
 
-### Configuration
-- Mode: ${isLoopMode ? 'loop (infinite)' : `batch (${maxFeatures})`}
-- Resume: ${options.resume || false}
-- Category filter: ${options.category || 'all'}
-- Until feature: ${options.until || 'none'}
-- Dry run: ${options.dryRun || false}
+### Session Metadata
+- **Session ID**: ${sessionId}
+- **Started at**: ${sessionStartTime}
+- **Mode**: ${isLoopMode ? 'loop (infinite)' : `batch (${maxFeatures})`}
+- **Resume**: ${options.resume || false}
+- **Category filter**: ${options.category || 'all'}
+- **Until feature**: ${options.until || 'none'}
+- **Max attempts**: ${maxAttempts}
+- **Dry run**: ${options.dryRun || false}
+- **Initial progress**: ${initialProgress.completed}/${initialProgress.total} features (${initialProgress.percentage}%)
 
 ### Processing Log
 `;
@@ -89,14 +164,45 @@ export async function auto(count = '5', options = {}) {
         const currentFeatureList = readFeatureList(baseDir);
         if (!currentFeatureList)
             break;
-        // 다음 기능 선택 (첫 번째 iteration에서 resume 체크)
+        // 다음 기능 선택 (retry 또는 신규)
         let feature;
+        let featureContext;
+        // 1. 첫 iteration에서 --resume으로 지정된 feature 처리
         if (iterationCount === 0 && resumeFeature) {
             feature = resumeFeature;
-            resumeFeature = undefined; // 한 번만 사용
+            featureContext = resumeContext;
+            resumeFeature = undefined;
+            resumeContext = undefined;
+            verboseLog(`Using --resume feature: ${feature.id} (attempt ${featureContext?.attemptNumber})`);
         }
+        // 2. session_context.md에 실패한 feature가 있고 재시도 가능한지 확인
         else {
-            feature = selectNextFeature(currentFeatureList, options);
+            const failedFeature = getInProgressFeature(baseDir, currentFeatureList);
+            if (failedFeature) {
+                const context = getFeatureContext(baseDir, failedFeature.id);
+                // 최대 시도 횟수 미만이면 자동 재시도
+                if (context.attemptNumber <= maxAttempts) {
+                    feature = failedFeature;
+                    featureContext = context;
+                    verboseLog(`Auto-retrying failed feature: ${feature.id} (attempt ${context.attemptNumber}/${maxAttempts})`);
+                }
+                else {
+                    // 최대 시도 횟수 초과 - 영구 실패 처리
+                    verboseLog(`Feature ${failedFeature.id} exceeded max attempts (${maxAttempts}), moving to next`);
+                    appendToProgress(baseDir, `- [!] ${failedFeature.id}: Permanently failed after ${maxAttempts} attempts\n`);
+                    clearSessionContext(baseDir); // 컨텍스트 정리하고 다음 feature로
+                    feature = selectNextFeature(currentFeatureList, options);
+                    featureContext = { attemptNumber: 1 };
+                }
+            }
+            else {
+                // 실패한 feature 없음 - 다음 feature 선택
+                feature = selectNextFeature(currentFeatureList, options);
+                featureContext = { attemptNumber: 1 };
+                if (feature) {
+                    verboseLog(`Selected next feature: ${feature.id}`);
+                }
+            }
         }
         if (!feature) {
             console.log('');
@@ -114,7 +220,10 @@ export async function auto(count = '5', options = {}) {
         const featureStartTime = Date.now();
         console.log('');
         const progressDisplay = isLoopMode ? `#${iterationCount}` : `${iterationCount}/${maxFeatures}`;
-        console.log(colors.bold(`[${progressDisplay}] ${feature.id}: ${feature.description}`));
+        const attemptDisplay = (featureContext?.attemptNumber || 1) > 1
+            ? ` ${colors.warning(`[Retry ${featureContext?.attemptNumber}/${maxAttempts}]`)}`
+            : '';
+        console.log(colors.bold(`[${progressDisplay}] ${feature.id}: ${feature.description}${attemptDisplay}`));
         if (options.dryRun) {
             console.log(`  ${icons.arrow} Would implement...`);
             console.log(`  ${icons.arrow} Would test...`);
@@ -127,27 +236,49 @@ export async function auto(count = '5', options = {}) {
             continue;
         }
         try {
-            // 1. Claude Code로 구현 시도
+            // 1. Update session context (in_progress)
+            updateSessionContext(baseDir, feature, {
+                status: 'in_progress',
+                attempts: featureContext?.attemptNumber || 1,
+            });
+            // 2. Build enhanced prompt context
+            verboseLog(`Building prompt context for ${feature.id}`);
+            const promptContext = await buildPromptContext(baseDir, feature, currentFeatureList, featureContext?.attemptNumber || 1, featureContext?.previousError);
+            // 3. Claude Code로 구현 시도
             console.log(`  ${icons.arrow} Implementing...`);
             verboseLog(`Starting Claude Code for ${feature.id}`);
-            const implementResult = await runClaudeCode(baseDir, feature, claudeTimeout, isVerbose);
+            const implementResult = await runClaudeCode(baseDir, feature, promptContext, claudeTimeout, isVerbose);
             if (!implementResult.success) {
                 verboseLog(`Implementation failed: ${implementResult.error}`);
                 throw new Error(implementResult.error || 'Implementation failed');
             }
             verboseLog('Implementation completed successfully');
-            // 2. 테스트 실행
+            // 2. Self-Verification
+            console.log(`  ${icons.arrow} Self-verifying...`);
+            verboseLog('Running self-verification of acceptance criteria');
+            const verificationResult = await runSelfVerification(baseDir, feature, claudeTimeout, isVerbose);
+            if (!verificationResult.allPassed) {
+                const failedCriteria = verificationResult.results
+                    .filter((r) => !r.passed)
+                    .map((r) => `- ${r.criterion}: ${r.evidence}`)
+                    .join('\n');
+                verboseLog(`Self-verification failed:\n${failedCriteria}`);
+                throw new Error(`Self-verification failed. Not all acceptance criteria are met:\n${failedCriteria}`);
+            }
+            console.log(`  ${icons.success} Verified`);
+            verboseLog(`All ${feature.acceptanceCriteria.length} criteria passed verification`);
+            // 3. 테스트 실행
             console.log(`  ${icons.arrow} Testing...`);
             const testResult = await runTest(baseDir, feature);
             if (!testResult.success) {
                 throw new Error('Test failed');
             }
             console.log(`  ${icons.success} Passed`);
-            // 3. 완료 처리
+            // 4. 완료 처리
             console.log(`  ${icons.arrow} Completing...`);
             await markComplete(baseDir, feature.id);
             console.log(`  ${icons.success} Done`);
-            // 4. 커밋
+            // 5. 커밋
             console.log(`  ${icons.arrow} Committing...`);
             const commitResult = await runCommit(baseDir, feature);
             if (commitResult.success) {
@@ -159,24 +290,48 @@ export async function auto(count = '5', options = {}) {
                 status: 'success',
                 duration: Date.now() - featureStartTime,
             });
+            // Clear session context (success)
+            clearSessionContext(baseDir);
             // progress.md에 기록
-            appendToProgress(baseDir, `- [x] ${feature.id}: Completed automatically\n`);
+            const attemptSuffix = (featureContext?.attemptNumber || 1) > 1
+                ? ` (succeeded on attempt ${featureContext?.attemptNumber})`
+                : '';
+            appendToProgress(baseDir, `- [x] ${feature.id}: Completed automatically${attemptSuffix}\n`);
         }
         catch (error) {
             failedCount++;
             const errorMessage = error instanceof Error ? error.message : String(error);
+            // Analyze failure pattern
+            const failureAnalysis = analyzeFailure(errorMessage);
+            // Display failure info
             console.log(`  ${icons.error} Failed: ${errorMessage}`);
+            // Verbose: show failure analysis
+            if (isVerbose && failureAnalysis.category !== 'unknown') {
+                verboseLog(`Failure category: ${failureAnalysis.category}`);
+                verboseLog(`Suggested fix: ${failureAnalysis.suggestion}`);
+                verboseLog(`Should retry: ${failureAnalysis.shouldRetry ? 'Yes' : 'No (consider manual fix)'}`);
+            }
             results.push({
                 featureId: feature.id,
                 status: 'failed',
                 error: errorMessage,
                 duration: Date.now() - featureStartTime,
             });
+            // Update session context (failed) with failure analysis
+            updateSessionContext(baseDir, feature, {
+                status: 'failed',
+                attempts: featureContext?.attemptNumber || 1,
+                error: errorMessage,
+                failureAnalysis,
+            });
             // 롤백
             console.log(`  ${icons.arrow} Rolling back...`);
             await rollback(baseDir);
             // progress.md에 기록
-            appendToProgress(baseDir, `- [ ] ${feature.id}: Failed - ${errorMessage}\n`);
+            const attemptInfo = `(attempt ${featureContext?.attemptNumber}/${maxAttempts})`;
+            const willRetry = (featureContext?.attemptNumber || 1) < maxAttempts ? ' - will retry' : ' - max attempts reached';
+            const categoryInfo = failureAnalysis.category !== 'unknown' ? ` [${failureAnalysis.category}]` : '';
+            appendToProgress(baseDir, `- [ ] ${feature.id}: Failed ${attemptInfo}${willRetry}${categoryInfo} - ${errorMessage}\n`);
         }
         // 쿨다운 (다음 iteration이 있고 중단 요청이 없을 때만)
         if (!shouldStop) {
@@ -190,25 +345,46 @@ export async function auto(count = '5', options = {}) {
     }
     // 최종 결과 출력
     const totalDuration = Date.now() - startTime;
+    const sessionEndTime = new Date().toISOString();
     const finalProgress = getProgress(baseDir);
+    // 성공/실패한 features 분류
+    const completedFeatures = results.filter((r) => r.status === 'success');
+    const failedFeatures = results.filter((r) => r.status === 'failed');
+    const skippedFeatures = results.filter((r) => r.status === 'skipped');
     printSection('Summary');
     console.log('');
     console.log(`  ${colors.success('Completed:')} ${completedCount}`);
     console.log(`  ${colors.error('Failed:')} ${failedCount}`);
-    console.log(`  ${colors.dim('Skipped:')} ${results.filter((r) => r.status === 'skipped').length}`);
+    console.log(`  ${colors.dim('Skipped:')} ${skippedFeatures.length}`);
     console.log('');
     console.log(`  ${colors.dim('Progress:')} ${initialProgress.percentage}% → ${finalProgress.percentage}%`);
     console.log(`  ${colors.dim('Duration:')} ${formatDuration(totalDuration)}`);
     console.log('');
-    // 최종 로그
+    // 최종 로그 (상세 세션 요약)
     const autoEndLog = `
-### Summary
-- Processed: ${processedCount}
-- Completed: ${completedCount}
-- Failed: ${failedCount}
-- Progress: ${initialProgress.percentage}% → ${finalProgress.percentage}%
-- Duration: ${formatDuration(totalDuration)}
+### Session Summary
+
+#### Metrics
+- **Session ID**: ${sessionId}
+- **Started at**: ${sessionStartTime}
+- **Ended at**: ${sessionEndTime}
+- **Duration**: ${formatDuration(totalDuration)}
+- **Processed**: ${processedCount} features
+- **Completed**: ${completedCount} features
+- **Failed**: ${failedCount} features
+- **Skipped**: ${skippedFeatures.length} features
+- **Progress**: ${initialProgress.percentage}% → ${finalProgress.percentage}%
+- **Success Rate**: ${processedCount > 0 ? Math.round((completedCount / processedCount) * 100) : 0}%
 
+${completedFeatures.length > 0 ? `#### ✅ Completed Features
+${completedFeatures.map((r) => `- **${r.featureId}** (${formatDuration(r.duration)})`).join('\n')}
+` : ''}
+${failedFeatures.length > 0 ? `#### ❌ Failed Features
+${failedFeatures.map((r) => `- **${r.featureId}**: ${r.error} (${formatDuration(r.duration)})`).join('\n')}
+` : ''}
+${skippedFeatures.length > 0 ? `#### ⏭️ Skipped Features
+${skippedFeatures.map((r) => `- **${r.featureId}**`).join('\n')}
+` : ''}
 ---
 `;
     appendToProgress(baseDir, autoEndLog);
@@ -220,7 +396,7 @@ export async function auto(count = '5', options = {}) {
     }
 }
 /**
- * session_context.md에서 진행 중인 작업을 찾아 반환
+ * session_context.md에서 진행 중인 작업을 찾아 반환 (with context)
  */
 function getInProgressFeature(baseDir, featureList) {
     const sessionContextPath = path.join(baseDir, '.aiag', 'session_context.md');
@@ -245,6 +421,100 @@ function getInProgressFeature(baseDir, featureList) {
         return undefined;
     }
 }
+/**
+ * session_context.md에서 feature의 컨텍스트 정보 추출
+ */
+function getFeatureContext(baseDir, featureId) {
+    const sessionContextPath = path.join(baseDir, '.aiag', 'session_context.md');
+    if (!fs.existsSync(sessionContextPath)) {
+        return { attemptNumber: 1 };
+    }
+    try {
+        const content = fs.readFileSync(sessionContextPath, 'utf-8');
+        // Attempts 추출
+        const attemptsMatch = content.match(/- Attempts:\s*(\d+)/);
+        const attemptNumber = attemptsMatch ? parseInt(attemptsMatch[1], 10) + 1 : 1;
+        // Previous error 추출
+        const errorMatch = content.match(/## Previous Error\s*```\s*(.+?)\s*```/s);
+        const previousError = errorMatch ? errorMatch[1].trim() : undefined;
+        return {
+            attemptNumber,
+            previousError,
+        };
+    }
+    catch {
+        return { attemptNumber: 1 };
+    }
+}
+/**
+ * Update session_context.md with feature info and failure context
+ */
+function updateSessionContext(baseDir, feature, context) {
+    const sessionContextPath = path.join(baseDir, '.aiag', 'session_context.md');
+    const timestamp = new Date().toISOString();
+    let content = `# Current Session Context
+
+## Active Feature
+
+- ID: ${feature.id}
+- Description: ${feature.description}
+- Status: ${context.status}
+- Started: ${timestamp}
+- Attempts: ${context.attempts}
+
+`;
+    if (context.error) {
+        content += `## Previous Error
+
+\`\`\`
+${context.error}
+\`\`\`
+
+`;
+        // Add failure analysis if available
+        if (context.failureAnalysis && context.failureAnalysis.category !== 'unknown') {
+            content += `## Failure Analysis
+
+- **Category**: ${context.failureAnalysis.category}
+- **Suggested Fix**: ${context.failureAnalysis.suggestion}
+- **Should Retry**: ${context.failureAnalysis.shouldRetry ? 'Yes' : 'No (manual fix recommended)'}
+
+`;
+        }
+    }
+    content += `## Acceptance Criteria
+
+${feature.acceptanceCriteria.map((c, i) => `${i + 1}. [ ] ${c}`).join('\n')}
+
+## Next Action
+
+${context.status === 'failed' ? '- Retry with different approach based on error analysis' : '- Continue implementation or verify completion'}
+`;
+    try {
+        fs.writeFileSync(sessionContextPath, content, 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to update session context:', error);
+    }
+}
+/**
+ * Clear session context (on successful completion)
+ */
+function clearSessionContext(baseDir) {
+    const sessionContextPath = path.join(baseDir, '.aiag', 'session_context.md');
+    const content = `# Current Session Context
+
+## No Active Feature
+
+Last updated: ${new Date().toISOString()}
+`;
+    try {
+        fs.writeFileSync(sessionContextPath, content, 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to clear session context:', error);
+    }
+}
 function selectNextFeature(featureList, options) {
     let candidates = featureList.features.filter((f) => !f.passes);
     // 카테고리 필터
@@ -264,8 +534,8 @@ function selectNextFeature(featureList, options) {
     candidates.sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]);
     return candidates[0];
 }
-async function runClaudeCode(baseDir, feature, timeout, verbose) {
-    const prompt = generatePrompt(feature);
+async function runClaudeCode(baseDir, feature, context, timeout, verbose) {
+    const prompt = generateEnhancedPrompt(feature, context);
     // verbose 로그 헬퍼
     const verboseLog = (message) => {
         if (verbose) {
@@ -434,20 +704,392 @@ async function rollback(baseDir) {
         });
     });
 }
-function generatePrompt(feature) {
-    const lines = [
-        `${feature.id} feature를 구현해주세요.`,
-        '',
-        'Acceptance Criteria:',
-        ...feature.acceptanceCriteria.map((c) => `- ${c}`),
-        '',
-    ];
+/**
+ * Run self-verification to check if all acceptance criteria are met
+ */
+async function runSelfVerification(baseDir, feature, timeout, verbose) {
+    const verboseLog = (message) => {
+        if (verbose) {
+            console.log(colors.dim(`  [verbose] ${message}`));
+        }
+    };
+    verboseLog(`Starting self-verification for ${feature.id}`);
+    const verificationPrompt = `
+# Self-Verification for ${feature.id}
+
+Your implementation of ${feature.id} is complete. Now you MUST verify that ALL acceptance criteria are satisfied.
+
+## Acceptance Criteria to Verify:
+
+${feature.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}
+
+## Verification Instructions:
+
+For each criterion above, check if it is satisfied by:
+1. Inspecting the code you wrote
+2. Checking if files exist
+3. Verifying function signatures and implementations
+4. Confirming expected behavior
+
+## Response Format:
+
+You MUST respond with EXACTLY this format for each criterion:
+
+\`\`\`
+CRITERION 1: [PASS/FAIL]
+Evidence: [Brief explanation of how this criterion is met, or why it failed]
+
+CRITERION 2: [PASS/FAIL]
+Evidence: [Brief explanation]
+
+...
+\`\`\`
+
+Then, at the end, provide a final verdict:
+
+\`\`\`
+FINAL VERDICT: [ALL PASS / FAILED]
+\`\`\`
+
+**IMPORTANT:**
+- Be HONEST and STRICT in your verification
+- If ANY criterion is not met, mark it as FAIL
+- Only respond ALL PASS if EVERY criterion is satisfied
+- If you're unsure about a criterion, mark it as FAIL and explain why
+
+Start verification now.
+`;
+    const result = await runClaudeCodeForVerification(baseDir, verificationPrompt, timeout, verbose);
+    if (!result.success) {
+        verboseLog(`Verification failed to run: ${result.error}`);
+        return {
+            allPassed: false,
+            results: feature.acceptanceCriteria.map((c) => ({
+                criterion: c,
+                passed: false,
+                evidence: 'Verification did not complete',
+            })),
+            report: result.error || 'Verification failed',
+        };
+    }
+    // Parse verification output
+    return parseVerificationOutput(result.output || '', feature.acceptanceCriteria);
+}
+/**
+ * Run Claude Code specifically for verification (separate from implementation)
+ */
+async function runClaudeCodeForVerification(baseDir, prompt, timeout, verbose) {
+    const verboseLog = (message) => {
+        if (verbose) {
+            console.log(colors.dim(`  [verbose] ${message}`));
+        }
+    };
+    return new Promise((resolve) => {
+        const args = [
+            '--print',
+            '--dangerously-skip-permissions',
+            '--strict-mcp-config',
+            prompt,
+        ];
+        verboseLog(`Spawning claude for verification`);
+        const claude = spawn('claude', args, {
+            cwd: baseDir,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                MCP_TIMEOUT: '10000',
+            },
+        });
+        let stdout = '';
+        let stderr = '';
+        if (claude.stdout) {
+            claude.stdout.on('data', (data) => {
+                const chunk = data.toString();
+                stdout += chunk;
+                if (verbose) {
+                    process.stdout.write(chunk);
+                }
+            });
+        }
+        if (claude.stderr) {
+            claude.stderr.on('data', (data) => {
+                const chunk = data.toString();
+                stderr += chunk;
+                if (verbose) {
+                    process.stderr.write(chunk);
+                }
+            });
+        }
+        const timeoutId = setTimeout(() => {
+            verboseLog('Verification timeout, killing process...');
+            claude.kill('SIGTERM');
+            setTimeout(() => {
+                if (!claude.killed) {
+                    claude.kill('SIGKILL');
+                }
+            }, 5000);
+            resolve({ success: false, error: `Verification timeout after ${timeout / 1000}s` });
+        }, timeout);
+        claude.on('close', (code) => {
+            clearTimeout(timeoutId);
+            verboseLog(`Verification process exited with code=${code}`);
+            if (code === 0) {
+                resolve({ success: true, output: stdout });
+            }
+            else {
+                resolve({ success: false, error: `Exit code ${code}`, output: stdout + stderr });
+            }
+        });
+        claude.on('error', (err) => {
+            clearTimeout(timeoutId);
+            verboseLog(`Verification spawn error: ${err.message}`);
+            resolve({ success: false, error: err.message });
+        });
+    });
+}
+/**
+ * Parse verification output from Claude
+ */
+function parseVerificationOutput(output, acceptanceCriteria) {
+    const results = [];
+    let allPassed = false;
+    // Extract CRITERION N: PASS/FAIL lines
+    const criterionPattern = /CRITERION\s+(\d+):\s*(PASS|FAIL)\s*\n\s*Evidence:\s*(.+?)(?=\n\s*CRITERION|\n\s*FINAL|$)/gis;
+    let match;
+    const foundCriteria = new Map();
+    while ((match = criterionPattern.exec(output)) !== null) {
+        const index = parseInt(match[1], 10) - 1; // Convert to 0-based index
+        const passed = match[2].toUpperCase() === 'PASS';
+        const evidence = match[3].trim();
+        foundCriteria.set(index, { passed, evidence });
+    }
+    // Build results array
+    acceptanceCriteria.forEach((criterion, index) => {
+        const found = foundCriteria.get(index);
+        if (found) {
+            results.push({
+                criterion,
+                passed: found.passed,
+                evidence: found.evidence,
+            });
+        }
+        else {
+            // Criterion not found in output
+            results.push({
+                criterion,
+                passed: false,
+                evidence: 'Not verified (missing in output)',
+            });
+        }
+    });
+    // Check final verdict
+    const finalVerdictMatch = output.match(/FINAL\s+VERDICT:\s*(ALL\s+PASS|FAILED)/i);
+    if (finalVerdictMatch) {
+        allPassed = finalVerdictMatch[1].toUpperCase().includes('ALL PASS');
+    }
+    else {
+        // No final verdict found, check if all criteria passed
+        allPassed = results.every((r) => r.passed);
+    }
+    return {
+        allPassed,
+        results,
+        report: output,
+    };
+}
+/**
+ * Build context for enhanced prompt generation
+ */
+async function buildPromptContext(baseDir, feature, featureList, attemptNumber = 1, previousError) {
+    // Get recent commits
+    const recentCommits = await getRecentCommits(baseDir, 5);
+    // Get recent progress
+    const recentProgress = getRecentProgress(baseDir);
+    // Get dependencies
+    const dependencies = (feature.dependsOn || [])
+        .map((depId) => featureList.features.find((f) => f.id === depId))
+        .filter((f) => f !== undefined && f.passes === true);
+    return {
+        recentCommits,
+        recentProgress,
+        dependencies,
+        workingDirectory: baseDir,
+        attemptNumber,
+        previousError,
+    };
+}
+/**
+ * Get recent git commits
+ */
+async function getRecentCommits(baseDir, count) {
+    return new Promise((resolve) => {
+        const git = spawn('git', ['log', '--oneline', `-${count}`], {
+            cwd: baseDir,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        if (git.stdout) {
+            git.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+        }
+        git.on('close', () => {
+            const commits = stdout
+                .trim()
+                .split('\n')
+                .filter((line) => line.length > 0);
+            resolve(commits);
+        });
+        git.on('error', () => {
+            resolve([]);
+        });
+    });
+}
+/**
+ * Get recent progress from progress.md
+ */
+function getRecentProgress(baseDir) {
+    try {
+        const progressPath = path.join(baseDir, '.aiag', 'progress.md');
+        if (!fs.existsSync(progressPath)) {
+            return 'No progress history available';
+        }
+        const content = fs.readFileSync(progressPath, 'utf-8');
+        const lines = content.split('\n');
+        // Get last session or last 10 lines
+        const recentLines = lines.slice(-20).join('\n');
+        return recentLines.trim() || 'No recent progress';
+    }
+    catch {
+        return 'Error reading progress';
+    }
+}
+/**
+ * Generate enhanced prompt with session checklist and context
+ */
+function generateEnhancedPrompt(feature, context) {
+    const lines = [];
+    // Session Start Checklist
+    lines.push('# Session Start Checklist');
+    lines.push('');
+    lines.push(`□ 1. Working directory: ${context.workingDirectory}`);
+    lines.push('□ 2. Recent progress:');
+    lines.push(context.recentProgress.split('\n').map((l) => `   ${l}`).join('\n'));
+    lines.push('');
+    lines.push('□ 3. Recent commits:');
+    if (context.recentCommits.length > 0) {
+        context.recentCommits.forEach((commit) => {
+            lines.push(`   - ${commit}`);
+        });
+    }
+    else {
+        lines.push('   - (no recent commits)');
+    }
+    lines.push('');
+    // Dependencies
+    if (context.dependencies.length > 0) {
+        lines.push('□ 4. Dependencies (already completed):');
+        context.dependencies.forEach((dep) => {
+            lines.push(`   ✓ ${dep.id}: ${dep.description}`);
+        });
+        lines.push('');
+    }
+    lines.push('---');
+    lines.push('');
+    // Feature Implementation Section
+    lines.push(`# Feature Implementation: ${feature.id}`);
+    lines.push('');
+    lines.push('## Description');
+    lines.push(feature.description);
+    lines.push('');
+    lines.push('## Priority');
+    lines.push(`${feature.priority} - Must complete before dependent features can proceed`);
+    lines.push('');
+    // Retry context if applicable
+    if (context.attemptNumber && context.attemptNumber > 1) {
+        lines.push('## ⚠️ Retry Attempt');
+        lines.push(`This is attempt #${context.attemptNumber} for this feature.`);
+        lines.push('');
+        if (context.previousError) {
+            lines.push('### Previous Failure:');
+            lines.push('```');
+            lines.push(context.previousError);
+            lines.push('```');
+            lines.push('');
+            lines.push('**Please analyze the error and try a different approach.**');
+            lines.push('');
+        }
+    }
+    // Acceptance Criteria
+    lines.push('## Acceptance Criteria');
+    lines.push('');
+    feature.acceptanceCriteria.forEach((criterion, index) => {
+        lines.push(`${index + 1}. [ ] ${criterion}`);
+    });
+    lines.push('');
+    // Test Command
     if (feature.testCommand) {
-        lines.push(`테스트 명령어: ${feature.testCommand}`);
+        lines.push('## Test Command');
+        lines.push('```bash');
+        lines.push(feature.testCommand);
+        lines.push('```');
+        lines.push('');
     }
+    // Implementation Guidelines
+    lines.push('## Implementation Guidelines');
+    lines.push('');
+    lines.push('### 1. ONE Feature Rule');
+    lines.push(`- Implement ONLY ${feature.id}`);
+    lines.push('- Do NOT modify unrelated code');
+    lines.push('- If you discover issues in other features, note them in comments but DO NOT fix');
+    lines.push('');
+    lines.push('### 2. Code Quality');
+    lines.push('- Follow existing codebase patterns');
+    lines.push('- Add comments for complex logic (in Korean)');
+    lines.push('- Use meaningful variable names');
+    lines.push('- Maintain clean, readable code');
+    lines.push('');
+    lines.push('### 3. Testing Strategy');
+    lines.push('- Run tests frequently during development');
+    lines.push('- Tests must pass before marking complete');
+    lines.push('- Fix any test failures immediately');
+    lines.push('');
+    lines.push('### 4. Incremental Progress');
+    lines.push('- Make small, working commits if needed');
+    lines.push('- Each intermediate state should compile and run');
+    lines.push(`- Use commit message format: "feat(${feature.id}): [description]"`);
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    // Completion Criteria
+    lines.push('# Completion Criteria');
+    lines.push('');
+    lines.push('Before marking this feature as complete, you MUST verify:');
+    lines.push('');
+    lines.push('1. ✓ All acceptance criteria are satisfied');
+    lines.push(`2. ✓ Test command passes: \`${feature.testCommand || 'bun test'}\``);
+    lines.push('3. ✓ Code follows project conventions');
+    lines.push('4. ✓ No unintended side effects in other parts of codebase');
+    lines.push('5. ✓ Clean state (code compiles and runs)');
     lines.push('');
-    lines.push('구현이 완료되면 테스트를 실행할 수 있도록 코드를 작성하세요.');
-    lines.push('테스트 실패 시 변경사항은 롤백됩니다.');
+    lines.push('**If ANY criterion fails, DO NOT mark as complete.**');
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    // Failure Handling
+    lines.push('# On Failure');
+    lines.push('');
+    lines.push('If you cannot complete this feature:');
+    lines.push('1. Document the specific blocker or error');
+    lines.push('2. Rollback any breaking changes');
+    lines.push('3. Leave codebase in clean, working state');
+    lines.push('4. Report the failure reason clearly');
+    lines.push('');
+    lines.push('---');
+    lines.push('');
+    lines.push('**Start implementation now.**');
     return lines.join('\n');
 }
 function sleep(ms) {
@@ -467,4 +1109,39 @@ function formatDuration(ms) {
         return `${seconds}s`;
     }
 }
+/**
+ * Analyze failure error message and match against known patterns
+ */
+function analyzeFailure(errorMessage) {
+    // Try to match against known patterns
+    for (const pattern of KNOWN_PATTERNS) {
+        if (pattern.pattern.test(errorMessage)) {
+            return {
+                category: pattern.category,
+                shouldRetry: pattern.shouldRetry,
+                suggestion: pattern.suggestedFix,
+                matchedPattern: pattern,
+            };
+        }
+    }
+    // Unknown error - default to retry
+    return {
+        category: 'unknown',
+        shouldRetry: true,
+        suggestion: 'Unknown error. Review the error message carefully and debug step by step.',
+    };
+}
+/**
+ * Generate unique session ID based on timestamp
+ */
+function generateSessionId() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hours = String(now.getHours()).padStart(2, '0');
+    const minutes = String(now.getMinutes()).padStart(2, '0');
+    const seconds = String(now.getSeconds()).padStart(2, '0');
+    return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
 //# sourceMappingURL=auto.js.map