@pennyfarthing/core 11.0.0 → 11.1.1

package/pennyfarthing_scripts/tests/test_confidence_sm_gate.py

@@ -0,0 +1,315 @@
+"""Tests for SM confidence gate file — Story 90-2.
+
+Epic: 90 (Confidence Circuit Breaker via Gate)
+Story: 90-2 — Implement SM confidence gate file
+
+Tests the confidence-sm gate file that checks whether an instruction to the
+SM agent is ambiguous. If ambiguous, <fail> returns clarifying options. If
+unambiguous, <pass> lets the agent proceed.
+
+Acceptance Criteria:
+- [AC1] Gate file exists in pennyfarthing-dist/gates/ following Gate PRD schema
+- [AC2] Gate has <gate>, <purpose>, <pass>, <fail> blocks
+- [AC3] Gate checks whether SM instruction is ambiguous
+- [AC4] <fail> block returns clarifying options when ambiguous
+- [AC5] <pass> block lets the agent proceed when unambiguous
+- [AC6] Gate uses model="haiku"
+- [AC7] Gate validates against existing schema (same structure as tests-pass.md)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from pennyfarthing_scripts.handoff.gate_file import resolve_gate_file
+from pennyfarthing_scripts.handoff.gate_runner import parse_gate_file
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+GATE_NAME = "confidence-sm"
+
+# The gate file lives in pennyfarthing-dist/gates/ relative to the framework root
+# In the dogfooding context, the project root is the orchestrator, so we need
+# to resolve paths relative to this test file.
+_THIS_DIR = Path(__file__).resolve().parent
+_SCRIPTS_DIR = _THIS_DIR.parent  # pennyfarthing_scripts/
+_FRAMEWORK_ROOT = _SCRIPTS_DIR.parent  # pennyfarthing/
+_GATE_FILE = _FRAMEWORK_ROOT / "pennyfarthing-dist" / "gates" / f"{GATE_NAME}.md"
+
+
+@pytest.fixture
+def gate_path() -> Path:
+    """Return the expected path to the confidence-sm gate file."""
+    return _GATE_FILE
+
+
+@pytest.fixture
+def gate_content(gate_path: Path) -> str:
+    """Read and return the gate file content. Fails if file missing."""
+    assert gate_path.is_file(), f"Gate file not found: {gate_path}"
+    return gate_path.read_text()
+
+
+@pytest.fixture
+def parsed_gate(gate_path: Path) -> dict:
+    """Parse the gate file using the gate runner's parse_gate_file."""
+    return parse_gate_file(gate_path)
+
+
+# ===========================================================================
+# AC1: Gate file exists in pennyfarthing-dist/gates/
+# ===========================================================================
+
+
+class TestGateFileExists:
+    """AC1: Gate file exists at the expected location."""
+
+    def test_gate_file_exists(self, gate_path: Path) -> None:
+        """AC1: confidence-sm.md exists in pennyfarthing-dist/gates/."""
+        assert gate_path.is_file(), f"Gate file not found: {gate_path}"
+
+    def test_gate_file_not_empty(self, gate_path: Path) -> None:
+        """AC1: Gate file is not empty."""
+        assert gate_path.is_file(), f"Gate file not found: {gate_path}"
+        content = gate_path.read_text()
+        assert len(content.strip()) > 0, "Gate file is empty"
+
+    def test_gate_discoverable(self, gate_path: Path) -> None:
+        """AC1: Gate is discoverable via resolve_gate_file()."""
+        # Use the framework root which has pennyfarthing-dist/gates/
+        result = resolve_gate_file(GATE_NAME, project_root=_FRAMEWORK_ROOT)
+        assert result["status"] == "found", (
+            f"Gate not discoverable: {result.get('error')}"
+        )
+
+    def test_gate_discoverable_with_prefix(self, gate_path: Path) -> None:
+        """AC1: Gate discoverable with gates/ prefix."""
+        result = resolve_gate_file(
+            f"gates/{GATE_NAME}", project_root=_FRAMEWORK_ROOT
+        )
+        assert result["status"] == "found"
+
+
+# ===========================================================================
+# AC2: Gate has <gate>, <purpose>, <pass>, <fail> blocks
+# ===========================================================================
+
+
+class TestGateSchemaStructure:
+    """AC2: Gate file has all required XML-tagged blocks."""
+
+    def test_has_gate_tag(self, gate_content: str) -> None:
+        """AC2: File contains a <gate> opening tag."""
+        assert "<gate " in gate_content or "<gate>" in gate_content
+
+    def test_has_closing_gate_tag(self, gate_content: str) -> None:
+        """AC2: File contains a </gate> closing tag."""
+        assert "</gate>" in gate_content
+
+    def test_has_purpose_block(self, gate_content: str) -> None:
+        """AC2: File contains <purpose> and </purpose> tags."""
+        assert "<purpose>" in gate_content
+        assert "</purpose>" in gate_content
+
+    def test_has_pass_block(self, gate_content: str) -> None:
+        """AC2: File contains <pass> and </pass> tags."""
+        assert "<pass>" in gate_content
+        assert "</pass>" in gate_content
+
+    def test_has_fail_block(self, gate_content: str) -> None:
+        """AC2: File contains <fail> and </fail> tags."""
+        assert "<fail>" in gate_content
+        assert "</fail>" in gate_content
+
+    def test_parses_without_error(self, parsed_gate: dict) -> None:
+        """AC2: parse_gate_file returns status 'ok'."""
+        assert parsed_gate["status"] == "ok", (
+            f"Parse error: {parsed_gate.get('error')}"
+        )
+
+
+# ===========================================================================
+# AC3: Gate checks whether SM instruction is ambiguous
+# ===========================================================================
+
+
+class TestGateAmbiguityDetection:
+    """AC3: Gate content describes checking for ambiguous SM instructions."""
+
+    def test_purpose_mentions_ambiguity(self, gate_content: str) -> None:
+        """AC3: Purpose section references ambiguity or unclear instructions."""
+        # Extract purpose content between tags
+        import re
+
+        purpose_match = re.search(
+            r"<purpose>(.*?)</purpose>", gate_content, re.DOTALL
+        )
+        assert purpose_match is not None, "No <purpose> block found"
+        purpose = purpose_match.group(1).lower()
+        assert any(
+            term in purpose
+            for term in ["ambig", "unclear", "vague", "confidence", "clarif"]
+        ), f"Purpose doesn't reference ambiguity: {purpose}"
+
+    def test_gate_name_is_confidence_sm(self, parsed_gate: dict) -> None:
+        """AC3: Gate name is 'confidence-sm'."""
+        assert parsed_gate["name"] == GATE_NAME
+
+    def test_content_references_sm_agent(self, gate_content: str) -> None:
+        """AC3: Gate content references the SM agent or scrum master role."""
+        content_lower = gate_content.lower()
+        assert any(
+            term in content_lower
+            for term in ["sm agent", "scrum master", "sm ", "story management"]
+        ), "Gate doesn't reference SM agent"
+
+
+# ===========================================================================
+# AC4: <fail> block returns clarifying options when ambiguous
+# ===========================================================================
+
+
+class TestGateFailBlock:
+    """AC4: Fail block provides clarifying options for ambiguous instructions."""
+
+    def test_fail_block_has_content(self, gate_content: str) -> None:
+        """AC4: Fail block is not empty."""
+        import re
+
+        fail_match = re.search(r"<fail>(.*?)</fail>", gate_content, re.DOTALL)
+        assert fail_match is not None, "No <fail> block found"
+        fail_content = fail_match.group(1).strip()
+        assert len(fail_content) > 0, "Fail block is empty"
+
+    def test_fail_block_mentions_clarification(self, gate_content: str) -> None:
+        """AC4: Fail block mentions clarifying or asking for more info."""
+        import re
+
+        fail_match = re.search(r"<fail>(.*?)</fail>", gate_content, re.DOTALL)
+        assert fail_match is not None
+        fail_content = fail_match.group(1).lower()
+        assert any(
+            term in fail_content
+            for term in ["clarif", "option", "which", "specify", "did you mean"]
+        ), f"Fail block doesn't offer clarifying options: {fail_content[:200]}"
+
+    def test_fail_block_has_gate_result(self, gate_content: str) -> None:
+        """AC4: Fail block includes GATE_RESULT template with status: fail."""
+        import re
+
+        fail_match = re.search(r"<fail>(.*?)</fail>", gate_content, re.DOTALL)
+        assert fail_match is not None
+        fail_content = fail_match.group(1)
+        assert "GATE_RESULT" in fail_content, "Fail block missing GATE_RESULT"
+        assert "status: fail" in fail_content, "Fail block missing status: fail"
+
+
+# ===========================================================================
+# AC5: <pass> block lets the agent proceed when unambiguous
+# ===========================================================================
+
+
+class TestGatePassBlock:
+    """AC5: Pass block describes proceeding when instruction is clear."""
+
+    def test_pass_block_has_content(self, gate_content: str) -> None:
+        """AC5: Pass block is not empty."""
+        import re
+
+        pass_match = re.search(r"<pass>(.*?)</pass>", gate_content, re.DOTALL)
+        assert pass_match is not None, "No <pass> block found"
+        pass_content = pass_match.group(1).strip()
+        assert len(pass_content) > 0, "Pass block is empty"
+
+    def test_pass_block_indicates_proceed(self, gate_content: str) -> None:
+        """AC5: Pass block indicates the agent should proceed."""
+        import re
+
+        pass_match = re.search(r"<pass>(.*?)</pass>", gate_content, re.DOTALL)
+        assert pass_match is not None
+        pass_content = pass_match.group(1).lower()
+        assert any(
+            term in pass_content
+            for term in ["proceed", "continue", "clear", "unambig", "confident"]
+        ), f"Pass block doesn't indicate proceeding: {pass_content[:200]}"
+
+    def test_pass_block_has_gate_result(self, gate_content: str) -> None:
+        """AC5: Pass block includes GATE_RESULT template with status: pass."""
+        import re
+
+        pass_match = re.search(r"<pass>(.*?)</pass>", gate_content, re.DOTALL)
+        assert pass_match is not None
+        pass_content = pass_match.group(1)
+        assert "GATE_RESULT" in pass_content, "Pass block missing GATE_RESULT"
+        assert "status: pass" in pass_content, "Pass block missing status: pass"
+
+
+# ===========================================================================
+# AC6: Gate uses model="haiku"
+# ===========================================================================
+
+
+class TestGateModel:
+    """AC6: Gate specifies model="haiku" per Gate PRD defaults."""
+
+    def test_model_is_haiku(self, parsed_gate: dict) -> None:
+        """AC6: parse_gate_file extracts model as 'haiku' from a valid gate."""
+        assert parsed_gate["status"] == "ok", (
+            f"Gate parse failed: {parsed_gate.get('error')}"
+        )
+        assert parsed_gate["model"] == "haiku", (
+            f"Expected model 'haiku', got '{parsed_gate['model']}'"
+        )
+
+    def test_gate_tag_has_model_attribute(self, gate_content: str) -> None:
+        """AC6: <gate> tag explicitly includes model="haiku"."""
+        import re
+
+        gate_match = re.search(r"<gate\b[^>]*>", gate_content)
+        assert gate_match is not None
+        gate_tag = gate_match.group(0)
+        assert 'model="haiku"' in gate_tag, (
+            f"<gate> tag missing model=\"haiku\": {gate_tag}"
+        )
+
+
+# ===========================================================================
+# AC7: Validates against existing schema (same structure as tests-pass.md)
+# ===========================================================================
+
+
+class TestGateSchemaConsistency:
+    """AC7: Gate follows the same structural patterns as tests-pass.md."""
+
+    def test_result_has_all_required_keys(self, parsed_gate: dict) -> None:
+        """AC7: parse_gate_file result has all expected keys and parse succeeds."""
+        assert parsed_gate["status"] == "ok", (
+            f"Gate parse failed: {parsed_gate.get('error')}"
+        )
+        for key in ("status", "name", "model", "content", "error"):
+            assert key in parsed_gate, f"Missing key: {key}"
+
+    def test_name_matches_filename(self, parsed_gate: dict) -> None:
+        """AC7: Gate name attribute matches the filename convention."""
+        assert parsed_gate["name"] == GATE_NAME
+
+    def test_content_is_full_file(self, gate_path: Path, parsed_gate: dict) -> None:
+        """AC7: Parsed content matches raw file read."""
+        assert parsed_gate["status"] == "ok"
+        raw = gate_path.read_text()
+        assert parsed_gate["content"] == raw
+
+    def test_gate_result_yaml_in_both_blocks(self, gate_content: str) -> None:
+        """AC7: Both pass and fail blocks include GATE_RESULT YAML blocks."""
+        import re
+
+        pass_match = re.search(r"<pass>(.*?)</pass>", gate_content, re.DOTALL)
+        fail_match = re.search(r"<fail>(.*?)</fail>", gate_content, re.DOTALL)
+        assert pass_match is not None
+        assert fail_match is not None
+        assert "GATE_RESULT:" in pass_match.group(1)
+        assert "GATE_RESULT:" in fail_match.group(1)

package/pennyfarthing_scripts/tests/test_gate_file_resolution.py

@@ -0,0 +1,341 @@
+"""Tests for gate file discovery and resolution — Story 106-4.
+
+Epic: 106 (Gate Files & First Migration)
+Story: 106-4 — Gate file discovery and resolution
+
+Tests the resolve_gate_file() function that locates gate definition files
+using a priority-based discovery algorithm.
+
+Acceptance Criteria:
+- [AC1] resolve_gate_file() resolves gate names to file paths
+- [AC2] Resolution order: .pennyfarthing/gates/{name}.md → pennyfarthing-dist/gates/{name}.md
+- [AC3] Non-existent gate file returns error/blocked status
+- [AC5] Tests cover: found in local, found in built-in, not found, symlink resolution
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from pennyfarthing_scripts.handoff.gate_file import resolve_gate_file
+
+# ---------------------------------------------------------------------------
+# Fixtures: Project structure
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def project(tmp_path: Path) -> Path:
+    """Create a minimal project structure with .pennyfarthing/ and gates."""
+    (tmp_path / ".pennyfarthing").mkdir()
+    (tmp_path / ".pennyfarthing" / "gates").mkdir()
+    (tmp_path / "pennyfarthing-dist" / "gates").mkdir(parents=True)
+    return tmp_path
+
+
+@pytest.fixture
+def project_with_builtin_gate(project: Path) -> Path:
+    """Project with a gate file in pennyfarthing-dist/gates/ only."""
+    gate = project / "pennyfarthing-dist" / "gates" / "tests-pass.md"
+    gate.write_text(
+        '<gate name="tests-pass" model="haiku">\n'
+        "  <purpose>Verify tests pass</purpose>\n"
+        "  <pass>Check tests</pass>\n"
+        "  <fail>Report failures</fail>\n"
+        "</gate>\n"
+    )
+    return project
+
+
+@pytest.fixture
+def project_with_local_gate(project: Path) -> Path:
+    """Project with a gate file in .pennyfarthing/gates/ only."""
+    gate = project / ".pennyfarthing" / "gates" / "custom-gate.md"
+    gate.write_text(
+        '<gate name="custom-gate" model="haiku">\n'
+        "  <purpose>Custom project gate</purpose>\n"
+        "  <pass>Custom pass</pass>\n"
+        "  <fail>Custom fail</fail>\n"
+        "</gate>\n"
+    )
+    return project
+
+
+@pytest.fixture
+def project_with_both_gates(project: Path) -> Path:
+    """Project with same gate in both locations (local should win)."""
+    # Built-in version
+    builtin = project / "pennyfarthing-dist" / "gates" / "tests-pass.md"
+    builtin.write_text(
+        '<gate name="tests-pass" model="haiku">\n'
+        "  <purpose>Built-in version</purpose>\n"
+        "  <pass>Built-in pass</pass>\n"
+        "  <fail>Built-in fail</fail>\n"
+        "</gate>\n"
+    )
+    # Local override
+    local = project / ".pennyfarthing" / "gates" / "tests-pass.md"
+    local.write_text(
+        '<gate name="tests-pass" model="haiku">\n'
+        "  <purpose>Local override version</purpose>\n"
+        "  <pass>Local pass</pass>\n"
+        "  <fail>Local fail</fail>\n"
+        "</gate>\n"
+    )
+    return project
+
+
+@pytest.fixture
+def project_with_symlinked_gates(project: Path) -> Path:
+    """Project where .pennyfarthing/gates is a symlink to pennyfarthing-dist/gates."""
+    import shutil
+
+    # Remove the real .pennyfarthing/gates dir
+    shutil.rmtree(project / ".pennyfarthing" / "gates")
+    # Create symlink (mimics real install)
+    (project / ".pennyfarthing" / "gates").symlink_to(
+        project / "pennyfarthing-dist" / "gates"
+    )
+    # Add a gate file to the source
+    gate = project / "pennyfarthing-dist" / "gates" / "tests-pass.md"
+    gate.write_text(
+        '<gate name="tests-pass" model="haiku">\n'
+        "  <purpose>Symlinked gate</purpose>\n"
+        "  <pass>Check tests</pass>\n"
+        "  <fail>Report failures</fail>\n"
+        "</gate>\n"
+    )
+    return project
+
+
+# ===========================================================================
+# AC1: resolve_gate_file() resolves gate names to file paths
+# ===========================================================================
+
+
+class TestResolveGateFileFound:
+    """AC1: Function returns path when gate file exists."""
+
+    def test_returns_found_status(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: Status should be 'found' when gate file exists."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result["status"] == "found"
+
+    def test_returns_absolute_path(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: Path should be an absolute path string."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result["path"] is not None
+        assert Path(result["path"]).is_absolute()
+
+    def test_path_points_to_existing_file(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: Returned path should point to an actual file."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert Path(result["path"]).is_file()
+
+    def test_error_is_none_when_found(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: Error field should be None when gate is found."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result["error"] is None
+
+    def test_strips_gates_prefix(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: 'gates/tests-pass' and 'tests-pass' should resolve the same."""
+        result_bare = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        result_prefixed = resolve_gate_file(
+            "gates/tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result_bare["path"] == result_prefixed["path"]
+
+    def test_result_has_required_fields(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC1: Result dict must have status, path, error keys."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert "status" in result
+        assert "path" in result
+        assert "error" in result
+
+
+# ===========================================================================
+# AC2: Resolution order — local first, built-in fallback
+# ===========================================================================
+
+
+class TestResolveGateFileOrder:
+    """AC2: .pennyfarthing/gates/ takes priority over pennyfarthing-dist/gates/."""
+
+    def test_local_gate_found(self, project_with_local_gate: Path) -> None:
+        """AC2: Gate in .pennyfarthing/gates/ should be found."""
+        result = resolve_gate_file(
+            "custom-gate", project_root=project_with_local_gate
+        )
+        assert result["status"] == "found"
+        assert ".pennyfarthing/gates/custom-gate.md" in result["path"]
+
+    def test_builtin_gate_found_as_fallback(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """AC2: Gate in pennyfarthing-dist/gates/ found when not in local."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result["status"] == "found"
+        assert "pennyfarthing-dist/gates/tests-pass.md" in result["path"]
+
+    def test_local_overrides_builtin(
+        self, project_with_both_gates: Path
+    ) -> None:
+        """AC2: When same gate exists in both, local wins."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_both_gates
+        )
+        assert result["status"] == "found"
+        # Path should be the .pennyfarthing/gates/ version, not pennyfarthing-dist/
+        assert ".pennyfarthing/gates/tests-pass.md" in result["path"]
+
+    def test_local_override_content_is_local_version(
+        self, project_with_both_gates: Path
+    ) -> None:
+        """AC2: Content at resolved path should be the local version."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_both_gates
+        )
+        content = Path(result["path"]).read_text()
+        assert "Local override version" in content
+
+
+# ===========================================================================
+# AC3: Non-existent gate file returns error/blocked
+# ===========================================================================
+
+
+class TestResolveGateFileNotFound:
+    """AC3: Missing gate files return error status."""
+
+    def test_missing_gate_returns_not_found(self, project: Path) -> None:
+        """AC3: Non-existent gate → status: not_found."""
+        result = resolve_gate_file("nonexistent-gate", project_root=project)
+        assert result["status"] == "not_found"
+
+    def test_missing_gate_path_is_none(self, project: Path) -> None:
+        """AC3: Non-existent gate → path: None."""
+        result = resolve_gate_file("nonexistent-gate", project_root=project)
+        assert result["path"] is None
+
+    def test_missing_gate_has_error_message(self, project: Path) -> None:
+        """AC3: Non-existent gate → error message present."""
+        result = resolve_gate_file("nonexistent-gate", project_root=project)
+        assert result["error"] is not None
+        assert len(result["error"]) > 0
+
+    def test_empty_gate_name_returns_not_found(self, project: Path) -> None:
+        """AC3: Empty string gate name → not_found."""
+        result = resolve_gate_file("", project_root=project)
+        assert result["status"] == "not_found"
+
+    def test_missing_gates_directory_returns_not_found(
+        self, tmp_path: Path
+    ) -> None:
+        """AC3: No gates/ directories at all → not_found (no crash)."""
+        # Project with .pennyfarthing but no gates subdirectory
+        (tmp_path / ".pennyfarthing").mkdir()
+        result = resolve_gate_file("tests-pass", project_root=tmp_path)
+        assert result["status"] == "not_found"
+
+
+# ===========================================================================
+# AC5: Symlink resolution
+# ===========================================================================
+
+
+class TestResolveGateFileSymlink:
+    """AC5: Gate files found through symlinked .pennyfarthing/gates/."""
+
+    def test_symlinked_gate_found(
+        self, project_with_symlinked_gates: Path
+    ) -> None:
+        """AC5: Gate found through .pennyfarthing/gates/ symlink."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_symlinked_gates
+        )
+        assert result["status"] == "found"
+
+    def test_symlinked_gate_path_is_valid(
+        self, project_with_symlinked_gates: Path
+    ) -> None:
+        """AC5: Path through symlink points to real file."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_symlinked_gates
+        )
+        assert result["path"] is not None
+        assert Path(result["path"]).exists()
+
+    def test_symlinked_gate_content_readable(
+        self, project_with_symlinked_gates: Path
+    ) -> None:
+        """AC5: Content at symlinked path is the actual gate file."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_symlinked_gates
+        )
+        content = Path(result["path"]).read_text()
+        assert "Symlinked gate" in content
+
+
+# ===========================================================================
+# Edge cases
+# ===========================================================================
+
+
+class TestResolveGateFileEdgeCases:
+    """Edge cases and boundary conditions."""
+
+    def test_gate_name_with_md_extension_still_works(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """Edge: 'tests-pass.md' should resolve same as 'tests-pass'."""
+        result = resolve_gate_file(
+            "tests-pass.md", project_root=project_with_builtin_gate
+        )
+        assert result["status"] == "found"
+
+    def test_gate_name_with_nested_path_rejected(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """Edge: '../escape/tests-pass' should not resolve (path traversal)."""
+        result = resolve_gate_file(
+            "../escape/tests-pass",
+            project_root=project_with_builtin_gate,
+        )
+        assert result["status"] == "not_found"
+
+    def test_result_status_is_valid_enum(
+        self, project_with_builtin_gate: Path
+    ) -> None:
+        """Edge: Status must be one of the expected values."""
+        result = resolve_gate_file(
+            "tests-pass", project_root=project_with_builtin_gate
+        )
+        assert result["status"] in ("found", "not_found")