@christang/keel 5.66.0 → 5.68.0

package/scripts/validate_plugin.py

@@ -38,8 +38,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.66.0"
-PROTOCOL_VERSION = "5.66.0"
+PACKAGE_VERSION = "5.68.0"
+PROTOCOL_VERSION = "5.68.0"
 LEGACY_MANAGED_START = "<!-- keel:start version=2.1 -->"
 OPENSPEC_SCHEMA_NAME = "keel-spec-driven"
 # Mirrors KEEL_PACKAGE_NAME in scripts/install_to_repo.py, one of the two
@@ -14396,6 +14396,27 @@ def validate_native_plugin_manifests_scenario() -> int:
                 f"source: {skill_name}"
             )
             return 1
+        # A referenced `guidance.md` travels with the body that names it. The
+        # host reads the plugin copy directly, so a guidance file the parity
+        # check ignored could drift from the criteria it was split out of, and
+        # the drift would be invisible to everything except a reader.
+        canonical_guidance = canonical_skill.parent / "guidance.md"
+        plugin_guidance = plugin_skill.parent / "guidance.md"
+        if canonical_guidance.is_file() and not plugin_guidance.is_file():
+            report(
+                "native-plugin-manifests guidance file diverges from canonical "
+                f"source: {skill_name} has guidance.md that the plugin does not "
+                "ship, so the body's reference resolves to nothing"
+            )
+            return 1
+        if canonical_guidance.is_file() and plugin_guidance.read_text(
+            encoding="utf-8"
+        ) != canonical_guidance.read_text(encoding="utf-8"):
+            report(
+                "native-plugin-manifests guidance file diverges from canonical "
+                f"source: {skill_name}"
+            )
+            return 1
     lenses_root = ROOT / "assets/lenses"
     for template in ("web.md", "hardware.md", "hardware-dsl.md"):
         if not (lenses_root / template).is_file():
@@ -20692,6 +20713,15 @@ def validate_native_goal_capabilities_scenario() -> int:
     return 0
 
 
+# The referenced half of a split skill. Returns "" for a skill with one body, so
+# every assertion about a skill's content reads the same shape whether or not it
+# was split — a split must not be able to drop a required statement, and a
+# scenario must not have to know which skills were split to stay correct.
+def skill_guidance_text(skill_md: Path) -> str:
+    guidance = skill_md.parent / "guidance.md"
+    return guidance.read_text(encoding="utf-8") if guidance.is_file() else ""
+
+
 SINGLE_TASK_GOAL_SKILL = "keel-run-single-task-goal"
 OFFICIAL_GOAL_SOURCES = (
     "https://learn.chatgpt.com/use-cases/follow-goals",
@@ -20711,7 +20741,13 @@ def validate_single_task_goal_skill_scenario() -> int:
     if canonical_bytes != projection.read_bytes():
         report("single-task-goal-skill projection is not byte-equal to the canonical source.")
         return 1
-    text = canonical_bytes.decode("utf-8")
+    # A skill split into a body and a referenced `guidance.md` carries its
+    # content across both files. What these assertions require is that the skill
+    # states the thing, not that SKILL.md does, so the split must not be able to
+    # drop a required statement by moving it — and must not be able to keep one
+    # only in a file the plugin does not ship, which `native-plugin-manifests`
+    # checks byte-for-byte alongside the body.
+    text = canonical_bytes.decode("utf-8") + skill_guidance_text(canonical)
 
     # Authoritative official sources are linked, and provenance/license is recorded.
     for source in OFFICIAL_GOAL_SOURCES:
@@ -20916,8 +20952,9 @@ def _goal_target_surface(target: str) -> int:
             return 1
 
         # The skill carries the target-specific fallback guidance.
-        skill_text = (ROOT / "plugins/keel/skills" / SINGLE_TASK_GOAL_SKILL / "SKILL.md").read_text(
-            encoding="utf-8"
+        skill_body = ROOT / "plugins/keel/skills" / SINGLE_TASK_GOAL_SKILL / "SKILL.md"
+        skill_text = skill_body.read_text(encoding="utf-8") + skill_guidance_text(
+            skill_body
         )
         if target == "claude" and "disabled hooks" not in skill_text.lower():
             report("native-goal-claude skill lacks the disabled-hooks fallback.")
@@ -28721,10 +28758,17 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
 
     # A header naming every declaration while miscounting them in prose passes:
     # membership is the checkable property, and a count is a lossy restatement.
-    miscounted = flat_header.replace(
-        "Six independent declarations", "Five independent declarations"
+    # The numeral is located by shape, not by its current value. Pinning the
+    # word here would reintroduce the literal this scenario exists to remove,
+    # one level down: adding `executor_tier` moved the header to "Seven" and the
+    # mutation stopped finding anything to vary.
+    miscounted, varied = re.subn(
+        r"\b\w+ independent declarations\b",
+        "Zero independent declarations",
+        flat_header,
+        count=1,
     )
-    if miscounted == flat_header:
+    if not varied:
         report(f"{label}: the header's prose count could not be located to vary it.")
         return 1
     if config_header_problem(names, miscounted):
@@ -28741,6 +28785,766 @@ def validate_a_count_is_derived_from_what_it_counts_scenario() -> int:
     return 0
 
 
+def validate_a_tier_declares_what_is_skipped_scenario() -> int:
+    """Issue #135: which guidance an executor skips is a declaration, not a judgement.
+
+    A strong executor gets no value from stepwise how-to prose and pays for it on
+    every activation. The report's own argument against letting the executor
+    decide is that "do I need this?" is the judgement it is worst at, so the skip
+    is written down by the repository. The tier reaches guidance and nothing else:
+    a reader who takes it for a relaxation of the gates is worse off than one who
+    never saw it, which is why every surface that reports it says so.
+    """
+    label = "a-tier-declares-what-is-skipped"
+
+    with tempfile.TemporaryDirectory(prefix="keel-tier-") as raw:
+        root = Path(raw)
+
+        def fixture(name: str, body: str) -> Path:
+            repo = root / name
+            repo.mkdir()
+            (repo / "keel").mkdir()
+            (repo / "keel" / "config.yaml").write_text(body, encoding="utf-8")
+            return repo
+
+        def context(repo: Path) -> str:
+            return run_keel(repo, "context").stdout
+
+        # M1 — the declared tier is reported, an absent one reports the default,
+        # and both say guidance is all the tier reaches.
+        for name, body, expected in (
+            ("high", "fast_check: echo high\nexecutor_tier: high\n", "high"),
+            ("absent", "fast_check: echo absent\n", "standard"),
+        ):
+            repo = fixture(name, body)
+            out = context(repo)
+            line = next(
+                (l for l in out.splitlines() if l.startswith("Executor tier:")), None
+            )
+            if line is None:
+                report(
+                    f"{label}: no executor tier reported — the {name} repository "
+                    "is told nothing about which guidance its skills load."
+                )
+                report(out)
+                return 1
+            if expected not in line:
+                report(
+                    f"{label}: the {name} repository reports {line!r} rather than "
+                    f"the {expected!r} tier."
+                )
+                return 1
+            if "guidance" not in line:
+                report(
+                    f"{label}: no executor tier reported as affecting guidance "
+                    f"only; {line!r} leaves a reader free to take it for a "
+                    "relaxation of the gates."
+                )
+                return 1
+
+        # M2 — a value Keel cannot read fails closed to reading the guidance.
+        # The author of a typo believes they declared what they typed, so a
+        # misspelling must not silently buy the skip it asked for, and the
+        # refusal names the value and the alternatives rather than the key.
+        typo = fixture("typo", "fast_check: echo typo\nexecutor_tier: aggressive\n")
+        out = context(typo)
+        line = next(
+            (l for l in out.splitlines() if l.startswith("Executor tier:")), None
+        )
+        if line is None:
+            report(
+                f"{label}: accepted a tier outside the set — the projection "
+                "reported no tier at all for an unreadable value, so the "
+                "fallback is invisible."
+            )
+            report(out)
+            return 1
+        if "standard" not in line:
+            report(
+                f"{label}: accepted a tier outside the set — an unreadable value "
+                f"did not fall back to reading the guidance; got {line!r}."
+            )
+            report(out)
+            return 1
+        if "aggressive" not in out:
+            report(
+                f"{label}: the rejected value is not named, so the author is "
+                "left believing they declared what they typed."
+            )
+            report(out)
+            return 1
+        if "high" not in out:
+            report(
+                f"{label}: the refusal does not name the accepted tiers, so the "
+                "reader learns their value is wrong and not what is right."
+            )
+            report(out)
+            return 1
+        doctor = run_keel(typo, "--doctor").stdout
+        if "executor_tier" not in doctor or "aggressive" not in doctor:
+            report(
+                f"{label}: the doctor does not report the declaration as failed "
+                "and name the entry, so it reports health the projection "
+                "contradicts."
+            )
+            report(doctor)
+            return 1
+        healthy = run_keel(fixture("ok", "executor_tier: high\n"), "--doctor").stdout
+        if "executor_tier: high" not in healthy:
+            report(
+                f"{label}: the doctor does not report a readable declaration, so "
+                "the only tier it ever mentions is a broken one."
+            )
+            report(healthy)
+            return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
+# The words Keel states a criterion in. A guidance file is asserted to contain
+# none of them, which is what makes "the executor tier removes no criterion" a
+# property of the repository rather than a promise in a design document: a tier
+# can only skip a file that decides nothing.
+CRITERION_VOCABULARY = ("MUST", "SHOULD", "refuses", "rejects", "hard-stops")
+
+
+def guidance_criterion_problem(name: str, text: str) -> str | None:
+    """Return the problem a guidance file's text has, or None.
+
+    Takes the text rather than reading the path, so the rule can be exercised on
+    a planted copy. A rule that could only ever see files already known to be
+    clean would pass forever without anyone learning whether it fires.
+    """
+    for word in CRITERION_VOCABULARY:
+        if word in text:
+            return (
+                f"{name}'s guidance.md states a criterion — it contains "
+                f"{word!r}, and a criterion in the file the executor tier skips "
+                "would let `executor_tier: high` relax a rule rather than skip "
+                "an explanation. Move the sentence back into SKILL.md."
+            )
+    return None
+
+
+def validate_guidance_is_referenced_and_carries_no_criterion_scenario() -> int:
+    """Issue #135: stepwise guidance is referenced, and it decides nothing.
+
+    Keel is not on the delivery path for a skill body — the host reads
+    `plugins/keel/skills/*/SKILL.md` directly — so the only way the resident cost
+    falls is for the body to be smaller. What leaves it is how-to prose; every
+    criterion stays, and that is checked here by planting one rather than
+    promised, because a tier that could remove a criterion would be a relaxation
+    of the gates wearing a capability label.
+    """
+    label = "guidance-is-referenced-and-carries-no-criterion"
+    skills_root = ROOT / "src/skills"
+    guidance_files = sorted(skills_root.glob("*/guidance.md"))
+
+    # D4 splits exactly one skill today. An empty glob would satisfy every loop
+    # below without reading anything, so the count is asserted first.
+    if not guidance_files:
+        report(
+            f"{label}: no skill has a guidance.md, so every assertion below is "
+            "vacuous — the split this scenario checks did not happen."
+        )
+        return 1
+
+    for guidance in guidance_files:
+        skill = guidance.parent / "SKILL.md"
+        body = skill.read_text(encoding="utf-8")
+        text = guidance.read_text(encoding="utf-8")
+        if "guidance.md" not in body:
+            report(
+                f"{label}: guidance file is not referenced — "
+                f"{guidance.parent.name}'s SKILL.md never names guidance.md, so "
+                "the prose that left the body is unreachable from it."
+            )
+            return 1
+        if "executor_tier" not in body:
+            report(
+                f"{label}: {guidance.parent.name}'s SKILL.md names guidance.md "
+                "without the condition under which it is read, which leaves the "
+                "skip to the executor's own judgement — the judgement #135 says "
+                "it gets most wrong."
+            )
+            return 1
+        if "high" not in body:
+            report(
+                f"{label}: {guidance.parent.name}'s SKILL.md does not name the "
+                "tier that skips the read, so the condition it states cannot be "
+                "evaluated."
+            )
+            return 1
+        # "Measurably smaller than before the split" is checkable only as a
+        # property of what is on disk now: the guidance carries real content,
+        # and that content is no longer duplicated in the body it left.
+        if len(text) < 500:
+            report(
+                f"{label}: {guidance.parent.name}'s guidance.md holds "
+                f"{len(text)} bytes, too few for the split to have moved "
+                "anything; a pointer to an almost-empty file costs a read and "
+                "saves nothing."
+            )
+            return 1
+        criterion = guidance_criterion_problem(guidance.parent.name, text)
+        if criterion:
+            report(f"{label}: {criterion}")
+            return 1
+        for heading in [
+            line for line in text.splitlines() if line.startswith("## ")
+        ]:
+            if heading in body:
+                report(
+                    f"{label}: {guidance.parent.name}'s body still carries "
+                    f"{heading!r}, so the section was copied rather than moved "
+                    "and the resident cost did not fall."
+                )
+                return 1
+
+    # M2 — the property is held by the suite, not promised by the design. A
+    # guidance file that stated a criterion would let the tier skip one, which
+    # would make `executor_tier: high` a relaxation of the gates wearing a
+    # capability label. Planting one is the only way to know the rule fires.
+    sample = guidance_files[0]
+    planted = (
+        sample.read_text(encoding="utf-8")
+        + "\nAn executor MUST record the fingerprint before implementing.\n"
+    )
+    problem = guidance_criterion_problem(sample.parent.name, planted)
+    if not problem:
+        report(
+            f"{label}: states a criterion — a guidance file carrying `MUST` was "
+            "accepted, so nothing stops a criterion from moving into the file "
+            "the tier skips."
+        )
+        return 1
+    if sample.parent.name not in problem:
+        report(
+            f"{label}: the refusal does not name the file that states the "
+            f"criterion; got {problem!r}."
+        )
+        return 1
+    if "MUST" not in problem:
+        report(
+            f"{label}: the refusal does not name the word it objected to, so the "
+            f"author has to guess which sentence to move; got {problem!r}."
+        )
+        return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def equivalence_task(
+    *,
+    base: str | None = "HEAD~1",
+    fields: str | None = "wns, tns, cell_count",
+    covers: tuple[str, ...] = ("E1: the measured result does not move",),
+    label: str = "1.1",
+    title: str = "Move the attribute without moving the numbers",
+) -> str:
+    """One `equivalence` task, with either declaration omittable."""
+    lines = [
+        f"- [ ] {label} {title}",
+        "  - Covers:",
+    ]
+    lines.extend(f"    - {entry}" for entry in covers)
+    lines.extend(
+        [
+            "  - Read:",
+            "    - README.md",
+            "  - Touch:",
+            "    - src/example.js",
+            "  - Verify:",
+            "    - Strategy: equivalence",
+        ]
+    )
+    if base is not None:
+        lines.append(f"    - Base: {base}")
+    if fields is not None:
+        lines.append(f"    - Fields: {fields}")
+    lines.extend(
+        [
+            "    - M1: node compare.js --base --head reports every field equal",
+            "  - Autonomy boundary:",
+            "    - Default: hard-stop",
+            "    - Pre-authorized fallback: none",
+            "  - Stop Rules:",
+            "    - Stop on any field that differs.",
+            "  - Evidence:",
+            "    - Contract: pending",
+            "    - M1: pending",
+            "    - Review:",
+            "      - Status: pass",
+            "      - Acceptance check: every declared field agreed.",
+            "      - Scope check: writes stayed inside Touch.",
+            "      - Findings: none",
+            "    - Blocker: none",
+        ]
+    )
+    return "\n".join(lines) + "\n"
+
+
+def validate_an_equivalence_claim_names_its_base_scenario() -> int:
+    """Issue #142: the correct evidence for a refactor is zero difference.
+
+    Red-green has no shape for it. The reporting repository re-recorded one
+    task's contract twice to get past the shape — not because a criterion was
+    wrong, but because the criterion had nowhere to live. An A/B against a base
+    is *stronger* than red-green: it catches the change that also, incidentally,
+    moved a result. What it needs is a place to say what it compares against and
+    on which fields, plus a refusal for every way that shape can be complete and
+    still compare nothing.
+    """
+    label = "an-equivalence-claim-names-its-base"
+
+    def git(repo: Path, *args: str) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            ["git", "-C", str(repo), *args], capture_output=True, text=True
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-equivalence-") as raw:
+        root = Path(raw)
+
+        def fixture(name: str, task: str) -> Path:
+            repo = (root / name).resolve()
+            repo.mkdir()
+            git(repo, "init", "-q")
+            git(repo, "config", "user.email", "t@example.com")
+            git(repo, "config", "user.name", "keel-test")
+            write_gate_fixture(repo, tasks=task)
+            write_text(repo / "src/example.js", "// product\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "first")
+            write_text(repo / "src/example.js", "// product, moved\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "second")
+            return repo
+
+        def start(name: str, **kwargs) -> dict:
+            repo = fixture(name, equivalence_task(**kwargs))
+            result = run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--no-guard", "--json",
+            )
+            try:
+                return json.loads(result.stdout)
+            except json.JSONDecodeError:
+                return {
+                    "status": "unparsed",
+                    "problems": [{"message": result.stdout[:400]}],
+                }
+
+        # M1 — the strategy is accepted, and it owes no red.
+        payload = start("accepted")
+        if payload.get("status") != "pass":
+            report(
+                f"{label}: unsupported verification strategy — a complete "
+                "equivalence task was refused, so the one task class with the "
+                "strongest criterion still has nowhere to declare it. "
+                f"{problem_text(payload)}"
+            )
+            return 1
+        capsule = (payload.get("contract") or {}).get("capsule") or {}
+        verification = capsule.get("verification") or {}
+        if verification.get("strategy", "").lower() != "equivalence":
+            report(
+                f"{label}: the compiled capsule does not carry the strategy; got "
+                f"{verification.get('strategy')!r}."
+            )
+            return 1
+        if not verification.get("base") or not verification.get("fields"):
+            report(
+                f"{label}: the capsule drops the declarations — base "
+                f"{verification.get('base')!r}, fields "
+                f"{verification.get('fields')!r}. A declaration absent from the "
+                "capsule is absent from the fingerprint, so it could be edited "
+                "after the run without moving the contract."
+            )
+            return 1
+        warnings = " ".join(str(w) for w in (payload.get("warnings") or []))
+        if ".red" in warnings or ".green" in warnings:
+            report(
+                f"{label}: equivalence was given a red-green obligation; the "
+                f"criterion is agreement with a base, not a failing first run. "
+                f"{warnings}"
+            )
+            return 1
+
+        # M2 — every way the shape can be complete and still compare nothing,
+        # each named for the declaration it is about. A diagnostic that named
+        # the strategy would send the author to the line that is correct.
+        for name, kwargs, code, expected in (
+            ("no-base", {"base": None}, "missing-equivalence-base", "Base:"),
+            ("no-fields", {"fields": None}, "missing-equivalence-fields", "Fields:"),
+            ("empty-fields", {"fields": " , "}, "missing-equivalence-fields", "Fields:"),
+            (
+                "bad-base",
+                {"base": "no-such-ref"},
+                "unresolvable-equivalence-base",
+                "no-such-ref",
+            ),
+        ):
+            payload = start(name, **kwargs)
+            if payload.get("status") == "pass":
+                report(
+                    f"{label}: accepted an equivalence task that compares "
+                    f"nothing — the {name} fixture passed, so the declaration "
+                    "is optional in practice."
+                )
+                return 1
+            if code not in problem_codes(payload):
+                report(
+                    f"{label}: accepted an equivalence task that compares "
+                    f"nothing — the {name} fixture was refused for another "
+                    f"reason; expected {code}, got {problem_codes(payload)!r}."
+                )
+                return 1
+            message = problem_text(payload)
+            if expected not in message:
+                report(
+                    f"{label}: the {name} refusal does not name {expected!r}, so "
+                    f"the author is sent to find which line is wrong; got "
+                    f"{message!r}."
+                )
+                return 1
+        # Absent and empty are the same state to the comparison and different
+        # states to the author, so the two are asserted to read differently.
+        absent = problem_text(start("no-fields-message", fields=None))
+        empty = problem_text(start("empty-fields-message", fields=" , "))
+        if absent == empty:
+            report(
+                f"{label}: a missing `Fields:` and one that resolves to an empty "
+                "set produce the same sentence, so an author who wrote the line "
+                "is told they did not."
+            )
+            return 1
+
+        # M1 of 1.2 — `equivalence` owes no red, which makes it the first thing
+        # reached for by a task that should have one. A task covering a scenario
+        # the change *adds* is claiming new behavior and unchanged behavior at
+        # once, and one of the two claims has no proof anywhere.
+        added_spec = (
+            "## ADDED Requirements\n\n"
+            "### Requirement: The moved attribute keeps its effect\n\n"
+            "The attribute SHALL keep its effect after the move.\n\n"
+            "#### Scenario: The effect survives the move\n\n"
+            "- **WHEN** the attribute moves into the flow\n"
+            "- **THEN** the effect is unchanged\n\n"
+            # A second real scenario, so the mismatched-sibling control fails
+            # because the guard refused it and not because its Covers entry
+            # resolves to nothing. A first attempt pointed the sibling at an
+            # invented scenario and passed for that unrelated reason.
+            "#### Scenario: The flow reports the attribute\n\n"
+            "- **WHEN** the flow runs\n"
+            "- **THEN** it reports the attribute\n"
+        )
+        covered = (
+            "demo / The moved attribute keeps its effect / The effect survives "
+            "the move"
+        )
+
+        def escape_fixture(name: str, *, sibling: str | None) -> dict:
+            repo = (root / name).resolve()
+            repo.mkdir()
+            git(repo, "init", "-q")
+            git(repo, "config", "user.email", "t@example.com")
+            git(repo, "config", "user.name", "keel-test")
+            tasks = equivalence_task(covers=(covered,))
+            if sibling is not None:
+                tasks += (
+                    "- [ ] 1.2 Add the behavior\n"
+                    "  - Covers:\n"
+                    f"    - {sibling}\n"
+                    "  - Read:\n    - README.md\n"
+                    "  - Touch:\n    - src/other.js\n"
+                    "  - Verify:\n"
+                    "    - Strategy: vertical-tdd\n"
+                    "    - M1: node test.js asserts the new behavior\n"
+                    "  - Autonomy boundary:\n"
+                    "    - Default: hard-stop\n"
+                    "    - Pre-authorized fallback: none\n"
+                    "  - Stop Rules:\n    - Stop on failure.\n"
+                    "  - Evidence:\n    - Contract: pending\n    - M1: pending\n"
+                    "    - Review:\n      - Status: pass\n"
+                    "      - Acceptance check: behavior asserted.\n"
+                    "      - Scope check: inside Touch.\n"
+                    "      - Findings: none\n"
+                    "    - Blocker: none\n"
+                )
+            write_gate_fixture(repo, tasks=tasks)
+            write_text(repo / "openspec/changes/demo/specs/demo/spec.md", added_spec)
+            write_text(repo / "src/example.js", "// product\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "first")
+            write_text(repo / "src/example.js", "// moved\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "second")
+            result = run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--no-guard", "--json",
+            )
+            try:
+                return json.loads(result.stdout)
+            except json.JSONDecodeError:
+                return {
+                    "status": "unparsed",
+                    "problems": [{"message": result.stdout[:400]}],
+                }
+
+        payload = escape_fixture("escape-alone", sibling=None)
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: accepted new behavior with no red anywhere — an "
+                "equivalence task covering a scenario the change adds passed, so "
+                "the strategy is a way to author a feature with no red in the "
+                "whole change."
+            )
+            return 1
+        if "equivalence-covers-added-behavior" not in problem_codes(payload):
+            report(
+                f"{label}: accepted new behavior with no red anywhere — refused "
+                f"for another reason; got {problem_codes(payload)!r}."
+            )
+            return 1
+        message = problem_text(payload)
+        if "The effect survives the move" not in message:
+            report(
+                f"{label}: the refusal does not name the covered scenario, so "
+                f"the author cannot tell which Covers entry is the problem; got "
+                f"{message!r}."
+            )
+            return 1
+        if "unchanged" not in message:
+            report(
+                f"{label}: the refusal does not say why the two claims conflict; "
+                f"got {message!r}."
+            )
+            return 1
+
+        # M2 of 1.2 — the guard is satisfied by coverage of the entry it
+        # objected to, and not by a red-green task merely existing in the change.
+        payload = escape_fixture("escape-sibling", sibling=covered)
+        if payload.get("status") != "pass":
+            report(
+                f"{label}: a sibling task covering the same scenario under "
+                f"vertical-tdd did not satisfy the guard. {problem_text(payload)}"
+            )
+            return 1
+        payload = escape_fixture(
+            "escape-other-sibling",
+            sibling=(
+                "demo / The moved attribute keeps its effect / The flow reports "
+                "the attribute"
+            ),
+        )
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: any sibling satisfied the guard — a red-green task "
+                "covering a different scenario was accepted as proof of this "
+                "one, which makes the guard a check that a change contains at "
+                "least one red-green task."
+            )
+            return 1
+        if "equivalence-covers-added-behavior" not in problem_codes(payload):
+            report(
+                f"{label}: any sibling satisfied the guard — refused for another "
+                f"reason; got {problem_codes(payload)!r}."
+            )
+            return 1
+
+        # M3 of 1.2 — the guard fires on new behavior, not on the strategy. A
+        # task covering only identifiers, or a requirement the change does not
+        # add, is an ordinary equivalence task.
+        plain = start("escape-plain")
+        if plain.get("status") != "pass":
+            report(
+                f"{label}: an equivalence task covering no added scenario was "
+                f"refused. {problem_text(plain)}"
+            )
+            return 1
+
+        # M3 — the shape that is complete, resolvable, and still empty. This is
+        # the refusal worth having: nothing about the task looks wrong, and the
+        # check passes having compared a thing against itself.
+        payload = start("base-is-head", base="HEAD")
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: accepted a base that is head — an A/B against itself "
+                "always agrees, so the check proves nothing and looks complete "
+                "doing it."
+            )
+            return 1
+        if "equivalence-base-is-head" not in problem_codes(payload):
+            report(
+                f"{label}: accepted a base that is head — refused for another "
+                f"reason; got {problem_codes(payload)!r}."
+            )
+            return 1
+        message = problem_text(payload)
+        head = subprocess.run(
+            ["git", "-C", str((root / "base-is-head").resolve()), "rev-parse",
+             "HEAD"],
+            capture_output=True, text=True,
+        ).stdout.strip()
+        if head and head not in message:
+            report(
+                f"{label}: the refusal does not name the resolved commit, so the "
+                "author cannot tell which ref collapsed onto HEAD; got "
+                f"{message!r}."
+            )
+            return 1
+        if "always agrees" not in message:
+            report(
+                f"{label}: the refusal does not say why a base that is HEAD is "
+                f"empty rather than merely redundant; got {message!r}."
+            )
+            return 1
+
+        # 1.3 — Evidence may point at the machine output instead of retelling
+        # it. A 244-line tasks.md that is mostly transcribed test output is a
+        # transcription that can be wrong and that nobody can re-check.
+        def artifact_fixture(
+            name: str,
+            *,
+            artifact_path: str = "openspec/changes/demo/evidence/compare.json",
+            body: str = '{"wns": 0.0, "tns": 0.0}\n',
+            recorded: str | None = None,
+            write_at: str | None = None,
+        ) -> dict:
+            repo = (root / name).resolve()
+            repo.mkdir()
+            git(repo, "init", "-q")
+            git(repo, "config", "user.email", "t@example.com")
+            git(repo, "config", "user.name", "keel-test")
+            digest = hashlib.sha256(body.encode("utf-8")).hexdigest()
+            evidence = recorded or f"artifact {artifact_path} sha256:{digest}"
+            tasks = equivalence_task().replace(
+                "    - M1: pending", f"    - M1: {evidence}"
+            )
+            write_gate_fixture(repo, tasks=tasks)
+            if write_at is not None:
+                write_text(repo / write_at, body)
+            write_text(repo / "src/example.js", "// product\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "first")
+            write_text(repo / "src/example.js", "// moved\n")
+            git(repo, "add", "-A")
+            git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "second")
+            run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--record", "--no-guard",
+            )
+            result = run_keel(
+                repo, "gate", "task-complete", "--change", "demo", "--task",
+                "1.1", "--json",
+            )
+            try:
+                return json.loads(result.stdout)
+            except json.JSONDecodeError:
+                return {
+                    "status": "unparsed",
+                    "problems": [{"message": result.stdout[:400]}],
+                }
+
+        inside = "openspec/changes/demo/evidence/compare.json"
+        payload = artifact_fixture("artifact-ok", write_at=inside)
+        if payload.get("status") != "pass":
+            report(
+                f"{label}: an artifact reference was not verified — a reference "
+                "to a file that is there, with a digest that matches, was "
+                f"refused. {problem_text(payload)}"
+            )
+            return 1
+        payload = artifact_fixture("artifact-absent", write_at=None)
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: an artifact reference was not verified — a reference "
+                "to a file that does not exist was accepted, so the form is "
+                "tolerated as prose rather than checked. Any sentence would "
+                "have passed the same way."
+            )
+            return 1
+        if "artifact-missing" not in problem_codes(payload):
+            report(
+                f"{label}: an artifact reference was not verified — refused for "
+                f"another reason; got {problem_codes(payload)!r}."
+            )
+            return 1
+
+        # M2 of 1.3 — the digest is what makes the pointer worth more than a
+        # path. A file that moved after the digest was recorded is the case a
+        # bare path cannot see, and it is the common one: the command gets
+        # re-run.
+        stale = hashlib.sha256(b"different\n").hexdigest()
+        payload = artifact_fixture(
+            "artifact-stale",
+            recorded=f"artifact {inside} sha256:{stale}",
+            write_at=inside,
+        )
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: accepted a stale digest — the artifact's content does "
+                "not hash to the recorded digest and the reference was accepted, "
+                "so Review reads whatever the file says now."
+            )
+            return 1
+        if "artifact-digest-mismatch" not in problem_codes(payload):
+            report(
+                f"{label}: accepted a stale digest — refused for another reason; "
+                f"got {problem_codes(payload)!r}."
+            )
+            return 1
+        message = problem_text(payload)
+        for expected in (inside, stale[:12]):
+            if expected not in message:
+                report(
+                    f"{label}: the refusal does not name {expected!r}, so a "
+                    "reader cannot tell a stale record from a wrong path; got "
+                    f"{message!r}."
+                )
+                return 1
+
+        # M3 of 1.3 — the inverse of the `Durable owner:` rule, for the opposite
+        # reason: a follow-up pointer must outlive the change, and an evidence
+        # artifact must travel with it. `openspec archive` moves the change
+        # directory, so a path outside it is one the archive leaves behind.
+        outside = "evidence/compare.json"
+        payload = artifact_fixture("artifact-outside", artifact_path=outside, write_at=outside)
+        if payload.get("status") == "pass":
+            report(
+                f"{label}: accepted a path archiving would leave behind — an "
+                f"artifact at {outside!r} was accepted although the archive "
+                "moves only the change directory."
+            )
+            return 1
+        if "artifact-outside-change" not in problem_codes(payload):
+            report(
+                f"{label}: accepted a path archiving would leave behind — "
+                f"refused for another reason; got {problem_codes(payload)!r}."
+            )
+            return 1
+        if "archiv" not in problem_text(payload):
+            report(
+                f"{label}: the refusal does not say that archiving is what "
+                f"breaks the pointer; got {problem_text(payload)!r}."
+            )
+            return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
@@ -29103,6 +29907,18 @@ SCENARIOS: tuple = (
         "a-negation-is-not-a-marker",
         validate_a_negation_is_not_a_marker_scenario,
     ),
+    (
+        "an-equivalence-claim-names-its-base",
+        validate_an_equivalence_claim_names_its_base_scenario,
+    ),
+    (
+        "guidance-is-referenced-and-carries-no-criterion",
+        validate_guidance_is_referenced_and_carries_no_criterion_scenario,
+    ),
+    (
+        "a-tier-declares-what-is-skipped",
+        validate_a_tier_declares_what_is_skipped_scenario,
+    ),
     (
         "a-count-is-derived-from-what-it-counts",
         validate_a_count_is_derived_from_what_it_counts_scenario,