@intrect/openswarm 0.2.0

package/dist/agents/pairPipeline.js

@@ -0,0 +1,793 @@
+// ============================================
+// OpenSwarm - Pair Pipeline
+// Worker → Reviewer → Tester → Documenter pipeline
+// ============================================
+import { EventEmitter } from 'node:events';
+import { aggregateCosts, formatCost } from '../support/costTracker.js';
+import { broadcastEvent } from '../core/eventHub.js';
+import { CONFIDENCE_THRESHOLDS } from './agentPair.js';
+import * as agentPair from './agentPair.js';
+import { runGuards } from './pipelineGuards.js';
+import { hasRepoSnapshot, scanAndCache } from '../knowledge/index.js';
+import * as workerAgent from './worker.js';
+import * as reviewerAgent from './reviewer.js';
+import * as testerAgent from './tester.js';
+import * as documenterAgent from './documenter.js';
+import * as auditorAgent from './auditor.js';
+import * as skillDocumenterAgent from './skillDocumenter.js';
+import { createStuckDetector } from '../support/stuckDetector.js';
+/**
+ * Build a consistent task prefix for logging across all pipeline stages.
+ * Format: "ProjectName | INT-XXX | worktree/abc123" or "ProjectName | INT-XXX"
+ */
+export function buildTaskPrefix(task, projectPath) {
+    const parts = [];
+    const projectName = task.linearProject?.name || projectPath.split('/').pop() || 'unknown';
+    parts.push(projectName);
+    if (task.issueIdentifier) {
+        parts.push(task.issueIdentifier);
+    }
+    else if (task.issueId) {
+        parts.push(task.issueId.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 ?? [];
+    }
+    matchesProfile(task, profile) {
+        const estimate = task.estimatedMinutes ?? 0;
+        if (profile.minMinutes != null && estimate < profile.minMinutes)
+            return false;
+        if (profile.maxMinutes != null && estimate > profile.maxMinutes)
+            return false;
+        if (profile.priority != null && task.priority !== profile.priority)
+            return false;
+        return true;
+    }
+    getProfileForTask(task) {
+        if (!this.jobProfiles || this.jobProfiles.length === 0)
+            return undefined;
+        return this.jobProfiles.find((profile) => this.matchesProfile(task, profile));
+    }
+    getModelForRole(stage, task) {
+        const profile = this.getProfileForTask(task);
+        return profile?.roles?.[stage] || this.config.roles?.[stage]?.model;
+    }
+    // ============================================
+    // Main Execution
+    // ============================================
+    /**
+     * Run pipeline
+     *
+     * 1 iteration = full pass through Worker → Reviewer → Tester
+     * On failure at any stage, returns to Worker (up to maxIterations)
+     */
+    async run(task, projectPath) {
+        const startTime = Date.now();
+        const stages = [];
+        const maxIterations = this.config.maxIterations ?? 3;
+        // Reset stuck detector (new pipeline run)
+        this.stuckDetector.reset();
+        // Ensure repo graph snapshot exists (first-time scan if needed)
+        if (!hasRepoSnapshot(projectPath)) {
+            console.log(`[Pipeline] No repo snapshot found, scanning ${projectPath}...`);
+            try {
+                await scanAndCache(projectPath);
+            }
+            catch (e) {
+                console.warn(`[Pipeline] Repo scan failed (non-blocking):`, e);
+            }
+        }
+        // Create session
+        const session = agentPair.createPairSession({
+            taskId: task.issueIdentifier || task.issueId || task.id,
+            taskTitle: task.title,
+            taskDescription: task.description || '',
+            projectPath,
+            maxAttempts: maxIterations,
+            models: {
+                worker: this.config.roles?.worker?.model,
+                reviewer: this.config.roles?.reviewer?.model,
+            },
+        });
+        const taskPrefix = buildTaskPrefix(task, projectPath);
+        const context = {
+            task,
+            projectPath,
+            session,
+            config: this.config,
+            currentIteration: 0,
+            taskPrefix,
+        };
+        try {
+            // Full iteration loop: Worker → 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.workerResult?.success) {
+                if (this.config.skipDocumenterIfNoChange &&
+                    (!context.workerResult.filesChanged || context.workerResult.filesChanged.length === 0)) {
+                    console.log(`[${context.taskPrefix}] 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.workerResult?.success) {
+                const auditorFileThreshold = this.config.skipAuditorUnderFileCount ?? 3;
+                const auditorChangedFiles = context.workerResult.filesChanged || [];
+                if (auditorChangedFiles.length < auditorFileThreshold) {
+                    console.log(`[${context.taskPrefix}] 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('skill-documenter') && context.workerResult?.success) {
+                const sdResult = await this.runStage('skill-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(`[${context.taskPrefix}] Error:`, error);
+            agentPair.updateSessionStatus(session.id, 'failed');
+            return {
+                success: false,
+                sessionId: session.id,
+                stages,
+                finalStatus: 'failed',
+                totalDuration: Date.now() - startTime,
+                iterations: context.currentIteration,
+                workerResult: context.workerResult,
+                reviewResult: context.reviewResult,
+                testerResult: context.testerResult,
+                documenterResult: context.documenterResult,
+                taskContext: {
+                    issueIdentifier: context.task.issueIdentifier || context.task.issueId,
+                    projectName: context.task.linearProject?.name,
+                    projectPath: context.projectPath,
+                    taskTitle: context.task.title,
+                },
+            };
+        }
+    }
+    // ============================================
+    // Stage Execution
+    // ============================================
+    /**
+     * 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.task);
+        const prefix = context.taskPrefix;
+        console.log(`[${prefix}] Stage starting: ${stage}`);
+        this.emit('stage:start', { stage, context });
+        broadcastEvent({ type: 'pipeline:stage', data: { taskId: context.task.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 'worker': {
+                    agentPair.updateSessionStatus(context.session.id, 'working');
+                    const taskId = context.task.id;
+                    const onLog = (line) => broadcastEvent({ type: 'log', data: { taskId, stage: 'worker', 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 worker (retry with clean slate)`);
+                        agentPair.consumeFreshContext(context.session.id);
+                        onLog('🔄 Using fresh context (previous attempts failed)');
+                    }
+                    result = await workerAgent.runWorker({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        projectPath: context.projectPath,
+                        previousFeedback: useFreshContext
+                            ? undefined // Fresh context: no previous feedback
+                            : (context.reviewResult
+                                ? reviewerAgent.buildRevisionPrompt(context.reviewResult)
+                                : undefined),
+                        timeoutMs: this.config.roles?.worker?.timeoutMs ?? 0,
+                        model: overrides?.model ?? this.config.roles?.worker?.model,
+                        maxTurns: this.config.roles?.worker?.maxTurns,
+                        adapterName: this.config.roles?.worker?.adapter,
+                        issueIdentifier: context.task.issueIdentifier || context.task.issueId,
+                        projectName: context.task.linearProject?.name,
+                        onLog,
+                        processContext: { taskId: context.task.id, stage: 'worker' },
+                    });
+                    agentPair.saveWorkerResult(context.session.id, result);
+                    context.workerResult = result;
+                    // Verbose: emit detailed worker 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] Worker confidence: ${wr.confidencePercent}%` });
+                        }
+                        if (wr.haltReason) {
+                            this.emit('log', { line: `[verbose] Worker halt reason: ${wr.haltReason}` });
+                        }
+                    }
+                    // Track confidence and check for degradation
+                    const attempt = context.session.worker.attempts;
+                    agentPair.updateConfidenceTracker(context.session.id, result, attempt);
+                    // Check if confidence intervention is needed
+                    if (agentPair.needsConfidenceIntervention(context.session.id)) {
+                        console.warn(`[${prefix}] Confidence intervention needed - early review triggered`);
+                        const summary = agentPair.getConfidenceSummary(context.session.id);
+                        this.emit('log', { line: `⚠️ Low confidence detected: ${summary}` });
+                        // Continue to review, but reviewer should be aware of low confidence
+                    }
+                    break;
+                }
+                case 'reviewer':
+                    agentPair.updateSessionStatus(context.session.id, 'reviewing');
+                    if (!context.workerResult) {
+                        throw new Error('Worker result required for reviewer');
+                    }
+                    // Pre-check disabled - Haiku format compliance issues causing false rejections
+                    // Proceed directly to full Sonnet review for reliability
+                    // Reduce review depth when worker confidence is very high
+                    let reviewerMaxTurns = this.config.roles?.reviewer?.maxTurns;
+                    if (context.workerResult?.confidencePercent && context.workerResult.confidencePercent > 90) {
+                        const cappedTurns = Math.min(reviewerMaxTurns ?? 10, 5);
+                        console.log(`[${prefix}] High worker confidence (${context.workerResult.confidencePercent}%), limiting reviewer to ${cappedTurns} turns`);
+                        reviewerMaxTurns = cappedTurns;
+                    }
+                    console.log(`[${prefix}] Running full review (Sonnet)...`);
+                    result = await reviewerAgent.runReviewer({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        workerResult: context.workerResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.roles?.reviewer?.timeoutMs ?? 0,
+                        model: this.config.roles?.reviewer?.model,
+                        maxTurns: reviewerMaxTurns,
+                        adapterName: this.config.roles?.reviewer?.adapter,
+                        processContext: { taskId: context.task.id, stage: 'reviewer' },
+                    });
+                    agentPair.saveReviewerResult(context.session.id, result);
+                    context.reviewResult = result;
+                    // Verbose: emit reviewer decision details
+                    if (this.config.verbose) {
+                        const rr = result;
+                        this.emit('log', { line: `[verbose] Reviewer decision: ${rr.decision}` });
+                        if (rr.feedback) {
+                            const lines = rr.feedback.split('\n').slice(0, 10);
+                            for (const line of lines) {
+                                this.emit('log', { line: `[verbose]   ${line}` });
+                            }
+                        }
+                    }
+                    break;
+                case 'tester':
+                    if (!context.workerResult) {
+                        throw new Error('Worker result required for tester');
+                    }
+                    result = await testerAgent.runTester({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        workerResult: context.workerResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.roles?.tester?.timeoutMs ?? 0,
+                        model: this.config.roles?.tester?.model,
+                        maxTurns: this.config.roles?.tester?.maxTurns,
+                        adapterName: this.config.roles?.tester?.adapter,
+                    });
+                    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.workerResult) {
+                        throw new Error('Worker result required for documenter');
+                    }
+                    result = await documenterAgent.runDocumenter({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        workerResult: context.workerResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.roles?.documenter?.timeoutMs ?? 0,
+                        model: this.config.roles?.documenter?.model,
+                        maxTurns: this.config.roles?.documenter?.maxTurns,
+                        adapterName: this.config.roles?.documenter?.adapter,
+                    });
+                    context.documenterResult = result;
+                    break;
+                case 'auditor':
+                    if (!context.workerResult) {
+                        throw new Error('Worker result required for auditor');
+                    }
+                    result = await auditorAgent.runAuditor({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        workerResult: context.workerResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.roles?.auditor?.timeoutMs ?? 0,
+                        model: this.config.roles?.auditor?.model,
+                        maxTurns: this.config.roles?.auditor?.maxTurns,
+                        adapterName: this.config.roles?.auditor?.adapter,
+                    });
+                    context.auditorResult = result;
+                    break;
+                case 'skill-documenter':
+                    if (!context.workerResult) {
+                        throw new Error('Worker result required for skill-documenter');
+                    }
+                    result = await skillDocumenterAgent.runSkillDocumenter({
+                        taskTitle: context.task.title,
+                        taskDescription: context.task.description || '',
+                        workerResult: context.workerResult,
+                        projectPath: context.projectPath,
+                        timeoutMs: this.config.roles?.['skill-documenter']?.timeoutMs ?? 0,
+                        model: this.config.roles?.['skill-documenter']?.model,
+                        maxTurns: this.config.roles?.['skill-documenter']?.maxTurns,
+                        adapterName: this.config.roles?.['skill-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: {
+                    taskId: context.task.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: { taskId: context.task.id, stage, status: 'fail' } });
+            return stageResult;
+        }
+    }
+    /**
+     * Determine stage success
+     */
+    isStageSuccess(stage, result) {
+        switch (stage) {
+            case 'worker':
+                return result.success;
+            case 'reviewer':
+                return result.decision === 'approve';
+            case 'tester':
+                return result.success;
+            case 'documenter':
+                return result.success;
+            case 'auditor':
+                return result.success;
+            case 'skill-documenter':
+                return result.success;
+            default:
+                return false;
+        }
+    }
+    // ============================================
+    // Full Iteration Loop
+    // ============================================
+    /**
+     * Full iteration loop
+     *
+     * 1 iteration = full pass through Worker → Reviewer → Tester
+     * On failure (revise) at any stage, restart from Worker in next iteration
+     * reject = immediate termination
+     */
+    async runFullIterationLoop(context, stages) {
+        const maxIterations = this.config.maxIterations ?? 3;
+        const hasWorker = this.hasStage('worker');
+        const hasReviewer = this.hasStage('reviewer');
+        const hasTester = this.hasStage('tester');
+        // No point without a worker
+        if (!hasWorker) {
+            console.log(`[${context.taskPrefix}] No worker 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.taskPrefix}] STUCK DETECTED: ${stuckCheck.reason}`);
+                console.error(`[${context.taskPrefix}] 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: { taskId: context.task.id, iteration: context.currentIteration } });
+            console.log(`[${context.taskPrefix}] Iteration ${context.currentIteration}/${maxIterations}`);
+            // ========== WORKER (with escalation) ==========
+            const workerCfg = this.config.roles?.worker;
+            const escalateThreshold = workerCfg?.escalateAfterIteration ?? 3;
+            const shouldEscalate = context.currentIteration >= escalateThreshold && !!workerCfg?.escalateModel;
+            const baseWorkerModel = this.getModelForRole('worker', context.task);
+            const workerOverrides = shouldEscalate
+                ? { model: workerCfg.escalateModel }
+                : (baseWorkerModel ? { model: baseWorkerModel } : undefined);
+            if (shouldEscalate) {
+                console.log(`[${context.taskPrefix}] Escalating worker model → ${workerCfg.escalateModel} (iteration ${context.currentIteration})`);
+                broadcastEvent({ type: 'pipeline:escalation', data: {
+                        taskId: context.task.id,
+                        iteration: context.currentIteration,
+                        fromModel: workerCfg?.model,
+                        toModel: workerCfg.escalateModel,
+                    } });
+            }
+            agentPair.updateSessionStatus(context.session.id, 'working');
+            const workerResult = await this.runStage('worker', context, workerOverrides);
+            stages.push(workerResult);
+            // Record Worker result in stuck detector
+            this.stuckDetector.addEntry({
+                stage: 'worker',
+                success: workerResult.success,
+                output: workerResult.result.summary,
+                error: workerResult.result.error,
+                timestamp: Date.now(),
+            });
+            if (!workerResult.success) {
+                console.log(`[${context.taskPrefix}] Worker failed, retrying...`);
+                agentPair.trackFailure(context.session.id); // Track for fresh context decision
+                this.emit('iteration:fail', {
+                    iteration: context.currentIteration,
+                    stage: 'worker',
+                    context,
+                });
+                continue; // Next iteration
+            }
+            // ========== PIPELINE GUARDS (post-worker, pre-reviewer) ==========
+            if (this.config.guards && context.workerResult) {
+                console.log(`[${context.taskPrefix}] Running pipeline guards...`);
+                const guardsResult = await runGuards(context.workerResult, context.projectPath, this.config.guards);
+                context.guardsResult = guardsResult;
+                if (!guardsResult.allPassed) {
+                    // Blocking guard failed → inject revise, skip reviewer
+                    console.log(`[${context.taskPrefix}] Blocking guard failed: ${guardsResult.combinedIssues.join('; ')}`);
+                    context.reviewResult = {
+                        decision: 'revise',
+                        feedback: `Pipeline guard failed: ${guardsResult.combinedIssues.join('; ')}`,
+                        issues: guardsResult.combinedIssues,
+                        suggestions: ['Fix the issues flagged by quality guards'],
+                    };
+                    agentPair.trackFailure(context.session.id);
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'worker',
+                        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.taskPrefix}] Guard warnings: ${warnings.map(w => w.guard).join(', ')}`);
+                    this.emit('log', {
+                        line: `⚠️ Guard warnings: ${warnings.flatMap(w => w.issues).join('; ')}`,
+                    });
+                }
+            }
+            // ========== HALT CHECK (confidence too low) ==========
+            if (context.workerResult) {
+                const confidence = agentPair.calculateConfidence(context.workerResult);
+                if (confidence < CONFIDENCE_THRESHOLDS.HALT) {
+                    const haltReason = context.workerResult.haltReason
+                        || `Low confidence: ${confidence}%`;
+                    console.warn(`[${context.taskPrefix}] 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}`,
+                        issues: [haltReason],
+                        suggestions: ['Review task requirements', 'Provide additional context', 'Break into sub-tasks'],
+                    };
+                    agentPair.trackFailure(context.session.id);
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'worker',
+                        context,
+                    });
+                    agentPair.updateSessionStatus(context.session.id, 'revising');
+                    continue;
+                }
+            }
+            // ========== REVIEWER ==========
+            if (hasReviewer) {
+                agentPair.updateSessionStatus(context.session.id, 'reviewing');
+                const reviewerResult = await this.runStage('reviewer', context);
+                stages.push(reviewerResult);
+                const decision = reviewerResult.result.decision;
+                // Record Reviewer result in stuck detector
+                this.stuckDetector.addEntry({
+                    stage: 'reviewer',
+                    success: reviewerResult.success,
+                    decision: decision,
+                    output: reviewerResult.result.feedback,
+                    timestamp: Date.now(),
+                });
+                if (decision === 'reject') {
+                    // reject = terminate immediately
+                    console.log(`[${context.taskPrefix}] Reviewer rejected`);
+                    agentPair.updateSessionStatus(context.session.id, 'rejected');
+                    return { success: false };
+                }
+                if (decision === 'revise') {
+                    // revise = next iteration
+                    console.log(`[${context.taskPrefix}] Reviewer requested revision`);
+                    agentPair.trackFailure(context.session.id); // Track for fresh context decision
+                    this.emit('iteration:fail', {
+                        iteration: context.currentIteration,
+                        stage: 'reviewer',
+                        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.workerResult?.filesChanged || [];
+                const hasCodeChange = changedFiles.some(f => codeExtensions.test(f));
+                if (skipIfNoCode && !hasCodeChange) {
+                    console.log(`[${context.taskPrefix}] 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.taskPrefix}] 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),
+                                issues: 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.taskPrefix}] Iteration ${context.currentIteration} completed successfully`);
+            this.emit('iteration:complete', {
+                iteration: context.currentIteration,
+                context,
+            });
+            return { success: true };
+        }
+        // maxIterations exceeded
+        console.log(`[${context.taskPrefix}] 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.workerResult?.costInfo)
+            stageCosts.push(context.workerResult.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.taskPrefix}] Total cost: ${formatCost(totalCost)}`);
+            broadcastEvent({ type: 'task:cost', data: { taskId: context.task.id, cost: totalCost } });
+        }
+        const result = {
+            success,
+            sessionId: context.session.id,
+            stages,
+            finalStatus,
+            totalDuration: Date.now() - startTime,
+            iterations: context.currentIteration,
+            workerResult: context.workerResult,
+            reviewResult: context.reviewResult,
+            testerResult: context.testerResult,
+            documenterResult: context.documenterResult,
+            auditorResult: context.auditorResult,
+            skillDocumenterResult: context.skillDocumenterResult,
+            taskContext: {
+                issueIdentifier: context.task.issueIdentifier || context.task.issueId,
+                projectName: context.task.linearProject?.name,
+                projectPath: context.projectPath,
+                taskTitle: context.task.title,
+            },
+            totalCost,
+        };
+        if (success) {
+            this.emit('pipeline:complete', result);
+        }
+        else {
+            this.emit('pipeline:fail', result);
+        }
+        return result;
+    }
+}
+// Factory Functions
+/**
+ * Create default pipeline (Worker + Reviewer)
+ */
+export function createDefaultPipeline(maxIterations = 3) {
+    return new PairPipeline({
+        stages: ['worker', 'reviewer'],
+        maxIterations,
+    });
+}
+/**
+ * Create full pipeline (Worker + Reviewer + Tester + Documenter)
+ */
+export function createFullPipeline(config) {
+    return new PairPipeline({
+        stages: ['worker', 'reviewer', 'tester', 'documenter'],
+        maxIterations: 3,
+        continueOnTestFail: false,
+        skipDocumenterIfNoChange: true,
+        ...config,
+    });
+}
+/**
+ * Create pipeline from configuration
+ */
+export function createPipelineFromConfig(roles, maxIterations = 3, guards, jobProfiles) {
+    const stages = [];
+    if (roles?.worker?.enabled !== false) {
+        stages.push('worker');
+    }
+    if (roles?.reviewer?.enabled !== false) {
+        stages.push('reviewer');
+    }
+    if (roles?.tester?.enabled) {
+        stages.push('tester');
+    }
+    if (roles?.documenter?.enabled) {
+        stages.push('documenter');
+    }
+    if (roles?.auditor?.enabled) {
+        stages.push('auditor');
+    }
+    if (roles?.['skill-documenter']?.enabled) {
+        stages.push('skill-documenter');
+    }
+    return new PairPipeline({
+        stages,
+        maxIterations,
+        roles,
+        guards,
+        jobProfiles,
+    });
+}
+// Helpers
+// Re-export formatting functions (extracted to pipelineFormat.ts)
+export { formatPipelineResult, formatPipelineResultEmbed } from './pipelineFormat.js';
+//# sourceMappingURL=pairPipeline.js.map