master-skill 0.10.0 → 0.10.1

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" / "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

package/scripts/tests/test_validate_workflow.py

@@ -0,0 +1,265 @@
+"""Structural and behavior checks for the repository validation workflow."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[2]
+WORKFLOW_PATH = ROOT / ".github" / "workflows" / "validate-and-test.yml"
+WORKFLOW_TEXT = WORKFLOW_PATH.read_text(encoding="utf-8")
+
+
+def _load_workflow_text(text: str) -> dict:
+    workflow = yaml.safe_load(text)
+    assert isinstance(workflow, dict)
+    assert isinstance(workflow.get("jobs"), dict)
+    return workflow
+
+
+def _job(workflow: dict, job_name: str) -> dict:
+    job = workflow["jobs"].get(job_name)
+    assert isinstance(job, dict), f"missing workflow job: {job_name}"
+    assert isinstance(job.get("steps"), list), f"job has no steps: {job_name}"
+    return job
+
+
+def _step(workflow: dict, job_name: str, step_name: str) -> dict:
+    matches = [
+        step
+        for step in _job(workflow, job_name)["steps"]
+        if step.get("name") == step_name
+    ]
+    assert len(matches) == 1, f"expected one {job_name}/{step_name} step, got {len(matches)}"
+    return matches[0]
+
+
+def _assert_hard(step: dict) -> None:
+    assert step.get("continue-on-error") not in (True, "true")
+
+
+WORKFLOW = _load_workflow_text(WORKFLOW_TEXT)
+
+
+def test_free_text_tokens_cannot_substitute_for_workflow_structure():
+    fake = _load_workflow_text(
+        """\
+name: fake
+jobs:
+  validate:
+    steps:
+      - name: comments only
+        run: echo 'python -m pytest tests/ scripts/tests/ -v'
+"""
+    )
+
+    with pytest.raises(AssertionError, match="Run Python tests"):
+        _step(fake, "validate", "Run Python tests")
+
+
+def test_workflow_has_no_softened_steps():
+    for job_name, job in WORKFLOW["jobs"].items():
+        for step in job.get("steps", []):
+            assert step.get("continue-on-error") not in (True, "true"), (
+                f"softened workflow step in {job_name}: {step.get('name', step.get('uses'))}"
+            )
+
+
+@pytest.mark.parametrize(
+    ("step_name", "command"),
+    [
+        ("Run Python tests", "python -m pytest tests/ scripts/tests/ -v"),
+        ("Validate citation contracts", "python scripts/validate-citation-contract.py"),
+        (
+            "Validate lore_triggers content (v0.8 — hard gate)",
+            "python scripts/validate-lore-triggers-content.py --strict",
+        ),
+    ],
+)
+def test_validate_job_contains_hard_gate_commands(step_name: str, command: str):
+    step = _step(WORKFLOW, "validate", step_name)
+    assert step.get("run") == command
+    _assert_hard(step)
+
+
+@pytest.mark.parametrize(
+    ("step_name", "command"),
+    [
+        ("Check desktop formatting", "cargo fmt --manifest-path desktop/Cargo.toml -- --check"),
+        (
+            "Lint desktop app",
+            "cargo clippy --locked --manifest-path desktop/Cargo.toml "
+            "--all-targets -- -D warnings",
+        ),
+        ("Test desktop app", "cargo test --locked --manifest-path desktop/Cargo.toml"),
+        ("Build desktop app", "cargo build --locked --manifest-path desktop/Cargo.toml"),
+    ],
+)
+def test_desktop_job_contains_hard_gate_commands(step_name: str, command: str):
+    step = _step(WORKFLOW, "desktop-rust", step_name)
+    assert step.get("run") == command
+    _assert_hard(step)
+
+
+def test_desktop_quality_gates_run_before_tests_and_build():
+    step_names = [step.get("name") for step in _job(WORKFLOW, "desktop-rust")["steps"]]
+    assert step_names.index("Check desktop formatting") < step_names.index("Lint desktop app")
+    assert step_names.index("Lint desktop app") < step_names.index("Test desktop app")
+    assert step_names.index("Test desktop app") < step_names.index("Build desktop app")
+
+
+def test_windows_cli_job_installs_the_generator_python_runtime():
+    job = _job(WORKFLOW, "cli-windows")
+    uses = [step.get("uses", "") for step in job["steps"]]
+    assert any(use.startswith("actions/setup-python@") for use in uses)
+    install = _step(WORKFLOW, "cli-windows", "Install generator dependencies")
+    assert install.get("run") == "python -m pip install -r requirements.txt"
+    _assert_hard(install)
+
+
+def test_python39_job_compiles_and_runs_the_four_generator_cli_steps():
+    job = _job(WORKFLOW, "python-compat")
+    setup = next(
+        step
+        for step in job["steps"]
+        if str(step.get("uses", "")).startswith("actions/setup-python@")
+    )
+    assert setup.get("with", {}).get("python-version") == "3.9"
+    smoke = _step(WORKFLOW, "python-compat", "Run Python 3.9 generator smoke")
+    command = smoke["run"]
+    assert "python -m compileall -q tools scripts" in command
+    assert "sutra_collector.py" in command
+    assert "verify_sources.py --check-links" in command
+    assert "master_builder.py" in command
+    assert "verify_sources.py --final-check" in command
+    _assert_hard(smoke)
+
+
+def test_push_paths_include_distribution_and_generator_runtime():
+    triggers = WORKFLOW.get("on", WORKFLOW.get(True))
+    assert isinstance(triggers, dict)
+    paths = set(triggers["push"]["paths"])
+    assert {
+        "skill-catalog.json",
+        "SKILL.md",
+        "references/**",
+        "ETHICS.md",
+        "requirements.txt",
+        "README.md",
+        "README_EN.md",
+        "CONTRIBUTING.md",
+        "CHANGELOG.md",
+        "docs/PRD.md",
+        "docs/v1-framework-roadmap.md",
+        "masters/**",
+        ".claude-plugin/**",
+        ".cursor-plugin/**",
+        "gemini-extension.json",
+        ".github/PULL_REQUEST_TEMPLATE.md",
+        ".github/ISSUE_TEMPLATE/**",
+    } <= paths
+
+
+def test_pick_step_uses_checked_selector_without_fixed_roster():
+    checkout = next(
+        step
+        for step in _job(WORKFLOW, "fidelity-smoke")["steps"]
+        if str(step.get("uses", "")).startswith("actions/checkout@")
+    )
+    assert checkout.get("with", {}).get("fetch-depth") == 0
+    step = _step(WORKFLOW, "fidelity-smoke", "Pick smoke target")
+    script = step["run"]
+    assert "if ! CHANGED=$(python scripts/select-fidelity-smoke.py" in script
+    assert "if ! DIFF_OUTPUT=$(git diff --name-only" in script
+    assert "CHANGED_CANDIDATES" in script
+    assert "--prebuilt prebuilt" in script
+    assert '--day-of-year "$(date +%j)"' in script
+    assert "MASTERS=(" not in script
+    _assert_hard(step)
+
+
+def test_smoke_selector_producer_failure_is_not_masked(tmp_path: Path):
+    pick_step = _step(WORKFLOW, "fidelity-smoke", "Pick smoke target")
+    script = pick_step["run"].replace("${{ github.base_ref || 'main' }}", "main")
+
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    fake_python = bin_dir / "python"
+    fake_python.write_text(
+        "#!/bin/sh\nprintf 'master-partial\\n'\nexit 7\n",
+        encoding="utf-8",
+    )
+    fake_python.chmod(0o755)
+    output_path = tmp_path / "github-output"
+    env = os.environ.copy()
+    env["PATH"] = f"{bin_dir}:{env['PATH']}"
+    env["GITHUB_OUTPUT"] = str(output_path)
+
+    result = subprocess.run(
+        ["bash", "-e", "-o", "pipefail", "-c", script],
+        cwd=ROOT,
+        env=env,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert not output_path.exists()
+
+
+def test_smoke_git_diff_failure_is_not_masked(tmp_path: Path):
+    pick_step = _step(WORKFLOW, "fidelity-smoke", "Pick smoke target")
+    script = pick_step["run"].replace("${{ github.base_ref || 'main' }}", "main")
+
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    fake_git = bin_dir / "git"
+    fake_git.write_text("#!/bin/sh\nexit 7\n", encoding="utf-8")
+    fake_git.chmod(0o755)
+    fake_python = bin_dir / "python"
+    fake_python.write_text(
+        "#!/bin/sh\nprintf 'master-alpha\\n'\n",
+        encoding="utf-8",
+    )
+    fake_python.chmod(0o755)
+    output_path = tmp_path / "github-output"
+    env = os.environ.copy()
+    env["PATH"] = f"{bin_dir}:{env['PATH']}"
+    env["GITHUB_OUTPUT"] = str(output_path)
+
+    result = subprocess.run(
+        ["bash", "-e", "-o", "pipefail", "-c", script],
+        cwd=ROOT,
+        env=env,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "git diff failed" in result.stdout
+    assert not output_path.exists()
+
+
+@pytest.mark.parametrize(
+    ("job_name", "step_name"),
+    [
+        ("fidelity-smoke", "Run fidelity smoke"),
+        ("fidelity-full", "Run fidelity tests"),
+    ],
+)
+def test_each_fidelity_no_key_branch_records_step_summary(job_name: str, step_name: str):
+    job = _job(WORKFLOW, job_name)
+    assert job.get("needs") == "validate"
+    step = _step(WORKFLOW, job_name, step_name)
+    script = step["run"]
+    assert 'if [ -z "${ANTHROPIC_API_KEY:-}" ]; then' in script
+    assert script.count('echo "### Fidelity grading skipped"') == 1
+    assert '} >> "$GITHUB_STEP_SUMMARY"' in script
+    _assert_hard(step)