master-skill 0.5.0 → 0.8.0

package/scripts/tests/test_debate_protocol.py

@@ -0,0 +1,159 @@
+"""Tests for master-debate meta.json debate_protocol schema.
+
+Verifies:
+  1. master-debate/meta.json exists, has a `debate_protocol` object
+  2. Required scalar fields with valid types + sane ranges
+  3. min_rounds <= default_rounds <= max_rounds
+  4. per_pair_overrides keys are <slug_a>-vs-<slug_b> with both slugs being
+     real masters under prebuilt/
+  5. Each pair listed in per_pair_overrides is also covered bidirectionally
+     by cross_critique (i.e. the per-pair list does not invent debate pairs
+     that v0.7.1 didn't actually arm with ammo)
+  6. per_pair_overrides values have valid default_rounds in
+     [debate_protocol.min_rounds, debate_protocol.max_rounds]
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+PREBUILT = REPO_ROOT / "prebuilt"
+DEBATE_META = PREBUILT / "master-debate" / "meta.json"
+
+
+def _load_json(p: Path) -> dict:
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="module")
+def debate_meta():
+    assert DEBATE_META.exists(), f"missing {DEBATE_META}"
+    return _load_json(DEBATE_META)
+
+
+@pytest.fixture(scope="module")
+def protocol(debate_meta):
+    proto = debate_meta.get("debate_protocol")
+    assert isinstance(proto, dict), "debate_protocol must be an object"
+    return proto
+
+
+@pytest.fixture(scope="module")
+def known_slugs():
+    return {p.parent.name.removeprefix("master-")
+            for p in PREBUILT.glob("master-*/meta.json")}
+
+
+def test_protocol_required_scalars(protocol):
+    for key, typ in [
+        ("default_rounds", int),
+        ("max_rounds", int),
+        ("min_rounds", int),
+        ("selector", str),
+        ("stop_on_consensus", bool),
+        ("subagent_isolation", bool),
+        ("moderator_summary", bool),
+    ]:
+        assert key in protocol, f"missing debate_protocol.{key}"
+        assert isinstance(protocol[key], typ), (
+            f"debate_protocol.{key} must be {typ.__name__}, "
+            f"got {type(protocol[key]).__name__}"
+        )
+
+
+def test_protocol_round_ranges(protocol):
+    min_r = protocol["min_rounds"]
+    def_r = protocol["default_rounds"]
+    max_r = protocol["max_rounds"]
+    assert min_r >= 1, "min_rounds must be >= 1"
+    assert min_r <= def_r <= max_r, (
+        f"require min_rounds <= default_rounds <= max_rounds, "
+        f"got {min_r} <= {def_r} <= {max_r}"
+    )
+    assert max_r <= 10, "max_rounds sanity cap"
+
+
+def test_protocol_selector_alternating(protocol):
+    assert protocol["selector"] == "alternating", (
+        "v0.8 only ships alternating selector"
+    )
+
+
+def test_protocol_subagent_isolation_on(protocol):
+    assert protocol["subagent_isolation"] is True, (
+        "v0.8 requires subagent_isolation=true (the whole point of the refactor)"
+    )
+
+
+def test_per_pair_overrides_is_object(protocol):
+    overrides = protocol.get("per_pair_overrides")
+    assert isinstance(overrides, dict), (
+        "debate_protocol.per_pair_overrides must be an object"
+    )
+
+
+def test_per_pair_keys_well_formed_and_real_slugs(protocol, known_slugs):
+    overrides = protocol["per_pair_overrides"]
+    for key in overrides:
+        assert "-vs-" in key, f"per-pair key '{key}' must contain '-vs-'"
+        parts = key.split("-vs-")
+        assert len(parts) == 2, f"per-pair key '{key}' must split into exactly 2 slugs"
+        a, b = parts
+        assert a != b, f"per-pair key '{key}' self-pair"
+        assert a in known_slugs, f"per-pair key '{key}': slug '{a}' not a known master"
+        assert b in known_slugs, f"per-pair key '{key}': slug '{b}' not a known master"
+
+
+def test_per_pair_keys_are_alphabetically_sorted(protocol):
+    """SKILL.md tells the orchestrator to compute the lookup key by sorting
+    the two slugs alphabetically. If a key here isn't sorted, the orchestrator
+    silently misses the override. Lock the convention in."""
+    for key in protocol["per_pair_overrides"]:
+        a, b = key.split("-vs-", 1)
+        assert a < b, (
+            f"per-pair key '{key}' must be alphabetically sorted "
+            f"('{a}' < '{b}'); orchestrators compute the key by sorting slugs."
+        )
+
+
+def test_per_pair_default_rounds_in_protocol_range(protocol):
+    min_r = protocol["min_rounds"]
+    max_r = protocol["max_rounds"]
+    for key, val in protocol["per_pair_overrides"].items():
+        assert isinstance(val, dict), f"override for '{key}' must be object"
+        dr = val.get("default_rounds")
+        assert isinstance(dr, int), f"override '{key}'.default_rounds must be int"
+        assert min_r <= dr <= max_r, (
+            f"override '{key}'.default_rounds={dr} out of "
+            f"[{min_r}, {max_r}]"
+        )
+
+
+def test_per_pair_overrides_cross_critique_covered(protocol):
+    """Each per-pair override must correspond to a pair both directions of
+    which appear in cross_critique entries — otherwise the override would
+    fire a debate the v0.7.1 ammo system didn't arm."""
+    overrides = protocol["per_pair_overrides"]
+
+    # Build {(src, tgt)} set from all cross_critique entries.
+    pairs = set()
+    for meta_path in PREBUILT.glob("master-*/meta.json"):
+        src = meta_path.parent.name.removeprefix("master-")
+        data = _load_json(meta_path)
+        for e in data.get("cross_critique", []) or []:
+            tgt = e.get("target_master")
+            if isinstance(tgt, str):
+                pairs.add((src, tgt))
+
+    for key in overrides:
+        a, b = key.split("-vs-", 1)
+        assert (a, b) in pairs, (
+            f"override '{key}': cross_critique missing direction {a}→{b}"
+        )
+        assert (b, a) in pairs, (
+            f"override '{key}': cross_critique missing direction {b}→{a}"
+        )

package/scripts/tests/test_validate_cross_critique.py

@@ -0,0 +1,149 @@
+"""Tests for validate-cross-critique.py."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import importlib.util
+import sys
+
+import pytest
+
+
+def _load_module():
+    spec_path = Path(__file__).resolve().parents[1] / "validate-cross-critique.py"
+    spec = importlib.util.spec_from_file_location("vcc", spec_path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["vcc"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _write_master(prebuilt: Path, slug: str, sources: list[dict], cross_critique=None):
+    d = prebuilt / f"master-{slug}"
+    d.mkdir(parents=True, exist_ok=True)
+    data = {"slug": slug, "sources": sources}
+    if cross_critique is not None:
+        data["cross_critique"] = cross_critique
+    (d / "meta.json").write_text(json.dumps(data), encoding="utf-8")
+
+
+@pytest.fixture
+def fake_tree(tmp_path):
+    prebuilt = tmp_path / "prebuilt"
+    # build enough masters to satisfy required_pairs in tests that need them
+    for slug in [
+        "huineng", "yinguang", "kumarajiva", "xuanzang", "zhiyi",
+        "tsongkhapa", "ajahn-chah", "mahasi-sayadaw", "atisha", "ouyi",
+    ]:
+        _write_master(prebuilt, slug, [{"type": "cbeta", "id": "T00n0001", "title": "demo"}])
+    return prebuilt
+
+
+def test_empty_cross_critique_is_ok(fake_tree):
+    vcc = _load_module()
+    # No master has cross_critique; structural check passes,
+    # but required_pairs check still fails (no coverage).
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert errors == []
+
+
+def test_well_formed_entry_passes(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[
+            {"target_master": "yinguang", "position": "对净土：本性弥陀唯心净土，何曾离自心。", "citation": "T48n2008"},
+        ])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    # Only the huineng→yinguang structural check should pass.
+    huineng_errors = [e for e in errors if "huineng" in e]
+    assert huineng_errors == []
+
+
+def test_missing_required_field(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[{"target_master": "yinguang"}])  # no position, no citation
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("position" in e for e in errors)
+    assert any("citation" in e for e in errors)
+
+
+def test_cannot_target_self(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[{"target_master": "huineng", "position": "x" * 50, "citation": "T48n2008"}])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("self" in e.lower() for e in errors)
+
+
+def test_cannot_target_meta_skill(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[{"target_master": "curriculum", "position": "x" * 50, "citation": "T48n2008"}])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("meta-skill" in e or "curriculum" in e for e in errors)
+
+
+def test_unknown_target_master(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[{"target_master": "ghost", "position": "x" * 50, "citation": "T48n2008"}])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("ghost" in e for e in errors)
+
+
+def test_citation_not_in_own_sources(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[{"target_master": "yinguang", "position": "x" * 50, "citation": "T99n9999"}])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("T99n9999" in e for e in errors)
+
+
+def test_position_length_bounds(fake_tree):
+    vcc = _load_module()
+    _write_master(fake_tree, "huineng",
+        [{"type": "cbeta", "id": "T48n2008", "title": "坛经"}],
+        cross_critique=[
+            {"target_master": "yinguang", "position": "短", "citation": "T48n2008"},  # < 10
+            {"target_master": "zhiyi", "position": "x" * 400, "citation": "T48n2008"},  # > 300
+        ])
+    errors = vcc.validate(fake_tree, check_coverage=False)
+    assert any("length" in e for e in errors)
+
+
+def test_coverage_fails_when_pairs_missing(fake_tree):
+    vcc = _load_module()
+    errors = vcc.validate(fake_tree, check_coverage=True)
+    # Should report all 16 missing critique entries.
+    missing_errors = [e for e in errors if "missing critique" in e]
+    assert len(missing_errors) == 16
+
+
+def test_coverage_succeeds_with_full_pairs(fake_tree):
+    vcc = _load_module()
+    pairs = [
+        ("huineng", "yinguang"), ("yinguang", "huineng"),
+        ("kumarajiva", "xuanzang"), ("xuanzang", "kumarajiva"),
+        ("huineng", "zhiyi"), ("zhiyi", "huineng"),
+        ("tsongkhapa", "huineng"), ("huineng", "tsongkhapa"),
+        ("ajahn-chah", "mahasi-sayadaw"), ("mahasi-sayadaw", "ajahn-chah"),
+        ("atisha", "huineng"), ("huineng", "atisha"),
+        ("ouyi", "yinguang"), ("yinguang", "ouyi"),
+        ("ouyi", "tsongkhapa"), ("tsongkhapa", "ouyi"),
+    ]
+    by_slug: dict[str, list[dict]] = {}
+    for src, tgt in pairs:
+        by_slug.setdefault(src, []).append(
+            {"target_master": tgt, "position": "x" * 50, "citation": "T00n0001"})
+    for slug, cc in by_slug.items():
+        _write_master(fake_tree, slug, [{"type": "cbeta", "id": "T00n0001", "title": "demo"}], cc)
+    errors = vcc.validate(fake_tree, check_coverage=True)
+    assert errors == []

package/scripts/tests/test_validate_curriculum_sources.py

@@ -0,0 +1,144 @@
+"""Tests for validate-curriculum-sources.py.
+
+Verifies that citations (CBETA T-numbers, X-numbers, Toh, compiled-teaching ids)
+and /master-<slug> references in curriculum reference files cross-check against
+the actual prebuilt master metadata.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+import importlib.util
+import sys
+
+
+def _load_module():
+    spec_path = Path(__file__).resolve().parents[1] / "validate-curriculum-sources.py"
+    spec = importlib.util.spec_from_file_location("vcs", spec_path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["vcs"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+@pytest.fixture
+def fake_prebuilt(tmp_path):
+    """Fake prebuilt tree with two masters and a curriculum dir."""
+    prebuilt = tmp_path / "prebuilt"
+    # Master A: cbeta source
+    (prebuilt / "master-aaa").mkdir(parents=True)
+    (prebuilt / "master-aaa" / "meta.json").write_text(json.dumps({
+        "slug": "aaa",
+        "sources": [{"type": "cbeta", "id": "T48n2008", "title": "demo"}],
+    }), encoding="utf-8")
+    # Master B: compiled_teaching source + Toh
+    (prebuilt / "master-bbb").mkdir(parents=True)
+    (prebuilt / "master-bbb" / "meta.json").write_text(json.dumps({
+        "slug": "bbb",
+        "sources": [
+            {"type": "compiled_teaching", "id": "AjahnChah:FoodForTheHeart", "title": "demo"},
+            {"type": "84000", "id": "Toh 21", "title": "demo"},
+        ],
+    }), encoding="utf-8")
+    (prebuilt / "master-curriculum" / "references").mkdir(parents=True)
+    return prebuilt
+
+
+def test_extract_citations_finds_T_numbers():
+    vcs = _load_module()
+    text = "See 《坛经》【T48n2008】 for details."
+    assert "T48n2008" in vcs.extract_citations(text)
+
+
+def test_extract_citations_finds_Toh():
+    vcs = _load_module()
+    text = "藏文藏经 Toh 21 心经..."
+    assert "Toh 21" in vcs.extract_citations(text)
+
+
+def test_extract_citations_finds_compiled_teaching():
+    vcs = _load_module()
+    text = "见 AjahnChah:FoodForTheHeart ..."
+    assert "AjahnChah:FoodForTheHeart" in vcs.extract_citations(text)
+
+
+def test_extract_master_slugs():
+    vcs = _load_module()
+    text = "推荐 master：/master-aaa ；交叉 /master-bbb 。"
+    assert vcs.extract_master_slugs(text) == {"aaa", "bbb"}
+
+
+def test_collect_known_citations(fake_prebuilt):
+    vcs = _load_module()
+    known = vcs.collect_known_citations(fake_prebuilt)
+    assert "T48n2008" in known
+    assert "AjahnChah:FoodForTheHeart" in known
+    assert "Toh 21" in known
+
+
+def test_validate_pass(fake_prebuilt):
+    vcs = _load_module()
+    ref = fake_prebuilt / "master-curriculum" / "references" / "ok.md"
+    ref.write_text(
+        "## Path\n- 主用经《坛经》【T48n2008】\n- master：/master-aaa\n- 藏：Toh 21\n",
+        encoding="utf-8",
+    )
+    errors = vcs.validate(fake_prebuilt)
+    assert errors == []
+
+
+def test_validate_fails_on_fabricated_citation(fake_prebuilt):
+    vcs = _load_module()
+    ref = fake_prebuilt / "master-curriculum" / "references" / "bad.md"
+    ref.write_text("【T99n9999】 fake\n", encoding="utf-8")
+    errors = vcs.validate(fake_prebuilt)
+    assert any("T99n9999" in e for e in errors)
+
+
+def test_validate_fails_on_unknown_master_slug(fake_prebuilt):
+    vcs = _load_module()
+    ref = fake_prebuilt / "master-curriculum" / "references" / "bad.md"
+    ref.write_text("/master-ghost\n", encoding="utf-8")
+    errors = vcs.validate(fake_prebuilt)
+    assert any("ghost" in e for e in errors)
+
+
+def test_validate_ignores_meta_skill_slugs(fake_prebuilt):
+    """/master-curriculum and /master-debate are meta-skills suppressed via
+    META_SKILL_SLUGS. /compare-masters never matches _SLUG (no /master- prefix),
+    so it is naturally ignored. None of these may raise validate errors."""
+    vcs = _load_module()
+    ref = fake_prebuilt / "master-curriculum" / "references" / "ok.md"
+    ref.write_text(
+        "延伸 → /compare-masters · /master-debate · /master-curriculum\n",
+        encoding="utf-8",
+    )
+    errors = vcs.validate(fake_prebuilt)
+    assert errors == []
+
+
+def test_validate_returns_error_when_refs_dir_missing(tmp_path):
+    vcs = _load_module()
+    prebuilt = tmp_path / "prebuilt"
+    prebuilt.mkdir()
+    # curriculum/references missing
+    errors = vcs.validate(prebuilt)
+    assert len(errors) == 1
+    assert "references dir not found" in errors[0]
+
+
+def test_extract_citations_finds_hyphenated_compiled_teaching():
+    vcs = _load_module()
+    text = "PTS:DN-Comm 注释 / BDRC:Pha-chos-Bu-chos"
+    cits = vcs.extract_citations(text)
+    assert "PTS:DN-Comm" in cits
+    assert "BDRC:Pha-chos-Bu-chos" in cits
+
+
+def test_extract_citations_finds_Toh_with_colon():
+    vcs = _load_module()
+    text = "见 Toh:3948"
+    assert "Toh:3948" in vcs.extract_citations(text)