@christang/keel 5.39.0 → 5.44.0

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.39.0"
-PROTOCOL_VERSION = "5.39.0"
+PACKAGE_VERSION = "5.44.0"
+PROTOCOL_VERSION = "5.44.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
@@ -1656,10 +1656,12 @@ def validate_unparsed_covers_critical_statement_scenario() -> int:
 
     with tempfile.TemporaryDirectory(prefix="keel-unparsed-covers-unparsed-") as raw:
         repo = Path(raw)
+        # A colon after the identifier stays outside the accepted shapes now
+        # that bullet and bold wrapping resolve (issue #49, owner-decided).
         write_text(
             repo / "openspec/changes/demo/design.md",
             "## Decisions\n\n"
-            "- **D2** — Keep one shared parser. Basis: fixture authority.\n",
+            "D2: Keep one shared parser. Basis: fixture authority.\n",
         )
         returncode, message = covers_message(repo)
         if returncode == 0:
@@ -1723,6 +1725,250 @@ def validate_unparsed_covers_critical_statement_scenario() -> int:
     return 0
 
 
+def validate_widened_critical_statement_shapes_scenario() -> int:
+    """Issue #49 Section 1, owner-decided 2026-08-17: criticalAuthority() must
+    resolve a design.md critical-statement line in the shapes authors actually
+    write — bulleted, bold-wrapped, or both — not only the bare line shape,
+    while a reference matching more than one line still fails as duplicated and
+    a still-unaccepted shape reports Unparsed naming the accepted shapes.
+    """
+    task = task_capsule_compact_fixture().replace(
+        "    - E1: Public behavior passes.\n",
+        "    - D2\n",
+    )
+
+    def start(repo: Path) -> subprocess.CompletedProcess[str]:
+        write_text(repo / "openspec/changes/demo/tasks.md", task)
+        return run_keel(
+            repo, "gate", "task-start", "--change", "demo", "--task", "1.1", "--json"
+        )
+
+    accepted_shapes = [
+        "- D2 — Keep one shared parser.",
+        "**D2** — Keep one shared parser.",
+        "- **D2** — Keep one shared parser.",
+        "* D2 — Keep one shared parser.",
+        "+ D2 — Keep one shared parser.",
+    ]
+    for shape in accepted_shapes:
+        with tempfile.TemporaryDirectory(prefix="keel-widened-shape-") as raw:
+            repo = Path(raw)
+            write_text(
+                repo / "openspec/changes/demo/design.md",
+                f"## Decisions\n\n{shape}\n",
+            )
+            result = start(repo)
+            if result.returncode != 0:
+                report(
+                    f"widened-critical-statement-shapes: the shape {shape!r} "
+                    f"must resolve, got exit {result.returncode}: "
+                    f"{(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"
+                and item.get("text") == "Keep one shared parser."
+                for item in authority
+            ):
+                report(
+                    f"widened-critical-statement-shapes: the shape {shape!r} "
+                    "must resolve as critical-statement authority carrying the "
+                    "statement text."
+                )
+                return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-widened-duplicate-") as raw:
+        repo = Path(raw)
+        write_text(
+            repo / "openspec/changes/demo/design.md",
+            "## Decisions\n\nD2 — Keep one shared parser.\n\n"
+            "- D2 — Keep one shared parser.\n",
+        )
+        result = start(repo)
+        problems = json.loads(result.stdout).get("problems", [])
+        if result.returncode == 0 or not any(
+            item.get("code") == "ambiguous-covers"
+            and item.get("message", "").startswith(
+                "Duplicated Covers critical statement: D2."
+            )
+            for item in problems
+        ):
+            report(
+                "widened-critical-statement-shapes: the same identifier in "
+                "two accepted shapes must fail as duplicated."
+            )
+            return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-widened-unparsed-") as raw:
+        repo = Path(raw)
+        write_text(
+            repo / "openspec/changes/demo/design.md",
+            "## Decisions\n\nD2: Keep one shared parser.\n",
+        )
+        result = start(repo)
+        problems = json.loads(result.stdout).get("problems", [])
+        message = next(
+            (
+                item.get("message", "")
+                for item in problems
+                if item.get("code") == "unresolved-covers"
+            ),
+            "",
+        )
+        if result.returncode == 0 or not message.startswith(
+            "Unparsed Covers critical statement: D2."
+        ):
+            report(
+                "widened-critical-statement-shapes: a colon line must still "
+                f"report Unparsed, got: {message!r}"
+            )
+            return 1
+        if "- D2 — " not in message or "**D2** — " not in message:
+            report(
+                "widened-critical-statement-shapes: the Unparsed message must "
+                f"name the bulleted and bold shapes as accepted, got: {message!r}"
+            )
+            return 1
+
+    if "widened-critical-statement-shapes" not in {name for name, _ in SCENARIOS}:
+        report(
+            "widened-critical-statement-shapes: the scenario registry does not "
+            "include it."
+        )
+        return 1
+    report("widened-critical-statement-shapes scenario passed.")
+    return 0
+
+
+def validate_covers_annotation_entry_scenario() -> int:
+    """Issue #49 Section 1's fail-open half, owner-decided 2026-08-17: a Covers
+    entry that opens with a critical-statement identifier and a dash
+    (`D2 — note`) must resolve as that critical statement — failing loudly when
+    the identifier is missing from design.md — instead of silently degrading to
+    an unlinked legacy-task-reference, while colon-form entries and hyphenated
+    free text stay free-text references.
+    """
+    design_with_d2 = "## Decisions\n\nD2 — Keep one shared parser.\n"
+
+    def start_with_covers(
+        repo: Path, covers_entry: str, design: str
+    ) -> subprocess.CompletedProcess[str]:
+        write_text(repo / "openspec/changes/demo/design.md", design)
+        write_text(
+            repo / "openspec/changes/demo/tasks.md",
+            task_capsule_compact_fixture().replace(
+                "    - E1: Public behavior passes.\n",
+                f"    - {covers_entry}\n",
+            ),
+        )
+        return run_keel(
+            repo, "gate", "task-start", "--change", "demo", "--task", "1.1", "--json"
+        )
+
+    def authority_of(result: subprocess.CompletedProcess[str]) -> list:
+        return (
+            json.loads(result.stdout)
+            .get("contract", {})
+            .get("capsule", {})
+            .get("authority", [])
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-covers-annotation-") as raw:
+        repo = Path(raw)
+        result = start_with_covers(repo, "D2 — an annotation", design_with_d2)
+        if result.returncode != 0:
+            report(
+                "covers-annotation-entry: `D2 — an annotation` with a resolvable "
+                f"D2 must pass, got exit {result.returncode}: "
+                f"{(result.stderr or result.stdout).strip()}"
+            )
+            return 1
+        authority = authority_of(result)
+        if not any(
+            item.get("reference") == "D2"
+            and item.get("kind") == "critical-statement"
+            and item.get("text") == "Keep one shared parser."
+            for item in authority
+        ):
+            report(
+                "covers-annotation-entry: `D2 — an annotation` must resolve as "
+                "critical-statement authority carrying the design.md statement "
+                f"text, got: {authority!r}"
+            )
+            return 1
+        if any("an annotation" in str(item.get("text", "")) for item in authority):
+            report(
+                "covers-annotation-entry: the annotation must not become "
+                "authority text; design.md owns the statement."
+            )
+            return 1
+
+    with tempfile.TemporaryDirectory(prefix="keel-covers-annotation-missing-") as raw:
+        repo = Path(raw)
+        result = start_with_covers(
+            repo,
+            "D2 — an annotation",
+            "## Decisions\n\nD1 — Unrelated decision. Basis: fixture authority.\n",
+        )
+        problems = json.loads(result.stdout).get("problems", [])
+        message = next(
+            (
+                item.get("message", "")
+                for item in problems
+                if item.get("code") == "unresolved-covers"
+            ),
+            "",
+        )
+        if result.returncode == 0 or not message.startswith(
+            "Missing Covers critical statement: D2."
+        ):
+            report(
+                "covers-annotation-entry: `D2 — an annotation` with no D2 in "
+                "design.md must fail as Missing instead of passing as an "
+                f"unlinked reference, got exit {result.returncode}: {message!r}"
+            )
+            return 1
+
+    for covers_entry in ("E1: Public behavior passes.", "D2-compatible fixture text"):
+        with tempfile.TemporaryDirectory(prefix="keel-covers-annotation-free-") as raw:
+            repo = Path(raw)
+            result = start_with_covers(repo, covers_entry, design_with_d2)
+            if result.returncode != 0:
+                report(
+                    f"covers-annotation-entry: {covers_entry!r} must stay a "
+                    "passing free-text reference, got exit "
+                    f"{result.returncode}: "
+                    f"{(result.stderr or result.stdout).strip()}"
+                )
+                return 1
+            authority = authority_of(result)
+            if not any(
+                item.get("kind") == "legacy-task-reference" for item in authority
+            ) or any(
+                item.get("kind") == "critical-statement" for item in authority
+            ):
+                report(
+                    f"covers-annotation-entry: {covers_entry!r} must remain a "
+                    f"legacy-task-reference, got: {authority!r}"
+                )
+                return 1
+
+    if "covers-annotation-entry" not in {name for name, _ in SCENARIOS}:
+        report(
+            "covers-annotation-entry: the scenario registry does not include it."
+        )
+        return 1
+    report("covers-annotation-entry scenario passed.")
+    return 0
+
+
 def validate_expectation_completion_gates_scenario() -> int:
     protocol_snippets = [
         "Completion Gate",
@@ -4866,6 +5112,359 @@ def validate_authoring_surface_owner_and_tags_scenario() -> int:
     return 0
 
 
+def validate_the_spec_names_the_managed_set_scenario() -> int:
+    """Issue #86: the spec's summary named two of the four actions it covers.
+
+    `propose` and `sync` joined the managed set as new requirements appended to
+    the overlay spec, and the `## Purpose` and the requirement that says which
+    actions carry an overlay were never rewritten — so the top of the file
+    disagreed with the requirements below it.
+
+    The Purpose line survived issue #79's sweep for a structural reason:
+    OpenSpec's delta operations are Requirement-scoped, so no change can carry
+    a Purpose edit, and the line is written once when the capability is
+    created. It is therefore the location most likely to drift and the one
+    least likely to be noticed, which is why it is checked by name here.
+
+    Two named locations, not a scan. Three statements in the published specs
+    name a proper subset of the managed set and are correct — the doctor's
+    command-surface label, which excludes the authoring action on purpose;
+    `sync/archive decisions`, which names what the current agent owns; and
+    `authoring/apply/archive/sync`, which spells `propose` as authoring. A
+    check that refused those would cost more than the drift it catches.
+    """
+    label = "the-spec-names-the-managed-set"
+
+    source = (ROOT / "bin" / "keel.js").read_text(encoding="utf-8")
+    declaration = re.search(
+        r"const OPENSPEC_OVERLAY_ACTIONS = \[([^\]]*)\];", source
+    )
+    if declaration is None:
+        report(
+            f"{label}: bin/keel.js declares no OPENSPEC_OVERLAY_ACTIONS, so the "
+            "check has no managed set to compare against. Restating the set "
+            "here would be the same defect one layer out."
+        )
+        return 1
+    managed = re.findall(r'"([a-z]+)"', declaration.group(1))
+    if not managed:
+        report(f"{label}: OPENSPEC_OVERLAY_ACTIONS parsed to an empty set.")
+        return 1
+
+    spec_path = ROOT / "openspec/specs/keel-openspec-surface-overlay/spec.md"
+    REQUIREMENT = "### Requirement: Keel overlays every action in the managed set"
+
+    def locations(text: str) -> tuple[str, str] | None:
+        purpose = re.search(r"^## Purpose\s*\n+(.+?)\n", text, re.M)
+        if purpose is None:
+            return None
+        start = text.find(REQUIREMENT)
+        if start < 0:
+            return None
+        end = text.find("\n### Requirement:", start + len(REQUIREMENT))
+        body = text[start : end if end > 0 else len(text)]
+        return purpose.group(1), body
+
+    # Two distinct failures, kept apart on purpose: a location the check
+    # cannot find is not a location that names the wrong thing, and reporting
+    # the second when the first happened sends the reader to a paragraph with
+    # nothing wrong in it.
+    NOT_FOUND = "__not-found__"
+
+    def missing(text: str) -> list[tuple[str, list[str]]]:
+        found = locations(text)
+        if found is None:
+            return [(NOT_FOUND, list(managed))]
+        purpose, body = found
+        gaps = []
+        for name, region in (("## Purpose", purpose), (REQUIREMENT, body)):
+            absent = [
+                action for action in managed
+                if not re.search(rf"\b{action}\b", region)
+            ]
+            if absent:
+                gaps.append((name, absent))
+        return gaps
+
+    published = spec_path.read_text(encoding="utf-8")
+    gaps = missing(published)
+    if gaps:
+        for name, absent in gaps:
+            if name == NOT_FOUND:
+                report(
+                    f"{label}: keel-openspec-surface-overlay has no `## Purpose` "
+                    f"line or no `{REQUIREMENT}` heading, so this check found "
+                    "nothing to compare against the managed set. Nothing about "
+                    "the action names is being reported here — the location is "
+                    "what is missing."
+                )
+                continue
+            report(
+                f"{label}: the `{name}` of keel-openspec-surface-overlay does "
+                f"not name {', '.join(absent)}, which bin/keel.js manages an "
+                "overlay for. The file's summary and the requirements under it "
+                "disagree, and a reader takes the summary."
+            )
+        return 1
+
+    # The check fails on a drifted copy, and names the location that drifted.
+    drifted = published.replace(
+        REQUIREMENT, "### Requirement: Keel overlays apply and archive surfaces", 1
+    )
+    if missing(drifted) == []:
+        report(
+            f"{label}: a copy whose requirement heading is gone was reported "
+            "clean. A check that cannot find what it looks for must fail, not "
+            "pass — a vacuous pass is how the drift got here."
+        )
+        return 1
+
+    for action in managed:
+        reduced = published
+        found = locations(published)
+        assert found is not None
+        purpose_line = found[0]
+        reduced = reduced.replace(
+            purpose_line, re.sub(rf"\b{action}\b[,/ ]*", "", purpose_line), 1
+        )
+        gaps = missing(reduced)
+        if not any(name == "## Purpose" and action in absent for name, absent in gaps):
+            report(
+                f"{label}: the Purpose line with `{action}` removed was not "
+                "reported. Each managed action is checked on its own, so an "
+                "action that joins the set later is not covered by the others."
+            )
+            return 1
+
+    # The three subset spellings that are correct stay correct: the check is
+    # two named locations in one file, not a scan for action words.
+    diagnostics = (
+        ROOT / "openspec/specs/keel-target-surface-diagnostics/spec.md"
+    ).read_text(encoding="utf-8")
+    for correct in (
+        "apply/archive/sync overlay markers",
+        "it names sync alongside apply and archive",
+    ):
+        if correct not in diagnostics:
+            report(
+                f"{label}: the diagnostics spec no longer carries the correct "
+                f"subset spelling `{correct}`. This scenario asserts the check "
+                "leaves it alone; if the wording moved, the assertion has to "
+                "move with it rather than be dropped."
+            )
+            return 1
+    if "sync/archive decisions" not in published:
+        report(
+            f"{label}: the overlay spec no longer carries `sync/archive "
+            "decisions`, the third correct subset spelling this check must "
+            "not refuse."
+        )
+        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_an_owner_outlives_the_change_scenario() -> int:
+    """Issue #100: the existence check expires at archive.
+
+    `openspec archive` moves `openspec/changes/<name>/` under
+    `openspec/changes/archive/`, so a `Durable owner:` naming the change's own
+    `design.md` is true when the gate reads it and false one workflow step
+    later. Measured in this repository: 10 declarations name a path inside a
+    live change directory, all 10 are dead, and all 10 point at the change that
+    wrote them. A pointer that must break is worse than none — the Review reads
+    as closed while the trail ends halfway.
+
+    A path into a *different* live change stays accepted: the protocol names a
+    new OpenSpec change as a legitimate owner of deferred work, and no measured
+    pointer has that shape.
+    """
+    label = "an-owner-outlives-the-change"
+
+    with tempfile.TemporaryDirectory(prefix="keel-owner-outlives-") as raw_tmp:
+        repo = Path(raw_tmp) / "repo"
+        repo.mkdir()
+        tasks_path = repo / "openspec/changes/demo/tasks.md"
+        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",
+        )
+        # The other live change, and an archived path. Both exist; only one of
+        # them is the directory the selected change is about to move.
+        write_text(repo / "openspec/changes/other/design.md", "## Context\n\nother\n")
+        write_text(repo / "keel/archive/notes/2026-09-05-example.md", "note\n")
+
+        SELF = "openspec/changes/demo/design.md"
+        OTHER = "openspec/changes/other/design.md"
+        ARCHIVED = "keel/archive/notes/2026-09-05-example.md"
+        TRACKER = "https://github.com/TanglmChris/keel/issues/100"
+
+        def start(section: str) -> dict:
+            fixture = task_contract_fixture()
+            if section.startswith("## Invalidates"):
+                fixture = fixture.replace("## Invalidates\n\n- None.\n\n", section)
+            else:
+                fixture = fixture + "\n" + section
+            write_text(tasks_path, fixture)
+            result = run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--json",
+            )
+            return json.loads(result.stdout)
+
+        def invalidates(closure: str) -> dict:
+            return start(
+                '## Invalidates\n\n- I1: "the wording that is now wrong" '
+                f"— somewhere in the repo. {closure}\n\n"
+            )
+
+        # `## Expectation Coverage` is read by change-close, not task-start, so
+        # this fixture closes the change rather than starting a task. Mirrors
+        # the `durable-owner-vocabulary` scenario's own closing fixture.
+        def expectation(closure: str) -> dict:
+            write_text(
+                tasks_path,
+                task_contract_fixture(evidence=("M1: check exercised.",))
+                .replace("- [ ] 1.1", "- [x] 1.1")
+                .replace("      - Status: pending\n", "      - Status: pass\n")
+                .replace(
+                    "      - Acceptance check: pending\n",
+                    "      - Acceptance check: proven.\n",
+                )
+                .replace(
+                    "      - Scope check: pending\n",
+                    "      - Scope check: inside Touch.\n",
+                )
+                .replace("      - Findings: pending\n", "      - Findings: none\n")
+                + f"\n## Expectation Coverage\n\n- E1: the expectation. {closure}\n",
+            )
+            record_contract_anchor(repo, "demo")
+            result = run_keel(
+                repo, "gate", "change-close", "--change", "demo", "--action",
+                "sync", "--json",
+            )
+            return json.loads(result.stdout)
+
+        def completion(findings: str) -> dict:
+            fixture = (
+                task_contract_fixture(evidence=("M1: check exercised.",))
+                .replace("- [ ] 1.1", "- [x] 1.1")
+                .replace("      - Status: pending\n", "      - Status: pass\n")
+                .replace(
+                    "      - Acceptance check: pending\n",
+                    "      - Acceptance check: behavior proven through the public CLI.\n",
+                )
+                .replace(
+                    "      - Scope check: pending\n",
+                    "      - Scope check: writes stayed inside Touch.\n",
+                )
+                .replace("      - Findings: pending\n", f"      - Findings: {findings}\n")
+            )
+            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 messages(payload: dict) -> str:
+            return " ".join(
+                item.get("message", "") for item in payload.get("problems", [])
+            )
+
+        # The self-pointer is refused wherever an owner closes an entry, and
+        # the refusal says why rather than reporting a spelling problem.
+        refusals = (
+            ("an Invalidates entry", invalidates(f"Durable owner: {SELF}")),
+            ("an Expectation Coverage entry", expectation(f"Durable owner: {SELF}")),
+            (
+                "a Review finding",
+                completion(f"the rule needs a second look. Durable owner: {SELF}"),
+            ),
+            (
+                "a Resolved here claim",
+                completion(f"the rule was repaired. Resolved here: {SELF}"),
+            ),
+        )
+        for description, payload in refusals:
+            if payload.get("status") == "pass":
+                report(
+                    f"{label}: a path inside the selected change's own directory "
+                    f"closed {description}. That directory moves when the change "
+                    "is archived, so the check was true only until the next step "
+                    "of the workflow that accepted it."
+                )
+                return 1
+            text = messages(payload)
+            if "archiv" not in text.lower():
+                report(
+                    f"{label}: the refusal for {description} does not say the "
+                    "directory moves when the change is archived, so it reads as "
+                    "a spelling problem the author cannot repair. Got: "
+                    f"{text or '(none)'}"
+                )
+                return 1
+
+        # A different live change is a legitimate owner and stays one, as do
+        # the forms that already worked.
+        accepted = (
+            ("another live change closing an Invalidates entry",
+             invalidates(f"Durable owner: {OTHER}")),
+            ("another live change closing an Expectation Coverage entry",
+             expectation(f"Durable owner: {OTHER}")),
+            ("another live change owning a finding",
+             completion(f"still open. Durable owner: {OTHER}")),
+            ("resolution evidence in another live change",
+             completion(f"repaired. Resolved here: {OTHER}")),
+            ("an archived path owning a finding",
+             completion(f"still open. Durable owner: {ARCHIVED}")),
+            ("a tracker reference owning a finding",
+             completion(f"still open. Durable owner: {TRACKER}")),
+        )
+        for description, payload in accepted:
+            if payload.get("status") != "pass":
+                report(
+                    f"{label}: {description} was refused. The rule is about the "
+                    "directory this change is about to move, not about change "
+                    "directories in general."
+                )
+                report(json.dumps(payload.get("problems", []), indent=2))
+                return 1
+
+        # Every refusal that lists the forms says what checking each is worth.
+        for description, payload in (
+            ("an Invalidates refusal", invalidates("no closure at all")),
+            ("an Expectation Coverage refusal", expectation("no closure at all")),
+            ("a Findings refusal", completion("a narrative finding with no marker")),
+        ):
+            text = messages(payload)
+            for expected in (
+                "checked for existence when it is cited",
+                "never fetches",
+            ):
+                if expected not in text:
+                    report(
+                        f"{label}: {description} does not say what the accepted "
+                        f"forms are worth — missing: {expected}. An author who "
+                        "cannot see what was checked infers that it was."
+                    )
+                    report(text or "(none)")
+                    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_durable_owner_vocabulary_scenario() -> int:
     label = "durable-owner-vocabulary"
 
@@ -5003,14 +5602,18 @@ def validate_durable_owner_vocabulary_scenario() -> int:
                 report(messages)
                 return 1
 
-        # M3 — every previously accepted form still closes.
+        # M3 — every previously accepted form still closes. The change artifact
+        # names another live change: a path inside `demo`'s own directory is
+        # refused now, because that directory moves when `demo` is archived.
         for closure in (
-            "Durable owner: openspec/changes/demo/proposal.md",
+            "Durable owner: openspec/changes/other-change/proposal.md",
             "Durable owner: keel/archive/notes/2026-07-28-example.md",
             "Durable owner: https://github.com/TanglmChris/keel/issues/20",
             "Discard reason: it stands as written.",
         ):
-            write_text(repo / "openspec/changes/demo/proposal.md", "# Proposal\n")
+            write_text(
+                repo / "openspec/changes/other-change/proposal.md", "# Proposal\n"
+            )
             payload = invalidation_start(closure)
             if payload.get("status") != "pass":
                 report(f"{label} dropped a previously accepted form: {closure}")
@@ -10031,7 +10634,11 @@ def validate_review_entry_extent_scenario() -> int:
     one entry cannot be satisfied by another's text.
     """
     label = "review-entry-extent"
-    owner_path = "openspec/changes/demo/tasks.md"
+    # Outside the selected change's own directory on purpose: a path under
+    # `openspec/changes/demo/` is refused as a durable owner because that
+    # directory moves at archive, and this scenario is about how far a wrapped
+    # Findings entry extends, not about which owner forms are accepted.
+    owner_path = "openspec/FOLLOWUP.md"
 
     with tempfile.TemporaryDirectory(
         prefix="keel-review-extent-", ignore_cleanup_errors=True
@@ -10039,6 +10646,7 @@ def validate_review_entry_extent_scenario() -> int:
         repo = Path(raw)
         tasks = repo / "openspec/changes/demo/tasks.md"
         write_text(repo / "openspec/changes/demo/proposal.md", "# Proposal\n")
+        write_text(repo / owner_path, "# Follow-ups\n")
         write_text(
             repo / "openspec/changes/demo/specs/demo/spec.md",
             "## ADDED Requirements\n",
@@ -15556,7 +16164,13 @@ def validate_verification_layering_docs_scenario() -> int:
     return 0
 
 
-STANDING_AUTHORIZATION_ACTIONS = ("commit", "push", "release", "archive")
+STANDING_AUTHORIZATION_ACTIONS = (
+    "commit",
+    "push",
+    "release",
+    "archive",
+    "continuation",
+)
 
 
 def write_authorize_config(repo: Path, body: str) -> None:
@@ -15588,7 +16202,11 @@ def validate_standing_authorization_declaration_scenario() -> int:
                 report(f"standing-authorization: declared action not reported: {needle}")
                 report(out)
                 return 1
-        for needle in ("release: not authorized", "archive: not authorized"):
+        for needle in (
+            "release: not authorized",
+            "archive: not authorized",
+            "continuation: not authorized",
+        ):
             if needle not in out:
                 report(f"standing-authorization: undeclared action not reported: {needle}")
                 report(out)
@@ -18030,84 +18648,264 @@ def validate_standing_authorization_never_weakens_scenario() -> int:
             ),
         }
 
-    def pair(root: Path, name: str, tasks: str) -> tuple[Path, Path]:
-        authorizing = root / f"{name}-authorizing"
-        authorizing.mkdir()
-        write_gate_fixture(authorizing, tasks)
+    def pair(root: Path, name: str, tasks: str) -> tuple[Path, Path]:
+        authorizing = root / f"{name}-authorizing"
+        authorizing.mkdir()
+        write_gate_fixture(authorizing, tasks)
+        write_authorize_config(
+            authorizing,
+            "authorize:\n  - commit\n  - push\n  - release\n  - archive\n"
+            "  - continuation\n",
+        )
+        silent = root / f"{name}-silent"
+        silent.mkdir()
+        write_gate_fixture(silent, tasks)
+        # Positive control. Every check below compares these two repositories
+        # and passes when they agree, so a declaration that silently failed to
+        # reach the capsule would make each comparison trivially true and prove
+        # nothing. Assert the difference exists before asserting it is inert.
+        live = standing_authorization_autonomy(authorizing) or []
+        inert = standing_authorization_autonomy(silent) or []
+        if not any("keel/config.yaml" in entry for entry in live):
+            report(
+                f"standing-authorization-inert: the {name} authorizing fixture "
+                f"never actually authorized anything: {live}"
+            )
+            raise AssertionError("authorizing fixture is not authorizing")
+        if any("keel/config.yaml" in entry for entry in inert):
+            report(
+                f"standing-authorization-inert: the {name} silent fixture "
+                f"declared something: {inert}"
+            )
+            raise AssertionError("silent fixture is not silent")
+        return authorizing, silent
+
+    with tempfile.TemporaryDirectory(prefix="keel-authinert-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — completion returns the same status and problem set either way.
+        authorizing, silent = pair(root, "complete", complete_task)
+        for repo in (authorizing, silent):
+            if gate_result(repo, "task-start") is None:
+                report("standing-authorization-inert: task-start produced no JSON.")
+                return 1
+        authorized_result = gate_result(authorizing, "task-complete")
+        silent_result = gate_result(silent, "task-complete")
+        if authorized_result is None or silent_result is None:
+            report("standing-authorization-inert: task-complete produced no JSON.")
+            return 1
+        if authorized_result != silent_result:
+            report(
+                "standing-authorization-inert: a declaration changed the "
+                f"completion gate result: {authorized_result} != {silent_result}"
+            )
+            return 1
+
+        # M2 — a repo authorizing every action still fails for missing evidence,
+        # with unchanged failure text.
+        authorizing, silent = pair(root, "missing", missing_evidence_task)
+        for repo in (authorizing, silent):
+            if gate_result(repo, "task-start") is None:
+                report("standing-authorization-inert: task-start produced no JSON.")
+                return 1
+        authorized_result = gate_result(authorizing, "task-complete")
+        silent_result = gate_result(silent, "task-complete")
+        if authorized_result is None or silent_result is None:
+            report("standing-authorization-inert: task-complete produced no JSON.")
+            return 1
+        if authorized_result.get("status") == "pass":
+            report(
+                "standing-authorization-inert: authorizing every action let a "
+                "task with missing evidence pass completion."
+            )
+            return 1
+        if authorized_result != silent_result:
+            report(
+                "standing-authorization-inert: a declaration changed the failure "
+                f"text: {authorized_result} != {silent_result}"
+            )
+            return 1
+
+        # M3 — a declaration selects nothing and starts nothing.
+        def continuity(repo: Path) -> dict | None:
+            result = run_keel(repo, "context", "--json")
+            try:
+                payload = json.loads(result.stdout)
+            except json.JSONDecodeError:
+                return None
+            return {
+                "status": payload.get("status"),
+                "selection": payload.get("selection"),
+                "nextAction": payload.get("nextAction"),
+            }
+
+        authorizing, silent = pair(root, "context", complete_task)
+        authorized_context = continuity(authorizing)
+        silent_context = continuity(silent)
+        if authorized_context is None or silent_context is None:
+            report("standing-authorization-inert: keel context produced no JSON.")
+            return 1
+        if authorized_context != silent_context:
+            report(
+                "standing-authorization-inert: a declaration changed continuity "
+                f"selection: {authorized_context} != {silent_context}"
+            )
+            return 1
+
+    report("standing-authorization-never-weakens scenario passed.")
+    return 0
+
+
+def validate_continuation_authorization_scenario() -> int:
+    """`continuation` gives the between-task approval a durable home (#94).
+
+    The fifth vocabulary name has the same nature as the four before it:
+    declared, it authorizes and an inheriting capsule names its source;
+    undeclared, it authorizes nothing; and the declaration stays inert to
+    every gate result and to continuity selection — it removes a
+    confirmation, never a proof, and it never selects the next task itself.
+    """
+    label = "continuation-authorization"
+
+    complete_task = (
+        "- [ ] 1.1 Behavior\n"
+        "  - Covers:\n"
+        "    - E1: public behavior\n"
+        "  - Touch:\n"
+        "    - src/feature.js\n"
+        "  - Verify:\n"
+        "    - Strategy: evidence-first\n"
+        "    - M1: node test.js proves the public behavior\n"
+        "  - Evidence:\n"
+        "    - Contract: pending\n"
+        "    - M1: node test.js printed ok\n"
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: reviewed\n"
+        "      - Scope check: reviewed\n"
+        "      - Findings: none\n"
+        "    - Blocker: none\n"
+    )
+
+    def gate_result(repo: Path, stage: str) -> dict | None:
+        result = run_keel(
+            repo, "gate", stage, "--change", "demo", "--task", "1.1", "--json"
+        )
+        try:
+            payload = json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return None
+        return {
+            "status": payload.get("status"),
+            "problems": sorted(
+                (problem.get("code", ""), problem.get("message", ""))
+                for problem in payload.get("problems") or []
+            ),
+        }
+
+    with tempfile.TemporaryDirectory(prefix="keel-continuation-") as raw_tmp:
+        root = Path(raw_tmp)
+
+        # M1 — declared alone, `continuation` is authorized and no repository
+        # action rides along with it: commit, push, release, and archive each
+        # still require their own name.
+        declared = root / "declared"
+        declared.mkdir()
+        write_authorize_config(declared, "authorize:\n  - continuation\n")
+        result = run_keel(declared, "--doctor")
+        if result.returncode != 0:
+            report(f"{label}: a continuation-only declaration was refused.")
+            report(result.stdout + result.stderr)
+            return 1
+        if "continuation: authorized" not in result.stdout:
+            report(f"{label}: a declared continuation was not reported authorized.")
+            report(result.stdout)
+            return 1
+        for needle in (
+            "commit: not authorized",
+            "push: not authorized",
+            "release: not authorized",
+            "archive: not authorized",
+        ):
+            if needle not in result.stdout:
+                report(f"{label}: undeclared action not reported: {needle}")
+                report(result.stdout)
+                return 1
+
+        # M1 — undeclared, it is reported beside the four exactly as any
+        # unlisted action is.
+        four = root / "four"
+        four.mkdir()
         write_authorize_config(
-            authorizing,
-            "authorize:\n  - commit\n  - push\n  - release\n  - archive\n",
+            four, "authorize:\n  - commit\n  - push\n  - release\n  - archive\n"
         )
-        silent = root / f"{name}-silent"
-        silent.mkdir()
-        write_gate_fixture(silent, tasks)
-        # Positive control. Every check below compares these two repositories
-        # and passes when they agree, so a declaration that silently failed to
-        # reach the capsule would make each comparison trivially true and prove
-        # nothing. Assert the difference exists before asserting it is inert.
-        live = standing_authorization_autonomy(authorizing) or []
-        inert = standing_authorization_autonomy(silent) or []
-        if not any("keel/config.yaml" in entry for entry in live):
+        out = run_keel(four, "--doctor").stdout
+        if "continuation: not authorized" not in out:
+            report(f"{label}: an undeclared continuation was not reported.")
+            report(out)
+            return 1
+
+        # M1 — a task that authored no boundary inherits it, the capsule names
+        # the declaration as its source, and undeclared actions keep the
+        # hard-stop default.
+        write_gate_fixture(declared, standing_authorization_task())
+        autonomy = standing_authorization_autonomy(declared)
+        if autonomy is None:
+            report(f"{label}: task-start returned no capsule autonomy.")
+            return 1
+        inherited = [entry for entry in autonomy if "continuation" in entry]
+        if not inherited:
             report(
-                f"standing-authorization-inert: the {name} authorizing fixture "
-                f"never actually authorized anything: {live}"
+                f"{label}: continuation did not reach the capsule autonomy: "
+                f"{autonomy}"
             )
-            raise AssertionError("authorizing fixture is not authorizing")
-        if any("keel/config.yaml" in entry for entry in inert):
+            return 1
+        if not any("keel/config.yaml" in entry for entry in inherited):
             report(
-                f"standing-authorization-inert: the {name} silent fixture "
-                f"declared something: {inert}"
+                f"{label}: the inherited entry does not name its source: "
+                f"{autonomy}"
             )
-            raise AssertionError("silent fixture is not silent")
-        return authorizing, silent
-
-    with tempfile.TemporaryDirectory(prefix="keel-authinert-") as raw_tmp:
-        root = Path(raw_tmp)
-
-        # M1 — completion returns the same status and problem set either way.
-        authorizing, silent = pair(root, "complete", complete_task)
-        for repo in (authorizing, silent):
-            if gate_result(repo, "task-start") is None:
-                report("standing-authorization-inert: task-start produced no JSON.")
-                return 1
-        authorized_result = gate_result(authorizing, "task-complete")
-        silent_result = gate_result(silent, "task-complete")
-        if authorized_result is None or silent_result is None:
-            report("standing-authorization-inert: task-complete produced no JSON.")
             return 1
-        if authorized_result != silent_result:
+        if not any(entry.startswith("Default: hard-stop") for entry in autonomy):
             report(
-                "standing-authorization-inert: a declaration changed the "
-                f"completion gate result: {authorized_result} != {silent_result}"
+                f"{label}: undeclared actions lost the hard-stop default: "
+                f"{autonomy}"
             )
             return 1
 
-        # M2 — a repo authorizing every action still fails for missing evidence,
-        # with unchanged failure text.
-        authorizing, silent = pair(root, "missing", missing_evidence_task)
-        for repo in (authorizing, silent):
+        # M1 — inert to gates and selection: against an otherwise identical
+        # silent repository, gate results and continuity are equal. The
+        # capsule check above is the positive control — the declaration
+        # demonstrably reached the capsule, so equality is not trivially true.
+        inert_declared = root / "inert-declared"
+        inert_declared.mkdir()
+        write_gate_fixture(inert_declared, complete_task)
+        write_authorize_config(inert_declared, "authorize:\n  - continuation\n")
+        inert_silent = root / "inert-silent"
+        inert_silent.mkdir()
+        write_gate_fixture(inert_silent, complete_task)
+        if any(
+            "keel/config.yaml" in entry
+            for entry in standing_authorization_autonomy(inert_silent) or []
+        ):
+            report(f"{label}: the silent fixture declared something.")
+            return 1
+        for repo in (inert_declared, inert_silent):
             if gate_result(repo, "task-start") is None:
-                report("standing-authorization-inert: task-start produced no JSON.")
+                report(f"{label}: task-start produced no JSON.")
                 return 1
-        authorized_result = gate_result(authorizing, "task-complete")
-        silent_result = gate_result(silent, "task-complete")
-        if authorized_result is None or silent_result is None:
-            report("standing-authorization-inert: task-complete produced no JSON.")
-            return 1
-        if authorized_result.get("status") == "pass":
-            report(
-                "standing-authorization-inert: authorizing every action let a "
-                "task with missing evidence pass completion."
-            )
+        declared_result = gate_result(inert_declared, "task-complete")
+        silent_result = gate_result(inert_silent, "task-complete")
+        if declared_result is None or silent_result is None:
+            report(f"{label}: task-complete produced no JSON.")
             return 1
-        if authorized_result != silent_result:
+        if declared_result != silent_result:
             report(
-                "standing-authorization-inert: a declaration changed the failure "
-                f"text: {authorized_result} != {silent_result}"
+                f"{label}: the declaration changed a gate result: "
+                f"{declared_result} != {silent_result}"
             )
             return 1
 
-        # M3 — a declaration selects nothing and starts nothing.
         def continuity(repo: Path) -> dict | None:
             result = run_keel(repo, "context", "--json")
             try:
@@ -18120,20 +18918,95 @@ def validate_standing_authorization_never_weakens_scenario() -> int:
                 "nextAction": payload.get("nextAction"),
             }
 
-        authorizing, silent = pair(root, "context", complete_task)
-        authorized_context = continuity(authorizing)
-        silent_context = continuity(silent)
-        if authorized_context is None or silent_context is None:
-            report("standing-authorization-inert: keel context produced no JSON.")
+        declared_context = continuity(inert_declared)
+        silent_context = continuity(inert_silent)
+        if declared_context is None or silent_context is None:
+            report(f"{label}: keel context produced no JSON.")
             return 1
-        if authorized_context != silent_context:
+        if declared_context != silent_context:
             report(
-                "standing-authorization-inert: a declaration changed continuity "
-                f"selection: {authorized_context} != {silent_context}"
+                f"{label}: the declaration changed continuity selection: "
+                f"{declared_context} != {silent_context}"
             )
             return 1
 
-    report("standing-authorization-never-weakens scenario passed.")
+    report("continuation-authorization scenario passed.")
+    return 0
+
+
+def validate_continuation_docs_scenario() -> int:
+    """Every text an agent reads at the between-task boundary names the word (#94).
+
+    The declaration only works if the boundary's readers know it exists: the
+    goal skill's stop rule is what an agent obeys at the boundary, the README
+    and the config comment are where an owner learns the vocabulary, and the
+    resident protocol is what the enforcing agent holds in context.
+    """
+    label = "continuation-docs"
+
+    src_skill = (
+        ROOT / "src/skills/keel-run-single-task-goal/SKILL.md"
+    ).read_text(encoding="utf-8")
+    plugin_skill = (
+        ROOT / "plugins/keel/skills/keel-run-single-task-goal/SKILL.md"
+    ).read_text(encoding="utf-8")
+    if src_skill != plugin_skill:
+        report(f"{label}: the src/ and plugins/ skill copies diverge.")
+        return 1
+
+    step7 = next(
+        (line for line in plugin_skill.splitlines() if line.startswith("7. ")), ""
+    )
+    if not step7.startswith("7. Stop."):
+        report(f"{label}: the goal skill lost its stop step: {step7!r}")
+        return 1
+    for needle in (
+        "standing `continuation` authorization",
+        "keel/config.yaml",
+        "next unchecked task of the same change",
+        "its own recorded fingerprint",
+        "no hidden scheduler",
+    ):
+        if needle not in step7:
+            report(f"{label}: the stop rule lacks: {needle}")
+            report(step7)
+            return 1
+
+    readme = (ROOT / "README.md").read_text(encoding="utf-8")
+    for needle in (
+        "accepted names: commit, push, release, archive, continuation",
+        "next unchecked task of the same change",
+        "the stop that re-asks for an approval already given",
+        "The five names above are the whole vocabulary.",
+    ):
+        if needle not in readme:
+            report(f"{label}: README.md lacks: {needle}")
+            return 1
+
+    config_text = (ROOT / "keel/config.yaml").read_text(encoding="utf-8")
+    if "commit, push, release, archive,\n# continuation" not in config_text:
+        report(
+            f"{label}: keel/config.yaml's comment does not name the five-name "
+            "vocabulary."
+        )
+        return 1
+
+    agents = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
+    parts = agents.split("## Execution boundary", 1)
+    if len(parts) != 2:
+        report(f"{label}: AGENTS.md lost its Execution boundary section.")
+        return 1
+    section = parts[1].split("\n## ", 1)[0]
+    for needle in (
+        "standing `continuation` authorization",
+        "next unchecked task of the same change",
+        "its own recorded fingerprint",
+    ):
+        if needle not in section:
+            report(f"{label}: AGENTS.md Execution boundary lacks: {needle}")
+            return 1
+
+    report("continuation-docs scenario passed.")
     return 0
 
 
@@ -22270,8 +23143,11 @@ def validate_decimal_runs_are_not_hash_shaped_scenario() -> int:
     )
     # The other half of the requirement: what the rule exists to refuse.
     refused_token = "- M4: pass —— 合入前的 commit a1b2c3d4e5f6 已验证。\n"
-    # Wording alone, carrying no hash-shaped token at all.
-    refused_wording = "- M5: 该任务**未提交**，等待评审。\n"
+    # Wording alone, carrying no hash-shaped token at all. The line names 分支
+    # because 提交 on its own is an ordinary verb and no longer refused (#103);
+    # what this fixture is for is the absence of a token, not the absence of
+    # context.
+    refused_wording = "- M5: 该分支**未提交**，等待评审。\n"
 
     def state_of(check) -> str:
         if "keel state: ok" in check.stdout:
@@ -22494,12 +23370,17 @@ def validate_a_context_word_is_a_word_scenario() -> int:
 
         # 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 ("已提交", "未提交", "该任务尚未提交，等待评审"):
+        # about: `\b提交\b` matches none of these. What the absence buys is
+        # the context supply below — each line holds a hash-shaped token and
+        # no other context word, so the Chinese word is the only thing that
+        # can make the token an identifier. The wording rule no longer rests
+        # on this: 提交 alone is an ordinary verb and needs a git word of its
+        # own, which `a-submission-is-not-a-commit` covers.
+        for recorded in ("已提交", "未提交", "该任务尚未提交"):
             state, _ = check(
                 "- [x] A1 implementation\n"
                 "  - Evidence:\n"
-                f"    - M1: {recorded}。\n"
+                f"    - M1: {recorded} a1b2c3d4e5f6。\n"
             )
             if state == "unreported":
                 report(
@@ -22510,12 +23391,240 @@ def validate_a_context_word_is_a_word_scenario() -> int:
                 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."
+                    f"{label}: an identifier beside `{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_submission_is_not_a_commit_scenario() -> int:
+    """Issue #103: a general Chinese verb was read as a git word.
+
+    \u63d0\u4ea4 is an ordinary transitive verb — \u63d0\u4ea4\u8d44\u6599, \u63d0\u4ea4\u5ba1\u6838, \u63d0\u4ea4\u7533\u8bf7. Matched bare, it
+    refused an Evidence line recording that a user had submitted paperwork to
+    a third-party review queue, while the same fact written in English passed
+    untouched. A check whose verdict depends on which language the author
+    wrote in is not checking what it claims to.
+
+    \u5408\u5165 is the other half and stays bare: it names the git act and has no
+    ordinary-prose reading, so requiring context for it would buy nothing.
+    """
+    label = "a-submission-is-not-a-commit"
+
+    with tempfile.TemporaryDirectory(prefix="keel-submission-") 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
+
+        def evidence(text: str) -> str:
+            return (
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                f"    - M1: {text}\n"
+            )
+
+        # The report's own line, and its English translation. Neither says
+        # anything about this repository's git state, and the check must not
+        # split them.
+        accepted = (
+            (
+                "the reported line",
+                "\u6536\u5de5\u72b6\u6001\u4e00\u5e76\u767b\u8bb0\uff1a\u7528\u6237\u5f53\u5929**\u5df2\u63d0\u4ea4**\u80fd\u586b\u7684\u5546\u6237\u4e0e\u7ed3\u7b97\u8d44\u6599\u3002",
+            ),
+            (
+                "its English translation",
+                "the user has submitted the merchant paperwork for review.",
+            ),
+            (
+                "a submission to a review queue",
+                "\u8868\u5355**\u5df2\u63d0\u4ea4**\uff0c\u5f00\u53d1\u8005\u8d26\u6237\u5904\u4e8e\u5ba1\u6838\u4e2d\u3002",
+            ),
+        )
+        for description, text in accepted:
+            state, errors = check(evidence(text))
+            if state == "unreported":
+                report(
+                    f"{label}: keel --check reported no state at all on "
+                    f"{description}."
+                )
+                return 1
+            if state != "ok":
+                report(
+                    f"{label}: {description} was refused as recorded commit "
+                    "state. Nothing on that line names git, and the same "
+                    "sentence in English is accepted — so what the check "
+                    "measured was the language, not the claim."
+                )
+                for error in errors:
+                    report(f"  {error}")
+                return 1
+
+        # What the rule exists to catch, kept refused. Each of these carries a
+        # git word, so the subject of the verb is not in doubt.
+        refused = (
+            ("beside a branch name", "1.2 \u7684\u6539\u52a8**\u5df2\u63d0\u4ea4**\u5230 main\u3002"),
+            ("beside \u5206\u652f", "\u8be5\u5206\u652f\u7684\u6539\u52a8**\u5c1a\u672a\u63d0\u4ea4**\uff0c\u7b49\u5f85\u8bc4\u5ba1\u3002"),
+            ("beside \u4ee3\u7801", "\u4ee3\u7801**\u5df2\u63d0\u4ea4**\uff0c\u6587\u6863\u672a\u52a8\u3002"),
+            ("\u5408\u5165 alone", "\u8fd9\u4e00\u6ce2**\u672a\u5408\u5165**\uff0c\u4e0b\u5468\u518d\u8bf4\u3002"),
+            ("\u5df2\u5408\u5165 alone", "\u8be5\u6539\u52a8**\u5df2\u5408\u5165**\u3002"),
+        )
+        for description, text in refused:
+            state, errors = check(evidence(text))
+            if state == "unreported":
+                report(
+                    f"{label}: keel --check reported no state at all on a "
+                    f"line {description}."
+                )
+                return 1
+            if state != "failed":
+                report(
+                    f"{label}: recorded state {description} was accepted. "
+                    "Requiring context must narrow which lines are read, not "
+                    "which words the rule knows."
+                )
+                return 1
+            if not [error for error in errors if "tasks.md:" in error]:
+                report(f"{label}: the refusal {description} named no line.")
+                return 1
+
+        # The contextual-identifier rule is untouched: a Chinese state word
+        # still supplies context to a hash-shaped token, with no other context
+        # word on the line.
+        state, _ = check(evidence("\u5df2\u63d0\u4ea4 a1b2c3d4e5f6 \u5f85\u9a8c\u3002"))
+        if state != "failed":
+            report(
+                f"{label}: a hash-shaped token beside a Chinese state word "
+                "was accepted. This change bounds the wording rule, not the "
+                "contextual-identifier rule."
+            )
+            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_quoted_span_is_not_a_claim_scenario() -> int:
+    """Issue #65 §2 and §4: quoted material was read as an assertion.
+
+    Evidence prose quotes what it is evidence of — the command that ran, the
+    output it printed, the branch base it ran against, the name of the
+    requirement under change. `withoutInlineCode()` in
+    `src/core/task-contract.js` already settled that shape for the field
+    reader; this check never had it, so a Scope check recording that it ran
+    `git status --short` was refused for the word inside the backticks.
+
+    The boundary matters as much as the exemption: quoting one token must not
+    exempt the sentence around it, or the rule becomes optional.
+    """
+    label = "a-quoted-span-is-not-a-claim"
+
+    with tempfile.TemporaryDirectory(prefix="keel-quoted-span-") 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
+
+        # Each of these carries its whole match inside a quoted span. Nothing
+        # outside the quotes on any of these lines is a claim about this
+        # repository's git state.
+        quoted = (
+            (
+                "inline code holding quoted output",
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                "    - M1.red: fail, as required. The runner printed "
+                "`fatal: you have uncommitted changes`.\n",
+            ),
+            (
+                "inline code holding an identifier and its context word",
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                "    - M1: pass. The fixture repository reported "
+                "`HEAD is at 3f2a9bc` before the run.\n",
+            ),
+            (
+                "a fenced block holding output",
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                "    - M1: pass. The runner printed:\n"
+                "      ```\n"
+                "      HEAD is at 3f2a9bc, working tree uncommitted\n"
+                "      ```\n",
+            ),
+            (
+                "a quotation span holding a requirement name",
+                "- [x] A1 implementation\n"
+                "  - Evidence:\n"
+                "    - M1: pass. This task renames \u201cA recorded commit "
+                "hash is recognized by what makes it one\u201d.\n",
+            ),
+        )
+        for description, body in quoted:
+            state, errors = check(body)
+            if state == "unreported":
+                report(
+                    f"{label}: keel --check reported no state at all on "
+                    f"{description}. This is not a verdict about the fixture — "
+                    "the check did not reach the point of having one."
+                )
+                return 1
+            if state != "ok":
+                report(
+                    f"{label}: {description} was read as a claim. A quoted "
+                    "span is content the author cites, and the only repair "
+                    "open to them is to stop quoting it accurately."
                 )
+                for error in errors:
+                    report(f"  {error}")
                 return 1
 
+        # The boundary. Quoting one token exempts that token and nothing else.
+        state, errors = check(
+            "- [x] A1 implementation\n"
+            "  - Evidence:\n"
+            "    - M1: verified against `3f2a9bc`, but the work is still "
+            "uncommitted.\n"
+        )
+        if state != "failed":
+            report(
+                f"{label}: wording outside a quoted span was exempted. The "
+                "span is what stops being read, not the line holding it."
+            )
+            return 1
+        if not [error for error in errors if "tasks.md:" in error]:
+            report(f"{label}: the refusal outside the span named no line.")
+            return 1
+
+        # An apostrophe is not a quotation delimiter. Treating it as one would
+        # silence the remainder of any line carrying a contraction, which is
+        # the failure mode that is invisible rather than wrong.
+        state, errors = check(
+            "- [x] A1 implementation\n"
+            "  - Evidence:\n"
+            "    - M1: the guard doesn't fire here, and the worktree is "
+            "uncommitted.\n"
+        )
+        if state != "failed":
+            report(
+                f"{label}: a contraction opened a quotation span and silenced "
+                "the rest of the line. The ASCII single quote is an "
+                "apostrophe far more often than it is a quotation mark."
+            )
+            return 1
+
     if label not in {name for name, _ in SCENARIOS}:
         report(f"{label}: the scenario registry does not include it.")
         return 1
@@ -22622,7 +23731,7 @@ def validate_a_covers_citation_is_not_a_record_scenario() -> int:
             "  - Covers:\n"
             f"    - {cited[0]}\n"
             "  - Verify:\n"
-            "    - M1: the change is 已提交 and needs no further work.\n"
+            "    - M1: the change is 已合入 and needs no further work.\n"
         )
         if state == "unreported":
             report(
@@ -22989,6 +24098,14 @@ SCENARIOS: tuple = (
         "unparsed-covers-critical-statement",
         validate_unparsed_covers_critical_statement_scenario,
     ),
+    (
+        "widened-critical-statement-shapes",
+        validate_widened_critical_statement_shapes_scenario,
+    ),
+    (
+        "covers-annotation-entry",
+        validate_covers_annotation_entry_scenario,
+    ),
     ("expectation-completion-gates", validate_expectation_completion_gates_scenario),
     ("authoring-continuity", validate_authoring_continuity_scenario),
     ("domain-lenses", validate_domain_lenses_scenario),
@@ -23026,6 +24143,11 @@ SCENARIOS: tuple = (
         "standing-authorization-never-weakens",
         validate_standing_authorization_never_weakens_scenario,
     ),
+    (
+        "continuation-authorization",
+        validate_continuation_authorization_scenario,
+    ),
+    ("continuation-docs", validate_continuation_docs_scenario),
     (
         "precedent-store-declaration",
         validate_precedent_store_declaration_scenario,
@@ -23236,7 +24358,23 @@ SCENARIOS: tuple = (
         "decimal-runs-are-not-hash-shaped",
         validate_decimal_runs_are_not_hash_shaped_scenario,
     ),
+    (
+        "an-owner-outlives-the-change",
+        validate_an_owner_outlives_the_change_scenario,
+    ),
+    (
+        "the-spec-names-the-managed-set",
+        validate_the_spec_names_the_managed_set_scenario,
+    ),
     ("a-context-word-is-a-word", validate_a_context_word_is_a_word_scenario),
+    (
+        "a-quoted-span-is-not-a-claim",
+        validate_a_quoted_span_is_not_a_claim_scenario,
+    ),
+    (
+        "a-submission-is-not-a-commit",
+        validate_a_submission_is_not_a_commit_scenario,
+    ),
     (
         "a-covers-citation-is-not-a-record",
         validate_a_covers_citation_is_not_a_record_scenario,