@christang/keel 5.64.0 → 5.65.0

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.64.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.64.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.64.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.64.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.64.0"
-PROTOCOL_VERSION = "5.64.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
@@ -28459,6 +28459,138 @@ def validate_a_claim_names_what_would_falsify_it_scenario() -> int:
     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),
@@ -28817,6 +28949,10 @@ SCENARIOS: tuple = (
         "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))
   );
 }
 
@@ -1269,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."
+              : "")
         )
       );
     }
@@ -1276,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];