@christang/keel 5.16.0 → 5.20.0

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.16.0 -->
+<!-- keel:start version=5.20.0 -->
 ## Keel Bootstrap
 
 - Start every session with `keel context`; OpenSpec artifacts and Git are the only durable authority — never native memory, goals, or transcripts.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@christang/keel",
   "displayName": "Keel",
   "description": "Keel OpenSpec execution discipline CLI for Claude Code, Codex, and OpenCode.",
-  "version": "5.16.0",
+  "version": "5.20.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/plugins/keel/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.16.0",
+  "version": "5.20.0",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.16.0",
+  "version": "5.20.0",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/scripts/install_to_repo.py

@@ -120,9 +120,19 @@ TASKS_COMMIT_STATUS_PATTERNS = (
         "remove branch merge state from tasks.md; git log is the source of truth",
     ),
 )
+# A commit identifier is hexadecimal, and `a`-`f` are the only reason those
+# letters appear in one. A run of decimal digits alone is a phone number, a
+# timestamp, an order number, or a port — evidence prose, not state git owns.
+# Matching one as a recorded identifier (#58) asks the author to reword
+# something that was true, and a check that refuses correct work is one people
+# learn to route around. The length and word-boundary conditions are kept
+# verbatim inside the lookahead, so the token that matches is the token that
+# always matched, minus the all-decimal ones.
+_HASH_SHAPED_TOKEN = r"\b(?=[0-9a-f]{7,40}\b)[0-9a-f]*[a-f][0-9a-f]*\b"
+_HASH_CONTEXT_WORD = r"(?:commit|提交|合入|master|main|HEAD|hash|哈希)"
 TASKS_CONTEXTUAL_HASH_RE = re.compile(
-    r"(?i)(?:commit|提交|合入|master|main|HEAD|hash|哈希).*\b[0-9a-f]{7,40}\b|"
-    r"\b[0-9a-f]{7,40}\b.*(?:commit|提交|合入|master|main|HEAD|hash|哈希)"
+    rf"(?i){_HASH_CONTEXT_WORD}.*{_HASH_SHAPED_TOKEN}|"
+    rf"{_HASH_SHAPED_TOKEN}.*{_HASH_CONTEXT_WORD}"
 )
 
 

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.16.0"
-PROTOCOL_VERSION = "5.16.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
@@ -7890,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.
 
@@ -19344,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.")
@@ -19565,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,
@@ -19694,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),
 )
 

package/src/core/gates.js

@@ -372,6 +372,35 @@ const DURABLE_OWNER_FORMS =
   + "repository's own ledger; `keel/HANDOFF.md` is a pointer override rather "
   + "than an owner";
 
+// Trailing punctuation a declared path can abut in prose. ASCII sentence marks
+// and their CJK counterparts both belong here: once the extractor stops
+// assuming ASCII, its terminators cannot assume ASCII either. A Chinese
+// sentence ends in `。`, which is not whitespace, so a non-whitespace run
+// swallows it and the gate looks for a file that cannot exist.
+const DECLARED_PATH_TRAILING = /[.,;:!?)\]}"'\u2019\u201d\u3002\uff0c\u3001\uff1b\uff1a\uff01\uff1f\uff09\u3011\u300b\u300d\u300f]+$/;
+
+// A declared path is a run of non-whitespace holding a separator. What ends a
+// path is whitespace; what a path is *made of* is the filesystem's business,
+// and answering the first question with the second is what refused
+// `notes/note-006-转岗最难的不是流程/note.md` by reporting that
+// `notes/note-006-` does not exist — a path nobody wrote (issue #60). It is the
+// same class as #40 on the worktree-reading side, which survived because that
+// fix repaired one reader rather than how paths are extracted; this is the one
+// extractor every gate reader of a declared path now uses.
+//
+// The backtick form wins when present. It is the only way to write a path
+// containing whitespace, and `touchEntries` already strips backticks from a
+// Touch entry, so one authorship stops being spelled two ways depending on
+// which reader will read it.
+function declaredPath(value) {
+  const text = String(value || "");
+  const quoted = text.match(/`([^`\n]*\/[^`\n]*)`/);
+  if (quoted) return quoted[1].trim() || null;
+  const bare = text.match(/[^\s`]+\/[^\s`]+/);
+  if (!bare) return null;
+  return bare[0].replace(DECLARED_PATH_TRAILING, "") || null;
+}
+
 // Classify a declared `Durable owner:` value. A gate runs without network, so a
 // URL is accepted on shape alone; a path is the one form it can actually check,
 // and checking it is stricter than the prefix whitelist this replaced.
@@ -380,10 +409,10 @@ function durableOwnerVerdict(repo, value) {
   if (!owner) return { ok: false, reason: "unrecognized" };
   if (/keel\/HANDOFF\.md/i.test(owner)) return { ok: false, reason: "handoff" };
   if (TRACKER_REFERENCE.test(owner)) return { ok: true };
-  const candidate = owner.match(/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)+/);
+  const candidate = declaredPath(owner);
   if (!candidate) return { ok: false, reason: "unrecognized" };
-  if (fs.existsSync(path.join(repo, candidate[0]))) return { ok: true };
-  return { ok: false, reason: "missing", path: candidate[0] };
+  if (fs.existsSync(path.join(repo, candidate))) return { ok: true };
+  return { ok: false, reason: "missing", path: candidate };
 }
 
 // A finding has three dispositions and the gate recognized two. One found and
@@ -423,10 +452,10 @@ function resolutionEvidenceVerdict(repo, value, commands) {
     if (commands.includes(cited[0])) return { ok: true };
     return { ok: false, reason: "unknown-check", label: cited[0] };
   }
-  const candidate = evidence.match(/[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)+/);
+  const candidate = declaredPath(evidence);
   if (!candidate) return { ok: false, reason: "unrecognized" };
-  if (fs.existsSync(path.join(repo, candidate[0]))) return { ok: true };
-  return { ok: false, reason: "missing", path: candidate[0] };
+  if (fs.existsSync(path.join(repo, candidate))) return { ok: true };
+  return { ok: false, reason: "missing", path: candidate };
 }
 
 function resolutionEvidenceMessage(verdict) {
@@ -466,13 +495,12 @@ function findingOwnerIsDurable(repo, findings) {
     /\b(openspec\/changes\/[A-Za-z0-9][A-Za-z0-9._-]*\/(?:proposal|design|tasks)\.md)(?:#\d+(?:\.\d+)*)?/i
   );
   if (artifact && fs.existsSync(path.join(repo, artifact[1]))) return true;
-  return /\bkeel\/archive\/[A-Za-z0-9._/-]+/i.test(findings)
-    && fs.existsSync(
-      path.join(
-        repo,
-        findings.match(/\bkeel\/archive\/[A-Za-z0-9._/-]+/i)[0]
-      )
-    );
+  // Same extractor, scoped to the archive prefix: the segment after
+  // `keel/archive/` is a path like any other and was equally ASCII-bound.
+  const archive = findings.match(/keel\/archive\/[^\s`]*/i);
+  if (!archive) return false;
+  const archivePath = declaredPath(archive[0]);
+  return Boolean(archivePath) && fs.existsSync(path.join(repo, archivePath));
 }
 
 // Read in `-z` form, because every other form escapes. Git octal-escapes any
@@ -678,7 +706,13 @@ function completionChecks(repo, task, contract = null) {
   const commands = contract
     ? contract.capsule.verification.commands.map((item) => item.label)
     : commandLabels(task);
-  if (commands.length === 0) {
+  // With no contract, the labels came from the expanded v3 `Commands` field,
+  // which a compact task never declares — so their absence is a fact about the
+  // fallback, not about the task. The compiler's own diagnostics are already in
+  // `problems` (the caller pushes them unconditionally, and an unusable
+  // contract has at least one), so this cannot turn a refusal into a pass. The
+  // per-label evidence checks below stay: a genuine v3 task yields real labels.
+  if (contract && commands.length === 0) {
     problems.push(problem("missing-commands", "Commands must define at least one M<n>."));
   }
   for (const label of commands) {

package/src/core/task-contract.js

@@ -416,10 +416,24 @@ function requiredFieldProblems(task) {
 function missingFieldProblems(task, names) {
   return names
     .filter((name) => !isConcrete(field(task, name)))
-    .map((name) => ({
-      code: "missing-field",
-      message: `${name} must be concrete.`,
-    }));
+    .map((name) => {
+      // Name the matched slot, the way the check and Verify diagnostics already
+      // do. The unqualified wording stated only the verdict, so an author whose
+      // field held a token in ordinary prose had nothing to search for — and
+      // the first problem they saw named a field of the other schema instead.
+      // The code is unchanged: the verdict is the same either way, and a new
+      // one would hide this case from every consumer keying on `missing-field`.
+      const token = unfilledToken(field(task, name));
+      return {
+        code: "missing-field",
+        message: token
+          ? `${name} carries the unfilled slot \`${token}\`, so it is not `
+            + "concrete. Replace that slot with the value it stands for, or "
+            + "fence it in inline code when it is literal text — a numeric "
+            + "range or test output — rather than a slot left to fill."
+          : `${name} must be concrete.`,
+      };
+    });
 }
 
 function canonical(value) {