@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/unit/agents/test_synthesis_fixes.py

@@ -1,761 +0,0 @@
-"""Unit tests for Synthesis Agent fixes (FR-6).
-
-Tests for Task 4 of audit-llm-analysis-refinement spec:
-- 4.1 _elevate_critical_findings() method
-- 4.2 _generate_coherent_recommendations() method
-- 4.3 _deduplicate_findings() method (via _dedupe_items)
-- 4.4 Synthesis output generation coherence
-- 4.5 Edge cases and comprehensive coverage
-
-Requirements validated:
-- FR-6.1: CRITICAL severity → always add to critical_gaps
-- FR-6.2: HIGH severity with score < 40 → add to critical_gaps
-- FR-6.3: Recommendation coherence with score ranges
-"""
-
-from unittest.mock import MagicMock
-
-import pytest
-from vds_audit_orchestrator.agents.base import AgentResult
-from vds_audit_orchestrator.agents.synthesis_agent import SynthesisAgent
-
-
-@pytest.fixture
-def synthesis_agent():
-    """Create a SynthesisAgent with LLM disabled for deterministic testing."""
-    return SynthesisAgent(settings=MagicMock(enabled=False))
-
-
-# =============================================================================
-# Task 4.1: Test _elevate_critical_findings() method (FR-6.1, FR-6.2)
-# =============================================================================
-
-
-class TestElevateCriticalFindings:
-    """Tests for _elevate_critical_findings() method."""
-
-    def test_critical_severity_always_elevated(self, synthesis_agent):
-        """FR-6.1: CRITICAL severity findings are always elevated regardless of score."""
-        findings = [
-            {"type": "security_vulnerability", "severity": "critical", "title": "Critical Issue 1"},
-            {"type": "security_vulnerability", "severity": "critical", "title": "Critical Issue 2"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Test with high score (80) - critical should still be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=80.0)
-
-        assert len(elevated) == 2
-        titles = {f["title"] for f in elevated}
-        assert "Critical Issue 1" in titles
-        assert "Critical Issue 2" in titles
-
-    def test_high_severity_elevated_when_score_below_40(self, synthesis_agent):
-        """FR-6.2: HIGH severity findings elevated when score < 40."""
-        findings = [
-            {"type": "security_risk", "severity": "high", "title": "High Issue 1"},
-            {"type": "code_quality", "severity": "high", "title": "High Issue 2"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Test with low score (30) - high should be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-
-        assert len(elevated) == 2
-        titles = {f["title"] for f in elevated}
-        assert "High Issue 1" in titles
-        assert "High Issue 2" in titles
-
-    def test_high_severity_not_elevated_when_score_above_40(self, synthesis_agent):
-        """FR-6.2: HIGH severity findings NOT elevated when score >= 40."""
-        findings = [
-            {"type": "security_risk", "severity": "high", "title": "High Issue 1"},
-            {"type": "code_quality", "severity": "high", "title": "High Issue 2"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Test with score at boundary (40) - high should NOT be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=40.0)
-        assert len(elevated) == 0
-
-        # Test with high score (80) - high should NOT be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=80.0)
-        assert len(elevated) == 0
-
-    def test_mixed_severity_elevation(self, synthesis_agent):
-        """Test elevation with mixed severity findings."""
-        findings = [
-            {"type": "security_vulnerability", "severity": "critical", "title": "Crit 1"},
-            {"type": "security_risk", "severity": "high", "title": "High 1"},
-            {"type": "code_issue", "severity": "high", "title": "High 2"},
-            {"type": "style", "severity": "medium", "title": "Med 1"},
-            {"type": "info", "severity": "low", "title": "Low 1"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Low score (30) -> Critical + High elevated
-        elevated_low = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-        titles_low = {f["title"] for f in elevated_low}
-        assert "Crit 1" in titles_low
-        assert "High 1" in titles_low
-        assert "High 2" in titles_low
-        assert "Med 1" not in titles_low
-        assert "Low 1" not in titles_low
-
-        # High score (80) -> Only Critical elevated
-        elevated_high = synthesis_agent._elevate_critical_findings(prioritized, overall_score=80.0)
-        titles_high = {f["title"] for f in elevated_high}
-        assert "Crit 1" in titles_high
-        assert "High 1" not in titles_high
-        assert "High 2" not in titles_high
-
-    def test_source_agent_tracking(self, synthesis_agent):
-        """Test that finding source (agent name) is tracked for auditability."""
-        findings = [
-            {
-                "type": "security_vulnerability",
-                "severity": "critical",
-                "title": "Critical Issue",
-                "source_agent": "SecurityAgent",
-            },
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=50.0)
-
-        assert len(elevated) == 1
-        assert elevated[0]["source_agent"] == "SecurityAgent"
-        assert "elevated_reason" in elevated[0]
-        assert elevated[0]["elevated_reason"] == "critical_severity"
-
-    def test_elevated_reason_tracking(self, synthesis_agent):
-        """Test that elevation reason is tracked correctly."""
-        findings = [
-            {"type": "security_vulnerability", "severity": "critical", "title": "Crit 1"},
-            {"type": "security_risk", "severity": "high", "title": "High 1"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-
-        crit_finding = next(f for f in elevated if f["title"] == "Crit 1")
-        high_finding = next(f for f in elevated if f["title"] == "High 1")
-
-        assert crit_finding["elevated_reason"] == "critical_severity"
-        assert high_finding["elevated_reason"] == "high_with_low_score"
-
-    def test_limit_to_top_10(self, synthesis_agent):
-        """Test that critical_gaps is limited to top 10 by severity + impact."""
-        # Create 15 critical findings
-        findings = [
-            {"type": "security_vulnerability", "severity": "critical", "title": f"Critical Issue {i}"}
-            for i in range(15)
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=50.0)
-
-        assert len(elevated) == 10
-
-    def test_elevation_deduplicates_identical_findings(self, synthesis_agent):
-        """Identical findings should collapse into a single elevated critical gap."""
-        findings = [
-            {
-                "type": "security_sql_string_concat",
-                "severity": "high",
-                "title": "SQL concat risk",
-                "location": "src/a.py:10",
-                "source_agent": "code",
-            },
-            {
-                "type": "security_sql_string_concat",
-                "severity": "high",
-                "title": "SQL concat risk",
-                "location": "src/a.py:10",
-                "source_agent": "code",
-            },
-            {
-                "type": "security_sql_string_concat",
-                "severity": "high",
-                "title": "SQL concat risk",
-                "location": "src/a.py:10",
-                "source_agent": "security",
-            },
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-
-        assert len(elevated) == 1
-        assert elevated[0]["title"] == "SQL concat risk"
-        assert elevated[0]["source_agent"] == "code"
-        assert elevated[0]["source_agents"] == ["code", "security"]
-
-    def test_elevation_deduplicates_prefixed_duplicate_titles(self, synthesis_agent):
-        """Prefix variants from different agents should still dedupe as one issue."""
-        findings = [
-            {
-                "type": "security_sql_string_concat",
-                "severity": "high",
-                "title": "Potential SQL injection via string concatenation",
-                "location": "src/a.py:10",
-                "source_agent": "security",
-            },
-            {
-                "type": "security_sql_string_concat",
-                "severity": "high",
-                "title": "Potential security issue: Potential SQL injection via string concatenation",
-                "location": "src/a.py:10",
-                "source_agent": "code",
-            },
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-
-        assert len(elevated) == 1
-        assert elevated[0]["source_agents"] == ["code", "security"]
-
-    def test_elevation_keeps_distinct_issues_same_location(self, synthesis_agent):
-        """Different issue titles at same location should remain separate."""
-        findings = [
-            {
-                "type": "security",
-                "severity": "high",
-                "title": "Java 8 is outdated",
-                "location": "pom.xml",
-                "source_agent": "code",
-            },
-            {
-                "type": "security",
-                "severity": "high",
-                "title": "Keycloak version is outdated",
-                "location": "pom.xml",
-                "source_agent": "code",
-            },
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-
-        assert len(elevated) == 2
-
-    def test_empty_findings(self, synthesis_agent):
-        """Test elevation with no findings."""
-        elevated = synthesis_agent._elevate_critical_findings([], overall_score=50.0)
-        assert len(elevated) == 0
-
-    def test_no_critical_or_high_findings(self, synthesis_agent):
-        """Test elevation when no critical or high severity findings exist."""
-        findings = [
-            {"type": "style", "severity": "medium", "title": "Med 1"},
-            {"type": "info", "severity": "low", "title": "Low 1"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=30.0)
-        assert len(elevated) == 0
-
-
-# =============================================================================
-# Task 4.2: Test _generate_coherent_recommendations() method (FR-6.3)
-# =============================================================================
-
-
-class TestGenerateCoherentRecommendations:
-    """Tests for _generate_coherent_recommendations() method."""
-
-    def test_critical_score_range_0_to_30(self, synthesis_agent):
-        """FR-6.3: Score 0-30 should generate CRITICAL prefix recommendations."""
-        gaps = [{"type": "security_vulnerability", "title": "Security Gap"}]
-
-        # Test at score 0
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(0.0, gaps)
-        assert prefix == "CRITICAL"
-        assert any("CRITICAL" in r["title"] for r in recs)
-        assert any(r["priority"] == "critical" for r in recs)
-
-        # Test at score 15
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(15.0, gaps)
-        assert prefix == "CRITICAL"
-
-        # Test at score 30
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(30.0, gaps)
-        assert prefix == "CRITICAL"
-
-    def test_high_priority_score_range_31_to_50(self, synthesis_agent):
-        """FR-6.3: Score 31-50 should generate HIGH PRIORITY prefix recommendations."""
-        gaps = [{"type": "security_vulnerability", "title": "Security Gap"}]
-
-        # Test at score 31
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(31.0, gaps)
-        assert prefix == "HIGH PRIORITY"
-        assert any("HIGH PRIORITY" in r["title"] for r in recs)
-        assert any(r["priority"] == "high" for r in recs)
-
-        # Test at score 40
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(40.0, gaps)
-        assert prefix == "HIGH PRIORITY"
-
-        # Test at score 50
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(50.0, gaps)
-        assert prefix == "HIGH PRIORITY"
-
-    def test_medium_score_range_51_to_70(self, synthesis_agent):
-        """FR-6.3: Score 51-70 should generate MEDIUM prefix recommendations."""
-        gaps = [{"type": "technical_debt", "title": "Tech Debt Gap"}]
-
-        # Test at score 51
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(51.0, gaps)
-        assert prefix == "MEDIUM"
-        assert any("MEDIUM" in r["title"] for r in recs)
-        assert any(r["priority"] == "medium" for r in recs)
-
-        # Test at score 60
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(60.0, gaps)
-        assert prefix == "MEDIUM"
-
-        # Test at score 70
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(70.0, gaps)
-        assert prefix == "MEDIUM"
-
-    def test_maintenance_score_range_71_to_100(self, synthesis_agent):
-        """FR-6.3: Score 71-100 should generate MAINTENANCE prefix recommendations."""
-        gaps = [{"type": "doc_quality", "title": "Doc Gap"}]
-
-        # Test at score 71
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(71.0, gaps)
-        assert prefix == "MAINTENANCE"
-        assert any("MAINTENANCE" in r["title"] for r in recs)
-        assert any(r["priority"] == "low" for r in recs)
-
-        # Test at score 85
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(85.0, gaps)
-        assert prefix == "MAINTENANCE"
-
-        # Test at score 100
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(100.0, gaps)
-        assert prefix == "MAINTENANCE"
-
-    def test_security_gap_generates_security_recommendation(self, synthesis_agent):
-        """Test that security gaps generate security-category recommendations."""
-        gaps = [{"type": "security_vulnerability", "title": "SQL Injection"}]
-
-        _prefix, recs = synthesis_agent._generate_coherent_recommendations(20.0, gaps)
-
-        security_recs = [r for r in recs if r.get("category") == "security"]
-        assert len(security_recs) >= 1
-        assert "security" in security_recs[0]["description"].lower()
-
-    def test_technical_debt_gap_generates_code_recommendation(self, synthesis_agent):
-        """Test that technical debt gaps generate code-category recommendations."""
-        gaps = [{"type": "technical_debt", "title": "Complex Function"}]
-
-        _prefix, recs = synthesis_agent._generate_coherent_recommendations(20.0, gaps)
-
-        code_recs = [r for r in recs if r.get("category") == "code"]
-        assert len(code_recs) >= 1
-
-    def test_doc_gap_generates_docs_recommendation(self, synthesis_agent):
-        """Test that documentation gaps generate docs-category recommendations."""
-        gaps = [{"type": "doc_quality", "title": "Missing README"}]
-
-        _prefix, recs = synthesis_agent._generate_coherent_recommendations(20.0, gaps)
-
-        docs_recs = [r for r in recs if r.get("category") == "docs"]
-        assert len(docs_recs) >= 1
-
-    def test_empty_gaps_returns_empty_recommendations(self, synthesis_agent):
-        """Test that empty gaps list returns empty recommendations."""
-        prefix, recs = synthesis_agent._generate_coherent_recommendations(50.0, [])
-
-        # Prefix should still be determined by score
-        assert prefix == "HIGH PRIORITY"
-        # But no recommendations generated without gaps
-        assert len(recs) == 0
-
-    def test_effort_varies_with_score(self, synthesis_agent):
-        """Test that effort level varies based on score severity."""
-        gaps = [{"type": "security_vulnerability", "title": "Security Gap"}]
-
-        # Low score -> high effort
-        _, recs_low = synthesis_agent._generate_coherent_recommendations(20.0, gaps)
-        security_rec_low = next((r for r in recs_low if r.get("category") == "security"), None)
-        if security_rec_low:
-            assert security_rec_low["effort"] == "high"
-
-        # High score -> medium effort
-        _, recs_high = synthesis_agent._generate_coherent_recommendations(80.0, gaps)
-        security_rec_high = next((r for r in recs_high if r.get("category") == "security"), None)
-        if security_rec_high:
-            assert security_rec_high["effort"] == "medium"
-
-
-# =============================================================================
-# Task 4.3: Test _deduplicate_findings() method (via _dedupe_items)
-# =============================================================================
-
-
-class TestDeduplicateFindings:
-    """Tests for finding deduplication logic via _dedupe_items()."""
-
-    def test_basic_deduplication(self, synthesis_agent):
-        """Test basic deduplication of identical findings."""
-        findings = [
-            {"type": "sec", "location": "a.py", "title": "Issue A"},
-            {"type": "sec", "location": "a.py", "title": "Issue A"},  # Duplicate
-            {"type": "sec", "location": "b.py", "title": "Issue B"},
-        ]
-
-        def _key(x):
-            return (x["type"], x["location"], x["title"])
-
-        deduped = synthesis_agent._dedupe_items(findings, _key, "test")
-
-        assert len(deduped) == 2
-        titles = [f["title"] for f in deduped]
-        assert "Issue A" in titles
-        assert "Issue B" in titles
-
-    def test_preserves_order(self, synthesis_agent):
-        """Test that deduplication preserves original order."""
-        findings = [
-            {"type": "a", "location": "1.py", "title": "First"},
-            {"type": "b", "location": "2.py", "title": "Second"},
-            {"type": "a", "location": "1.py", "title": "First"},  # Duplicate
-            {"type": "c", "location": "3.py", "title": "Third"},
-        ]
-
-        def _key(x):
-            return (x["type"], x["location"], x["title"])
-
-        deduped = synthesis_agent._dedupe_items(findings, _key, "test")
-
-        assert len(deduped) == 3
-        assert deduped[0]["title"] == "First"
-        assert deduped[1]["title"] == "Second"
-        assert deduped[2]["title"] == "Third"
-
-    def test_different_locations_not_deduplicated(self, synthesis_agent):
-        """Test that same type/title but different locations are not deduplicated."""
-        findings = [
-            {"type": "sec", "location": "a.py", "title": "Issue"},
-            {"type": "sec", "location": "b.py", "title": "Issue"},  # Different location
-        ]
-
-        def _key(x):
-            return (x["type"], x["location"], x["title"])
-
-        deduped = synthesis_agent._dedupe_items(findings, _key, "test")
-
-        assert len(deduped) == 2
-
-    def test_empty_list(self, synthesis_agent):
-        """Test deduplication of empty list."""
-
-        def _key(x):
-            return (x.get("type"),)
-
-        deduped = synthesis_agent._dedupe_items([], _key, "test")
-        assert len(deduped) == 0
-
-    def test_single_item(self, synthesis_agent):
-        """Test deduplication of single item list."""
-        findings = [{"type": "sec", "location": "a.py", "title": "Issue"}]
-
-        def _key(x):
-            return (x["type"], x["location"], x["title"])
-
-        deduped = synthesis_agent._dedupe_items(findings, _key, "test")
-        assert len(deduped) == 1
-
-    def test_all_duplicates(self, synthesis_agent):
-        """Test deduplication when all items are duplicates."""
-        findings = [
-            {"type": "sec", "location": "a.py", "title": "Issue"},
-            {"type": "sec", "location": "a.py", "title": "Issue"},
-            {"type": "sec", "location": "a.py", "title": "Issue"},
-        ]
-
-        def _key(x):
-            return (x["type"], x["location"], x["title"])
-
-        deduped = synthesis_agent._dedupe_items(findings, _key, "test")
-        assert len(deduped) == 1
-
-
-# =============================================================================
-# Task 4.4: Test synthesis output generation coherence
-# =============================================================================
-
-
-class TestSynthesisCoherence:
-    """Tests for _validate_synthesis_coherence() method."""
-
-    def test_low_score_with_positive_summary_detected(self, synthesis_agent):
-        """Test that low score with positive summary is flagged as incoherent."""
-        # Low score should not have "continue current practices" type language
-        result = synthesis_agent._validate_synthesis_coherence(
-            score=20.0,
-            critical_gaps=[{"type": "sec", "title": "Gap 1"}],
-            recommendations=[],
-            executive_summary="The project is well positioned and should continue current practices.",
-        )
-
-        # Should return False (incoherent)
-        assert result is False
-
-    def test_low_score_with_appropriate_summary_passes(self, synthesis_agent):
-        """Test that low score with appropriate summary passes coherence check."""
-        result = synthesis_agent._validate_synthesis_coherence(
-            score=20.0,
-            critical_gaps=[{"type": "sec", "title": "Gap 1"}],
-            recommendations=[],
-            executive_summary="The project has critical issues that require immediate attention.",
-        )
-
-        # Should return True (coherent)
-        assert result is True
-
-    def test_high_score_with_any_summary_passes(self, synthesis_agent):
-        """Test that high score passes coherence check regardless of summary."""
-        result = synthesis_agent._validate_synthesis_coherence(
-            score=80.0,
-            critical_gaps=[],
-            recommendations=[],
-            executive_summary="The project is well positioned and should continue current practices.",
-        )
-
-        # Should return True (coherent)
-        assert result is True
-
-    def test_many_gaps_warning_logged(self, synthesis_agent):
-        """Test that many critical gaps without 'critical' mention logs warning."""
-        # This is a warning, not a failure
-        result = synthesis_agent._validate_synthesis_coherence(
-            score=30.0,
-            critical_gaps=[{"type": "sec", "title": f"Gap {i}"} for i in range(6)],
-            recommendations=[],
-            executive_summary="The project has some issues to address.",
-        )
-
-        # Should still return True (warning only, not failure)
-        # The actual warning is logged but doesn't affect return value
-        assert result is True
-
-    def test_template_summary_low_score_without_gaps_avoids_positive_default(self, synthesis_agent):
-        """Low-score template fallback should not emit positive default guidance."""
-        summary = synthesis_agent._get_template_summary(
-            repository="repo-a",
-            overall_score=35.0,
-            maturity_level="critical",
-            critical_gaps=[],
-            aligned_practices=[],
-        )
-
-        assert "Continue current practices while monitoring for issues." not in summary
-        assert "Investigate low-score drivers" in summary
-
-    def test_template_summary_high_score_without_gaps_keeps_positive_default(self, synthesis_agent):
-        """High-score template fallback keeps maintenance guidance."""
-        summary = synthesis_agent._get_template_summary(
-            repository="repo-a",
-            overall_score=86.0,
-            maturity_level="optimized",
-            critical_gaps=[],
-            aligned_practices=[],
-        )
-
-        assert "Continue current practices while monitoring for issues." in summary
-
-
-class TestAlignedPractices:
-    """Tests for aligned practices extraction correctness."""
-
-    def test_not_aligned_when_explicit_critical_severity_present(self, synthesis_agent):
-        """Findings with explicit critical/high severity must not be reported as aligned."""
-        agent_results = [
-            AgentResult(
-                agent_name="CodeAnalysisAgent",
-                success=True,
-                findings=[
-                    {
-                        "type": "security_code",
-                        "severity": "critical",
-                        "title": "Hardcoded password",
-                    }
-                ],
-            )
-        ]
-        aligned = synthesis_agent._extract_aligned_practices(agent_results)
-        assert aligned == []
-
-    def test_aligned_when_only_medium_or_low_findings(self, synthesis_agent):
-        """Agents with only medium/low findings should be marked aligned."""
-        agent_results = [
-            AgentResult(
-                agent_name="DocumentationAgent",
-                success=True,
-                findings=[
-                    {"type": "doc_quality", "severity": "medium", "title": "Minor formatting issue"},
-                    {"type": "doc_quality", "severity": "low", "title": "Typo"},
-                ],
-            )
-        ]
-        aligned = synthesis_agent._extract_aligned_practices(agent_results)
-        assert len(aligned) == 1
-        assert aligned[0]["domain"] == "Documentation"
-
-
-# =============================================================================
-# Task 4.5: Edge cases and comprehensive coverage
-# =============================================================================
-
-
-class TestEdgeCases:
-    """Edge case tests for synthesis fixes."""
-
-    def test_all_critical_findings(self, synthesis_agent):
-        """Test synthesis with all critical findings."""
-        findings = [
-            {"type": "security_vulnerability", "severity": "critical", "title": f"Critical {i}"} for i in range(5)
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=10.0)
-
-        assert len(elevated) == 5
-        assert all(f["severity"] == "critical" for f in elevated)
-
-    def test_boundary_score_39(self, synthesis_agent):
-        """Test HIGH elevation at boundary score 39 (just below 40)."""
-        findings = [
-            {"type": "security_risk", "severity": "high", "title": "High Issue"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Score 39 is < 40, so HIGH should be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=39.0)
-        assert len(elevated) == 1
-
-    def test_boundary_score_40(self, synthesis_agent):
-        """Test HIGH elevation at boundary score 40 (exactly 40)."""
-        findings = [
-            {"type": "security_risk", "severity": "high", "title": "High Issue"},
-        ]
-        prioritized = synthesis_agent._prioritize_findings(findings)
-
-        # Score 40 is NOT < 40, so HIGH should NOT be elevated
-        elevated = synthesis_agent._elevate_critical_findings(prioritized, overall_score=40.0)
-        assert len(elevated) == 0
-
-    def test_recommendation_score_boundaries(self, synthesis_agent):
-        """Test recommendation prefix at exact score boundaries."""
-        gaps = [{"type": "security_vulnerability", "title": "Gap"}]
-
-        # Boundary: 30 -> CRITICAL
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(30.0, gaps)
-        assert prefix == "CRITICAL"
-
-        # Boundary: 31 -> HIGH PRIORITY
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(31.0, gaps)
-        assert prefix == "HIGH PRIORITY"
-
-        # Boundary: 50 -> HIGH PRIORITY
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(50.0, gaps)
-        assert prefix == "HIGH PRIORITY"
-
-        # Boundary: 51 -> MEDIUM
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(51.0, gaps)
-        assert prefix == "MEDIUM"
-
-        # Boundary: 70 -> MEDIUM
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(70.0, gaps)
-        assert prefix == "MEDIUM"
-
-        # Boundary: 71 -> MAINTENANCE
-        prefix, _ = synthesis_agent._generate_coherent_recommendations(71.0, gaps)
-        assert prefix == "MAINTENANCE"
-
-    def test_mixed_gap_types(self, synthesis_agent):
-        """Test recommendations with mixed gap types."""
-        gaps = [
-            {"type": "security_vulnerability", "title": "Security Gap"},
-            {"type": "technical_debt", "title": "Tech Debt Gap"},
-            {"type": "doc_quality", "title": "Doc Gap"},
-        ]
-
-        _prefix, recs = synthesis_agent._generate_coherent_recommendations(20.0, gaps)
-
-        # Should have recommendations for all categories
-        categories = {r.get("category") for r in recs}
-        assert "security" in categories
-        assert "code" in categories
-        assert "docs" in categories
-
-    def test_normalize_severity_handles_various_formats(self, synthesis_agent):
-        """Test that severity normalization handles various input formats."""
-        # Test with uppercase
-        finding_upper = {"severity": "CRITICAL", "type": "test"}
-        assert synthesis_agent._normalize_severity(finding_upper) == "critical"
-
-        # Test with mixed case
-        finding_mixed = {"severity": "High", "type": "test"}
-        assert synthesis_agent._normalize_severity(finding_mixed) == "high"
-
-        # Test with whitespace
-        finding_whitespace = {"severity": "  medium  ", "type": "test"}
-        assert synthesis_agent._normalize_severity(finding_whitespace) == "medium"
-
-        # Test with missing severity (falls back to type mapping)
-        finding_no_severity = {"type": "security_vulnerability"}
-        assert synthesis_agent._normalize_severity(finding_no_severity) == "critical"
-
-    @pytest.mark.asyncio
-    async def test_full_synthesis_flow_with_fixes(self, synthesis_agent):
-        """Integration test: full synthesis flow with FR-6 fixes applied."""
-        agent_results = [
-            AgentResult(
-                agent_name="SecurityAgent",
-                success=True,
-                findings=[
-                    {
-                        "type": "security_vulnerability",
-                        "severity": "critical",
-                        "title": "SQL Injection",
-                        "location": "src/db.py",
-                        "source_agent": "SecurityAgent",
-                    },
-                    {
-                        "type": "security_risk",
-                        "severity": "high",
-                        "title": "Weak Password Policy",
-                        "location": "src/auth.py",
-                        "source_agent": "SecurityAgent",
-                    },
-                ],
-            ),
-            AgentResult(
-                agent_name="CodeAnalysisAgent",
-                success=True,
-                findings=[
-                    {
-                        "type": "technical_debt",
-                        "severity": "medium",
-                        "title": "Complex Function",
-                        "location": "src/utils.py",
-                        "source_agent": "CodeAnalysisAgent",
-                    },
-                ],
-            ),
-        ]
-
-        synthesis = await synthesis_agent.synthesize("test-repo", agent_results)
-
-        # Verify critical gaps include elevated findings
-        assert len(synthesis.gaps) >= 1
-
-        # Verify recommendations are coherent with score
-        # With critical findings, score should be low
-        assert synthesis.overall_score < 100
-
-        # Verify executive summary exists
-        assert synthesis.executive_summary is not None
-        assert len(synthesis.executive_summary) > 0