master-skill 0.10.0 → 0.11.0

package/scripts/tests/test_select_fidelity_smoke.py

@@ -0,0 +1,142 @@
+"""Behavior tests for deterministic fidelity smoke-target selection."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[2]
+SELECTOR = ROOT / "scripts" / "select-fidelity-smoke.py"
+
+
+def _write_meta(prebuilt: Path, slug: str, sources: object) -> None:
+    master_dir = prebuilt / slug
+    master_dir.mkdir(parents=True)
+    (master_dir / "meta.json").write_text(
+        json.dumps({"sources": sources}),
+        encoding="utf-8",
+    )
+
+
+def _run_selector(
+    prebuilt: Path,
+    day_of_year: str,
+    changed: str | list[str] | None = None,
+) -> subprocess.CompletedProcess[str]:
+    command = [
+        sys.executable,
+        str(SELECTOR),
+        "--prebuilt",
+        str(prebuilt),
+        "--day-of-year",
+        day_of_year,
+    ]
+    if changed is not None:
+        changed_values = [changed] if isinstance(changed, str) else changed
+        for candidate in changed_values:
+            command.extend(["--changed", candidate])
+    return subprocess.run(command, text=True, capture_output=True, check=False)
+
+
+@pytest.mark.parametrize(
+    ("day_of_year", "expected"),
+    [("008", "master-gamma"), ("099", "master-alpha"), ("100", "master-beta")],
+)
+def test_rotation_parses_zero_padded_days_as_decimal(
+    tmp_path: Path,
+    day_of_year: str,
+    expected: str,
+):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-gamma", [{"id": "g"}])
+    _write_meta(prebuilt, "master-alpha", [{"id": "a"}])
+    _write_meta(prebuilt, "master-beta", [{"id": "b"}])
+
+    result = _run_selector(prebuilt, day_of_year)
+
+    assert result.returncode == 0, result.stderr
+    assert result.stdout == f"{expected}\n"
+    assert result.stderr == ""
+
+
+def test_changed_persona_wins_only_when_in_discovered_roster(tmp_path: Path):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-alpha", [{"id": "a"}])
+    _write_meta(prebuilt, "master-beta", [{"id": "b"}])
+
+    selected = _run_selector(prebuilt, "008", "master-beta")
+    rotated = _run_selector(prebuilt, "008", "master-not-discovered")
+
+    assert selected.returncode == 0, selected.stderr
+    assert selected.stdout == "master-beta\n"
+    assert rotated.returncode == 0, rotated.stderr
+    assert rotated.stdout == "master-alpha\n"
+
+
+def test_meta_skill_before_persona_does_not_hide_changed_persona(tmp_path: Path):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-alpha", [{"id": "a"}])
+    _write_meta(prebuilt, "master-beta", [{"id": "b"}])
+
+    result = _run_selector(
+        prebuilt,
+        "008",
+        ["compare-masters", "master-beta", "master-alpha"],
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert result.stdout == "master-beta\n"
+
+
+def test_discovery_ignores_meta_skills_and_empty_sources(tmp_path: Path):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "compare-masters", [{"id": "meta"}])
+    _write_meta(prebuilt, "master-empty", [])
+    _write_meta(prebuilt, "master-valid", [{"id": "source"}])
+
+    result = _run_selector(prebuilt, "100")
+
+    assert result.returncode == 0, result.stderr
+    assert result.stdout == "master-valid\n"
+
+
+def test_empty_roster_fails_closed(tmp_path: Path):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-empty", [])
+
+    result = _run_selector(prebuilt, "008")
+
+    assert result.returncode != 0
+    assert result.stdout == ""
+    assert "No persona smoke targets" in result.stderr
+
+
+def test_invalid_json_after_valid_metadata_fails_without_partial_stdout(tmp_path: Path):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-alpha", [{"id": "a"}])
+    invalid_dir = prebuilt / "master-zeta"
+    invalid_dir.mkdir(parents=True)
+    (invalid_dir / "meta.json").write_text("{not-json", encoding="utf-8")
+
+    result = _run_selector(prebuilt, "008")
+
+    assert result.returncode != 0
+    assert result.stdout == ""
+    assert "master-zeta/meta.json" in result.stderr
+
+
+@pytest.mark.parametrize("day_of_year", ["0", "367", "not-a-day"])
+def test_invalid_day_fails_closed(tmp_path: Path, day_of_year: str):
+    prebuilt = tmp_path / "prebuilt"
+    _write_meta(prebuilt, "master-alpha", [{"id": "a"}])
+
+    result = _run_selector(prebuilt, day_of_year)
+
+    assert result.returncode != 0
+    assert result.stdout == ""
+    assert "day-of-year" in result.stderr

package/scripts/tests/test_validate.py

@@ -0,0 +1,145 @@
+"""Tests for scripts/validate.py — the strict gate `npm run validate` runs.
+
+parse_frontmatter had no tests, which is how it kept only the last entry of
+`sources:` and dropped every `cbeta_id`. The sources[] checks in lint_master
+were reading a shape the file never had.
+"""
+
+import importlib.util
+from pathlib import Path
+
+MODULE_PATH = Path(__file__).resolve().parents[1] / "validate.py"
+SPEC = importlib.util.spec_from_file_location("validate_module", MODULE_PATH)
+validate_module = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(validate_module)
+
+parse_frontmatter = validate_module.parse_frontmatter
+
+FRONTMATTER = """---
+name: master-test
+description: Test master.
+version: 0.5.0
+license: MIT
+lineage: 测试宗
+dates: 638-713
+sources:
+  - title: 六祖大师法宝坛经
+    cbeta_id: T48n2008
+    fojin_text_id: 58
+  - title: 金刚般若波罗蜜经
+    cbeta_id: T08n0235
+    fojin_text_id: 7
+  - title: 维摩诘所说经
+    cbeta_id: T14n0475
+    fojin_text_id: 28
+citation_format: "【《{title}》{section}，{cbeta_id}】"
+verified_by: xr843
+verified_at: 2026-04-06
+---
+
+# Body
+"""
+
+
+def _write(tmp_path: Path, text: str) -> Path:
+    path = tmp_path / "SKILL.md"
+    path.write_text(text, encoding="utf-8")
+    return path
+
+
+def test_parse_frontmatter_keeps_every_source(tmp_path):
+    """All three declared sources survive, not just the last one."""
+    fm, _, _ = parse_frontmatter(_write(tmp_path, FRONTMATTER))
+
+    titles = [s["title"] for s in fm["sources"]]
+    assert titles == ["六祖大师法宝坛经", "金刚般若波罗蜜经", "维摩诘所说经"]
+
+
+def test_parse_frontmatter_keeps_continuation_keys(tmp_path):
+    """cbeta_id and fojin_text_id sit on continuation lines and must survive.
+
+    Every citation check downstream keys off cbeta_id; dropping it silently
+    empties the data the sources[] rules are supposed to inspect.
+    """
+    fm, _, _ = parse_frontmatter(_write(tmp_path, FRONTMATTER))
+
+    assert [s.get("cbeta_id") for s in fm["sources"]] == [
+        "T48n2008",
+        "T08n0235",
+        "T14n0475",
+    ]
+    assert fm["sources"][0].get("fojin_text_id") == 58
+
+
+def test_parse_frontmatter_reads_scalar_keys(tmp_path):
+    """Scalar keys around the list keep working."""
+    fm, _, _ = parse_frontmatter(_write(tmp_path, FRONTMATTER))
+
+    assert fm["name"] == "master-test"
+    assert fm["lineage"] == "测试宗"
+    assert fm["citation_format"] == "【《{title}》{section}，{cbeta_id}】"
+
+
+def test_parse_frontmatter_surfaces_a_malformed_source_before_the_last(tmp_path):
+    """A source with neither title nor cbeta_id must reach lint_master.
+
+    lint_master flags `sources[i] missing 'title' or 'cbeta_id'`, but only
+    ever saw the final entry — a malformed one anywhere earlier was invisible.
+    """
+    text = FRONTMATTER.replace(
+        "  - title: 六祖大师法宝坛经\n    cbeta_id: T48n2008\n    fojin_text_id: 58\n",
+        "  - fojin_text_id: 58\n    note: no title and no cbeta_id\n",
+    )
+    fm, _, _ = parse_frontmatter(_write(tmp_path, text))
+
+    assert len(fm["sources"]) == 3
+    bad = fm["sources"][0]
+    assert "title" not in bad and "cbeta_id" not in bad
+
+
+def test_parse_frontmatter_without_frontmatter(tmp_path):
+    """A file with no frontmatter yields an empty dict, not a crash."""
+    fm, body, _ = parse_frontmatter(_write(tmp_path, "# Just a body\n"))
+
+    assert fm == {}
+    assert "Just a body" in body
+
+
+def test_parse_frontmatter_rejects_invalid_yaml(tmp_path):
+    """Malformed frontmatter raises instead of being silently mis-parsed.
+
+    The old parser accepted anything, which let two skills ship a description
+    holding a bare `: ` — YAML reads that as a nested mapping and rejects the
+    whole block. Clients that parse frontmatter strictly see no frontmatter
+    at all, so this must fail loudly here.
+    """
+    text = "---\nname: master-test\ndescription: keyed on 时序: staged plan\n---\n"
+    try:
+        parse_frontmatter(_write(tmp_path, text))
+    except ValueError as exc:
+        assert "invalid YAML frontmatter" in str(exc)
+    else:
+        raise AssertionError("invalid YAML frontmatter was accepted")
+
+
+def test_curriculum_sources_subcheck_is_wired_in():
+    """The curriculum gate must be reachable from validate.py.
+
+    master-curriculum/SKILL.md claims CI enforces it, but the script was in no
+    workflow, no npm script and no sub-check — only unit tests over synthetic
+    trees. It passed against the real references/ by luck, never by check.
+    """
+    assert hasattr(validate_module, "_run_curriculum_sources_subcheck")
+    assert validate_module._run_curriculum_sources_subcheck() == []
+
+
+def test_every_prebuilt_skill_has_parseable_frontmatter():
+    """Every shipped SKILL.md must parse — this is the case that would have
+    caught master-curriculum and master-debate before they shipped."""
+    prebuilt = Path(__file__).resolve().parents[2] / "prebuilt"
+    skills = sorted(prebuilt.glob("*/SKILL.md"))
+    assert skills, f"no SKILL.md found under {prebuilt}"
+
+    for skill in skills:
+        fm, _, _ = parse_frontmatter(skill)
+        assert fm.get("name"), f"{skill.parent.name}: frontmatter has no name"

package/scripts/tests/test_validate_citation_contract.py

@@ -0,0 +1,408 @@
+"""Tests for the cross-tradition citation contract validator."""
+from __future__ import annotations
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def validator():
+    script_path = Path(__file__).resolve().parents[1] / "validate-citation-contract.py"
+    spec = importlib.util.spec_from_file_location("validate_citation_contract", script_path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["validate_citation_contract"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+@pytest.fixture
+def fake_tree(tmp_path: Path) -> Path:
+    return tmp_path / "prebuilt"
+
+
+def contract(*types: str) -> dict:
+    return {
+        "version": 1,
+        "claim_policy": "declared_sources_only",
+        "required_for": [
+            "doctrinal_claim",
+            "practice_guidance",
+            "text_interpretation",
+        ],
+        "allowed_source_types": sorted(types),
+        "minimum_claim_coverage": 0.9,
+        "live_retrieval_allowed": True,
+    }
+
+
+def write_meta(
+    prebuilt: Path,
+    slug: str,
+    source_types: list[str],
+    value: dict | None,
+    *,
+    kind: str | None = None,
+) -> None:
+    directory = prebuilt / f"master-{slug}"
+    directory.mkdir(parents=True, exist_ok=True)
+    data = {
+        "slug": slug,
+        "sources": [
+            {"type": source_type, "id": f"id-{index}", "title": f"source-{index}"}
+            for index, source_type in enumerate(source_types)
+        ],
+    }
+    if kind is not None:
+        data["kind"] = kind
+    if value is not None:
+        data["citation_contract"] = value
+    (directory / "meta.json").write_text(json.dumps(data), encoding="utf-8")
+
+
+@pytest.mark.parametrize(
+    "source_types",
+    [
+        ["cbeta"],
+        ["tibetan_canon", "tibetan_treatise"],
+        ["compiled_teaching", "pali_canon", "pali_treatise"],
+    ],
+)
+def test_valid_source_family_contracts_pass(validator, fake_tree, source_types):
+    write_meta(fake_tree, "demo", source_types, contract(*source_types))
+    assert validator.validate(fake_tree) == []
+
+
+def test_missing_contract_fails(validator, fake_tree):
+    write_meta(fake_tree, "demo", ["cbeta"], None)
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and "citation_contract" in error
+        for error in errors
+    )
+
+
+@pytest.mark.parametrize("allowed", [[], ["cbeta", "pali_canon"]])
+def test_source_type_drift_fails(validator, fake_tree, allowed):
+    value = contract("cbeta")
+    value["allowed_source_types"] = allowed
+    write_meta(fake_tree, "demo", ["cbeta"], value)
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and "allowed_source_types" in error
+        for error in errors
+    )
+
+
+@pytest.mark.parametrize(
+    ("field", "invalid"),
+    [
+        ("version", 2),
+        ("claim_policy", "any_source"),
+        ("required_for", ["doctrinal_claim"]),
+        ("minimum_claim_coverage", True),
+        ("minimum_claim_coverage", 0.8),
+        ("live_retrieval_allowed", "yes"),
+    ],
+)
+def test_fixed_contract_values_are_enforced(
+    validator,
+    fake_tree,
+    field,
+    invalid,
+):
+    value = contract("cbeta")
+    value[field] = invalid
+    write_meta(fake_tree, "demo", ["cbeta"], value)
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and field in error for error in errors
+    )
+
+
+def test_meta_skill_without_sources_is_ignored(validator, fake_tree):
+    write_meta(fake_tree, "debate", [], None, kind="meta-skill")
+    assert validator.validate(fake_tree) == []
+
+
+def test_meta_skill_must_not_declare_persona_contract(validator, fake_tree):
+    write_meta(
+        fake_tree,
+        "debate",
+        ["cbeta"],
+        contract("cbeta"),
+        kind="meta-skill",
+    )
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-debate/meta.json" in error and "meta-skill" in error
+        for error in errors
+    )
+
+
+def test_persona_without_sources_is_not_treated_as_meta_skill(validator, fake_tree):
+    write_meta(fake_tree, "demo", [], None)
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and "sources" in error for error in errors
+    )
+
+
+@pytest.mark.parametrize("mutation", ["missing", "extra"])
+def test_contract_keys_are_exact(validator, fake_tree, mutation):
+    value = contract("cbeta")
+    if mutation == "missing":
+        del value["claim_policy"]
+    else:
+        value["unexpected"] = "value"
+    write_meta(fake_tree, "demo", ["cbeta"], value)
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and "citation_contract" in error
+        for error in errors
+    )
+
+
+@pytest.mark.parametrize("source_type", ["", "   ", None, True])
+def test_source_types_must_be_non_empty_strings(
+    validator,
+    fake_tree,
+    source_type,
+):
+    write_meta(fake_tree, "demo", [source_type], contract("cbeta"))
+    errors = validator.validate(fake_tree)
+    assert any(
+        "master-demo/meta.json" in error and "sources[].type" in error
+        for error in errors
+    )
+
+
+def test_cli_exit_codes_and_persona_count(
+    validator,
+    fake_tree,
+    monkeypatch,
+    capsys,
+):
+    monkeypatch.setattr(validator, "PREBUILT_DIR", fake_tree)
+    monkeypatch.setattr(validator, "EXPECTED_PERSONA_SLUGS", ("demo",))
+    write_meta(fake_tree, "demo", ["cbeta"], None)
+
+    assert validator.main() == 1
+    assert "master-demo/meta.json" in capsys.readouterr().err
+
+    write_meta(fake_tree, "demo", ["cbeta"], contract("cbeta"))
+    assert validator.main() == 0
+    captured = capsys.readouterr()
+    assert captured.err == ""
+    assert captured.out.strip() == "citation contracts OK (1 personas)"
+
+
+def test_repository_mode_fails_when_prebuilt_directory_is_missing(
+    validator,
+    tmp_path,
+):
+    errors = validator.validate_repository(tmp_path / "missing")
+    assert any("prebuilt directory" in error for error in errors)
+
+
+def test_repository_mode_fails_with_zero_personas(validator, fake_tree):
+    write_meta(fake_tree, "debate", [], None, kind="meta-skill")
+    errors = validator.validate_repository(fake_tree)
+    assert any("persona roster" in error and "missing" in error for error in errors)
+
+
+def test_repository_mode_fails_with_fourteen_personas(validator, fake_tree):
+    for slug in validator.EXPECTED_PERSONA_SLUGS[:-1]:
+        write_meta(fake_tree, slug, ["cbeta"], contract("cbeta"))
+
+    errors = validator.validate_repository(fake_tree)
+    missing = validator.EXPECTED_PERSONA_SLUGS[-1]
+    assert any(
+        "persona roster" in error and f"master-{missing}" in error
+        for error in errors
+    )
+
+
+def test_repository_mode_accepts_the_real_fifteen_persona_roster(validator):
+    repository = Path(__file__).resolve().parents[2]
+    assert validator.validate_repository(repository / "prebuilt") == []
+
+
+def test_repository_wording_uses_declared_source_contract():
+    repository = Path(__file__).resolve().parents[2]
+    runtime_paths = [
+        repository / "SKILL.md",
+        repository / "prebuilt" / "compare-masters" / "SKILL.md",
+        repository / "prompts" / "doctrine_reviewer.md",
+        repository / "references" / "ethics-runtime.md",
+        repository / "references" / "source-conventions.md",
+        repository / "docs" / "PRD.md",
+        repository / "docs" / "v1-framework-roadmap.md",
+        repository / "ETHICS.md",
+        repository / "README.md",
+        repository / "README_EN.md",
+        repository / "CONTRIBUTING.md",
+    ]
+    forbidden = [
+        "NO DOCTRINAL CLAIM WITHOUT CBETA CITATION",
+        "每位祖师的回答必须附 CBETA 引用",
+        "CBETA 经证覆盖率 ≥ 90%",
+        "primary_cbeta_ids 过滤结果",
+        "当前版本仅汉传",
+        "无 CBETA 经号的教义断言不得写入",
+        "每一条教义断言必须附一个**真实**的 CBETA 经号",
+    ]
+    for path in runtime_paths:
+        content = path.read_text(encoding="utf-8")
+        for phrase in forbidden:
+            assert phrase not in content, (
+                f"{path}: stale source-family rule: {phrase}"
+            )
+
+    root_text = runtime_paths[0].read_text(encoding="utf-8")
+    compare_text = runtime_paths[1].read_text(encoding="utf-8")
+    reviewer_text = runtime_paths[2].read_text(encoding="utf-8")
+    conventions_text = runtime_paths[4].read_text(encoding="utf-8")
+
+    for text in (root_text, compare_text):
+        assert "NO DOCTRINAL CLAIM WITHOUT A DECLARED SOURCE CITATION" in text
+        assert "citation_contract.allowed_source_types" in text
+        assert "meta.json.sources[]" in text
+        assert "live_retrieval_allowed" in text
+
+    assert "primary_cbeta_ids" not in compare_text
+    assert "minimum_claim_coverage" in reviewer_text
+    assert "同等适用 citation contract" in conventions_text
+    contributing_text = runtime_paths[-1].read_text(encoding="utf-8")
+    assert "validate-citation-contract.py" in contributing_text
+    assert '"citation_contract"' in contributing_text
+    assert "meta.json.sources[]" in contributing_text
+    for source_family in (
+        "CBETA",
+        "BDRC / Toh",
+        "PTS / SuttaCentral",
+        "compiled teachings",
+    ):
+        assert source_family in conventions_text
+
+
+def test_non_cbeta_runtime_instructions_are_source_family_aware():
+    repository = Path(__file__).resolve().parents[2]
+    slugs = (
+        "atisha",
+        "tsongkhapa",
+        "milarepa",
+        "buddhaghosa",
+        "mahasi-sayadaw",
+        "ajahn-chah",
+    )
+    for slug in slugs:
+        persona = repository / "prebuilt" / f"master-{slug}"
+        meta = json.loads((persona / "meta.json").read_text(encoding="utf-8"))
+        assert "cbeta" not in meta["citation_contract"]["allowed_source_types"]
+        instructions = (persona / "SKILL.md").read_text(encoding="utf-8")
+        for stale in ("cbeta_id", "--sources cbeta", "以 CBETA 汉文为主"):
+            assert stale not in instructions, f"master-{slug}: stale {stale}"
+        for required in (
+            "source_type",
+            "source_id",
+            "meta.json.sources[]",
+            "citation_contract.allowed_source_types",
+        ):
+            assert required in instructions, f"master-{slug}: missing {required}"
+
+    rag = (repository / "prompts" / "rag_instructions.md").read_text(
+        encoding="utf-8"
+    )
+    assert "--sources cbeta" not in rag
+    for required in (
+        "source_type",
+        "source_id",
+        "meta.json.sources[]",
+        "citation_contract.allowed_source_types",
+    ):
+        assert required in rag
+
+
+def test_live_retrieval_never_uses_sources_outside_the_declared_contract():
+    repository = Path(__file__).resolve().parents[2]
+    persona_skills = []
+    for path in sorted((repository / "prebuilt").glob("master-*/SKILL.md")):
+        meta_path = path.parent / "meta.json"
+        if not meta_path.is_file():
+            continue
+        metadata = json.loads(meta_path.read_text(encoding="utf-8"))
+        if isinstance(metadata.get("sources"), list) and metadata["sources"]:
+            persona_skills.append(path)
+    assert len(persona_skills) == 15
+    for path in persona_skills:
+        content = path.read_text(encoding="utf-8")
+        for stale in (
+            "声明经典之外",
+            "所列经典之外",
+            "三部经之外",
+            "上述三部经之外",
+        ):
+            assert stale not in content, f"{path}: contradictory live trigger {stale}"
+        assert "先人工扩充 `sources[]` / citation contract" in content
+        assert "已声明来源" in content
+
+
+def test_create_master_docs_match_the_real_generator_cli():
+    repository = Path(__file__).resolve().parents[2]
+    root = (repository / "SKILL.md").read_text(encoding="utf-8")
+    workflow = (repository / "references" / "workflow-details.md").read_text(
+        encoding="utf-8"
+    )
+    conventions = (repository / "references" / "source-conventions.md").read_text(
+        encoding="utf-8"
+    )
+    combined = root + workflow + conventions
+    assert "sutra_collector.py --name" in combined
+    assert "--output collected_data.json" in combined
+    assert "verify_sources.py --check-links collected_data.json" in combined
+    assert "master_builder.py --spec generated-master.json" in combined
+    assert "verify_sources.py --final-check" in combined
+    assert "masters/master-{slug}/" in root
+    assert "masters/master-{slug}/" in workflow
+    assert "masters/master-{slug}/" in conventions
+    assert "masters/{slug}/" not in combined
+    assert "生成器内存" in root
+    assert "master_builder.py --name" not in combined
+
+
+def test_create_master_prompts_and_contribution_paths_are_source_neutral():
+    repository = Path(__file__).resolve().parents[2]
+    source_prompts = [
+        repository / "prompts" / "sutra_analyzer.md",
+        repository / "prompts" / "teaching_builder.md",
+        repository / "prompts" / "voice_builder.md",
+    ]
+    for path in source_prompts:
+        content = path.read_text(encoding="utf-8")
+        for stale in (
+            "`cbeta_id`",
+            "`fojin_url`",
+            "所有经文引用必须附 FoJin 链接",
+            "https://fojin.app/texts/{text_id}",
+        ):
+            assert stale not in content, f"{path}: stale {stale}"
+        assert "source_id" in content, f"{path}: missing source_id"
+
+    intake = (repository / "prompts" / "intake.md").read_text(encoding="utf-8")
+    for tradition in ("印度", "汉传", "藏传", "南传"):
+        assert tradition in intake
+    assert "当前版本仅汉传" not in intake
+
+    pull_request = (
+        repository / ".github" / "PULL_REQUEST_TEMPLATE.md"
+    ).read_text(encoding="utf-8")
+    issue = (
+        repository / ".github" / "ISSUE_TEMPLATE" / "new_master.yml"
+    ).read_text(encoding="utf-8")
+    for content in (pull_request, issue):
+        assert "声明来源" in content
+    assert "validate-citation-contract.py" in pull_request