@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/tests/unit/domains/quality-assessment/coherence-gate.test.ts

@@ -1,1006 +0,0 @@
-/**
- * Agentic QE v3 - Coherence-Gated Quality Gates Tests
- * ADR-030: Comprehensive tests for lambda-coherence with 4-tier compute allocation
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  // Types
-  QualityLambda,
-  QualityTier,
-  QualityLambdaFlags,
-  QualityGateReason,
-  QualityMetricsInput,
-  QualityDimensions,
-  CoherenceGatePolicy,
-  DEFAULT_COHERENCE_GATE_POLICY,
-  QualityPartition,
-
-  // Lambda Calculator
-  LambdaCalculator,
-  createLambdaCalculator,
-  calculateQualityLambda,
-
-  // Gate Controller
-  CoherenceGateController,
-  createCoherenceGateController,
-  evaluateQualityGate,
-
-  // Partition Detector
-  PartitionDetector,
-  createPartitionDetector,
-  detectQualityPartitions,
-
-  // Convenience Functions
-  evaluateCoherenceGate,
-  canDeploy,
-  getQualityTier,
-  getLambdaValue,
-  getQualitySummary,
-} from '../../../../src/domains/quality-assessment/coherence';
-
-// ============================================================================
-// Test Data Fixtures
-// ============================================================================
-
-const HEALTHY_METRICS: QualityMetricsInput = {
-  lineCoverage: 92,
-  testPassRate: 99,
-  criticalVulns: 0,
-  p95Latency: 100,
-  targetLatency: 200,
-  maintainabilityIndex: 85,
-  flakyTestRatio: 0,
-  technicalDebtHours: 2,
-  maxAcceptableDebtHours: 20,
-  duplicationPercent: 2,
-};
-
-const DEGRADED_METRICS: QualityMetricsInput = {
-  lineCoverage: 65,
-  testPassRate: 85,
-  criticalVulns: 0,
-  p95Latency: 180,
-  targetLatency: 200,
-  maintainabilityIndex: 60,
-  flakyTestRatio: 0.1,
-  technicalDebtHours: 15,
-  maxAcceptableDebtHours: 20,
-  duplicationPercent: 10,
-};
-
-const FAILING_METRICS: QualityMetricsInput = {
-  lineCoverage: 45,
-  testPassRate: 70,
-  criticalVulns: 2,
-  p95Latency: 350,
-  targetLatency: 200,
-  maintainabilityIndex: 40,
-  flakyTestRatio: 0.2,
-  technicalDebtHours: 25,
-  maxAcceptableDebtHours: 20,
-  duplicationPercent: 18,
-};
-
-const CRITICAL_SECURITY_METRICS: QualityMetricsInput = {
-  lineCoverage: 85,
-  testPassRate: 95,
-  criticalVulns: 5, // Critical security issue
-  p95Latency: 100,
-  targetLatency: 200,
-  maintainabilityIndex: 80,
-};
-
-// ============================================================================
-// Lambda Calculator Tests
-// ============================================================================
-
-describe('LambdaCalculator', () => {
-  let calculator: LambdaCalculator;
-
-  beforeEach(() => {
-    calculator = createLambdaCalculator();
-  });
-
-  describe('calculate()', () => {
-    it('should calculate lambda for healthy metrics', () => {
-      const lambda = calculator.calculate(HEALTHY_METRICS);
-
-      expect(lambda.lambda).toBeGreaterThanOrEqual(70);
-      expect(lambda.boundaryEdges).toBeLessThanOrEqual(1);
-      expect(lambda.calculatedAt).toBeInstanceOf(Date);
-    });
-
-    it('should calculate lambda for degraded metrics', () => {
-      const lambda = calculator.calculate(DEGRADED_METRICS);
-
-      // Degraded metrics have multiple issues, lambda will be lower
-      expect(lambda.lambda).toBeLessThan(70);
-      expect(lambda.lambda).toBeGreaterThanOrEqual(20);
-    });
-
-    it('should calculate lambda for failing metrics', () => {
-      const lambda = calculator.calculate(FAILING_METRICS);
-
-      expect(lambda.lambda).toBeLessThan(60);
-    });
-
-    it('should detect boundary edges correctly', () => {
-      // Metrics with values around 70% threshold
-      const boundaryMetrics: QualityMetricsInput = {
-        lineCoverage: 68,
-        testPassRate: 72,
-        criticalVulns: 0,
-        p95Latency: 140,
-        targetLatency: 200,
-        maintainabilityIndex: 71,
-      };
-
-      const lambda = calculator.calculate(boundaryMetrics);
-      expect(lambda.boundaryEdges).toBeGreaterThan(0);
-    });
-
-    it('should set previousLambda from input', () => {
-      const metrics = { ...HEALTHY_METRICS, previousLambda: 80 };
-      const lambda = calculator.calculate(metrics);
-
-      expect(lambda.lambdaPrev).toBe(80);
-    });
-
-    it('should set FIRST_EVALUATION flag when no previous lambda', () => {
-      const lambda = calculator.calculate(HEALTHY_METRICS);
-
-      expect(lambda.flags & QualityLambdaFlags.FIRST_EVALUATION).toBeTruthy();
-    });
-
-    it('should detect trending down', () => {
-      const metrics = { ...DEGRADED_METRICS, previousLambda: 85 };
-      const lambda = calculator.calculate(metrics);
-
-      expect(lambda.flags & QualityLambdaFlags.TRENDING_DOWN).toBeTruthy();
-    });
-
-    it('should detect trending up', () => {
-      const metrics = { ...HEALTHY_METRICS, previousLambda: 60 };
-      const lambda = calculator.calculate(metrics);
-
-      expect(lambda.flags & QualityLambdaFlags.TRENDING_UP).toBeTruthy();
-    });
-  });
-
-  describe('normalizeMetrics()', () => {
-    it('should normalize coverage to 0-1 range', () => {
-      const dimensions = calculator.normalizeMetrics(HEALTHY_METRICS);
-
-      expect(dimensions.coverage).toBeGreaterThanOrEqual(0);
-      expect(dimensions.coverage).toBeLessThanOrEqual(1);
-      expect(dimensions.coverage).toBeCloseTo(0.92, 2);
-    });
-
-    it('should normalize security based on vulnerability count', () => {
-      const safeMetrics = { ...HEALTHY_METRICS, criticalVulns: 0 };
-      const unsafeMetrics = { ...HEALTHY_METRICS, criticalVulns: 5 };
-
-      const safeDims = calculator.normalizeMetrics(safeMetrics);
-      const unsafeDims = calculator.normalizeMetrics(unsafeMetrics);
-
-      expect(safeDims.security).toBe(1);
-      expect(unsafeDims.security).toBe(0);
-    });
-
-    it('should normalize performance based on latency ratio', () => {
-      const fastMetrics = { ...HEALTHY_METRICS, p95Latency: 100, targetLatency: 200 };
-      const slowMetrics = { ...HEALTHY_METRICS, p95Latency: 400, targetLatency: 200 };
-
-      const fastDims = calculator.normalizeMetrics(fastMetrics);
-      const slowDims = calculator.normalizeMetrics(slowMetrics);
-
-      expect(fastDims.performance).toBe(1);
-      expect(slowDims.performance).toBeCloseTo(0.5, 2);
-    });
-
-    it('should handle missing optional metrics', () => {
-      const minimalMetrics: QualityMetricsInput = {
-        lineCoverage: 80,
-        testPassRate: 95,
-        criticalVulns: 0,
-        p95Latency: 100,
-        targetLatency: 200,
-        maintainabilityIndex: 75,
-      };
-
-      const dimensions = calculator.normalizeMetrics(minimalMetrics);
-
-      expect(dimensions.coverage).toBeDefined();
-      expect(dimensions.technicalDebt).toBeUndefined();
-    });
-  });
-
-  describe('calculateMinimumCut()', () => {
-    it('should return the minimum dimension value scaled to 0-100', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.9,
-        passRate: 0.95,
-        security: 1.0,
-        performance: 0.8, // This is the minimum
-        maintainability: 0.85,
-        reliability: 0.9,
-      };
-
-      // Due to weighting, the exact value may differ
-      const lambda = calculator.calculateMinimumCut(dimensions);
-      expect(lambda).toBeGreaterThanOrEqual(70);
-      expect(lambda).toBeLessThanOrEqual(85);
-    });
-
-    it('should prioritize critical dimensions', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.5, // Low coverage
-        passRate: 0.5, // Low pass rate (CRITICAL)
-        security: 1.0,
-        performance: 0.9,
-        maintainability: 0.9,
-        reliability: 0.9,
-      };
-
-      const lambda = calculator.calculateMinimumCut(dimensions);
-      // Pass rate is critical, so lambda should be around 50
-      expect(lambda).toBeLessThanOrEqual(55);
-    });
-  });
-
-  describe('getDimensionsBelowThreshold()', () => {
-    it('should return dimensions below threshold sorted by deficit', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.5,
-        passRate: 0.6,
-        security: 0.9,
-        performance: 0.55,
-        maintainability: 0.8,
-        reliability: 0.9,
-      };
-
-      const below = calculator.getDimensionsBelowThreshold(dimensions);
-
-      expect(below.length).toBe(3);
-      expect(below[0].dimension).toBe('coverage');
-      expect(below[0].deficit).toBeCloseTo(0.2, 2);
-    });
-  });
-
-  describe('getDimensionSummary()', () => {
-    it('should categorize dimensions correctly', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.9, // healthy
-        passRate: 0.65, // warning
-        security: 0.4, // critical
-        performance: 0.8, // healthy
-        maintainability: 0.7, // warning
-        reliability: 0.95, // healthy
-      };
-
-      const summary = calculator.getDimensionSummary(dimensions);
-
-      // Note: 0.7 is the threshold, 0.6 is boundary (warning)
-      // healthy >= 0.7, warning >= 0.6, critical < 0.6
-      expect(summary.healthy).toBeGreaterThanOrEqual(3);
-      expect(summary.warning).toBeGreaterThanOrEqual(1);
-      expect(summary.critical).toBeGreaterThanOrEqual(1);
-      expect(summary.total).toBe(6);
-    });
-  });
-});
-
-describe('calculateQualityLambda (convenience function)', () => {
-  it('should create calculator and calculate lambda', () => {
-    const lambda = calculateQualityLambda(HEALTHY_METRICS);
-
-    expect(lambda.lambda).toBeGreaterThan(0);
-    expect(lambda.dimensions).toBeDefined();
-  });
-});
-
-// ============================================================================
-// Gate Controller Tests
-// ============================================================================
-
-describe('CoherenceGateController', () => {
-  let controller: CoherenceGateController;
-
-  beforeEach(() => {
-    controller = createCoherenceGateController();
-  });
-
-  describe('evaluate()', () => {
-    it('should return NORMAL tier for healthy quality', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      expect(decision.tier).toBe(QualityTier.NORMAL);
-      expect(decision.decision).toBe('allow');
-      expect(decision.actions).toHaveLength(0);
-    });
-
-    it('should return REDUCED or higher tier for degraded quality', () => {
-      const lambda = calculateQualityLambda(DEGRADED_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      // Degraded metrics may result in REDUCED, SAFE, or QUARANTINE
-      expect(decision.tier).toBeGreaterThanOrEqual(QualityTier.REDUCED);
-      expect(['reduceScope', 'freezeWrites', 'quarantine']).toContain(decision.decision);
-    });
-
-    it('should return QUARANTINE tier for critical failures', () => {
-      const lambda = calculateQualityLambda(FAILING_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      // With critical vulns and very low metrics, should be quarantined
-      expect(decision.tier).toBeGreaterThanOrEqual(QualityTier.REDUCED);
-    });
-
-    it('should detect critical security issues', () => {
-      const lambda = calculateQualityLambda(CRITICAL_SECURITY_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      // Security issues cause lambda to drop, so lambdaBelowMin triggers first
-      // or securityCritical may be detected
-      expect(decision.tier).toBe(QualityTier.QUARANTINE);
-      expect(['lambdaBelowMin', 'securityCritical']).toContain(decision.reason);
-    });
-
-    it('should detect rapid lambda drop', () => {
-      const metrics = { ...DEGRADED_METRICS, previousLambda: 90 };
-      const lambda = calculateQualityLambda(metrics);
-      const decision = controller.evaluate(lambda);
-
-      expect(decision.additionalReasons || []).toContain('lambdaDroppedFast');
-    });
-
-    it('should handle forced flags', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      lambda.flags = QualityLambdaFlags.FORCE_QUARANTINE;
-
-      const decision = controller.evaluate(lambda);
-
-      expect(decision.tier).toBe(QualityTier.QUARANTINE);
-      expect(decision.reason).toBe('forcedByFlag');
-    });
-
-    it('should allow bypass flag to pass', () => {
-      const lambda = calculateQualityLambda(FAILING_METRICS);
-      lambda.flags = QualityLambdaFlags.BYPASS_CHECKS;
-
-      const decision = controller.evaluate(lambda);
-
-      expect(decision.tier).toBe(QualityTier.NORMAL);
-      expect(decision.decision).toBe('allow');
-    });
-  });
-
-  describe('evaluateTier()', () => {
-    it('should return just the tier number', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      const tier = controller.evaluateTier(lambda);
-
-      expect(typeof tier).toBe('number');
-      expect(tier).toBeGreaterThanOrEqual(0);
-      expect(tier).toBeLessThanOrEqual(3);
-    });
-  });
-
-  describe('canDeploy()', () => {
-    it('should return true for healthy quality', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-
-      expect(controller.canDeploy(lambda)).toBe(true);
-    });
-
-    it('should return false for quarantined quality', () => {
-      const lambda = calculateQualityLambda(FAILING_METRICS);
-      lambda.lambda = 50; // Ensure it fails
-
-      expect(controller.canDeploy(lambda)).toBe(false);
-    });
-  });
-
-  describe('decision history', () => {
-    it('should record decisions', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      controller.evaluate(lambda);
-      controller.evaluate(lambda);
-
-      const history = controller.getHistory();
-      expect(history.length).toBe(2);
-    });
-
-    it('should clear history', () => {
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      controller.evaluate(lambda);
-      controller.clearHistory();
-
-      const history = controller.getHistory();
-      expect(history.length).toBe(0);
-    });
-  });
-
-  describe('policy management', () => {
-    it('should allow policy updates', () => {
-      controller.updatePolicy({ lambdaMin: 80 });
-
-      const policy = controller.getPolicy();
-      expect(policy.lambdaMin).toBe(80);
-    });
-
-    it('should use updated policy for evaluation', () => {
-      // Healthy metrics with default policy pass
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      const decision1 = controller.evaluate(lambda);
-      expect(decision1.tier).toBe(QualityTier.NORMAL);
-
-      // Increase minimum threshold
-      controller.updatePolicy({ lambdaMin: 95 });
-
-      // Same lambda now fails
-      const decision2 = controller.evaluate(lambda);
-      expect(decision2.tier).toBe(QualityTier.QUARANTINE);
-    });
-  });
-
-  describe('decision explanation', () => {
-    it('should provide human-readable explanation', () => {
-      const lambda = calculateQualityLambda(DEGRADED_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      expect(decision.explanation).toBeTruthy();
-      expect(decision.explanation.length).toBeGreaterThan(20);
-    });
-
-    it('should include actions for non-normal tiers', () => {
-      const lambda = calculateQualityLambda(DEGRADED_METRICS);
-      const decision = controller.evaluate(lambda);
-
-      if (decision.tier > QualityTier.NORMAL) {
-        expect(decision.actions.length).toBeGreaterThan(0);
-      }
-    });
-  });
-});
-
-describe('evaluateQualityGate (convenience function)', () => {
-  it('should create controller and evaluate', () => {
-    const lambda = calculateQualityLambda(HEALTHY_METRICS);
-    const decision = evaluateQualityGate(lambda);
-
-    expect(decision.tier).toBeDefined();
-    expect(decision.decision).toBeDefined();
-  });
-
-  it('should accept custom policy', () => {
-    const lambda = calculateQualityLambda(HEALTHY_METRICS);
-    const decision = evaluateQualityGate(lambda, { lambdaMin: 95 });
-
-    // Should fail with strict policy
-    expect(decision.tier).toBe(QualityTier.QUARANTINE);
-  });
-});
-
-// ============================================================================
-// Partition Detector Tests
-// ============================================================================
-
-describe('PartitionDetector', () => {
-  let detector: PartitionDetector;
-
-  beforeEach(() => {
-    detector = createPartitionDetector();
-  });
-
-  describe('detect()', () => {
-    it('should find no partitions for healthy dimensions', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.9,
-        passRate: 0.95,
-        security: 1.0,
-        performance: 0.85,
-        maintainability: 0.8,
-        reliability: 0.9,
-      };
-
-      const result = detector.detect(dimensions);
-
-      expect(result.partitionCount).toBe(0);
-      expect(result.isFragmented).toBe(false);
-    });
-
-    it('should detect testing partition', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.4, // Below 0.7 threshold
-        passRate: 0.5, // Below 0.7 threshold
-        security: 0.9,
-        performance: 0.85,
-        maintainability: 0.8,
-        reliability: 0.4, // Below 0.7 threshold
-      };
-
-      const result = detector.detect(dimensions);
-
-      expect(result.partitionCount).toBeGreaterThan(0);
-      const testingPartition = result.partitions.find(p => p.type === 'testing');
-      expect(testingPartition).toBeDefined();
-    });
-
-    it('should detect security partition', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.9,
-        passRate: 0.95,
-        security: 0.3, // Critical security issue
-        performance: 0.85,
-        maintainability: 0.8,
-        reliability: 0.9,
-      };
-
-      const result = detector.detect(dimensions);
-
-      const securityPartition = result.partitions.find(p => p.type === 'security');
-      expect(securityPartition).toBeDefined();
-      expect(securityPartition?.isCritical).toBe(true);
-    });
-
-    it('should detect maintainability partition', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.9,
-        passRate: 0.95,
-        security: 1.0,
-        performance: 0.85,
-        maintainability: 0.4, // Low maintainability
-        reliability: 0.9,
-        technicalDebt: 0.3, // High tech debt
-        duplication: 0.4, // High duplication
-      };
-
-      const result = detector.detect(dimensions);
-
-      const maintPartition = result.partitions.find(p => p.type === 'maintainability');
-      expect(maintPartition).toBeDefined();
-      expect(maintPartition?.dimensions).toContain('maintainability');
-    });
-
-    it('should detect multiple partitions for widespread issues', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.3,
-        passRate: 0.4,
-        security: 0.3,
-        performance: 0.3,
-        maintainability: 0.2,
-        reliability: 0.3,
-      };
-
-      const result = detector.detect(dimensions);
-
-      // Should have multiple partitions across different groups
-      expect(result.partitionCount).toBeGreaterThan(0);
-    });
-
-    it('should calculate fragmentation score', () => {
-      const badDimensions: QualityDimensions = {
-        coverage: 0.3, // Well below 0.7 threshold
-        passRate: 0.3,
-        security: 0.3,
-        performance: 0.3,
-        maintainability: 0.3,
-        reliability: 0.3,
-      };
-
-      const result = detector.detect(badDimensions);
-
-      // With all dimensions below threshold, should have partitions
-      expect(result.partitionCount).toBeGreaterThanOrEqual(0);
-      // Fragmentation may be 0 if no partitions detected
-    });
-
-    it('should identify priority partition (most severe)', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.6,
-        passRate: 0.65,
-        security: 0.2, // Most severe
-        performance: 0.7,
-        maintainability: 0.6,
-        reliability: 0.65,
-      };
-
-      const result = detector.detect(dimensions);
-
-      expect(result.priorityPartition).toBeDefined();
-      expect(result.priorityPartition?.type).toBe('security');
-    });
-  });
-
-  describe('updateLambdaWithPartitions()', () => {
-    it('should update lambda with partition count', () => {
-      const lambda = calculateQualityLambda(DEGRADED_METRICS);
-      const originalPartitionCount = lambda.partitionCount;
-
-      const updated = detector.updateLambdaWithPartitions(lambda);
-
-      // May change if partitions detected
-      expect(updated.partitionCount).toBeDefined();
-    });
-  });
-
-  describe('getRemediationPlan()', () => {
-    it('should generate remediation plan for partitions', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.5,
-        passRate: 0.6,
-        security: 0.4,
-        performance: 0.8,
-        maintainability: 0.5,
-        reliability: 0.6,
-      };
-
-      const result = detector.detect(dimensions);
-      const plan = detector.getRemediationPlan(result.partitions);
-
-      expect(plan.steps.length).toBe(result.partitionCount);
-      expect(plan.estimatedTotalEffort).toBeGreaterThan(0);
-
-      for (const step of plan.steps) {
-        expect(step.actions.length).toBeGreaterThan(0);
-        expect(['critical', 'high', 'medium', 'low']).toContain(step.priority);
-      }
-    });
-
-    it('should sort steps by severity', () => {
-      const dimensions: QualityDimensions = {
-        coverage: 0.4, // Medium severity
-        passRate: 0.6,
-        security: 0.2, // High severity
-        performance: 0.6,
-        maintainability: 0.8,
-        reliability: 0.6,
-      };
-
-      const result = detector.detect(dimensions);
-      const plan = detector.getRemediationPlan(result.partitions);
-
-      if (plan.steps.length > 1) {
-        // First step should be higher or equal priority
-        const priorities = ['critical', 'high', 'medium', 'low'];
-        const firstPriority = priorities.indexOf(plan.steps[0].priority);
-        const secondPriority = priorities.indexOf(plan.steps[1].priority);
-        expect(firstPriority).toBeLessThanOrEqual(secondPriority);
-      }
-    });
-  });
-});
-
-describe('detectQualityPartitions (convenience function)', () => {
-  it('should detect partitions from dimensions', () => {
-    const dimensions: QualityDimensions = {
-      coverage: 0.5,
-      passRate: 0.6,
-      security: 0.9,
-      performance: 0.8,
-      maintainability: 0.7,
-      reliability: 0.6,
-    };
-
-    const result = detectQualityPartitions(dimensions);
-
-    expect(result).toBeDefined();
-    expect(Array.isArray(result.partitions)).toBe(true);
-  });
-});
-
-// ============================================================================
-// Integration Tests (End-to-End)
-// ============================================================================
-
-describe('Coherence Gate Integration', () => {
-  describe('evaluateCoherenceGate()', () => {
-    it('should perform full evaluation pipeline', () => {
-      // Use extra healthy metrics to ensure NORMAL
-      const extraHealthy: QualityMetricsInput = {
-        lineCoverage: 95,
-        testPassRate: 100,
-        criticalVulns: 0,
-        p95Latency: 50,
-        targetLatency: 200,
-        maintainabilityIndex: 95,
-        flakyTestRatio: 0,
-      };
-      const decision = evaluateCoherenceGate(extraHealthy);
-
-      expect(decision.tier).toBe(QualityTier.NORMAL);
-      expect(decision.decision).toBe('allow');
-      expect(decision.lambda).toBeDefined();
-    });
-
-    it('should detect issues and suggest actions', () => {
-      const decision = evaluateCoherenceGate(DEGRADED_METRICS);
-
-      if (decision.tier > QualityTier.NORMAL) {
-        expect(decision.actions.length).toBeGreaterThan(0);
-        expect(decision.explanation).toBeTruthy();
-      }
-    });
-  });
-
-  describe('canDeploy()', () => {
-    it('should allow deployment for healthy metrics', () => {
-      // Use extra healthy metrics
-      const extraHealthy: QualityMetricsInput = {
-        lineCoverage: 95,
-        testPassRate: 100,
-        criticalVulns: 0,
-        p95Latency: 50,
-        targetLatency: 200,
-        maintainabilityIndex: 95,
-        flakyTestRatio: 0,
-      };
-      expect(canDeploy(extraHealthy)).toBe(true);
-    });
-
-    it('should block deployment for failing metrics', () => {
-      expect(canDeploy(FAILING_METRICS)).toBe(false);
-    });
-  });
-
-  describe('getQualityTier()', () => {
-    it('should return tier 0 for healthy metrics', () => {
-      const extraHealthy: QualityMetricsInput = {
-        lineCoverage: 95,
-        testPassRate: 100,
-        criticalVulns: 0,
-        p95Latency: 50,
-        targetLatency: 200,
-        maintainabilityIndex: 95,
-        flakyTestRatio: 0,
-      };
-      expect(getQualityTier(extraHealthy)).toBe(QualityTier.NORMAL);
-    });
-
-    it('should return higher tier for degraded metrics', () => {
-      const tier = getQualityTier(DEGRADED_METRICS);
-      expect(tier).toBeGreaterThanOrEqual(QualityTier.REDUCED);
-    });
-  });
-
-  describe('getLambdaValue()', () => {
-    it('should return lambda as number', () => {
-      const lambda = getLambdaValue(HEALTHY_METRICS);
-
-      expect(typeof lambda).toBe('number');
-      expect(lambda).toBeGreaterThan(0);
-      expect(lambda).toBeLessThanOrEqual(100);
-    });
-  });
-
-  describe('getQualitySummary()', () => {
-    it('should return comprehensive summary', () => {
-      const summary = getQualitySummary(HEALTHY_METRICS);
-
-      expect(summary.lambda).toBeGreaterThan(0);
-      expect(summary.tier).toBeDefined();
-      expect(summary.decision).toBeDefined();
-      expect(summary.explanation).toBeTruthy();
-    });
-
-    it('should include remediation for issues', () => {
-      const summary = getQualitySummary(DEGRADED_METRICS);
-
-      if (summary.partitionCount > 0) {
-        expect(summary.topIssue).toBeDefined();
-        expect(summary.topRemediation).toBeDefined();
-      }
-    });
-  });
-});
-
-// ============================================================================
-// Edge Cases and Error Handling
-// ============================================================================
-
-describe('Edge Cases', () => {
-  describe('extreme values', () => {
-    it('should handle 0% coverage', () => {
-      const metrics: QualityMetricsInput = {
-        ...HEALTHY_METRICS,
-        lineCoverage: 0,
-      };
-
-      const decision = evaluateCoherenceGate(metrics);
-      expect(decision.tier).toBe(QualityTier.QUARANTINE);
-    });
-
-    it('should handle 100% everything', () => {
-      const metrics: QualityMetricsInput = {
-        lineCoverage: 100,
-        testPassRate: 100,
-        criticalVulns: 0,
-        p95Latency: 50,
-        targetLatency: 200,
-        maintainabilityIndex: 100,
-        flakyTestRatio: 0,
-      };
-
-      const lambda = calculateQualityLambda(metrics);
-      // All metrics at max should give high lambda
-      expect(lambda.lambda).toBeGreaterThanOrEqual(90);
-    });
-
-    it('should handle very high vulnerability count', () => {
-      const metrics: QualityMetricsInput = {
-        ...HEALTHY_METRICS,
-        criticalVulns: 100,
-      };
-
-      const decision = evaluateCoherenceGate(metrics);
-      // High vulns cause lambda to drop, triggering quarantine
-      expect(decision.tier).toBe(QualityTier.QUARANTINE);
-    });
-  });
-
-  describe('boundary conditions', () => {
-    it('should handle metrics exactly at threshold', () => {
-      const metrics: QualityMetricsInput = {
-        lineCoverage: 70,
-        testPassRate: 70,
-        criticalVulns: 0,
-        p95Latency: 200,
-        targetLatency: 200,
-        maintainabilityIndex: 70,
-      };
-
-      const lambda = calculateQualityLambda(metrics);
-      expect(lambda.boundaryEdges).toBeGreaterThan(0);
-    });
-
-    it('should detect lambda exactly at lambdaMin', () => {
-      const controller = createCoherenceGateController({
-        policy: { ...DEFAULT_COHERENCE_GATE_POLICY, lambdaMin: 60 },
-      });
-
-      const lambda = calculateQualityLambda(HEALTHY_METRICS);
-      lambda.lambda = 61; // Just above threshold
-
-      const decision = controller.evaluate(lambda);
-      // At or above threshold could pass if no other issues
-      expect(decision.tier).toBeLessThanOrEqual(QualityTier.REDUCED);
-    });
-  });
-
-  describe('Q15 calculations', () => {
-    it('should calculate drop ratio correctly', () => {
-      const calculator = createLambdaCalculator();
-      const metrics = { ...DEGRADED_METRICS, previousLambda: 100 };
-      const lambda = calculator.calculate(metrics);
-
-      const dropRatio = calculator.calculateDropRatioQ15(lambda);
-      // Drop ratio should be significant
-      expect(dropRatio).toBeGreaterThan(0);
-      expect(dropRatio).toBeLessThanOrEqual(32767);
-    });
-
-    it('should handle zero previous lambda', () => {
-      const calculator = createLambdaCalculator();
-      const lambda = calculator.calculate(HEALTHY_METRICS);
-      lambda.lambdaPrev = 0;
-
-      const dropRatio = calculator.calculateDropRatioQ15(lambda);
-      expect(dropRatio).toBe(0);
-    });
-  });
-});
-
-// ============================================================================
-// Performance Tests
-// ============================================================================
-
-describe('Performance', () => {
-  it('should calculate lambda in under 10ms', () => {
-    const start = performance.now();
-
-    for (let i = 0; i < 100; i++) {
-      calculateQualityLambda(HEALTHY_METRICS);
-    }
-
-    const elapsed = performance.now() - start;
-    const avgTime = elapsed / 100;
-
-    expect(avgTime).toBeLessThan(10);
-  });
-
-  it('should evaluate gate in under 10ms', () => {
-    const lambda = calculateQualityLambda(HEALTHY_METRICS);
-    const controller = createCoherenceGateController();
-
-    const start = performance.now();
-
-    for (let i = 0; i < 100; i++) {
-      controller.evaluate(lambda);
-    }
-
-    const elapsed = performance.now() - start;
-    const avgTime = elapsed / 100;
-
-    expect(avgTime).toBeLessThan(10);
-  });
-
-  it('should complete full evaluation in under 20ms', () => {
-    const start = performance.now();
-
-    for (let i = 0; i < 50; i++) {
-      evaluateCoherenceGate(HEALTHY_METRICS);
-    }
-
-    const elapsed = performance.now() - start;
-    const avgTime = elapsed / 50;
-
-    expect(avgTime).toBeLessThan(20);
-  });
-});
-
-// ============================================================================
-// 4-Tier Decision Tests
-// ============================================================================
-
-describe('4-Tier Response System', () => {
-  it('should return correct actions for each tier', () => {
-    const controller = createCoherenceGateController();
-
-    // Tier 0: Normal - use explicitly healthy metrics
-    const healthyMetrics: QualityMetricsInput = {
-      lineCoverage: 95,
-      testPassRate: 100,
-      criticalVulns: 0,
-      p95Latency: 50,
-      targetLatency: 200,
-      maintainabilityIndex: 95,
-      flakyTestRatio: 0,
-    };
-    const normalLambda = calculateQualityLambda(healthyMetrics);
-    const normalDecision = controller.evaluate(normalLambda);
-    expect(normalDecision.tier).toBe(QualityTier.NORMAL);
-    expect(normalDecision.actions).toHaveLength(0);
-
-    // Tier 3: Quarantine
-    const quarantineLambda = calculateQualityLambda(CRITICAL_SECURITY_METRICS);
-    const quarantineDecision = controller.evaluate(quarantineLambda);
-    expect(quarantineDecision.tier).toBe(QualityTier.QUARANTINE);
-    expect(quarantineDecision.actions).toContain('blockAllDeploys');
-    expect(quarantineDecision.actions).toContain('escalateToLeads');
-  });
-
-  it('should set correct overridable flag', () => {
-    const controller = createCoherenceGateController();
-
-    // Use explicitly healthy metrics
-    const healthyMetrics: QualityMetricsInput = {
-      lineCoverage: 95,
-      testPassRate: 100,
-      criticalVulns: 0,
-      p95Latency: 50,
-      targetLatency: 200,
-      maintainabilityIndex: 95,
-      flakyTestRatio: 0,
-    };
-    const normalLambda = calculateQualityLambda(healthyMetrics);
-    const normalDecision = controller.evaluate(normalLambda);
-    expect(normalDecision.overridable).toBe(true);
-
-    const quarantineLambda = calculateQualityLambda(CRITICAL_SECURITY_METRICS);
-    const quarantineDecision = controller.evaluate(quarantineLambda);
-    expect(quarantineDecision.overridable).toBe(false);
-  });
-
-  it('should include confidence score', () => {
-    const controller = createCoherenceGateController();
-
-    const lambda = calculateQualityLambda(HEALTHY_METRICS);
-    const decision = controller.evaluate(lambda);
-
-    expect(decision.confidence).toBeGreaterThanOrEqual(0.5);
-    expect(decision.confidence).toBeLessThanOrEqual(1.0);
-  });
-});