@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/audit_orchestrator/tests/test_agents/test_security_agent.py

@@ -1,2069 +0,0 @@
-"""Tests for SecurityAgent."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from tempfile import TemporaryDirectory
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from vds_agent_core.config import LLMProtocolType
-from vds_audit_orchestrator.agents.pydantic_base import SecurityFindings, Vulnerability
-from vds_audit_orchestrator.agents.security_agent import (
-    SecurityAgent,
-)
-from vds_audit_orchestrator.agents.security_scanner import SECURITY_PATTERNS
-from vds_audit_orchestrator.llm.provider import LLMSettings
-from vds_audit_orchestrator.models.evidence import Evidence, EvidenceBundle, EvidenceStatus
-
-
-@pytest.fixture
-def mock_evidence_bundle():
-    """Create a mock evidence bundle with security data."""
-    return EvidenceBundle(
-        repository="test-repo",
-        git_evidence=[
-            Evidence(
-                source="git_file",
-                source_id="security-config.yaml",
-                title="Security Config",
-                content="enable_auth: true\nallow_anonymous: false",
-                content_hash="hash1",
-                status=EvidenceStatus.FOUND,
-            ),
-            Evidence(
-                source="git_file",
-                source_id="src/unsafe.py",
-                title="Unsafe Code",
-                content="eval(user_input)",
-                content_hash="hash2",
-                status=EvidenceStatus.FOUND,
-            ),
-        ],
-        sonarqube_evidence=[
-            Evidence(
-                source="sonarqube_metric",
-                source_id="test-repo",
-                title="Quality Gate",
-                content=json.dumps(
-                    {
-                        "issues": [
-                            {
-                                "key": "issue-1",
-                                "severity": "CRITICAL",
-                                "message": "Hardcoded password in configuration",
-                                "component": "src/config.py",
-                                "rule": "security:S123",
-                            }
-                        ]
-                    }
-                ),
-                content_hash="hash3",
-                status=EvidenceStatus.FOUND,
-            )
-        ],
-    )
-
-
-@pytest.mark.asyncio
-async def test_tool_usage_logged_in_metadata(monkeypatch, mock_evidence_bundle):
-    """Ensure pattern scanner usage is recorded in security metadata."""
-    # Create a temporary directory to act as repo_path
-    with TemporaryDirectory() as tmpdir:
-        # Create a test file with security pattern
-        test_file = Path(tmpdir) / "test.py"
-        test_file.write_text("password = 'supersecret123'")
-
-        agent = SecurityAgent(settings=LLMSettings(enabled=False))
-        # Pass repo_path via profile
-        result = await agent.analyze(mock_evidence_bundle, profile={"repo_path": tmpdir})
-
-        assert result.success is True
-        # Check that pattern scanner was used
-        assert (
-            result.metadata.get("pattern_scanner_used") is True
-            or result.metadata.get("pattern_scanner_skipped") is not None
-        )
-
-
-class TestSecurityAgent:
-    """Tests for SecurityAgent."""
-
-    @pytest.mark.asyncio
-    async def test_analyze_bundle_missing(self):
-        """Test handling of missing evidence bundle."""
-        agent = SecurityAgent()
-        result = await agent.analyze({})
-        assert result.success is False
-        assert result.error and "Evidence bundle missing" in result.error
-
-    @pytest.mark.asyncio
-    async def test_analyze_sonarqube(self, mock_evidence_bundle):
-        """Test parsing of SonarQube evidence."""
-        # Ensure no LLM needed for this part
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check SonarQube findings
-        sq_findings = [f for f in findings if f.get("source") == "sonarqube"]
-        assert len(sq_findings) >= 1
-        assert sq_findings[0]["type"] == "sonarqube_vulnerability"
-        assert "Hardcoded password" in sq_findings[0]["description"]
-        assert "Hardcoded password" in sq_findings[0]["description"]
-
-    @pytest.mark.asyncio
-    async def test_analyze_patterns_scanner(self, mock_evidence_bundle):
-        """Test security pattern detection via SecurityPatternScanner."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        # Create a temporary directory with security issues
-        with TemporaryDirectory() as tmpdir:
-            # Create a test file with security pattern
-            test_file = Path(tmpdir) / "unsafe.py"
-            test_file.write_text("password = 'supersecret123'\neval(user_input)")
-
-            # Pass repo_path via profile
-            result = await agent.analyze(mock_evidence_bundle, profile={"repo_path": tmpdir})
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check for pattern scanner findings
-        pattern_findings = [f for f in findings if f.get("source") == "pattern_scanner"]
-        # Should find the hardcoded password
-        assert len(pattern_findings) >= 1
-
-    @pytest.mark.asyncio
-    async def test_analyze_llm_config(self, mock_evidence_bundle):
-        """Test LLM-based security config analysis."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = True
-
-        # Structured response from PydanticAI using SecurityFindings model
-        llm_output = SecurityFindings(
-            vulnerabilities=[
-                Vulnerability(
-                    id="SEC-001",
-                    severity="medium",
-                    category="configuration",
-                    title="Security Misconfiguration",
-                    description="Anonymous access might be risky",
-                    affected_component="security-config.yaml",
-                    remediation="Review settings",
-                    cvss_score=None,
-                )
-            ],
-            posture_score=5.0,
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-            confidence=0.8,
-            security_controls=["basic_auth"],
-            recommendations=["Review anonymous access settings"],
-        )
-
-        agent = SecurityAgent(settings=mock_settings)
-        agent._run_pydantic_ai_analysis = AsyncMock(return_value=llm_output)
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check LLM findings (now using pydantic_ai_analysis source)
-        llm_findings = [f for f in findings if f.get("source") == "pydantic_ai_analysis"]
-        assert len(llm_findings) == 1
-        assert llm_findings[0]["location"] == "security-config.yaml"
-
-    # ========== NEW TEST CASES ==========
-
-    # 1. Severity classification tests
-    @pytest.mark.asyncio
-    async def test_severity_classification_critical(self):
-        """Test CRITICAL severity classification for high-risk issues."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="src/unsafe.py",
-                    title="Unsafe Code",
-                    content="eval(user_input)",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Critical Issues",
-                    content=json.dumps(
-                        {
-                            "issues": [
-                                {
-                                    "key": "issue-1",
-                                    "severity": "CRITICAL",
-                                    "message": "SQL injection vulnerability",
-                                    "component": "src/db.py",
-                                    "rule": "security:S456",
-                                }
-                            ]
-                        }
-                    ),
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check for CRITICAL severity findings
-        critical_findings = [f for f in findings if f.get("severity") == "CRITICAL"]
-        assert len(critical_findings) > 0
-
-    @pytest.mark.asyncio
-    async def test_severity_classification_high(self):
-        """Test HIGH severity classification for security issues."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="config.py",
-                    title="Config File",
-                    content="DB_PASSWORD='supersecret123'\nAPI_KEY='sk-1234567890'",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check for HIGH severity findings from git analysis (hardcoded secrets)
-        high_findings = [f for f in findings if f.get("severity") == "HIGH"]
-        assert len(high_findings) > 0
-
-        # Verify hardcoded secrets are detected with HIGH severity
-        secret_findings = [f for f in high_findings if "potential_" in f.get("type", "")]
-        assert len(secret_findings) > 0
-
-    @pytest.mark.asyncio
-    async def test_severity_classification_medium(self):
-        """Test MEDIUM severity classification."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="README.md",
-                    title="Readme",
-                    content="This is a readme without security configs",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check for MEDIUM severity findings (missing security configs)
-        medium_findings = [f for f in findings if f.get("severity") == "MEDIUM"]
-        assert len(medium_findings) > 0
-        assert any(f.get("type") == "missing_security_config" for f in medium_findings)
-
-    @pytest.mark.asyncio
-    async def test_severity_classification_patterns(self):
-        """Test severity classification for security patterns."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-
-        # Check that SECURITY_PATTERNS have valid severity levels
-        for pattern in SECURITY_PATTERNS:
-            assert pattern.severity in ["CRITICAL", "HIGH", "MEDIUM", "LOW"]
-
-    # 2. Cross-source correlation tests
-    @pytest.mark.asyncio
-    async def test_cross_source_correlation_git_sonarqube_scanner(self, mock_evidence_bundle):
-        """Test correlation of findings from git, SonarQube, and pattern scanner."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        # Create a temporary directory with security issues
-        with TemporaryDirectory() as tmpdir:
-            # Create a test file with security pattern
-            test_file = Path(tmpdir) / "unsafe.py"
-            test_file.write_text("password = 'supersecret123'")
-
-            result = await agent.analyze(mock_evidence_bundle, profile={"repo_path": tmpdir})
-
-        assert result.success is True
-        findings = result.findings
-        metadata = result.metadata
-
-        # Verify pattern scanner was used
-        assert metadata.get("pattern_scanner_used") is True
-        assert metadata["sonarqube_issues_parsed"] == len(mock_evidence_bundle.sonarqube_evidence)
-
-        # Check findings from different sources
-        sonarqube_findings = [f for f in findings if f.get("source") == "sonarqube"]
-
-        # At least one finding should be present from each active source
-        assert len(sonarqube_findings) > 0  # From mock_evidence_bundle
-
-    # 3. SonarQube parsing tests with various formats
-    @pytest.mark.asyncio
-    async def test_sonarqube_parsing_various_formats(self):
-        """Test SonarQube parsing with various issue formats."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        # Create bundle with different SonarQube formats
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[],
-            sonarqube_evidence=[
-                # Format 1: Structured JSON with CRITICAL
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Critical Issues",
-                    content=json.dumps(
-                        {
-                            "issues": [
-                                {
-                                    "key": "issue-1",
-                                    "severity": "CRITICAL",
-                                    "message": "SQL injection vulnerability",
-                                    "component": "src/db.py",
-                                    "rule": "security:S456",
-                                }
-                            ]
-                        }
-                    ),
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-                # Format 2: Structured JSON with MAJOR
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Major Issues",
-                    content=json.dumps(
-                        {
-                            "issues": [
-                                {
-                                    "key": "issue-2",
-                                    "severity": "MAJOR",
-                                    "message": "Authentication bypass possible",
-                                    "component": "src/auth.py",
-                                    "rule": "security:S789",
-                                }
-                            ]
-                        }
-                    ),
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                ),
-                # Format 3: Unstructured with keywords
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Text Report",
-                    content="Found 2 CRITICAL security hotspots and 5 MAJOR vulnerabilities in codebase",
-                    content_hash="hash3",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check CRITICAL from structured format
-        critical_sq = [f for f in findings if f.get("severity") == "CRITICAL" and f.get("source") == "sonarqube"]
-        assert len(critical_sq) > 0
-        assert critical_sq[0]["type"] == "sonarqube_vulnerability"
-
-        # Check HIGH (MAJOR) from structured format
-        high_sq = [f for f in findings if f.get("severity") == "HIGH" and f.get("source") == "sonarqube"]
-        assert len(high_sq) > 0
-
-        # Check keyword-based detection for unstructured
-        keyword_findings = [f for f in findings if f.get("type") == "sonarqube_issue"]
-        assert len(keyword_findings) > 0
-
-    @pytest.mark.asyncio
-    async def test_sonarqube_parsing_blocker_severity(self):
-        """Test SonarQube parsing with BLOCKER severity."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[],
-            sonarqube_evidence=[
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Blocker Issues",
-                    content=json.dumps(
-                        {
-                            "issues": [
-                                {
-                                    "key": "issue-1",
-                                    "severity": "BLOCKER",
-                                    "message": "Hard-coded credential used",
-                                    "component": "src/config.py",
-                                    "rule": "security:S001",
-                                }
-                            ]
-                        }
-                    ),
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # BLOCKER should be treated as CRITICAL
-        blocker_findings = [f for f in findings if f.get("severity") == "CRITICAL"]
-        assert len(blocker_findings) > 0
-
-    # 4. Security pattern detection edge cases
-    @pytest.mark.asyncio
-    async def test_security_pattern_detection_false_positives(self):
-        """Test security pattern detection filters false positives."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                # Example files that should be filtered
-                Evidence(
-                    source="git_file",
-                    source_id="config.example.py",
-                    title="Example Config",
-                    content="DB_PASSWORD='example_password_here'\nAPI_KEY='your_api_key_here'",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-                Evidence(
-                    source="git_file",
-                    source_id="config.placeholder.py",
-                    title="Placeholder Config",
-                    content="SECRET_KEY='xxx'\nTOKEN='***'",
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # False positives should be filtered (no HIGH severity secret findings)
-        secret_findings = [f for f in findings if "potential_" in f.get("type", "") and f.get("severity") == "HIGH"]
-        # These should be filtered out
-        assert len(secret_findings) == 0
-
-    @pytest.mark.asyncio
-    async def test_security_pattern_detection_multiple_secrets(self):
-        """Test detection of multiple different secret types."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="config.py",
-                    title="Config File",
-                    content="DB_PASSWORD='supersecret123'\nAPI_KEY='sk-1234567890'",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-                Evidence(
-                    source="git_file",
-                    source_id="auth.py",
-                    title="Auth Module",
-                    content="JWT_SECRET='my-secret-key'\nprivate_key='-----BEGIN PRIVATE KEY-----'",
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                ),
-                Evidence(
-                    source="git_file",
-                    source_id="api.py",
-                    title="API Client",
-                    content="bearer_token='Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9'",
-                    content_hash="hash3",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Check for different secret types
-        secret_types = set()
-        for finding in findings:
-            if "potential_" in finding.get("type", ""):
-                secret_types.add(finding["type"])
-
-        # Should detect multiple secret types
-        expected_types = {
-            "potential_hardcoded_password",
-            "potential_hardcoded_api_key",
-            "potential_hardcoded_secret",
-            "potential_hardcoded_private_key",
-            "potential_hardcoded_token",
-        }
-        detected_types = {t for t in secret_types if t in expected_types}
-        assert len(detected_types) > 0
-
-    # 5. Empty SonarQube metrics test
-    @pytest.mark.asyncio
-    async def test_empty_sonarqube_metrics(self):
-        """Test handling of empty SonarQube metrics."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="README.md",
-                    title="Readme",
-                    content="This is a readme file",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Quality Gate",
-                    content="",
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        assert result.metadata["sonarqube_issues_parsed"] == 1
-
-        # Should not crash on empty content
-        findings = result.findings
-        assert isinstance(findings, list)
-
-    @pytest.mark.asyncio
-    async def test_empty_sonarqube_evidence_list(self):
-        """Test handling when SonarQube evidence list is empty."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        assert result.metadata["sonarqube_issues_parsed"] == 0
-
-    # 6. LLM security config analysis with different configs
-    @pytest.mark.asyncio
-    async def test_llm_analysis_different_risk_levels(self):
-        """Test LLM analysis with different risk level outputs."""
-        # Test HIGH risk level using SecurityFindings model
-        llm_output_high = SecurityFindings(
-            vulnerabilities=[
-                Vulnerability(
-                    id="SEC-001",
-                    severity="high",
-                    category="authentication",
-                    title="Authentication Bypass",
-                    description="Critical auth flaw detected",
-                    affected_component="src/auth.py",
-                    remediation="Implement proper authentication",
-                    cvss_score=None,
-                )
-            ],
-            posture_score=4.5,  # Score 4.0-5.9 = HIGH risk
-            confidence=0.85,
-            security_controls=[],
-            recommendations=["Implement proper authentication"],
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-        )
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = True
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="src/auth.py",
-                    title="Auth Module",
-                    content="# Authentication code",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[],
-        )
-
-        agent = SecurityAgent(settings=mock_settings)
-        agent._run_pydantic_ai_analysis = AsyncMock(return_value=llm_output_high)
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        assert result.metadata["overall_risk_level"] == "HIGH"
-        # Check that security_summary contains expected content
-        assert (
-            "high" in result.metadata["security_summary"].lower()
-            or "security" in result.metadata["security_summary"].lower()
-        )
-
-        llm_findings = [f for f in result.findings if f.get("source") == "pydantic_ai_analysis"]
-        assert len(llm_findings) > 0
-        assert llm_findings[0]["severity"] == "HIGH"
-
-    @pytest.mark.asyncio
-    async def test_llm_analysis_json_with_markdown_wrapper(self):
-        """Test LLM analysis when response is wrapped in markdown code blocks."""
-        # Use SecurityFindings model (PydanticAI handles structured output)
-        llm_output = SecurityFindings(
-            vulnerabilities=[
-                Vulnerability(
-                    id="SEC-002",
-                    severity="medium",
-                    category="input_validation",
-                    title="Missing Input Sanitization",
-                    description="Missing input sanitization",
-                    affected_component="src/api.py",
-                    remediation="Add input validation",
-                    cvss_score=None,
-                )
-            ],
-            posture_score=6.5,  # Medium score = MEDIUM risk
-            confidence=0.8,
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-            security_controls=[],
-            recommendations=["Add input validation"],
-        )
-
-        mock_settings = MagicMock()
-        mock_settings.enabled = True
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="src/api.py",
-                    title="API Module",
-                    content="# API code",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[],
-        )
-
-        agent = SecurityAgent(settings=mock_settings)
-        agent._run_pydantic_ai_analysis = AsyncMock(return_value=llm_output)
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        assert result.metadata["overall_risk_level"] == "MEDIUM"
-
-    @pytest.mark.asyncio
-    async def test_llm_analysis_invalid_json_response(self):
-        """Test LLM analysis when response is not valid JSON."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = True
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="README.md",
-                    title="Readme",
-                    content="# Project readme",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                )
-            ],
-            sonarqube_evidence=[],
-        )
-
-        agent = SecurityAgent(settings=mock_settings)
-        agent._run_pydantic_agent = AsyncMock(side_effect=ValueError("Invalid LLM output"))
-        result = await agent.analyze(bundle)
-
-        # Should still succeed with fallback
-        assert result.success is True
-        assert result.metadata.get("llm_error") or result.metadata.get("overall_risk_level") == "UNKNOWN"
-
-    # 7. Multiple findings aggregation test
-    @pytest.mark.asyncio
-    async def test_multiple_findings_aggregation(self, mock_evidence_bundle):
-        """Test aggregation of findings from multiple sources."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        # Create a temporary directory with security issues
-        with TemporaryDirectory() as tmpdir:
-            # Create test files with security patterns
-            db_file = Path(tmpdir) / "src" / "db.py"
-            db_file.parent.mkdir(parents=True, exist_ok=True)
-            db_file.write_text('query = f"SELECT * FROM users WHERE id={user_input}"')
-
-            auth_file = Path(tmpdir) / "src" / "auth.py"
-            auth_file.write_text("password = 'supersecret123'")
-
-            result = await agent.analyze(mock_evidence_bundle, profile={"repo_path": tmpdir})
-
-        assert result.success is True
-        findings = result.findings
-
-        # Should have findings from multiple sources
-        sources = {f.get("source") for f in findings}
-        assert "sonarqube" in sources or len(findings) > 0
-
-        # Verify metadata aggregation
-        metadata = result.metadata
-        assert "pattern_scanner_used" in metadata or "pattern_scanner_skipped" in metadata
-        assert "sonarqube_issues_parsed" in metadata
-
-    # 8. Additional edge cases
-    @pytest.mark.asyncio
-    async def test_security_config_files_detection(self):
-        """Test detection of security configuration files."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[
-                Evidence(
-                    source="git_file",
-                    source_id="SECURITY.md",
-                    title="Security Documentation",
-                    content="# Security Policy\n\nThis document outlines security practices.",
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-                Evidence(
-                    source="git_file",
-                    source_id=".snyk",
-                    title="Snyk Config",
-                    content="# Snyk configuration",
-                    content_hash="hash2",
-                    status=EvidenceStatus.FOUND,
-                ),
-                Evidence(
-                    source="git_file",
-                    source_id="dependabot.yml",
-                    title="Dependabot Config",
-                    content="# Dependabot configuration",
-                    content_hash="hash3",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-            sonarqube_evidence=[],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        findings = result.findings
-
-        # Should detect security config files (no missing config warning)
-        missing_config_findings = [f for f in findings if f.get("type") == "missing_security_config"]
-        # Since we have SECURITY.md and .snyk, missing configs should be reduced or none
-        assert len(missing_config_findings) == 0
-
-    @pytest.mark.asyncio
-    async def test_evidence_bundle_dict_input(self, mock_evidence_bundle):
-        """Test analyzing evidence bundle passed as dict."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        result = await agent.analyze({"evidence_bundle": mock_evidence_bundle})
-
-        assert result.success is True
-
-    @pytest.mark.asyncio
-    async def test_llm_disabled(self, mock_evidence_bundle):
-        """Test behavior when LLM is disabled."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        result = await agent.analyze(mock_evidence_bundle)
-
-        assert result.success is True
-        assert result.metadata["llm_analysis_used"] is False
-
-    @pytest.mark.asyncio
-    async def test_security_patterns_severity_levels(self):
-        """Test that SECURITY_PATTERNS have valid severity levels."""
-        # Test all security patterns have valid severity levels
-        valid_severities = {"CRITICAL", "HIGH", "MEDIUM", "LOW"}
-
-        for pattern in SECURITY_PATTERNS:
-            assert pattern.severity in valid_severities, (
-                f"Pattern {pattern.name} has invalid severity {pattern.severity}"
-            )
-
-        # Verify expected severity mappings for key patterns
-        pattern_severities = {p.name: p.severity for p in SECURITY_PATTERNS}
-
-        # Hardcoded secrets should be CRITICAL
-        assert pattern_severities.get("hardcoded_password") == "CRITICAL"
-        assert pattern_severities.get("hardcoded_api_key") == "CRITICAL"
-        assert pattern_severities.get("hardcoded_jwt_secret") == "CRITICAL"
-
-        # SQL injection should be HIGH
-        assert pattern_severities.get("sql_string_concat") == "HIGH"
-
-        # CORS should be MEDIUM
-        assert pattern_severities.get("cors_allow_all") == "MEDIUM"
-
-    @pytest.mark.asyncio
-    async def test_sonarqube_minor_severity_not_reported(self):
-        """Test that MINOR severity SonarQube issues are handled correctly."""
-        mock_settings = MagicMock()
-        mock_settings.enabled = False
-        agent = SecurityAgent(settings=mock_settings)
-
-        bundle = EvidenceBundle(
-            repository="test-repo",
-            git_evidence=[],
-            sonarqube_evidence=[
-                Evidence(
-                    source="sonarqube_metric",
-                    source_id="test-repo",
-                    title="Minor Issues",
-                    content=json.dumps(
-                        {
-                            "issues": [
-                                {
-                                    "key": "issue-1",
-                                    "severity": "MINOR",
-                                    "message": "Code style issue",
-                                    "component": "src/util.py",
-                                    "rule": "style:S001",
-                                }
-                            ]
-                        }
-                    ),
-                    content_hash="hash1",
-                    status=EvidenceStatus.FOUND,
-                ),
-            ],
-        )
-
-        result = await agent.analyze(bundle)
-
-        assert result.success is True
-        # MINOR issues should be handled (may or may not produce findings depending on implementation)
-        findings = result.findings
-        # The implementation may still report MINOR issues
-        assert isinstance(findings, list)
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_passes_toolsets_to_pydantic_agent(monkeypatch, mock_evidence_bundle):
-    """Security analysis should forward configured toolsets to _run_pydantic_agent."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    run_mock = AsyncMock(
-        return_value=SecurityFindings(
-            vulnerabilities=[],
-            posture_score=7.5,
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-            confidence=0.8,
-            security_controls=[],
-            recommendations=[],
-        )
-    )
-    monkeypatch.setattr(agent, "_run_pydantic_agent", run_mock)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is not None
-    assert run_mock.await_args.kwargs["toolsets"] == ["toolset-security"]
-    max_tool_calls = run_mock.await_args.kwargs["max_tool_calls"]
-    assert isinstance(max_tool_calls, int)
-    assert 8 <= max_tool_calls <= 64
-    assert "Tool-first requirements:" in run_mock.await_args.kwargs["user_prompt"]
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_evidence_first_when_tools_unavailable(monkeypatch, mock_evidence_bundle):
-    """Security analysis should enforce strict no-tool guidance in zero-tool mode."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: [])
-    run_mock = AsyncMock(
-        return_value=SecurityFindings(
-            vulnerabilities=[],
-            posture_score=7.5,
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-            confidence=0.8,
-            security_controls=[],
-            recommendations=[],
-        )
-    )
-    monkeypatch.setattr(agent, "_run_pydantic_agent", run_mock)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is not None
-    assert run_mock.await_args.kwargs["toolsets"] == []
-    assert run_mock.await_args.kwargs["max_tool_calls"] == 0
-    assert "Zero-tool requirements (strict):" in run_mock.await_args.kwargs["user_prompt"]
-    assert "Do not call any tool or skill." in run_mock.await_args.kwargs["user_prompt"]
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_zero_tool_invalid_tool_usage_fails_fast(monkeypatch, mock_evidence_bundle):
-    """Zero-tool mode must fail fast without allowlist retry when tool usage is attempted."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: [])
-    run_mock = AsyncMock(side_effect=RuntimeError("Unknown tool: read_file"))
-    monkeypatch.setattr(agent, "_run_pydantic_agent", run_mock)
-
-    with pytest.raises(RuntimeError, match="zero-tool mode forbids tool calls"):
-        await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert run_mock.await_count == 1
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_retries_after_invalid_tool_with_allowlist_prompt(monkeypatch, mock_evidence_bundle):
-    """Invalid tool usage should trigger one allowlist-guided retry."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (["search_evidence", "read_evidence_document"], {}),
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.5,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.8,
-        security_controls=[],
-        recommendations=[],
-    )
-    run_prompts: list[str] = []
-
-    async def _fake_run(**kwargs):
-        run_prompts.append(kwargs["user_prompt"])
-        if len(run_prompts) == 1:
-            raise RuntimeError("Unknown tool: run_shell")
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(run_prompts) == 2
-    assert "TOOL ALLOWLIST GUARD" in run_prompts[1]
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "budget_error",
-    [
-        "The next tool call(s) would exceed the tool_calls_limit of 16 (tool_calls=17).",
-        "The next request would exceed the request_limit of 10.",
-    ],
-)
-async def test_security_analysis_budget_exhaustion_retries_with_final_synthesis(
-    monkeypatch, mock_evidence_bundle, budget_error
-):
-    """tool_calls_limit/request_limit should trigger one bounded recovery retry first."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TOOL_ALLOWLIST", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TOOL_ALLOWLIST", raising=False)
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=56)),
-    )
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS", "8")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS", "14")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", "8")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", "14")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS", "8")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS", "14")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", "8")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", "14")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS", "7")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS", "11")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", "7")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", "11")
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise RuntimeError(budget_error)
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_file": 1, "grep_search": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-    assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" in str(calls[1]["user_prompt"])
-    assert calls[1]["max_tool_calls"] == 11
-    assert calls[1]["max_turns"] == 7
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "budget_error",
-    [
-        "The next tool call(s) would exceed the tool_calls_limit of 16 (tool_calls=17).",
-        "The next request would exceed the request_limit of 10.",
-    ],
-)
-async def test_security_analysis_budget_exhaustion_falls_back_to_final_synthesis_after_recovery_retry(
-    monkeypatch, mock_evidence_bundle, budget_error
-):
-    """A second budget error should fall back to final synthesis mode without tools."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TOOL_ALLOWLIST", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TOOL_ALLOWLIST", raising=False)
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=56)),
-    )
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) <= 2:
-            raise RuntimeError(budget_error)
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_file": 1, "grep_search": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 3
-    assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" in str(calls[1]["user_prompt"])
-    observed_recovery_tool_calls = int(calls[1]["max_tool_calls"])
-    observed_recovery_turns = int(calls[1]["max_turns"])
-    assert observed_recovery_tool_calls in {8, 14}
-    assert observed_recovery_turns in {6, 8}
-    if observed_recovery_tool_calls == 8:
-        assert observed_recovery_turns == 6
-    else:
-        assert observed_recovery_turns == 8
-    assert "BUDGET EXHAUSTED - FINAL SYNTHESIS MODE" in str(calls[2]["user_prompt"])
-    assert calls[2]["toolsets"] == []
-    assert calls[2]["max_tool_calls"] == 1
-    assert calls[2]["max_turns"] is None
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize(
-    ("budget_error", "expect_recovery_retry"),
-    [
-        ("UsageLimitExceeded: The next request would exceed the request_limit of 20.", False),
-        ("UsageLimitExceeded: The next tool call(s) would exceed the tool_calls_limit of 20 (tool_calls=21).", True),
-    ],
-)
-async def test_security_analysis_strict_local_openai_budget_limit_behavior(
-    monkeypatch, mock_evidence_bundle, budget_error, expect_recovery_retry
-):
-    """Strict local OpenAI limit exhaustion should use bounded recovery for tool-call overflow only."""
-    # Isolate budget env vars to prevent leakage from ~/.vds/.env (GAP fix)
-    for env_key in [
-        "VDS_AUDIT_AGENTIC_STRICT_MAX_TURNS_CAP",
-        "VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TURNS_CAP",
-        "VDS_AUDIT_AGENTIC_STRICT_MAX_TOOL_CALLS_CAP",
-        "VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TOOL_CALLS_CAP",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_COMPACT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_COMPACT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_DEFAULT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_DEFAULT_MAX_TOOL_CALLS",
-    ]:
-        monkeypatch.delenv(env_key, raising=False)
-    settings = LLMSettings(
-        enabled=True,
-        protocol=LLMProtocolType.OPENAI,
-        base_url="http://127.0.0.1:11434/v1",
-    )
-    agent = SecurityAgent(settings=settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=24)),
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.1,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.72,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise RuntimeError(budget_error)
-        if expect_recovery_retry:
-            agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        else:
-            agent._last_agent_run_telemetry = {"event_tool_count_by_name": {}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-    if expect_recovery_retry:
-        assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" in str(calls[1]["user_prompt"])
-        assert calls[1]["toolsets"] == ["toolset-security"]
-        assert calls[1]["max_tool_calls"] == 7
-        assert calls[1]["max_turns"] == 6
-    else:
-        assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" not in str(calls[1]["user_prompt"])
-        assert "BUDGET EXHAUSTED - FINAL SYNTHESIS MODE" in str(calls[1]["user_prompt"])
-        assert calls[1]["toolsets"] == []
-        assert calls[1]["max_tool_calls"] == 1
-        assert calls[1]["max_turns"] is None
-
-
-@pytest.mark.asyncio
-async def test_security_budget_recovery_terminal_pass_pivots_early_to_synthesis(monkeypatch, mock_evidence_bundle):
-    """Low-signal terminal recovery pass should pivot directly to synthesis-only mode."""
-    # Isolate ALL budget env vars to prevent leakage from ~/.vds/.env
-    for env_key in [
-        "VDS_AUDIT_AGENTIC_STRICT_MAX_TURNS_CAP",
-        "VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TURNS_CAP",
-        "VDS_AUDIT_AGENTIC_STRICT_MAX_TOOL_CALLS_CAP",
-        "VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TOOL_CALLS_CAP",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_COMPACT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_COMPACT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_DEFAULT_MAX_TURNS",
-        "VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TOOL_CALLS",
-        "VDS_AUDIT_AGENTIC_SECURITY_COMPACT_DEFAULT_MAX_TOOL_CALLS",
-    ]:
-        monkeypatch.delenv(env_key, raising=False)
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=56)),
-    )
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_BUDGET_RECOVERY_TERMINAL_MAX_TOOL_CALLS", raising=False)
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise RuntimeError("The next tool call(s) would exceed the tool_calls_limit of 16 (tool_calls=17).")
-        if len(calls) == 2:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 4,
-                "event_tool_count_by_name": {"search_evidence": 4, "read_evidence_document": 0},
-            }
-            return expected
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 3
-    assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" in str(calls[1]["user_prompt"])
-    assert calls[1]["max_tool_calls"] == 8
-    assert calls[1]["max_turns"] == 6
-    assert "RECOVERY TERMINAL PASS EXIT - FINAL SYNTHESIS MODE" in str(calls[2]["user_prompt"])
-    assert calls[2]["toolsets"] == []
-    assert calls[2]["max_tool_calls"] == 1
-    assert calls[2]["max_turns"] is None
-
-
-@pytest.mark.asyncio
-async def test_security_budget_recovery_allowlist_filters_non_read_tools(monkeypatch, mock_evidence_bundle):
-    """Recovery allowlist should remain read-first even when env includes search tools."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setenv(
-        "VDS_AUDIT_AGENTIC_BUDGET_RECOVERY_TOOL_ALLOWLIST",
-        "search_evidence,list_evidence_documents,read_evidence_document,read_file,rg_search",
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    captured_allowlists: list[list[str]] = []
-    calls: list[dict[str, object]] = []
-
-    def _capture_apply_tool_allowlist(toolsets, allowlist):
-        captured_allowlists.append(list(allowlist))
-        return list(toolsets)
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise RuntimeError("The next tool call(s) would exceed the tool_calls_limit of 16 (tool_calls=17).")
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_apply_tool_allowlist", _capture_apply_tool_allowlist)
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(captured_allowlists) >= 1
-    recovery_allowlist = captured_allowlists[-1]
-    assert "search_evidence" not in recovery_allowlist
-    assert "rg_search" not in recovery_allowlist
-    assert "list_evidence_documents" in recovery_allowlist
-    assert "read_evidence_document" in recovery_allowlist
-    assert "read_file" in recovery_allowlist
-
-
-@pytest.mark.asyncio
-async def test_security_budget_synthesis_zero_tool_mode_coerces_ungrounded_vulnerabilities(
-    monkeypatch, mock_evidence_bundle
-):
-    """Zero-tool synthesis mode must coerce ungrounded vulnerabilities without extra retries."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-
-    calls: list[dict[str, Any]] = []
-    synthesis_output = SecurityFindings(
-        vulnerabilities=[
-            Vulnerability(
-                id="SEC-001",
-                severity="high",
-                category="code",
-                title="Ungrounded assertion",
-                description="Model-reported issue without concrete evidence reads in synthesis mode",
-                affected_component="src/app.py",
-                remediation="Validate via read_file before reporting",
-            )
-        ],
-        posture_score=4.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.9,
-        security_controls=[],
-        recommendations=[],
-    )
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) <= 2:
-            raise RuntimeError("The next tool call(s) would exceed the tool_calls_limit of 24 (tool_calls=25).")
-        # No grounded read/search activity is available in synthesis call telemetry.
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {}}
-        return synthesis_output
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is not None
-    assert len(calls) == 3
-    assert "BUDGET RECOVERY MODE (READ-FOCUSED TERMINAL PASS)" in str(calls[1]["user_prompt"])
-    assert "BUDGET EXHAUSTED - FINAL SYNTHESIS MODE" in str(calls[2]["user_prompt"])
-    assert calls[2]["toolsets"] == []
-    assert calls[2]["max_tool_calls"] == 1
-    assert output.vulnerabilities == []
-    assert output.confidence <= 0.4
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_tightens_strict_budget_for_local_openai(monkeypatch, mock_evidence_bundle):
-    """Strict mode on local OpenAI endpoints should apply bounded, non-overtightened budgets."""
-    settings = LLMSettings(
-        enabled=True,
-        protocol=LLMProtocolType.OPENAI,
-        base_url="http://127.0.0.1:11434/v1",
-    )
-    agent = SecurityAgent(settings=settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_STRICT_MAX_TURNS_CAP", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_STRICT_MAX_TOOL_CALLS_CAP", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TURNS_CAP", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_SECURITY_STRICT_MAX_TOOL_CALLS_CAP", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_COMPACT_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_COMPACT_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TURNS", raising=False)
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_COMPACT_DEFAULT_MAX_TOOL_CALLS", raising=False)
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=24)),
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 1
-    assert calls[0]["max_turns"] == 8
-    assert calls[0]["max_tool_calls"] == 20
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_local_openai_prompt_adds_budget_discipline(monkeypatch, mock_evidence_bundle):
-    """Local OpenAI mode should append explicit bounded tool-usage guidance to prompt."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(agent, "_should_disable_parallel_tool_calls", lambda: True)
-
-    run_mock = AsyncMock(
-        return_value=SecurityFindings(
-            vulnerabilities=[],
-            posture_score=7.5,
-            sonarqube_issues=0,
-            dependency_vulnerabilities=0,
-            confidence=0.8,
-            security_controls=[],
-            recommendations=[],
-        )
-    )
-    monkeypatch.setattr(agent, "_run_pydantic_agent", run_mock)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is not None
-    assert (
-        "Local OpenAI discipline: keep tool usage bounded and deterministic."
-        in run_mock.await_args.kwargs["user_prompt"]
-    )
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_strict_tool_cap_override_from_env(monkeypatch, mock_evidence_bundle):
-    """Generic env override should control strict tool-call cap for SecurityAgent."""
-    settings = LLMSettings(
-        enabled=True,
-        protocol=LLMProtocolType.OPENAI,
-        base_url="http://127.0.0.1:11434/v1",
-    )
-    agent = SecurityAgent(settings=settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=24)),
-    )
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_STRICT_MAX_TOOL_CALLS_CAP", "24")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_COMPACT_MAX_TOOL_CALLS", "24")
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 1
-    assert calls[0]["max_tool_calls"] == 24
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_strict_turn_cap_override_from_env(monkeypatch, mock_evidence_bundle):
-    """Generic env override should control strict max turns when compact cap aligns."""
-    settings = LLMSettings(
-        enabled=True,
-        protocol=LLMProtocolType.OPENAI,
-        base_url="http://127.0.0.1:11434/v1",
-    )
-    agent = SecurityAgent(settings=settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent.get_config",
-        lambda: MagicMock(agentic=MagicMock(strict_no_fallback=True, max_turns=10, max_tool_calls=24)),
-    )
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_STRICT_MAX_TURNS_CAP", "10")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_STRICT_MAX_TOOL_CALLS_CAP", "20")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_COMPACT_MAX_TURNS", "10")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_COMPACT_MAX_TOOL_CALLS", "20")
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, object]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_evidence_document": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 1
-    assert calls[0]["max_turns"] == 10
-    assert calls[0]["max_tool_calls"] == 20
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_trailing_characters_retries_with_output_recovery(monkeypatch, mock_evidence_bundle):
-    """Trailing JSON characters should trigger one strict output-format recovery retry."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.2,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.75,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise ValueError("trailing characters at line 1 column 103")
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_file": 1, "grep_search": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-    assert "OUTPUT FORMAT RECOVERY MODE" in str(calls[1]["user_prompt"])
-    assert calls[1]["toolsets"] == []
-    assert calls[1]["max_tool_calls"] == 1
-    assert calls[1]["max_turns"] is None
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_rate_limit_retries_once(monkeypatch, mock_evidence_bundle):
-    """Provider 429/rate-limit should trigger one retry with backoff."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr("vds_audit_orchestrator.agents.security_agent.asyncio.sleep", AsyncMock())
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.1,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.7,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            raise RuntimeError(
-                "status_code: 429, model_name: claude-haiku-4-5-20251001, body: {'type': 'error', 'error': {'type': 'rate_limit_error', 'message': 'Rate limit exceeded'}}"
-            )
-        agent._last_agent_run_telemetry = {"event_tool_count_by_name": {"read_file": 1, "grep_search": 1}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_cadence_guard_pivots_search_only_burst(monkeypatch, mock_evidence_bundle):
-    """Search-only burst should trigger cadence pivot prompt once."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (
-            ["search_evidence", "read_evidence_document"],
-            {"search_only_burst_min_tool_calls": 4, "search_only_burst_min_search_calls": 4},
-        ),
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.5,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.8,
-        security_controls=[],
-        recommendations=[],
-    )
-    run_prompts: list[str] = []
-
-    async def _fake_run(**kwargs):
-        run_prompts.append(kwargs["user_prompt"])
-        if len(run_prompts) == 1:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 4,
-                "event_tool_count_by_name": {"search_evidence": 4, "read_evidence_document": 0},
-            }
-        else:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 4,
-                "event_tool_count_by_name": {"search_evidence": 2, "read_evidence_document": 1},
-            }
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(run_prompts) == 2
-    assert "CADENCE PIVOT GUARD" in run_prompts[1]
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_cadence_guard_accepts_grounded_output_without_restart(
-    monkeypatch, mock_evidence_bundle
-):
-    """Low-signal cadence with grounded output should be accepted without synthesis restart."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (
-            ["grep_search", "read_file"],
-            {"high_repeat_min_tool_calls": 10, "max_unique_tools_in_window": 2},
-        ),
-    )
-    # Keep cadence acceptance thresholds deterministic for this test; host env can override defaults.
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_ACCEPT_MIN_READ_CALLS", "2")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_ACCEPT_MIN_UNIQUE_TOOLS", "2")
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.2,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.82,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 12,
-                "event_tool_count_by_name": {"grep_search": 8, "read_file": 4},
-            }
-            return expected
-        agent._last_agent_run_telemetry = {"event_tool_calls_completed": 0, "event_tool_count_by_name": {}}
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 1
-
-
-def test_security_low_signal_search_burst_detects_mixed_loop_churn() -> None:
-    telemetry = {
-        "event_tool_calls_completed": 12,
-        "event_tool_count_by_name": {
-            "grep_search": 7,
-            "read_file": 5,
-        },
-    }
-
-    assert SecurityAgent._is_low_signal_search_burst(telemetry, policy={}) is True
-
-
-def test_security_build_analysis_toolsets_disables_skills(monkeypatch):
-    """Security analysis should drop skills toolsets to avoid noisy script calls."""
-
-    class _SkillToolset:
-        skills = {"llm-analysis-skill": object()}
-        _vds_skill_metadata = []
-
-    class _OtherToolset:
-        pass
-
-    agent = SecurityAgent(settings=MagicMock(enabled=True))
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent._build_toolsets",
-        lambda *_: [_SkillToolset(), _OtherToolset()],
-    )
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_SECURITY_ENABLE_SKILLS_TOOLSET", "false")
-    monkeypatch.delenv("VDS_AUDIT_AGENTIC_ENABLE_SKILLS_TOOLSET", raising=False)
-
-    toolsets = agent._build_analysis_toolsets()
-
-    assert len(toolsets) == 1
-    assert isinstance(toolsets[0], _OtherToolset)
-
-
-def test_security_build_analysis_toolsets_can_enable_skills_via_env(monkeypatch):
-    """Security analysis may keep skills toolsets when explicitly enabled via env."""
-
-    class _SkillToolset:
-        skills = {"llm-analysis-skill": object()}
-        _vds_skill_metadata = []
-
-    class _OtherToolset:
-        pass
-
-    agent = SecurityAgent(settings=MagicMock(enabled=True))
-    monkeypatch.setattr(
-        "vds_audit_orchestrator.agents.security_agent._build_toolsets",
-        lambda *_: [_SkillToolset(), _OtherToolset()],
-    )
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_SECURITY_ENABLE_SKILLS_TOOLSET", "true")
-
-    toolsets = agent._build_analysis_toolsets()
-
-    assert len(toolsets) == 2
-    assert any(isinstance(item, _SkillToolset) for item in toolsets)
-    assert any(isinstance(item, _OtherToolset) for item in toolsets)
-
-
-def test_security_has_min_evidence_grounding() -> None:
-    assert SecurityAgent._has_min_evidence_grounding(None) is False
-    assert SecurityAgent._has_min_evidence_grounding({}) is False
-    assert (
-        SecurityAgent._has_min_evidence_grounding(
-            {"event_tool_count_by_name": {"search_evidence": 1, "read_evidence_document": 1}}
-        )
-        is True
-    )
-    assert (
-        SecurityAgent._has_min_evidence_grounding(
-            {"event_tool_count_by_name": {"search_evidence": 2, "read_evidence_document": 0}}
-        )
-        is False
-    )
-    assert (
-        SecurityAgent._has_min_evidence_grounding(
-            {"event_tool_count_by_name": {"search_evidence": 2, "read_evidence_document": 1}},
-            min_read_calls=2,
-            min_unique_tools=2,
-        )
-        is False
-    )
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_cadence_guard_stricter_accept_threshold_retries(monkeypatch, mock_evidence_bundle):
-    """Stricter cadence acceptance threshold should force one retry before accept."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: ["toolset-security"])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (
-            ["search_evidence", "read_evidence_document"],
-            {"high_repeat_min_tool_calls": 10, "max_unique_tools_in_window": 2},
-        ),
-    )
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_ACCEPT_MIN_READ_CALLS", "2")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_ACCEPT_MIN_UNIQUE_TOOLS", "2")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_RETRY_MAX_TURNS", "6")
-    monkeypatch.setenv("VDS_AUDIT_AGENTIC_CADENCE_RETRY_MAX_TOOL_CALLS", "10")
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.1,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.8,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 10,
-                "event_tool_count_by_name": {"search_evidence": 9, "read_evidence_document": 1},
-            }
-            return expected
-        # Second call: enough read calls (2 >= 2) and not search-dominant (4 < max(8, 8))
-        agent._last_agent_run_telemetry = {
-            "event_tool_calls_completed": 10,
-            "event_tool_count_by_name": {"search_evidence": 4, "read_evidence_document": 3, "read_file": 3},
-        }
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-    assert "CADENCE PIVOT GUARD" in str(calls[1]["user_prompt"])
-    assert calls[1]["max_turns"] == 6
-    assert calls[1]["max_tool_calls"] == 10
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_cadence_retry_tool_allowlist_applied(monkeypatch, mock_evidence_bundle):
-    """Cadence retry should optionally narrow toolsets via env allowlist."""
-    mock_settings = MagicMock()
-    mock_settings.enabled = True
-    agent = SecurityAgent(settings=mock_settings)
-
-    class _Toolset:
-        def __init__(self):
-            self.tools = {
-                "search_evidence": object(),
-                "read_evidence_document": object(),
-                "read_file": object(),
-                "grep_search": object(),
-            }
-
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: [_Toolset()])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (
-            ["search_evidence", "read_evidence_document", "read_file", "grep_search"],
-            {"high_repeat_min_tool_calls": 10, "max_unique_tools_in_window": 2},
-        ),
-    )
-    monkeypatch.setenv(
-        "VDS_AUDIT_AGENTIC_CADENCE_RETRY_TOOL_ALLOWLIST",
-        "read_evidence_document,read_file,search_evidence",
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.1,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.8,
-        security_controls=[],
-        recommendations=[],
-    )
-    calls: list[dict[str, Any]] = []
-
-    async def _fake_run(**kwargs):
-        calls.append(kwargs)
-        if len(calls) == 1:
-            agent._last_agent_run_telemetry = {
-                "event_tool_calls_completed": 10,
-                "event_tool_count_by_name": {"search_evidence": 9, "read_evidence_document": 0},
-            }
-            return expected
-        agent._last_agent_run_telemetry = {
-            "event_tool_calls_completed": 10,
-            "event_tool_count_by_name": {"search_evidence": 6, "read_evidence_document": 2, "read_file": 1},
-        }
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is expected
-    assert len(calls) == 2
-    retry_toolset = (calls[1].get("toolsets") or [None])[0]
-    retry_tools = getattr(retry_toolset, "tools", {})
-    assert set(retry_tools.keys()) == {"read_evidence_document", "read_file", "search_evidence"}
-
-
-@pytest.mark.asyncio
-async def test_security_analysis_retries_and_drops_ungrounded_output(monkeypatch, mock_evidence_bundle):
-    agent = SecurityAgent(settings=MagicMock(enabled=True))
-    monkeypatch.setattr(agent, "_build_analysis_toolsets", lambda: [object()])
-    monkeypatch.setattr(agent, "_collect_available_skill_names", lambda *_: [])
-    monkeypatch.setattr(
-        agent,
-        "_resolve_tool_policy",
-        lambda: (["search_evidence", "read_evidence_document"], {"search_only_burst_min_tool_calls": 4}),
-    )
-
-    expected = SecurityFindings(
-        vulnerabilities=[],
-        posture_score=7.0,
-        sonarqube_issues=0,
-        dependency_vulnerabilities=0,
-        confidence=0.8,
-        security_controls=[],
-        recommendations=[],
-    )
-    run_prompts: list[str] = []
-
-    async def _fake_run(**kwargs):
-        run_prompts.append(kwargs["user_prompt"])
-        agent._last_agent_run_telemetry = {
-            "event_tool_calls_completed": 0,
-            "event_tool_count_by_name": {"search_evidence": 0, "read_evidence_document": 0},
-        }
-        return expected
-
-    monkeypatch.setattr(agent, "_run_pydantic_agent", _fake_run)
-
-    output = await agent._run_pydantic_ai_analysis(mock_evidence_bundle, existing_findings=[])
-
-    assert output is None
-    assert len(run_prompts) == 2
-    assert "EVIDENCE GROUNDING GUARD" in run_prompts[1]