@christang/keel 5.20.0 → 5.39.0

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.20.0"
-PROTOCOL_VERSION = "5.20.0"
+PACKAGE_VERSION = "5.39.0"
+PROTOCOL_VERSION = "5.39.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
@@ -1611,6 +1611,118 @@ def validate_expectation_slice_gates_scenario() -> int:
     return 0
 
 
+def validate_unparsed_covers_critical_statement_scenario() -> int:
+    """Issue #49 item 1: a critical-statement Covers reference must be told apart
+    as missing (the identifier never appears in design.md) from unparsed (the
+    identifier appears but not in the exact resolvable shape), instead of both
+    collapsing into the same "Missing" message.
+    """
+    task = task_capsule_compact_fixture().replace(
+        "    - E1: Public behavior passes.\n",
+        "    - D2\n",
+    )
+
+    def covers_message(repo: Path) -> tuple[int, str]:
+        write_text(repo / "openspec/changes/demo/tasks.md", task)
+        result = run_keel(
+            repo, "gate", "task-start", "--change", "demo", "--task", "1.1", "--json"
+        )
+        problems = json.loads(result.stdout).get("problems", [])
+        message = next(
+            (
+                item.get("message", "")
+                for item in problems
+                if item.get("code") == "unresolved-covers"
+            ),
+            "",
+        )
+        return result.returncode, message
+
+    with tempfile.TemporaryDirectory(prefix="keel-unparsed-covers-missing-") as raw:
+        repo = Path(raw)
+        write_text(
+            repo / "openspec/changes/demo/design.md",
+            "## Decisions\n\nD1 — Unrelated decision. Basis: fixture authority.\n",
+        )
+        returncode, message = covers_message(repo)
+        if returncode == 0 or not message.startswith(
+            "Missing Covers critical statement: D2."
+        ):
+            report(
+                "unparsed-covers-critical-statement: an identifier absent from "
+                f"design.md must still report Missing, got: {message!r}"
+            )
+            return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-unparsed-covers-unparsed-") as raw:
+        repo = Path(raw)
+        write_text(
+            repo / "openspec/changes/demo/design.md",
+            "## Decisions\n\n"
+            "- **D2** — Keep one shared parser. Basis: fixture authority.\n",
+        )
+        returncode, message = covers_message(repo)
+        if returncode == 0:
+            report(
+                "unparsed-covers-critical-statement: a present-but-mis-shaped D2 "
+                "must still fail task-start."
+            )
+            return 1
+        if not message.startswith("Unparsed Covers critical statement: D2."):
+            report(
+                "unparsed-covers-critical-statement: a present-but-mis-shaped D2 "
+                f"must report Unparsed, got: {message!r}"
+            )
+            return 1
+        if "D2 — one-line statement" not in message:
+            report(
+                "unparsed-covers-critical-statement: the Unparsed message must "
+                f"name the required shape, got: {message!r}"
+            )
+            return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-unparsed-covers-resolved-") as raw:
+        repo = Path(raw)
+        write_text(
+            repo / "openspec/changes/demo/design.md",
+            "## Decisions\n\nD2 — Keep one shared parser. Basis: fixture authority.\n",
+        )
+        write_text(repo / "openspec/changes/demo/tasks.md", task)
+        result = run_keel(
+            repo, "gate", "task-start", "--change", "demo", "--task", "1.1", "--json"
+        )
+        if result.returncode != 0:
+            report(
+                "unparsed-covers-critical-statement: a correctly-shaped D2 must "
+                f"still resolve. {(result.stderr or result.stdout).strip()}"
+            )
+            return 1
+        authority = (
+            json.loads(result.stdout)
+            .get("contract", {})
+            .get("capsule", {})
+            .get("authority", [])
+        )
+        if not any(
+            item.get("reference") == "D2" and item.get("kind") == "critical-statement"
+            for item in authority
+        ):
+            report(
+                "unparsed-covers-critical-statement: correctly-shaped D2 did not "
+                "resolve as critical-statement authority."
+            )
+            return 1
+
+    if "unparsed-covers-critical-statement" not in {name for name, _ in SCENARIOS}:
+        report(
+            "unparsed-covers-critical-statement: the scenario registry does not "
+            "include it."
+        )
+        return 1
+    report("unparsed-covers-critical-statement scenario passed.")
+    return 0
+
+
 def validate_expectation_completion_gates_scenario() -> int:
     protocol_snippets = [
         "Completion Gate",
@@ -2147,6 +2259,256 @@ def assert_target_overlays(
     return None
 
 
+OVERLAY_ACTION_SKILLS = {
+    "propose": "openspec-propose",
+    "apply": "openspec-apply-change",
+    "archive": "openspec-archive-change",
+    "sync": "openspec-sync-specs",
+}
+
+
+def expected_overlay_surfaces(
+    repo: Path,
+    target: str,
+    codex_home: Path | None = None,
+) -> list[Path]:
+    """Every surface `openspecOverlaySurfacesForTarget` projects the overlay onto.
+
+    Written out rather than discovered, so that a scan of the tree can be
+    compared against it. A scan alone answers "the files that carry the
+    marker", which is the same answer whether the CLI covered eight surfaces
+    or none — and "none of them still carry it" is exactly what a broken
+    surface list also reports.
+    """
+    surfaces: list[Path] = []
+    for action, skill in OVERLAY_ACTION_SKILLS.items():
+        if action == "propose" and target == "opencode":
+            continue
+        if target == "claude":
+            surfaces.append(repo / f".claude/skills/{skill}/SKILL.md")
+            surfaces.append(repo / f".claude/commands/opsx/{action}.md")
+        elif target == "codex":
+            assert codex_home is not None
+            surfaces.append(repo / f".codex/skills/{skill}/SKILL.md")
+            surfaces.append(codex_home / f"prompts/opsx-{action}.md")
+        else:
+            surfaces.append(repo / f".opencode/skills/{skill}/SKILL.md")
+            surfaces.append(repo / f".opencode/commands/opsx-{action}.md")
+    return surfaces
+
+
+def files_carrying_overlay(*roots: Path) -> set[Path]:
+    found: set[Path] = set()
+    for root in roots:
+        if not root.is_dir():
+            continue
+        for path in root.rglob("*.md"):
+            if not path.is_file():
+                continue
+            text = path.read_text(encoding="utf-8", errors="replace")
+            if "keel:openspec-surface-overlay" in text:
+                found.add(path)
+    return found
+
+
+def validate_uninstall_removes_the_overlay_scenario() -> int:
+    """Uninstalling left Keel's instructions in files OpenSpec owns.
+
+    The overlay block is written into the `opsx` command surfaces and the
+    `openspec-*` skills, and every line of it is about Keel: the gate to run,
+    the checklist to run, how to invoke OpenSpec, where standing authorization
+    is declared. `keel --uninstall` removed the `keel:start` managed block from
+    AGENTS.md and CLAUDE.md and left all of that behind.
+
+    Measured 2026-08-03 at 5.22.0: Claude 8 of 8 surfaces, Codex 8 of 8 (four
+    of them under `CODEX_HOME/prompts/`), OpenCode 6 of 6 still carried the
+    marker after uninstall. Filed as
+    https://github.com/TanglmChris/keel/issues/50.
+    """
+    label = "uninstall-removes-the-overlay"
+    with tempfile.TemporaryDirectory(prefix="keel-uninstall-overlay-") as raw:
+        tmp = Path(raw)
+
+        for target in ("claude", "codex", "opencode"):
+            repo = tmp / target
+            repo.mkdir()
+            env = None
+            codex_home = None
+            roots = [repo]
+            if target == "codex":
+                codex_home = tmp / "codex-home"
+                env = os.environ.copy()
+                env["CODEX_HOME"] = str(codex_home)
+                roots.append(codex_home)
+
+            init = run_keel(repo, "--init", "--target", target, env=env)
+            if init.returncode != 0:
+                report(f"{label} `keel --init --target {target}` failed.")
+                report((init.stderr or init.stdout).strip())
+                return 1
+
+            # M1 positive control — the surfaces the CLI writes to are the ones
+            # this scenario is about to check, asserted before the act. Without
+            # it, a run whose surface list resolved to nothing reports the same
+            # clean tree as a run that removed everything.
+            expected = set(expected_overlay_surfaces(repo, target, codex_home))
+            carrying = files_carrying_overlay(*roots)
+            if carrying != expected:
+                report(
+                    f"{label} M1 the {target} surfaces carrying the overlay "
+                    "after init are not the ones this scenario expects, so "
+                    "nothing after this measures removal."
+                )
+                report(f"  only installed: {sorted(str(p) for p in carrying - expected)}")
+                report(f"  only expected:  {sorted(str(p) for p in expected - carrying)}")
+                return 1
+
+            # M2 — what the file held before Keel's block, kept so the whole
+            # file can be compared against it afterwards. Trailing newlines are
+            # normalized to one because the separator the install side inserted
+            # before the block goes with the block.
+            bodies = {}
+            for surface in expected:
+                text = surface.read_text(encoding="utf-8")
+                head = text[: text.index("<!-- keel:openspec-surface-overlay")]
+                bodies[surface] = head.rstrip("\n") + "\n"
+
+            uninstall = run_keel(repo, "--uninstall", "--target", target, env=env)
+            if uninstall.returncode != 0:
+                report(f"{label} M1 `keel --uninstall --target {target}` failed.")
+                report((uninstall.stderr or uninstall.stdout).strip())
+                return 1
+
+            # M1 — nothing Keel wrote is left in a file OpenSpec owns.
+            left = files_carrying_overlay(*roots)
+            if left:
+                report(
+                    f"{label} M1 uninstalling {target} left the Keel overlay "
+                    f"in {len(left)} of {len(expected)} surfaces, so the "
+                    "uninstalled repository still instructs an agent to run "
+                    "commands that were just removed."
+                )
+                for path in sorted(str(p) for p in left):
+                    report(f"  {path}")
+                return 1
+
+            # M4 — the run says how many surfaces it cleaned. An uninstall that
+            # silently does nothing and an uninstall that cleaned everything
+            # produce the same tree on a repository that was never installed.
+            if f"removed={len(expected)}" not in uninstall.stdout:
+                report(
+                    f"{label} M4 uninstalling {target} did not report the "
+                    f"{len(expected)} overlays it removed."
+                )
+                report((uninstall.stderr or uninstall.stdout).strip())
+                return 1
+
+            # M2 — the block, and only the block. The file is OpenSpec's, so a
+            # removal that took the marker and anything either side of it is a
+            # worse defect than the one being fixed, and "the marker is gone"
+            # cannot tell the two apart.
+            for surface, body in bodies.items():
+                if not surface.is_file():
+                    report(
+                        f"{label} M2 uninstalling {target} deleted {surface}, "
+                        "which is OpenSpec's file. Removing Keel's block is "
+                        "the whole obligation."
+                    )
+                    return 1
+                after = surface.read_text(encoding="utf-8")
+                if after != body:
+                    report(
+                        f"{label} M2 uninstalling {target} did not leave "
+                        f"{surface} at the bytes that preceded the overlay."
+                    )
+                    report(f"  expected {len(body)} bytes ending {body[-40:]!r}")
+                    report(f"  found    {len(after)} bytes ending {after[-40:]!r}")
+                    return 1
+
+        # M3 — a dry run plans the writes it would make. `--check` already had
+        # to learn that a Node-side step the installer's plan cannot see makes
+        # a dry run under-report a run that writes; the uninstall side has the
+        # same shape.
+        dry = tmp / "dry-run"
+        dry.mkdir()
+        dry_init = run_keel(dry, "--init", "--target", "claude")
+        if dry_init.returncode != 0:
+            report(f"{label} M3 dry-run fixture init failed.")
+            report((dry_init.stderr or dry_init.stdout).strip())
+            return 1
+        dry_expected = set(expected_overlay_surfaces(dry, "claude"))
+        dry_run = run_keel(dry, "--uninstall", "--target", "claude", "--dry-run")
+        if dry_run.returncode != 0:
+            report(f"{label} M3 `keel --uninstall --dry-run` failed.")
+            report((dry_run.stderr or dry_run.stdout).strip())
+            return 1
+        unplanned = [
+            str(surface)
+            for surface in sorted(dry_expected)
+            if str(surface) not in dry_run.stdout
+        ]
+        if unplanned:
+            report(
+                f"{label} M3 the dry run did not name {len(unplanned)} of "
+                f"{len(dry_expected)} surfaces it would clean, so the plan "
+                "under-reports a run that writes."
+            )
+            for surface in unplanned:
+                report(f"  {surface}")
+            return 1
+        if files_carrying_overlay(dry) != dry_expected:
+            report(
+                f"{label} M3 the dry run removed overlays. A dry run reports "
+                "what it would do and writes nothing."
+            )
+            return 1
+
+        # M4 — uninstalling again, and uninstalling a repository that never
+        # received the overlay, both succeed. Uninstall is something a user
+        # reaches for when something is already wrong; failing on the second
+        # attempt is the worst moment to fail.
+        again = run_keel(tmp / "claude", "--uninstall", "--target", "claude")
+        if again.returncode != 0:
+            report(
+                f"{label} M4 a second uninstall failed. Uninstall is reached "
+                "when something is already wrong; failing on the second "
+                "attempt is the worst moment to fail."
+            )
+            report((again.stderr or again.stdout).strip())
+            return 1
+        if "removed=0" not in again.stdout:
+            report(
+                f"{label} M4 a second uninstall did not report that it removed "
+                "nothing, so a run that cleaned nothing reads like a run that "
+                "cleaned everything."
+            )
+            report((again.stderr or again.stdout).strip())
+            return 1
+
+        bare = tmp / "install-only"
+        bare.mkdir()
+        bare_install = run_keel(bare, "--install", "--target", "claude")
+        if bare_install.returncode != 0:
+            report(f"{label} M4 install-only fixture failed.")
+            report((bare_install.stderr or bare_install.stdout).strip())
+            return 1
+        bare_uninstall = run_keel(bare, "--uninstall", "--target", "claude")
+        if bare_uninstall.returncode != 0:
+            report(
+                f"{label} M4 uninstalling a repository whose OpenSpec surfaces "
+                "were never created failed. An absent surface is nothing to "
+                "remove, not an error."
+            )
+            report((bare_uninstall.stderr or bare_uninstall.stdout).strip())
+            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 validate_sync_surface_overlay_scenario() -> int:
     """The surface that performs a gated action never named its gate.
 
@@ -2253,11 +2615,11 @@ def validate_sync_surface_overlay_scenario() -> int:
                 )
                 return 1
 
-            # Uninstall is deliberately not asserted here. It does not strip
-            # the overlay from any surface — measured on archive as well as
-            # sync — so an assertion would be about a contract that has never
-            # existed rather than about this change. Filed as
-            # https://github.com/TanglmChris/keel/issues/50.
+            # Uninstall is asserted by `uninstall-removes-the-overlay`, which
+            # covers every surface on every target rather than sync alone. It
+            # stripped nothing from any surface when this scenario was written;
+            # that was #50, and the assertion lives there because the contract
+            # is about all four actions, not about this one.
 
     # M4 — covering the surface did not widen what may be standing-authorized.
     config_doc = (ROOT / "keel/config.yaml").read_text(encoding="utf-8")
@@ -2276,6 +2638,19 @@ def validate_sync_surface_overlay_scenario() -> int:
     return 0
 
 
+def overlay_action_label(text: str, pattern: str) -> str | None:
+    """The action list a summary line names, or None when the line is absent.
+
+    `\\S*` rather than `\\S+` on purpose: a label that derived to nothing leaves
+    two spaces where the actions belong, and matching it is what lets an empty
+    label be reported as empty instead of as a missing line.
+    """
+    match = re.search(pattern, text)
+    if match is None:
+        return None
+    return match.group(1)
+
+
 def validate_openspec_surface_overlay_scenario() -> int:
     with tempfile.TemporaryDirectory(prefix="keel-overlay-") as raw_tmp:
         tmp = Path(raw_tmp)
@@ -2300,6 +2675,61 @@ def validate_openspec_surface_overlay_scenario() -> int:
             report((claude_doctor.stderr or claude_doctor.stdout).strip())
             return 1
 
+        # Every direction that reports the overlay names the actions it covers,
+        # and all of them describe one surface list. They are compared against
+        # each other rather than against a literal repeated here: the doctor
+        # label is already pinned above, so an action joining the managed set
+        # moves all three lines together or fails on this comparison. A third
+        # copy of the string is what produced the defect this guards.
+        #
+        # The refresh line was the copy nobody was watching. Measured 2026-08-03
+        # on one repository, back to back: `--init` reported `apply/archive`
+        # while `--uninstall` reported `apply/archive/sync` (issue #75).
+        #
+        # Absence is checked before agreement, and separately, because two
+        # labels that were never found also agree.
+        claude_uninstall = run_keel(claude_repo, "--uninstall", "--target", "claude")
+        if claude_uninstall.returncode != 0:
+            report("openspec-surface-overlay scenario Claude uninstall failed:")
+            report((claude_uninstall.stderr or claude_uninstall.stdout).strip())
+            return 1
+        summaries = {
+            "refresh": overlay_action_label(
+                claude_init.stdout, r"OpenSpec (\S*) overlay refreshed="
+            ),
+            "doctor": overlay_action_label(
+                claude_doctor.stdout, r"Keel (\S*) overlay:"
+            ),
+            "removal": overlay_action_label(
+                claude_uninstall.stdout, r"OpenSpec (\S*) overlay removed="
+            ),
+        }
+        for direction, printed in summaries.items():
+            if printed is None:
+                report(
+                    f"openspec-surface-overlay scenario found no {direction} "
+                    "overlay summary at all, so there was no label to compare "
+                    "rather than a label that disagreed."
+                )
+                return 1
+            if not printed:
+                report(
+                    f"openspec-surface-overlay scenario read an empty action "
+                    f"label from the {direction} summary; a label that derives "
+                    "to nothing reports no actions at all."
+                )
+                return 1
+        for direction in ("refresh", "removal"):
+            if summaries[direction] != summaries["doctor"]:
+                report(
+                    "openspec-surface-overlay scenario overlay summaries "
+                    f"disagree: {direction} names {summaries[direction]!r} and "
+                    f"doctor names {summaries['doctor']!r}. They describe the "
+                    "same managed surface list, so one of them is written "
+                    "beside the action set instead of derived from it."
+                )
+                return 1
+
         codex_repo = tmp / "codex"
         codex_repo.mkdir()
         codex_home = tmp / "codex-home"
@@ -2762,6 +3192,21 @@ def validate_cli_scenario() -> int:
         report((help_result.stderr or help_result.stdout).strip())
         return 1
 
+    usage_block = help_result.stdout.split("Usage:", 1)[1].split("\n\n", 1)[0]
+    triage_lines = [line for line in usage_block.splitlines() if "keel triage" in line]
+    if not triage_lines:
+        report("cli scenario expected keel --help Usage: block to list a `keel triage` line.")
+        report(usage_block.strip())
+        return 1
+    if "--labels" not in triage_lines[0]:
+        report("cli scenario expected the keel --help `keel triage` line to name --labels.")
+        report(triage_lines[0].strip())
+        return 1
+    if "--issue" not in triage_lines[0]:
+        report("cli scenario expected the keel --help `keel triage` line to name --issue.")
+        report(triage_lines[0].strip())
+        return 1
+
     version_result = run_keel(ROOT, "--version")
     expected_version = f"keel {PACKAGE_VERSION}"
     if version_result.returncode != 0 or version_result.stdout.strip() != expected_version:
@@ -3837,55 +4282,368 @@ def validate_task_start_invalidation_scenario() -> int:
     return 0
 
 
-SCHEMA_COPY_PAIRS = (
-    (
-        "openspec/schemas/keel-spec-driven/templates/tasks.md",
-        "assets/openspec/schemas/keel-spec-driven/templates/tasks.md",
-    ),
-    (
-        "openspec/schemas/keel-spec-driven/schema.yaml",
-        "assets/openspec/schemas/keel-spec-driven/schema.yaml",
-    ),
-)
+# A task for the section-boundary fixtures. Two shapes matter and nothing else
+# does: `covers` puts `- E<n>:` lines inside a task body, which a section that
+# ran over the task list read as its own entries, and `repo_action` gives the
+# task a `Touch` of a bare `- none`, which such a section read as its `- None.`
+# and closed itself with. Every other field is the cheapest legitimate value.
+def section_boundary_task(
+    task_id: str,
+    *,
+    checked: bool,
+    covers: tuple[str, ...] = ("E1: the task owns its file",),
+    repo_action: bool = False,
+) -> str:
+    covers_lines = "".join(f"    - {item}\n" for item in covers)
+    touch = "    - none\n" if repo_action else "    - src/example.js\n"
+    mode = "repo-action" if repo_action else "implementation"
+    return (
+        f"- [{'x' if checked else ' '}] {task_id} Section boundary fixture\n"
+        "  - Owner: claude\n"
+        f"  - Mode: {mode}\n"
+        "  - Covers:\n"
+        f"{covers_lines}"
+        "  - Read:\n"
+        "    - README.md\n"
+        "  - Touch:\n"
+        f"{touch}"
+        "  - Verify:\n"
+        "    - Strategy: evidence-first\n"
+        "    - M1: node test.js reports the public behavior passing\n"
+        "  - Acceptance:\n"
+        "    - Public behavior passes.\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: node test.js reported 4 passing and 0 failing\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: the public behavior was exercised\n"
+        "      - Scope check: only the declared file changed\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+        "  - Stop if:\n"
+        "    - Requires files outside Touch.\n"
+    )
 
 
-def validate_dry_run_overlay_accounting_scenario() -> int:
-    label = "dry-run-overlay-accounting"
+# The same file with the section above the task list and in the tail. Nothing
+# else differs between the two, which is what makes the pair a measurement of
+# position rather than of content.
+def section_boundary_tasks_md(*, section: str, task: str, position: str) -> str:
+    if position == "above":
+        return "# Tasks\n\n" + section + "\n" + task
+    return "# Tasks\n\n" + task + "\n" + section
 
-    # A dry run is relied on, so it is wrong in both directions: naming a write
-    # that will not happen trains the reader to ignore it, and omitting one
-    # breaks the promise the dry run exists to make. `--check` used to omit the
-    # overlay step entirely while `--install --dry-run` claimed every surface.
-    def overlay_lines(text: str) -> list[str]:
-        return [line for line in text.splitlines() if "overlay" in line]
 
-    def counts(text: str) -> str | None:
-        found = re.search(r"refreshed=(\d+) current=(\d+) missing=(\d+)", text)
-        return found.group(0) if found else None
+def section_boundary_repo(root: Path, name: str, content: str) -> Path:
+    repo = root / name
+    change = repo / "openspec/changes/demo"
+    write_text(change / "tasks.md", content)
+    write_text(change / "proposal.md", "# Proposal\n")
+    write_text(change / "design.md", "## Context\n\nfixture\n")
+    write_text(change / "specs/demo/spec.md", "## ADDED Requirements\n")
+    return repo
 
-    with tempfile.TemporaryDirectory(prefix="keel-dry-run-overlay-") as raw_tmp:
-        repo = Path(raw_tmp) / "repo"
-        repo.mkdir()
-        # The overlay surfaces are files OpenSpec generates; install merges into
-        # them and skips the ones that are absent. Create them so this scenario
-        # exercises the classification rather than the missing branch.
-        for relative in (
-            ".claude/skills/openspec-propose/SKILL.md",
-            ".claude/skills/openspec-apply-change/SKILL.md",
-            ".claude/skills/openspec-archive-change/SKILL.md",
-            ".claude/commands/opsx/propose.md",
-            ".claude/commands/opsx/apply.md",
-            ".claude/commands/opsx/archive.md",
-        ):
-            write_text(repo / relative, "# OpenSpec surface\n\nGenerated body.\n")
-        if run_keel(repo, "--install", "--target", "claude").returncode != 0:
-            report(f"{label} could not install a fixture repository.")
-            return 1
 
-        # Nothing stale: neither dry run may name a file.
-        check = run_keel(repo, "--check", "--target", "claude")
-        if any("would refresh OpenSpec" in line and ".md" in line
-               for line in overlay_lines(check.stdout)):
+def validate_section_boundary_scenario() -> int:
+    """A change-level section is bounded by the tasks, not only by headings.
+
+    Regression for issue #71 and for the silent half the issue does not report.
+    Both readers of a change-level section sliced to the next `## ` heading, so
+    a section that was not the file's last one ran over the task list: the
+    `- E<n>:` lines a task declares under `Covers` were judged as coverage
+    entries and reported unclosed, and a `repo-action` task's `Touch` of a bare
+    `- none` was read as the section's `- None.` and closed a declaration that
+    closed nothing.
+
+    Every cell is a pair — the identical section above the task list and in the
+    tail — asserted both absolutely and against each other. The absolute half
+    matters: a comparison alone passes when both positions are broken the same
+    way.
+    """
+    label = "section-boundary"
+
+    def problems_of(payload: dict) -> list[tuple[str, str]]:
+        return sorted(
+            (item.get("code", ""), item.get("message", ""))
+            for item in payload.get("problems", [])
+        )
+
+    def closure_problems(payload: dict, code: str) -> list[str]:
+        return [
+            item.get("message", "")
+            for item in payload.get("problems", [])
+            if item.get("code") == code
+        ]
+
+    with tempfile.TemporaryDirectory(
+        prefix="keel-section-boundary-", ignore_cleanup_errors=True
+    ) as raw:
+        tmp = Path(raw)
+
+        # `None` and `{}` are kept apart on purpose. A fixture task-start
+        # refused and a gate that printed nothing are different failures, and a
+        # message naming one of them while the other happened sends the reader
+        # to a place with no problem in it.
+        def close(name: str, content: str) -> dict | None:
+            repo = section_boundary_repo(tmp, name, content)
+            # A checked task with no recorded anchor fails the close for a
+            # reason that has nothing to do with this boundary, and that noise
+            # would land in both halves of every pair.
+            if not record_contract_anchor(repo, "demo", "1.1"):
+                return None
+            result = run_keel(
+                repo, "gate", "change-close", ".",
+                "--change", "demo", "--action", "archive", "--json",
+            )
+            return json.loads(result.stdout) if result.stdout.strip() else {}
+
+        def start(name: str, content: str) -> dict:
+            repo = section_boundary_repo(tmp, name, content)
+            result = run_keel(
+                repo, "gate", "task-start", ".",
+                "--change", "demo", "--task", "1.1", "--no-guard", "--json",
+            )
+            return json.loads(result.stdout) if result.stdout.strip() else {}
+
+        def readable(payload: dict | None, fixture: str, gate: str) -> bool:
+            if payload is None:
+                report(
+                    f"{label} could not record a Contract anchor for {fixture}: "
+                    "task-start refused the fixture, so change-close never ran "
+                    "against it."
+                )
+                return False
+            if not payload:
+                report(
+                    f"{label} got no JSON from {gate} for {fixture}, so there "
+                    "was no verdict to read rather than a verdict that was "
+                    "wrong."
+                )
+                return False
+            return True
+
+        # Cell 1: `## Expectation Coverage` closes every entry it declares, and
+        # the task below it declares `- E1:`/`- E2:` under its own `Covers`.
+        # Nothing here is unclosed in either position.
+        closed_coverage = (
+            "## Invalidates\n\n- None.\n\n"
+            "## Expectation Coverage\n\n"
+            "- E1: The task owns its file. Covered by: 1.1\n"
+            "- E2: The task proves it. Covered by: 1.1\n"
+        )
+        closed_task = section_boundary_task(
+            "1.1",
+            checked=True,
+            covers=("E1: The task owns its file.", "E2: The task proves it."),
+        )
+        closed = {
+            position: close(
+                f"coverage-closed-{position}",
+                section_boundary_tasks_md(
+                    section=closed_coverage, task=closed_task, position=position
+                ),
+            )
+            for position in ("above", "tail")
+        }
+        for position, payload in closed.items():
+            if not readable(payload, f"coverage-closed-{position}", "change-close"):
+                return 1
+            stray = closure_problems(payload, "expectation-closure")
+            if stray:
+                report(
+                    f"{label} reported an expectation the section closes as "
+                    f"unclosed, with the section {position} the task list. The "
+                    "entries it judged are the task's own Covers lines."
+                )
+                report(repr(stray))
+                return 1
+        if problems_of(closed["above"]) != problems_of(closed["tail"]):
+            report(
+                f"{label} returned different problems for identical section "
+                "content depending on where the section sits."
+            )
+            report(repr(problems_of(closed["above"])))
+            report(repr(problems_of(closed["tail"])))
+            return 1
+        if closed["tail"].get("status") != "pass":
+            report(
+                f"{label} refused a fixture whose only expectations are closed; "
+                "the pair comparison above would then be comparing two failures."
+            )
+            report(repr(closed["tail"].get("problems")))
+            return 1
+
+        # Cell 2: the silent half. The entry closes nothing, and the task below
+        # is a `repo-action` whose `Touch` is a bare `- none`.
+        open_coverage = (
+            "## Invalidates\n\n- None.\n\n"
+            "## Expectation Coverage\n\n"
+            "- E3: Nothing closes this one.\n"
+        )
+        none_task = section_boundary_task("1.1", checked=True, repo_action=True)
+        unclosed = {
+            position: close(
+                f"coverage-open-{position}",
+                section_boundary_tasks_md(
+                    section=open_coverage, task=none_task, position=position
+                ),
+            )
+            for position in ("above", "tail")
+        }
+        for position, payload in unclosed.items():
+            if not readable(payload, f"coverage-open-{position}", "change-close"):
+                return 1
+            named = [
+                message
+                for message in closure_problems(payload, "expectation-closure")
+                if "E3" in message
+            ]
+            if not named:
+                report(
+                    f"{label} accepted an expectation that closes nothing, with "
+                    f"the section {position} the task list. A task field of "
+                    "`none` is not the section's `- None.`."
+                )
+                report(repr(payload.get("problems")))
+                return 1
+        if problems_of(unclosed["above"]) != problems_of(unclosed["tail"]):
+            report(
+                f"{label} returned different problems for an identical unclosed "
+                "section depending on where the section sits."
+            )
+            report(repr(problems_of(unclosed["above"])))
+            report(repr(problems_of(unclosed["tail"])))
+            return 1
+
+        # Cell 3: the other reader. `## Invalidates` is read by task-start, and
+        # holds the character-identical slice.
+        closed_invalidates = (
+            "## Invalidates\n\n"
+            '- I1: "the wording that is now wrong" — README.md. Updated by: 1.1\n'
+        )
+        start_task = section_boundary_task("1.1", checked=False)
+        started = {
+            position: start(
+                f"invalidates-closed-{position}",
+                section_boundary_tasks_md(
+                    section=closed_invalidates, task=start_task, position=position
+                ),
+            )
+            for position in ("above", "tail")
+        }
+        for position, payload in started.items():
+            if not readable(payload, f"invalidates-closed-{position}", "task-start"):
+                return 1
+            if payload.get("status") != "pass":
+                report(
+                    f"{label} refused a closed invalidation declaration with "
+                    f"the section {position} the task list."
+                )
+                report(repr(payload.get("problems")))
+                return 1
+
+        # Cell 4: the silent half of the other reader. This is the cell that
+        # returned `pass` before the boundary gained its task half.
+        open_invalidates = (
+            "## Invalidates\n\n"
+            '- I1: "the wording that is now wrong" — README.md.\n'
+        )
+        open_start_task = section_boundary_task(
+            "1.1", checked=False, repo_action=True
+        )
+        unstarted = {
+            position: start(
+                f"invalidates-open-{position}",
+                section_boundary_tasks_md(
+                    section=open_invalidates, task=open_start_task, position=position
+                ),
+            )
+            for position in ("above", "tail")
+        }
+        for position, payload in unstarted.items():
+            if not readable(payload, f"invalidates-open-{position}", "task-start"):
+                return 1
+            named = [
+                message
+                for message in closure_problems(payload, "invalidation-closure")
+                if "I1" in message
+            ]
+            if not named:
+                report(
+                    f"{label} accepted an invalidation that closes nothing, "
+                    f"with the section {position} the task list. A task field "
+                    "of `none` is not the section's `- None.`."
+                )
+                report(repr(payload.get("problems")))
+                return 1
+        if problems_of(unstarted["above"]) != problems_of(unstarted["tail"]):
+            report(
+                f"{label} returned different problems for an identical unclosed "
+                "invalidation depending on where the section sits."
+            )
+            report(repr(problems_of(unstarted["above"])))
+            report(repr(problems_of(unstarted["tail"])))
+            return 1
+
+    report(f"{label} scenario passed.")
+    return 0
+
+
+SCHEMA_COPY_PAIRS = (
+    (
+        "openspec/schemas/keel-spec-driven/templates/tasks.md",
+        "assets/openspec/schemas/keel-spec-driven/templates/tasks.md",
+    ),
+    (
+        "openspec/schemas/keel-spec-driven/schema.yaml",
+        "assets/openspec/schemas/keel-spec-driven/schema.yaml",
+    ),
+)
+
+
+def validate_dry_run_overlay_accounting_scenario() -> int:
+    label = "dry-run-overlay-accounting"
+
+    # A dry run is relied on, so it is wrong in both directions: naming a write
+    # that will not happen trains the reader to ignore it, and omitting one
+    # breaks the promise the dry run exists to make. `--check` used to omit the
+    # overlay step entirely while `--install --dry-run` claimed every surface.
+    def overlay_lines(text: str) -> list[str]:
+        return [line for line in text.splitlines() if "overlay" in line]
+
+    def counts(text: str) -> str | None:
+        found = re.search(r"refreshed=(\d+) current=(\d+) missing=(\d+)", text)
+        return found.group(0) if found else None
+
+    with tempfile.TemporaryDirectory(prefix="keel-dry-run-overlay-") as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+        # The overlay surfaces are files OpenSpec generates; install merges into
+        # them and skips the ones that are absent. Create them so this scenario
+        # exercises the classification rather than the missing branch.
+        for relative in (
+            ".claude/skills/openspec-propose/SKILL.md",
+            ".claude/skills/openspec-apply-change/SKILL.md",
+            ".claude/skills/openspec-archive-change/SKILL.md",
+            ".claude/commands/opsx/propose.md",
+            ".claude/commands/opsx/apply.md",
+            ".claude/commands/opsx/archive.md",
+        ):
+            write_text(repo / relative, "# OpenSpec surface\n\nGenerated body.\n")
+        if run_keel(repo, "--install", "--target", "claude").returncode != 0:
+            report(f"{label} could not install a fixture repository.")
+            return 1
+
+        # Nothing stale: neither dry run may name a file.
+        check = run_keel(repo, "--check", "--target", "claude")
+        if any("would refresh OpenSpec" in line and ".md" in line
+               for line in overlay_lines(check.stdout)):
             report(f"{label} named a surface that would not change.")
             report("\n".join(overlay_lines(check.stdout)))
             return 1
@@ -4424,84 +5182,357 @@ def validate_regression_check_tag_scenario() -> int:
     return 0
 
 
-def validate_packaged_schema_derivation_scenario() -> int:
-    label = "packaged-schema-derivation"
-
-    # The helper derives the consumer-repo paths every install/uninstall/clear
-    # assertion iterates. When its root stopped existing it returned an empty
-    # list, so those loops compared nothing and reported success. Anchor it to
-    # what the installer really writes, and make emptiness a failure here.
-    try:
-        packaged_openspec_schema_install_paths(ROOT / "no-such-packaged-root")
-    except FileNotFoundError as error:
-        if "no-such-packaged-root" not in str(error):
-            report(f"{label} missing-root failure does not name the path it expected.")
-            report(str(error))
-            return 1
-    else:
-        report(
-            f"{label} returned a set for a missing packaged root instead of failing; "
-            "an absent root must not silently empty its callers' assertions."
-        )
-        return 1
+def change_verify_task(
+    task_id: str,
+    *,
+    checked: bool,
+    commands: tuple[str, ...],
+    evidence: tuple[str, ...],
+) -> str:
+    command_lines = "".join(f"    - {item}\n" for item in commands)
+    evidence_lines = "".join(f"    - {item}\n" for item in evidence)
+    return (
+        f"- [{'x' if checked else ' '}] {task_id} Change verify fixture\n"
+        "  - Owner: claude\n"
+        "  - Mode: implementation\n"
+        "  - Covers:\n"
+        "    - E1: the task proves its own behavior\n"
+        "  - Read:\n"
+        "    - README.md\n"
+        "  - Touch:\n"
+        "    - src/example.js\n"
+        "  - Verify:\n"
+        "    - Strategy: vertical-tdd\n"
+        f"{command_lines}"
+        "  - Acceptance:\n"
+        "    - Public behavior passes.\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"
+        f"{evidence_lines}"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: behavior proven.\n"
+        "      - Scope check: writes stayed inside Touch.\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+        "  - Stop if:\n"
+        "    - Requires files outside Touch.\n"
+    )
 
-    derived = packaged_openspec_schema_install_paths()
-    if not derived:
-        report(
-            f"{label} derived no packaged schema paths, so every assertion that "
-            "iterates them verifies nothing."
-        )
-        return 1
 
-    with tempfile.TemporaryDirectory(prefix="keel-packaged-schema-") as raw_tmp:
-        repo = Path(raw_tmp) / "repo"
-        repo.mkdir()
-        install = run_keel(repo, "--install")
-        if install.returncode != 0:
-            report(f"{label} keel --install failed.")
-            report((install.stderr or install.stdout).strip())
-            return 1
+def change_verify_deferred_evidence_repo(root: Path, name: str) -> Path:
+    repo = root / name
+    write_text(repo / "openspec/changes/demo/proposal.md", "# Proposal\n")
+    write_text(repo / "openspec/changes/demo/design.md", "## Context\n\nfixture\n")
+    write_text(repo / "openspec/changes/demo/specs/demo/spec.md", "## ADDED Requirements\n")
+    return repo
 
-        schema_root = repo / OPENSPEC_SCHEMA_ROOT
-        installed = sorted(
-            path.relative_to(repo).as_posix()
-            for path in schema_root.rglob("*")
-            if path.is_file()
-        )
-        if installed != sorted(derived):
-            report(
-                f"{label} derived paths do not match what keel --install wrote."
-            )
-            report(f"derived:   {sorted(derived)}")
-            report(f"installed: {installed}")
-            return 1
 
-    report(f"{label} scenario passed.")
-    return 0
+def validate_change_verify_deferred_evidence_scenario() -> int:
+    """A `(regression)`-tagged check may defer its bare Evidence to a
+    change-level `C<n>` check, run once for the whole change instead of once
+    per task. Issue #95: a full regression suite that only needs to run once
+    had no place to live in `tasks.md`, so authors either paid to repeat it on
+    every task or gave the middle tasks no safety net at all.
+    """
+    label = "change-verify-deferred-evidence"
 
+    change_verify_c1 = (
+        "## Change Verify\n\n"
+        "- Strategy: regression-first\n"
+        "- C1: the full three-layer suite is 0 failed\n\n"
+    )
+    change_evidence_c1_pending = "## Change Evidence\n\n- C1: pending\n\n"
+    change_evidence_c1_pass = (
+        "## Change Evidence\n\n- C1: pass. Full suite ran clean at 142/142.\n\n"
+    )
+    tagged_commands = (
+        "M1: behavior reaches the public interface",
+        "M2 (regression): the full suite stays green",
+    )
+    deferred_evidence = (
+        "M1: behavior exercised.",
+        "M1.red: failed before the implementation.",
+        "M1.green: passed after.",
+        "M2: deferred to C1",
+    )
 
-def validate_invalidation_authoring_surface_scenario() -> int:
-    label = "invalidation-authoring-surface"
+    def tasks_md(
+        *,
+        change_verify: str = "",
+        change_evidence: str = "",
+        commands: tuple[str, ...] = tagged_commands,
+        evidence: tuple[str, ...],
+        checked: bool = True,
+    ) -> str:
+        sections = (
+            "## Invalidates\n\n- None.\n\n"
+            "## Expectation Coverage\n\n"
+            "- E1: the task proves its own behavior. Covered by: 1.1\n\n"
+            + change_verify
+            + change_evidence
+        )
+        return "# Tasks\n\n" + sections + change_verify_task(
+            "1.1", checked=checked, commands=commands, evidence=evidence
+        )
 
-    # The two schema copies are the repo-local one OpenSpec resolves and the
-    # packaged one `keel --init` writes. This is the only check that asserts they
-    # agree: compact-task-authoring used to imply it through a projection loop
-    # rooted at trees that no longer exist, so it compared nothing and has since
-    # been removed.
-    for local, packaged in SCHEMA_COPY_PAIRS:
-        local_text = (ROOT / local).read_text(encoding="utf-8")
-        packaged_text = (ROOT / packaged).read_text(encoding="utf-8")
-        if local_text != packaged_text:
-            report(f"{label} schema copies diverge: {local} vs {packaged}")
-            return 1
+    with tempfile.TemporaryDirectory(
+        prefix="keel-change-verify-", ignore_cleanup_errors=True
+    ) as raw:
+        tmp = Path(raw)
+        repo = change_verify_deferred_evidence_repo(tmp, "repo")
+        tasks_path = repo / "openspec/changes/demo/tasks.md"
 
-    template = (
-        ROOT / "openspec/schemas/keel-spec-driven/templates/tasks.md"
-    ).read_text(encoding="utf-8")
-    for marker in ("## Invalidates", "- None.", "- I1:"):
-        if marker not in template:
-            report(f"{label} tasks template lacks the invalidation section: {marker}")
-            return 1
+        def codes(payload: dict) -> set[str]:
+            return {item.get("code") for item in payload.get("problems", [])}
+
+        def complete(fixture: str) -> dict:
+            write_text(tasks_path, fixture)
+            record_contract_anchor(repo, "demo")
+            result = run_keel(
+                repo, "gate", "task-complete", "--change", "demo", "--task", "1.1", "--json"
+            )
+            return json.loads(result.stdout)
+
+        def close(fixture: str) -> dict:
+            write_text(tasks_path, fixture)
+            record_contract_anchor(repo, "demo")
+            result = run_keel(
+                repo, "gate", "change-close", "--change", "demo", "--action", "sync", "--json"
+            )
+            return json.loads(result.stdout)
+
+        # (a) A `(regression)`-tagged check deferring to a declared C1 passes
+        # task-complete with no C1 result required yet — the change has not
+        # closed, so the deferred check may legitimately not have run.
+        payload = complete(tasks_md(change_verify=change_verify_c1, evidence=deferred_evidence))
+        if payload.get("status") != "pass":
+            report(f"{label} refused a regression check deferring to a declared change-level check.")
+            report(json.dumps(payload.get("problems", []), indent=2))
+            return 1
+
+        # (b) An untagged check deferring to C1 fails: only a
+        # `(regression)`-tagged check may defer.
+        payload = complete(
+            tasks_md(
+                change_verify=change_verify_c1,
+                commands=(
+                    "M1: behavior reaches the public interface",
+                    "M2: the full suite stays green",
+                ),
+                evidence=(
+                    "M1: behavior exercised.",
+                    "M1.red: failed before the implementation.",
+                    "M1.green: passed after.",
+                    "M2: deferred to C1",
+                    "M2.red: n/a",
+                    "M2.green: n/a",
+                ),
+            )
+        )
+        if (
+            payload.get("status") != "fail"
+            or "deferred-evidence-not-regression" not in codes(payload)
+        ):
+            report(f"{label} let an untagged check defer to a change-level check.")
+            report(json.dumps(payload, indent=2))
+            return 1
+
+        # (c) A `(regression)`-tagged check deferring to an undeclared C9
+        # fails: the reference must resolve.
+        payload = complete(
+            tasks_md(
+                change_verify=change_verify_c1,
+                evidence=(
+                    "M1: behavior exercised.",
+                    "M1.red: failed before the implementation.",
+                    "M1.green: passed after.",
+                    "M2: deferred to C9",
+                ),
+            )
+        )
+        if payload.get("status") != "fail" or "deferred-check-unresolved" not in codes(payload):
+            report(f"{label} accepted a deferral to a change-level check that was never declared.")
+            report(json.dumps(payload, indent=2))
+            return 1
+
+        # (d) change-close fails the same way when a task defers but
+        # `## Change Verify` does not exist at all.
+        payload = close(tasks_md(evidence=deferred_evidence))
+        if payload.get("status") != "fail" or "deferred-check-unresolved" not in codes(payload):
+            report(f"{label} closed a change whose deferred check has no Change Verify section.")
+            report(json.dumps(payload, indent=2))
+            return 1
+
+        # (e) change-close fails when C1 is declared but Change Evidence has
+        # no concrete entry for it — the check has to actually run once.
+        payload = close(
+            tasks_md(
+                change_verify=change_verify_c1,
+                change_evidence=change_evidence_c1_pending,
+                evidence=deferred_evidence,
+            )
+        )
+        if payload.get("status") != "fail" or "change-evidence-missing" not in codes(payload):
+            report(f"{label} closed a change whose declared C1 has no concrete Change Evidence.")
+            report(json.dumps(payload, indent=2))
+            return 1
+
+        # (f) change-close passes once Change Evidence carries concrete
+        # evidence for every declared C<n>.
+        payload = close(
+            tasks_md(
+                change_verify=change_verify_c1,
+                change_evidence=change_evidence_c1_pass,
+                evidence=deferred_evidence,
+            )
+        )
+        if payload.get("status") != "pass":
+            report(f"{label} refused a fully resolved deferred change-level check at close.")
+            report(json.dumps(payload.get("problems", []), indent=2))
+            return 1
+
+        # (g) A change no task defers in reports nothing about either
+        # section, whether present or absent — the feature costs nothing to a
+        # change that never uses it, and a declared-but-unused section is
+        # still held to its own shape.
+        undeferred_evidence = (
+            "M1: behavior exercised.",
+            "M1.red: failed before the implementation.",
+            "M1.green: passed after.",
+            "M2: existing suite still green.",
+        )
+        without_sections = close(tasks_md(evidence=undeferred_evidence))
+        with_unused_sections = close(
+            tasks_md(
+                change_verify=change_verify_c1,
+                change_evidence=change_evidence_c1_pass,
+                evidence=undeferred_evidence,
+            )
+        )
+        for payload in (without_sections, with_unused_sections):
+            stray = [
+                item
+                for item in payload.get("problems", [])
+                if item.get("code", "").startswith("change-verify")
+                or item.get("code", "").startswith("change-evidence")
+                or item.get("code", "").startswith("deferred-")
+            ]
+            if stray:
+                report(
+                    f"{label} reported a Change Verify/Evidence problem for a "
+                    "change nothing defers to."
+                )
+                report(json.dumps(stray, indent=2))
+                return 1
+
+        # (h) Non-contiguous C<n> labels fail change-close: the section is
+        # held to the same label discipline `M<n>` already is.
+        broken_change_verify = (
+            "## Change Verify\n\n"
+            "- Strategy: regression-first\n"
+            "- C1: the full three-layer suite is 0 failed\n"
+            "- C3: the byte baseline stays identical\n\n"
+        )
+        payload = close(
+            tasks_md(
+                change_verify=broken_change_verify,
+                change_evidence="## Change Evidence\n\n- C1: pass.\n- C3: pass.\n\n",
+                evidence=deferred_evidence,
+            )
+        )
+        if payload.get("status") != "fail" or "change-verify-shape" not in codes(payload):
+            report(f"{label} accepted non-contiguous Change Verify labels.")
+            report(json.dumps(payload, indent=2))
+            return 1
+
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def validate_packaged_schema_derivation_scenario() -> int:
+    label = "packaged-schema-derivation"
+
+    # The helper derives the consumer-repo paths every install/uninstall/clear
+    # assertion iterates. When its root stopped existing it returned an empty
+    # list, so those loops compared nothing and reported success. Anchor it to
+    # what the installer really writes, and make emptiness a failure here.
+    try:
+        packaged_openspec_schema_install_paths(ROOT / "no-such-packaged-root")
+    except FileNotFoundError as error:
+        if "no-such-packaged-root" not in str(error):
+            report(f"{label} missing-root failure does not name the path it expected.")
+            report(str(error))
+            return 1
+    else:
+        report(
+            f"{label} returned a set for a missing packaged root instead of failing; "
+            "an absent root must not silently empty its callers' assertions."
+        )
+        return 1
+
+    derived = packaged_openspec_schema_install_paths()
+    if not derived:
+        report(
+            f"{label} derived no packaged schema paths, so every assertion that "
+            "iterates them verifies nothing."
+        )
+        return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-packaged-schema-") as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+        install = run_keel(repo, "--install")
+        if install.returncode != 0:
+            report(f"{label} keel --install failed.")
+            report((install.stderr or install.stdout).strip())
+            return 1
+
+        schema_root = repo / OPENSPEC_SCHEMA_ROOT
+        installed = sorted(
+            path.relative_to(repo).as_posix()
+            for path in schema_root.rglob("*")
+            if path.is_file()
+        )
+        if installed != sorted(derived):
+            report(
+                f"{label} derived paths do not match what keel --install wrote."
+            )
+            report(f"derived:   {sorted(derived)}")
+            report(f"installed: {installed}")
+            return 1
+
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def validate_invalidation_authoring_surface_scenario() -> int:
+    label = "invalidation-authoring-surface"
+
+    # The two schema copies are the repo-local one OpenSpec resolves and the
+    # packaged one `keel --init` writes. This is the only check that asserts they
+    # agree: compact-task-authoring used to imply it through a projection loop
+    # rooted at trees that no longer exist, so it compared nothing and has since
+    # been removed.
+    for local, packaged in SCHEMA_COPY_PAIRS:
+        local_text = (ROOT / local).read_text(encoding="utf-8")
+        packaged_text = (ROOT / packaged).read_text(encoding="utf-8")
+        if local_text != packaged_text:
+            report(f"{label} schema copies diverge: {local} vs {packaged}")
+            return 1
+
+    template = (
+        ROOT / "openspec/schemas/keel-spec-driven/templates/tasks.md"
+    ).read_text(encoding="utf-8")
+    for marker in ("## Invalidates", "- None.", "- I1:"):
+        if marker not in template:
+            report(f"{label} tasks template lacks the invalidation section: {marker}")
+            return 1
 
     schema = (
         ROOT / "openspec/schemas/keel-spec-driven/schema.yaml"
@@ -5124,7 +6155,10 @@ def validate_covers_separator_collision_scenario() -> int:
             )
             report(trimmed_messages)
             return 1
-        # A capability with no collision keeps the plain wording.
+        # A capability with no colliding name receives no separator hint. It
+        # still gets the unresolved diagnostic, which since 5.21.0 names what
+        # the spec holds instead; what is asserted here is only that the
+        # separator explanation stays with the capability that has one.
         plain = start(
             "plain", "clean-cap / No such requirement / No such scenario"
         )
@@ -5162,6 +6196,195 @@ def validate_covers_separator_collision_scenario() -> int:
     return 0
 
 
+def validate_unresolved_covers_names_what_failed_scenario() -> int:
+    """Issue #49, 2026-08-02 supplement: an unresolved reference said only that.
+
+    A two-segment `Covers` reference whose second segment is a Scenario name is
+    the most common way to write the notation wrong — the shipped task template
+    taught it — and the spec being read holds that exact name one heading level
+    down. The refusal reported the reference back and nothing else, while the
+    hierarchy sentence sat thirty lines above in the same function, reachable
+    only by over-segmenting. Every case below still fails; only what it says
+    changes, and the last case asserts that.
+    """
+    spec = (
+        "# demo-cap\n\n## Purpose\nDemo.\n\n"
+        "### Requirement: The store validates itself\n"
+        "Keel MUST validate the published store.\n\n"
+        "#### Scenario: A published store passes the pinned validator\n"
+        "- **WHEN** the pinned validator runs\n"
+        "- **THEN** the published store passes\n"
+        "- **AND THEN** the pin is reported\n\n"
+        "#### Scenario: A shared scenario name\n"
+        "- **WHEN** a thing\n- **THEN** another\n\n"
+        "### Requirement: Another requirement\n"
+        "Keel MUST do the other thing.\n\n"
+        "#### Scenario: A shared scenario name\n"
+        "- **WHEN** a thing\n- **THEN** another\n"
+    )
+
+    with tempfile.TemporaryDirectory(prefix="keel-covers-what-failed-") as raw:
+        repo = Path(raw)
+        write_text(repo / "openspec/specs/demo-cap/spec.md", spec)
+
+        def start(change: str, reference: str) -> dict:
+            write_text(
+                repo / f"openspec/changes/{change}/tasks.md",
+                task_capsule_compact_fixture().replace(
+                    "    - E1: Public behavior passes.\n", f"    - {reference}\n"
+                ),
+            )
+            result = run_keel(
+                repo, "gate", "task-start", "--change", change, "--task", "1.1",
+                "--json",
+            )
+            return json.loads(result.stdout)
+
+        def refusal(change: str, reference: str) -> tuple[dict, str]:
+            payload = start(change, reference)
+            message = " ".join(
+                problem.get("message", "")
+                for problem in payload.get("problems", [])
+            )
+            return payload, message
+
+        # The reported case: the Scenario name written where a Requirement goes.
+        scenario_ref = "demo-cap / A published store passes the pinned validator"
+        offered, offered_message = refusal("offered", scenario_ref)
+        corrected = (
+            "demo-cap / The store validates itself"
+            " / A published store passes the pinned validator"
+        )
+        if offered.get("status") != "fail":
+            report(
+                "unresolved-covers-names-what-failed: a Scenario named as a "
+                "Requirement stopped being refused."
+            )
+            report(json.dumps(offered.get("problems"), ensure_ascii=False))
+            return 1
+        if not any(
+            problem.get("code") == "unresolved-covers"
+            for problem in offered.get("problems", [])
+        ):
+            report(
+                "unresolved-covers-names-what-failed: the refusal no longer "
+                "carries the unresolved-covers code."
+            )
+            report(json.dumps(offered.get("problems"), ensure_ascii=False))
+            return 1
+        if (
+            "The store validates itself" not in offered_message
+            or "Scenario" not in offered_message
+            or corrected not in offered_message
+        ):
+            report(
+                "unresolved-covers-names-what-failed: the diagnostic did not "
+                "name the Requirement the Scenario belongs to, did not call it "
+                "a Scenario, or did not spell the corrected reference."
+            )
+            report(offered_message)
+            return 1
+
+        # A name the capability declares nowhere: say the spec was read.
+        absent, absent_message = refusal("absent", "demo-cap / No such name")
+        if absent.get("status") != "fail":
+            report(
+                "unresolved-covers-names-what-failed: a name the capability does "
+                "not declare stopped being refused."
+            )
+            report(json.dumps(absent.get("problems"), ensure_ascii=False))
+            return 1
+        if (
+            "No such name" not in absent_message
+            or "hierarchy is capability / requirement" not in absent_message
+        ):
+            report(
+                "unresolved-covers-names-what-failed: a name the spec does not "
+                "declare was not reported as read, or the hierarchy was withheld."
+            )
+            report(absent_message)
+            return 1
+
+        # A capability with no spec at all is a different failure.
+        nospec, nospec_message = refusal("nospec", "nosuch-cap / Whatever")
+        if nospec.get("status") != "fail":
+            report(
+                "unresolved-covers-names-what-failed: a capability with no spec "
+                "stopped being refused."
+            )
+            report(json.dumps(nospec.get("problems"), ensure_ascii=False))
+            return 1
+        if (
+            "nosuch-cap" not in nospec_message
+            or "no spec" not in nospec_message.lower()
+        ):
+            report(
+                "unresolved-covers-names-what-failed: a capability with no spec "
+                "was not distinguished from a name the spec lacks."
+            )
+            report(nospec_message)
+            return 1
+
+        # Ambiguous: the same Scenario name under two Requirements has no single
+        # correction, so none is offered.
+        shared, shared_message = refusal("shared", "demo-cap / A shared scenario name")
+        if shared.get("status") != "fail":
+            report(
+                "unresolved-covers-names-what-failed: an ambiguous Scenario name "
+                "stopped being refused."
+            )
+            report(json.dumps(shared.get("problems"), ensure_ascii=False))
+            return 1
+        if (
+            "The store validates itself" not in shared_message
+            or "Another requirement" not in shared_message
+        ):
+            report(
+                "unresolved-covers-names-what-failed: an ambiguous Scenario name "
+                "did not name the Requirements it appears under."
+            )
+            report(shared_message)
+            return 1
+        if "Write it as" in shared_message:
+            report(
+                "unresolved-covers-names-what-failed: a corrected reference was "
+                "offered for a Scenario name that has more than one parent."
+            )
+            report(shared_message)
+            return 1
+
+        # What resolves is unchanged. This is the assertion that must not be
+        # dropped: reading more of the spec on the failure path is the direction
+        # in which a refusal could accidentally become a resolution.
+        resolves = start("resolves", "demo-cap / The store validates itself")
+        capsule = resolves.get("contract", {}).get("capsule", {})
+        authority = capsule.get("authority", [])
+        if (
+            resolves.get("status") != "pass"
+            or resolves.get("problems")
+            or len(authority) != 1
+            or authority[0].get("kind") != "requirement"
+            or not authority[0]
+            .get("source", "")
+            .endswith("specs/demo-cap/spec.md#Requirement:The store validates itself")
+        ):
+            report(
+                "unresolved-covers-names-what-failed: a reference that resolves "
+                "no longer compiles to the same authority."
+            )
+            report(json.dumps(resolves, ensure_ascii=False)[:2000])
+            return 1
+
+    if "unresolved-covers-names-what-failed" not in {name for name, _ in SCENARIOS}:
+        report(
+            "unresolved-covers-names-what-failed: the scenario registry does not "
+            "include it."
+        )
+        return 1
+    report("unresolved-covers-names-what-failed scenario passed.")
+    return 0
+
+
 def validate_unresolved_authority_names_field_scenario() -> int:
     """Issue #7 example 3: the diagnostic must name what it actually reads.
 
@@ -6216,6 +7439,14 @@ def validate_default_completion_attributes_writes_scenario() -> int:
     dirty then answers "did this task write it" without asking Git to answer
     "which task wrote it", which is the question it cannot answer in a
     half-finished change.
+
+    Issue #72: recording only the path, not its content, meant a path already
+    dirty at task start was exempt for the rest of the task's life, even after
+    the task wrote it again — the common case, since most tasks in this
+    repository start on a tree a prior task already legitimately touched. M2
+    proves the fix: a dirty-at-start path the task modifies again is
+    attributed, while M1's own dirty-at-start path (never touched again) stays
+    exempt.
     """
     label = "default-completion-attributes-writes"
 
@@ -6314,6 +7545,34 @@ def validate_default_completion_attributes_writes_scenario() -> int:
             )
             return 1
 
+        # M2 — issue #72: a path already dirty at task start is exempt only
+        # while its content stays the one recorded then. A task that goes on
+        # to modify that same path has written it, and the boundary M1 proved
+        # above must still catch that write instead of exempting it forever
+        # because it happened to be dirty at the start too.
+        write_text(
+            repo / "src/already-dirty.js", "// touched again by the task\n"
+        )
+        payload = gate()
+        problems = outside(payload)
+        if not any("src/already-dirty.js" in message for message in problems):
+            report(
+                f"{label} M2 a path already dirty at task start, then "
+                "modified again by the task, was not attributed. Recording "
+                "only the path (not its content) at task start exempts every "
+                "later write to it, not just the one that predates the task."
+            )
+            report(f"  status={payload.get('status')!r}")
+            for warning in payload.get("warnings", []):
+                report(f"  warning: {warning}")
+            return 1
+        if payload.get("status") != "fail":
+            report(
+                f"{label} M2 the gate named the re-touched path but did not "
+                f"fail; got status {payload.get('status')!r}."
+            )
+            return 1
+
         # M1 — an explicit base answers the question the caller asked, which is
         # the broader one: everything since that commit, including what was
         # already dirty when the task started.
@@ -8604,106 +9863,623 @@ def validate_findings_resolved_here_scenario() -> int:
             )
             return 1
 
-        as_owner = complete(
-            f"the helper rewrote its own baseline path. Durable owner: {TRACKER_OWNER}"
+        as_owner = complete(
+            f"the helper rewrote its own baseline path. Durable owner: {TRACKER_OWNER}"
+        )
+        if as_owner.returncode != 0:
+            report(
+                "findings-resolved-here: M2 the same tracker reference must "
+                "still pass as a durable owner."
+            )
+            report((as_owner.stderr or as_owner.stdout).strip())
+            return 1
+
+        # A Findings block normally holds several findings with different
+        # dispositions, written as free prose on one line or wrapped across
+        # several — `review-entry-extent` covers the wrapped shape. The
+        # evidence taken from a marker is what follows *that* marker, not the
+        # rest of the text — otherwise the first `Resolved here:` swallows
+        # every disposition after it, and a block mixing a fix with a
+        # tracker-owned follow-up is refused on the follow-up's URL. Measured
+        # on this change's own task 1.3 before it was fixed.
+        mixed = complete(
+            "the counter's own line arithmetic was wrong. Resolved here: M1. "
+            "Second, nothing warned that the CLI was four minors old. "
+            f"Durable owner: {TRACKER_OWNER}"
+        )
+        if mixed.returncode != 0:
+            report(
+                "findings-resolved-here: M1 a block holding a resolved finding "
+                "and a tracker-owned one was refused; the resolved marker must "
+                "not reach past its own evidence."
+            )
+            report((mixed.stderr or mixed.stdout).strip())
+            return 1
+
+        second_bare = complete(
+            "the first was fixed. Resolved here: M1. The second was too. "
+            "Resolved here:"
+        )
+        if second_bare.returncode != 3:
+            report(
+                "findings-resolved-here: M2 every resolved marker must be "
+                "checked, not only the first; a block whose second names no "
+                f"evidence exited {second_bare.returncode}, not 3."
+            )
+            report((second_bare.stderr or second_bare.stdout).strip())
+            return 1
+        if not problems(second_bare, "finding-resolution-evidence"):
+            report(
+                "findings-resolved-here: M2 the second resolved marker was not "
+                "reported as missing its evidence."
+            )
+            return 1
+
+        # M3 — the general refusal has to name the form that now exists.
+        unowned = complete("a finding with no disposition at all")
+        owner_message = problems(unowned, "finding-owner")
+        if unowned.returncode != 3:
+            report(
+                "findings-resolved-here: M3 a finding with no disposition "
+                f"exited {unowned.returncode}, not 3."
+            )
+            report((unowned.stderr or unowned.stdout).strip())
+            return 1
+        for phrase in ("Resolved here", "M<n>", "Discard reason", "Durable owner"):
+            if phrase not in owner_message:
+                report(
+                    "findings-resolved-here: M3 the accepted-forms message must "
+                    f"name every disposition; {phrase!r} is missing from it."
+                )
+                report(owner_message or "(no finding-owner problem)")
+                return 1
+
+    # M4 — the criterion is stated where the author reads it, and the portable
+    # skill and its projection do not disagree about it.
+    canonical = ROOT / "src/skills/keel-review-checklist/SKILL.md"
+    projected = ROOT / "plugins/keel/skills/keel-review-checklist/SKILL.md"
+    if canonical.read_bytes() != projected.read_bytes():
+        report(
+            "findings-resolved-here: M4 the portable checklist and its plugin "
+            "projection are not byte-identical."
+        )
+        return 1
+    checklist = canonical.read_text(encoding="utf-8")
+    for phrase in ("Resolved here:", "Durable owner:", "Discard reason:"):
+        if phrase not in checklist:
+            report(
+                "findings-resolved-here: M4 keel-review-checklist does not name "
+                f"the {phrase!r} disposition."
+            )
+            return 1
+    agents = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
+    if "Resolved here:" not in agents:
+        report(
+            "findings-resolved-here: M4 AGENTS.md does not name the "
+            "`Resolved here:` disposition."
+        )
+        return 1
+
+    if "findings-resolved-here" not in {name for name, _ in SCENARIOS}:
+        report("findings-resolved-here: the scenario registry does not include it.")
+        return 1
+    report("findings-resolved-here scenario passed.")
+    return 0
+
+
+# A task whose Review entries are supplied verbatim, so a fixture can wrap one
+# across lines. Everything outside the Review block is the complete, checked
+# shape `tracker_owner_tasks` uses; only the four entries and the sibling below
+# them vary.
+def review_extent_tasks(review: str, blocker: str = "none") -> str:
+    return (
+        "# Tasks\n\n## Invalidates\n\n- None.\n\n"
+        "## Expectation Coverage\n\n"
+        "- E1:\n"
+        "  - Covered by: 1.1\n\n"
+        "## 1. Work\n\n"
+        "- [x] 1.1 Complete behavior\n"
+        "  - Owner: keel-agent\n"
+        "  - Mode: implementation\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Read:\n"
+        "    - README.md\n"
+        "  - Touch:\n"
+        "    - src/feature.js\n"
+        "  - Commands:\n"
+        "    - M1: node test.js\n"
+        "  - Acceptance:\n"
+        "    - Public behavior passes.\n"
+        "  - Autonomy boundary:\n"
+        "    - Default: hard-stop\n"
+        "    - Pre-authorized fallback: none\n"
+        "  - Coupling: none\n"
+        "  - Candidate Boundary:\n"
+        "    - One candidate.\n"
+        "  - Stop Rules:\n"
+        "    - Stop on failure.\n"
+        "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: passed\n"
+        "    - Review:\n"
+        f"{review}"
+        f"    - Blocker: {blocker}\n"
+        "  - Stop if:\n"
+        "    - Scope expands.\n"
+        "  - Report:\n"
+        "    - Summary\n"
+    )
+
+
+def validate_review_entry_extent_scenario() -> int:
+    """A Review entry is the text the author wrote under its label.
+
+    Issue #49's first supplement. `reviewValue()` matched each Review entry
+    with a line-anchored regex, so an entry that wrapped was judged by its
+    first line and every continuation line was discarded before any check saw
+    it. A `Findings` recording its `Durable owner:` on the fourth line was
+    refused with the owner present, the path existing, and the form correct.
+
+    The same truncation failed open, which #49 does not report: a `Findings`
+    reading `none` on its first line and recording an unowned finding below it
+    produced no problem at all, because the check tested `none` and never saw
+    the rest.
+
+    Both directions are driven through `keel gate task-complete` on real
+    repositories, and the widened read is bounded at the sibling entry so that
+    one entry cannot be satisfied by another's text.
+    """
+    label = "review-entry-extent"
+    owner_path = "openspec/changes/demo/tasks.md"
+
+    with tempfile.TemporaryDirectory(
+        prefix="keel-review-extent-", ignore_cleanup_errors=True
+    ) as raw:
+        repo = Path(raw)
+        tasks = repo / "openspec/changes/demo/tasks.md"
+        write_text(repo / "openspec/changes/demo/proposal.md", "# Proposal\n")
+        write_text(
+            repo / "openspec/changes/demo/specs/demo/spec.md",
+            "## ADDED Requirements\n",
+        )
+
+        def complete(review: str, blocker: str = "none") -> dict | None:
+            write_text(tasks, review_extent_tasks(review, blocker))
+            if not record_contract_anchor(repo, "demo"):
+                return None
+            result = run_keel(
+                repo, "gate", "task-complete", ".",
+                "--change", "demo", "--task", "1.1", "--json",
+            )
+            return json.loads(result.stdout) if result.stdout.strip() else {}
+
+        def codes(payload: dict) -> list[str]:
+            return sorted(
+                item.get("code", "") for item in payload.get("problems", [])
+            )
+
+        def owner_problems(payload: dict) -> list[str]:
+            return [
+                item.get("message", "")
+                for item in payload.get("problems", [])
+                if item.get("code") == "finding-owner"
+            ]
+
+        def readable(payload: dict | None, fixture: str) -> bool:
+            if payload is None:
+                report(
+                    f"{label} could not record a Contract anchor for {fixture}: "
+                    "task-start refused the fixture, so task-complete never ran "
+                    "against it."
+                )
+                return False
+            if not payload:
+                report(
+                    f"{label} got no JSON from task-complete for {fixture}, so "
+                    "there was no verdict to read rather than a verdict that "
+                    "was wrong."
+                )
+                return False
+            return True
+
+        def review_block(findings: str, status: str = "pass") -> str:
+            return (
+                f"      - Status: {status}\n"
+                "      - Acceptance check: reviewed\n"
+                "      - Scope check: reviewed\n"
+                f"{findings}"
+            )
+
+        # M1 — the reported defect. The same finding is written twice: wrapped
+        # across four indented lines with the owner on the last, and joined
+        # onto one line with no word changed. The pair is compared as well as
+        # pinned absolutely, because a comparison alone passes when both forms
+        # are refused identically.
+        wrapped_owner = (
+            "      - Findings: two behaviors of state sync turned up in "
+            "measurement.\n"
+            "        First, the watcher fires per property rather than once "
+            "per object.\n"
+            "        Second, a class-typed property does not update on the "
+            "child side.\n"
+            f"        Durable owner: {owner_path}\n"
+        )
+        joined_owner = (
+            "      - Findings: two behaviors of state sync turned up in "
+            "measurement. First, the watcher fires per property rather than "
+            "once per object. Second, a class-typed property does not update "
+            f"on the child side. Durable owner: {owner_path}\n"
+        )
+        forms = {
+            "wrapped": complete(review_block(wrapped_owner)),
+            "joined": complete(review_block(joined_owner)),
+        }
+        for form, payload in forms.items():
+            if not readable(payload, f"owner-{form}"):
+                return 1
+            stray = owner_problems(payload)
+            if stray:
+                report(
+                    f"{label} refused a durable owner the author recorded, with "
+                    f"the finding written {form}. The owner is named after "
+                    "`Durable owner:` and the path exists."
+                )
+                report(repr(stray))
+                return 1
+        if codes(forms["wrapped"]) != codes(forms["joined"]):
+            report(
+                f"{label} returned different problems for the same finding "
+                "depending on whether it wrapped."
+            )
+            report(f"wrapped={codes(forms['wrapped'])} joined={codes(forms['joined'])}")
+            return 1
+
+        # M2 — the silent half. `none` on the first line, a real finding under
+        # it. At 5.27.0 this produced no problem at all.
+        below_none = complete(
+            review_block(
+                "      - Findings: none\n"
+                "        Actually the retry path still drops the last error.\n"
+                "        Nobody owns this and no reason is given for dropping "
+                "it.\n"
+            )
+        )
+        if not readable(below_none, "finding-below-none"):
+            return 1
+        if not owner_problems(below_none):
+            report(
+                f"{label} accepted a finding written below a `none` first "
+                "line. The gate read the word `none` and not the finding under "
+                "it."
+            )
+            report(repr(codes(below_none)))
+            return 1
+
+        # M3 — the sibling bound. The wrapped `Findings` carries no disposition
+        # of its own; the `- Blocker:` entry below it does. Reading the entry
+        # whole must not let the sibling's text satisfy it.
+        absorbing = complete(
+            review_block(
+                "      - Findings: the helper rewrote its own baseline path.\n"
+                "        Nothing here names who owns it.\n"
+            ),
+            blocker=f"none. Durable owner: {owner_path}",
+        )
+        if not readable(absorbing, "sibling-bound"):
+            return 1
+        if not owner_problems(absorbing):
+            report(
+                f"{label} let a `Findings` with no disposition be satisfied by "
+                "the sibling entry below it. A widened read must still stop at "
+                "its sibling."
+            )
+            report(repr(codes(absorbing)))
+            return 1
+
+        # M4 — the unwrapped shape, which is what all 640 archived Review
+        # entries use. The expected message is written out rather than compared
+        # against another run of the same build, so a change that altered the
+        # text in both places would still fail here.
+        unwrapped = complete(
+            review_block("      - Findings: a finding with no disposition\n")
+        )
+        if not readable(unwrapped, "unwrapped"):
+            return 1
+        unwrapped_owner = owner_problems(unwrapped)
+        if len(unwrapped_owner) != 1:
+            report(
+                f"{label} did not produce exactly one `finding-owner` problem "
+                "for an unwrapped finding with no disposition."
+            )
+            report(repr(codes(unwrapped)))
+            return 1
+        for phrase in (
+            "Review Findings must be `none` or carry a disposition — name a "
+            "path after `Durable owner:`",
+            "Resolved here:",
+            "Durable owner:",
+            "Discard reason:",
+            "keel/HANDOFF.md",
+        ):
+            if phrase not in unwrapped_owner[0]:
+                report(
+                    f"{label} the unwrapped refusal's message changed; "
+                    f"{phrase!r} is no longer in it. This change moves how much "
+                    "text is read, not what the gate says."
+                )
+                report(unwrapped_owner[0])
+                return 1
+        passing = complete(
+            review_block(f"      - Findings: still open. Durable owner: {owner_path}\n")
+        )
+        if not readable(passing, "unwrapped-owned"):
+            return 1
+        if owner_problems(passing):
+            report(
+                f"{label} refused an unwrapped finding that names an existing "
+                "path after `Durable owner:`."
+            )
+            report(repr(owner_problems(passing)))
+            return 1
+
+    if "review-entry-extent" 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
+
+
+# A task whose Reauthorizations entry is supplied verbatim, so a fixture can
+# leave it out entirely, wrap it, or plant an unfilled token on either the
+# label line or a continuation line. Everything else is the complete, checked
+# shape `review_extent_tasks` uses; only the Reauthorizations line (or its
+# absence) and Blocker vary.
+def reauthorizations_tasks(reauthorizations: str, blocker: str = "none") -> str:
+    return (
+        "# Tasks\n\n## Invalidates\n\n- None.\n\n"
+        "## Expectation Coverage\n\n"
+        "- E1:\n"
+        "  - Covered by: 1.1\n\n"
+        "## 1. Work\n\n"
+        "- [x] 1.1 Complete behavior\n"
+        "  - Owner: keel-agent\n"
+        "  - Mode: implementation\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Read:\n"
+        "    - README.md\n"
+        "  - Touch:\n"
+        "    - src/feature.js\n"
+        "  - Commands:\n"
+        "    - M1: node test.js\n"
+        "  - Acceptance:\n"
+        "    - Public behavior passes.\n"
+        "  - Autonomy boundary:\n"
+        "    - Default: hard-stop\n"
+        "    - Pre-authorized fallback: none\n"
+        "  - Coupling: none\n"
+        "  - Candidate Boundary:\n"
+        "    - One candidate.\n"
+        "  - Stop Rules:\n"
+        "    - Stop on failure.\n"
+        "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: passed\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: reviewed\n"
+        "      - Scope check: reviewed\n"
+        "      - Findings: none\n"
+        f"    - Blocker: {blocker}\n"
+        f"{reauthorizations}"
+        "  - Stop if:\n"
+        "    - Scope expands.\n"
+        "  - Report:\n"
+        "    - Summary\n"
+    )
+
+
+def validate_reauthorizations_shape_scenario() -> int:
+    """A rejection becomes a Reauthorizations entry the author writes (#70).
+
+    The owner chose R2 over R3 on issue #70: the task author records what a
+    gate rejected themselves, in a new `Reauthorizations` Evidence entry; the
+    gate adds no write of its own and validates only the entry's shape. This
+    drives that shape check through `keel gate task-complete` on real
+    repositories: absence and `none` need nothing, a concrete record — wrapped
+    or joined — is accepted, an unfilled `<slot>` token is refused even when it
+    only appears on a continuation line the label line itself does not carry,
+    and a concrete record never blocks completion the way a concrete `Blocker`
+    does.
+    """
+    label = "reauthorizations-shape"
+    baseline_reauthorizations = "    - Reauthorizations: none\n"
+    baseline_blocker = "    - Blocker: none\n"
+
+    with tempfile.TemporaryDirectory(
+        prefix="keel-reauthorizations-shape-", ignore_cleanup_errors=True
+    ) as raw:
+        repo = Path(raw)
+        tasks = repo / "openspec/changes/demo/tasks.md"
+        write_text(repo / "openspec/changes/demo/proposal.md", "# Proposal\n")
+        write_text(
+            repo / "openspec/changes/demo/specs/demo/spec.md",
+            "## ADDED Requirements\n",
+        )
+
+        # Started once, with clean Evidence, and every variant below edits
+        # only the Reauthorizations/Blocker lines and calls task-complete
+        # directly rather than restarting. Two things make restarting wrong
+        # here: Evidence is not part of the compiled capsule that task-start
+        # fingerprints, so editing only these lines cannot drift it; and
+        # task-start separately enforces its own blanket "Evidence must be
+        # concrete" check across the whole field regardless of which label an
+        # unfilled `<slot>` sits under, so planting one for M1 and then
+        # restarting would be refused there before task-complete's more
+        # specific `reauthorizations-shape` ever saw it.
+        write_text(tasks, reauthorizations_tasks(baseline_reauthorizations))
+        if not record_contract_anchor(repo, "demo"):
+            report(f"{label} could not record a Contract anchor for the baseline fixture.")
+            return 1
+        baseline = tasks.read_text(encoding="utf-8")
+        if baseline_reauthorizations not in baseline or baseline_blocker not in baseline:
+            report(
+                f"{label} lost track of the baseline Reauthorizations/Blocker "
+                "lines after task-start recorded the Contract anchor."
+            )
+            return 1
+
+        def complete(reauthorizations: str, blocker: str = "none") -> dict:
+            text = baseline.replace(baseline_reauthorizations, reauthorizations, 1)
+            if blocker != "none":
+                text = text.replace(baseline_blocker, f"    - Blocker: {blocker}\n", 1)
+            write_text(tasks, text)
+            result = run_keel(
+                repo, "gate", "task-complete", ".",
+                "--change", "demo", "--task", "1.1", "--json",
+            )
+            return json.loads(result.stdout) if result.stdout.strip() else {}
+
+        def codes(payload: dict) -> list[str]:
+            return sorted(
+                item.get("code", "") for item in payload.get("problems", [])
+            )
+
+        def shape_problems(payload: dict) -> list[str]:
+            return [
+                item.get("message", "")
+                for item in payload.get("problems", [])
+                if item.get("code") == "reauthorizations-shape"
+            ]
+
+        def readable(payload: dict, fixture: str) -> bool:
+            if not payload:
+                report(
+                    f"{label} got no JSON from task-complete for {fixture}, so "
+                    "there was no verdict to read rather than a verdict that "
+                    "was wrong."
+                )
+                return False
+            return True
+
+        # M1 — the core new behavior, in both places an unfilled token can
+        # hide: on the label line itself, and on a continuation line a
+        # first-line-only reader would never see.
+        on_label_line = complete("    - Reauthorizations: <what was rejected>\n")
+        if not readable(on_label_line, "unfilled-on-label-line"):
+            return 1
+        if not shape_problems(on_label_line):
+            report(
+                f"{label} accepted an unfilled `<slot>` token written on the "
+                "Reauthorizations label line itself."
+            )
+            report(repr(codes(on_label_line)))
+            return 1
+        if "<what was rejected>" not in shape_problems(on_label_line)[0]:
+            report(f"{label} refused the unfilled token but did not name it.")
+            report(shape_problems(on_label_line)[0])
+            return 1
+
+        on_continuation = complete(
+            "    - Reauthorizations:\n"
+            "      - task-complete refused finding-owner on 2026-08-05; added\n"
+            "        a Durable owner naming <the tracker issue>.\n"
         )
-        if as_owner.returncode != 0:
+        if not readable(on_continuation, "unfilled-on-continuation-line"):
+            return 1
+        if not shape_problems(on_continuation):
             report(
-                "findings-resolved-here: M2 the same tracker reference must "
-                "still pass as a durable owner."
+                f"{label} accepted an unfilled `<slot>` token written on a "
+                "continuation line below the Reauthorizations label. A reader "
+                "that only looks at the first line would miss it."
             )
-            report((as_owner.stderr or as_owner.stdout).strip())
+            report(repr(codes(on_continuation)))
+            return 1
+        if "<the tracker issue>" not in shape_problems(on_continuation)[0]:
+            report(
+                f"{label} refused the continuation-line token but did not "
+                "name it."
+            )
+            report(shape_problems(on_continuation)[0])
             return 1
 
-        # A Findings block normally holds several findings with different
-        # dispositions, all in one line of free prose. The evidence taken from
-        # a marker is what follows *that* marker, not the rest of the line —
-        # otherwise the first `Resolved here:` swallows every disposition after
-        # it, and a block mixing a fix with a tracker-owned follow-up is
-        # refused on the follow-up's URL. Measured on this change's own task
-        # 1.3 before it was fixed.
-        mixed = complete(
-            "the counter's own line arithmetic was wrong. Resolved here: M1. "
-            "Second, nothing warned that the CLI was four minors old. "
-            f"Durable owner: {TRACKER_OWNER}"
-        )
-        if mixed.returncode != 0:
+        # M2 (regression) — no false positives: absent, none, and a wrapped
+        # concrete record all pass, and wrapped/joined forms of the same
+        # concrete text agree.
+        absent = complete("")
+        if not readable(absent, "absent"):
+            return 1
+        if shape_problems(absent):
             report(
-                "findings-resolved-here: M1 a block holding a resolved finding "
-                "and a tracker-owned one was refused; the resolved marker must "
-                "not reach past its own evidence."
+                f"{label} refused a task that declares no Reauthorizations "
+                "entry at all."
             )
-            report((mixed.stderr or mixed.stdout).strip())
+            report(repr(shape_problems(absent)))
             return 1
 
-        second_bare = complete(
-            "the first was fixed. Resolved here: M1. The second was too. "
-            "Resolved here:"
+        bare_none = complete("    - Reauthorizations: none\n")
+        if not readable(bare_none, "bare-none"):
+            return 1
+        if shape_problems(bare_none):
+            report(f"{label} refused a bare `Reauthorizations: none`.")
+            report(repr(shape_problems(bare_none)))
+            return 1
+
+        wrapped_concrete = complete(
+            "    - Reauthorizations:\n"
+            "      - task-complete refused outside-touch on src/helper.js on\n"
+            "        2026-08-05; the file belonged to this task and Touch was\n"
+            "        missing it, so it was added.\n"
         )
-        if second_bare.returncode != 3:
+        joined_concrete = complete(
+            "    - Reauthorizations: task-complete refused outside-touch on "
+            "src/helper.js on 2026-08-05; the file belonged to this task and "
+            "Touch was missing it, so it was added.\n"
+        )
+        if not readable(wrapped_concrete, "wrapped-concrete"):
+            return 1
+        if not readable(joined_concrete, "joined-concrete"):
+            return 1
+        if shape_problems(wrapped_concrete):
+            report(f"{label} refused a concrete, wrapped Reauthorizations record.")
+            report(repr(shape_problems(wrapped_concrete)))
+            return 1
+        if codes(wrapped_concrete) != codes(joined_concrete):
             report(
-                "findings-resolved-here: M2 every resolved marker must be "
-                "checked, not only the first; a block whose second names no "
-                f"evidence exited {second_bare.returncode}, not 3."
+                f"{label} returned different problems for the same concrete "
+                "record depending on whether it wrapped."
             )
-            report((second_bare.stderr or second_bare.stdout).strip())
-            return 1
-        if not problems(second_bare, "finding-resolution-evidence"):
             report(
-                "findings-resolved-here: M2 the second resolved marker was not "
-                "reported as missing its evidence."
+                f"wrapped={codes(wrapped_concrete)} joined={codes(joined_concrete)}"
             )
             return 1
 
-        # M3 — the general refusal has to name the form that now exists.
-        unowned = complete("a finding with no disposition at all")
-        owner_message = problems(unowned, "finding-owner")
-        if unowned.returncode != 3:
+        # M3 (regression) — presence does not block completion, unlike
+        # Blocker. Proven able to fail: a concrete Blocker on the same
+        # repository does fail it, so the comparison is not vacuous.
+        if codes(wrapped_concrete):
             report(
-                "findings-resolved-here: M3 a finding with no disposition "
-                f"exited {unowned.returncode}, not 3."
+                f"{label} a concrete Reauthorizations record produced a "
+                "problem — presence alone must not fail completion."
             )
-            report((unowned.stderr or unowned.stdout).strip())
+            report(repr(codes(wrapped_concrete)))
             return 1
-        for phrase in ("Resolved here", "M<n>", "Discard reason", "Durable owner"):
-            if phrase not in owner_message:
-                report(
-                    "findings-resolved-here: M3 the accepted-forms message must "
-                    f"name every disposition; {phrase!r} is missing from it."
-                )
-                report(owner_message or "(no finding-owner problem)")
-                return 1
-
-    # M4 — the criterion is stated where the author reads it, and the portable
-    # skill and its projection do not disagree about it.
-    canonical = ROOT / "src/skills/keel-review-checklist/SKILL.md"
-    projected = ROOT / "plugins/keel/skills/keel-review-checklist/SKILL.md"
-    if canonical.read_bytes() != projected.read_bytes():
-        report(
-            "findings-resolved-here: M4 the portable checklist and its plugin "
-            "projection are not byte-identical."
-        )
-        return 1
-    checklist = canonical.read_text(encoding="utf-8")
-    for phrase in ("Resolved here:", "Durable owner:", "Discard reason:"):
-        if phrase not in checklist:
+        concrete_blocker = complete("", blocker="a real blocker is recorded here")
+        if not readable(concrete_blocker, "concrete-blocker"):
+            return 1
+        if "blocker" not in codes(concrete_blocker):
             report(
-                "findings-resolved-here: M4 keel-review-checklist does not name "
-                f"the {phrase!r} disposition."
+                f"{label} the comparison fixture proves nothing: a concrete "
+                "Blocker on this repository did not fail completion either."
             )
+            report(repr(codes(concrete_blocker)))
             return 1
-    agents = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
-    if "Resolved here:" not in agents:
-        report(
-            "findings-resolved-here: M4 AGENTS.md does not name the "
-            "`Resolved here:` disposition."
-        )
-        return 1
 
-    if "findings-resolved-here" not in {name for name, _ in SCENARIOS}:
-        report("findings-resolved-here: the scenario registry does not include it.")
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
         return 1
-    report("findings-resolved-here scenario passed.")
+    report(f"{label} scenario passed.")
     return 0
 
 
@@ -8900,6 +10676,38 @@ def validate_guard_status_is_not_enforcement_scenario() -> int:
     return 0
 
 
+def validate_guard_warnings_are_concise_scenario() -> int:
+    """Issue #92 item 1: shorten the two standing guard warnings.
+
+    The owner authorized shortening wording, not removing content: every
+    idea `guard-status-is-not-enforcement` checks for must still resolve, but
+    the combined text must drop below the byte counts `#92` measured before
+    this fix (398 for `guard status`, 397 for `guard clear`, on a fresh
+    directory with no manifest).
+    """
+    baseline = {"status": 398, "clear": 397}
+    with tempfile.TemporaryDirectory(prefix="keel-guard-concise-") as raw:
+        project = Path(raw)
+        for label, before in baseline.items():
+            result = run_keel(project, "guard", label)
+            out = result.stdout or ""
+            if len(out) >= before:
+                report(
+                    f"guard-warnings-are-concise: keel guard {label} is "
+                    f"{len(out)} chars, not shorter than the {before}-char "
+                    "baseline #92 measured before the wording was shortened."
+                )
+                return 1
+    if "guard-warnings-are-concise" not in {name for name, _ in SCENARIOS}:
+        report(
+            "guard-warnings-are-concise: the scenario registry does not "
+            "include it."
+        )
+        return 1
+    report("guard-warnings-are-concise scenario passed.")
+    return 0
+
+
 def validate_source_repo_cli_resolution_scenario() -> int:
     """Issue #13 item 3: a bare `keel` runs the installed package.
 
@@ -9839,6 +11647,38 @@ def validate_core_gates_scenario() -> int:
             report((handoff_owner.stderr or handoff_owner.stdout).strip())
             return 1
 
+        # The accepted-forms enumeration is a menu; the one actionable
+        # instruction inside it (name a path after `Durable owner:`) must lead
+        # the message, not close it, so a reader who forgot to name a path
+        # reads what to do before reading the menu. Three single-cause checks,
+        # not one compound condition — issue #43 exists to catch exactly that
+        # shape.
+        finding_owner_lower = finding_owner_message.lower()
+        instruction_at = finding_owner_lower.find(
+            "name a path after `durable owner:`"
+        )
+        if instruction_at < 0:
+            report(
+                "core-gates scenario: the finding-owner message dropped its "
+                "actionable instruction (\"name a path after `Durable "
+                "owner:`\")."
+            )
+            return 1
+        resolved_here_at = finding_owner_lower.find("`resolved here:`")
+        if resolved_here_at < 0:
+            report(
+                "core-gates scenario: the finding-owner message dropped its "
+                "`Resolved here:` disposition form."
+            )
+            return 1
+        if instruction_at > resolved_here_at:
+            report(
+                "core-gates scenario: the finding-owner message states its "
+                "actionable instruction after the `Resolved here:` form "
+                "instead of before it."
+            )
+            return 1
+
         write_text(
             completion_tasks,
             completion_task(
@@ -13835,6 +15675,99 @@ def validate_standing_authorization_declaration_scenario() -> int:
     return 0
 
 
+def validate_standing_authorization_sync_confusion_scenario() -> int:
+    """`sync` is a `change-close --action` value, not an `authorize:` name (#93).
+
+    A reader who copies `sync` from `change-close --action sync|archive` into
+    `authorize:` gets the generic unrecognized-action message, which never says
+    why `sync` in particular is wrong or what to write instead — and the
+    failure was reported only by `keel --doctor`, an explicitly-invoked
+    diagnostic, not by `keel context`, the command a session runs first.
+    """
+    label = "standing-authorization-sync-confusion"
+    with tempfile.TemporaryDirectory(prefix="keel-authorize-sync-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — `sync` gets a sentence naming the `change-close --action`
+        # confusion and pointing at `archive`; an unrelated typo does not.
+        sync_repo = root / "sync"
+        sync_repo.mkdir()
+        write_authorize_config(sync_repo, "authorize:\n  - sync\n")
+        doctor = run_keel(sync_repo, "--doctor")
+        combined = doctor.stdout + doctor.stderr
+        for needle in ("change-close --action", "declare `archive`"):
+            if needle not in combined:
+                report(
+                    f"{label} M1 the doctor message does not name the sync "
+                    f"confusion: {needle!r}."
+                )
+                report(combined)
+                return 1
+
+        typo_repo = root / "typo"
+        typo_repo.mkdir()
+        write_authorize_config(typo_repo, "authorize:\n  - deploy\n")
+        typo_doctor = run_keel(typo_repo, "--doctor")
+        typo_combined = typo_doctor.stdout + typo_doctor.stderr
+        if "deploy" not in typo_combined:
+            report(f"{label} M1 the typo repo's own offending entry went unreported.")
+            report(typo_combined)
+            return 1
+        if "change-close --action" in typo_combined:
+            report(
+                f"{label} M1 a genuine typo (`deploy`) still received the "
+                "sync-specific sentence."
+            )
+            report(typo_combined)
+            return 1
+
+        # M2 — the same broken declaration surfaces in `keel context`'s
+        # warnings, and does not disturb status or nextAction, exactly as an
+        # uncommitted git path is reported without changing selection.
+        context = json.loads(run_keel(sync_repo, "context", "--json").stdout)
+        warnings = " ".join(context.get("warnings", []))
+        if "change-close --action" not in warnings or "sync" not in warnings:
+            report(
+                f"{label} M2 `keel context` did not report the broken "
+                "authorize: declaration."
+            )
+            report(f"  warnings: {context.get('warnings')!r}")
+            return 1
+        if context.get("status") != "idle":
+            report(f"{label} M2 the broken declaration changed context's status: {context.get('status')!r}")
+            return 1
+        if context.get("nextAction", {}).get("kind") != "none":
+            report(
+                "{} M2 the broken declaration changed context's nextAction: {!r}".format(
+                    label, context.get("nextAction")
+                )
+            )
+            return 1
+
+        typo_context = json.loads(run_keel(typo_repo, "context", "--json").stdout)
+        typo_warnings = " ".join(typo_context.get("warnings", []))
+        if "deploy" not in typo_warnings:
+            report(
+                f"{label} M2 `keel context` did not report the typo repo's "
+                "broken authorize: declaration at all."
+            )
+            report(f"  warnings: {typo_context.get('warnings')!r}")
+            return 1
+        if "change-close --action" in typo_warnings:
+            report(
+                f"{label} M2 a genuine typo (`deploy`) still received the "
+                "sync-specific sentence inside `keel context`'s warning."
+            )
+            report(f"  warnings: {typo_context.get('warnings')!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 standing_authorization_task(boundary: str = "") -> str:
     return (
         "- [ ] 1.1 Behavior\n"
@@ -14237,7 +16170,274 @@ def validate_triage_declaration_scenario() -> int:
             report(f"triage: the same inputs gave different answers: {offline} != {again}")
             return 1
 
-    report("triage-declaration scenario passed.")
+    report("triage-declaration scenario passed.")
+    return 0
+
+
+def validate_triage_admits_from_the_repository_scenario() -> int:
+    """The owner's decision belongs in the owner's file, not on the reporter's issue.
+
+    A label records "this may run unattended" in a field the person who filed
+    the issue can see, in the vocabulary they were asked to file under. The
+    second source moves that decision into keel/config.yaml without giving it
+    up to inference: a number is applied by hand to one issue, exactly as a
+    label is. Reported as #62.
+    """
+
+    def declare(repo: Path, body: str) -> None:
+        (repo / "keel").mkdir(parents=True, exist_ok=True)
+        (repo / "keel" / "config.yaml").write_text(
+            f"fast_check: echo check\n{body}", encoding="utf-8"
+        )
+
+    def triage(repo: Path, *args: str) -> dict | None:
+        result = run_keel(repo, "triage", ".", *args, "--json")
+        try:
+            return json.loads(result.stdout)
+        except json.JSONDecodeError:
+            # Reported here rather than at the call site. "did not admit" and
+            # "did not run" are two different diagnoses, and a caller checking
+            # `verdict is None or verdict["status"] != "admit"` would send the
+            # reader looking for a verdict in a run that produced none.
+            report(
+                f"keel triage {' '.join(args)} printed no JSON "
+                f"(exit {result.returncode}): "
+                f"{(result.stderr or result.stdout).strip()}"
+            )
+            return None
+
+    def make(root: Path, name: str, body: str) -> Path:
+        repo = root / name
+        repo.mkdir()
+        declare(repo, body)
+        return repo
+
+    nested = "triage:\n  labels:\n    - auto\n  issues:\n    - 62\n"
+
+    with tempfile.TemporaryDirectory(prefix="keel-triage-repo-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — a number listed in the repository's own file admits, and says so.
+        numbers = make(root, "numbers", "triage:\n  issues:\n    - 62\n    - 58\n")
+        admitted = triage(numbers, "--issue", "62", "--labels", "bug")
+        if admitted is None or admitted.get("status") != "admit":
+            report(f"M1 a declared issue number did not admit: {admitted}")
+            return 1
+        reason = admitted.get("reason") or ""
+        if "62" not in reason or "keel/config.yaml" not in reason:
+            report(
+                "M1 the admission does not name the number and the file that "
+                f"lists it, so a reader cannot tell which source answered: {reason}"
+            )
+            return 1
+        if admitted.get("sources") != ["issue"]:
+            report(f"M1 the admitting source is not reported as the issue: {admitted}")
+            return 1
+        refused = triage(numbers, "--issue", "61", "--labels", "bug")
+        if refused is None or refused.get("status") != "refuse":
+            report(f"M1 an unlisted number was admitted: {refused}")
+            return 1
+
+        # M2 — the flat form is what every installed repository has. Its
+        # entries keep their exact meaning, down to the reason text, and none
+        # of them is read as a number.
+        flat = make(root, "flat", "triage:\n  - auto\n")
+        legacy_admit = triage(flat, "--labels", "auto,bug")
+        if legacy_admit is None or legacy_admit.get("status") != "admit":
+            report(f"M2 the bare list stopped admitting its labels: {legacy_admit}")
+            return 1
+        expected_admit = (
+            "admitted by declared label auto; admission starts work and decides "
+            "nothing after it — every later gate still applies and a material "
+            "decision still stops for the owner."
+        )
+        if (legacy_admit.get("reason") or "") != expected_admit:
+            report(
+                "M2 the bare list's admission reason changed from the 5.23.0 "
+                f"text: {legacy_admit.get('reason')!r}"
+            )
+            return 1
+        if legacy_admit.get("sources") != ["label"]:
+            report(f"M2 the bare list's admitting source is not the label: {legacy_admit}")
+            return 1
+        legacy_refuse = triage(flat, "--labels", "bug")
+        expected_refuse = "the issue carries bug and this repository accepts auto."
+        if legacy_refuse is None or legacy_refuse.get("status") != "refuse":
+            report(f"M2 the bare list admitted an undeclared label: {legacy_refuse}")
+            return 1
+        if (legacy_refuse.get("reason") or "") != expected_refuse:
+            report(
+                "M2 the bare list's refusal reason changed from the 5.23.0 "
+                f"text: {legacy_refuse.get('reason')!r}"
+            )
+            return 1
+        # The entry is the label `auto`, not the number 62 — a bare token must
+        # not have been reclassified, because that would move an authorization
+        # boundary in a repository nobody edited.
+        by_number = triage(flat, "--issue", "62", "--labels", "bug")
+        if by_number is None or by_number.get("status") != "refuse":
+            report(f"M2 a bare list entry was read as an issue number: {by_number}")
+            return 1
+
+        # M2 — and either source admits alone when both are declared.
+        both = make(root, "both", nested)
+        for args, source in (
+            (("--labels", "auto"), "label"),
+            (("--issue", "62"), "issue"),
+        ):
+            verdict = triage(both, *args)
+            if verdict is None or verdict.get("status") != "admit":
+                report(f"M2 the {source} source did not admit alone: {verdict}")
+                return 1
+        neither = triage(both, "--labels", "bug", "--issue", "7")
+        if neither is None or neither.get("status") != "refuse":
+            report(f"M2 an issue matching neither source was admitted: {neither}")
+            return 1
+        neither_reason = neither.get("reason") or ""
+        for needle in ("bug", "7", "auto", "62"):
+            if needle not in neither_reason:
+                report(
+                    "M2 the refusal must name what the issue carried and both "
+                    f"halves of what is accepted; missing {needle}: {neither_reason}"
+                )
+                return 1
+
+        # M3 — a declaration Keel cannot fully read admits nothing, including
+        # the half it did read, and names the part that failed.
+        unreadable = {
+            "hash": ("triage:\n  issues:\n    - '#62'\n  labels:\n    - auto\n", "#62"),
+            "unknown-key": (
+                "triage:\n  authors:\n    - someone\n  labels:\n    - auto\n",
+                "authors",
+            ),
+            "mixed": ("triage:\n  - auto\n  issues:\n    - 62\n", "auto"),
+            "inline": ("triage: { issues: [62] }\n", "issues"),
+        }
+        undeclared = make(root, "undeclared", "")
+        undeclared_reason = (triage(undeclared, "--labels", "auto") or {}).get(
+            "reason"
+        ) or ""
+        for name, (body, needle) in unreadable.items():
+            repo = make(root, name, body)
+            # Every fixture above carries something Keel *did* read — the label
+            # `auto`, or the number 62. A partial read would admit here.
+            verdict = triage(repo, "--labels", "auto", "--issue", "62")
+            if verdict is None or verdict.get("status") != "refuse":
+                report(
+                    f"M3 the {name} declaration admitted on the half Keel could "
+                    f"read: {verdict}"
+                )
+                return 1
+            reason = verdict.get("reason") or ""
+            if needle not in reason:
+                report(
+                    f"M3 the {name} refusal does not name the entry it could not "
+                    f"read ({needle}): {reason}"
+                )
+                return 1
+            if reason == undeclared_reason:
+                report(
+                    f"M3 the {name} refusal is word for word the undeclared-policy "
+                    "refusal, so a broken declaration reads as an absent one."
+                )
+                return 1
+            if "could not" not in reason.lower():
+                report(f"M3 the {name} refusal does not say it could not read: {reason}")
+                return 1
+
+        # M3 — and the CLI refuses the same spelling it refuses in the file,
+        # and refuses to answer with no issue attributes at all.
+        hashed = run_keel(numbers, "triage", ".", "--issue", "#62")
+        if hashed.returncode == 0:
+            report("M3 --issue accepted a number Keel refuses in the declaration.")
+            return 1
+        empty = run_keel(numbers, "triage", ".")
+        if empty.returncode == 0:
+            report("M3 triage answered with neither labels nor an issue number.")
+            return 1
+
+        # M4 — what may start work here is answerable from one command.
+        doctor_both = run_keel(both, "--doctor").stdout
+        if "Unattended triage:" not in doctor_both or "triage: ok" not in doctor_both:
+            report(f"M4 doctor does not report a declared triage surface:\n{doctor_both}")
+            return 1
+        for needle in ("auto", "62"):
+            if needle not in doctor_both:
+                report(
+                    f"M4 doctor omits the declared {needle} source, so the surface "
+                    f"under-reports what may start work:\n{doctor_both}"
+                )
+                return 1
+        doctor_numbers = run_keel(numbers, "--doctor").stdout
+        if "triage: ok" not in doctor_numbers or "62" not in doctor_numbers:
+            report(f"M4 doctor does not report an issues-only policy:\n{doctor_numbers}")
+            return 1
+        if "labelled" in doctor_numbers:
+            report(
+                "M4 doctor names labels for a repository that declared none:\n"
+                f"{doctor_numbers}"
+            )
+            return 1
+        doctor_broken = run_keel(root / "hash", "--doctor").stdout
+        if "triage: ok" in doctor_broken:
+            report(
+                "M4 doctor reports an unreadable declaration as a working policy:\n"
+                f"{doctor_broken}"
+            )
+            return 1
+        if "#62" not in doctor_broken:
+            report(
+                "M4 doctor does not name what it could not read, so the owner "
+                f"cannot tell a broken declaration from an absent one:\n{doctor_broken}"
+            )
+            return 1
+
+    # M5 — the surfaces an owner reads must state the second source. Phrases,
+    # not keywords: "issue number" appearing anywhere would satisfy a keyword
+    # check while the page still teaches that a label is the only unit. The
+    # alignment skill points at the protocol's own statement instead of
+    # repeating it (keel-unattended-triage's "A secondary surface points
+    # instead of repeating" scenario), so only the three full surfaces below
+    # are held to the phrase itself; the skill copies are held to the pointer.
+    full_surfaces = {
+        "config": ROOT / "keel/config.yaml",
+        "protocol": ROOT / "AGENTS.md",
+        "readme": ROOT / "README.md",
+    }
+    stale = "A label is the unit"
+    for label, path in full_surfaces.items():
+        if not path.is_file():
+            report(f"M5 missing surface: {path}")
+            return 1
+        content = re.sub(r"\s+", " ", path.read_text(encoding="utf-8"))
+        if "issue number" not in content:
+            report(f"M5 {label} does not state the issue-number source: {path}")
+            return 1
+        if stale in content:
+            report(
+                f"M5 {label} still says {stale!r}, which stopped being true when "
+                f"a second source was declared: {path}"
+            )
+            return 1
+
+    canonical = ROOT / "src/skills/keel-align-expectations/SKILL.md"
+    distributed = ROOT / PLUGIN_ROOT / "skills/keel-align-expectations/SKILL.md"
+    for label, path in (("canonical skill", canonical), ("distributed skill", distributed)):
+        if not path.is_file():
+            report(f"M5 missing surface: {path}")
+            return 1
+        content = re.sub(r"\s+", " ", path.read_text(encoding="utf-8"))
+        if "AGENTS.md" not in content or "states no separate copy" not in content:
+            report(
+                f"M5 {label} does not point to the protocol's issue-number "
+                f"statement: {path}"
+            )
+            return 1
+    if canonical.read_bytes() != distributed.read_bytes():
+        report("M5 the canonical and distributed skills diverged.")
+        return 1
+
+    report("triage-admits-from-the-repository scenario passed.")
     return 0
 
 
@@ -15338,7 +17538,11 @@ def validate_unattended_boundary_scenario() -> int:
     """The boundary must be readable where an unattended run will read it.
 
     Phrases, not keywords: "unattended" appearing somewhere would satisfy a
-    keyword check while stating none of what a run may and may not do.
+    keyword check while stating none of what a run may and may not do. The
+    alignment skill points at the protocol's own statement instead of
+    repeating it (keel-unattended-triage's "A secondary surface points
+    instead of repeating" scenario), so only the protocol is held to the
+    full phrase set; the skill copies are held to the pointer instead.
     """
 
     required = [
@@ -15352,22 +17556,35 @@ def validate_unattended_boundary_scenario() -> int:
         # Admission comes from a declaration, never from accumulated history.
         "never from a precedent",
     ]
+    pointer_required = [
+        "AGENTS.md",
+        "Unattended runs",
+        "states no separate copy",
+    ]
     canonical = ROOT / "src/skills/keel-align-expectations/SKILL.md"
     distributed = ROOT / PLUGIN_ROOT / "skills/keel-align-expectations/SKILL.md"
     protocol = ROOT / "AGENTS.md"
 
+    if not protocol.is_file():
+        report(f"unattended-boundary: missing protocol: {protocol}")
+        return 1
+    # Collapse whitespace: these are multi-word phrases in hard-wrapped
+    # prose, so raw matching would assert the line layout, not the wording.
+    protocol_content = re.sub(r"\s+", " ", protocol.read_text(encoding="utf-8"))
+    for phrase in required:
+        if phrase not in protocol_content:
+            report(f"unattended-boundary: protocol omits: {phrase}")
+            return 1
+
     for label, path in (
-        ("protocol", protocol),
         ("canonical skill", canonical),
         ("distributed skill", distributed),
     ):
         if not path.is_file():
             report(f"unattended-boundary: missing {label}: {path}")
             return 1
-        # Collapse whitespace: these are multi-word phrases in hard-wrapped
-        # prose, so raw matching would assert the line layout, not the wording.
         content = re.sub(r"\s+", " ", path.read_text(encoding="utf-8"))
-        for phrase in required:
+        for phrase in pointer_required:
             if phrase not in content:
                 report(f"unattended-boundary: {label} omits: {phrase}")
                 return 1
@@ -19264,6 +21481,202 @@ def validate_guard_stale_manifest_scenario() -> int:
     return 0
 
 
+# The message a reader is given when the state cannot be reauthorized.
+#
+# 5.26.0 recorded verbatim, so the parse-miss cell compares against the text as
+# it shipped rather than against whatever the code happens to produce.
+PARSE_MISS_PROBLEM = (
+    "Guarded task demo#1.1 no longer resolves; reauthorize through "
+    "`keel gate task-start` and `keel guard start`."
+)
+
+
+def guard_status_payload(repo: Path, cell: str) -> tuple[dict, str]:
+    """Return `guard status --json` as a payload plus its first problem message.
+
+    A run that produced nothing readable is reported here rather than handed
+    back as an empty payload. Otherwise one condition downstream would guard two
+    unrelated failures — the command did not run, and the status was wrong — and
+    every caller would report the second, sending the reader to a state that was
+    never observed. Returning `None` for the payload is what makes the two
+    distinguishable at the call site instead of at the reader.
+    """
+    result = run_keel(repo, "guard", "status", "--json")
+    if not result.stdout.strip():
+        report(
+            f"guard-status-stale-manifest: {cell} `guard status --json` "
+            f"produced no output (exit {result.returncode}). "
+            f"{(result.stderr or '').strip()!r}"
+        )
+        return None, ""
+    try:
+        payload = json.loads(result.stdout)
+    except json.JSONDecodeError as error:
+        report(
+            f"guard-status-stale-manifest: {cell} `guard status --json` "
+            f"produced output that is not JSON ({error}): {result.stdout!r}"
+        )
+        return None, ""
+    problems = payload.get("problems", [])
+    return payload, (problems[0].get("message", "") if problems else "")
+
+
+def validate_guard_status_stale_manifest_scenario() -> int:
+    """`keel guard status` says which of two states the manifest is in.
+
+    `loadTaskContract` returns `null` when the tasks file is absent and when the
+    task id is not in it. `guardStatus` had one branch for both, so a manifest
+    whose change had been archived and a manifest whose task id was merely
+    renumbered produced byte-identical output — and the shared message told the
+    reader to reauthorize, which for the archived change is impossible:
+    `keel gate task-start` reports a missing tasks file and `keel guard start`
+    reports that the task does not exist. Neither names `keel guard clear`,
+    which is the only action that resolves it.
+
+    The write guard hook drew this line in 5.12.0 by testing the change
+    directory. This is the same test on the surface that describes the manifest
+    rather than the one that refuses a write. Measured at the start of this
+    change: both states returned `Guarded task demo#1.1 no longer resolves`.
+    """
+    with tempfile.TemporaryDirectory(
+        prefix="keel-guard-status-stale-", ignore_cleanup_errors=True
+    ) as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+        change_dir = repo / "openspec/changes/demo"
+        write_text(change_dir / "tasks.md", guard_task_fixture())
+        write_text(repo / "src/feature.js", "// fixture\n")
+
+        started = run_keel(
+            repo, "guard", "start", "--change", "demo", "--task", "1.1", "--json"
+        )
+        if started.returncode != 0:
+            report("guard-status-stale-manifest: guard start failed.")
+            report((started.stderr or started.stdout).strip())
+            return 1
+
+        # Relocated to where `openspec archive` moves it, for the reason the
+        # guard-stale-manifest scenario records: what is under test is the
+        # answer once the change is gone, not the archiver.
+        archived_dir = repo / "openspec/changes/archive/2026-08-04-demo"
+        archived_dir.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(change_dir), str(archived_dir))
+
+        # M1 — the archived state names the directory that is gone and the
+        # action that resolves it.
+        stale, stale_message = guard_status_payload(repo, "M1")
+        if stale is None:
+            return 1
+        if stale.get("status") != "drifted":
+            report(
+                "guard-status-stale-manifest: M1 expected the archived state to "
+                f"stay classified as drifted, got {stale.get('status')!r}."
+            )
+            return 1
+        stale_codes = [item.get("code") for item in stale.get("problems", [])]
+        if "stale-manifest" not in stale_codes:
+            report(
+                "guard-status-stale-manifest: M1 an archived change was not "
+                "reported under its own problem code, so a --json reader cannot "
+                f"tell it from a parse miss. Codes: {stale_codes!r}"
+            )
+            return 1
+        for needle in ("stale", "openspec/changes/demo", "keel guard clear"):
+            if needle not in stale_message:
+                report(
+                    "guard-status-stale-manifest: M1 the message must report the "
+                    f"manifest as stale and name what resolves it; {needle!r} is "
+                    f"missing from: {stale_message!r}"
+                )
+                return 1
+        # The advice that could not be followed. `keel gate task-start` may
+        # still be named for the task the reader is actually starting — what
+        # must be gone is the instruction to reauthorize the vanished one.
+        for forbidden in ("reauthorize through", "keel guard start"):
+            if forbidden in stale_message:
+                report(
+                    "guard-status-stale-manifest: M1 the message still sends the "
+                    f"reader to reauthorize a change that is not there; "
+                    f"{forbidden!r} is in: {stale_message!r}"
+                )
+                return 1
+
+        # M3 — the parse miss is untouched. A live change whose task id is
+        # absent is not a fact about the repository, it is a read the guard
+        # must not guess about, and its answer is the 5.26.0 answer verbatim.
+        change_dir.mkdir(parents=True, exist_ok=True)
+        write_text(
+            change_dir / "tasks.md",
+            guard_task_fixture().replace("1.1", "9.9"),
+        )
+        miss, miss_message = guard_status_payload(repo, "M3")
+        if miss is None:
+            return 1
+        if miss.get("status") != "drifted":
+            report(
+                "guard-status-stale-manifest: M3 the parse miss changed status "
+                f"from drifted to {miss.get('status')!r}."
+            )
+            return 1
+        miss_codes = [item.get("code") for item in miss.get("problems", [])]
+        if miss_codes != ["authority-drift"]:
+            report(
+                "guard-status-stale-manifest: M3 the parse miss changed problem "
+                f"code. Expected ['authority-drift'], got {miss_codes!r}"
+            )
+            return 1
+        if miss_message != PARSE_MISS_PROBLEM:
+            report(
+                "guard-status-stale-manifest: M3 the parse-miss message changed "
+                f"from the 5.26.0 text.\nwas:  {PARSE_MISS_PROBLEM!r}\nnow:  "
+                f"{miss_message!r}"
+            )
+            return 1
+
+        # M2 — the two states no longer answer the same. Asserted on both the
+        # code and the message: a repair that reworded one branch while leaving
+        # one code for two states would pass a message comparison alone.
+        if stale_codes == miss_codes:
+            report(
+                "guard-status-stale-manifest: M2 an archived change and a task "
+                "id absent from a live tasks.md still share a problem code "
+                f"({stale_codes!r}), so they are separable only by prose."
+            )
+            return 1
+        if stale_message == miss_message:
+            report(
+                "guard-status-stale-manifest: M2 the two states still produce "
+                f"one message: {stale_message!r}"
+            )
+            return 1
+
+        # D4 — a third state: the change directory is there and its tasks file
+        # is not. That is a live change mid-authoring, where reauthorizing after
+        # writing the tasks file is genuinely the way out, so it keeps the
+        # parse-miss message. This is what testing the directory rather than the
+        # tasks file buys, and it is the cell that fails if the two are swapped.
+        (change_dir / "tasks.md").unlink()
+        authoring, authoring_message = guard_status_payload(repo, "D4")
+        if authoring is None:
+            return 1
+        if authoring_message != PARSE_MISS_PROBLEM:
+            report(
+                "guard-status-stale-manifest: D4 a live change whose tasks.md "
+                "is absent was reported as a stale manifest; the change is "
+                f"still there and can be reauthorized. Got: {authoring_message!r}"
+            )
+            return 1
+
+    if "guard-status-stale-manifest" not in {name for name, _ in SCENARIOS}:
+        report(
+            "guard-status-stale-manifest: the scenario registry does not "
+            "include it."
+        )
+        return 1
+    report("guard-status-stale-manifest scenario passed.")
+    return 0
+
+
 # The one-message-many-failures shape, counted rather than forbidden.
 #
 # Issue #43 records it caught by `keel-review-checklist` in three consecutive
@@ -19287,7 +21700,15 @@ def validate_guard_stale_manifest_scenario() -> int:
 # lowered, because a number that only checks for rises becomes false the first
 # time someone fixes a site — and a false number is what this whole change is
 # about. Fixing sites is expected. Lowering this constant is one line.
-OR_GUARDED_ASSERTION_SITES = 75
+#
+# Raised 75 -> 80 by `change-verify-deferred-evidence` (issue #95): five sites,
+# each `payload.get("status") != "fail" or "<code>" not in codes(payload)`
+# guarding one `report(...)`, the same already-accepted gate-result-assertion
+# shape as `regression-check-tag`'s own site above. The message covers both
+# operands (the gate did not fail the way the fixture requires, whichever half
+# was wrong), and every site prints the full problem payload alongside it, so
+# a reader is never left with only the sentence.
+OR_GUARDED_ASSERTION_SITES = 80
 
 
 def or_guarded_assertion_sites(source: str) -> list[int]:
@@ -19966,6 +22387,263 @@ def validate_decimal_runs_are_not_hash_shaped_scenario() -> int:
     return 0
 
 
+def _tasks_semantics_probe(raw: str):
+    """Install into `raw` and return `check(body) -> (state, errors)`.
+
+    Both scenarios below ask the same question of `keel --check` — which lines
+    of one active `tasks.md` it refuses — so they share the fixture rather than
+    each growing their own copy of it. The caller owns the temporary directory,
+    so a failed install is reported by the caller and cleaned up by its `with`.
+    """
+    repo = (Path(raw) / "repo").resolve()
+    repo.mkdir()
+    install = run_keel(repo, "--install")
+    if install.returncode != 0:
+        return None, (install.stderr or install.stdout).strip()
+
+    tasks_path = repo / "openspec/changes/reading-lines/tasks.md"
+
+    def check(body: str):
+        write_text(
+            tasks_path,
+            "# Tasks\n\n## Invalidates\n\n- None.\n\n"
+            "## Tasks\n\n"
+            f"{body}\n"
+            "## Workflow Notes\n\n- None.\n",
+        )
+        result = run_keel(repo, "--check")
+        if "keel state: ok" in result.stdout:
+            state = "ok"
+        elif "keel state: failed" in result.stdout:
+            state = "failed"
+        else:
+            state = "unreported"
+        errors = [
+            out for out in result.stdout.splitlines() if out.startswith("state-error")
+        ]
+        return state, errors
+
+    return check, None
+
+
+def validate_a_context_word_is_a_word_scenario() -> int:
+    """Issue #65 §1: `remaining` supplied the word `main`.
+
+    The context words that turn a hash-shaped token into a recorded commit
+    identifier were matched anywhere on the line, so `remaining`, `heading`,
+    `domain`, and `maintains` each supplied one. Four lines in this
+    repository's own history are refused this way, and every hex token on
+    them is a `sha256:` contract anchor rather than a commit identifier.
+
+    The boundary form is the owner's decision on #65 and keeps the inflections
+    an author actually writes. Dropping `committed` and `hashes` would have
+    been the quieter change and would have cost four real refusals.
+    """
+    label = "a-context-word-is-a-word"
+    with tempfile.TemporaryDirectory(prefix="keel-context-word-") as raw:
+        check, failure = _tasks_semantics_probe(raw)
+        if failure is not None:
+            report(f"{label}: keel --install failed while building the fixture.")
+            report(failure)
+            return 1
+
+        # A word is not the words inside it. Each carries a hash-shaped token so
+        # that the host word is the only thing under test.
+        for host in ("remaining", "heading", "domain", "maintains"):
+            state, errors = check(
+                "- [x] A1 implementation\n"
+                f"  - Evidence:\n"
+                f"    - M1: pass — 0 anchors {host}, recorded at sha256:01b9e740ab.\n"
+            )
+            if state == "unreported":
+                report(f"{label}: keel --check reported no state at all on `{host}`.")
+                return 1
+            if state != "ok":
+                report(
+                    f"{label}: `{host}` was read as a context word. It contains "
+                    "one, which is not the same thing, and the token beside it "
+                    "here is a contract anchor. The author's only repair is to "
+                    "reword a line that was correct."
+                )
+                for error in errors:
+                    report(f"  {error}")
+                return 1
+
+        # The control. A check that passes because nothing is refused any more
+        # is indistinguishable from this one, so the inflections the owner
+        # decided to keep are asserted in the same repository.
+        for host in ("commit", "commits", "committed", "committing", "hashes"):
+            state, errors = check(
+                "- [x] A1 implementation\n"
+                f"  - Evidence:\n"
+                f"    - M1: pass — {host} a1b2c3d4e5f6 verified.\n"
+            )
+            if state == "unreported":
+                report(f"{label}: keel --check reported no state at all on `{host}`.")
+                return 1
+            if state != "failed":
+                report(
+                    f"{label}: an identifier beside `{host}` was accepted. That "
+                    "word names the act the rule exists to catch, and requiring "
+                    "a boundary must not stop it counting."
+                )
+                return 1
+            if not [error for error in errors if "tasks.md:" in error]:
+                report(f"{label}: the refusal on `{host}` named no line.")
+                return 1
+
+        # The Chinese words carry no boundary, because none is definable
+        # between two word characters. Asserted here rather than reasoned
+        # about: `\b提交\b` matches none of these.
+        for recorded in ("已提交", "未提交", "该任务尚未提交，等待评审"):
+            state, _ = check(
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                f"    - M1: {recorded}。\n"
+            )
+            if state == "unreported":
+                report(
+                    f"{label}: keel --check reported no state at all on "
+                    f"`{recorded}`. This is not a verdict about the fixture — "
+                    "the check did not reach the point of having one."
+                )
+                return 1
+            if state != "failed":
+                report(
+                    f"{label}: recorded state written as `{recorded}` was "
+                    "accepted. A word boundary around a Chinese context word "
+                    "disables it silently, which is why it does not carry one."
+                )
+                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 validate_a_covers_citation_is_not_a_record_scenario() -> int:
+    """Issue #65 §4: the rule refused a tasks.md that cited it.
+
+    A `Covers` entry names a requirement that must exist in a spec. When the
+    requirement is about the state this check forbids — dirty worktrees,
+    recorded identifiers — citing it by name reads to the check as recording
+    it. The repair available to the author is to rename the requirement, which
+    is what 5.19.0 did.
+
+    Eleven lines across four changes in this repository's history sit in this
+    shape, eight of them citing requirements published in `openspec/specs/`.
+    """
+    label = "a-covers-citation-is-not-a-record"
+    # Two requirement names published in this repository today. Neither is
+    # invented for the fixture; both are cited by archived changes.
+    cited = (
+        "keel-core-gates / Dirty-worktree attribution is conservative"
+        " / A path already dirty at task start is not attributed",
+        "keel-stateless-continuity / A recorded commit hash is recognized by"
+        " what makes it one / A decimal run is not a hash",
+    )
+
+    with tempfile.TemporaryDirectory(prefix="keel-covers-citation-") as raw:
+        check, failure = _tasks_semantics_probe(raw)
+        if failure is not None:
+            report(f"{label}: keel --install failed while building the fixture.")
+            report(failure)
+            return 1
+
+        state, errors = check(
+            "- [x] A1 implementation\n"
+            "  - Covers:\n"
+            + "".join(f"    - {entry}\n" for entry in cited)
+            + "  - Touch:\n    - src/a.js\n"
+        )
+        if state == "unreported":
+            report(f"{label}: keel --check reported no state at all on a citation.")
+            return 1
+        if state != "ok":
+            report(
+                f"{label}: a Covers citation was read as a record of the state "
+                "it names. The entry is a reference to a requirement that has "
+                "to exist elsewhere, and the only repair open to the author is "
+                "to rename that requirement."
+            )
+            for error in errors:
+                report(f"  {error}")
+            return 1
+
+        # The control, and the boundary. The same wording outside the field is
+        # a statement, and is still refused — otherwise this scenario would
+        # pass just as well against a check that had stopped running.
+        state, errors = check(
+            "- [x] A1 implementation\n"
+            "  - Covers:\n"
+            + "".join(f"    - {entry}\n" for entry in cited)
+            + "  - Evidence:\n"
+            "    - M1: pass — the worktree was dirty when the task started.\n"
+        )
+        if state == "unreported":
+            report(
+                f"{label}: keel --check reported no state at all while reading "
+                "the wording outside the field."
+            )
+            return 1
+        if state != "failed":
+            report(
+                f"{label}: the same wording in an Evidence line was accepted. "
+                "The exemption is the Covers field, not the file that contains "
+                "one."
+            )
+            return 1
+        named = [error for error in errors if "tasks.md:" in error]
+        if not named:
+            report(f"{label}: the refusal outside the field named no line.")
+            return 1
+        # The citations are the two lines under the label, and each carries
+        # wording this rule refuses; naming either of them means the exemption
+        # did not hold while the Evidence line was being refused.
+        if any(f"tasks.md:{cited_line}:" in error
+               for error in named for cited_line in (11, 12)):
+            report(
+                f"{label}: the refusal named a citation line. The rule fired "
+                "correctly on the Evidence line and wrongly on the field, so "
+                "what is wrong is the field's bound."
+            )
+            for error in named:
+                report(f"  {error}")
+            return 1
+
+        # The bound ends where the next field begins. A `Covers` field that
+        # ran to the end of the task would swallow the Evidence line above and
+        # make that control vacuous, so the end of the field is asserted from
+        # the other side too.
+        state, _ = check(
+            "- [x] A1 implementation\n"
+            "  - Covers:\n"
+            f"    - {cited[0]}\n"
+            "  - Verify:\n"
+            "    - M1: the change is 已提交 and needs no further work.\n"
+        )
+        if state == "unreported":
+            report(
+                f"{label}: keel --check reported no state at all while reading "
+                "the field that follows a Covers field."
+            )
+            return 1
+        if state != "failed":
+            report(
+                f"{label}: a Verify line following a Covers field was exempted. "
+                "The field ends at the next field label."
+            )
+            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 validate_validation_runner_scenario() -> int:
     if "SCENARIOS" not in globals():
         report("validation-runner: the scenario registry is missing.")
@@ -20104,6 +22782,200 @@ def validate_doctor_openspec_honesty_scenario() -> int:
     return 0
 
 
+# A scenario name, as the registry spells one. Two registered names carry no
+# hyphen — `cli` and `uninstall` — so requiring one would leave exactly those
+# two unchecked, and allowing single words was measured to add no false
+# positive.
+AUTHORED_SCENARIO_NAME = re.compile(r"^[a-z0-9][a-z0-9-]*$")
+
+# The two forms a scenario reference is read in. `--scenario` is the invocation
+# itself and needs no context. The other is keyed on the *assertion* rather than
+# on the token, because kebab-case is this project's spelling for gate stages,
+# diagnostic codes, skills, capabilities, and hook events too: reading every
+# such token as a scenario name flags 22 of the 55 in the archive. Keying on
+# "stays green" flags one, and that one is a real unregistered name.
+AUTHORED_SCENARIO_FLAG = re.compile(r"--scenario\s+`?([A-Za-z0-9][\w.-]*)`?")
+AUTHORED_SCENARIO_STAYS_GREEN = re.compile(r"stays? green", re.IGNORECASE)
+AUTHORED_CHECK_LINE = re.compile(r"^-\s*M\d+\b")
+AUTHORED_VERIFY_BLOCK = re.compile(r"^-\s*(?:Verify|Commands):\s*$")
+AUTHORED_CAPSULE_BLOCK = re.compile(r"^-\s*[A-Z][A-Za-z ]*:\s*$")
+AUTHORED_INLINE_CODE = re.compile(r"`([^`\n]+)`")
+
+AUTHORED_SCENARIO_FORMS = (
+    "A scenario reference is read in two forms: a name after `--scenario`, and "
+    "a backticked lowercase token in a `Verify` M<n> check asserting that "
+    "something stays green. Other backticked vocabulary in a check is not read "
+    "as a scenario name."
+)
+
+
+def unregistered_scenario_references(
+    text: str, registered: set[str]
+) -> list[tuple[int, str, str]]:
+    """Scenario names a task contract declares that the registry does not hold.
+
+    Returns `(line, name, form)` for each, 1-indexed, in file order. The `form`
+    is which of the two recognized shapes matched, so a report can say why the
+    token was read as a scenario name at all.
+    """
+    problems: list[tuple[int, str, str]] = []
+    in_verify = False
+    for line_number, line in enumerate(text.splitlines(), start=1):
+        stripped = line.strip()
+        # A capsule block heading ends the previous block, so `Evidence` and
+        # `Stop Rules` leave the Verify block rather than extending it. Evidence
+        # is written after the run, when execution has already answered the
+        # question this check exists to answer earlier.
+        if AUTHORED_CAPSULE_BLOCK.match(stripped):
+            in_verify = bool(AUTHORED_VERIFY_BLOCK.match(stripped))
+        for match in AUTHORED_SCENARIO_FLAG.finditer(line):
+            name = match.group(1)
+            if name not in registered:
+                problems.append((line_number, name, "--scenario"))
+        if not in_verify or not AUTHORED_CHECK_LINE.match(stripped):
+            continue
+        if not AUTHORED_SCENARIO_STAYS_GREEN.search(line):
+            continue
+        for token in AUTHORED_INLINE_CODE.findall(line):
+            if not AUTHORED_SCENARIO_NAME.match(token):
+                continue
+            if token not in registered:
+                problems.append((line_number, token, "stays green"))
+    return problems
+
+
+def active_change_tasks(repo: Path) -> list[Path]:
+    """Every active change's tasks.md. Archived changes are deliberately absent.
+
+    An archived task records what was true when it ran; a scenario renamed
+    afterwards does not make that record wrong, and turning history red for it
+    tells a reader nothing they can act on.
+    """
+    changes = repo / "openspec" / "changes"
+    archive = changes / "archive"
+    # The walk finds archived changes and the filter is what drops them, rather
+    # than a glob depth that happens not to reach them. A depth that excludes by
+    # accident passes every test aimed at the exclusion, including one aimed at
+    # it on purpose.
+    return sorted(
+        path for path in changes.rglob("tasks.md") if archive not in path.parents
+    )
+
+
+def validate_authored_scenario_names_scenario() -> int:
+    """Issue #51: a check whose scenario name is not registered cannot run.
+
+    Three of the four authored contracts #51 records named something that did
+    not exist, two of them scenario names, both written as an `M5 (regression)`
+    check asserting that named scenarios stay green, and both found only when
+    the check was executed. A fifth, unrecorded there, is
+    `2026-08-01-the-name-is-not-the-thing/tasks.md:132`, which declares
+    `tasks-template-validates` — a name `git log -S` finds at no commit — and
+    records that check as passing.
+
+    The assertions live on synthetic content with a known name set, because the
+    live scan reads whatever the working tree holds and is normally empty: a
+    change is archived when it closes. The temp-repository half is the positive
+    control for the whole path, so a run that passes because the file selection
+    silently found nothing is distinguishable from one that verified something.
+    """
+    registered = {name for name, _ in SCENARIOS}
+    known = {"core-gates", "cli"}
+    authored = (
+        "# Tasks\n"
+        "\n"
+        "- [ ] 1.1 Do the thing\n"
+        "  - Touch:\n"
+        "    - src/thing.js\n"
+        "  - Verify:\n"
+        "    - Strategy: vertical-tdd\n"
+        "    - M1: `node scripts/run_python.js scripts/validate_plugin.py "
+        "--scenario gate-diagnostics` passes\n"
+        "    - M2 (regression): `core-gates` and `target-surface-doctor` stay "
+        "green\n"
+        "    - M3 (regression): `task-start`, `keel-review-checklist`, "
+        "`contract-drift`, `subagent-stop`, and `keel-task-capsule` are "
+        "unchanged\n"
+        "    - M4: `cli` and "
+        "`node scripts/run_python.js scripts/validate_plugin.py "
+        "--scenario core-gates` stay green\n"
+        "  - Evidence:\n"
+        "    - M2: `target-surface-doctor` stays green\n"
+    )
+    found = unregistered_scenario_references(authored, known)
+    expected = [
+        (8, "gate-diagnostics", "--scenario"),
+        (9, "target-surface-doctor", "stays green"),
+    ]
+    if found != expected:
+        report(
+            "authored-scenario-names-are-registered: the recognized forms did "
+            f"not report what they must. expected {expected}, found {found}."
+        )
+        report(AUTHORED_SCENARIO_FORMS)
+        return 1
+
+    # Which files are read is a separate question from what is read out of
+    # them, and it is the half that can silently resolve to nothing. The
+    # planted reference is the positive control for the whole path: an
+    # extractor that stopped reporting, or a selection that stopped finding,
+    # both fail here rather than passing on an empty scan.
+    with tempfile.TemporaryDirectory(prefix="keel-authored-names-") as raw:
+        repo = Path(raw)
+        write_text(repo / "openspec/changes/live/tasks.md", authored)
+        write_text(repo / "openspec/changes/archive/old/tasks.md", authored)
+        selected = active_change_tasks(repo)
+        if selected != [repo / "openspec/changes/live/tasks.md"]:
+            report(
+                "authored-scenario-names-are-registered: the active change "
+                "selection is wrong. An archived tasks.md must not be scanned "
+                "and an active one must be. "
+                f"selected {[str(path) for path in selected]}."
+            )
+            return 1
+        control = [
+            (path, unregistered_scenario_references(
+                path.read_text(encoding="utf-8"), known
+            ))
+            for path in selected
+        ]
+        if [problems for _, problems in control] != [expected]:
+            report(
+                "authored-scenario-names-are-registered: a planted reference "
+                "in an active change was not reported end to end, so a clean "
+                "run over the real tree would prove nothing. "
+                f"found {control}."
+            )
+            return 1
+
+    for path in active_change_tasks(ROOT):
+        problems = unregistered_scenario_references(
+            path.read_text(encoding="utf-8"), registered
+        )
+        if not problems:
+            continue
+        relative = path.relative_to(ROOT).as_posix()
+        for line_number, name, form in problems:
+            report(
+                f"authored-scenario-names-are-registered: {relative}:"
+                f"{line_number} names `{name}` after {form}, and no scenario by "
+                "that name is registered, so the check that names it cannot run."
+            )
+        report(AUTHORED_SCENARIO_FORMS)
+        return 1
+
+    if "authored-scenario-names-are-registered" not in {
+        name for name, _ in SCENARIOS
+    }:
+        report(
+            "authored-scenario-names-are-registered: the scenario registry "
+            "does not include it."
+        )
+        return 1
+    report("authored-scenario-names-are-registered scenario passed.")
+    return 0
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
@@ -20113,6 +22985,10 @@ SCENARIOS: tuple = (
     ("target-surface", validate_target_surface_scenario),
     ("thin-native-install", validate_thin_native_install_scenario),
     ("expectation-slice-gates", validate_expectation_slice_gates_scenario),
+    (
+        "unparsed-covers-critical-statement",
+        validate_unparsed_covers_critical_statement_scenario,
+    ),
     ("expectation-completion-gates", validate_expectation_completion_gates_scenario),
     ("authoring-continuity", validate_authoring_continuity_scenario),
     ("domain-lenses", validate_domain_lenses_scenario),
@@ -20121,8 +22997,16 @@ SCENARIOS: tuple = (
     ("sync-surface-overlay", validate_sync_surface_overlay_scenario),
     ("openspec-surface-overlay", validate_openspec_surface_overlay_scenario),
     ("uninstall", validate_uninstall_scenario),
+    (
+        "uninstall-removes-the-overlay",
+        validate_uninstall_removes_the_overlay_scenario,
+    ),
     ("cli", validate_cli_scenario),
     ("doctor-openspec-honesty", validate_doctor_openspec_honesty_scenario),
+    (
+        "authored-scenario-names-are-registered",
+        validate_authored_scenario_names_scenario,
+    ),
     ("update-pack-install", validate_update_pack_install_scenario),
     ("update-default-registry", validate_update_default_registry_scenario),
     ("verification-layering-docs", validate_verification_layering_docs_scenario),
@@ -20130,6 +23014,10 @@ SCENARIOS: tuple = (
         "standing-authorization-declaration",
         validate_standing_authorization_declaration_scenario,
     ),
+    (
+        "standing-authorization-sync-confusion",
+        validate_standing_authorization_sync_confusion_scenario,
+    ),
     (
         "standing-authorization-inheritance",
         validate_standing_authorization_inheritance_scenario,
@@ -20145,6 +23033,10 @@ SCENARIOS: tuple = (
     ("precedent-never-weakens", validate_precedent_never_weakens_scenario),
     ("precedent-rules", validate_precedent_rules_scenario),
     ("triage-declaration", validate_triage_declaration_scenario),
+    (
+        "triage-admits-from-the-repository",
+        validate_triage_admits_from_the_repository_scenario,
+    ),
     ("delegation-declaration", validate_delegation_declaration_scenario),
     ("delegation-inheritance", validate_delegation_inheritance_scenario),
     ("native-capability-scope", validate_native_capability_scope_scenario),
@@ -20175,6 +23067,10 @@ SCENARIOS: tuple = (
     ),
     ("inline-code-is-concrete", validate_inline_code_is_concrete_scenario),
     ("covers-separator-collision", validate_covers_separator_collision_scenario),
+    (
+        "unresolved-covers-names-what-failed",
+        validate_unresolved_covers_names_what_failed_scenario,
+    ),
     (
         "unresolved-authority-names-field",
         validate_unresolved_authority_names_field_scenario,
@@ -20251,12 +23147,20 @@ SCENARIOS: tuple = (
     ("tracker-durable-owner", validate_tracker_durable_owner_scenario),
     ("findings-resolved-here", validate_findings_resolved_here_scenario),
     ("guard-stale-manifest", validate_guard_stale_manifest_scenario),
+    (
+        "guard-status-stale-manifest",
+        validate_guard_status_stale_manifest_scenario,
+    ),
     ("assertion-shape-count", validate_assertion_shape_count_scenario),
     ("guard-manifest-ignored", validate_guard_manifest_ignored_scenario),
     (
         "guard-status-is-not-enforcement",
         validate_guard_status_is_not_enforcement_scenario,
     ),
+    (
+        "guard-warnings-are-concise",
+        validate_guard_warnings_are_concise_scenario,
+    ),
     ("source-repo-cli-resolution", validate_source_repo_cli_resolution_scenario),
     ("task-contract-core", validate_task_contract_core_scenario),
     ("task-capsule", validate_task_capsule_scenario),
@@ -20332,7 +23236,19 @@ SCENARIOS: tuple = (
         "decimal-runs-are-not-hash-shaped",
         validate_decimal_runs_are_not_hash_shaped_scenario,
     ),
+    ("a-context-word-is-a-word", validate_a_context_word_is_a_word_scenario),
+    (
+        "a-covers-citation-is-not-a-record",
+        validate_a_covers_citation_is_not_a_record_scenario,
+    ),
     ("validation-runner", validate_validation_runner_scenario),
+    ("section-boundary", validate_section_boundary_scenario),
+    ("review-entry-extent", validate_review_entry_extent_scenario),
+    ("reauthorizations-shape", validate_reauthorizations_shape_scenario),
+    (
+        "change-verify-deferred-evidence",
+        validate_change_verify_deferred_evidence_scenario,
+    ),
 )