@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/engine/test_requirement_analysis_phase114.py

@@ -1,919 +0,0 @@
-"""Unit tests for Phase 114 NLP/semantic requirement classification fields (FR-114.1, FR-114.2).
-
-Coverage:
-- Phase 114 field presence and defaults on RequirementAnalysisResult (FR-114.1, TSK-114.1)
-- from_mapping() round-trip with Phase 114 fields (FR-114.1, AC-114.1.2)
-- heuristic_confidence clamping to [0.0, 1.0] (FR-114.1, AC-114.1.1)
-- nlp_exemplar_similarity clamping to [0.0, 1.0] (FR-114.1)
-- classification_source validation against allowed enum values (FR-114.1)
-- compute_requirement_content_fingerprint stability and NFC normalization (FR-114.2, DD-114.7)
-- compute_classification_fingerprint stability and order independence (FR-114.2, DD-114.7)
-- Phase 114 fields coexist with Phase 113 execution_scope_class (FR-113.1 + FR-114.1)
-- analyze_requirement_intent populates Phase 114 fields end-to-end (FR-114.1, FR-114.2)
-"""
-
-from __future__ import annotations
-
-import unicodedata
-
-import pytest
-from vds_audit_orchestrator.engine.requirement_analysis import (
-    RequirementAnalysisResult,
-    analyze_requirement_intent,
-    compute_classification_fingerprint,
-    compute_requirement_content_fingerprint,
-)
-
-# ============================================================================
-# Phase 114 Field Defaults (FR-114.1, TSK-114.1)
-# ============================================================================
-
-
-class TestPhase114FieldDefaults:
-    """Verify Phase 114 field presence and default values on RequirementAnalysisResult."""
-
-    def test_heuristic_confidence_default(self) -> None:
-        """heuristic_confidence defaults to 0.5 when not explicitly set."""
-        result = RequirementAnalysisResult(analysis_mode="code_first")
-        assert result.heuristic_confidence == 0.5
-
-    def test_classification_source_default(self) -> None:
-        """classification_source defaults to 'heuristic' when not explicitly set."""
-        result = RequirementAnalysisResult(analysis_mode="code_first")
-        assert result.classification_source == "heuristic"
-
-    def test_content_fingerprint_default(self) -> None:
-        """content_fingerprint defaults to empty string when not explicitly set."""
-        result = RequirementAnalysisResult(analysis_mode="docs_first")
-        assert result.content_fingerprint == ""
-
-    def test_classification_fingerprint_default(self) -> None:
-        """classification_fingerprint defaults to empty string when not explicitly set."""
-        result = RequirementAnalysisResult(analysis_mode="docs_first")
-        assert result.classification_fingerprint == ""
-
-    def test_nlp_exemplar_similarity_default(self) -> None:
-        """nlp_exemplar_similarity defaults to 0.0 when not explicitly set."""
-        result = RequirementAnalysisResult(analysis_mode="hybrid_balanced")
-        assert result.nlp_exemplar_similarity == 0.0
-
-    def test_all_phase114_fields_present_in_to_dict(self) -> None:
-        """All Phase 114 fields appear in the to_dict() serialization output."""
-        result = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            heuristic_confidence=0.75,
-            classification_source="nlp_enrichment",
-            content_fingerprint="abc123",
-            classification_fingerprint="def456",
-            nlp_exemplar_similarity=0.88,
-        )
-        d = result.to_dict()
-
-        assert "heuristic_confidence" in d
-        assert "classification_source" in d
-        assert "content_fingerprint" in d
-        assert "classification_fingerprint" in d
-        assert "nlp_exemplar_similarity" in d
-        assert d["heuristic_confidence"] == 0.75
-        assert d["classification_source"] == "nlp_enrichment"
-        assert d["content_fingerprint"] == "abc123"
-        assert d["classification_fingerprint"] == "def456"
-        assert d["nlp_exemplar_similarity"] == 0.88
-
-
-# ============================================================================
-# from_mapping() Round-Trip (FR-114.1, AC-114.1.2)
-# ============================================================================
-
-
-class TestPhase114FromMappingRoundTrip:
-    """Verify Phase 114 fields survive to_dict → from_mapping round-trip."""
-
-    def test_round_trip_preserves_all_phase114_fields(self) -> None:
-        """Create a result with Phase 114 fields, serialize, deserialize, and verify all survive."""
-        original = RequirementAnalysisResult(
-            analysis_mode="hybrid_balanced",
-            analysis_reason_codes=["mixed_modalities_required"],
-            required_anchor_modalities=["code", "docs"],
-            project_scope_required=True,
-            execution_scope_class="project_doc_authoritative",
-            generic_anchor_exemption=False,
-            minimum_substantive_code_anchors=1,
-            finalization_policy="mixed_modalities_preserve_strong_code",
-            heuristic_confidence=0.72,
-            classification_source="nlp_enrichment",
-            content_fingerprint="a" * 64,
-            classification_fingerprint="b" * 64,
-            nlp_exemplar_similarity=0.91,
-        )
-
-        serialized = original.to_dict()
-        restored = RequirementAnalysisResult.from_mapping(serialized)
-
-        assert restored is not None
-        assert restored.heuristic_confidence == 0.72
-        assert restored.classification_source == "nlp_enrichment"
-        assert restored.content_fingerprint == "a" * 64
-        assert restored.classification_fingerprint == "b" * 64
-        assert restored.nlp_exemplar_similarity == 0.91
-        # Also verify core fields survive
-        assert restored.analysis_mode == "hybrid_balanced"
-        assert restored.execution_scope_class == "project_doc_authoritative"
-        assert restored.project_scope_required is True
-        assert restored.finalization_policy == "mixed_modalities_preserve_strong_code"
-
-    def test_round_trip_with_defaults(self) -> None:
-        """Round-trip with default Phase 114 values produces equivalent result."""
-        original = RequirementAnalysisResult(analysis_mode="code_first")
-        serialized = original.to_dict()
-        restored = RequirementAnalysisResult.from_mapping(serialized)
-
-        assert restored is not None
-        assert restored.heuristic_confidence == original.heuristic_confidence
-        assert restored.classification_source == original.classification_source
-        assert restored.content_fingerprint == original.content_fingerprint
-        assert restored.classification_fingerprint == original.classification_fingerprint
-        assert restored.nlp_exemplar_similarity == original.nlp_exemplar_similarity
-
-    def test_from_mapping_with_missing_phase114_fields_uses_defaults(self) -> None:
-        """from_mapping falls back to defaults when Phase 114 fields are absent."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "required_anchor_modalities": ["code"],
-                "finalization_policy": "code_substantive_required",
-            }
-        )
-
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 0.5
-        assert parsed.classification_source == "heuristic"
-        assert parsed.content_fingerprint == ""
-        assert parsed.classification_fingerprint == ""
-        assert parsed.nlp_exemplar_similarity == 0.0
-
-    def test_from_mapping_with_none_phase114_values_uses_defaults(self) -> None:
-        """from_mapping handles None values for Phase 114 fields gracefully."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "docs_first",
-                "required_anchor_modalities": ["docs"],
-                "finalization_policy": "docs_primary",
-                "heuristic_confidence": None,
-                "classification_source": None,
-                "content_fingerprint": None,
-                "classification_fingerprint": None,
-                "nlp_exemplar_similarity": None,
-            }
-        )
-
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 0.5
-        assert parsed.classification_source == "heuristic"
-        assert parsed.content_fingerprint == ""
-        assert parsed.classification_fingerprint == ""
-        assert parsed.nlp_exemplar_similarity == 0.0
-
-
-# ============================================================================
-# Confidence Clamping (FR-114.1, AC-114.1.1)
-# ============================================================================
-
-
-class TestConfidenceClamping:
-    """Verify heuristic_confidence and nlp_exemplar_similarity are clamped to [0.0, 1.0]."""
-
-    def test_heuristic_confidence_clamped_above_one(self) -> None:
-        """heuristic_confidence > 1.0 is clamped to 1.0 via from_mapping."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": 1.5,
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 1.0
-
-    def test_heuristic_confidence_clamped_below_zero(self) -> None:
-        """heuristic_confidence < 0.0 is clamped to 0.0 via from_mapping."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": -0.3,
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 0.0
-
-    def test_heuristic_confidence_at_boundary_zero(self) -> None:
-        """heuristic_confidence exactly 0.0 is preserved."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": 0.0,
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 0.0
-
-    def test_heuristic_confidence_at_boundary_one(self) -> None:
-        """heuristic_confidence exactly 1.0 is preserved."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": 1.0,
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 1.0
-
-    def test_heuristic_confidence_integer_coercion(self) -> None:
-        """heuristic_confidence with integer input is coerced to float and clamped."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": 3,
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 1.0
-
-    def test_nlp_exemplar_similarity_clamped_above_one(self) -> None:
-        """nlp_exemplar_similarity > 1.0 is clamped to 1.0 via from_mapping."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "nlp_exemplar_similarity": 2.0,
-            }
-        )
-        assert parsed is not None
-        assert parsed.nlp_exemplar_similarity == 1.0
-
-    def test_nlp_exemplar_similarity_clamped_below_zero(self) -> None:
-        """nlp_exemplar_similarity < 0.0 is clamped to 0.0 via from_mapping."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "nlp_exemplar_similarity": -0.5,
-            }
-        )
-        assert parsed is not None
-        assert parsed.nlp_exemplar_similarity == 0.0
-
-    def test_nlp_exemplar_similarity_valid_mid_range(self) -> None:
-        """nlp_exemplar_similarity within [0.0, 1.0] is preserved."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "nlp_exemplar_similarity": 0.73,
-            }
-        )
-        assert parsed is not None
-        assert parsed.nlp_exemplar_similarity == pytest.approx(0.73)
-
-    def test_nlp_exemplar_similarity_string_falls_back_to_default(self) -> None:
-        """Non-numeric nlp_exemplar_similarity falls back to 0.0 default."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "nlp_exemplar_similarity": "not_a_number",
-            }
-        )
-        assert parsed is not None
-        assert parsed.nlp_exemplar_similarity == 0.0
-
-    def test_heuristic_confidence_string_falls_back_to_default(self) -> None:
-        """Non-numeric heuristic_confidence falls back to 0.5 default."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "heuristic_confidence": "invalid",
-            }
-        )
-        assert parsed is not None
-        assert parsed.heuristic_confidence == 0.5
-
-
-# ============================================================================
-# classification_source Validation (FR-114.1)
-# ============================================================================
-
-
-class TestClassificationSourceValidation:
-    """Verify classification_source is validated against allowed enum values."""
-
-    @pytest.mark.parametrize(
-        "source",
-        ["heuristic", "nlp_enrichment", "llm_agent", "dspy_classifier"],
-    )
-    def test_valid_classification_sources_accepted(self, source: str) -> None:
-        """All valid classification_source values are accepted by from_mapping."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "classification_source": source,
-            }
-        )
-        assert parsed is not None
-        assert parsed.classification_source == source
-
-    def test_invalid_classification_source_falls_back_to_heuristic(self) -> None:
-        """Invalid classification_source falls back to 'heuristic'."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "classification_source": "unknown_source",
-            }
-        )
-        assert parsed is not None
-        assert parsed.classification_source == "heuristic"
-
-    def test_empty_classification_source_falls_back_to_heuristic(self) -> None:
-        """Empty string classification_source falls back to 'heuristic'."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "classification_source": "",
-            }
-        )
-        assert parsed is not None
-        assert parsed.classification_source == "heuristic"
-
-    def test_classification_source_case_normalization(self) -> None:
-        """classification_source is normalized to lowercase."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "classification_source": "NLP_ENRICHMENT",
-            }
-        )
-        assert parsed is not None
-        assert parsed.classification_source == "nlp_enrichment"
-
-    def test_cached_is_not_valid_classification_source(self) -> None:
-        """'cached' is not in the valid ClassificationSource Literal for RequirementAnalysisResult.
-
-        The 'cached' source is used in RequirementClassificationRecord (drift module),
-        not in the core RequirementAnalysisResult.
-        """
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "code_first",
-                "classification_source": "cached",
-            }
-        )
-        assert parsed is not None
-        # 'cached' is not in the valid set for RequirementAnalysisResult
-        assert parsed.classification_source == "heuristic"
-
-
-# ============================================================================
-# Content Fingerprint Computation (FR-114.2, DD-114.7)
-# ============================================================================
-
-
-class TestContentFingerprintComputation:
-    """Verify compute_requirement_content_fingerprint stability, normalization, and uniqueness."""
-
-    def test_produces_sha256_hex_digest(self) -> None:
-        """Content fingerprint is a 64-character hexadecimal SHA-256 digest."""
-        fp = compute_requirement_content_fingerprint(
-            requirement_text="Validate health endpoint implementation.",
-            requirement_category="Observability",
-        )
-        assert len(fp) == 64
-        assert all(c in "0123456789abcdef" for c in fp)
-
-    def test_stable_for_same_inputs(self) -> None:
-        """Same inputs always produce the same fingerprint (determinism)."""
-        kwargs = {
-            "requirement_text": "Validate dependency graph decoupling.",
-            "requirement_category": "Architecture",
-        }
-        fp1 = compute_requirement_content_fingerprint(**kwargs)
-        fp2 = compute_requirement_content_fingerprint(**kwargs)
-        assert fp1 == fp2
-
-    def test_different_text_produces_different_fingerprint(self) -> None:
-        """Different requirement text produces a different fingerprint."""
-        fp1 = compute_requirement_content_fingerprint(
-            requirement_text="Validate health endpoint.",
-            requirement_category="Observability",
-        )
-        fp2 = compute_requirement_content_fingerprint(
-            requirement_text="Validate metrics endpoint.",
-            requirement_category="Observability",
-        )
-        assert fp1 != fp2
-
-    def test_different_category_produces_different_fingerprint(self) -> None:
-        """Different category with same text produces a different fingerprint."""
-        fp1 = compute_requirement_content_fingerprint(
-            requirement_text="Validate Dockerfile.",
-            requirement_category="Deployment",
-        )
-        fp2 = compute_requirement_content_fingerprint(
-            requirement_text="Validate Dockerfile.",
-            requirement_category="Security",
-        )
-        assert fp1 != fp2
-
-    def test_unicode_nfc_normalization(self) -> None:
-        """NFC normalization ensures equivalent Unicode sequences produce the same fingerprint.
-
-        'café' (precomposed) and 'cafe\\u0301' (decomposed) must produce identical fingerprints
-        after NFC normalization (DD-114.7).
-        """
-        text_nfc = "café"
-        text_nfd = "cafe\u0301"
-        # Confirm they differ at the byte level before normalization
-        assert text_nfc.encode("utf-8") != text_nfd.encode("utf-8")
-        # But produce the same fingerprint
-        fp_nfc = compute_requirement_content_fingerprint(
-            requirement_text=text_nfc,
-            requirement_category="Test",
-        )
-        fp_nfd = compute_requirement_content_fingerprint(
-            requirement_text=text_nfd,
-            requirement_category="Test",
-        )
-        assert fp_nfc == fp_nfd
-
-    def test_vietnamese_nfc_normalization(self) -> None:
-        """Vietnamese diacritics are NFC-normalized for stable fingerprints."""
-        # Precomposed Vietnamese
-        text_nfc = "Không có cycle trong dependency graph"
-        # Decomposed equivalent
-        text_nfd = unicodedata.normalize("NFD", text_nfc)
-
-        fp_nfc = compute_requirement_content_fingerprint(
-            requirement_text=text_nfc,
-            requirement_category="Decoupling",
-        )
-        fp_nfd = compute_requirement_content_fingerprint(
-            requirement_text=text_nfd,
-            requirement_category="Decoupling",
-        )
-        assert fp_nfc == fp_nfd
-
-    def test_trailing_whitespace_tolerated(self) -> None:
-        """Trailing and leading whitespace is stripped, producing the same fingerprint."""
-        fp_clean = compute_requirement_content_fingerprint(
-            requirement_text="Validate health endpoint.",
-            requirement_category="Observability",
-        )
-        fp_whitespace = compute_requirement_content_fingerprint(
-            requirement_text="  Validate health endpoint.  ",
-            requirement_category="  Observability  ",
-        )
-        assert fp_clean == fp_whitespace
-
-    def test_empty_category_allowed(self) -> None:
-        """Empty category produces a valid fingerprint (category defaults to empty string)."""
-        fp = compute_requirement_content_fingerprint(
-            requirement_text="Validate implementation.",
-        )
-        assert len(fp) == 64
-
-    def test_empty_text_produces_valid_fingerprint(self) -> None:
-        """Empty requirement text produces a valid SHA-256 fingerprint."""
-        fp = compute_requirement_content_fingerprint(
-            requirement_text="",
-            requirement_category="",
-        )
-        assert len(fp) == 64
-        assert all(c in "0123456789abcdef" for c in fp)
-
-
-# ============================================================================
-# Classification Fingerprint Computation (FR-114.2, DD-114.7)
-# ============================================================================
-
-
-class TestClassificationFingerprintComputation:
-    """Verify compute_classification_fingerprint stability and order independence."""
-
-    def test_produces_sha256_hex_digest(self) -> None:
-        """Classification fingerprint is a 64-character hexadecimal SHA-256 digest."""
-        fp = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert len(fp) == 64
-        assert all(c in "0123456789abcdef" for c in fp)
-
-    def test_stable_for_same_inputs(self) -> None:
-        """Same classification inputs produce the same fingerprint."""
-        fp1 = compute_classification_fingerprint(
-            analysis_mode="hybrid_balanced",
-            required_anchor_modalities=["code", "docs"],
-            project_scope_required=True,
-            finalization_policy="mixed_modalities_preserve_strong_code",
-        )
-        fp2 = compute_classification_fingerprint(
-            analysis_mode="hybrid_balanced",
-            required_anchor_modalities=["code", "docs"],
-            project_scope_required=True,
-            finalization_policy="mixed_modalities_preserve_strong_code",
-        )
-        assert fp1 == fp2
-
-    def test_modality_order_independence(self) -> None:
-        """Modality order does not affect the fingerprint (sorted internally)."""
-        fp_code_docs = compute_classification_fingerprint(
-            analysis_mode="hybrid_balanced",
-            required_anchor_modalities=["code", "docs"],
-            project_scope_required=False,
-            finalization_policy="mixed_modalities_preserve_strong_code",
-        )
-        fp_docs_code = compute_classification_fingerprint(
-            analysis_mode="hybrid_balanced",
-            required_anchor_modalities=["docs", "code"],
-            project_scope_required=False,
-            finalization_policy="mixed_modalities_preserve_strong_code",
-        )
-        assert fp_code_docs == fp_docs_code
-
-    def test_different_mode_produces_different_fingerprint(self) -> None:
-        """Different analysis_mode produces a different fingerprint."""
-        fp1 = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        fp2 = compute_classification_fingerprint(
-            analysis_mode="docs_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert fp1 != fp2
-
-    def test_different_project_scope_produces_different_fingerprint(self) -> None:
-        """Different project_scope_required produces a different fingerprint."""
-        fp_false = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        fp_true = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=True,
-            finalization_policy="code_substantive_required",
-        )
-        assert fp_false != fp_true
-
-    def test_different_finalization_policy_produces_different_fingerprint(self) -> None:
-        """Different finalization_policy produces a different fingerprint."""
-        fp1 = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        fp2 = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="infra_negative_allow_generic",
-        )
-        assert fp1 != fp2
-
-    def test_empty_modalities_handled(self) -> None:
-        """Empty modalities list produces a valid fingerprint."""
-        fp = compute_classification_fingerprint(
-            analysis_mode="docs_first",
-            required_anchor_modalities=[],
-            project_scope_required=False,
-            finalization_policy="docs_primary",
-        )
-        assert len(fp) == 64
-
-    def test_whitespace_modalities_filtered(self) -> None:
-        """Whitespace-only modalities are filtered out before fingerprinting."""
-        fp_clean = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code"],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        fp_with_whitespace = compute_classification_fingerprint(
-            analysis_mode="code_first",
-            required_anchor_modalities=["code", "  ", ""],
-            project_scope_required=False,
-            finalization_policy="code_substantive_required",
-        )
-        assert fp_clean == fp_with_whitespace
-
-
-# ============================================================================
-# Phase 114 + Phase 113 Coexistence (FR-113.1 + FR-114.1)
-# ============================================================================
-
-
-class TestPhase114Phase113Coexistence:
-    """Verify Phase 114 fields coexist with Phase 113 execution_scope_class."""
-
-    def test_execution_scope_class_and_phase114_fields_coexist(self) -> None:
-        """All Phase 113 and Phase 114 fields can be set simultaneously."""
-        result = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            project_scope_required=True,
-            execution_scope_class="cross_repo_code_required",
-            heuristic_confidence=0.85,
-            classification_source="nlp_enrichment",
-            content_fingerprint="abc" * 20 + "abcd",
-            classification_fingerprint="def" * 20 + "defg",
-            nlp_exemplar_similarity=0.92,
-        )
-
-        assert result.execution_scope_class == "cross_repo_code_required"
-        assert result.heuristic_confidence == 0.85
-        assert result.classification_source == "nlp_enrichment"
-        assert result.nlp_exemplar_similarity == 0.92
-
-    def test_from_mapping_preserves_both_phase113_and_phase114(self) -> None:
-        """from_mapping preserves both execution_scope_class and Phase 114 fields."""
-        parsed = RequirementAnalysisResult.from_mapping(
-            {
-                "analysis_mode": "hybrid_balanced",
-                "execution_scope_class": "project_doc_authoritative",
-                "project_scope_required": True,
-                "required_anchor_modalities": ["code", "docs"],
-                "finalization_policy": "mixed_modalities_preserve_strong_code",
-                "heuristic_confidence": 0.68,
-                "classification_source": "dspy_classifier",
-                "content_fingerprint": "x" * 64,
-                "classification_fingerprint": "y" * 64,
-                "nlp_exemplar_similarity": 0.77,
-            }
-        )
-
-        assert parsed is not None
-        # Phase 113
-        assert parsed.execution_scope_class == "project_doc_authoritative"
-        assert parsed.project_scope_required is True
-        # Phase 114
-        assert parsed.heuristic_confidence == 0.68
-        assert parsed.classification_source == "dspy_classifier"
-        assert parsed.content_fingerprint == "x" * 64
-        assert parsed.classification_fingerprint == "y" * 64
-        assert parsed.nlp_exemplar_similarity == 0.77
-
-    def test_analyze_requirement_populates_both_phase113_and_phase114(self) -> None:
-        """analyze_requirement_intent populates execution_scope_class and Phase 114 fields."""
-        result = analyze_requirement_intent(
-            requirement_text=("No Circular Dependency: Không có cycle trong dependency graph giữa modules/services."),
-            requirement_category="1. Decoupling",
-            interpretation={
-                "evidence_targets": ["code"],
-                "code_markers": ["decoupling"],
-            },
-            code_candidate_paths=["src/main/java/com/example/domain/OrderUseCase.java"],
-        )
-
-        # Phase 113
-        assert result.execution_scope_class == "cross_repo_code_required"
-        assert result.project_scope_required is True
-        # Phase 114
-        assert result.classification_source == "heuristic"
-        assert 0.0 <= result.heuristic_confidence <= 1.0
-        assert len(result.content_fingerprint) == 64
-        assert len(result.classification_fingerprint) == 64
-        assert result.nlp_exemplar_similarity == 0.0  # NLP not applied in heuristic layer
-
-    def test_repo_local_scope_with_phase114_defaults(self) -> None:
-        """repo_local scope rows also carry Phase 114 fields."""
-        result = analyze_requirement_intent(
-            requirement_text="Validate README.md documentation.",
-            requirement_category="Documentation",
-            interpretation={"evidence_targets": ["docs"]},
-            code_candidate_paths=[],
-        )
-
-        assert result.execution_scope_class == "repo_local"
-        assert result.classification_source == "heuristic"
-        assert len(result.content_fingerprint) == 64
-        assert len(result.classification_fingerprint) == 64
-        assert result.heuristic_confidence > 0.0
-
-
-# ============================================================================
-# analyze_requirement_intent Phase 114 Integration (FR-114.1, FR-114.2)
-# ============================================================================
-
-
-class TestAnalyzeRequirementIntentPhase114:
-    """Verify analyze_requirement_intent populates Phase 114 fields end-to-end."""
-
-    def test_heuristic_confidence_increases_with_more_markers(self) -> None:
-        """More corroborating markers produce higher heuristic_confidence."""
-        # Simple docs-only requirement (few markers)
-        result_simple = analyze_requirement_intent(
-            requirement_text="Validate API documentation.",
-            interpretation={"evidence_targets": ["docs"]},
-            code_candidate_paths=[],
-        )
-
-        # Complex multi-signal requirement (many markers)
-        result_complex = analyze_requirement_intent(
-            requirement_text=(
-                "Validate dependency graph and circular dependency decoupling "
-                "between modules/services for clean architecture."
-            ),
-            requirement_category="1. Decoupling",
-            interpretation={
-                "evidence_targets": ["code"],
-                "code_markers": ["decoupling", "implementation"],
-            },
-            code_candidate_paths=[
-                "src/main/java/com/example/domain/OrderUseCase.java",
-                "src/main/java/com/example/config/AppConfig.java",
-            ],
-        )
-
-        assert result_complex.heuristic_confidence > result_simple.heuristic_confidence
-
-    def test_heuristic_confidence_never_exceeds_0_9(self) -> None:
-        """heuristic_confidence from analyze_requirement_intent is capped at 0.9."""
-        result = analyze_requirement_intent(
-            requirement_text=(
-                "Validate dependency graph circular dependency decoupling "
-                "modules/services hexagonal architecture deployment Dockerfile."
-            ),
-            requirement_category="1. Decoupling",
-            interpretation={
-                "evidence_targets": ["code", "docs"],
-                "code_markers": ["decoupling", "implementation"],
-                "docs_markers": ["architecture"],
-            },
-            code_candidate_paths=[
-                "src/main/java/com/example/service/OrderService.java",
-                "Dockerfile",
-            ],
-        )
-
-        assert result.heuristic_confidence <= 0.9
-
-    def test_classification_source_always_heuristic_from_analyze(self) -> None:
-        """analyze_requirement_intent always sets classification_source='heuristic'."""
-        result = analyze_requirement_intent(
-            requirement_text="Validate health endpoint implementation.",
-            interpretation={"evidence_targets": ["code"], "code_markers": ["implementation"]},
-            code_candidate_paths=["src/main/java/com/example/HealthController.java"],
-        )
-
-        assert result.classification_source == "heuristic"
-
-    def test_content_fingerprint_deterministic_across_calls(self) -> None:
-        """Multiple calls with same inputs produce the same content_fingerprint."""
-        result1 = analyze_requirement_intent(
-            requirement_text="Validate health endpoint implementation.",
-            requirement_category="Observability",
-            interpretation={"evidence_targets": ["code"], "code_markers": ["implementation"]},
-            code_candidate_paths=["src/main/java/com/example/HealthController.java"],
-        )
-        result2 = analyze_requirement_intent(
-            requirement_text="Validate health endpoint implementation.",
-            requirement_category="Observability",
-            interpretation={"evidence_targets": ["code"], "code_markers": ["implementation"]},
-            code_candidate_paths=["src/main/java/com/example/HealthController.java"],
-        )
-
-        assert result1.content_fingerprint == result2.content_fingerprint
-        assert result1.classification_fingerprint == result2.classification_fingerprint
-
-    def test_nlp_exemplar_similarity_zero_from_heuristic_layer(self) -> None:
-        """NLP exemplar similarity is 0.0 when only the heuristic layer runs."""
-        result = analyze_requirement_intent(
-            requirement_text="Validate Kubernetes deployment artifacts.",
-            interpretation={"evidence_targets": ["code"]},
-            code_candidate_paths=["Dockerfile"],
-        )
-
-        assert result.nlp_exemplar_similarity == 0.0
-
-    def test_content_fingerprint_matches_standalone_computation(self) -> None:
-        """Content fingerprint from analyze matches compute_requirement_content_fingerprint."""
-        text = "Validate OpenAPI specification."
-        category = "API Documentation"
-
-        result = analyze_requirement_intent(
-            requirement_text=text,
-            requirement_category=category,
-            interpretation={"evidence_targets": ["docs"], "docs_markers": ["openapi"]},
-            code_candidate_paths=[],
-        )
-
-        standalone_fp = compute_requirement_content_fingerprint(
-            requirement_text=text,
-            requirement_category=category,
-        )
-
-        assert result.content_fingerprint == standalone_fp
-
-    def test_classification_fingerprint_matches_standalone_computation(self) -> None:
-        """Classification fingerprint from analyze matches compute_classification_fingerprint."""
-        result = analyze_requirement_intent(
-            requirement_text="Validate health endpoint implementation.",
-            requirement_category="Observability",
-            interpretation={
-                "evidence_targets": ["code"],
-                "code_markers": ["implementation"],
-            },
-            code_candidate_paths=[
-                "src/main/java/com/example/metrics/HealthProbeController.java",
-            ],
-        )
-
-        standalone_fp = compute_classification_fingerprint(
-            analysis_mode=result.analysis_mode,
-            required_anchor_modalities=result.required_anchor_modalities,
-            project_scope_required=result.project_scope_required,
-            finalization_policy=result.finalization_policy,
-        )
-
-        assert result.classification_fingerprint == standalone_fp
-
-
-# ============================================================================
-# Frozen Dataclass Immutability (structural contract)
-# ============================================================================
-
-
-class TestFrozenDataclassContract:
-    """RequirementAnalysisResult is frozen; Phase 114 fields must be immutable."""
-
-    def test_phase114_fields_immutable(self) -> None:
-        """Phase 114 fields cannot be modified after construction (frozen dataclass)."""
-        result = RequirementAnalysisResult(
-            analysis_mode="code_first",
-            heuristic_confidence=0.7,
-            classification_source="heuristic",
-        )
-
-        with pytest.raises(AttributeError):
-            result.heuristic_confidence = 0.9  # type: ignore[misc]
-
-        with pytest.raises(AttributeError):
-            result.classification_source = "nlp_enrichment"  # type: ignore[misc]
-
-        with pytest.raises(AttributeError):
-            result.content_fingerprint = "new_fp"  # type: ignore[misc]
-
-        with pytest.raises(AttributeError):
-            result.nlp_exemplar_similarity = 0.5  # type: ignore[misc]
-
-
-# ============================================================================
-# Diagnostic Keys Registry (Phase 114 contract)
-# ============================================================================
-
-
-class TestDiagnosticKeysIncludePhase114:
-    """Verify Phase 114 field names are registered in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS."""
-
-    def test_diagnostic_keys_include_heuristic_confidence(self) -> None:
-        """heuristic_confidence is in the diagnostic keys tuple."""
-        from vds_audit_orchestrator.engine.requirement_analysis import (
-            _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS,
-        )
-
-        assert "heuristic_confidence" in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS
-
-    def test_diagnostic_keys_include_classification_source(self) -> None:
-        """classification_source is in the diagnostic keys tuple."""
-        from vds_audit_orchestrator.engine.requirement_analysis import (
-            _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS,
-        )
-
-        assert "classification_source" in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS
-
-    def test_diagnostic_keys_include_content_fingerprint(self) -> None:
-        """content_fingerprint is in the diagnostic keys tuple."""
-        from vds_audit_orchestrator.engine.requirement_analysis import (
-            _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS,
-        )
-
-        assert "content_fingerprint" in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS
-
-    def test_diagnostic_keys_include_classification_fingerprint(self) -> None:
-        """classification_fingerprint is in the diagnostic keys tuple."""
-        from vds_audit_orchestrator.engine.requirement_analysis import (
-            _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS,
-        )
-
-        assert "classification_fingerprint" in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS
-
-    def test_diagnostic_keys_include_nlp_exemplar_similarity(self) -> None:
-        """nlp_exemplar_similarity is in the diagnostic keys tuple."""
-        from vds_audit_orchestrator.engine.requirement_analysis import (
-            _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS,
-        )
-
-        assert "nlp_exemplar_similarity" in _REQUIREMENT_ANALYSIS_DIAGNOSTIC_KEYS