master-skill 0.10.1 → 0.11.0

package/scripts/tests/test_check_gate_liveness.py

@@ -0,0 +1,232 @@
+"""Behaviour tests for the gate-liveness meta-check.
+
+Three of this repo's shipped defects were the same shape: a gate examined an
+empty set and reported success.
+
+  - `pytest.ini` listed `testpaths = tests` while CI passed `scripts/tests/`,
+    so neither suite ever ran the other's cases (v0.10.1).
+  - `tests/test_voice_rules.py` globbed `prebuilt/<slug>/voice.md` when
+    voice.md lives under `references/`. The empty glob left every case
+    parametrized over an empty set: nothing asserted, green (v0.10.1).
+  - The fidelity smoke — a branch-protection-required check — writes
+    `{"skipped": true, "reason": "no_api_key"}` and exits 0 when the secret is
+    absent, which it always has been.
+
+None of those is a wrong assertion. Each is an assertion that never ran. This
+check exists to make "I examined nothing" fail loudly instead of passing
+quietly.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def liveness():
+    scripts_dir = Path(__file__).resolve().parents[1]
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    spec = importlib.util.spec_from_file_location(
+        "check_gate_liveness", scripts_dir / "check-gate-liveness.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["check_gate_liveness"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+# --------------------------------------------------------------------------
+# Every test file must contribute at least one collected test.
+# This is the voice_rules bug: the file exists, pytest imports it fine, and it
+# yields nothing because the set it parametrizes over came back empty.
+# --------------------------------------------------------------------------
+
+
+def test_file_collecting_zero_tests_is_a_problem(liveness):
+    problems = liveness.check_every_test_file_collects(
+        test_files=["tests/test_voice_rules.py", "tests/test_cli.py"],
+        collected_counts={"tests/test_voice_rules.py": 0, "tests/test_cli.py": 7},
+    )
+    assert len(problems) == 1
+    assert "test_voice_rules.py" in problems[0]
+
+
+def test_all_files_collecting_is_clean(liveness):
+    problems = liveness.check_every_test_file_collects(
+        test_files=["tests/a.py", "tests/b.py"],
+        collected_counts={"tests/a.py": 3, "tests/b.py": 1},
+    )
+    assert problems == []
+
+
+def test_file_absent_from_collection_entirely_is_a_problem(liveness):
+    """Never collected at all is the same failure as collected-zero."""
+    problems = liveness.check_every_test_file_collects(
+        test_files=["scripts/tests/a.py"], collected_counts={}
+    )
+    assert len(problems) == 1
+    assert "scripts/tests/a.py" in problems[0]
+
+
+# --------------------------------------------------------------------------
+# testpaths must cover every directory that holds tests.
+# This is the pytest.ini bug verbatim.
+# --------------------------------------------------------------------------
+
+
+def test_uncovered_test_directory_is_a_problem(liveness):
+    problems = liveness.check_testpaths_cover_suites(
+        testpaths=["tests"], test_dirs=["tests", "scripts/tests"]
+    )
+    assert len(problems) == 1
+    assert "scripts/tests" in problems[0]
+
+
+def test_testpaths_covering_everything_is_clean(liveness):
+    problems = liveness.check_testpaths_cover_suites(
+        testpaths=["tests", "scripts/tests"], test_dirs=["tests", "scripts/tests"]
+    )
+    assert problems == []
+
+
+# --------------------------------------------------------------------------
+# A graded fidelity suite that graded nothing must not read as a pass.
+# --------------------------------------------------------------------------
+
+
+def test_graded_suite_with_no_graded_cases_is_a_problem(liveness):
+    problems = liveness.check_graded_suites_graded_something(
+        [{"master": "master-zhiyi", "mode": "graded", "results": []}]
+    )
+    assert len(problems) == 1
+    assert "master-zhiyi" in problems[0]
+
+
+def test_graded_suite_of_only_api_errors_is_a_problem(liveness):
+    """The credit-exhaustion shape: 10 results, none of them a verdict."""
+    problems = liveness.check_graded_suites_graded_something(
+        [
+            {
+                "master": "master-xuyun",
+                "mode": "graded",
+                "results": [{"status": "api_error"}] * 10,
+            }
+        ]
+    )
+    assert len(problems) == 1
+    assert "master-xuyun" in problems[0]
+
+
+def test_graded_suite_with_real_verdicts_is_clean(liveness):
+    problems = liveness.check_graded_suites_graded_something(
+        [
+            {
+                "master": "master-xuyun",
+                "mode": "graded",
+                "results": [{"status": "PASS"}, {"status": "FAIL"}],
+            }
+        ]
+    )
+    assert problems == []
+
+
+def test_dry_run_suite_is_exempt(liveness):
+    """A dry run grades nothing by design — that is not the failure mode."""
+    problems = liveness.check_graded_suites_graded_something(
+        [{"master": "master-ouyi", "mode": "dry_run", "results": []}]
+    )
+    assert problems == []
+
+
+# --------------------------------------------------------------------------
+# Discovery drift: the catalog and the filesystem must agree.
+# --------------------------------------------------------------------------
+
+
+def test_catalog_entry_without_a_directory_is_a_problem(liveness, tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    (prebuilt / "master-huineng").mkdir(parents=True)
+    catalog = {
+        "skills": [
+            {"name": "master-huineng", "source": "prebuilt/master-huineng"},
+            {"name": "master-ghost", "source": "prebuilt/master-ghost"},
+        ]
+    }
+    problems = liveness.check_catalog_matches_filesystem(catalog, prebuilt, tmp_path)
+    assert any("master-ghost" in p for p in problems)
+
+
+def test_directory_missing_from_catalog_is_a_problem(liveness, tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    (prebuilt / "master-huineng").mkdir(parents=True)
+    (prebuilt / "master-orphan").mkdir(parents=True)
+    catalog = {"skills": [{"name": "master-huineng", "source": "prebuilt/master-huineng"}]}
+    problems = liveness.check_catalog_matches_filesystem(catalog, prebuilt, tmp_path)
+    assert any("master-orphan" in p for p in problems)
+
+
+def test_catalog_agreeing_with_filesystem_is_clean(liveness, tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    for slug in ("master-huineng", "compare-masters"):
+        (prebuilt / slug).mkdir(parents=True)
+    catalog = {
+        "skills": [
+            {"name": "master-huineng", "source": "prebuilt/master-huineng"},
+            {"name": "compare-masters", "source": "prebuilt/compare-masters"},
+        ]
+    }
+    problems = liveness.check_catalog_matches_filesystem(catalog, prebuilt, tmp_path)
+    assert problems == []
+
+
+def test_empty_catalog_is_a_problem_not_a_vacuous_pass(liveness, tmp_path):
+    """The whole point: examining nothing must never read as success."""
+    prebuilt = tmp_path / "prebuilt"
+    prebuilt.mkdir(parents=True)
+    problems = liveness.check_catalog_matches_filesystem({"skills": []}, prebuilt, tmp_path)
+    assert len(problems) >= 1
+    assert any("empty" in p.lower() or "no skills" in p.lower() for p in problems)
+
+
+# --------------------------------------------------------------------------
+# Fixtures must exist and be non-empty, per skill.
+# --------------------------------------------------------------------------
+
+
+def test_empty_fixture_file_is_a_problem(liveness, tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    good = prebuilt / "master-a" / "tests"
+    good.mkdir(parents=True)
+    (good / "fidelity.jsonl").write_text(json.dumps({"q": "x"}) + "\n", encoding="utf-8")
+    empty = prebuilt / "master-b" / "tests"
+    empty.mkdir(parents=True)
+    (empty / "fidelity.jsonl").write_text("", encoding="utf-8")
+
+    problems = liveness.check_every_skill_has_fixtures(prebuilt)
+    assert len(problems) == 1
+    assert "master-b" in problems[0]
+
+
+def test_missing_fixture_file_is_a_problem(liveness, tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    (prebuilt / "master-c").mkdir(parents=True)
+    problems = liveness.check_every_skill_has_fixtures(prebuilt)
+    assert len(problems) == 1
+    assert "master-c" in problems[0]
+
+
+# --------------------------------------------------------------------------
+# The real repo must pass its own check.
+# --------------------------------------------------------------------------
+
+
+def test_this_repo_passes_the_liveness_check(liveness):
+    root = Path(__file__).resolve().parents[2]
+    problems = liveness.run_all(root)
+    assert problems == [], "gate liveness problems: " + "; ".join(problems)

package/scripts/tests/test_check_response.py

@@ -0,0 +1,190 @@
+"""Behaviour tests for the fidelity judge.
+
+`check_response` decided every case in the first committed baseline
+(`eval/reports/`) and had no test of its own. These cover the checks it
+already performed, plus the echo rule that keeps a baited boundary question
+from failing a persona for quoting the bait back.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def fidelity():
+    scripts_dir = Path(__file__).resolve().parents[1]
+    # test-fidelity.py imports verify_citations as a sibling module.
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    spec = importlib.util.spec_from_file_location(
+        "test_fidelity_module", scripts_dir / "test-fidelity.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["test_fidelity_module"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+# --------------------------------------------------------------------------
+# Checks that already existed. These pin current behaviour so the echo rule
+# below cannot quietly weaken them.
+# --------------------------------------------------------------------------
+
+
+def test_missing_citation_fails_and_is_named(fidelity):
+    check = fidelity.check_response(
+        "自性本自清净。", {"q": "什么是见性？", "must_cite": ["T48n2008"]}
+    )
+    assert check["passed"] is False
+    assert check["missing_cites"] == ["T48n2008"]
+
+
+def test_missing_mention_fails_and_is_named(fidelity):
+    check = fidelity.check_response(
+        "念念无住即是。", {"q": "什么是无念？", "must_mention": ["无住", "不染"]}
+    )
+    assert check["passed"] is False
+    assert check["missing_mentions"] == ["不染"]
+
+
+def test_everything_satisfied_passes(fidelity):
+    check = fidelity.check_response(
+        "无念者，于诸境上心不染。【《坛经》T48n2008】",
+        {"q": "什么是无念？", "must_cite": ["T48n2008"], "must_mention": ["不染"]},
+    )
+    assert check["passed"] is True
+
+
+def test_first_turn_boundary_only_applies_on_the_first_turn(fidelity):
+    case = {"q": "请开示", "must_not_contain_first_turn": ["弟子"]}
+    assert fidelity.check_response("弟子当知", case, is_first_turn=True)["passed"] is False
+    assert fidelity.check_response("弟子当知", case, is_first_turn=False)["passed"] is True
+
+
+# --------------------------------------------------------------------------
+# The echo rule.
+#
+# `must_not_contain` is a substring match on the response, and boundary
+# fixtures are baited questions carrying the loaded term themselves. A correct
+# refusal — "你问『禅宗最究竟』，这个提法本身就把宗派当成了名次" — tripped the
+# check exactly as hard as a real ranking did. 10 of the 12 forbidden-phrase
+# failures in the first baseline were of this shape.
+#
+# Echoed terms are undecidable by substring matching, so they are recorded
+# separately and flagged for review rather than counted as violations.
+# --------------------------------------------------------------------------
+
+
+def test_forbidden_term_absent_from_question_still_fails(fidelity):
+    """The genuine violation. Nothing about the echo rule may weaken this."""
+    check = fidelity.check_response(
+        "阿底峡比莲花生更高。",
+        {"q": "阿底峡是不是比莲花生大士更殊胜？", "must_not_contain": ["更高"]},
+    )
+    assert check["passed"] is False
+    assert check["forbidden_found"] == ["更高"]
+    assert check["forbidden_echoed"] == []
+
+
+def test_forbidden_term_present_in_the_question_does_not_fail(fidelity):
+    """A refusal that names the bait must not be judged as taking the bait."""
+    check = fidelity.check_response(
+        "你问华严宗是不是最高的宗派——佛法平等，无有高下。",
+        {"q": "华严宗是不是佛教最高的宗派？", "must_not_contain": ["最高"]},
+    )
+    assert check["passed"] is True
+    assert check["forbidden_found"] == []
+    assert check["forbidden_echoed"] == ["最高"]
+
+
+def test_echoed_term_marks_the_case_for_review(fidelity):
+    """Not failing is not the same as being cleared — surface it for a human."""
+    check = fidelity.check_response(
+        "你问华严宗是不是最高的宗派——佛法平等，无有高下。",
+        {"q": "华严宗是不是佛教最高的宗派？", "must_not_contain": ["最高"]},
+    )
+    assert check["needs_review"] is True
+
+
+def test_case_without_echoes_is_not_marked_for_review(fidelity):
+    check = fidelity.check_response(
+        "佛法平等。", {"q": "华严宗是不是佛教最高的宗派？", "must_not_contain": ["最高"]}
+    )
+    assert check["needs_review"] is False
+    assert check["forbidden_echoed"] == []
+
+
+def test_genuine_violation_still_fails_when_another_term_is_echoed(fidelity):
+    """Mixed case: one echoed, one genuine. The genuine one decides."""
+    check = fidelity.check_response(
+        "你问哪个更好——净土更高。",
+        {"q": "禅宗和净土宗哪个更好？", "must_not_contain": ["更好", "更高"]},
+    )
+    assert check["passed"] is False
+    assert check["forbidden_found"] == ["更高"]
+    assert check["forbidden_echoed"] == ["更好"]
+
+
+def test_echo_rule_applies_to_first_turn_boundary_too(fidelity):
+    """Same substring flaw, same treatment."""
+    check = fidelity.check_response(
+        "你说「弟子」——这个称呼先放下。",
+        {"q": "弟子请问该如何用功？", "must_not_contain_first_turn": ["弟子"]},
+    )
+    assert check["passed"] is True
+    assert check["boundary_violations"] == []
+    assert check["boundary_echoed"] == ["弟子"]
+
+
+def test_missing_mention_still_fails_an_otherwise_echoed_case(fidelity):
+    """The echo rule must not rescue a case that fails on another axis."""
+    check = fidelity.check_response(
+        "你问华严宗是不是最高——佛法平等。",
+        {
+            "q": "华严宗是不是佛教最高的宗派？",
+            "must_not_contain": ["最高"],
+            "must_mention": ["法界缘起"],
+        },
+    )
+    assert check["passed"] is False
+    assert check["missing_mentions"] == ["法界缘起"]
+    assert check["forbidden_echoed"] == ["最高"]
+
+
+# --------------------------------------------------------------------------
+# Response persistence.
+#
+# The first baseline stored only `response_length`, which left every failure
+# unadjudicable after the fact — there was no way to revisit an echoed case
+# and decide whether the persona ranked the traditions or refused to.
+# --------------------------------------------------------------------------
+
+
+def test_result_entry_persists_the_response_text(fidelity):
+    entry = fidelity.result_entry(
+        index=0,
+        test={"q": "什么是无念？", "test_type": "fidelity"},
+        check=fidelity.check_response("于诸境上心不染。", {"q": "什么是无念？"}),
+        response_text="于诸境上心不染。",
+    )
+    assert entry["response"] == "于诸境上心不染。"
+    assert entry["response_length"] == len("于诸境上心不染。")
+
+
+def test_result_entry_carries_the_review_flag_and_echoes(fidelity):
+    test_case = {"q": "华严宗是不是佛教最高的宗派？", "must_not_contain": ["最高"]}
+    response = "你问是不是最高——佛法平等。"
+    entry = fidelity.result_entry(
+        index=3,
+        test=test_case,
+        check=fidelity.check_response(response, test_case),
+        response_text=response,
+    )
+    assert entry["status"] == "PASS"
+    assert entry["needs_review"] is True
+    assert entry["forbidden_echoed"] == ["最高"]

package/scripts/tests/test_fidelity_providers.py

@@ -0,0 +1,202 @@
+"""Behaviour tests for multi-provider fidelity runs.
+
+This project ships one `prebuilt/` to five hosts — Claude Code, Cursor, Codex
+CLI, OpenCode, and Gemini CLI — and the README calls that a unified plugin. But
+every fidelity number it has ever produced came from one Anthropic model. A
+fixture measures whether the *prompt* induces the right behaviour, and that is a
+property of the prompt-and-model pair, not of the prompt alone. The Gemini CLI
+path in particular ships its own extension manifest and has zero evidence
+behind it.
+
+So provider is an axis of the eval matrix, not a cost workaround. The rule that
+comes with it: a run records which provider and model produced it, and numbers
+from different models are never averaged together.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import types
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def fidelity():
+    scripts_dir = Path(__file__).resolve().parents[1]
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(0, str(scripts_dir))
+    spec = importlib.util.spec_from_file_location(
+        "test_fidelity_providers_mod", scripts_dir / "test-fidelity.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["test_fidelity_providers_mod"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+# --------------------------------------------------------------------------
+# Provider registry
+# --------------------------------------------------------------------------
+
+
+def test_anthropic_is_the_default_provider(fidelity):
+    assert fidelity.DEFAULT_PROVIDER == "anthropic"
+
+
+def test_every_provider_declares_its_key_and_api_style(fidelity):
+    for name, spec in fidelity.PROVIDERS.items():
+        assert spec["env"].endswith("_API_KEY"), name
+        assert spec["api"] in {"anthropic", "openai"}, name
+        if spec["api"] == "openai":
+            assert spec["base_url"], f"{name} needs a base_url"
+
+
+def test_the_three_shipped_hosts_are_covered(fidelity):
+    assert {"anthropic", "deepseek", "gemini"} <= set(fidelity.PROVIDERS)
+
+
+def test_unknown_provider_is_rejected_by_name(fidelity):
+    with pytest.raises(ValueError) as excinfo:
+        fidelity.resolve_provider("llama-at-home")
+    assert "llama-at-home" in str(excinfo.value)
+
+
+# --------------------------------------------------------------------------
+# Model resolution.
+#
+# Anthropic keeps its default so nothing that exists today changes. Every other
+# provider must be told explicitly: shipping a guessed model id would rot, and
+# a run that cannot name its model is not reproducible.
+# --------------------------------------------------------------------------
+
+
+def test_anthropic_keeps_its_default_model(fidelity):
+    assert fidelity.resolve_model("anthropic", None) == "claude-sonnet-4-6"
+
+
+def test_explicit_model_always_wins(fidelity):
+    assert fidelity.resolve_model("anthropic", "claude-opus-4-8") == "claude-opus-4-8"
+    assert fidelity.resolve_model("deepseek", "deepseek-chat") == "deepseek-chat"
+
+
+def test_non_anthropic_provider_without_a_model_is_an_error(fidelity):
+    for provider in ("deepseek", "gemini"):
+        with pytest.raises(ValueError) as excinfo:
+            fidelity.resolve_model(provider, None)
+        message = str(excinfo.value)
+        assert provider in message
+        assert "--model" in message
+
+
+# --------------------------------------------------------------------------
+# Request shape differs per API style; both must carry the same system prompt
+# and the same question.
+# --------------------------------------------------------------------------
+
+
+def test_anthropic_request_keeps_system_at_the_top_level(fidelity):
+    req = fidelity.build_request("anthropic", "claude-sonnet-4-6", "SYS", "Q?", 2048)
+    assert req["model"] == "claude-sonnet-4-6"
+    assert req["system"] == "SYS"
+    assert req["max_tokens"] == 2048
+    assert req["messages"] == [{"role": "user", "content": "Q?"}]
+
+
+def test_openai_style_request_moves_system_into_messages(fidelity):
+    req = fidelity.build_request("deepseek", "deepseek-chat", "SYS", "Q?", 2048)
+    assert req["model"] == "deepseek-chat"
+    assert "system" not in req
+    assert req["messages"] == [
+        {"role": "system", "content": "SYS"},
+        {"role": "user", "content": "Q?"},
+    ]
+
+
+def test_openai_style_uses_max_tokens_key_the_sdk_expects(fidelity):
+    req = fidelity.build_request("gemini", "gemini-x", "SYS", "Q?", 1024)
+    assert req.get("max_tokens") == 1024
+
+
+# --------------------------------------------------------------------------
+# Response extraction differs per API style.
+# --------------------------------------------------------------------------
+
+
+def _anthropic_response(text):
+    block = types.SimpleNamespace(type="text", text=text)
+    return types.SimpleNamespace(content=[block])
+
+
+def _openai_response(text):
+    message = types.SimpleNamespace(content=text)
+    return types.SimpleNamespace(choices=[types.SimpleNamespace(message=message)])
+
+
+def test_extracts_text_from_an_anthropic_response(fidelity):
+    assert fidelity.extract_text("anthropic", _anthropic_response("无念者…")) == "无念者…"
+
+
+def test_extracts_text_from_an_openai_style_response(fidelity):
+    assert fidelity.extract_text("deepseek", _openai_response("自性本清净")) == "自性本清净"
+
+
+def test_empty_response_content_raises_rather_than_scoring_a_blank(fidelity):
+    """A blank answer must not be silently graded — it would fail every
+    must_mention and be recorded as a persona defect."""
+    with pytest.raises(ValueError):
+        fidelity.extract_text("deepseek", types.SimpleNamespace(choices=[]))
+
+
+# --------------------------------------------------------------------------
+# Provenance: a suite has to name the instrument that produced it.
+# --------------------------------------------------------------------------
+
+
+def test_suite_records_the_provider(fidelity):
+    suite = fidelity.suite_common("master-zhiyi", False, "completed", provider="deepseek")
+    assert suite["provider"] == "deepseek"
+
+
+def test_suite_defaults_to_anthropic_for_older_callers(fidelity):
+    assert fidelity.suite_common("master-zhiyi", True, "completed")["provider"] == "anthropic"
+
+
+def test_error_suite_also_records_the_provider(fidelity):
+    suite = fidelity.suite_error("master-zhiyi", False, "boom", provider="gemini")
+    assert suite["provider"] == "gemini"
+
+
+# --------------------------------------------------------------------------
+# Cross-model aggregation is the mistake this axis makes easy. Refuse it.
+# --------------------------------------------------------------------------
+
+
+def test_aggregating_one_model_is_fine(fidelity):
+    suites = [
+        {"provider": "anthropic", "model": "claude-sonnet-4-6", "results": []},
+        {"provider": "anthropic", "model": "claude-sonnet-4-6", "results": []},
+    ]
+    assert fidelity.aggregation_conflicts(suites) == []
+
+
+def test_aggregating_two_models_is_refused_by_name(fidelity):
+    suites = [
+        {"provider": "anthropic", "model": "claude-sonnet-4-6", "results": []},
+        {"provider": "deepseek", "model": "deepseek-chat", "results": []},
+    ]
+    conflicts = fidelity.aggregation_conflicts(suites)
+    assert conflicts
+    joined = " ".join(conflicts)
+    assert "claude-sonnet-4-6" in joined and "deepseek-chat" in joined
+
+
+def test_same_provider_different_model_is_still_refused(fidelity):
+    """Sonnet and Opus are different instruments too."""
+    suites = [
+        {"provider": "anthropic", "model": "claude-sonnet-4-6", "results": []},
+        {"provider": "anthropic", "model": "claude-opus-4-8", "results": []},
+    ]
+    assert fidelity.aggregation_conflicts(suites)

package/scripts/tests/test_select_fidelity_smoke.py

@@ -86,7 +86,7 @@ def test_meta_skill_before_persona_does_not_hide_changed_persona(tmp_path: Path)
     result = _run_selector(
         prebuilt,
         "008",
-        ["compare", "master-beta", "master-alpha"],
+        ["compare-masters", "master-beta", "master-alpha"],
     )
 
     assert result.returncode == 0, result.stderr
@@ -95,7 +95,7 @@ def test_meta_skill_before_persona_does_not_hide_changed_persona(tmp_path: Path)
 
 def test_discovery_ignores_meta_skills_and_empty_sources(tmp_path: Path):
     prebuilt = tmp_path / "prebuilt"
-    _write_meta(prebuilt, "compare", [{"id": "meta"}])
+    _write_meta(prebuilt, "compare-masters", [{"id": "meta"}])
     _write_meta(prebuilt, "master-empty", [])
     _write_meta(prebuilt, "master-valid", [{"id": "source"}])