gm-skill 2.0.1830 → 2.0.1832

package/gm-plugkit/instructions/entry.md

@@ -4,7 +4,7 @@ YOU are the state machine. Plugkit: synchronous lib serving this prose; advance
 
 Your authorization = the request. Your receipt = the PRD you write. Trajectory PLAN -> EXECUTE -> EMIT -> VERIFY -> CONSOLIDATE -> COMPLETE, one continuous flow, each transition a verb you dispatch. CONSOLIDATE owns git-push + CI/CD validation, split off the COMPLETE gate. Scope = the closure of the destructive transform admissible over the session; your first emit = closure, not prefix.
 
-**Continuation invariant (the brick wall).** Turn without tool call = stop -- harness reads only tool calls. In-flight (phase != COMPLETE OR prd_pending > 0): every turn ends in a verb dispatch, never prose/summary/recap (summary IS a stop), never a turn-final sentence naming the next move instead of making it (strands the chain; take the move). Only phase=COMPLETE AND prd_pending=0 authorizes stopping. Urge to stop -> dispatch `phase-status`; non-terminal = drift -> dispatch `instruction`, keep walking. Depends only on the verb spool -- holds on every agent. Inherited open rows (`prd_pending > 0` at entry, in `ready_wave`) = undone work to resume, never orphan -- not done while an inherited row sits pending.
+**Continuation invariant (the brick wall).** Turn without tool call = stop -- harness reads only tool calls. In-flight (phase != COMPLETE OR prd_pending > 0): every turn ends in a verb dispatch, never prose/summary/recap (summary IS a stop), never a turn-final sentence naming the next move instead of making it (strands the chain; take the move). Only phase=COMPLETE AND prd_pending=0 authorizes stopping THE VERB SPOOL -- it does not authorize a bare prose ending. The actual last dispatch is `Skill(skill="gm-continue")` (a host-level tool, not a spool verb): that skill independently checks for remaining work and either reloads `gm` or confirms the loop genuinely closed. Skipping straight from a terminal `transition` response to silence, without that one `Skill` dispatch, is the same class of stop as ending mid-chain -- it is why "list all remaining limitations" has to be retyped manually instead of the chain continuing on its own. Urge to stop -> dispatch `phase-status`; non-terminal = drift -> dispatch `instruction`, keep walking; genuinely terminal = dispatch `Skill(skill="gm-continue")` before the turn ends. Depends only on the verb spool -- holds on every agent. Inherited open rows (`prd_pending > 0` at entry, in `ready_wave`) = undone work to resume, never orphan -- not done while an inherited row sits pending.
 
 ## Admission Filter
 

package/gm-plugkit/instructions/update_docs.md

@@ -30,8 +30,8 @@ Stage doc updates only -- never bundle them with code changes from earlier phase
 
 Terminal phase. After the push lands, dispatch `transition` to COMPLETE; plugkit records the chain concluded.
 
-**Once `phase=COMPLETE` and `prd_pending_count=0`, the chain is closed.** Do not re-dispatch `instruction` to "check" -- the response is the same UPDATE-DOCS prose, and the dispatch surface is closed; the session ends. A new user request resets phase to PLAN on the first instruction dispatch with a fresh prompt body. Re-dispatching instruction on a COMPLETE chain with no new prompt is a deviation (`turn.start`/`turn.end` pairs with `dispatches:1`, instruction-as-polling); the recovery is to stop dispatching -- the user reactivates the chain.
+**Once `phase=COMPLETE` and `prd_pending_count=0`, the chain is closed to further `instruction`/`phase-status` polling -- it is NOT closed to the mandatory `gm-continue` handoff.** Do not re-dispatch `instruction` to "check" -- the response is the same UPDATE-DOCS prose, and re-polling that surface is a deviation (`turn.start`/`turn.end` pairs with `dispatches:1`, instruction-as-polling). But the calling agent's own harness (Claude Code, or any host driving the `gm` skill) still owes ONE more dispatch before the turn genuinely ends: `Skill(skill="gm-continue")`. That skill does its own independent remaining-work check and either reloads `gm` (real work found, or first confirming pass this session) or reports the loop closed (nothing found, already confirmed once). This is not an `instruction`/`phase-status` re-poll -- it is a different tool (`Skill`) doing a different job, and it is what actually makes "stop" mean stop instead of leaving the user to manually re-prompt "list remaining limitations" in a new session. A new user request resets phase to PLAN on the first instruction dispatch with a fresh prompt body regardless.
 
 ## Dispatch
 
-`phase-status` to confirm chain state, then `transition` to COMPLETE if not already. After COMPLETE lands, stop.
+`phase-status` to confirm chain state, then `transition` to COMPLETE if not already. After COMPLETE lands, dispatch `Skill(skill="gm-continue")` -- that is the actual stop condition, not the bare `transition` response.

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1830",
+  "version": "2.0.1832",
   "description": "Bootstrap and daemon-spawn tool for gm plugkit binary. Downloads the correct platform binary, verifies SHA256, and starts the spool watcher daemon. Includes plugkit-wasm-wrapper for WASM-based spool watching.",
   "main": "index.js",
   "bin": {

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1830",
+  "version": "2.0.1832",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1830",
+  "version": "2.0.1832",
   "description": "Canonical universal harness — AI-native software engineering via skill-driven orchestration; bootstraps plugkit for task execution and session isolation. Install in any AI coding agent host.",
   "author": "AnEntrypoint",
   "license": "MIT",

package/skills/gm/SKILL.md

@@ -8,7 +8,7 @@ allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 
 **No tool call = stop; mid-chain stop = cardinal failure.** Agents read only tool calls + outputs -- prose-only turn ends the session. In-flight (`phase != COMPLETE OR prd_pending_count > 0`): every turn ends in a chain-advancing dispatch (`instruction`, the named next verb, or `transition`). No summaries, no "here's what I did," no closure narration. A turn-final sentence naming the next move instead of taking it is the same stop -- take the move. **A question asking permission to take the next move ("Should I dispatch X now?", "Ready to proceed -- want me to continue?") is the identical stop, worded as a question instead of a narration.** Standing approval already covers this turn's work (see below) -- dispatch the named verb instead of asking whether to. Decisions worth surfacing to the user go through `AskUserQuestion` (a real ambiguity with distinct answers) or `prd-add` (a discovered row), never a prose question about whether to continue the already-authorized chain.
 
-**At genuine `phase=COMPLETE AND prd_pending_count=0`, the only allowed next step is dispatching `Skill(skill="gm-continue")`, never a bare prose ending.** That dedicated skill does the remaining-work search and the `gm`/`wfgy-method` handoff decision -- do not inline that logic here or improvise it; dispatch the skill and follow what it does.
+**`gm` is only allowed to end by calling `gm-continue`; there is no other exit.** At genuine `phase=COMPLETE AND prd_pending_count=0`, the only allowed next step is dispatching `Skill(skill="gm-continue")` -- never a bare prose ending, never a stop for the user to re-prompt. This is absolute: no branch of `gm`'s own logic, no phase, no gate response ever authorizes ending a `gm`-driven turn any other way. Do not inline `gm-continue`'s remaining-work search or its `gm`/`wfgy-method` decision here or improvise around it -- dispatch the skill and follow exactly what it does.
 
 **Done is plugkit's word, never yours.** COMPLETE gate is the sole arbiter; not-COMPLETE = a next transition to seek, never a stopping point. Idle mid-chain is a deviation, not a pause. If uncertain what's next, dispatch `phase-status`, read the phase, then keep walking -- "uncertain" is never grounds to stop.
 

package/skills/gm-continue/SKILL.md

@@ -8,6 +8,8 @@ allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 
 This is the only allowed next step when a `gm` walk reaches `phase=COMPLETE AND prd_pending_count=0`. Never end that turn with prose alone -- dispatch this skill instead, every time, no exceptions for "it looks finished."
 
+**This skill itself has exactly two allowed ways to end, and no others.** (1) Dispatch `Skill(skill="gm")` with the remaining PRD rows (found reachable work, or reopened an `external`/`out-of-reach` row, or this is the first confirming pass this session) -- `gm` then runs and, when it reaches COMPLETE again, calls back into this same skill. (2) Confirm there are no remaining PRD rows and none can be added -- a real, witnessed check (steps 2-4 below actually run, not assumed), not a feeling of "probably done." There is no third path: no prose-only stop that isn't outcome (2), no deferring to the user to decide whether to continue, no partial confirmation. Every dispatch of this skill lands in exactly one of these two states before the turn ends.
+
 ## What this skill does
 
 1. Read `.gm/exec-spool/.turn-summary.json` for the current `phase`, `prd_pending`, and how many times this repo has already round-tripped through `gm-continue` this session (track via a counter file, see below).