@ngocsangairvds/vsaf 3.2.14 → 3.2.16

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

@@ -1,650 +0,0 @@
-"""Phase 84 routing precision tests (TSK-840.9)."""
-
-from __future__ import annotations
-
-from dataclasses import FrozenInstanceError
-
-import pytest
-from vds_audit_orchestrator.engine.row_evaluator_types import (
-    CODE_MARKER_KEYWORDS,
-    DOCS_MARKER_ALLOWLIST,
-    PROCESS_MARKER_KEYWORDS,
-    RouteDecision,
-    build_requirement_interpretation,
-)
-from vds_audit_orchestrator.engine.tool_first_planner import ToolFirstPlanner
-
-
-class TestRouteDecisionModel:
-    """RouteDecision dataclass contract tests."""
-
-    def test_construction_all_fields(self):
-        rd = RouteDecision(
-            route_id="docs_search_read_verify_synthesize",
-            route_confidence=0.9,
-            ambiguity_reason_codes=[],
-            route_reason="test",
-            required_steps=["search", "read"],
-            required_tools=["search_docs"],
-            docs_focused=True,
-            code_targets=[],
-            docs_target=True,
-            code_target=False,
-            route_mode="docs_only",
-        )
-        assert rd.route_id == "docs_search_read_verify_synthesize"
-        assert rd.route_confidence == 0.9
-        assert rd.docs_target is True
-        assert rd.route_mode == "docs_only"
-
-    def test_to_dict_roundtrip(self):
-        rd = RouteDecision(route_id="test", route_confidence=0.5, route_mode="hybrid")
-        d = rd.to_dict()
-        assert d["route_id"] == "test"
-        assert d["route_confidence"] == 0.5
-        assert d["route_mode"] == "hybrid"
-        assert isinstance(d, dict)
-
-    def test_to_dict_contains_all_keys(self):
-        rd = RouteDecision(route_id="x", route_confidence=0.7)
-        d = rd.to_dict()
-        expected_keys = {
-            "route_id",
-            "route_confidence",
-            "ambiguity_reason_codes",
-            "route_reason",
-            "required_steps",
-            "required_tools",
-            "docs_focused",
-            "code_targets",
-            "docs_target",
-            "code_target",
-            "route_mode",
-            "override_source",
-            "override_reason",
-        }
-        assert set(d.keys()) == expected_keys
-
-    def test_frozen_immutable(self):
-        rd = RouteDecision(route_id="test", route_confidence=0.5)
-        with pytest.raises(FrozenInstanceError):
-            rd.route_id = "changed"  # type: ignore[misc]
-
-    def test_frozen_immutable_confidence(self):
-        rd = RouteDecision(route_id="test", route_confidence=0.5)
-        with pytest.raises(FrozenInstanceError):
-            rd.route_confidence = 0.9  # type: ignore[misc]
-
-    def test_explain_format(self):
-        rd = RouteDecision(
-            route_id="hybrid_code_first_search_read_verify_synthesize",
-            route_confidence=0.5,
-            ambiguity_reason_codes=["mixed_marker_families"],
-            route_mode="hybrid_code_first",
-        )
-        explanation = rd.explain()
-        assert "route=hybrid_code_first" in explanation
-        assert "confidence=0.50" in explanation
-        assert "mixed_marker_families" in explanation
-
-    def test_explain_no_ambiguity(self):
-        rd = RouteDecision(
-            route_id="docs_search_read_verify_synthesize",
-            route_confidence=0.9,
-            ambiguity_reason_codes=[],
-            route_mode="docs_only",
-        )
-        explanation = rd.explain()
-        assert "route=docs_search_read_verify_synthesize" in explanation
-        assert "confidence=0.90" in explanation
-        assert "ambiguity" not in explanation
-
-    def test_defaults(self):
-        rd = RouteDecision(route_id="x", route_confidence=0.0)
-        assert rd.ambiguity_reason_codes == []
-        assert rd.required_steps == []
-        assert rd.required_tools == []
-        assert rd.docs_focused is False
-        assert rd.code_targets == []
-        assert rd.docs_target is False
-        assert rd.code_target is False
-        assert rd.route_mode == ""
-
-
-class TestMarkerTaxonomy:
-    """TSK-840.1: Interpretation marker taxonomy tests."""
-
-    def test_docs_markers_from_openapi_requirement(self):
-        interp = build_requirement_interpretation(
-            requirement_text="API specification must be documented in OpenAPI/Swagger format",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        docs_markers = interp.get("docs_markers", [])
-        assert len(docs_markers) > 0, "Should detect docs markers for OpenAPI requirement"
-
-    def test_code_markers_from_implementation_requirement(self):
-        interp = build_requirement_interpretation(
-            requirement_text="Source code must implement health check endpoint with proper HTTP status codes",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        code_markers = interp.get("code_markers", [])
-        assert len(code_markers) > 0, "Should detect code markers for implementation requirement"
-
-    def test_process_markers_from_governance_requirement(self):
-        interp = build_requirement_interpretation(
-            requirement_text="Compliance governance policy must be followed with approval gates and audit certification",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        process_markers = interp.get("process_markers", [])
-        assert len(process_markers) > 0, "Should detect process markers for governance requirement"
-
-    def test_mixed_markers_produce_conflicts(self):
-        interp = build_requirement_interpretation(
-            requirement_text="Confluence documentation must describe the source code implementation of the API specification",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        docs_markers = interp.get("docs_markers", [])
-        code_markers = interp.get("code_markers", [])
-        marker_conflicts = interp.get("marker_conflicts", [])
-        if docs_markers and code_markers:
-            assert len(marker_conflicts) > 0, "Mixed markers should produce conflicts"
-
-    def test_no_markers_produces_empty_lists(self):
-        interp = build_requirement_interpretation(
-            requirement_text="General quality assessment criteria",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        assert isinstance(interp.get("docs_markers", []), list)
-        assert isinstance(interp.get("code_markers", []), list)
-        assert isinstance(interp.get("marker_conflicts", []), list)
-
-    def test_docs_marker_allowlist_contains_expected_terms(self):
-        assert "openapi" in DOCS_MARKER_ALLOWLIST
-        assert "swagger" in DOCS_MARKER_ALLOWLIST
-        assert "confluence" in DOCS_MARKER_ALLOWLIST
-        assert "runbook" in DOCS_MARKER_ALLOWLIST
-
-    def test_code_marker_keywords_contains_expected_terms(self):
-        assert "implementation" in CODE_MARKER_KEYWORDS
-        assert "source code" in CODE_MARKER_KEYWORDS
-        assert "dockerfile" in CODE_MARKER_KEYWORDS
-
-    def test_process_marker_keywords_contains_expected_terms(self):
-        assert "compliance" in PROCESS_MARKER_KEYWORDS
-        assert "governance" in PROCESS_MARKER_KEYWORDS
-        assert "policy" in PROCESS_MARKER_KEYWORDS
-        assert "audit" in PROCESS_MARKER_KEYWORDS
-
-    def test_marker_conflict_format(self):
-        interp = build_requirement_interpretation(
-            requirement_text="Confluence runbook must describe the source code implementation",
-            requirement_category=None,
-            requirement_guidance=None,
-        )
-        marker_conflicts = interp.get("marker_conflicts", [])
-        if marker_conflicts:
-            for conflict in marker_conflicts:
-                assert "docs_marker" in conflict
-                assert "code_marker" in conflict
-
-
-class TestRouteSelection:
-    """TSK-840.3/840.4: Route selection and ambiguity policy tests."""
-
-    @staticmethod
-    def _make_context(
-        requirement_interpretation: dict | None = None,
-        **overrides: object,
-    ) -> dict:
-        base: dict = {}
-        if requirement_interpretation is not None:
-            base["requirement_interpretation"] = requirement_interpretation
-        base.update(overrides)
-        return base
-
-    def test_resolve_returns_route_decision_type(self):
-        ctx = self._make_context()
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Check source code implementation",
-            requirement_category="quality",
-        )
-        assert isinstance(route, RouteDecision)
-
-    def test_high_confidence_docs_only_gets_docs_route(self):
-        interp = {
-            "docs_markers": ["openapi", "confluence"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="OpenAPI specification must be documented in Confluence",
-            requirement_category="documentation",
-        )
-        assert isinstance(route, RouteDecision)
-        # Docs-only markers should produce docs-focused route
-        assert route.docs_focused is True or "docs" in route.route_id
-
-    def test_mixed_signals_get_hybrid_fallback(self):
-        interp = {
-            "docs_markers": ["confluence"],
-            "code_markers": ["implementation"],
-            "marker_conflicts": ["docs_marker 'confluence' conflicts with code_marker 'implementation'"],
-            "evidence_targets": ["docs", "code"],
-            "code_targets": [],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Implementation code and Confluence documentation for API",
-            requirement_category="quality",
-        )
-        assert isinstance(route, RouteDecision)
-        # Mixed markers should lower confidence
-        assert route.route_confidence < 0.8
-        assert (
-            "mixed_marker_families" in route.ambiguity_reason_codes
-            or "marker_conflict_detected" in route.ambiguity_reason_codes
-        )
-
-    def test_no_marker_signal_gets_low_confidence(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": [],
-            "code_targets": [],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="General quality assessment",
-            requirement_category="quality",
-        )
-        assert isinstance(route, RouteDecision)
-        assert route.route_confidence <= 0.6
-
-    def test_route_decision_has_required_fields(self):
-        ctx = self._make_context()
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Check health endpoint implementation",
-            requirement_category="operations",
-        )
-        assert route.route_id != ""
-        assert route.route_reason != ""
-        assert isinstance(route.required_steps, list)
-        assert isinstance(route.required_tools, list)
-        assert 0.0 <= route.route_confidence <= 1.0
-
-    def test_code_only_markers_get_code_route(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": ["implementation", "dockerfile"],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["Dockerfile"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Dockerfile implementation must use multi-stage builds",
-            requirement_category="operations",
-        )
-        assert isinstance(route, RouteDecision)
-        assert route.code_target is True
-        assert "code" in route.route_id or route.route_mode in ("code_only", "hybrid_code_first")
-
-    def test_docs_target_db_decoupling_interpretation_promotes_code_only(self):
-        """Phase 123: Decoupling category rows always get code_only route.
-
-        DB-decoupling rows previously got hybrid_code_first when docs evidence
-        targets were present.  The decoupling category override now forces
-        code_only for all CL-001..CL-006 rows because architecture compliance
-        is purely a source-code concern.
-        """
-        interp = {
-            "docs_markers": [],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [
-                "src/main/java/com/example/config/database/CampaignDatabaseConfig.java",
-                "src/main/java/com/example/config/database/MongoDatabaseConfig.java",
-            ],
-            "control_objective": "1. Decoupling",
-            "acceptance_signals": ["Noi dung chinh: Tach biet Database"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text=(
-                "Moi service su dung Schema/DB instance rieng, khong co connection string tro sang DB cua service khac."
-            ),
-            requirement_category="1. Decoupling",
-        )
-        assert isinstance(route, RouteDecision)
-        assert route.code_target is True
-        assert route.docs_target is False
-        assert route.route_mode == "code_only"
-        assert ctx.get("decoupling_code_only_override") is True
-
-    def test_route_to_dict_survives_sync(self):
-        """Route decision dict output is compatible with _sync_route_context."""
-        ctx = self._make_context()
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Test requirement text",
-            requirement_category="quality",
-        )
-        d = route.to_dict()
-        assert "route_id" in d
-        assert "route_reason" in d
-        assert "required_steps" in d
-        assert "required_tools" in d
-        assert "docs_target" in d
-        assert "code_target" in d
-        assert "route_mode" in d
-
-    def test_sync_route_context_emits_phase84_route_payload_contract(self):
-        ctx = self._make_context()
-        route = RouteDecision(
-            route_id="hybrid_code_first_search_read_verify_synthesize",
-            route_confidence=0.63,
-            ambiguity_reason_codes=["mixed_marker_families"],
-            route_reason="targets=docs,code; control_objective=quality; risk_focus=quality",
-            required_steps=["search", "read", "verify", "synthesize"],
-            required_tools=["search_code", "read_code_file", "search_docs", "read_doc_chunk"],
-            docs_focused=False,
-            code_targets=["src/app.py"],
-            docs_target=True,
-            code_target=True,
-            route_mode="hybrid_code_first",
-            override_source="row_map",
-            override_reason="Row-specific override: R-7 -> hybrid_code_first",
-        )
-
-        ToolFirstPlanner._sync_route_context(ctx, route)
-
-        decision = ctx["tool_first_route_decision"]
-        assert set(decision.keys()) == {
-            "route_id",
-            "route_reason",
-            "route_confidence",
-            "ambiguity_reason_codes",
-            "required_steps",
-            "required_tools",
-            "docs_target",
-            "code_target",
-            "route_mode",
-            "override_source",
-            "override_reason",
-        }
-        assert decision["route_id"] == "hybrid_code_first_search_read_verify_synthesize"
-        assert decision["route_mode"] == "hybrid_code_first"
-        assert decision["docs_target"] is True
-        assert decision["code_target"] is True
-        assert decision["route_confidence"] == pytest.approx(0.63, abs=1e-6)
-        assert decision["ambiguity_reason_codes"] == ["mixed_marker_families"]
-        assert decision["override_source"] == "row_map"
-        assert "Row-specific override" in decision["override_reason"]
-        assert ctx["route_id"] == decision["route_id"]
-        assert ctx["required_steps"] == decision["required_steps"]
-        assert ctx["required_tools"] == decision["required_tools"]
-
-    def test_process_only_markers_no_no_marker_signal(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": [],
-            "process_markers": ["compliance", "governance", "audit"],
-            "marker_conflicts": [],
-            "evidence_targets": [],
-            "code_targets": [],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Compliance governance policy with audit certification",
-            requirement_category="governance",
-        )
-        assert "no_marker_signal" not in route.ambiguity_reason_codes
-        assert "process_marker_signal" in route.ambiguity_reason_codes
-        assert route.route_confidence >= 0.7
-
-    def test_process_markers_with_workflow_and_code_signal_bias_to_hybrid_docs_first(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": ["health endpoint"],
-            "process_markers": ["sla", "support"],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["src/main/java/com/example/health/HealthController.java"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="SLA support workflow for endpoint escalation and runbook evidence",
-            requirement_category="5. SLA & Support",
-        )
-        assert route.docs_target is True
-        assert route.route_mode == "hybrid_docs_first"
-        assert "process_marker_docs_bias" in route.ambiguity_reason_codes
-
-    def test_process_markers_with_grafana_signal_bias_to_hybrid_docs_first(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": [],
-            "process_markers": ["sla", "support"],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["src/main/java/com/example/monitoring/DashboardConfig.java"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Cung cấp Dashboard Grafana theo dõi throughput, latency, error rate cho SLA support.",
-            requirement_category="5. SLA & Support",
-        )
-        assert route.docs_target is True
-        assert route.route_mode == "hybrid_docs_first"
-        assert "process_marker_docs_bias" in route.ambiguity_reason_codes
-
-    def test_process_markers_with_endpoint_only_signal_keeps_code_only_route(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": ["health endpoint"],
-            "process_markers": ["sla", "support"],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["src/main/java/com/example/health/HealthController.java"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Validate /health and /metrics endpoint implementation for SLA support.",
-            requirement_category="5. SLA & Support",
-        )
-        assert route.docs_target is False
-        assert route.route_mode == "code_only"
-        assert "process_marker_docs_bias" not in route.ambiguity_reason_codes
-
-    def test_context_route_override_applied(self):
-        interp = {
-            "docs_markers": [],
-            "code_markers": ["implementation"],
-            "process_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["src/main.py"],
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        ctx["route_override"] = "docs_search_read_verify_synthesize"
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Validate implementation details",
-            requirement_category="quality",
-        )
-        assert route.route_id == "docs_search_read_verify_synthesize"
-        assert route.override_source == "cli"
-
-
-class TestLegacyHintRegression:
-    """Regression: legacy evidence_required must NOT influence routing."""
-
-    def test_evidence_required_not_in_routing_path(self):
-        ctx = {
-            "requirement_interpretation": {},
-        }
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Test requirement",
-            requirement_category="quality",
-        )
-        # Route should be determined by marker taxonomy, not evidence_required
-        assert isinstance(route, RouteDecision)
-        # evidence_required should not appear in ambiguity reasons
-        assert "evidence_required" not in str(route.ambiguity_reason_codes)
-
-    def test_evidence_required_in_config_does_not_alter_route(self):
-        """Even if check_config has evidence_required, route stays marker-driven."""
-        interp = {
-            "docs_markers": ["openapi"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-        }
-        ctx = {
-            "requirement_interpretation": interp,
-            "check_config": {"evidence_required": True},
-        }
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="OpenAPI specification documented",
-            requirement_category="documentation",
-        )
-        assert isinstance(route, RouteDecision)
-        assert "evidence_required" not in str(route.ambiguity_reason_codes)
-        assert "evidence_required" not in route.route_reason
-
-
-class TestGuidanceCodeSignalOverride:
-    """Phase 123: Guidance-based code signal forces hybrid route for CL-004-like rows."""
-
-    @staticmethod
-    def _make_context(
-        requirement_interpretation: dict | None = None,
-        **overrides: object,
-    ) -> dict:
-        base: dict = {}
-        if requirement_interpretation is not None:
-            base["requirement_interpretation"] = requirement_interpretation
-        base.update(overrides)
-        return base
-
-    def test_pom_xml_in_guidance_forces_code_target(self):
-        """When guidance mentions pom.xml, route must not be docs_only."""
-        interp = {
-            "docs_markers": ["architecture"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-            "detailed_guidance": (
-                "Kiểm tra không có circular dependency. Phân tích dependency graph: kiểm tra pom.xml/build.gradle."
-            ),
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Kiểm tra không có circular dependency giữa các repo trong project",
-            requirement_category="architecture",
-        )
-        assert route.route_mode != "docs_only", f"Expected hybrid route, got {route.route_mode}"
-        assert route.code_target is True
-        assert "guidance_code_signal_override" in route.ambiguity_reason_codes
-
-    def test_build_gradle_in_guidance_forces_code_target(self):
-        """build.gradle in guidance also triggers the override."""
-        interp = {
-            "docs_markers": ["process"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-            "detailed_guidance": "Check build.gradle for dependency declarations.",
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Verify dependency management",
-            requirement_category="quality",
-        )
-        assert route.route_mode != "docs_only"
-        assert route.code_target is True
-
-    def test_dependency_graph_in_guidance_forces_code_target(self):
-        """'dependency graph' in guidance triggers the override."""
-        interp = {
-            "docs_markers": ["documentation"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-            "detailed_guidance": "Phân tích dependency graph của project.",
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Check project dependencies",
-            requirement_category="architecture",
-        )
-        assert route.route_mode != "docs_only"
-        assert route.code_target is True
-
-    def test_no_guidance_code_markers_stays_docs_only(self):
-        """Without code markers in guidance, docs-only route is preserved."""
-        interp = {
-            "docs_markers": ["openapi"],
-            "code_markers": [],
-            "marker_conflicts": [],
-            "evidence_targets": ["docs"],
-            "code_targets": [],
-            "detailed_guidance": "Kiểm tra tài liệu API specification.",
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="API documentation exists",
-            requirement_category="documentation",
-        )
-        assert route.route_mode == "docs_only"
-        assert "guidance_code_signal_override" not in route.ambiguity_reason_codes
-
-    def test_guidance_override_with_code_already_targeted(self):
-        """If code_target is already True, guidance marker still appears in reasons."""
-        interp = {
-            "docs_markers": [],
-            "code_markers": ["implementation"],
-            "marker_conflicts": [],
-            "evidence_targets": ["code"],
-            "code_targets": ["src/main/java/App.java"],
-            "detailed_guidance": "Check pom.xml for versions.",
-        }
-        ctx = self._make_context(requirement_interpretation=interp)
-        route = ToolFirstPlanner._resolve_route_decision(
-            context=ctx,
-            requirement_text="Verify code implementation",
-            requirement_category="quality",
-        )
-        assert route.code_target is True
-        assert "guidance_code_signal_override" in route.ambiguity_reason_codes