@amsterdamdatalabs/enact-factory 0.1.1

package/dist/agents/pairPipeline.js

@@ -0,0 +1,934 @@
+// ============================================
+// EnactFactory - Pair Pipeline
+// Executor → Reviewer → Tester → Documenter pipeline
+// ============================================
+import { EventEmitter } from 'node:events';
+import { aggregateCosts, formatCost } from '../support/costTracker.js';
+import { broadcastEvent } from '../core/eventHub.js';
+import { getConfidenceAction, getConfidenceProfile, } from '../agents/agentPair.js';
+import * as agentPair from '../agents/agentPair.js';
+import { runGuards } from '../agents/pipelineGuards.js';
+import * as executorAgent from '../agents/executor.js';
+import * as reviewerAgent from '../agents/reviewer.js';
+import * as testerAgent from '../agents/tester.js';
+import { inferProviderFromModel } from '../support/chatBackend.js';
+const ADAPTER_NAMES = new Set(['claude', 'codex', 'responses', 'cursor', 'hermes', 'opencode']);
+function isAdapterName(v) {
+    return v !== undefined && ADAPTER_NAMES.has(v);
+}
+import * as documenterAgent from '../agents/documenter.js';
+import * as auditorAgent from '../agents/auditor.js';
+import * as skillDocumenterAgent from '../agents/skillDocumenter.js';
+import { createStuckDetector } from '../support/stuckDetector.js';
+/**
+ * Build a consistent workItem prefix for logging across all pipeline stages.
+ * Format: "ProjectName | INT-XXX | worktree/abc123" or "ProjectName | INT-XXX"
+ */
+export function buildWorkItemPrefix(workItem, projectPath) {
+    const parts = [];
+    const projectName = workItem.azdoProject?.name || projectPath.split('/').pop() || 'unknown';
+    parts.push(projectName);
+    if (workItem.workItemIdentifier) {
+        parts.push(workItem.workItemIdentifier);
+    }
+    else if (workItem.workItemId) {
+        parts.push(workItem.workItemId.slice(0, 8));
+    }
+    // Detect worktree path
+    const worktreeMatch = projectPath.match(/worktree\/([a-f0-9-]+)/);
+    if (worktreeMatch) {
+        parts.push(`worktree/${worktreeMatch[1].slice(0, 8)}`);
+    }
+    return parts.join(' | ');
+}
+// Pair Pipeline
+export class PairPipeline extends EventEmitter {
+    config;
+    stuckDetector;
+    jobProfiles;
+    constructor(config) {
+        super();
+        this.config = {
+            continueOnTestFail: false,
+            skipDocumenterIfNoChange: true,
+            maxIterations: 3,
+            ...config,
+        };
+        // Initialize stuck detector
+        this.stuckDetector = createStuckDetector({
+            sameErrorRepeat: 2,
+            revisionLoop: 4,
+        });
+        this.jobProfiles = config.jobProfiles ?? [];
+    }
+    getExecutorConfidenceProfile(context, stageModel) {
+        const executorModel = stageModel ?? this.getModelForRole('coder', context.workItem);
+        const adapterName = inferProviderFromModel(executorModel);
+        return getConfidenceProfile(adapterName ?? 'default');
+    }
+    matchesProfile(workItem, profile) {
+        const estimate = workItem.estimatedMinutes ?? 0;
+        if (profile.minMinutes != null && estimate < profile.minMinutes)
+            return false;
+        if (profile.maxMinutes != null && estimate > profile.maxMinutes)
+            return false;
+        if (profile.priority != null && workItem.priority !== profile.priority)
+            return false;
+        return true;
+    }
+    getProfileForWorkItem(workItem) {
+        if (!this.jobProfiles || this.jobProfiles.length === 0)
+            return undefined;
+        return this.jobProfiles.find((profile) => this.matchesProfile(workItem, profile));
+    }
+    getModelForRole(stage, workItem) {
+        const profile = this.getProfileForWorkItem(workItem);
+        return profile?.roles?.[stage] || this.config.stageConfigs?.[stage]?.model;
+    }
+    // ============================================
+    // Main Execution
+    // ============================================
+    /**
+     * Run pipeline
+     *
+     * 1 iteration = full pass through Executor → Reviewer → Tester
+     * On failure at any stage, returns to Executor (up to maxIterations)
+     */
+    async run(workItem, projectPath) {
+        const startTime = Date.now();
+        const stages = [];
+        const maxIterations = this.config.maxIterations ?? 3;
+        // Reset stuck detector (new pipeline run)
+        this.stuckDetector.reset();
+        // Create session
+        const session = agentPair.createPairSession({
+            workItemId: workItem.workItemIdentifier || workItem.workItemId || workItem.id,
+            workItemTitle: workItem.title,
+            workItemDescription: workItem.description || '',
+            projectPath,
+            maxAttempts: maxIterations,
+            models: {
+                coder: this.config.stageConfigs?.coder?.model,
+                critic: this.config.stageConfigs?.critic?.model,
+            },
+        });
+        const workItemPrefix = buildWorkItemPrefix(workItem, projectPath);
+        const context = {
+            workItem,
+            projectPath,
+            session,
+            config: this.config,
+            currentIteration: 0,
+            workItemPrefix,
+        };
+        try {
+            // Full iteration loop: Executor → Reviewer → Tester
+            const iterationResult = await this.runFullIterationLoop(context, stages);
+            if (!iterationResult.success) {
+                return this.buildResult(context, stages, startTime);
+            }
+            // Run Documenter after all stages pass
+            if (this.hasStage('documenter') && context.executorResult?.success) {
+                if (this.config.skipDocumenterIfNoChange &&
+                    (!context.executorResult.filesChanged || context.executorResult.filesChanged.length === 0)) {
+                    console.log(`[${context.workItemPrefix}] Skipping documenter: no files changed`);
+                }
+                else {
+                    const documenterResult = await this.runStage('documenter', context);
+                    stages.push(documenterResult);
+                    // Documenter failure does not cause overall failure
+                }
+            }
+            // Auditor (post-success, non-blocking)
+            if (this.hasStage('auditor') && context.executorResult?.success) {
+                const auditorFileThreshold = this.config.skipAuditorUnderFileCount ?? 3;
+                const auditorChangedFiles = context.executorResult.filesChanged || [];
+                if (auditorChangedFiles.length < auditorFileThreshold) {
+                    console.log(`[${context.workItemPrefix}] Skipping auditor: ${auditorChangedFiles.length} files changed (threshold: ${auditorFileThreshold})`);
+                }
+                else {
+                    const auditorResult = await this.runStage('auditor', context);
+                    stages.push(auditorResult);
+                    // Auditor failure does not affect overall success
+                }
+            }
+            // Skill Documenter (post-success, non-blocking)
+            if (this.hasStage('stage-documenter') && context.executorResult?.success) {
+                const sdResult = await this.runStage('stage-documenter', context);
+                stages.push(sdResult);
+                // Skill Documenter failure does not affect overall success
+            }
+            // Success
+            agentPair.updateSessionStatus(session.id, 'approved');
+            return this.buildResult(context, stages, startTime);
+        }
+        catch (error) {
+            console.error('[%s] Error:', context.workItemPrefix, error);
+            agentPair.updateSessionStatus(session.id, 'failed');
+            return {
+                success: false,
+                sessionId: session.id,
+                stages,
+                finalStatus: 'failed',
+                totalDuration: Date.now() - startTime,
+                iterations: context.currentIteration,
+                executorResult: context.executorResult,
+                reviewResult: context.reviewResult,
+                testerResult: context.testerResult,
+                documenterResult: context.documenterResult,
+                workItemContext: {
+                    workItemIdentifier: context.workItem.workItemIdentifier || context.workItem.workItemId,
+                    projectName: context.workItem.azdoProject?.name,
+                    projectPath: context.projectPath,
+                    workItemTitle: context.workItem.title,
+                },
+            };
+        }
+    }
+    // ============================================
+    // Stage Execution
+    // ============================================
+    /**
+     * Executor에 주입할 코드 컨텍스트 수집
+     * Draft 분석이 있으면 재사용, 없으면 직접 수집
+     */
+    async collectExecutorContext() {
+        try {
+            const wc = {};
+            const draft = this.config.draftAnalysis;
+            // Draft 분석 결과가 있으면 우선 사용 (중복 API 호출 방지)
+            if (draft) {
+                wc.draftAnalysis = {
+                    workItemType: draft.workItemType,
+                    intentSummary: draft.intentSummary,
+                    relevantFiles: draft.relevantFiles,
+                    suggestedApproach: draft.suggestedApproach,
+                    projectStats: draft.projectStats,
+                };
+                if (draft.registrySnapshot && draft.registrySnapshot.length > 0) {
+                    wc.registryBriefs = draft.registrySnapshot;
+                }
+            }
+            if (!wc.registryBriefs && !wc.draftAnalysis)
+                return undefined;
+            return wc;
+        }
+        catch (err) {
+            console.warn('[Pipeline] Executor context collection failed (non-blocking):', err);
+            return undefined;
+        }
+    }
+    /**
+     * Check if a stage is enabled
+     */
+    hasStage(stage) {
+        return this.config.stages.includes(stage);
+    }
+    /**
+     * Run a single stage
+     */
+    async runStage(stage, context, overrides) {
+        const startTime = Date.now();
+        const stageModel = overrides?.model ?? this.getModelForRole(stage, context.workItem);
+        // Priority 1: Explicit provider prefix in model (e.g. "codex:gpt-5.4")
+        let adapterName = inferProviderFromModel(stageModel);
+        // Priority 2: Explicit adapter configured for this role in the root config.toml
+        const roleConfig = this.config.stageConfigs?.[stage];
+        if (roleConfig?.adapter) {
+            adapterName = roleConfig.adapter;
+        }
+        const prefix = context.workItemPrefix;
+        console.log(`[${prefix}] Stage starting: ${stage} (model: ${stageModel || 'default'}, adapter: ${adapterName || 'default'})`);
+        this.emit('stage:start', { stage, context });
+        broadcastEvent({ type: 'pipeline:stage', data: { workItemId: context.workItem.id, stage, status: 'start', model: stageModel } });
+        if (this.config.verbose) {
+            this.emit('log', { line: `[verbose] Stage: ${stage} | model: ${stageModel ?? 'default'} | iteration: ${context.currentIteration}` });
+        }
+        try {
+            let result;
+            switch (stage) {
+                case 'coder': {
+                    agentPair.updateSessionStatus(context.session.id, 'working');
+                    const workItemId = context.workItem.id;
+                    const onLog = (line) => broadcastEvent({ type: 'log', data: { workItemId, stage: 'coder', line: `[${prefix}] ${line}` } });
+                    // Check if fresh context should be used (after N failures)
+                    const useFreshContext = agentPair.shouldUseFreshContext(context.session.id);
+                    if (useFreshContext) {
+                        console.log(`[${prefix}] Using fresh context for executor (retry with clean slate)`);
+                        agentPair.consumeFreshContext(context.session.id);
+                        onLog('🔄 Using fresh context (previous attempts failed)');
+                    }
+                    // 코드 컨텍스트 수집 (첫 시도 정확도 향상 목적)
+                    const executorContext = await this.collectExecutorContext();
+                    if (executorContext && this.config.verbose) {
+                        const briefCount = executorContext.registryBriefs?.length ?? 0;
+                        this.emit('log', { line: `[verbose] Executor context: ${briefCount} file briefs` });
+                    }
+                    result = await executorAgent.runExecutor({
+                        workItemTitle: context.workItem.title,
+                        workItemDescription: context.workItem.description || '',
+                        projectPath: context.projectPath,
+                        previousFeedback: useFreshContext
+                            ? undefined // Fresh context: no previous feedback
+                            : (context.reviewResult
+                                ? reviewerAgent.buildRevisionPrompt(context.reviewResult)
+                                : undefined),
+                        timeoutMs: this.config.stageConfigs?.coder?.timeoutMs ?? 0,
+                        model: stageModel,
+                        maxTurns: this.config.stageConfigs?.coder?.maxTurns,
+                        adapterName: adapterName,
+                        workItemIdentifier: context.workItem.workItemIdentifier || context.workItem.workItemId,
+                        projectName: context.workItem.azdoProject?.name,
+                        onLog,
+                        processContext: { workItemId: context.workItem.id, stage: 'coder' },
+                        executorContext,
+                    });
+                    agentPair.saveExecutorResult(context.session.id, result);
+                    context.executorResult = result;
+                    // Verbose: emit detailed executor result info
+                    if (this.config.verbose) {
+                        const wr = result;
+                        if (wr.filesChanged?.length) {
+                            this.emit('log', { line: `[verbose] Files changed: ${wr.filesChanged.join(', ')}` });
+                        }
+                        if (wr.commands?.length) {
+                            this.emit('log', { line: `[verbose] Commands executed: ${wr.commands.join('; ')}` });
+                        }
+                        if (wr.confidencePercent != null) {
+                            this.emit('log', { line: `[verbose] Executor confidence: ${wr.confidencePercent}%` });
+                        }
+                        if (wr.haltReason) {
+                            this.emit('log', { line: `[verbose] Executor halt reason: ${wr.haltReason}` });
+                        }
+                    }
+                    // Track confidence and check for degradation
+                    const attempt = context.session.executor.attempts;
+                    agentPair.updateConfidenceTracker(context.session.id, result, attempt);
+                    break;
+                }
+                case 'critic':
+                    result = await this.runReviewerStage(context, {
+                        executorResult: context.executorResult,
+                        stageModel,
+                        adapterName,
+                        criticOverrides: overrides,
+                    });
+                    context.reviewResult = result;
+                    agentPair.saveReviewerResult(context.session.id, result);
+                    break;
+                case 'tester':
+                    if (!context.executorResult) {
+                        throw new Error('Executor result required for tester');
+                    }
+                    result = await testerAgent.runTester({
+                        workItemTitle: context.workItem.title,
+                        workItemDescription: context.workItem.description || '',
+                        executorResult: context.executorResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.stageConfigs?.tester?.timeoutMs ?? 0,
+                        model: stageModel,
+                        maxTurns: this.config.stageConfigs?.tester?.maxTurns,
+                        adapterName: adapterName,
+                    });
+                    context.testerResult = result;
+                    // Verbose: emit tester details
+                    if (this.config.verbose) {
+                        const tr = result;
+                        this.emit('log', { line: `[verbose] Tests passed: ${tr.testsPassed}, failed: ${tr.testsFailed}${tr.coverage != null ? `, coverage: ${tr.coverage}%` : ''}` });
+                    }
+                    break;
+                case 'documenter':
+                    if (!context.executorResult) {
+                        throw new Error('Executor result required for documenter');
+                    }
+                    result = await documenterAgent.runDocumenter({
+                        workItemTitle: context.workItem.title,
+                        workItemDescription: context.workItem.description || '',
+                        executorResult: context.executorResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.stageConfigs?.documenter?.timeoutMs ?? 0,
+                        model: this.config.stageConfigs?.documenter?.model,
+                        maxTurns: this.config.stageConfigs?.documenter?.maxTurns,
+                        adapterName: this.config.stageConfigs?.documenter?.adapter,
+                    });
+                    context.documenterResult = result;
+                    break;
+                case 'auditor':
+                    if (!context.executorResult) {
+                        throw new Error('Executor result required for auditor');
+                    }
+                    result = await auditorAgent.runAuditor({
+                        workItemTitle: context.workItem.title,
+                        workItemDescription: context.workItem.description || '',
+                        executorResult: context.executorResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.stageConfigs?.auditor?.timeoutMs ?? 0,
+                        model: this.config.stageConfigs?.auditor?.model,
+                        maxTurns: this.config.stageConfigs?.auditor?.maxTurns,
+                        adapterName: this.config.stageConfigs?.auditor?.adapter,
+                    });
+                    context.auditorResult = result;
+                    break;
+                case 'stage-documenter':
+                    if (!context.executorResult) {
+                        throw new Error('Executor result required for stage-documenter');
+                    }
+                    result = await skillDocumenterAgent.runSkillDocumenter({
+                        workItemTitle: context.workItem.title,
+                        workItemDescription: context.workItem.description || '',
+                        executorResult: context.executorResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.stageConfigs?.['stage-documenter']?.timeoutMs ?? 0,
+                        model: this.config.stageConfigs?.['stage-documenter']?.model,
+                        maxTurns: this.config.stageConfigs?.['stage-documenter']?.maxTurns,
+                        adapterName: this.config.stageConfigs?.['stage-documenter']?.adapter,
+                    });
+                    context.skillDocumenterResult = result;
+                    break;
+                default:
+                    throw new Error(`Unknown stage: ${stage}`);
+            }
+            const completedAt = Date.now();
+            const stageResult = {
+                stage,
+                success: this.isStageSuccess(stage, result),
+                result,
+                duration: completedAt - startTime,
+                startedAt: startTime,
+                completedAt,
+            };
+            console.log(`[${prefix}] ${stage} completed (${(stageResult.duration / 1000).toFixed(1)}s)`);
+            this.emit('stage:complete', { stage, result: stageResult, context });
+            const costInfo = result.costInfo;
+            if (this.config.verbose) {
+                this.emit('log', { line: `[verbose] Stage ${stage} completed in ${(stageResult.duration / 1000).toFixed(1)}s${costInfo ? ` | cost: $${costInfo.costUsd.toFixed(4)} (${costInfo.inputTokens}in/${costInfo.outputTokens}out)` : ''}` });
+            }
+            broadcastEvent({ type: 'pipeline:stage', data: {
+                    workItemId: context.workItem.id, stage, status: 'complete',
+                    model: costInfo?.model,
+                    inputTokens: costInfo?.inputTokens,
+                    outputTokens: costInfo?.outputTokens,
+                    costUsd: costInfo?.costUsd,
+                } });
+            return stageResult;
+        }
+        catch (error) {
+            const completedAt = Date.now();
+            const stageResult = {
+                stage,
+                success: false,
+                result: {
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+                duration: completedAt - startTime,
+                startedAt: startTime,
+                completedAt,
+            };
+            console.log(`[${prefix}] ${stage} failed (${(stageResult.duration / 1000).toFixed(1)}s)`);
+            this.emit('stage:fail', { stage, result: stageResult, context, error });
+            broadcastEvent({ type: 'pipeline:stage', data: { workItemId: context.workItem.id, stage, status: 'fail' } });
+            return stageResult;
+        }
+    }
+    async runReviewerStage(context, options) {
+        const reviewerMaxTurns = this.config.stageConfigs?.critic?.maxTurns;
+        const effectiveReviewerMaxTurns = context.executorResult?.confidencePercent && context.executorResult.confidencePercent > 90
+            ? Math.min(reviewerMaxTurns ?? 10, 5)
+            : reviewerMaxTurns;
+        const timeoutMs = this.config.stageConfigs?.critic?.timeoutMs ?? 0;
+        const consensusConfig = this.config.stageConfigs?.critic?.consensus;
+        const consensusEnabled = consensusConfig?.enabled === true;
+        agentPair.updateSessionStatus(context.session.id, 'reviewing');
+        if (!options.executorResult) {
+            throw new Error('Executor result required for reviewer');
+        }
+        const runSingleReview = async (model, adapter, stageLabel = 'critic') => {
+            const resolvedModel = model ?? options.stageModel;
+            const resolvedAdapterStr = adapter ?? options.adapterName;
+            const resolvedAdapter = isAdapterName(resolvedAdapterStr) ? resolvedAdapterStr : undefined;
+            const result = await reviewerAgent.runReviewer({
+                workItemTitle: context.workItem.title,
+                workItemDescription: context.workItem.description || '',
+                executorResult: options.executorResult,
+                projectPath: context.projectPath,
+                timeoutMs,
+                model: resolvedModel,
+                maxTurns: effectiveReviewerMaxTurns,
+                adapterName: resolvedAdapter,
+                processContext: { workItemId: context.workItem.id, stage: stageLabel },
+            });
+            if (this.config.verbose) {
+                this.emit('log', { line: `[verbose] ${stageLabel} decision: ${result.decision}` });
+                if (result.feedback) {
+                    const lines = result.feedback.split('\n').slice(0, 5);
+                    for (const line of lines) {
+                        this.emit('log', { line: `[verbose]   ${line}` });
+                    }
+                }
+            }
+            return result;
+        };
+        const primaryModel = options.criticOverrides?.model ?? options.stageModel;
+        const primaryResult = await runSingleReview(primaryModel, options.adapterName, 'critic');
+        if (!consensusEnabled) {
+            return primaryResult;
+        }
+        const extraModels = (consensusConfig.models || [])
+            .map((m) => m?.trim())
+            .filter((m) => !!m && m.length > 0);
+        const uniqueExtraModels = Array.from(new Set(extraModels))
+            .filter((m) => m !== primaryModel);
+        if (uniqueExtraModels.length === 0) {
+            return primaryResult;
+        }
+        const extraResults = [];
+        for (let i = 0; i < uniqueExtraModels.length; i++) {
+            const model = uniqueExtraModels[i];
+            const adapter = inferProviderFromModel(model) ?? options.adapterName;
+            const extraResult = await runSingleReview(model, adapter, `reviewer-consensus-${i + 1}`);
+            extraResults.push(extraResult);
+        }
+        const allResults = [primaryResult, ...extraResults];
+        const totalReviews = allResults.length;
+        const requiredApprovals = Math.min(consensusConfig.requiredApprovals ?? totalReviews, totalReviews);
+        const approvalCount = allResults.filter((entry) => entry.decision === 'approve').length;
+        const rejectCount = allResults.filter((entry) => entry.decision === 'reject').length;
+        const reviseCount = allResults.filter((entry) => entry.decision === 'revise').length;
+        if (rejectCount > 0) {
+            const mergedWorkItems = allResults.flatMap((entry, idx) => {
+                const workItems = entry.workItems || [];
+                return workItems.length > 0 ? workItems : [`reviewer-${idx + 1}: ${entry.decision}`];
+            });
+            return {
+                decision: 'reject',
+                feedback: this.mergeReviewFeedback('Reviewer consensus decision', allResults),
+                workItems: mergedWorkItems.slice(0, 10),
+                suggestions: ['Resolve all reviewer blocking feedback before retrying'],
+            };
+        }
+        if (approvalCount < requiredApprovals || reviseCount > 0) {
+            const mergedWorkItems = allResults.flatMap((entry, idx) => {
+                const workItems = entry.workItems || [];
+                return workItems.length > 0 ? workItems : [`reviewer-${idx + 1}: ${entry.decision}`];
+            });
+            return {
+                decision: 'revise',
+                feedback: this.mergeReviewFeedback('Reviewer consensus decision', allResults),
+                workItems: mergedWorkItems.slice(0, 10),
+                suggestions: ['Incorporate the remaining reviewer feedback and re-run executor'],
+            };
+        }
+        return {
+            decision: 'approve',
+            feedback: this.mergeReviewFeedback('Reviewer consensus decision', allResults),
+            workItems: primaryResult.workItems,
+            suggestions: primaryResult.suggestions,
+            costInfo: primaryResult.costInfo || extraResults.find((entry) => entry.costInfo)?.costInfo,
+        };
+    }
+    mergeReviewFeedback(title, reviewResults) {
+        const parts = [title];
+        for (let i = 0; i < reviewResults.length; i++) {
+            const result = reviewResults[i];
+            const label = i === 0 ? `primary-${i + 1}` : `consensus-${i}`;
+            parts.push(`- ${label}: ${result.decision.toUpperCase()}`);
+            if (result.feedback) {
+                parts.push(result.feedback);
+            }
+        }
+        return parts.join('\n');
+    }
+    /**
+     * Determine stage success
+     */
+    isStageSuccess(stage, result) {
+        switch (stage) {
+            case 'coder':
+                return result.success;
+            case 'critic':
+                return result.decision === 'approve';
+            case 'tester':
+                return result.success;
+            case 'documenter':
+                return result.success;
+            case 'auditor':
+                return result.success;
+            case 'stage-documenter':
+                return result.success;
+            default:
+                return false;
+        }
+    }
+    // ============================================
+    // Full Iteration Loop
+    // ============================================
+    /**
+     * Full iteration loop
+     *
+     * 1 iteration = full pass through Executor → Reviewer → Tester
+     * On failure (revise) at any stage, restart from Executor in next iteration
+     * reject = immediate termination
+     */
+    async runFullIterationLoop(context, stages) {
+        const maxIterations = this.config.maxIterations ?? 3;
+        const hasCoder = this.hasStage('coder');
+        const hasCritic = this.hasStage('critic');
+        const hasTester = this.hasStage('tester');
+        // No point without a executor
+        if (!hasCoder) {
+            console.log(`[${context.workItemPrefix}] No executor stage configured`);
+            return { success: false };
+        }
+        while (context.currentIteration < maxIterations) {
+            context.currentIteration++;
+            // Stuck detection check (before iteration starts)
+            const stuckCheck = this.stuckDetector.check();
+            if (stuckCheck.isStuck) {
+                console.error(`[${context.workItemPrefix}] STUCK DETECTED: ${stuckCheck.reason}`);
+                console.error(`[${context.workItemPrefix}] Suggestion: ${stuckCheck.suggestion}`);
+                this.emit('stuck', {
+                    reason: stuckCheck.reason,
+                    suggestion: stuckCheck.suggestion,
+                    context,
+                });
+                agentPair.updateSessionStatus(context.session.id, 'failed');
+                return { success: false };
+            }
+            this.emit('iteration:start', {
+                iteration: context.currentIteration,
+                maxIterations,
+                context,
+            });
+            broadcastEvent({ type: 'pipeline:iteration', data: { workItemId: context.workItem.id, iteration: context.currentIteration } });
+            console.log(`[${context.workItemPrefix}] Iteration ${context.currentIteration}/${maxIterations}`);
+            // ========== EXECUTOR (with escalation) ==========
+            const coderCfg = this.config.stageConfigs?.coder;
+            const escalateThreshold = coderCfg?.escalateAfterIteration ?? 3;
+            const escalateModel = coderCfg?.escalateModel;
+            const shouldEscalate = context.currentIteration >= escalateThreshold && !!escalateModel;
+            const baseExecutorModel = this.getModelForRole('coder', context.workItem);
+            const executorOverrides = shouldEscalate
+                ? { model: escalateModel }
+                : (baseExecutorModel ? { model: baseExecutorModel } : undefined);
+            if (shouldEscalate && escalateModel) {
+                console.log(`[${context.workItemPrefix}] Escalating executor model → ${escalateModel} (iteration ${context.currentIteration})`);
+                broadcastEvent({ type: 'pipeline:escalation', data: {
+                        workItemId: context.workItem.id,
+                        iteration: context.currentIteration,
+                        fromModel: coderCfg?.model,
+                        toModel: escalateModel,
+                    } });
+            }
+            agentPair.updateSessionStatus(context.session.id, 'working');
+            const executorResult = await this.runStage('coder', context, executorOverrides);
+            stages.push(executorResult);
+            // Record Executor result in stuck detector
+            this.stuckDetector.addEntry({
+                stage: 'coder',
+                success: executorResult.success,
+                output: executorResult.result.summary,
+                error: executorResult.result.error,
+                timestamp: Date.now(),
+            });
+            if (!executorResult.success) {
+                console.log(`[${context.workItemPrefix}] Executor failed, retrying...`);
+                agentPair.trackFailure(context.session.id); // Track for fresh context decision
+                this.emit('iteration:fail', {
+                    iteration: context.currentIteration,
+                    stage: 'coder',
+                    context,
+                });
+                continue; // Next iteration
+            }
+            // ========== PIPELINE GUARDS (post-executor, pre-reviewer) ==========
+            if (this.config.guards && context.executorResult) {
+                console.log(`[${context.workItemPrefix}] Running pipeline guards...`);
+                const guardsResult = await runGuards(context.executorResult, context.projectPath, this.config.guards);
+                context.guardsResult = guardsResult;
+                if (!guardsResult.allPassed) {
+                    // Blocking guard failed → inject revise, skip reviewer
+                    console.log(`[${context.workItemPrefix}] Blocking guard failed: ${guardsResult.combinedWorkItems.join('; ')}`);
+                    context.reviewResult = {
+                        decision: 'revise',
+                        feedback: `Pipeline guard failed: ${guardsResult.combinedWorkItems.join('; ')}`,
+                        workItems: guardsResult.combinedWorkItems,
+                        suggestions: ['Fix the workItems flagged by quality guards'],
+                    };
+                    agentPair.trackFailure(context.session.id);
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'coder',
+                        context,
+                    });
+                    agentPair.updateSessionStatus(context.session.id, 'revising');
+                    continue;
+                }
+                // Log non-blocking guard warnings
+                const warnings = guardsResult.results.filter(r => !r.passed && !r.blocking);
+                if (warnings.length > 0) {
+                    console.log(`[${context.workItemPrefix}] Guard warnings: ${warnings.map(w => w.guard).join(', ')}`);
+                    this.emit('log', {
+                        line: `⚠️ Guard warnings: ${warnings.flatMap(w => w.workItems).join('; ')}`,
+                    });
+                }
+            }
+            // ========== HALT CHECK (confidence too low) ==========
+            if (context.executorResult) {
+                const confidence = agentPair.calculateConfidence(context.executorResult);
+                const stageModel = executorOverrides?.model;
+                const confidenceProfile = this.getExecutorConfidenceProfile(context, stageModel);
+                const confidenceAction = getConfidenceAction(confidence, confidenceProfile);
+                if (confidenceAction === 'halt') {
+                    const haltReason = context.executorResult.haltReason
+                        || `Low confidence: ${confidence}%`;
+                    console.warn(`[${context.workItemPrefix}] HALT triggered: confidence=${confidence}%, reason=${haltReason}`);
+                    this.emit('halt', {
+                        confidence,
+                        haltReason,
+                        sessionId: context.session.id,
+                        iteration: context.currentIteration,
+                        context,
+                    });
+                    // Inject revise to retry
+                    context.reviewResult = {
+                        decision: 'revise',
+                        feedback: `[HALT] Confidence too low (${confidence}%). ${haltReason}`,
+                        workItems: [haltReason],
+                        suggestions: ['Review workItem requirements', 'Provide additional context', 'Break into sub-workItems'],
+                    };
+                    agentPair.trackFailure(context.session.id);
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'coder',
+                        context,
+                    });
+                    agentPair.updateSessionStatus(context.session.id, 'revising');
+                    continue;
+                }
+                if (confidenceAction === 'cautious') {
+                    const summary = `⚠️ Cautious confidence: ${confidence}% — continuing with heightened review awareness`;
+                    console.warn(`[${context.workItemPrefix}] ${summary}`);
+                    this.emit('log', { line: summary });
+                }
+                if (context.config.verbose) {
+                    this.emit('log', { line: `[verbose] Executor confidence action: ${confidenceAction}` });
+                }
+            }
+            // ========== REVIEWER ==========
+            if (hasCritic) {
+                agentPair.updateSessionStatus(context.session.id, 'reviewing');
+                // Reviewer escalation: 로컬 모델이 N회 이상 REVISE → 상위 모델로 spot check
+                const criticCfg = this.config.stageConfigs?.critic;
+                const criticEscalateModel = criticCfg?.escalateModel;
+                const criticEscalateThreshold = criticCfg?.escalateAfterIteration ?? 3;
+                const shouldEscalateCritic = context.currentIteration >= criticEscalateThreshold && !!criticEscalateModel;
+                const criticOverrides = shouldEscalateCritic
+                    ? { model: criticEscalateModel }
+                    : undefined;
+                if (shouldEscalateCritic && criticEscalateModel) {
+                    console.log(`[${context.workItemPrefix}] Critic escalation → ${criticEscalateModel} (iteration ${context.currentIteration})`);
+                    this.emit('log', {
+                        line: `Critic spot check: escalating to ${criticEscalateModel}`,
+                    });
+                }
+                const criticResult = await this.runStage('critic', context, criticOverrides);
+                stages.push(criticResult);
+                const decision = criticResult.result.decision;
+                // Record Reviewer result in stuck detector
+                this.stuckDetector.addEntry({
+                    stage: 'critic',
+                    success: criticResult.success,
+                    decision: decision,
+                    output: criticResult.result.feedback,
+                    timestamp: Date.now(),
+                });
+                if (decision === 'reject') {
+                    // reject = terminate immediately
+                    console.log(`[${context.workItemPrefix}] Reviewer rejected`);
+                    agentPair.updateSessionStatus(context.session.id, 'rejected');
+                    return { success: false };
+                }
+                if (decision === 'revise') {
+                    // revise = next iteration
+                    console.log(`[${context.workItemPrefix}] Reviewer requested revision`);
+                    agentPair.trackFailure(context.session.id); // Track for fresh context decision
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'critic',
+                        context,
+                    });
+                    agentPair.updateSessionStatus(context.session.id, 'revising');
+                    continue;
+                }
+                // approve → proceed to Tester
+                agentPair.resetFailureStreak(context.session.id); // Reset on approval
+            }
+            // ========== TESTER ==========
+            if (hasTester) {
+                // Skip tester if no code files changed (configurable, default true)
+                const skipIfNoCode = this.config.skipTesterIfNoCodeChange ?? true;
+                const codeExtensions = /\.(ts|tsx|js|jsx|py|rs|go|java|rb|c|cpp|h|hpp)$/;
+                const changedFiles = context.executorResult?.filesChanged || [];
+                const hasCodeChange = changedFiles.some(f => codeExtensions.test(f));
+                if (skipIfNoCode && !hasCodeChange) {
+                    console.log(`[${context.workItemPrefix}] Skipping tester: no code files changed (${changedFiles.length} files: ${changedFiles.join(', ') || 'none'})`);
+                }
+                else {
+                    const testerResult = await this.runStage('tester', context);
+                    stages.push(testerResult);
+                    if (!testerResult.success && !this.config.continueOnTestFail) {
+                        // Test failed → set feedback then next iteration
+                        console.log(`[${context.workItemPrefix}] Tester failed, retrying...`);
+                        agentPair.trackFailure(context.session.id); // Track for fresh context decision
+                        if (context.testerResult) {
+                            context.reviewResult = {
+                                decision: 'revise',
+                                feedback: testerAgent.buildTestFixPrompt(context.testerResult),
+                                workItems: context.testerResult.failedTests,
+                                suggestions: context.testerResult.suggestions,
+                            };
+                        }
+                        this.emit('iteration:fail', {
+                            iteration: context.currentIteration,
+                            stage: 'tester',
+                            context,
+                        });
+                        agentPair.updateSessionStatus(context.session.id, 'revising');
+                        continue;
+                    }
+                } // end else (has code change)
+            }
+            // ========== ALL PASSED ==========
+            console.log(`[${context.workItemPrefix}] Iteration ${context.currentIteration} completed successfully`);
+            this.emit('iteration:complete', {
+                iteration: context.currentIteration,
+                context,
+            });
+            return { success: true };
+        }
+        // maxIterations exceeded
+        console.log(`[${context.workItemPrefix}] Max iterations (${maxIterations}) exceeded`);
+        agentPair.updateSessionStatus(context.session.id, 'failed');
+        return { success: false };
+    }
+    // ============================================
+    // Result Building
+    // ============================================
+    /**
+     * Build pipeline result
+     */
+    buildResult(context, stages, startTime) {
+        // Use context.session directly — do NOT re-fetch from store.
+        // updateSessionStatus('approved') archives the session (deletes from Map),
+        // so getPairSession() would return undefined → finalStatus = 'failed'.
+        const session = context.session;
+        const finalStatus = session.status || 'failed';
+        const success = finalStatus === 'approved';
+        // Aggregate costs from all stages
+        const stageCosts = [];
+        if (context.executorResult?.costInfo)
+            stageCosts.push(context.executorResult.costInfo);
+        if (context.reviewResult?.costInfo)
+            stageCosts.push(context.reviewResult.costInfo);
+        if (context.testerResult?.costInfo)
+            stageCosts.push(context.testerResult.costInfo);
+        if (context.documenterResult?.costInfo)
+            stageCosts.push(context.documenterResult.costInfo);
+        if (context.auditorResult?.costInfo)
+            stageCosts.push(context.auditorResult.costInfo);
+        if (context.skillDocumenterResult?.costInfo)
+            stageCosts.push(context.skillDocumenterResult.costInfo);
+        const totalCost = stageCosts.length > 0 ? aggregateCosts(stageCosts) : undefined;
+        if (totalCost) {
+            console.log(`[${context.workItemPrefix}] Total cost: ${formatCost(totalCost)}`);
+            broadcastEvent({ type: 'workItem:cost', data: { workItemId: context.workItem.id, cost: totalCost } });
+        }
+        const result = {
+            success,
+            sessionId: context.session.id,
+            stages,
+            finalStatus,
+            totalDuration: Date.now() - startTime,
+            iterations: context.currentIteration,
+            executorResult: context.executorResult,
+            reviewResult: context.reviewResult,
+            testerResult: context.testerResult,
+            documenterResult: context.documenterResult,
+            auditorResult: context.auditorResult,
+            skillDocumenterResult: context.skillDocumenterResult,
+            workItemContext: {
+                workItemIdentifier: context.workItem.workItemIdentifier || context.workItem.workItemId,
+                projectName: context.workItem.azdoProject?.name,
+                projectPath: context.projectPath,
+                workItemTitle: context.workItem.title,
+            },
+            totalCost,
+        };
+        if (success) {
+            this.emit('pipeline:complete', result);
+        }
+        else {
+            this.emit('pipeline:fail', result);
+        }
+        return result;
+    }
+}
+// Factory Functions
+/**
+ * Create default pipeline (Executor + Reviewer)
+ */
+export function createDefaultPipeline(maxIterations = 3) {
+    return new PairPipeline({
+        stages: ['coder', 'critic'],
+        maxIterations,
+    });
+}
+/**
+ * Create full pipeline (Executor + Reviewer + Tester + Documenter)
+ */
+export function createFullPipeline(config) {
+    return new PairPipeline({
+        stages: ['coder', 'critic', 'tester', 'documenter'],
+        maxIterations: 3,
+        continueOnTestFail: false,
+        skipDocumenterIfNoChange: true,
+        ...config,
+    });
+}
+/**
+ * Create pipeline from configuration
+ */
+export function createPipelineFromConfig(stageConfigs, maxIterations = 3, guards, jobProfiles, draftAnalysis) {
+    const stages = [];
+    if (stageConfigs?.coder?.enabled !== false) {
+        stages.push('coder');
+    }
+    if (stageConfigs?.critic?.enabled !== false) {
+        stages.push('critic');
+    }
+    if (stageConfigs?.tester?.enabled) {
+        stages.push('tester');
+    }
+    if (stageConfigs?.documenter?.enabled) {
+        stages.push('documenter');
+    }
+    if (stageConfigs?.auditor?.enabled) {
+        stages.push('auditor');
+    }
+    if (stageConfigs?.['stage-documenter']?.enabled) {
+        stages.push('stage-documenter');
+    }
+    return new PairPipeline({
+        stages,
+        maxIterations,
+        stageConfigs,
+        guards,
+        jobProfiles,
+        draftAnalysis,
+    });
+}
+// Helpers
+// Re-export formatting functions (extracted to pipelineFormat.ts)
+export { formatPipelineResult, formatPipelineResultEmbed } from '../agents/pipelineFormat.js';
+//# sourceMappingURL=pairPipeline.js.map