@christang/keel 5.63.0 → 5.65.0

package/README.md

@@ -375,6 +375,45 @@ set — fails `task-start` by name rather than sitting in the contract doing not
 `Fails with:` marker that names no literal. To *write about* the marker in a check without declaring
 one, put it in inline code.
 
+#### A red can be honest and the check still immune
+
+A signature predicts the red of an **absent** feature. It says nothing about the red of a **broken**
+one, and the two can be unrelated. A consistency check asserting two tool outputs agree had a real
+red, a correct signature, a real green — and stayed green through a 1000× unit error, the one thing
+it existed to catch, because its tolerance carried a default absolute floor. The only way to find
+that is to put the defect in and watch.
+
+`Detects:` declares that injection — the mutation, and the failure it must produce:
+
+```
+- M1: `pytest tests/test_fmax.py` asserts synth fmax == sta fmax. Fails with: `AttributeError` Detects: `sed -i s/0.0005/0.5/ run_sta.py` -> `assert 5e-16 == 5e-13`
+```
+
+Completion requires that second literal in the check's `.detects` Evidence. Clauses chain, so a check
+may carry both — the example above is one check, one line.
+
+**Keel does not run the mutation and does not judge it.** It records the claim and puts it where
+review can see it, the same standing every other check result has. You can declare an injection any
+check would catch; what the clause buys is that you decided it before the run, and that editing it
+afterwards moves the fingerprint.
+
+A `(regression)` check **may** declare one, and is the best place for it: such a check has no honest
+red by construction, so an injection is the only thing that can show it is not vacuous.
+
+#### A number can claim to be a measurement
+
+`Basis:`, Evidence prose and `Findings` are free text, and a number in them reads the same whether it
+was measured, estimated, or remembered. `Measured:` binds one to the output behind it:
+
+```
+- M1: `node bench.js` reports the fanout load. Measured: `1799.9`
+```
+
+Completion requires that literal in the check's own `M<n>` Evidence — the entry holding the command
+and its output. Opt-in, and deliberately not a rule over every number: measured against this
+repository's archive, that rule would reach 847 inline-code spans, mostly version strings, counts,
+and quoted references that appear in no command output, and each would be a false stop.
+
 ## Domain lenses
 
 Keel's core is pure process; it ships no domain knowledge and no decisions of its own. Alongside

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.63.0 -->
+<!-- keel:start version=5.65.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.63.0",
+  "version": "5.65.0",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.63.0",
+  "version": "5.65.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.63.0",
+  "version": "5.65.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/validate_plugin.py

@@ -38,8 +38,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.63.0"
-PROTOCOL_VERSION = "5.63.0"
+PACKAGE_VERSION = "5.65.0"
+PROTOCOL_VERSION = "5.65.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
@@ -28061,6 +28061,536 @@ def validate_the_routing_rule_reaches_the_decision_scenario() -> int:
     return 0
 
 
+def validate_a_claim_names_what_would_falsify_it_scenario() -> int:
+    """Issue #132: an honest red does not mean the check can catch the defect.
+
+    A consistency check whose red was real, whose signature predicted it, and
+    whose green was real stayed green through a 1000x unit error — the one thing
+    it existed to catch — because `pytest.approx` carries a default absolute
+    tolerance. `.red` proves the check failed before the implementation existed
+    and `Fails with:` predicts the red of an *absent* feature; neither says
+    anything about the red of a *broken* one. `Detects:` declares the injection
+    that answers the third question, in the same shape: inside the check text, so
+    it enters the fingerprint, and enforced by requiring its literal in Evidence.
+    """
+    label = "a-claim-names-what-would-falsify-it"
+    mutation = "sed -i s/0.0005/0.5/ run_sta.py"
+    failure = "assert 5e-16 == 5e-13"
+
+    with tempfile.TemporaryDirectory(prefix="keel-detects-") as raw:
+        root = Path(raw)
+
+        def start(name: str, **kwargs) -> dict:
+            return strategy_probe_start(root, name, strategy_probe_task(**kwargs))
+
+        def commands_of(payload: dict) -> list[dict]:
+            contract = payload.get("contract") or {}
+            capsule = contract.get("capsule") or {}
+            return ((capsule.get("verification") or {}).get("commands") or [])
+
+        # M1 — two clauses on one check, both parsed. The failure signature comes
+        # first, so this is also the assertion that a signature no longer has to
+        # be the final clause.
+        chained = (
+            "M1: node test.js asserts the public behavior. "
+            f"Fails with: `boom` Detects: `{mutation}` -> `{failure}`",
+        )
+        payload = start("chained", strategy="vertical-tdd", commands=chained)
+        if payload.get("status") != "pass":
+            report(
+                f"{label}: Detects: is not parsed — a check carrying a failure "
+                "signature followed by an injection clause was refused; got "
+                f"{payload.get('status')!r} {problem_text(payload)!r}."
+            )
+            return 1
+        compiled = commands_of(payload)
+        if len(compiled) != 1:
+            report(f"{label}: the chained check did not compile to one check; {compiled!r}")
+            return 1
+        entry = compiled[0]
+        if entry.get("failsWith") != "boom":
+            report(
+                f"{label}: Detects: is not parsed — the failure signature was "
+                f"lost when a clause followed it; got {entry!r}."
+            )
+            return 1
+        detects = entry.get("detects") or {}
+        if detects.get("mutation") != mutation or detects.get("failure") != failure:
+            report(
+                f"{label}: Detects: is not parsed — the compiled check does not "
+                f"carry the declared injection; got {entry!r}."
+            )
+            return 1
+        # The clause is inside the check text, so it is inside the fingerprint.
+        # Without this, an injection edited after the run would be invisible.
+        other = start(
+            "chained-edited",
+            strategy="vertical-tdd",
+            commands=(
+                "M1: node test.js asserts the public behavior. "
+                f"Fails with: `boom` Detects: `{mutation}` -> `assert 1 == 2`",
+            ),
+        )
+        first = str((payload.get("contract") or {}).get("fingerprint") or "")
+        second = str((other.get("contract") or {}).get("fingerprint") or "")
+        if not first or first == second:
+            report(
+                f"{label}: editing the declared injection did not move the "
+                f"fingerprint; {first!r} vs {second!r}."
+            )
+            return 1
+
+        # M1, second half — the declaration is enforced at completion, against a
+        # `.detects` Evidence entry for the same check. The clause is a claim Keel
+        # records: it never runs the mutation, so what completion holds is that
+        # the declared failure appears in what the author recorded.
+        def complete(name: str, detects_evidence: str | None) -> dict:
+            repo = root / name
+            evidence = [
+                "    - Contract: pending",
+                "    - M1: pass. node test.js reported the behavior.",
+                "    - M1.red: fail. `boom` as predicted.",
+                "    - M1.green: pass.",
+            ]
+            if detects_evidence is not None:
+                evidence.append(f"    - M1.detects: {detects_evidence}")
+            task = "\n".join(
+                [
+                    "- [x] 1.1 Injection probe",
+                    "  - Owner: claude",
+                    "  - Mode: implementation",
+                    "  - Covers:",
+                    "    - E1: the task proves its own behavior",
+                    "  - Read:",
+                    "    - README.md",
+                    "  - Touch:",
+                    "    - src/example.js",
+                    "  - Verify:",
+                    "    - Strategy: vertical-tdd",
+                    "    - M1: node test.js asserts the public behavior. "
+                    f"Fails with: `boom` Detects: `{mutation}` -> `{failure}`",
+                    "  - Evidence:",
+                    *evidence,
+                    "    - Review:",
+                    "      - Status: pass",
+                    "      - Acceptance check: the behavior is proven.",
+                    "      - Scope check: only Touch changed.",
+                    "      - Findings: none.",
+                    "    - Blocker: none",
+                    "    - Reauthorizations: none",
+                ]
+            )
+            write_gate_fixture(repo, tasks=task)
+            started = run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--record", "--json",
+            )
+            try:
+                anchor_value = str(
+                    (json.loads(started.stdout).get("contract") or {}).get(
+                        "fingerprint"
+                    )
+                    or ""
+                )
+            except json.JSONDecodeError:
+                anchor_value = ""
+            if not anchor_value:
+                return {"status": "unstarted", "problems": [{"message": started.stdout[:300]}]}
+            done = run_keel(
+                repo, "gate", "task-complete", "--change", "demo", "--task", "1.1",
+                "--json",
+            )
+            try:
+                return json.loads(done.stdout)
+            except json.JSONDecodeError:
+                return {"status": "unparsed", "problems": [{"message": done.stdout[:400]}]}
+
+        absent = complete("no-detects", None)
+        if absent.get("status") == "pass":
+            report(
+                f"{label}: Detects: is not enforced — a declared injection with "
+                "no `.detects` Evidence completed cleanly."
+            )
+            return 1
+        if "missing-injection-evidence" not in problem_codes(absent):
+            report(
+                f"{label}: Detects: is not enforced — an absent `.detects` was "
+                f"refused under another diagnostic; {problem_codes(absent)!r} "
+                f"{problem_text(absent)!r}."
+            )
+            return 1
+        wrong = complete("wrong-detects", "ran the mutation; it still passed.")
+        if wrong.get("status") == "pass":
+            report(
+                f"{label}: Detects: is not enforced — a `.detects` recording "
+                "something other than the declared failure completed cleanly."
+            )
+            return 1
+        if "injection-missing-declared-failure" not in problem_codes(wrong):
+            report(
+                f"{label}: a `.detects` lacking the declared failure was "
+                f"refused under another diagnostic; {problem_codes(wrong)!r} "
+                f"{problem_text(wrong)!r}."
+            )
+            return 1
+        right = complete("good-detects", f"fail, as declared: `{failure}`.")
+        if right.get("status") != "pass":
+            report(
+                f"{label}: a `.detects` carrying the declared failure was still "
+                f"refused; {problem_codes(right)!r} {problem_text(right)!r}."
+            )
+            return 1
+
+        # M2 — a (regression) check may declare one. It has no honest red by
+        # construction and is exempt from .red/.green, so an injection is the
+        # only mechanism that can show it is not vacuous: this is where the
+        # clause is worth most, which is why the report's suggested refusal here
+        # was narrowed rather than adopted.
+        regression = start(
+            "regression",
+            strategy="vertical-tdd",
+            commands=(
+                "M1: node test.js asserts the new behavior. Fails with: `boom`",
+                f"M2 (regression): node all.js stays green. Detects: `{mutation}` -> `{failure}`",
+            ),
+        )
+        if regression.get("status") != "pass":
+            report(
+                f"{label}: regression check may not declare an injection; got "
+                f"{regression.get('status')!r} {problem_text(regression)!r}."
+            )
+            return 1
+        second_entry = next(
+            (e for e in commands_of(regression) if e.get("label") == "M2"), {}
+        )
+        if not (second_entry.get("detects") or {}).get("failure"):
+            report(
+                f"{label}: regression check may not declare an injection — the "
+                f"clause was dropped; got {second_entry!r}."
+            )
+            return 1
+
+        # M3 — a malformed clause is named, not ignored. Both shapes: one literal
+        # with no arrow, and an arrow with nothing after it.
+        for name, clause in (
+            ("one-literal", f"Detects: `{mutation}`"),
+            ("no-target", f"Detects: `{mutation}` ->"),
+        ):
+            bad = start(
+                name,
+                strategy="vertical-tdd",
+                commands=(f"M1: node test.js asserts the behavior. {clause}",),
+            )
+            if bad.get("status") == "pass":
+                report(
+                    f"{label}: a malformed injection clause ({name}) was "
+                    "silently ignored, which leaves the author believing an "
+                    "injection is enforced when none was parsed."
+                )
+                return 1
+            if "malformed-injection" not in problem_codes(bad):
+                report(
+                    f"{label}: a malformed injection clause ({name}) was "
+                    "silently ignored under another diagnostic; got "
+                    f"{problem_codes(bad)!r} {problem_text(bad)!r}."
+                )
+                return 1
+        # A marker inside inline code is quoted material, not a declaration —
+        # which is what lets this repository's own tasks write about the clause.
+        quoted = start(
+            "quoted",
+            strategy="vertical-tdd",
+            commands=(
+                "M1: node test.js asserts that a check may close with "
+                "`Detects:` and two literals. Fails with: `boom`",
+            ),
+        )
+        if quoted.get("status") != "pass":
+            report(
+                f"{label}: a clause named inside inline code was silently "
+                f"ignored as a declaration; got {problem_text(quoted)!r}."
+            )
+            return 1
+
+        # 1.2 — `Measured:` binds a literal to the check's own recorded output.
+        # The failure class it answers is a number that reads like a measurement
+        # and is an estimate or a recollection; the one instance of it that was
+        # caught in the reporting session was caught exactly this way, by sitting
+        # in a clause the gate held against recorded output.
+        measured_literal = "1799.9"
+
+        def complete_measured(name: str, m1_evidence: str, clause: str) -> dict:
+            repo = root / name
+            task = "\n".join(
+                [
+                    "- [x] 1.1 Measurement probe",
+                    "  - Owner: claude",
+                    "  - Mode: implementation",
+                    "  - Covers:",
+                    "    - E1: the task proves its own behavior",
+                    "  - Read:",
+                    "    - README.md",
+                    "  - Touch:",
+                    "    - src/example.js",
+                    "  - Verify:",
+                    "    - Strategy: vertical-tdd",
+                    f"    - M1: node test.js reports the fanout load.{clause}",
+                    "  - Evidence:",
+                    "    - Contract: pending",
+                    f"    - M1: {m1_evidence}",
+                    "    - M1.red: fail. the reader did not exist.",
+                    "    - M1.green: pass.",
+                    "    - Review:",
+                    "      - Status: pass",
+                    "      - Acceptance check: the behavior is proven.",
+                    "      - Scope check: only Touch changed.",
+                    "      - Findings: none.",
+                    "    - Blocker: none",
+                    "    - Reauthorizations: none",
+                ]
+            )
+            write_gate_fixture(repo, tasks=task)
+            run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--record", "--json",
+            )
+            done = run_keel(
+                repo, "gate", "task-complete", "--change", "demo", "--task", "1.1",
+                "--json",
+            )
+            try:
+                return json.loads(done.stdout)
+            except json.JSONDecodeError:
+                return {"status": "unparsed", "problems": [{"message": done.stdout[:400]}]}
+
+        estimated = complete_measured(
+            "measured-absent",
+            "pass. node test.js reported a fanout load of 1200 fF.",
+            f" Measured: `{measured_literal}`",
+        )
+        if estimated.get("status") == "pass":
+            report(
+                f"{label}: Measured: is not enforced — a declared literal absent "
+                "from the check's own recorded output completed cleanly, which is "
+                "an estimate presented as a measurement."
+            )
+            return 1
+        if "measurement-missing-from-evidence" not in problem_codes(estimated):
+            report(
+                f"{label}: a declared measurement absent from the output was "
+                f"refused under another diagnostic; {problem_codes(estimated)!r} "
+                f"{problem_text(estimated)!r}."
+            )
+            return 1
+        real = complete_measured(
+            "measured-present",
+            f"pass. node test.js reported a fanout load of {measured_literal} fF.",
+            f" Measured: `{measured_literal}`",
+        )
+        if real.get("status") != "pass":
+            report(
+                f"{label}: a declared measurement present in the output was "
+                f"refused; {problem_codes(real)!r} {problem_text(real)!r}."
+            )
+            return 1
+        # D4 — opt-in. A number in Evidence that no check declared is required
+        # nowhere: the universal rule was declined on measurement, because in this
+        # repository's own archive it would reach 847 inline-code spans, most of
+        # them version strings, computed counts, and quoted references.
+        undeclared = complete_measured(
+            "measured-undeclared",
+            "pass. node test.js reported `1200` fF across `2433` fanout pins.",
+            "",
+        )
+        if undeclared.get("status") != "pass":
+            report(
+                f"{label}: numbers in Evidence with no `Measured:` clause were "
+                f"refused, so the opt-in boundary did not hold; "
+                f"{problem_codes(undeclared)!r} {problem_text(undeclared)!r}."
+            )
+            return 1
+
+    # 1.3 — the clauses are documented where the first one is documented. A
+    # vocabulary an author cannot discover is a vocabulary nobody declares.
+    readme = (ROOT / "README.md").read_text(encoding="utf-8")
+    agents = (ROOT / "AGENTS.md").read_text(encoding="utf-8")
+    for needle, why in (
+        ("Detects:", "the injection clause must be named"),
+        ("Measured:", "the measurement clause must be named"),
+    ):
+        if needle not in readme:
+            report(
+                f"{label}: README does not name {needle} — {why}, and a clause "
+                "an author cannot find is a clause nobody declares."
+            )
+            return 1
+        if needle not in agents:
+            report(
+                f"{label}: the protocol's verification discipline does not name "
+                f"{needle} — {why}."
+            )
+            return 1
+    flat_readme = re.sub(r"\s+", " ", readme)
+    for needle, why in (
+        ("records the claim", "the README must say Keel does not judge the injection"),
+        ("does not run", "the README must say Keel does not run the mutation"),
+    ):
+        if needle not in flat_readme:
+            report(f"{label}: README does not name Detects: honestly — {why}.")
+            return 1
+    # The chaining is taught by the example rather than by prose about it: a
+    # reader copies the example, and an example showing one clause teaches that
+    # one clause is all there is.
+    chained_example = re.search(
+        r"Fails with: `[^`]+` Detects: `[^`]+` -> `[^`]+`", readme
+    )
+    if not chained_example:
+        report(
+            f"{label}: README does not name Detects: in a worked example beside "
+            "a failure signature, so a reader learns the clauses are mutually "
+            "exclusive from the only example they have."
+        )
+        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_negation_is_not_a_marker_scenario() -> int:
+    """Issue #144: `Not resolved here:` was read as `Resolved here:`.
+
+    The marker scan's `\\b` sits at the space inside the negation, so a finding
+    that said in as many words it was *not* resolved here had the next word read
+    as its resolution evidence — a dismissal read as a repair, then refused for
+    lacking repair evidence. 5.42.0 established that a quoted marker is a
+    quotation; a negated one is the same class and was not covered.
+    """
+    label = "a-negation-is-not-a-marker"
+
+    def findings_task(findings: str) -> str:
+        return "\n".join(
+            [
+                "- [x] 1.1 Findings probe",
+                "  - Owner: claude",
+                "  - Mode: implementation",
+                "  - Covers:",
+                "    - E1: the task proves its own behavior",
+                "  - Read:",
+                "    - README.md",
+                "  - Touch:",
+                "    - src/example.js",
+                "  - Verify:",
+                "    - Strategy: vertical-tdd",
+                "    - M1: node test.js asserts the public behavior",
+                "  - Evidence:",
+                "    - Contract: pending",
+                "    - M1: pass. node test.js reported the behavior.",
+                "    - M1.red: fail. the behavior did not exist.",
+                "    - M1.green: pass.",
+                "    - Review:",
+                "      - Status: pass",
+                "      - Acceptance check: the behavior is proven.",
+                "      - Scope check: only Touch changed.",
+                f"      - Findings: {findings}",
+                "    - Blocker: none",
+                "    - Reauthorizations: none",
+            ]
+        )
+
+    with tempfile.TemporaryDirectory(prefix="keel-negation-") as raw:
+        root = Path(raw)
+
+        def complete(name: str, findings: str) -> dict:
+            repo = root / name
+            write_gate_fixture(repo, tasks=findings_task(findings))
+            run_keel(
+                repo, "gate", "task-start", "--change", "demo", "--task", "1.1",
+                "--record", "--json",
+            )
+            done = run_keel(
+                repo, "gate", "task-complete", "--change", "demo", "--task", "1.1",
+                "--json",
+            )
+            try:
+                return json.loads(done.stdout)
+            except json.JSONDecodeError:
+                return {"status": "unparsed", "problems": [{"message": done.stdout[:400]}]}
+
+        # M1 — the text that produced #144, verbatim in shape.
+        negated = complete(
+            "negated",
+            "one, still open. The count is derivable from the declarations the "
+            "module reads. Not resolved here: it is a different module and would "
+            "be scope expansion. Durable owner: https://example.com/issues/1",
+        )
+        if negated.get("status") != "pass":
+            report(
+                f"{label}: names neither a check nor a path — a finding saying it "
+                "was *not* resolved here, closing with a durable owner, was "
+                f"refused; {problem_codes(negated)!r} {problem_text(negated)!r}."
+            )
+            return 1
+        if "resolution evidence" in problem_text(negated).lower():
+            report(
+                f"{label}: the negated phrase still produced a resolution-evidence "
+                f"diagnostic; {problem_text(negated)!r}."
+            )
+            return 1
+
+        # M2 — the positive control, in all three opening positions. Without it
+        # the narrowing could pass by recognizing no marker anywhere.
+        for name, findings in (
+            ("opens-value", "Resolved here: M9"),
+            ("after-break", "one, and it was fixed.\n        Resolved here: M9"),
+            ("after-stop", "one, and it was fixed. Resolved here: M9"),
+        ):
+            payload = complete(name, findings)
+            if payload.get("status") == "pass":
+                report(
+                    f"{label}: stopped recognizing a real marker ({name}) — a "
+                    "`Resolved here:` naming a check this task does not declare "
+                    "completed cleanly."
+                )
+                return 1
+            if "M9" not in problem_text(payload):
+                report(
+                    f"{label}: stopped recognizing a real marker ({name}) — the "
+                    f"refusal does not name the cited check; {problem_text(payload)!r}."
+                )
+                return 1
+
+        # M3 — a marker that opens no clause is refused, not ignored, and the
+        # refusal names the rule so the author is not told to add what they wrote.
+        swallowed = complete(
+            "swallowed", "one, and the fix was Resolved here: M1 in passing"
+        )
+        if swallowed.get("status") == "pass":
+            report(
+                f"{label}: a finding whose only marker opens no clause completed "
+                "cleanly, so it carried no disposition and nothing said so."
+            )
+            return 1
+        # Asserted on the whole phrase, not the word: `opens` alone matches
+        # inside `openspec`, which the same diagnostic already prints, and the
+        # assertion was vacuous until this was tightened.
+        if "opens its clause" not in problem_text(swallowed).lower():
+            report(
+                f"{label}: does not name the opening requirement — an author "
+                "whose sentence visibly contains a marker is told to add a "
+                f"disposition; {problem_text(swallowed)!r}."
+            )
+            return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
 SCENARIOS: tuple = (
     ("stateless-continuity", validate_stateless_continuity_scenario),
     ("core-gates", validate_core_gates_scenario),
@@ -28415,6 +28945,14 @@ SCENARIOS: tuple = (
         "the-routing-rule-reaches-the-decision",
         validate_the_routing_rule_reaches_the_decision_scenario,
     ),
+    (
+        "a-claim-names-what-would-falsify-it",
+        validate_a_claim_names_what_would_falsify_it_scenario,
+    ),
+    (
+        "a-negation-is-not-a-marker",
+        validate_a_negation_is_not_a_marker_scenario,
+    ),
 )
 
 

package/src/core/gates.js

@@ -672,7 +672,24 @@ function transientOwnerMessage(candidate) {
 // swallow and changes nothing about why this one is narrow. The match is
 // global because each resolved claim owes its own evidence; checking only the
 // first would let a second one assert itself for free.
-const RESOLVED_HERE = /\bresolved here\s*:[ \t]*(\S*)/gi;
+// A marker is a disposition only where it OPENS its clause: the start of the
+// value, a line break, or sentence-ending punctuation may precede it, and a word
+// may not. `Not resolved here:` contains the marker and means its opposite, and a
+// `\b` boundary sat happily at the space inside it — the negation was read as a
+// resolution claim and the next word, `it`, as its evidence, so a dismissal was
+// read as a repair and then refused for lacking repair evidence (issue #144).
+// Quoting was the first way a marker could appear without being one (5.42.0);
+// negating it is the second.
+//
+// Written as a lookbehind so the captures keep reading from the same offsets —
+// every rule here is positional, and a rule that shortened the text would move
+// what they read.
+const CLAUSE_OPENING = "(?<=^|[\\n.;:!?\u2014\u2013])[ \\t]*";
+
+const RESOLVED_HERE = new RegExp(
+  `${CLAUSE_OPENING}resolved here\\s*:[ \\t]*(\\S*)`,
+  "gi"
+);
 
 // Resolution evidence is deliberately narrower than a durable owner. An
 // `http`/`https` reference says someone else will do the work later, which is
@@ -714,8 +731,24 @@ function resolutionEvidenceVerdict(repo, value, commands, change) {
 // next token, so a shortened text would move what they read. The original is
 // kept for anything reported back, since a diagnostic quoting the blanked copy
 // would show the author a sentence with holes in it.
-const DISPOSITION_MARKER =
-  /\b(?:resolved here|durable owner|discard (?:reason|rationale))\s*:/gi;
+// The same opening rule, for the same reason. Narrowing only the capture would
+// leave a negated marker counted as a disposition being *present* while it
+// supplied no evidence — a finding accepted as disposed with nothing behind it,
+// which is worse than either half of the defect alone.
+// The marker vocabulary wherever it appears, with no opening rule. Two different
+// questions are asked of this text and they need different patterns. *Blanking* a
+// marker inside a quoted span asks "is this marker text?" — and inside a span the
+// character before it is a backtick, so an opening rule would refuse to blank it
+// and the quotation would survive into the recognition scan. *Recognizing* a
+// disposition asks "does this marker open a clause?", which is the narrower
+// question `DISPOSITION_MARKER` below answers.
+const MARKER_VOCABULARY =
+  /(?:resolved here|durable owner|discard (?:reason|rationale))\s*:/gi;
+
+const DISPOSITION_MARKER = new RegExp(
+  `${CLAUSE_OPENING}(?:resolved here|durable owner|discard (?:reason|rationale))\\s*:`,
+  "gi"
+);
 
 function withoutQuotedMarkers(text) {
   return String(text || "").replace(/`[^`\n]*`/g, (span) =>
@@ -725,7 +758,7 @@ function withoutQuotedMarkers(text) {
     // span would destroy the very path the rule exists to read. Measured: the
     // first draft of this function did exactly that, and both the backticked
     // owner path and the backticked resolution path started failing.
-    span.replace(DISPOSITION_MARKER, (marker) => " ".repeat(marker.length))
+    span.replace(MARKER_VOCABULARY, (marker) => " ".repeat(marker.length))
   );
 }
 
@@ -1022,6 +1055,68 @@ function completionChecks(repo, task, contract = null, changeVerify = null, chan
       );
     }
   }
+  // A declared measurement is held against the check's own bare `M<n>` Evidence
+  // — the entry where the command and its output are recorded. A literal that
+  // output does not contain is either unpasted or not measured, and free prose
+  // gives a reader no way to tell those from a real reading (issue #132).
+  for (const entry of contract ? contract.capsule.verification.commands : []) {
+    if (!entry.measured || !entry.label) continue;
+    const recorded = evidenceValue(task, entry.label);
+    if (!isConcrete(recorded)) continue;
+    if (!String(recorded).includes(entry.measured)) {
+      problems.push(
+        problem(
+          "measurement-missing-from-evidence",
+          `${entry.label} declares the measurement \`${entry.measured}\`, and `
+            + `its recorded ${entry.label} Evidence does not contain that `
+            + "string. Paste the output the number came from, or correct the "
+            + "declaration — which moves the contract fingerprint, because a "
+            + "number reconciled to the output after the run is a transcription "
+            + "of it.",
+        )
+      );
+    }
+  }
+  // A declared injection is enforced whatever the strategy and whatever the
+  // tags. It is not a red-green artifact: `.red` proves the check failed before
+  // the implementation existed and a failure signature predicts the red of an
+  // *absent* feature, while an injection answers what neither can — whether the
+  // check still fails once the feature exists and is broken. A `(regression)`
+  // check is where it matters most, because it has no honest red at all, so
+  // exempting it here would remove the clause from its best use (issue #132).
+  //
+  // Keel does not run the mutation. What it holds is that the failure the author
+  // declared before the run appears in what they recorded after it.
+  for (const entry of contract ? contract.capsule.verification.commands : []) {
+    if (!entry.detects || !entry.label) continue;
+    const recorded = evidenceValue(task, `${entry.label}.detects`);
+    if (!isConcrete(recorded)) {
+      problems.push(
+        problem(
+          "missing-injection-evidence",
+          `${entry.label} declares that \`${entry.detects.mutation}\` must make `
+            + `it fail with \`${entry.detects.failure}\`, and records no `
+            + `${entry.label}.detects Evidence. Run the mutation, record what it `
+            + "printed, and revert it — a green check that has never been made "
+            + "to fail on the defect it names is not evidence that it would.",
+        )
+      );
+      continue;
+    }
+    if (!String(recorded).includes(entry.detects.failure)) {
+      problems.push(
+        problem(
+          "injection-missing-declared-failure",
+          `${entry.label} declares that its injection fails with `
+            + `\`${entry.detects.failure}\`, and the recorded `
+            + `${entry.label}.detects Evidence does not contain that string. `
+            + "Record what the mutation actually printed, or correct the "
+            + "declaration — which moves the contract fingerprint, because an "
+            + "injection edited after the run is a transcription of it.",
+        )
+      );
+    }
+  }
   const strategy = contract
     ? contract.capsule.verification.strategy.toLowerCase()
     : "";
@@ -1207,6 +1302,16 @@ function completionChecks(repo, task, contract = null, changeVerify = null, chan
             + "must still do is `Durable owner:` naming "
             + `${DURABLE_OWNER_FORMS}; one deliberately not being done is a `
             + "`Discard reason:`/`Discard rationale:` prefix."
+            // Said only where a marker is visibly present and was not counted,
+            // which is the one case where "carry a disposition" reads as a
+            // contradiction of what the author can see they wrote.
+            + (mentionsUnopenedMarker(scannable)
+              ? " A marker counts only where it opens its clause — after the "
+                + "start of the value, a line break, or sentence-ending "
+                + "punctuation. This text mentions one mid-sentence, so it was "
+                + "read as prose; move it to the start of its own clause, or "
+                + "keep it as prose and add the disposition separately."
+              : "")
         )
       );
     }
@@ -1214,6 +1319,15 @@ function completionChecks(repo, task, contract = null, changeVerify = null, chan
   return { problems, reviewProblems };
 }
 
+// Whether the text names a disposition marker somewhere that is not a clause
+// opening. Used only to add a sentence to a refusal, never to accept anything:
+// a marker mid-sentence stays prose, and this is what tells its author why.
+function mentionsUnopenedMarker(text) {
+  const body = String(text || "");
+  if (!new RegExp(MARKER_VOCABULARY.source, "i").test(body)) return false;
+  return !new RegExp(DISPOSITION_MARKER.source, "i").test(body);
+}
+
 function taskComplete(repo, options) {
   const selection = loadSelection(repo, options);
   const task = selection.selected[0];

package/src/core/task-contract.js

@@ -153,28 +153,88 @@ const RED_GREEN_VERIFICATION_STRATEGIES = new Set([
 // Tags an M<n> check may carry after its label, as a comma-separated set.
 const COMMAND_TAGS = new Set(["fast", "full", "regression"]);
 
-// A check may end by declaring the failure its red is expected to show, so that
-// what the red proves is written down before the red is run. The clause closes
-// the check: `Fails with:` followed by one inline-code literal and nothing more.
-// End-anchored on purpose — a check that describes this rule mentions the marker
-// mid-sentence, and a mention is not a declaration.
-const FAILURE_SIGNATURE = /\bFails with:[ \t]*`([^`\n]+)`[ \t]*$/i;
-const FAILURE_MARKER = /\bFails with:/i;
+// A check may end by declaring things about itself, so that each is written down
+// before the run it describes. Every clause has the same shape: it closes the
+// clause sequence with inline-code literals, it lives inside the check text and
+// therefore inside the contract fingerprint, and it is enforced by requiring its
+// literal in a named Evidence entry. Keel judges none of them.
+//
+// The clauses chain. A check is one line — `fieldValues` splits the field per
+// line and treats each as its own entry — so a single end-anchored slot would
+// make the clauses mutually exclusive, and the case that motivated `Detects:`
+// declares an injection beside a failure signature on one check (issue #132).
+//
+// Each is still anchored at the end of what remains, on purpose: a check that
+// describes this rule mentions a marker mid-sentence, and a mention is not a
+// declaration.
+//
+// - `Fails with:` — the failure the check's red must show. Predicts the red of an
+//   *absent* feature.
+// - `Detects:` — a mutation that puts a defect in, and the failure it must
+//   produce. Answers the question a red cannot: the red of a *broken* feature.
+//   The two can be entirely unrelated, which is the whole reason this exists.
+const DECLARATION_CLAUSES = [
+  {
+    name: "failure",
+    pattern: /\bFails with:[ \t]*`([^`\n]+)`[ \t]*$/i,
+    marker: /\bFails with:/i,
+    build: (match) => match[1].trim(),
+  },
+  {
+    name: "detects",
+    pattern: /\bDetects:[ \t]*`([^`\n]+)`[ \t]*->[ \t]*`([^`\n]+)`[ \t]*$/i,
+    marker: /\bDetects:/i,
+    build: (match) => ({
+      mutation: match[1].trim(),
+      failure: match[2].trim(),
+    }),
+  },
+  {
+    // `Measured:` — a literal the check's own recorded output must contain. The
+    // failure class is a number that reads like a measurement and is an estimate
+    // or a recollection; free prose cannot tell a reader which it is. Opt-in on
+    // purpose: a universal rule over every number in Evidence would reach 847
+    // inline-code spans in this repository's own archive, most of them version
+    // strings, counts the author computed, and quoted references that appear in
+    // no command output, and each would be a false stop.
+    name: "measured",
+    pattern: /\bMeasured:[ \t]*`([^`\n]+)`[ \t]*$/i,
+    marker: /\bMeasured:/i,
+    build: (match) => match[1].trim(),
+  },
+];
 
-// Classify a check's `Fails with:` marker. `signature` is the declared literal;
-// `malformed` marks a marker that is present and is not a closing clause — a
-// typo shape, and ignoring it would leave the author believing a signature is
-// enforced when none was parsed. A marker written inside inline code is quoted
-// material rather than a declaration, the meaning inline code already carries
-// here, which is what lets this file's own tasks name the marker.
-function failureSignature(check) {
-  const text = String(check || "");
-  const match = text.match(FAILURE_SIGNATURE);
-  if (match) return { signature: match[1].trim(), malformed: false };
+// Strip one matching trailing clause at a time until none matches, then report a
+// marker surviving in the remaining prose as malformed. Malformed rather than
+// ignored: a declaration that parsed as nothing reads to its author as a check
+// being enforced. A marker inside inline code is quoted material, the meaning
+// inline code already carries here, which is what lets this file's own tasks
+// name the markers.
+function declarationClauses(check) {
+  let text = String(check || "");
+  const declared = {};
+  for (let matched = true; matched; ) {
+    matched = false;
+    for (const clause of DECLARATION_CLAUSES) {
+      const match = text.match(clause.pattern);
+      if (!match) continue;
+      if (!(clause.name in declared)) declared[clause.name] = clause.build(match);
+      text = text.slice(0, match.index).replace(/[ \t]+$/, "");
+      matched = true;
+      break;
+    }
+  }
   const remainder = withoutInlineCode(text);
+  const malformed = {};
+  for (const clause of DECLARATION_CLAUSES) {
+    malformed[clause.name] =
+      !(clause.name in declared) && clause.marker.test(remainder);
+  }
   return {
-    signature: null,
-    malformed: FAILURE_MARKER.test(remainder),
+    signature: declared.failure == null ? null : declared.failure,
+    detects: declared.detects == null ? null : declared.detects,
+    measured: declared.measured == null ? null : declared.measured,
+    malformed,
   };
 }
 
@@ -226,6 +286,10 @@ function verification(task) {
         check: entry,
         failsWith: null,
         malformedSignature: false,
+        detects: null,
+        malformedInjection: false,
+        measured: null,
+        malformedMeasurement: false,
       };
     }
     const tags = (match[2] || "")
@@ -240,17 +304,25 @@ function verification(task) {
         check: entry,
         failsWith: null,
         malformedSignature: false,
+        detects: null,
+        malformedInjection: false,
+        measured: null,
+        malformedMeasurement: false,
       };
     }
     const check = normalizeText(match[3]);
-    const failure = failureSignature(check);
+    const clauses = declarationClauses(check);
     return {
       label: match[1],
       layer: tags.includes("fast") ? "fast" : "full",
       regression: tags.includes("regression"),
       check,
-      failsWith: failure.signature,
-      malformedSignature: failure.malformed,
+      failsWith: clauses.signature,
+      malformedSignature: clauses.malformed.failure,
+      detects: clauses.detects,
+      malformedInjection: clauses.malformed.detects,
+      measured: clauses.measured,
+      malformedMeasurement: clauses.malformed.measured,
     };
   });
   return {
@@ -443,6 +515,29 @@ function failureSignatureProblems(task) {
       });
       continue;
     }
+    if (entry.malformedMeasurement) {
+      problems.push({
+        code: "malformed-measurement",
+        message:
+          `${entry.label} carries a \`Measured:\` marker that does not close `
+          + "the check with a literal. Write it as `Measured: `<literal>`` at "
+          + "the end of the check, or fence the marker in inline code when the "
+          + "check is describing it rather than declaring one.",
+      });
+      continue;
+    }
+    if (entry.malformedInjection) {
+      problems.push({
+        code: "malformed-injection",
+        message:
+          `${entry.label} carries a \`Detects:\` marker that does not close `
+          + "the check with a mutation and the failure it must produce. Write "
+          + "it as `Detects: `<mutation>` -> `<failure>`` at the end of the "
+          + "check, or fence the marker in inline code when the check is "
+          + "describing it rather than declaring one.",
+      });
+      continue;
+    }
     if (!entry.failsWith) continue;
     if (!redGreen) {
       problems.push({
@@ -1229,6 +1324,8 @@ function compileTaskContract(repo, change, task) {
           // field is what the gate reads. Emitted only when declared, so every
           // check without one keeps the capsule shape and fingerprint it had.
           if (entry.failsWith) emitted.failsWith = entry.failsWith;
+          if (entry.detects) emitted.detects = entry.detects;
+          if (entry.measured) emitted.measured = entry.measured;
           return emitted;
         }),
     },