test: add capability admission control tests and structural guards

Add three missing tests identified by the audit-impl pass:
1. test_capability_override_parity - asserts _backend_capability_overrides
   (IL-3 server) and _build_capability_overrides (IL-2 fleet) produce
   identical output for every capability state
2. test_open_kitchen_refuses_doa_codex_pipeline - exercises the
   open_kitchen dispatch-infeasible refusal path through
   _dispatch_infeasible_response
3. test_codex_capability_gate_recipes - parametrized contract test
   asserting every bundled recipe containing a gate_backend_write step
   yields dispatch_feasible=False when loaded with codex overrides

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Trecek

tests/recipe/test_bundled_recipes_dispatch_ready.py

@@ -303,3 +303,41 @@ def test_dispatch_feasible_defaults_true_for_recipes_without_capability_gates()
     )
     assert result.get("dispatch_feasible") is True
     assert "infeasible_steps" not in result
+
+
+def _discover_capability_gate_recipes() -> list[str]:
+    """Return recipe names that contain a gate_backend_write step."""
+    gate_recipes = []
+    for name in _RECIPE_STEMS:
+        recipe_path = _RECIPES_DIR / f"{name}.yaml"
+        if not recipe_path.exists():
+            continue
+        recipe = load_recipe(recipe_path)
+        for step in recipe.steps.values():
+            if step.tool == "run_python" and step.with_args.get("callable", "").endswith(
+                "gate_backend_write"
+            ):
+                gate_recipes.append(name)
+                break
+    return gate_recipes
+
+
+_CAPABILITY_GATE_RECIPES = _discover_capability_gate_recipes()
+
+
+@pytest.mark.parametrize("recipe_name", _CAPABILITY_GATE_RECIPES)
+def test_codex_capability_gate_recipes(recipe_name: str) -> None:
+    """Every recipe with a gate_backend_write step must report
+    dispatch_feasible=False when loaded with codex overrides."""
+    result = load_and_validate(
+        recipe_name,
+        project_dir=_PROJECT_ROOT,
+        ingredient_overrides={"backend_supports_git_write": "false"},
+        backend_name="codex",
+    )
+    assert result.get("valid") is True
+    assert result.get("dispatch_feasible") is False, (
+        f"Recipe '{recipe_name}' with gate_backend_write step did not report "
+        f"dispatch_feasible=False under codex overrides"
+    )
+    assert "gate_backend_write" in result.get("infeasible_steps", [])

tests/server/test_capability_admission_e2e.py

@@ -53,3 +53,71 @@ def test_claude_code_backend_produces_feasible_recipe() -> None:
     assert result.get("valid") is True
     assert result.get("dispatch_feasible") is True
     assert "infeasible_steps" not in result
+
+
+def test_capability_override_parity() -> None:
+    """Server and fleet capability override functions must produce identical output.
+
+    _backend_capability_overrides (IL-3 server) and _build_capability_overrides
+    (IL-2 fleet) are parallel implementations — IL-2 cannot import IL-3. This
+    test asserts value-level parity for every capability state.
+    """
+    from unittest.mock import MagicMock
+
+    from autoskillit.fleet._api import _build_capability_overrides
+    from autoskillit.server.tools._auto_overrides import _backend_capability_overrides
+
+    for writable in (True, False):
+        backend = MagicMock()
+        backend.capabilities.git_metadata_writable = writable
+        assert _backend_capability_overrides(backend) == _build_capability_overrides(backend), (
+            f"Parity violation for git_metadata_writable={writable}"
+        )
+
+    assert _backend_capability_overrides(None) == _build_capability_overrides(None), (
+        "Parity violation for backend=None"
+    )
+
+
+@pytest.mark.anyio
+async def test_open_kitchen_refuses_doa_codex_pipeline() -> None:
+    """open_kitchen must return success=False with kitchen='dispatch_infeasible'
+    when load_and_validate reports dispatch_feasible=False."""
+    import json
+    from unittest.mock import AsyncMock, patch
+
+    from autoskillit.server.tools.tools_kitchen import open_kitchen
+    from tests.server.conftest import _make_mock_ctx
+
+    tool_ctx = _make_mock_ctx()
+    tool_ctx.gate.enabled = True
+    tool_ctx.recipe_name = "implementation"
+    tool_ctx.kitchen_id = "test-kitchen"
+    tool_ctx.backend.name = "codex"
+    tool_ctx.recipes.load_and_validate.return_value = {
+        "content": "name: implementation\nsteps:\n  build:\n    cmd: task build\n",
+        "valid": True,
+        "errors": [],
+        "requires_packs": [],
+        "requires_features": [],
+        "content_hash": "abc123",
+        "composite_hash": "def456",
+        "recipe_version": "1.0",
+        "suggestions": [],
+        "post_prune_step_names": ["build"],
+        "dispatch_feasible": False,
+        "infeasible_steps": ["gate_backend_write"],
+    }
+    tool_ctx.recipes.find.return_value = None
+
+    fastmcp_ctx = AsyncMock()
+
+    with patch("autoskillit.server._get_ctx", return_value=tool_ctx):
+        result = await open_kitchen(name="implementation", ctx=fastmcp_ctx)
+
+    parsed = json.loads(result)
+    assert parsed["success"] is False
+    assert parsed["kitchen"] == "dispatch_infeasible"
+    assert "gate_backend_write" in parsed["infeasible_steps"]
+    tool_ctx.gate.disable.assert_called_once()
+    fastmcp_ctx.disable_components.assert_called_once_with(tags={"kitchen"})