@christang/keel 5.14.0 → 5.20.0

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.14.0"
-PROTOCOL_VERSION = "5.14.0"
+PACKAGE_VERSION = "5.20.0"
+PROTOCOL_VERSION = "5.20.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
@@ -5594,6 +5594,146 @@ def validate_runtime_versions_are_checked_scenario() -> int:
     return 0
 
 
+def validate_doctor_reads_the_diagnosed_repository_scenario() -> int:
+    """Issue #57: doctor named one repository and answered about another.
+
+    The OpenSpec declaration was read from `PACKAGE_ROOT/package-lock.json` —
+    the directory Keel is installed in — while the line above it says
+    `keel doctor for <repo>`. The two coincide only when `node bin/keel.js`
+    runs from Keel's own checkout, which is the one arrangement every existing
+    scenario uses: `run_keel` always spawns `node <ROOT>/bin/keel.js`, so
+    `PACKAGE_ROOT` is Keel's checkout no matter what `cwd` is. Driving the
+    diagnosis at a repository that declares its own version is what separates
+    the two roots without needing a second installation.
+    """
+    label = "doctor-reads-the-diagnosed-repository"
+
+    def openspec_line(stdout: str) -> str:
+        return next(
+            (line for line in stdout.splitlines() if line.startswith("openspec:")),
+            "",
+        )
+
+    # M1 first half — a repository that declares a version Keel's own tree does
+    # not. The sentinel is deliberately one no published OpenSpec reports, so a
+    # line carrying it cannot have come from the resolved binary either.
+    declared = "0.0.1"
+    with tempfile.TemporaryDirectory(prefix="keel-doctor-declares-") as raw:
+        declares = Path(raw).resolve()
+        write_text(
+            declares / "package-lock.json",
+            json.dumps(
+                {
+                    "name": "consumer",
+                    "lockfileVersion": 3,
+                    "packages": {
+                        "node_modules/@fission-ai/openspec": {"version": declared}
+                    },
+                },
+                indent=2,
+            )
+            + "\n",
+        )
+        doctor = run_keel(declares, "--doctor")
+        line = openspec_line(doctor.stdout or "")
+        if not line:
+            report(f"{label} M1 `keel --doctor` emitted no openspec line.")
+            report((doctor.stdout or doctor.stderr or "").strip())
+            return 1
+        own_lock = json.loads((ROOT / "package-lock.json").read_text(encoding="utf-8"))
+        own_declared = None
+        for name, entry in own_lock.get("packages", {}).items():
+            if name.endswith("@fission-ai/openspec"):
+                own_declared = entry.get("version")
+        if not own_declared:
+            report(f"{label} could not read Keel's own declared OpenSpec version.")
+            return 1
+        # The reader sees two versions on this line: the one the resolved binary
+        # reports and the one the repository declares. Assert on the declared
+        # POSITION, not on bare presence — the resolved binary's version may
+        # legitimately equal Keel's own declared version, and a test that reads
+        # any occurrence cannot tell the two apart.
+        # Two distinct failures, two conditions. A line carrying the right
+        # version with no attribution and a line attributing the wrong version
+        # need different fixes, and one message covering both would send half
+        # its readers to a place with no problem in it.
+        if "repo pins" not in line:
+            report(
+                f"{label} M1 the openspec line does not attribute any declared "
+                "version to the repository, so a reader seeing two versions "
+                "cannot tell which one is theirs."
+            )
+            report(f"  {line}")
+            return 1
+        if f"repo pins {declared}" not in line:
+            report(
+                f"{label} M1 the openspec line attributes a declared version "
+                f"to the repository, but not {declared}, which is what this "
+                "repository declares. It is answering about some other "
+                "repository."
+            )
+            report(f"  {line}")
+            return 1
+        if own_declared != declared and f"repo pins {own_declared}" in line:
+            report(
+                f"{label} M1 the openspec line reports {own_declared} as the "
+                "declared version. That is what is declared where Keel is "
+                "installed, not where it was pointed."
+            )
+            report(f"  {line}")
+            return 1
+        if not line.startswith("openspec: warning"):
+            report(
+                f"{label} M1 the resolved binary and the declared version "
+                f"disagree ({declared} is declared and no release reports it), "
+                "and the line does not state the disagreement."
+            )
+            report(f"  {line}")
+            return 1
+
+    # M1 second half — absence is a statement about the repository, not a read
+    # failure, and not a disagreement. Most repositories do not depend on
+    # OpenSpec at all, so warning here would train readers to ignore the line.
+    with tempfile.TemporaryDirectory(prefix="keel-doctor-silent-") as raw:
+        silent = Path(raw).resolve()
+        write_text(silent / "README.md", "# consumer\n")
+        doctor = run_keel(silent, "--doctor")
+        line = openspec_line(doctor.stdout or "")
+        if not line:
+            report(f"{label} M1 `keel --doctor` emitted no openspec line.")
+            report((doctor.stdout or doctor.stderr or "").strip())
+            return 1
+        if "declares no OpenSpec" not in line:
+            report(
+                f"{label} M1 a repository declaring no OpenSpec version is not "
+                "reported as declaring none."
+            )
+            report(f"  {line}")
+            return 1
+        if "unreadable" in line:
+            report(
+                f"{label} M1 the absence of a declaration is reported as a "
+                "failure to read one. The two are different facts and only one "
+                "of them is true here."
+            )
+            report(f"  {line}")
+            return 1
+        if "answering from a different" in line:
+            report(
+                f"{label} M1 a repository declaring nothing is reported as "
+                "disagreeing with the resolved binary. There is nothing for it "
+                "to disagree with."
+            )
+            report(f"  {line}")
+            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
+
+
 TASK_SHAPE_TEMPLATE = """## 1. Work
 
 - [ ] 1.1 First half
@@ -6054,6 +6194,174 @@ def validate_interpreter_surfaces_agree_scenario() -> int:
     return 0
 
 
+def validate_default_completion_attributes_writes_scenario() -> int:
+    """A write outside Touch has to fail the gate the author actually runs.
+
+    `attributionResult` refuses an out-of-Touch path in full — diff, union with
+    the dirty set, `pathAllowed` filter, `outside-touch` problem — behind
+    `if (!base) return { problems: [] }`. Without `--base` the whole comparison
+    is skipped and the paths are printed as a warning instead. Measured at
+    5.15.0 on one tree and one task: `pass` with the offending path in a
+    warning, `fail` once `--base HEAD` was added.
+
+    It was found by it happening. During the 5.15.0 release task a file was
+    written that the task had not declared, through a `python3` heredoc in
+    Bash — the write guard binds the host's file-writing tools and cannot bind
+    a shell — and `task-complete` returned `pass`. A human reading `git status`
+    caught it. Nobody reads `git status` in an unattended run, and this
+    repository admits work into unattended runs by declaration.
+
+    The base does not have to come from the caller. `task-start` already writes
+    the manifest at the instant the task is authorized; recording what was
+    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.
+    """
+    label = "default-completion-attributes-writes"
+
+    def git(repo: Path, *args: str) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            ["git", "-C", str(repo), *args], capture_output=True, text=True
+        )
+
+    def tasks_doc() -> str:
+        return (
+            "# Tasks\n\n## Invalidates\n\n- None.\n\n"
+            "- [ ] 1.1 Exercise task contract\n"
+            "  - Covers:\n    - E1: Public behavior passes.\n"
+            "  - Touch:\n    - src/declared.js\n"
+            "  - Verify:\n    - Strategy: evidence-first\n"
+            "    - M1: node test.js asserts the recorded feed status\n"
+            "  - Evidence:\n    - Contract: pending\n    - M1: the suite passed\n"
+            "    - Review:\n      - Status: pass\n"
+            "      - Acceptance check: behavior asserted at the interface\n"
+            "      - Scope check: only Touch files changed\n"
+            "      - Findings: none\n"
+            "    - Blocker: none\n"
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-default-attribution-") as raw:
+        repo = (Path(raw) / "repo").resolve()
+        repo.mkdir()
+        git(repo, "init", "-q")
+        git(repo, "config", "user.email", "t@example.com")
+        git(repo, "config", "user.name", "keel-test")
+        write_text(repo / "src/declared.js", "// product\n")
+        write_text(repo / "src/undeclared.js", "// product\n")
+        write_text(repo / "src/already-dirty.js", "// product\n")
+        write_text(repo / "openspec/changes/demo/tasks.md", tasks_doc())
+        git(repo, "add", "-A")
+        git(repo, "-c", "commit.gpgsign=false", "commit", "-q", "-m", "base")
+
+        def start(*extra: str) -> subprocess.CompletedProcess[str]:
+            return run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--record", *extra, "--json",
+            )
+
+        def gate(*extra: str) -> dict:
+            return json.loads(
+                run_keel(
+                    repo, "gate", "task-complete", "--change", "demo",
+                    "--task", "1.1", *extra, "--json",
+                ).stdout
+            )
+
+        def outside(payload: dict) -> list[str]:
+            return [
+                problem.get("message", "")
+                for problem in payload.get("problems", [])
+                if problem.get("code") == "outside-touch"
+            ]
+
+        # A path already dirty before the task is authorized. It must stay
+        # unattributed afterwards: subtracting the start set is what removes
+        # the false-positive class that made automatic attribution unsafe.
+        write_text(repo / "src/already-dirty.js", "// touched before the task\n")
+
+        if start().returncode != 0:
+            report(f"{label} could not authorize the fixture task.")
+            return 1
+
+        # M1 — the reported defect. A write the guard never saw, and the gate
+        # invoked the way an author actually invokes it.
+        write_text(repo / "src/undeclared.js", "// written outside Touch\n")
+        payload = gate()
+        problems = outside(payload)
+        if not any("src/undeclared.js" in message for message in problems):
+            report(
+                f"{label} M1 a path written outside Touch after task start was "
+                "not refused by the default completion gate. The boundary "
+                "holds only when the caller asks for it."
+            )
+            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} M1 the gate named the out-of-Touch path but did not "
+                f"fail; got status {payload.get('status')!r}. A boundary that "
+                "reports without refusing is not a boundary."
+            )
+            return 1
+        if any("src/already-dirty.js" in message for message in problems):
+            report(
+                f"{label} M1 a path that was already dirty when the task "
+                "started was attributed to the task. The recorded set is not "
+                "being subtracted, so an unrelated dirty worktree fails the "
+                "gate."
+            )
+            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.
+        base_problems = outside(gate("--base", "HEAD"))
+        if not any("src/already-dirty.js" in message for message in base_problems):
+            report(
+                f"{label} M1 an explicit --base did not attribute a path that "
+                "changed since that base, so the recorded set is overriding "
+                "the base the caller supplied instead of yielding to it."
+            )
+            for message in base_problems:
+                report(f"  {message}")
+            return 1
+
+        # M1 — no record means no attribution. A manifest written before this
+        # existed, or a cleared one, must not be read as a clean start: absence
+        # of a record is not a record of absence.
+        run_keel(repo, "guard", "clear")
+        if start("--no-guard").returncode != 0:
+            report(f"{label} could not re-authorize without a manifest.")
+            return 1
+        payload = gate()
+        if outside(payload):
+            report(
+                f"{label} M1 the gate attributed paths with no recorded "
+                "task-start set. A missing record is being read as a clean "
+                "start, which fails every completion in a dirty repository."
+            )
+            for message in outside(payload):
+                report(f"  {message}")
+            return 1
+        if not any(
+            "not attributed" in warning for warning in payload.get("warnings", [])
+        ):
+            report(
+                f"{label} M1 with no record the gate neither attributed nor "
+                "reported the dirty paths, so the fallback lost the semantic "
+                "review evidence it is supposed to preserve."
+            )
+            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
+
+
 CJK_PATH = "src/摄影光影规划工具.js"
 SPACE_PATH = "src/has space.js"
 QUOTE_PATH = 'src/has"quote.js'
@@ -7582,6 +7890,197 @@ def validate_non_concrete_check_names_token_scenario() -> int:
     return 0
 
 
+def validate_unusable_contract_names_only_its_cause_scenario() -> int:
+    """Issue #52: the first problem named `Commands`, which compact tasks lack.
+
+    Two defects compound. `missingFieldProblems` emitted a bare "must be
+    concrete" while `unfilledToken` sat eight lines above it, and a contract
+    carrying any diagnostic is discarded, after which `completionChecks` falls
+    back to reading `Commands` — a field a compact task never declares. The
+    derived problem sorts first and is the only one naming a field, so it is the
+    one an author acts on, and it is about a schema they did not choose.
+
+    What is deliberately *not* changed is which fields the gate accepts. A bare
+    token in prose stays non-concrete; see the M3 regression on
+    `inline-code-is-concrete` and the decision recorded in
+    keel/archive/follow-ups/2026-07-27-unfilled-token-keywords.md.
+    """
+    less, greater = "<", ">"
+    # The reporter's own shape: two bare brackets separated by half a sentence,
+    # so the unbounded `<[^>]+>` swallows the span between them.
+    prose = (
+        f"pass — max ratio 0.001916 (bound {less}0.02), "
+        f"min ratio 0.998107 (bound {greater}0.98)."
+    )
+    captured = f"{less}0.02), min ratio 0.998107 (bound {greater}"
+    review = (
+        "    - Review:\n"
+        "      - Status: pass\n"
+        "      - Acceptance check: reviewed\n"
+        "      - Scope check: reviewed\n"
+        "      - Findings: none\n"
+    )
+    with tempfile.TemporaryDirectory(prefix="keel-unusable-contract-") as raw:
+        repo = Path(raw)
+        clean = task_capsule_compact_fixture()
+        write_text(repo / "openspec/changes/prose/tasks.md", clean)
+        # The anchor has to be recorded while the Evidence is still concrete —
+        # which is the real sequence, not a workaround. The token arrives when
+        # the author writes up the result, after the task started.
+        if not record_contract_anchor(repo, "prose"):
+            report(
+                "unusable-contract-names-only-its-cause: the clean fixture "
+                "could not record a contract anchor."
+            )
+            return 1
+        started = (repo / "openspec/changes/prose/tasks.md").read_text(
+            encoding="utf-8"
+        )
+        write_text(
+            repo / "openspec/changes/prose/tasks.md",
+            started.replace(
+                "    - M1: pending\n", f"    - M1: {prose}\n{review}"
+            ),
+        )
+        completed = run_keel(
+            repo,
+            "gate",
+            "task-complete",
+            "--change",
+            "prose",
+            "--task",
+            "1.1",
+            "--json",
+        )
+        payload = json.loads(completed.stdout)
+        problems = payload.get("problems", [])
+        messages = [problem.get("message", "") for problem in problems]
+
+        # 1. The derived problem is gone. It named a field compact tasks lack.
+        derived = [text for text in messages if "must define at least one" in text]
+        if derived:
+            report(
+                "unusable-contract-names-only-its-cause: an unusable contract "
+                "still derived a verification-form problem from the other "
+                "schema's field."
+            )
+            for text in derived:
+                report(f"  {text}")
+            return 1
+
+        # 2. The remaining problem names the span that caused it, and the escape.
+        named = [
+            text
+            for text in messages
+            if captured in text and "inline code" in text
+        ]
+        if not named:
+            report(
+                "unusable-contract-names-only-its-cause: the Evidence "
+                "diagnostic did not name the matched span and the inline-code "
+                "escape."
+            )
+            for text in messages:
+                report(f"  {text}")
+            return 1
+
+        # 3. Naming the cause did not stop the gate refusing. This is the
+        #    assertion that must never be dropped: suppressing a problem is the
+        #    direction that can wrongly make a gate pass.
+        if payload.get("status") != "fail":
+            report(
+                "unusable-contract-names-only-its-cause: the gate returned "
+                f"{payload.get('status')!r} for a task whose Evidence is not "
+                "concrete."
+            )
+            return 1
+
+        # 4. Fencing exactly what the message names clears it, so the offered
+        #    repair is the one that works.
+        fenced = started.replace(
+            "    - M1: pending\n",
+            f"    - M1: `{prose}`\n{review}",
+        )
+        write_text(repo / "openspec/changes/fenced/tasks.md", fenced)
+        if not record_contract_anchor(repo, "fenced"):
+            report(
+                "unusable-contract-names-only-its-cause: fencing the named "
+                "span did not make the Evidence concrete."
+            )
+            return 1
+
+        # 5. An empty field has no token to name, so it keeps the plain wording.
+        empty = clean.replace(
+            "  - Covers:\n    - E1: Public behavior passes.\n", "  - Covers:\n"
+        )
+        write_text(repo / "openspec/changes/empty/tasks.md", empty)
+        bare = run_keel(
+            repo, "gate", "task-start", "--change", "empty", "--task", "1.1",
+            "--json",
+        )
+        bare_messages = [
+            problem.get("message", "")
+            for problem in json.loads(bare.stdout).get("problems", [])
+        ]
+        if not any(
+            text.startswith("Covers must be concrete") for text in bare_messages
+        ):
+            report(
+                "unusable-contract-names-only-its-cause: an empty required "
+                "field lost the unqualified wording."
+            )
+            for text in bare_messages:
+                report(f"  {text}")
+            return 1
+
+        # 6. Suppression must not hide a task that genuinely declares no
+        #    verification form. The refusal names the compact field to add.
+        noform = clean.replace(
+            "  - Verify:\n    - Strategy: evidence-first\n    - M1: node test.js\n",
+            "",
+        )
+        write_text(repo / "openspec/changes/noform/tasks.md", noform)
+        absent = run_keel(
+            repo, "gate", "task-complete", "--change", "noform", "--task", "1.1",
+            "--json",
+        )
+        absent_payload = json.loads(absent.stdout)
+        absent_messages = [
+            problem.get("message", "")
+            for problem in absent_payload.get("problems", [])
+        ]
+        if absent_payload.get("status") != "fail":
+            report(
+                "unusable-contract-names-only-its-cause: a task declaring no "
+                "verification form was not refused."
+            )
+            return 1
+        if not any("`Verify`" in text for text in absent_messages):
+            report(
+                "unusable-contract-names-only-its-cause: the refusal did not "
+                "name `Verify` as the field to add."
+            )
+            for text in absent_messages:
+                report(f"  {text}")
+            return 1
+        if any("must define at least one" in text for text in absent_messages):
+            report(
+                "unusable-contract-names-only-its-cause: a task declaring no "
+                "verification form was told about `Commands`."
+            )
+            return 1
+    if "unusable-contract-names-only-its-cause" not in {
+        name for name, _ in SCENARIOS
+    }:
+        report(
+            "unusable-contract-names-only-its-cause: the scenario registry "
+            "does not include it."
+        )
+        return 1
+    report("unusable-contract-names-only-its-cause scenario passed.")
+    return 0
+
+
 def validate_covers_question_reference_scope_scenario() -> int:
     """Issue #28 item 9: citing a resolved question must not re-open it.
 
@@ -19036,6 +19535,437 @@ def validate_assertion_shape_count_scenario() -> int:
     return 0
 
 
+def validate_declared_paths_are_read_whole_scenario() -> int:
+    """Issue #60: a durable owner under a Chinese directory was refused.
+
+    `notes/note-006-转岗最难的不是流程/note.md` exists and `git ls-files` finds
+    it, and `change-close` reported that `notes/note-006-` does not exist — a
+    path nobody wrote. The extractor was `[A-Za-z0-9._-]+(?:/[A-Za-z0-9._-]+)+`,
+    which answers "where does the path end" by assuming what a path is made of.
+
+    Two more shapes fell out while reproducing it: a path whose *first* segment
+    is not ASCII does not match at all, and a path containing a space truncates
+    at the space. The last is why the backtick form matters — `Touch` already
+    accepts it, so one authorship was spelled two ways depending on which
+    reader would read it.
+
+    Same class as #40, which fixed it in `gitPaths` for the worktree side. That
+    fix did not generalize because it repaired one reader rather than how the
+    repository extracts paths.
+    """
+    label = "declared-paths-are-read-whole"
+    cjk_owner = "notes/note-006-转岗最难的不是流程/note.md"
+    cjk_first = "文档/风格.md"
+    spaced = "docs/has space.md"
+
+    def git(repo, *args):
+        return subprocess.run(
+            ["git", "-C", str(repo), *args], capture_output=True, text=True
+        )
+
+    def tasks_doc(findings: str, coverage: str) -> str:
+        return (
+            "# Tasks\n\n"
+            "- [x] 1.1 Exercise the declared-path readers\n"
+            "  - Covers:\n    - E1: Public behavior passes.\n"
+            "  - Touch:\n    - src/declared.js\n"
+            "  - Verify:\n    - Strategy: evidence-first\n"
+            "    - M1: node test.js asserts the recorded feed status\n"
+            "  - Evidence:\n"
+            "    - Contract: keel-task-capsule/v1 sha256:"
+            + ("0" * 64) + "\n"
+            "    - M1: the suite passed\n"
+            "    - Review:\n      - Status: pass\n"
+            "      - Acceptance check: behavior asserted at the interface\n"
+            "      - Scope check: only Touch files changed\n"
+            f"      - Findings: {findings}\n"
+            "    - Blocker: none\n\n"
+            "## Invalidates\n\n- None.\n\n"
+            "## Expectation Coverage\n\n"
+            f"- E1: the behavior {coverage}\n"
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-declared-paths-") as raw:
+        repo = (Path(raw) / "repo").resolve()
+        repo.mkdir()
+        git(repo, "init", "-q")
+        git(repo, "config", "user.email", "t@example.com")
+        git(repo, "config", "user.name", "keel-test")
+        for item in (cjk_owner, cjk_first, spaced):
+            write_text(repo / item, "# owner\n")
+        write_text(repo / "src/declared.js", "// product\n")
+        tasks_path = repo / "openspec/changes/demo/tasks.md"
+
+        def close(findings: str, coverage: str) -> dict:
+            write_text(tasks_path, tasks_doc(findings, coverage))
+            return json.loads(
+                run_keel(
+                    repo, "gate", "change-close", "--change", "demo",
+                    "--action", "sync", "--json",
+                ).stdout
+            )
+
+        def problems(payload: dict) -> list[str]:
+            return [p.get("message", "") for p in payload.get("problems", [])]
+
+        # M1 — the reported shape, on both readers that take a declared path.
+        for where, findings, coverage in (
+            ("Findings", f"one open. Durable owner: {cjk_owner}", "Covered by: 1.1"),
+            ("Expectation Coverage", "none", f"Durable owner: {cjk_owner}"),
+        ):
+            payload = close(findings, coverage)
+            truncated = [m for m in problems(payload) if "note-006-" in m]
+            if truncated:
+                report(
+                    f"{label} M1 a {where} durable owner naming an existing "
+                    "file under a non-ASCII directory was refused, and the "
+                    "refusal names a path nobody wrote."
+                )
+                for message in truncated:
+                    report(f"  {message}")
+                return 1
+
+        # M1 — a path whose first segment is not ASCII matched nothing at all,
+        # which is a different failure from truncation and needs its own case.
+        payload = close("none", f"Durable owner: {cjk_first}")
+        rejected = [m for m in problems(payload) if "E1" in m and "owner" in m.lower()]
+        if rejected:
+            report(
+                f"{label} M1 a durable owner whose first segment is not ASCII "
+                "was not recognized as a path at all."
+            )
+            for message in rejected:
+                report(f"  {message}")
+            return 1
+
+        # M1 — whitespace arrives in backticks, the form Touch already accepts.
+        payload = close("none", f"Durable owner: `{spaced}`")
+        rejected = [m for m in problems(payload) if "E1" in m and "owner" in m.lower()]
+        if rejected:
+            report(
+                f"{label} M1 a backtick-wrapped path containing a space was "
+                "not read whole, so Touch and Durable owner still disagree "
+                "about how one path is written."
+            )
+            for message in rejected:
+                report(f"  {message}")
+            return 1
+
+        # M1 — a path ending a sentence, in both punctuation families.
+        for mark in ("。", ","):
+            payload = close("none", f"Durable owner: {cjk_owner}{mark} 说明文字")
+            rejected = [
+                m for m in problems(payload) if "E1" in m and "owner" in m.lower()
+            ]
+            if rejected:
+                report(
+                    f"{label} M1 a path followed by {mark!r} was extended by "
+                    "its punctuation, so the gate looked for a file that "
+                    "cannot exist."
+                )
+                for message in rejected:
+                    report(f"  {message}")
+                return 1
+
+        # M1 — the check itself must survive the widening. A path that does not
+        # exist is still refused, and the refusal names the whole path.
+        missing = "notes/不存在的目录/note.md"
+        payload = close("none", f"Durable owner: {missing}")
+        named = [m for m in problems(payload) if missing in m]
+        if not named:
+            report(
+                f"{label} M1 a durable owner naming a file that does not exist "
+                "was accepted, or was refused without naming the whole path. "
+                "Widening the extractor must not weaken the existence check."
+            )
+            for message in problems(payload):
+                report(f"  {message}")
+            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_published_specs_validate_strictly_scenario() -> int:
+    """Issue #46: the store Keel publishes was validated by nothing.
+
+    Every change's closing task runs `openspec validate <change> --strict`,
+    which reads the change directory and stays green. The published store under
+    `openspec/specs/` was read by no check at all — measured at 5.16.0,
+    `--specs` appeared zero times in this file. Issue #46 found 8 of 21 specs
+    failing strict validation, every one on `Requirement must contain SHALL or
+    MUST keyword`, because the requirement opened with a context paragraph and
+    the strict validator reads only the block under the heading. Those failures
+    had never appeared in front of anyone.
+
+    They are gone now, removed by spec rewrites made for other reasons. That is
+    what makes this the moment to assert it absolutely rather than as the
+    ratchet #46 proposed: at a count of 8 a ratchet was the honest shape, and at
+    0 the same mechanism becomes a budget for failures to hide in.
+    """
+    label = "published-specs-validate-strictly"
+
+    # The pinned binary, not whatever `openspec` PATH happens to offer. This is
+    # not fussiness: measured here, PATH answers 1.4.1 and reports 8 failures
+    # while the version this repository resolves answers 1.6.0 and reports
+    # none. Issue #46 recorded those 8 failures as an openspec 1.6.0 result;
+    # they are 1.4.1's, and the store has always passed under the version the
+    # repository pins. A check that reads PATH would re-record the same
+    # mistake, which is exactly what `keel-target-surface-diagnostics` means by
+    # a suite that silently changes which program it runs reporting facts about
+    # a different program.
+    pinned = ROOT / "node_modules" / ".bin" / (
+        "openspec.cmd" if os.name == "nt" else "openspec"
+    )
+    if not pinned.exists():
+        report(
+            f"{label}: the pinned openspec is not installed "
+            "(node_modules/.bin/openspec); reporting the skip rather than "
+            "falling back to PATH, which would answer for a different program."
+        )
+        return 0
+
+    def pinned_openspec(*args: str) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            [str(pinned), *args],
+            cwd=ROOT,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            capture_output=True,
+            check=False,
+        )
+
+    version = pinned_openspec("--version")
+    exercised = re.search(r"\d+\.\d+\.\d+", version.stdout or "")
+    result = pinned_openspec("validate", "--specs", "--strict")
+
+    output = f"{result.stdout or ''}{result.stderr or ''}"
+    # Two independent readings. The exit status alone would pass if the command
+    # stopped validating; the per-spec lines alone would pass if it started
+    # exiting non-zero for an unrelated reason. Neither is trusted on its own.
+    failed = [
+        line.strip()
+        for line in output.splitlines()
+        if line.strip().startswith("✗")
+    ]
+    totals = re.search(r"Totals:\s*(\d+) passed,\s*(\d+) failed", output)
+    if not totals:
+        report(
+            f"{label} the validator produced no totals line, so the result "
+            "cannot be read. The output shape it reports may have moved."
+        )
+        report(output.strip()[:600])
+        return 1
+    passed_count, failed_count = int(totals.group(1)), int(totals.group(2))
+
+    if failed:
+        report(
+            f"{label} {len(failed)} published spec(s) fail strict validation "
+            f"against openspec {exercised.group(0) if exercised else 'unknown'}. "
+            "A published spec that the validator Keel ships refuses is one "
+            "every consumer sees refused. The usual cause is a requirement "
+            "whose modal verb sits below its first paragraph — the strict "
+            "validator reads only the block directly under the heading."
+        )
+        for line in failed:
+            report(f"  {line}")
+        return 1
+    if failed_count != 0:
+        report(
+            f"{label} the totals line reports {failed_count} failing spec(s) "
+            "while no per-spec failure line was emitted. The two readings "
+            "disagree, so the result is not trustworthy either way."
+        )
+        report(output.strip()[:600])
+        return 1
+    if result.returncode != 0:
+        report(
+            f"{label} the validator reported {passed_count} passed and 0 "
+            f"failed but exited {result.returncode}. The verdict and the exit "
+            "status disagree."
+        )
+        report(output.strip()[:600])
+        return 1
+    if passed_count == 0:
+        report(
+            f"{label} the validator reports zero specs. An empty store passes "
+            "every assertion about it, which is the shape "
+            "`A derived assertion set that collapses to empty fails instead of "
+            "passing` exists to 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: {passed_count} published specs validate "
+        f"strictly against openspec "
+        f"{exercised.group(0) if exercised else 'unknown'}."
+    )
+    return 0
+
+
+def validate_decimal_runs_are_not_hash_shaped_scenario() -> int:
+    """Issue #58: an eleven-digit fake phone number failed `keel state`.
+
+    The criterion was a context word beside `[0-9a-f]{7,40}`, and eleven
+    decimal digits are eleven characters of that class. So was a timestamp,
+    an order number, a port, and any numeric fixture that happened to sit on a
+    line with the word `commit` or `提交` — which in evidence prose is most of
+    them.
+
+    The cost is not the refusal, it is what the refusal asks for. Nothing is
+    wrong with the line, so the only way past it is to write the evidence
+    differently; the reporter changed the number to `138****0000`. Evidence
+    reworded to satisfy a pattern is weaker than the evidence that was true,
+    and a check that fails on correct work is one people learn to route
+    around.
+
+    Same class as #60, repaired one release earlier in the other direction:
+    there the character class was too narrow. The rule was right both times.
+    """
+    label = "decimal-runs-are-not-hash-shaped"
+
+    def tasks_doc(body: str) -> str:
+        return (
+            "# Tasks\n\n## Invalidates\n\n- None.\n\n"
+            "## Tasks\n\n"
+            "- [x] A1 implementation\n"
+            f"{body}\n"
+            "## Workflow Notes\n\n- None.\n"
+        )
+
+    # F2, measured at 5.18.0: each of these is refused by the pre-change
+    # criterion, and none of them records anything git owns.
+    accepted = (
+        "- M1: pass —— 提交表单时手机号 13800138000 通过校验。\n",
+        "- M2: pass —— 时间戳 1700000000 与 commit 记录对齐。\n",
+        "- M3: pass —— 提交订单号 20260802123 落库。\n",
+    )
+    # 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"
+
+    def state_of(check) -> str:
+        if "keel state: ok" in check.stdout:
+            return "ok"
+        if "keel state: failed" in check.stdout:
+            return "failed"
+        return "unreported"
+
+    with tempfile.TemporaryDirectory(prefix="keel-decimal-runs-") as raw:
+        repo = (Path(raw) / "repo").resolve()
+        repo.mkdir()
+        install = run_keel(repo, "--install")
+        if install.returncode != 0:
+            report(f"{label}: keel --install failed while building the fixture.")
+            report((install.stderr or install.stdout).strip())
+            return 1
+
+        tasks_path = repo / "openspec/changes/numbers-in-evidence/tasks.md"
+
+        def check(body: str):
+            write_text(tasks_path, tasks_doc(body))
+            return run_keel(repo, "--check")
+
+        # `keel state` reporting nothing at all is a different failure from it
+        # reporting a refusal, and one condition covering both would send the
+        # reader to a line that has no problem in it.
+        def unreported(result, where: str) -> bool:
+            if state_of(result) != "unreported":
+                return False
+            report(
+                f"{label}: keel --check reported no state at all while {where}. "
+                "This is not a verdict about the fixture — the check did not "
+                "reach the point of having one."
+            )
+            report((result.stderr or result.stdout).strip()[:600])
+            return True
+
+        # M1 — the reported shape and its two siblings, each on its own line so
+        # a failure names which one.
+        for line in accepted:
+            result = check(line)
+            if unreported(result, "reading one ordinary number"):
+                return 1
+            if state_of(result) != "ok":
+                report(
+                    f"{label}: an ordinary number in evidence prose was refused "
+                    "as a recorded identifier. Nothing on this line records "
+                    "anything git owns, so the only way past the refusal is to "
+                    "reword evidence that was true."
+                )
+                report(f"  line: {line.strip()}")
+                for state_error in [
+                    out for out in result.stdout.splitlines()
+                    if out.startswith("state-error")
+                ]:
+                    report(f"  {state_error}")
+                return 1
+
+        # All three together, because the check reports per line and a
+        # per-line pass says nothing about a file holding several.
+        together = check("".join(accepted))
+        if unreported(together, "reading three ordinary numbers in one file"):
+            return 1
+        if state_of(together) != "ok":
+            report(f"{label}: three ordinary numbers in one file were refused.")
+            report(together.stdout.strip()[:600])
+            return 1
+
+        # M1 negative — the narrowing must not have narrowed the rule.
+        with_token = check("".join(accepted) + refused_token)
+        if unreported(with_token, "reading a hexadecimal identifier"):
+            return 1
+        if state_of(with_token) != "failed":
+            report(
+                f"{label}: a hexadecimal identifier of that length beside a "
+                "context word was accepted. Narrowing what counts as an "
+                "identifier must not stop the check refusing one."
+            )
+            report(with_token.stdout.strip()[:600])
+            return 1
+        if with_token.returncode == 0:
+            report(f"{label}: the refusal did not fail the check's exit status.")
+            return 1
+        named = [
+            out for out in with_token.stdout.splitlines()
+            if out.startswith("state-error") and "tasks.md:" in out
+        ]
+        if not named:
+            report(
+                f"{label}: the refusal named no line. An author cannot act on "
+                "a refusal that does not say where."
+            )
+            report(with_token.stdout.strip()[:600])
+            return 1
+
+        # And the wording patterns, which never depended on a digit run.
+        wording = check(refused_wording)
+        if unreported(wording, "reading recorded work state written in words"):
+            return 1
+        if state_of(wording) != "failed":
+            report(
+                f"{label}: recorded work state written in words was accepted. "
+                "That rule reads the wording and is untouched by any change to "
+                "what counts as an identifier."
+            )
+            report(wording.stdout.strip()[:600])
+            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.")
@@ -19257,6 +20187,10 @@ SCENARIOS: tuple = (
         "non-concrete-check-names-token",
         validate_non_concrete_check_names_token_scenario,
     ),
+    (
+        "unusable-contract-names-only-its-cause",
+        validate_unusable_contract_names_only_its_cause_scenario,
+    ),
     (
         "absent-verification-form-is-one-problem",
         validate_absent_verification_form_is_one_problem_scenario,
@@ -19286,10 +20220,18 @@ SCENARIOS: tuple = (
         "git-paths-carry-no-escaping",
         validate_git_paths_carry_no_escaping_scenario,
     ),
+    (
+        "default-completion-attributes-writes",
+        validate_default_completion_attributes_writes_scenario,
+    ),
     (
         "runtime-versions-are-checked",
         validate_runtime_versions_are_checked_scenario,
     ),
+    (
+        "doctor-reads-the-diagnosed-repository",
+        validate_doctor_reads_the_diagnosed_repository_scenario,
+    ),
     ("task-shape-warning", validate_task_shape_warning_scenario),
     ("context-names-its-keel", validate_context_names_its_keel_scenario),
     ("interpreter-surfaces-agree", validate_interpreter_surfaces_agree_scenario),
@@ -19378,6 +20320,18 @@ SCENARIOS: tuple = (
     ("domain-lens-doctor", validate_domain_lens_doctor_scenario),
     ("plan-funnel-guidance", validate_plan_funnel_guidance_scenario),
     ("native-tasks-view", validate_native_tasks_view_scenario),
+    (
+        "declared-paths-are-read-whole",
+        validate_declared_paths_are_read_whole_scenario,
+    ),
+    (
+        "published-specs-validate-strictly",
+        validate_published_specs_validate_strictly_scenario,
+    ),
+    (
+        "decimal-runs-are-not-hash-shaped",
+        validate_decimal_runs_are_not_hash_shaped_scenario,
+    ),
     ("validation-runner", validate_validation_runner_scenario),
 )