@christang/keel 5.72.0 → 5.73.1

package/README.md

@@ -287,8 +287,8 @@ because the only thing the protocol says about merging is that the agent may not
 
 `merge: human` says the opposite. A bare `repository` is refused — "nobody reviews this" is only honest
 beside what replaced the reviewer. It is not a permission: `authorize:` has no `merge` entry and should
-not gain one. Keel reads the declaration and never GitHub, so it cannot check that auto-merge is really
-on; it reports what you declared.
+not gain one. Keel reads the declaration and never GitHub, so it cannot check that your repository really
+merges that way; it reports what you declared.
 
 ### Full vs Lite
 

package/assets/bootstrap/AGENTS.md

@@ -1,4 +1,4 @@
-<!-- keel:start version=5.72.0 -->
+<!-- keel:start version=5.73.1 -->
 ## 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.72.0",
+  "version": "5.73.1",
   "license": "MIT",
   "repository": {
     "type": "git",

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

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.72.0",
+  "version": "5.73.1",
   "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.72.0",
+  "version": "5.73.1",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/scripts/bump_version.js

@@ -165,13 +165,19 @@ function main() {
 
   prependChangelogEntry(newVersion);
 
+  // A version is released by landing its pull request: publish.yml's `land`
+  // job merges it once full-gate passes, then publishes, tags, and releases in
+  // the same run. It skips a version whose tag already exists, so a tag pushed
+  // by hand with no release means nothing publishes it at all (#162).
   process.stdout.write(
     `\nDone. Next:\n` +
-      `  1. Edit keel/CHANGELOG.md ${newVersion} entry.\n` +
+      `  1. Write the ${newVersion} entry into its stub in keel/CHANGELOG.md.\n` +
       `  2. npm test\n` +
-      `  3. git commit -am "${newVersion}"\n` +
-      `  4. git tag v${newVersion} && git push --follow-tags && git push origin v${newVersion}\n` +
-      `  5. gh release create v${newVersion} --title v${newVersion} --notes "..."\n`
+      `  3. Commit on a branch (git add -A, so an archived change is included),\n` +
+      `     push it, and open a pull request into main.\n` +
+      `  When full-gate passes, the land job merges it, publishes ${newVersion} to npm,\n` +
+      `  and creates tag v${newVersion} with its release. Do not tag by hand: the job\n` +
+      `  skips a version whose tag exists, and a pushed tag alone publishes nothing.\n`
   );
 }
 

package/scripts/validate_plugin.py

@@ -38,8 +38,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.72.0"
-PROTOCOL_VERSION = "5.72.0"
+PACKAGE_VERSION = "5.73.1"
+PROTOCOL_VERSION = "5.73.1"
 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
@@ -5031,6 +5031,71 @@ def validate_section_boundary_scenario() -> int:
             report(repr(problems_of(unstarted["tail"])))
             return 1
 
+        # Cells 5 and 6: the heading half of the boundary, in the tail, where
+        # it is the only half that applies. An indented `##` line inside the
+        # section's own body is not a heading, and the entry after it must still
+        # be judged. The tolerant spelling `parseTasks()` uses for task bodies
+        # ends the section there and drops that entry without a word — issue
+        # #160, measured on the abandoned first attempt at #71 as `7bd6448`.
+        # Both readers are covered because each slices its own section.
+        indented = "  ## an indented line is not a heading\n"
+        indented_invalidates = (
+            "## Invalidates\n\n"
+            '- I1: "the wording that is now wrong" — README.md. Updated by: 1.1\n'
+            + indented
+            + '- I2: "wording nothing updates" — README.md.\n'
+        )
+        payload = start(
+            "invalidates-indented-tail",
+            section_boundary_tasks_md(
+                section=indented_invalidates, task=start_task, position="tail"
+            ),
+        )
+        if not readable(payload, "invalidates-indented-tail", "task-start"):
+            return 1
+        if not [
+            message
+            for message in closure_problems(payload, "invalidation-closure")
+            if "I2" in message
+        ]:
+            report(
+                f"{label} accepted an invalidation that closes nothing because "
+                "it follows an indented `##` line; the section ended at a line "
+                "that is not a heading."
+            )
+            report(repr(payload.get("problems")))
+            return 1
+
+        indented_coverage = (
+            "## Invalidates\n\n- None.\n\n"
+            "## Expectation Coverage\n\n"
+            "- E1: The task owns its file. Covered by: 1.1\n"
+            + indented
+            + "- E3: Nothing closes this one.\n"
+        )
+        payload = close(
+            "coverage-indented-tail",
+            section_boundary_tasks_md(
+                section=indented_coverage,
+                task=section_boundary_task("1.1", checked=True),
+                position="tail",
+            ),
+        )
+        if not readable(payload, "coverage-indented-tail", "change-close"):
+            return 1
+        if not [
+            message
+            for message in closure_problems(payload, "expectation-closure")
+            if "E3" in message
+        ]:
+            report(
+                f"{label} accepted an expectation that closes nothing because "
+                "it follows an indented `##` line; the section ended at a line "
+                "that is not a heading."
+            )
+            report(repr(payload.get("problems")))
+            return 1
+
     report(f"{label} scenario passed.")
     return 0
 
@@ -10016,6 +10081,48 @@ def validate_task_body_ends_at_heading_scenario() -> int:
                 "preceding task's fields."
             )
             return 1
+        # An indented `##` line is not a heading — issue #160. The tolerant
+        # test ended the task there, and a field declared after it with a
+        # documented default was replaced by that default without a word: the
+        # stop rule below vanished and task-start still passed. The fields are
+        # ordered so the dropped one is exactly such a field.
+        write_text(
+            repo / "openspec/changes/indented/tasks.md",
+            header
+            + "- [ ] 1.1 Exercise task contract\n"
+            "  - Covers:\n"
+            "    - E1: Public behavior passes.\n"
+            "  - Touch:\n"
+            "    - src/feature.js\n"
+            "  - Verify:\n"
+            "    - Strategy: evidence-first\n"
+            "    - Reason: this is a gate fixture; it exercises contract structure and has no executable behavior that can fail first\n"
+            "    - M1: node test.js asserts the recorded feed status\n"
+            "  - Evidence:\n"
+            "    - Contract: pending\n"
+            "    - M1: pending\n"
+            "  - Acceptance:\n"
+            "    - Public behavior passes.\n"
+            "    ## an indented line is not a heading\n"
+            "  - Stop Rules:\n"
+            "    - Stop on the rule declared after the indented line.\n"
+            "\n## Invalidates\n\n- None.\n",
+        )
+        indented = json.loads(
+            run_keel(
+                repo, "gate", "task-start", "--change", "indented", "--task",
+                "1.1", "--no-guard", "--json",
+            ).stdout
+        )
+        if "Stop on the rule declared after the indented line." not in json.dumps(
+            indented
+        ):
+            report(
+                "task-body-ends-at-heading: task-start dropped the fields "
+                "declared after an indented `##` line; the task ended at a line "
+                f"that is not a heading (status {indented.get('status')!r})."
+            )
+            return 1
         # --record must anchor the last task's own Contract line, not the stray
         # one planted in the trailing section.
         recorded = run_keel(

package/src/core/gates.js

@@ -13,6 +13,7 @@ const {
   declaredCommandLabels,
   field,
   isConcrete,
+  isHeadingLine,
   isPassingReviewStatus,
   parseTasks,
   unfilledToken,
@@ -1597,10 +1598,11 @@ function taskComplete(repo, options) {
 //
 // The task half is the task list already parsed for this file rather than a
 // second checkbox pattern, so it cannot drift from the boundary `parseTasks()`
-// applies to a task's own body. The heading half stays as it was: the two
-// spellings are not interchangeable, and unifying them truncates a tail-position
-// section at an indented `##` line inside its own body, which is this same
-// defect pointed the other way.
+// applies to a task's own body. The heading half is `isHeadingLine()`, the same
+// test `parseTasks()` uses. It must stay the column-zero one: the tolerant
+// spelling truncates a tail-position section at an indented `##` line inside
+// its own body and drops every entry after it, which is this same defect
+// pointed the other way (#160).
 function sectionBody(content, headingOffset, tasks) {
   const lines = content.split(/\r?\n/);
   const headingLine = content.slice(0, headingOffset).split(/\r?\n/).length - 1;
@@ -1609,7 +1611,7 @@ function sectionBody(content, headingOffset, tasks) {
     if (task.line > headingLine && task.line < end) end = task.line;
   }
   for (let cursor = headingLine + 1; cursor < end; cursor += 1) {
-    if (/^##\s+/.test(lines[cursor])) {
+    if (isHeadingLine(lines[cursor])) {
       end = cursor;
       break;
     }

package/src/core/task-contract.js

@@ -59,6 +59,17 @@ function unfilledToken(value) {
   return match ? match[0] : null;
 }
 
+// A heading is a `##` line at column zero. An indented one is text: inside a
+// task it belongs to the field that is open, inside a change-level section it
+// is not an entry. Both readers decide through this one test — issue #160.
+// The tolerant spelling `/^\s*##\s/` ended a task at an indented line and
+// dropped every field after it, and a field with a documented default was
+// replaced by that default without a word; in a section it dropped the entries
+// after the line with no refusal at all.
+function isHeadingLine(line) {
+  return /^##\s/.test(line);
+}
+
 function parseTasks(content) {
   const lines = content.split(/\r?\n/);
   const tasks = [];
@@ -75,16 +86,17 @@ function parseTasks(content) {
     });
   }
   for (let index = 0; index < tasks.length; index += 1) {
-    // A task body ends at the next task or the next `##` heading, whichever
-    // comes first. Without the heading bound a change-level section such as
-    // `## Invalidates` was appended to whichever field was open last — the
-    // Evidence, in every shipped template — so a token quoted there made the
-    // Evidence non-concrete and the gate blamed a task that was fine.
+    // A task body ends at the next task or the next `##` heading (see
+    // `isHeadingLine`), whichever comes first. Without the heading bound a
+    // change-level section such as `## Invalidates` was appended to whichever
+    // field was open last — the Evidence, in every shipped template — so a
+    // token quoted there made the Evidence non-concrete and the gate blamed a
+    // task that was fine.
     const nextTask =
       index + 1 < tasks.length ? tasks[index + 1].line : lines.length;
     let end = nextTask;
     for (let cursor = tasks[index].line + 1; cursor < nextTask; cursor += 1) {
-      if (/^\s*##\s/.test(lines[cursor])) {
+      if (isHeadingLine(lines[cursor])) {
         end = cursor;
         break;
       }
@@ -1538,6 +1550,7 @@ module.exports = {
   isConcrete,
   isPassingReviewStatus,
   loadTaskContract,
+  isHeadingLine,
   parseTasks,
   taskStartContractProblems,
   unfilledToken,