aiag-cli 1.8.0 → 2.1.0

package/dist/commands/auto.js

@@ -3,9 +3,31 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { readFeatureList, writeFeatureList, getProgress } from '../utils/featureList.js';
 import { appendToProgress, recordWorkCompleted, updateProgressSummary, updateNextSteps, } from '../utils/progress.js';
-import { printHeader, printError, printSuccess, printWarning, printSection, colors, icons, } from '../utils/output.js';
+import { printHeader, printError, printSuccess, printWarning, printSection, printInfo, colors, icons, } from '../utils/output.js';
 import { getInterruptedWork, updateSessionContext as updateSessionContextUtil, clearSessionContext as clearSessionContextUtil, } from '../utils/sessionContext.js';
+import { loadConnection, saveCurrentSession, clearCurrentSession, } from '../utils/connection.js';
+import { getApiClient } from '../api/client.js';
 import { PRIORITY_ORDER } from '../types.js';
+import { getInitializerPrompt, getFeatureImplementationPrompt, } from '../prompts/index.js';
+// Claude Agent SDK
+import { runAgent, runFeatureImplementation, runInitializer, SECURITY_PRESET_DEVELOPMENT, } from '../sdk/index.js';
+/**
+ * 서버에 Feature 로그 전송 (비동기, 실패해도 계속 진행)
+ */
+async function sendFeatureLog(serverCtx, featureId, type, message, metadata) {
+    if (!serverCtx.connected || !serverCtx.client)
+        return;
+    try {
+        await serverCtx.client.sendLog(featureId, {
+            type,
+            message,
+            metadata,
+        });
+    }
+    catch {
+        // 로그 전송 실패해도 무시 (로컬 작업 계속 진행)
+    }
+}
 /**
  * 알려진 실패 패턴 (Common failure patterns)
  */
@@ -76,7 +98,7 @@ export async function auto(count = '5', options = {}) {
     const isVerbose = options.verbose === true;
     const maxFeatures = isLoopMode ? Infinity : (parseInt(count, 10) || 5);
     const cooldownMs = (options.cooldown || 5) * 1000;
-    const claudeTimeout = (options.timeout || 10) * 60 * 1000; // 기본 10분
+    const claudeTimeout = (options.timeout || 30) * 60 * 1000; // 기본 30분 (복잡한 기능 구현을 위해 증가)
     const maxAttempts = parseInt(String(options.maxAttempts || 3), 10); // 기본 최대 3회 시도
     // verbose 로그 헬퍼
     const verboseLog = (message) => {
@@ -108,6 +130,37 @@ export async function auto(count = '5', options = {}) {
     const startTime = Date.now();
     const sessionId = generateSessionId();
     const sessionStartTime = new Date().toISOString();
+    const processedInDryRun = new Set(); // dry-run 모드에서 처리된 feature 추적
+    // 서버 연결 초기화
+    const connection = loadConnection(baseDir);
+    const client = getApiClient();
+    const serverCtx = {
+        connected: false,
+    };
+    // 서버에 세션 시작 알림 (연결된 경우)
+    if (connection && client) {
+        try {
+            const sessionInfo = await client.startSession(connection.projectId, {
+                agentType: 'cli',
+                notes: `Auto mode started: ${isLoopMode ? 'loop' : `batch (${maxFeatures})`}`,
+            });
+            serverCtx.connected = true;
+            serverCtx.projectId = connection.projectId;
+            serverCtx.sessionId = sessionInfo.id;
+            serverCtx.client = client;
+            // 현재 세션 정보 저장
+            saveCurrentSession({
+                id: sessionInfo.id,
+                projectId: sessionInfo.projectId,
+                startedAt: sessionInfo.startedAt,
+                agentType: 'cli',
+            }, baseDir);
+            printInfo(colors.dim(`서버 세션 시작됨 (ID: ${sessionInfo.id.slice(0, 8)}...)`));
+        }
+        catch {
+            printWarning('서버 세션 등록 실패 (로컬 모드로 계속)');
+        }
+    }
     // Ctrl+C 핸들링 (loop 모드용)
     let shouldStop = false;
     const handleSignal = () => {
@@ -167,13 +220,13 @@ export async function auto(count = '5', options = {}) {
                 verboseLog(`Feature ${interruptedWork.feature.id} exceeded max attempts (${maxAttempts}), moving to next`);
                 appendToProgress(baseDir, `- [!] ${interruptedWork.feature.id}: Permanently failed after ${maxAttempts} attempts\n`);
                 clearSessionContextUtil(baseDir); // 컨텍스트 정리하고 다음 feature로
-                feature = selectNextFeature(currentFeatureList, options);
+                feature = selectNextFeature(currentFeatureList, options, processedInDryRun);
                 featureContext = { attemptNumber: 1 };
             }
         }
         else {
             // 중단된 작업 없음 - 다음 feature 선택
-            feature = selectNextFeature(currentFeatureList, options);
+            feature = selectNextFeature(currentFeatureList, options, processedInDryRun);
             featureContext = { attemptNumber: 1 };
             if (feature) {
                 verboseLog(`Selected next feature: ${feature.id}`);
@@ -208,6 +261,7 @@ export async function auto(count = '5', options = {}) {
                 status: 'skipped',
                 duration: 0,
             });
+            processedInDryRun.add(feature.id); // dry-run에서 처리된 feature 추적
             continue;
         }
         try {
@@ -216,12 +270,18 @@ export async function auto(count = '5', options = {}) {
                 status: 'in_progress',
                 attempts: featureContext?.attemptNumber || 1,
             });
+            // 서버에 feature 시작 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'started', `Started working on ${feature.id}: ${feature.description}`, {
+                attemptNumber: featureContext?.attemptNumber || 1,
+                priority: feature.priority,
+                category: feature.category,
+            });
             // 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로 구현 시도
+            // 3. Claude Code로 구현 시도 (SDK 사용)
             console.log(`  ${icons.arrow} ${colors.cyan('work')} ${feature.id}`);
-            verboseLog(`Starting Claude Code for ${feature.id}`);
+            verboseLog(`Starting Claude SDK for ${feature.id}`);
             const implementStart = Date.now();
             const implementResult = await runClaudeCode(baseDir, feature, promptContext, claudeTimeout, isVerbose);
             if (!implementResult.success) {
@@ -231,6 +291,8 @@ export async function auto(count = '5', options = {}) {
             const implementDuration = Date.now() - implementStart;
             console.log(`  ${icons.success} work completed (${formatDuration(implementDuration)})`);
             verboseLog('Implementation completed successfully');
+            // 서버에 progress 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'progress', `Implementation completed in ${formatDuration(implementDuration)}`, { phase: 'implementation', duration: implementDuration });
             // 2. Self-Verification
             console.log(`  ${icons.arrow} ${colors.cyan('verify')} ${feature.id}`);
             verboseLog('Running self-verification of acceptance criteria');
@@ -247,6 +309,8 @@ export async function auto(count = '5', options = {}) {
             const verifyDuration = Date.now() - verifyStart;
             console.log(`  ${icons.success} verify passed (${formatDuration(verifyDuration)})`);
             verboseLog(`All ${feature.acceptanceCriteria.length} criteria passed verification`);
+            // 서버에 verification 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'progress', `Self-verification passed (${feature.acceptanceCriteria.length} criteria)`, { phase: 'verification', duration: verifyDuration });
             // 3. 테스트 실행
             console.log(`  ${icons.arrow} ${colors.cyan('test')} ${feature.id}`);
             const testStart = Date.now();
@@ -256,6 +320,8 @@ export async function auto(count = '5', options = {}) {
             }
             const testDuration = Date.now() - testStart;
             console.log(`  ${icons.success} test passed (${formatDuration(testDuration)})`);
+            // 서버에 test passed 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'test_passed', `Tests passed in ${formatDuration(testDuration)}`, { phase: 'test', duration: testDuration, testCommand: feature.testCommand });
             // 4. 완료 처리
             console.log(`  ${icons.arrow} ${colors.cyan('complete')} ${feature.id}`);
             await markComplete(baseDir, feature.id);
@@ -272,10 +338,17 @@ export async function auto(count = '5', options = {}) {
                 console.log(`  ${colors.warning('⚠')} commit failed (continuing anyway)`);
             }
             completedCount++;
+            const featureDuration = Date.now() - featureStartTime;
             results.push({
                 featureId: feature.id,
                 status: 'success',
-                duration: Date.now() - featureStartTime,
+                duration: featureDuration,
+            });
+            // 서버에 feature 완료 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'completed', `Feature ${feature.id} completed successfully in ${formatDuration(featureDuration)}`, {
+                duration: featureDuration,
+                commitHash: commitResult.hash,
+                attemptNumber: featureContext?.attemptNumber || 1,
             });
             // Clear session context (success)
             clearSessionContextUtil(baseDir);
@@ -290,6 +363,12 @@ export async function auto(count = '5', options = {}) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             // Analyze failure pattern
             const failureAnalysis = analyzeFailure(errorMessage);
+            // 서버에 실패 로그 전송
+            await sendFeatureLog(serverCtx, feature.id, 'failed', `Feature ${feature.id} failed: ${errorMessage}`, {
+                attemptNumber: featureContext?.attemptNumber || 1,
+                failureCategory: failureAnalysis.category,
+                willRetry: (featureContext?.attemptNumber || 1) < maxAttempts && failureAnalysis.shouldRetry,
+            });
             // Display failure info
             console.log(`  ${icons.error} Failed: ${errorMessage}`);
             // Verbose: show failure analysis
@@ -332,12 +411,35 @@ export async function auto(count = '5', options = {}) {
     }
     // 최종 결과 출력
     const totalDuration = Date.now() - startTime;
+    const totalDurationSeconds = Math.floor(totalDuration / 1000);
     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');
+    // 서버에 세션 종료 알림 (연결된 경우)
+    if (serverCtx.connected && serverCtx.client && serverCtx.sessionId) {
+        try {
+            await serverCtx.client.endSession(serverCtx.sessionId, {
+                workDone: completedFeatures.map((r) => `${r.featureId}: Completed automatically`),
+                commits: [], // 커밋 해시는 개별 feature에서 처리됨
+                nextSteps: failedFeatures.map((r) => `Retry ${r.featureId}: ${r.error?.slice(0, 50)}`),
+                notes: [
+                    `Auto mode: ${isLoopMode ? 'loop' : `batch (${maxFeatures})`}`,
+                    `Progress: ${initialProgress.percentage}% → ${finalProgress.percentage}%`,
+                    `Success rate: ${processedCount > 0 ? Math.round((completedCount / processedCount) * 100) : 0}%`,
+                ],
+                duration: totalDurationSeconds,
+            });
+            // 현재 세션 정보 삭제
+            clearCurrentSession(baseDir);
+            printInfo(colors.dim(`서버 세션 종료됨 (${formatDurationKo(totalDurationSeconds)})`));
+        }
+        catch {
+            printWarning('서버 세션 종료 알림 실패');
+        }
+    }
     printSection('Summary');
     console.log('');
     console.log(`  ${colors.success('Completed:')} ${completedCount}`);
@@ -382,19 +484,24 @@ ${skippedFeatures.map((r) => `- **${r.featureId}**`).join('\n')}
         printWarning('Auto mode finished with failures');
     }
 }
-function selectNextFeature(featureList, options) {
+function selectNextFeature(featureList, options, excludeIds) {
     let candidates = featureList.features.filter((f) => !f.passes);
+    // dry-run 모드에서 이미 처리된 feature 제외
+    if (excludeIds && excludeIds.size > 0) {
+        candidates = candidates.filter((f) => !excludeIds.has(f.id));
+    }
     // 카테고리 필터
     if (options.category) {
         candidates = candidates.filter((f) => f.category === options.category);
     }
-    // 의존성 확인
+    // 의존성 확인 (dry-run에서는 처리된 것도 완료로 간주)
     candidates = candidates.filter((f) => {
         if (!f.dependsOn || f.dependsOn.length === 0)
             return true;
         return f.dependsOn.every((depId) => {
             const dep = featureList.features.find((df) => df.id === depId);
-            return dep?.passes === true;
+            // 실제로 passes이거나, dry-run에서 처리된 경우
+            return dep?.passes === true || (excludeIds && excludeIds.has(depId));
         });
     });
     // 우선순위로 정렬
@@ -402,100 +509,62 @@ function selectNextFeature(featureList, options) {
     return candidates[0];
 }
 async function runClaudeCode(baseDir, feature, context, timeout, verbose) {
-    const prompt = generateEnhancedPrompt(feature, context);
+    // Two-Agent Pattern: 새로운 간결한 프롬프트 사용
+    const progress = getProgress(baseDir);
+    const codingContext = {
+        projectDir: context.workingDirectory,
+        recentCommits: context.recentCommits,
+        recentProgress: context.recentProgress,
+        completedFeatures: progress.completed,
+        totalFeatures: progress.total,
+        attemptNumber: context.attemptNumber,
+        previousError: context.previousError,
+        dependencies: context.dependencies,
+    };
+    const prompt = getFeatureImplementationPrompt(feature, codingContext);
     // verbose 로그 헬퍼
     const verboseLog = (message) => {
         if (verbose) {
             console.log(colors.dim(`  [verbose] ${message}`));
         }
     };
-    return new Promise((resolve) => {
-        // Claude Code 인자 구성
-        // --dangerously-skip-permissions: 권한 확인 건너뛰기 (비대화형 자동화에 필요)
-        // --strict-mcp-config: MCP 서버 연결 건너뛰기 (자동화에서 MCP 서버 불필요)
-        const args = [
-            '--print',
-            '--dangerously-skip-permissions',
-            '--strict-mcp-config',
-            prompt,
-        ];
-        verboseLog(`Spawning claude with args: ${args.slice(0, 3).join(' ')} [prompt...]`);
-        verboseLog(`Timeout: ${timeout / 1000}s`);
-        // MCP 서버 연결 타임아웃 설정 (기본 10초)
-        // MCP 서버 초기화가 느릴 경우 Claude Code 시작이 지연되는 문제 방지
-        const mcpTimeout = process.env.MCP_TIMEOUT || '10000';
-        verboseLog(`MCP_TIMEOUT: ${mcpTimeout}ms`);
-        // stdin은 ignore (Claude Code가 stdin 대기로 블로킹되는 것 방지)
-        // stdout/stderr은 pipe로 출력 수집
-        const claude = spawn('claude', args, {
-            cwd: baseDir,
-            shell: false,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                MCP_TIMEOUT: mcpTimeout,
+    // Claude Agent SDK 사용
+    verboseLog('Using Claude Agent SDK');
+    try {
+        const result = await runFeatureImplementation(feature, prompt, {
+            workingDirectory: baseDir,
+            timeout,
+            maxTurns: 200,
+            securityConfig: SECURITY_PRESET_DEVELOPMENT,
+            onLog: verboseLog,
+            onProgress: (message) => {
+                if (verbose && message.type === 'assistant') {
+                    // 어시스턴트 메시지 실시간 출력
+                    const content = message.message?.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block && typeof block === 'object' && 'type' in block && block.type === 'text' && 'text' in block) {
+                                process.stdout.write(block.text);
+                            }
+                        }
+                    }
+                }
             },
         });
-        let stdout = '';
-        let stderr = '';
-        // stdout 처리: 수집 + verbose일 때 실시간 출력
-        if (claude.stdout) {
-            claude.stdout.on('data', (data) => {
-                const chunk = data.toString();
-                stdout += chunk;
-                if (verbose) {
-                    process.stdout.write(chunk);
-                }
-            });
+        if (result.success) {
+            verboseLog(`SDK execution completed: turns=${result.numTurns}, cost=$${result.costUsd?.toFixed(4)}`);
+            return { success: true, output: result.result };
         }
-        // stderr 처리: 수집 + verbose일 때 실시간 출력
-        if (claude.stderr) {
-            claude.stderr.on('data', (data) => {
-                const chunk = data.toString();
-                stderr += chunk;
-                if (verbose) {
-                    process.stderr.write(chunk);
-                }
-            });
+        else {
+            verboseLog(`SDK execution failed: ${result.error}`);
+            return { success: false, error: result.error, output: result.result };
         }
-        const timeoutId = setTimeout(() => {
-            verboseLog('Timeout reached, killing process...');
-            claude.kill('SIGTERM');
-            // SIGTERM 후 5초 대기, 그래도 안 죽으면 SIGKILL
-            setTimeout(() => {
-                if (!claude.killed) {
-                    verboseLog('Process still alive, sending SIGKILL...');
-                    claude.kill('SIGKILL');
-                }
-            }, 5000);
-            const errorMsg = `Timeout after ${timeout / 1000}s`;
-            if (stderr) {
-                verboseLog(`Last stderr: ${stderr.slice(-500)}`);
-            }
-            resolve({ success: false, error: errorMsg, output: stdout + stderr });
-        }, timeout);
-        claude.on('close', (code, signal) => {
-            clearTimeout(timeoutId);
-            verboseLog(`Process exited with code=${code}, signal=${signal}`);
-            if (code === 0) {
-                resolve({ success: true, output: stdout });
-            }
-            else {
-                const errorDetail = signal
-                    ? `Killed by signal ${signal}`
-                    : `Exit code ${code}`;
-                if (stderr) {
-                    verboseLog(`stderr: ${stderr.slice(-500)}`);
-                }
-                resolve({ success: false, error: errorDetail, output: stdout + stderr });
-            }
-        });
-        claude.on('error', (err) => {
-            clearTimeout(timeoutId);
-            verboseLog(`Spawn error: ${err.message}`);
-            resolve({ success: false, error: err.message });
-        });
-    });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        verboseLog(`SDK execution error: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
 }
 async function runTest(baseDir, feature) {
     const testCommand = feature.testCommand || 'bun test';
@@ -511,15 +580,15 @@ async function runTest(baseDir, feature) {
                 resolve({ success: false });
                 return;
             }
-            // UI 카테고리인 경우 브라우저 테스트 추가 실행
-            if (feature.category === 'ui') {
-                console.log(`  ${icons.arrow} ${colors.cyan('browser-test')} ${feature.id}`);
-                const browserTestResult = await runBrowserTest(baseDir, feature);
-                resolve({ success: browserTestResult.success });
-            }
-            else {
-                resolve({ success: true });
-            }
+            // UI 카테고리인 경우 브라우저 테스트 추가 실행 (auto 모드에서 비활성화)
+            // if (feature.category === 'ui') {
+            //   console.log(`  ${icons.arrow} ${colors.cyan('browser-test')} ${feature.id}`);
+            //   const browserTestResult = await runBrowserTest(baseDir, feature);
+            //   resolve({ success: browserTestResult.success });
+            // } else {
+            //   resolve({ success: true });
+            // }
+            resolve({ success: true });
         });
         test.on('error', () => {
             resolve({ success: false });
@@ -532,7 +601,7 @@ async function runTest(baseDir, feature) {
     });
 }
 /**
- * Run browser test using Puppeteer MCP server
+ * Run browser test using Puppeteer MCP server (SDK 사용)
  * UI 카테고리 feature에 대해 자동으로 실행
  */
 async function runBrowserTest(baseDir, feature) {
@@ -547,7 +616,7 @@ async function runBrowserTest(baseDir, feature) {
         const htmlPath = path.join(baseDir, htmlFile);
         const fileUrl = `file://${htmlPath}`;
         console.log(`  ${colors.dim(`  Opening ${htmlFile} in browser...`)}`);
-        // Use Claude Code to run Puppeteer test via MCP
+        // Use Claude Agent SDK to run Puppeteer test via MCP
         const browserTestPrompt = `
 # Browser Test for ${feature.id}
 
@@ -567,7 +636,13 @@ ${feature.acceptanceCriteria.map((c, i) => `   ${i + 1}. ${c}`).join('\n')}
 
 If the page fails to load or doesn't meet the criteria, report the issue.
 `;
-        const result = await runClaudeCodeForBrowserTest(baseDir, browserTestPrompt);
+        const result = await runAgent({
+            workingDirectory: baseDir,
+            prompt: browserTestPrompt,
+            timeout: 60000, // 60 seconds for browser tests
+            maxTurns: 30,
+            securityConfig: SECURITY_PRESET_DEVELOPMENT,
+        });
         if (!result.success) {
             console.log(`  ${colors.error('✗')} browser test failed: ${result.error}`);
             return { success: false, error: result.error };
@@ -581,61 +656,6 @@ If the page fails to load or doesn't meet the criteria, report the issue.
         return { success: true }; // Don't fail the whole feature for browser test errors
     }
 }
-/**
- * Run Claude Code specifically for browser testing
- */
-async function runClaudeCodeForBrowserTest(baseDir, prompt) {
-    return new Promise((resolve) => {
-        const args = [
-            '--print',
-            '--dangerously-skip-permissions',
-            prompt,
-        ];
-        const claude = spawn('claude', args, {
-            cwd: baseDir,
-            shell: false,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                MCP_TIMEOUT: '30000', // 30 seconds for browser operations
-            },
-        });
-        let stdout = '';
-        let stderr = '';
-        if (claude.stdout) {
-            claude.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-        }
-        if (claude.stderr) {
-            claude.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-        }
-        const timeoutId = setTimeout(() => {
-            claude.kill('SIGTERM');
-            setTimeout(() => {
-                if (!claude.killed) {
-                    claude.kill('SIGKILL');
-                }
-            }, 5000);
-            resolve({ success: false, error: 'Browser test timeout' });
-        }, 60000); // 60 second timeout for browser tests
-        claude.on('close', (code) => {
-            clearTimeout(timeoutId);
-            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);
-            resolve({ success: false, error: err.message });
-        });
-    });
-}
 async function markComplete(baseDir, featureId) {
     const featureList = readFeatureList(baseDir);
     if (!featureList)
@@ -774,7 +794,28 @@ FINAL VERDICT: [ALL PASS / FAILED]
 
 Start verification now.
 `;
-    const result = await runClaudeCodeForVerification(baseDir, verificationPrompt, timeout, verbose);
+    // Claude Agent SDK를 사용한 검증
+    verboseLog('Running verification via SDK');
+    const result = await runAgent({
+        workingDirectory: baseDir,
+        prompt: verificationPrompt,
+        timeout,
+        maxTurns: 50,
+        securityConfig: SECURITY_PRESET_DEVELOPMENT,
+        onLog: verboseLog,
+        onProgress: (message) => {
+            if (verbose && message.type === 'assistant') {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block && typeof block === 'object' && 'type' in block && block.type === 'text' && 'text' in block) {
+                            process.stdout.write(block.text);
+                        }
+                    }
+                }
+            }
+        },
+    });
     if (!result.success) {
         verboseLog(`Verification failed to run: ${result.error}`);
         return {
@@ -788,80 +829,7 @@ Start verification now.
         };
     }
     // 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 });
-        });
-    });
+    return parseVerificationOutput(result.result || '', feature.acceptanceCriteria);
 }
 /**
  * Parse verification output from Claude
@@ -1124,6 +1092,23 @@ function formatDuration(ms) {
         return `${seconds}s`;
     }
 }
+/**
+ * 시간 포맷팅 (한글, 초 단위 입력)
+ */
+function formatDurationKo(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+    if (hours > 0) {
+        return `${hours}시간 ${minutes}분`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}분 ${secs}초`;
+    }
+    else {
+        return `${secs}초`;
+    }
+}
 /**
  * Analyze failure error message and match against known patterns
  */
@@ -1159,4 +1144,104 @@ function generateSessionId() {
     const seconds = String(now.getSeconds()).padStart(2, '0');
     return `${year}${month}${day}-${hours}${minutes}${seconds}`;
 }
+/**
+ * 첫 실행 여부 감지
+ * - feature_list.json이 없거나 비어있으면 첫 실행
+ * - 모든 feature가 미완료 상태면 첫 실행으로 간주
+ */
+function isFirstRun(baseDir) {
+    const featureListPath = path.join(baseDir, '.aiag', 'feature_list.json');
+    const progressPath = path.join(baseDir, '.aiag', 'progress.md');
+    // feature_list.json이 없으면 첫 실행
+    if (!fs.existsSync(featureListPath))
+        return true;
+    const featureList = readFeatureList(baseDir);
+    // feature_list.json이 없거나 features가 비어있으면 첫 실행
+    if (!featureList || featureList.features.length === 0)
+        return true;
+    // 모든 feature가 미완료 상태면 첫 실행으로 간주
+    const hasAnyProgress = featureList.features.some((f) => f.passes);
+    if (!hasAnyProgress) {
+        // progress.md가 없으면 확실히 첫 실행
+        if (!fs.existsSync(progressPath))
+            return true;
+        // progress.md가 있지만 내용이 초기 상태면 첫 실행
+        try {
+            const progressContent = fs.readFileSync(progressPath, 'utf-8');
+            // 실질적인 세션 로그가 없으면 첫 실행
+            if (!progressContent.includes('## Auto Session:'))
+                return true;
+        }
+        catch {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * PRD 파일 읽기 (있는 경우)
+ */
+function readPrdContent(baseDir) {
+    const prdPaths = [
+        path.join(baseDir, '.aiag', 'prd.md'),
+        path.join(baseDir, 'PRD.md'),
+        path.join(baseDir, 'prd.md'),
+        path.join(baseDir, 'docs', 'prd.md'),
+        path.join(baseDir, 'docs', 'PRD.md'),
+    ];
+    for (const prdPath of prdPaths) {
+        if (fs.existsSync(prdPath)) {
+            try {
+                return fs.readFileSync(prdPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Initializer 세션 실행 (SDK 사용)
+ * 첫 실행 시 프로젝트 초기화를 위해 호출
+ */
+async function runInitializerSession(baseDir, timeout, verbose) {
+    const projectName = path.basename(baseDir);
+    const featureList = readFeatureList(baseDir);
+    const prdContent = readPrdContent(baseDir);
+    const context = {
+        projectDir: baseDir,
+        projectName,
+        hasExistingFeatures: featureList !== null && featureList.features.length > 0,
+        featureCount: featureList?.features.length || 0,
+    };
+    const prompt = getInitializerPrompt(context, prdContent);
+    const verboseLog = (message) => {
+        if (verbose) {
+            console.log(colors.dim(`  [verbose] ${message}`));
+        }
+    };
+    verboseLog('Running Initializer Agent via SDK');
+    verboseLog(`PRD found: ${prdContent ? 'Yes' : 'No'}`);
+    // SDK의 runInitializer 함수 사용
+    const result = await runInitializer(prompt, {
+        workingDirectory: baseDir,
+        timeout,
+        securityConfig: SECURITY_PRESET_DEVELOPMENT,
+        onLog: verboseLog,
+        onProgress: (message) => {
+            if (verbose && message.type === 'assistant') {
+                const content = message.message?.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (block && typeof block === 'object' && 'type' in block && block.type === 'text' && 'text' in block) {
+                            process.stdout.write(block.text);
+                        }
+                    }
+                }
+            }
+        },
+    });
+    return { success: result.success, error: result.error };
+}
 //# sourceMappingURL=auto.js.map