dartmind 17.0.0

package/dist/agents/CriticAgent.js

@@ -0,0 +1,895 @@
+/**
+ * DartMind V17 - Critic Agent (P2)
+ * Days 12-13: Self-Correction System
+ *
+ * The Critic Agent runs 8 verification steps on generated code:
+ * 1. Static Analysis - Dart analyzer
+ * 2. Compilation Check - Flutter build validation
+ * 3. Test Generation - Auto-generate tests
+ * 4. Edge Case Injection - Test boundary conditions
+ * 5. Null Safety Check - Sound null safety validation
+ * 6. Memory Leak Detection - Dispose pattern checking
+ * 7. Performance Check - Performance anti-patterns
+ * 8. Security Scan - Security vulnerability detection
+ *
+ * Features:
+ * - Max 3 iterations before force escalate
+ * - $2 cost ceiling per task
+ * - Doom loop detection (>80% similarity)
+ * - Human escalation when limits reached
+ *
+ * @module agents/CriticAgent
+ * @version 17.0.0
+ */
+import { EventEmitter } from 'events';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import { DEFAULT_CRITIC_AGENT_CONFIG, DEFAULT_VERIFICATION_CONFIGS, calculateCost, generateEscalationMessage, } from './CriticAgentTypes.js';
+import { createDoomLoopDetector } from '../engine/DoomLoopDetector.js';
+const execAsync = promisify(exec);
+const fsPromises = fs.promises;
+/**
+ * Static Analysis verification using Dart analyzer
+ */
+export class StaticAnalysisRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        try {
+            // Run dart analyze on the project
+            const { stdout, stderr } = await execAsync('dart analyze --format=json', {
+                cwd: context.projectPath,
+                timeout: 30000,
+            });
+            // Parse analysis output
+            const analysisIssues = this.parseAnalysisOutput(stdout || stderr);
+            issues.push(...analysisIssues);
+        }
+        catch (error) {
+            // Analysis may fail with non-zero exit code for issues
+            const execError = error;
+            const analysisIssues = this.parseAnalysisOutput(execError.stdout || execError.stderr || '');
+            issues.push(...analysisIssues);
+        }
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'static_analysis',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    parseAnalysisOutput(output) {
+        const issues = [];
+        // Parse line format: "file:line:column - severity - message"
+        const pattern = /(\S+):(\d+):(\d+)\s+-\s+(error|warning|info)\s+-\s+(.+)/gi;
+        let match;
+        while ((match = pattern.exec(output)) !== null) {
+            issues.push({
+                id: `sa-${issues.length}`,
+                type: 'static_analysis',
+                severity: this.mapSeverity(match[4]),
+                message: match[5],
+                location: {
+                    file: match[1],
+                    line: parseInt(match[2]),
+                    column: parseInt(match[3]),
+                },
+            });
+        }
+        return issues;
+    }
+    mapSeverity(dartSeverity) {
+        switch (dartSeverity.toLowerCase()) {
+            case 'error':
+                return 'error';
+            case 'warning':
+                return 'warning';
+            case 'info':
+            case 'hint':
+                return 'info';
+            default:
+                return 'info';
+        }
+    }
+}
+/**
+ * Compilation Check verification
+ */
+export class CompilationCheckRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        try {
+            // Try to compile in debug mode without actually building
+            await execAsync('flutter build --debug --no-pub', {
+                cwd: context.projectPath,
+                timeout: 60000,
+            });
+        }
+        catch (error) {
+            const execError = error;
+            const errorOutput = execError.stderr || execError.message || String(error);
+            // Parse compilation errors
+            const compileErrors = this.parseCompilationErrors(errorOutput);
+            issues.push(...compileErrors);
+        }
+        const passed = issues.length === 0;
+        return {
+            type: 'compilation_check',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    parseCompilationErrors(output) {
+        const issues = [];
+        // Parse Dart compilation errors
+        const pattern = /Error:\s*(.+?)(?:\n|$)/gi;
+        let match;
+        while ((match = pattern.exec(output)) !== null) {
+            issues.push({
+                id: `cc-${issues.length}`,
+                type: 'compilation_check',
+                severity: 'error',
+                message: match[1].trim(),
+            });
+        }
+        // If no specific errors parsed but command failed
+        if (issues.length === 0 && output.length > 0) {
+            issues.push({
+                id: 'cc-general',
+                type: 'compilation_check',
+                severity: 'error',
+                message: output.substring(0, 200),
+            });
+        }
+        return issues;
+    }
+}
+/**
+ * Test Generation verification - checks if code is testable
+ */
+export class TestGenerationRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Analyze code for testability issues
+        const testabilityIssues = this.analyzeTestability(code);
+        issues.push(...testabilityIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'test_generation',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzeTestability(code) {
+        const issues = [];
+        // Check for hard-coded dependencies
+        if (code.includes('DateTime.now()') && !code.includes('clock')) {
+            issues.push({
+                id: 'tg-datetime',
+                type: 'test_generation',
+                severity: 'warning',
+                message: 'Hard-coded DateTime.now() makes testing difficult',
+                suggestion: 'Inject a Clock or DateTime provider for testability',
+            });
+        }
+        // Check for static method calls that are hard to mock
+        const staticCallPattern = /\b[A-Z][a-zA-Z]+\.[a-z][a-zA-Z]+\(/g;
+        const staticCalls = code.match(staticCallPattern) || [];
+        const problematicStatics = staticCalls.filter((call) => !call.startsWith('Colors.') &&
+            !call.startsWith('Icons.') &&
+            !call.startsWith('TextStyle.') &&
+            !call.startsWith('EdgeInsets.'));
+        if (problematicStatics.length > 5) {
+            issues.push({
+                id: 'tg-static',
+                type: 'test_generation',
+                severity: 'warning',
+                message: `${problematicStatics.length} static method calls may make mocking difficult`,
+                suggestion: 'Consider using dependency injection for better testability',
+            });
+        }
+        // Check for global state
+        if (code.includes('static ') && code.includes('=') && !code.includes('const static')) {
+            issues.push({
+                id: 'tg-global',
+                type: 'test_generation',
+                severity: 'warning',
+                message: 'Mutable static state can cause test interference',
+                suggestion: 'Consider using instance state or proper state management',
+            });
+        }
+        return issues;
+    }
+}
+/**
+ * Edge Case Injection verification
+ */
+export class EdgeCaseInjectionRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for unhandled edge cases
+        const edgeCaseIssues = this.analyzeEdgeCases(code);
+        issues.push(...edgeCaseIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'edge_case_injection',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzeEdgeCases(code) {
+        const issues = [];
+        // Check for division without zero check
+        if (code.includes('/') && !code.includes('== 0') && !code.includes('!= 0')) {
+            const divisionMatch = code.match(/(\w+)\s*\/\s*(\w+)/);
+            if (divisionMatch && !divisionMatch[2].match(/^\d+$/)) {
+                issues.push({
+                    id: 'ec-division',
+                    type: 'edge_case_injection',
+                    severity: 'warning',
+                    message: 'Division without zero check detected',
+                    suggestion: 'Add check for divisor being zero',
+                });
+            }
+        }
+        // Check for array/list access without bounds check
+        if (code.includes('[') && code.includes(']')) {
+            const indexAccess = code.match(/\[(\w+)\]/g) || [];
+            const hasLengthCheck = code.includes('.length') || code.includes('.isEmpty');
+            if (indexAccess.length > 0 && !hasLengthCheck) {
+                issues.push({
+                    id: 'ec-bounds',
+                    type: 'edge_case_injection',
+                    severity: 'warning',
+                    message: 'Array index access without bounds checking',
+                    suggestion: 'Check list length before accessing by index',
+                });
+            }
+        }
+        // Check for string operations without null/empty check
+        if (code.includes('.substring') || code.includes('.split')) {
+            if (!code.includes('.isNotEmpty') && !code.includes('.isEmpty') && !code.includes('?.')) {
+                issues.push({
+                    id: 'ec-string',
+                    type: 'edge_case_injection',
+                    severity: 'info',
+                    message: 'String operations without empty check',
+                    suggestion: 'Consider checking for empty strings before operations',
+                });
+            }
+        }
+        return issues;
+    }
+}
+/**
+ * Null Safety Check verification
+ */
+export class NullSafetyCheckRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for null safety issues
+        const nullSafetyIssues = this.analyzeNullSafety(code);
+        issues.push(...nullSafetyIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'null_safety_check',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzeNullSafety(code) {
+        const issues = [];
+        // Check for bang operator abuse
+        const bangOperators = (code.match(/!\./g) || []).length;
+        if (bangOperators > 5) {
+            issues.push({
+                id: 'ns-bang',
+                type: 'null_safety_check',
+                severity: 'warning',
+                message: `${bangOperators} bang operators (!) detected - potential runtime crashes`,
+                suggestion: 'Use null-aware operators (?., ??) instead of bang operators',
+            });
+        }
+        // Check for late without initialization guarantee
+        const lateVars = code.match(/late\s+\w+\s+\w+;/g) || [];
+        if (lateVars.length > 0) {
+            issues.push({
+                id: 'ns-late',
+                type: 'null_safety_check',
+                severity: 'info',
+                message: `${lateVars.length} late variables without obvious initialization`,
+                suggestion: 'Ensure late variables are initialized before use',
+            });
+        }
+        // Check for as casts without type checks
+        const asCasts = (code.match(/\bas\s+\w+/g) || []).length;
+        const typeChecks = (code.match(/\bis\s+\w+/g) || []).length;
+        if (asCasts > typeChecks) {
+            issues.push({
+                id: 'ns-cast',
+                type: 'null_safety_check',
+                severity: 'warning',
+                message: 'More type casts than type checks - potential ClassCastException',
+                suggestion: 'Use type checks (is) before casting (as)',
+            });
+        }
+        return issues;
+    }
+}
+/**
+ * Memory Leak Detection verification
+ */
+export class MemoryLeakDetectionRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for memory leak patterns
+        const memoryLeakIssues = this.analyzeMemoryLeaks(code);
+        issues.push(...memoryLeakIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'memory_leak_detection',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzeMemoryLeaks(code) {
+        const issues = [];
+        // Check for StreamController without dispose
+        if (code.includes('StreamController') && !code.includes('.close()')) {
+            issues.push({
+                id: 'ml-stream',
+                type: 'memory_leak_detection',
+                severity: 'error',
+                message: 'StreamController without close() - memory leak',
+                suggestion: 'Call close() on StreamController in dispose()',
+                autoFixable: true,
+            });
+        }
+        // Check for TextEditingController without dispose
+        if (code.includes('TextEditingController') && !code.includes('.dispose()')) {
+            issues.push({
+                id: 'ml-text',
+                type: 'memory_leak_detection',
+                severity: 'error',
+                message: 'TextEditingController without dispose() - memory leak',
+                suggestion: 'Call dispose() on TextEditingController in dispose()',
+                autoFixable: true,
+            });
+        }
+        // Check for AnimationController without dispose
+        if (code.includes('AnimationController') && !code.includes('.dispose()')) {
+            issues.push({
+                id: 'ml-animation',
+                type: 'memory_leak_detection',
+                severity: 'error',
+                message: 'AnimationController without dispose() - memory leak',
+                suggestion: 'Call dispose() on AnimationController in dispose()',
+                autoFixable: true,
+            });
+        }
+        // Check for addListener without removeListener
+        const addListenerCount = (code.match(/\.addListener\(/g) || []).length;
+        const removeListenerCount = (code.match(/\.removeListener\(/g) || []).length;
+        if (addListenerCount > removeListenerCount) {
+            issues.push({
+                id: 'ml-listener',
+                type: 'memory_leak_detection',
+                severity: 'warning',
+                message: `${addListenerCount - removeListenerCount} listeners added without removal`,
+                suggestion: 'Remove listeners in dispose() to prevent memory leaks',
+            });
+        }
+        // Check for Timer without cancel
+        if (code.includes('Timer(') && !code.includes('.cancel()')) {
+            issues.push({
+                id: 'ml-timer',
+                type: 'memory_leak_detection',
+                severity: 'warning',
+                message: 'Timer without cancel() - potential memory leak',
+                suggestion: 'Cancel timers in dispose()',
+            });
+        }
+        return issues;
+    }
+}
+/**
+ * Performance Check verification
+ */
+export class PerformanceCheckRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for performance anti-patterns
+        const perfIssues = this.analyzePerformance(code);
+        issues.push(...perfIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'performance_check',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzePerformance(code) {
+        const issues = [];
+        // Check for build() method doing heavy computation
+        const buildMatch = code.match(/@override\s+Widget\s+build\([^)]*\)\s*\{([^}]+)\}/s);
+        if (buildMatch) {
+            const buildBody = buildMatch[1];
+            if (buildBody.includes('for (') || buildBody.includes('while (')) {
+                issues.push({
+                    id: 'pf-build-loop',
+                    type: 'performance_check',
+                    severity: 'warning',
+                    message: 'Loop in build() method - called on every frame',
+                    suggestion: 'Move computation to initState or use compute()',
+                });
+            }
+        }
+        // Check for missing const constructors
+        const widgetMatches = code.match(/new\s+\w+Widget\(/g) || [];
+        if (widgetMatches.length > 3) {
+            issues.push({
+                id: 'pf-const',
+                type: 'performance_check',
+                severity: 'info',
+                message: 'Multiple widget instantiations without const',
+                suggestion: 'Use const constructors where possible',
+            });
+        }
+        // Check for setState in loop
+        if (code.includes('setState') && (code.includes('for (') || code.includes('forEach'))) {
+            const setStateInLoop = code.match(/for\s*\([^)]*\)\s*\{[^}]*setState/s);
+            if (setStateInLoop) {
+                issues.push({
+                    id: 'pf-setstate-loop',
+                    type: 'performance_check',
+                    severity: 'error',
+                    message: 'setState() called in loop - causes multiple rebuilds',
+                    suggestion: 'Batch updates and call setState once',
+                });
+            }
+        }
+        // Check for expensive operations without caching
+        if (code.includes('MediaQuery.of(context)')) {
+            const mediaQueryCount = (code.match(/MediaQuery\.of\(context\)/g) || []).length;
+            if (mediaQueryCount > 2) {
+                issues.push({
+                    id: 'pf-mediaquery',
+                    type: 'performance_check',
+                    severity: 'info',
+                    message: `MediaQuery.of(context) called ${mediaQueryCount} times`,
+                    suggestion: 'Cache MediaQuery result in a variable',
+                });
+            }
+        }
+        return issues;
+    }
+}
+/**
+ * Security Scan verification
+ */
+export class SecurityScanRunner {
+    async run(code, context) {
+        const startTime = Date.now();
+        const issues = [];
+        // Check for security vulnerabilities
+        const securityIssues = this.analyzeSecurity(code);
+        issues.push(...securityIssues);
+        const passed = !issues.some((i) => i.severity === 'error' || i.severity === 'critical');
+        return {
+            type: 'security_scan',
+            passed,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    analyzeSecurity(code) {
+        const issues = [];
+        // Check for hardcoded secrets
+        const secretPatterns = [
+            /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi,
+            /secret[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi,
+            /password\s*[:=]\s*['"][^'"]+['"]/gi,
+            /token\s*[:=]\s*['"][^'"]+['"]/gi,
+        ];
+        for (const pattern of secretPatterns) {
+            if (pattern.test(code)) {
+                issues.push({
+                    id: 'sec-hardcoded',
+                    type: 'security_scan',
+                    severity: 'critical',
+                    message: 'Hardcoded secret detected in code',
+                    suggestion: 'Use environment variables or secure storage',
+                });
+                break;
+            }
+        }
+        // Check for SQL injection (if using raw queries)
+        if (code.includes('rawQuery') || code.includes('execute(')) {
+            if (code.includes('$') || code.includes('+')) {
+                issues.push({
+                    id: 'sec-sql',
+                    type: 'security_scan',
+                    severity: 'critical',
+                    message: 'Potential SQL injection - string interpolation in query',
+                    suggestion: 'Use parameterized queries instead',
+                });
+            }
+        }
+        // Check for insecure HTTP
+        if (code.includes('http://') && !code.includes('http://localhost') && !code.includes('http://127.0.0.1')) {
+            issues.push({
+                id: 'sec-http',
+                type: 'security_scan',
+                severity: 'warning',
+                message: 'Insecure HTTP URL detected',
+                suggestion: 'Use HTTPS for all external connections',
+            });
+        }
+        // Check for eval-like patterns
+        if (code.includes('Function(') || code.includes('eval(')) {
+            issues.push({
+                id: 'sec-eval',
+                type: 'security_scan',
+                severity: 'critical',
+                message: 'Dynamic code execution detected',
+                suggestion: 'Avoid eval/Function for security reasons',
+            });
+        }
+        // Check for WebView JavaScript injection
+        if (code.includes('WebView') && code.includes('javascriptMode: JavascriptMode.unrestricted')) {
+            issues.push({
+                id: 'sec-webview',
+                type: 'security_scan',
+                severity: 'warning',
+                message: 'WebView with unrestricted JavaScript',
+                suggestion: 'Restrict JavaScript or validate content sources',
+            });
+        }
+        return issues;
+    }
+}
+// ============================================================================
+// Critic Agent
+// ============================================================================
+/**
+ * Critic Agent - Self-correction system for code verification
+ */
+export class CriticAgent extends EventEmitter {
+    config;
+    doomLoopDetector;
+    verificationRunners;
+    iterationCount = 0;
+    costConsumed = 0;
+    verificationHistory = [];
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CRITIC_AGENT_CONFIG, ...config };
+        this.doomLoopDetector = createDoomLoopDetector({
+            maxAttempts: this.config.maxIterations,
+            similarityThreshold: this.config.doomLoopThreshold,
+        });
+        // Initialize verification runners
+        this.verificationRunners = new Map();
+        this.verificationRunners.set('static_analysis', new StaticAnalysisRunner());
+        this.verificationRunners.set('compilation_check', new CompilationCheckRunner());
+        this.verificationRunners.set('test_generation', new TestGenerationRunner());
+        this.verificationRunners.set('edge_case_injection', new EdgeCaseInjectionRunner());
+        this.verificationRunners.set('null_safety_check', new NullSafetyCheckRunner());
+        this.verificationRunners.set('memory_leak_detection', new MemoryLeakDetectionRunner());
+        this.verificationRunners.set('performance_check', new PerformanceCheckRunner());
+        this.verificationRunners.set('security_scan', new SecurityScanRunner());
+    }
+    /**
+     * Add event listener
+     */
+    onEvent(handler) {
+        this.on('event', handler);
+    }
+    /**
+     * Emit typed event
+     */
+    emitEvent(event) {
+        this.emit('event', event);
+    }
+    /**
+     * Run critique on code
+     */
+    async critique(code, context) {
+        const startTime = Date.now();
+        this.emitEvent({ type: 'critique:started', context, timestamp: Date.now() });
+        try {
+            // Check iteration limit
+            this.iterationCount++;
+            if (this.iterationCount > this.config.maxIterations) {
+                return this.forceEscalate('max_iterations', {
+                    maxIterations: this.config.maxIterations,
+                });
+            }
+            // Check cost ceiling
+            if (this.costConsumed > this.config.costCeiling) {
+                return this.forceEscalate('cost_ceiling', {
+                    costCeiling: this.config.costCeiling,
+                });
+            }
+            this.emitEvent({
+                type: 'iteration:started',
+                iteration: this.iterationCount,
+                timestamp: Date.now(),
+            });
+            // Record attempt for doom loop detection
+            this.doomLoopDetector.recordAttempt(code);
+            // Check for doom loop
+            const doomCheck = this.doomLoopDetector.check();
+            if (doomCheck.isLoop) {
+                this.emitEvent({
+                    type: 'doom_loop:detected',
+                    similarity: doomCheck.similarityScore,
+                    iterations: doomCheck.attemptCount,
+                    timestamp: Date.now(),
+                });
+                return this.forceEscalate('doom_loop', {
+                    similarity: doomCheck.similarityScore,
+                    iterations: doomCheck.attemptCount,
+                });
+            }
+            // Run verification steps
+            const verificationResults = await this.runVerifications(code, context);
+            // Collect failures
+            const failures = verificationResults.filter((r) => !r.passed);
+            // Store history
+            this.verificationHistory.push(...verificationResults);
+            // Build result
+            const result = this.buildResult(verificationResults, failures, startTime);
+            this.emitEvent({
+                type: 'iteration:completed',
+                result,
+                timestamp: Date.now(),
+            });
+            this.emitEvent({
+                type: 'critique:completed',
+                result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'critique:error',
+                error: error instanceof Error ? error : new Error(String(error)),
+                timestamp: Date.now(),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Run all enabled verification steps
+     */
+    async runVerifications(code, context) {
+        const enabledVerifications = [];
+        // Get enabled verifications
+        for (const [type, config] of Object.entries(this.config.verifications)) {
+            if (config?.enabled !== false) {
+                enabledVerifications.push(type);
+            }
+        }
+        if (this.config.parallelVerification) {
+            // Run all verifications in parallel
+            const promises = enabledVerifications.map((type) => this.runVerification(type, code, context));
+            return Promise.all(promises);
+        }
+        else {
+            // Run verifications sequentially
+            const results = [];
+            for (const type of enabledVerifications) {
+                const result = await this.runVerification(type, code, context);
+                results.push(result);
+                // Stop on critical failure
+                if (result.issues.some((i) => i.severity === 'critical')) {
+                    break;
+                }
+            }
+            return results;
+        }
+    }
+    /**
+     * Run a single verification
+     */
+    async runVerification(type, code, context) {
+        const runner = this.verificationRunners.get(type);
+        if (!runner) {
+            return {
+                type,
+                passed: true,
+                issues: [],
+                duration: 0,
+                metadata: { error: 'No runner available' },
+            };
+        }
+        this.emitEvent({
+            type: 'verification:started',
+            verificationType: type,
+            timestamp: Date.now(),
+        });
+        const config = this.config.verifications[type] || DEFAULT_VERIFICATION_CONFIGS[type];
+        const timeout = config?.timeout || 30000;
+        try {
+            const result = await Promise.race([
+                runner.run(code, context),
+                this.createTimeout(timeout, type),
+            ]);
+            this.emitEvent({
+                type: 'verification:completed',
+                result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+        catch (error) {
+            const result = {
+                type,
+                passed: false,
+                issues: [
+                    {
+                        id: `${type}-error`,
+                        type,
+                        severity: 'error',
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                ],
+                duration: timeout,
+            };
+            this.emitEvent({
+                type: 'verification:completed',
+                result,
+                timestamp: Date.now(),
+            });
+            return result;
+        }
+    }
+    /**
+     * Create a timeout promise
+     */
+    createTimeout(ms, type) {
+        return new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`Verification ${type} timed out after ${ms}ms`));
+            }, ms);
+        });
+    }
+    /**
+     * Force escalation to human
+     */
+    forceEscalate(reason, details) {
+        const escalation = {
+            reason,
+            message: generateEscalationMessage(reason, details),
+            iterationCount: this.iterationCount,
+            costConsumed: this.costConsumed,
+            verificationHistory: this.verificationHistory,
+            timestamp: Date.now(),
+        };
+        this.emitEvent({
+            type: 'escalation:triggered',
+            escalation,
+            timestamp: Date.now(),
+        });
+        return {
+            passed: false,
+            escalated: true,
+            escalation,
+            verifications: [],
+            failures: [],
+            suggestions: [],
+            decisionCardRequired: true,
+            iterationCount: this.iterationCount,
+            costConsumed: this.costConsumed,
+            totalDuration: 0,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Build critique result
+     */
+    buildResult(verifications, failures, startTime) {
+        const passed = failures.length === 0;
+        const suggestions = this.generateSuggestions(failures);
+        return {
+            passed,
+            escalated: false,
+            verifications,
+            failures,
+            suggestions,
+            decisionCardRequired: !passed,
+            iterationCount: this.iterationCount,
+            costConsumed: this.costConsumed,
+            totalDuration: Date.now() - startTime,
+            timestamp: Date.now(),
+        };
+    }
+    /**
+     * Generate fix suggestions from failures
+     */
+    generateSuggestions(failures) {
+        const suggestions = [];
+        for (const failure of failures) {
+            for (const issue of failure.issues) {
+                if (issue.suggestion) {
+                    suggestions.push(`[${issue.type}] ${issue.suggestion}`);
+                }
+            }
+        }
+        return [...new Set(suggestions)]; // Deduplicate
+    }
+    /**
+     * Track cost from token usage
+     */
+    trackCost(tokens) {
+        const cost = calculateCost(tokens, this.config.modelCosts);
+        this.costConsumed += cost;
+        // Emit warning at 80% of ceiling
+        if (this.costConsumed > this.config.costCeiling * 0.8) {
+            this.emitEvent({
+                type: 'cost:warning',
+                current: this.costConsumed,
+                ceiling: this.config.costCeiling,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    /**
+     * Reset the agent state
+     */
+    reset() {
+        this.iterationCount = 0;
+        this.costConsumed = 0;
+        this.verificationHistory = [];
+        this.doomLoopDetector.reset();
+    }
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return {
+            iterationCount: this.iterationCount,
+            costConsumed: this.costConsumed,
+            maxIterations: this.config.maxIterations,
+            costCeiling: this.config.costCeiling,
+            verificationsRun: this.verificationHistory.length,
+        };
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create a CriticAgent with default configuration
+ */
+export function createCriticAgent(config) {
+    return new CriticAgent(config);
+}
+/**
+ * Create a strict CriticAgent (lower limits)
+ */
+export function createStrictCriticAgent() {
+    return new CriticAgent({
+        maxIterations: 2,
+        costCeiling: 1.0,
+        doomLoopThreshold: 0.7,
+    });
+}
+export default CriticAgent;
+//# sourceMappingURL=CriticAgent.js.map