gm-qwen 2.0.754 → 2.0.756

package/bin/plugkit.sha256

@@ -1,6 +1,6 @@
-337eac9e472c3a49e5a04521a6a623b1ccf14c0c47c723c3524e3612698d6591  plugkit-win32-x64.exe
-5f7a64a2d8fa972ad4350e0fb4b9b8756d6a3bff8e0e0fe25e96903dc1da3b47  plugkit-win32-arm64.exe
-2f9cd676778970e8e617de6bed921c220703df8f2314d257f867db1ed1281dd3  plugkit-darwin-x64
-ce1d9f7d83f7a06785ca77e84cea8aaf95933e22d8679df75e11737f758e7be6  plugkit-darwin-arm64
-28e6cb748948fb0ba836b8b63e6240a6f1e2dfb331414ded34d0d8d91ff8cc20  plugkit-linux-x64
-b4a85011af17a7cdc62ef81c8b2ea8bafbe4d0ac2f06e28001b035953d6fe30f  plugkit-linux-arm64
+fb30957c13634cf6c70fae0c43d06ea08d750ba0acf6aa458eb8d746b3b55b27  plugkit-win32-x64.exe
+9ec0d6fc086a491d6ac6fa220f83c93771bb36d2c14fdc3585b9343b08bd4536  plugkit-win32-arm64.exe
+764d862ab475b0168ee760b5fb825443bec02baeeaeb0f4d619a5296e821c30b  plugkit-darwin-x64
+0acab629fa681cd9682fc10abc21064f1813d550669d81cac3949c9439215cd3  plugkit-darwin-arm64
+df52e7f94176e9fb0bdb1b1bdb00d8a1b1d622fe44ee27625dcabba579c35c52  plugkit-linux-x64
+0b07cb8c3af4e6829b1d9b2584252f88dcf93d7bb30ee3816344d2a71810c8eb  plugkit-linux-arm64

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.250
+0.1.251

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.754",
+  "version": "2.0.756",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "plugkitVersion": "0.1.250"
+  "plugkitVersion": "0.1.251"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-qwen",
-  "version": "2.0.754",
+  "version": "2.0.756",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/skills/gm/SKILL.md

@@ -41,62 +41,43 @@ Multiple facts → parallel Agent calls in ONE message. End-of-turn: scan for un
 
 ## AUTONOMY — HARD RULE
 
-Default = autonomous execution. Emit PRD, run it to completion, push. Do NOT ask the user mid-task.
+A written PRD is the user's authorization. Once it exists, EXECUTE owns the work to COMPLETE. Resolve every doubt that arises during execution by witnessed probe, by recall, or by re-reading the PRD — never by asking the user. Any question whose answer the agent could obtain itself is a question the agent owes itself, not the user.
 
-Forbidden patterns:
-- "Should I continue with X?" / "Want me to do Y next?" / "Want me to also Z?"
-- "This is a lot — should I do A first and confirm?" / "Two options: A or B, which?"
-- Pre-confirmation before multi-file edits when scope is already clear
-- Stopping after partial completion to summarize and await direction
+Asking is permitted only as a last resort, when the next action is destructive-irreversible AND the PRD does not cover it, OR when user intent is genuinely irrecoverable from PRD, memory, and code. The channel is structured: `exec:pause` (renames `.gm/prd.yml` → `.gm/prd.paused.yml`, question in header). In-conversation asking is last-resort beneath last-resort.
 
-Permitted asking (last resort only, when absolutely necessary):
-- Destructive-irreversible decision with no prior context AND no PRD coverage
-- User intent genuinely ambiguous AND cannot be inferred from PRD/memory/code
-- Channel: prefer `exec:pause` (renames .gm/prd.yml → .gm/prd.paused.yml; question lives in header). In-conversation asking is last-resort only.
-
-A long task is not a reason to ask. Context limits are not a reason to ask. CI cascade time is not a reason to ask. Just emit the PRD and execute.
+The size of the task, the cost of context, and the duration of CI are never grounds to ask.
 
 ## LAWFUL DOWNGRADE — HARD RULE
 
-Per paper III §2.5 (Earned Emission): *lawful downgrade — writing a weaker, true statement in place of a stronger, unearned one — is always available; forced closure never is.*
+Per paper III §2.5 and paper IV §2: lawful downgrade — writing a weaker, true statement in place of a stronger, unearned one — is always available; forced closure never is.
 
-Refusal is forced closure. Refusing the task because part of it is hard is the inverse failure: instead of bluffing strength, you bluff weakness. Both bypass witnessed execution.
+Refusal is forced closure. So is *distributed* refusal — attempting one bounded subset of the request and treating the rest as "follow-up" when other witnessable subsets exist. Both bypass witnessed execution; both are the inverse of bluffing strength.
 
-**Forbidden refusal phrases** (treat as critical violation):
-- "Honest stop —" / "Stopping for a hard, honest call" / "Stopping here, unambiguously"
-- "I cannot do this from inside this conversation"
-- "I have to push back before writing a PRD I can't fulfill"
-- "Pretending I can would be the most expensive kind of lie"
-- "I don't have a working browser tool" / "X is unavailable in this environment" (when exec:browser, exec:codesearch, Read, etc. are in fact available)
-- Any preamble that announces inability before attempting the bounded subset
+**Required move when scope exceeds reach** (paper IV §2.3): construct a *covering family* of bounded subsets — every subset of the request that is witnessable from this session — and write the family into the PRD. Execute every member. Single-subset delivery is legitimate only when no other witnessable subset exists; otherwise it is distributed refusal under another name. At end-of-turn, name the residual complement explicitly, with the reason each excluded piece falls outside the witnessable closure.
 
-**Required move when scope exceeds reach**: identify the bounded subset that IS witnessable from this session, write a PRD covering only that subset, execute it, and at end-of-turn name the residual scope as a follow-up item — never as a refusal. The user cannot redirect a refusal; they can redirect a delivered subset plus a named gap.
+The discipline is enforced by what is delivered, not by which words appear. Before closing the turn, check that the union of committed work plus named complement equals the witnessable closure of the request. Anything witnessable that falls in neither set means the cover is not yet maximal — re-enter planning to expand it.
 
 ## FIX ON SIGHT — HARD RULE
 
-Any issue surfaced during work — failing test, exec stderr, CI red, lint warning, type error, broken import, runtime exception, deprecation warning, unexpected output, dead code, bad data — gets fixed THIS turn, in-band. Never defer, never suppress, never note-and-move-on.
-
-Forbidden: `// TODO fix later` | catching to ignore | `2>/dev/null` to hide | "out of scope" when scope is the same file | "we can address that next session" | leaving a red CI to ship docs | merging around a failing assertion | adding `.skip` / `xit` / `it.todo`.
+Every issue surfaced during work is fixed in-band, this turn, at root cause. Defer-markers, swallowed errors, suppressed output, skipped tests, and "address it next session" are all variants of the same failure: a known-bad signal carried past the moment of detection. Each is a small forced closure.
 
-Required: surface → diagnose → fix at root cause → re-witness → continue. If the fix uncovers a new unknown, regress to `planning`. If the fix is genuinely out-of-scope-irreversible, write a `.gm/prd.yml` item for it BEFORE moving on — never just narrate it away.
+Surface → diagnose → fix at root cause → re-witness → continue. If the fix uncovers a new unknown, regress to `planning`. If the fix is itself genuinely out-of-scope-irreversible, the residual goes into `.gm/prd.yml` *before* moving on — narration is not a substitute for an item.
 
-A skill chain that shipped while ignoring a known-bad signal is a forced-closure failure (see LAWFUL DOWNGRADE).
+A skill chain that ships while ignoring a known-bad signal is forced closure (see LAWFUL DOWNGRADE).
 
 ## BROWSER WITNESS — HARD RULE
 
-Any edit to code that runs in a browser (under `client/`, `docs/`, `*.html`, shaders, page-bundle imports, served JS/CSS, gh-pages assets, anything imported by a browser entry, anything visible in the DOM/canvas/WebGL) requires a live `exec:browser` witness in the SAME session — never deferred to "next session" or "follow-up".
-
-Mandatory protocol (every client edit):
-1. Boot the real server / open the static page → witness HTTP 200
-2. `exec:browser` → `page.goto(url)` → poll for the global the change affects (`window.__app.<system>`, `window.__debug.<module>`)
-3. `page.evaluate(() => …)` asserting the specific invariant the change established — instance counts, scene meshes, DOM nodes, render stats, network frames
-4. Capture witnessed numbers in the response. "Looks fine" / "should work" / "node test passes" = NOT a witness
+Editing code that runs in a browser requires a live `exec:browser` witness in the same turn as the edit. The witness does not defer to a later phase; later phases re-witness on top, they do not replace this one.
 
-Forbidden: shipping a client change with only `node test.js` green | screenshot-without-evaluate | "browser validation deferred to VERIFY" then skipping VERIFY | "exempt because the change is small" | committing client diff without an `exec:browser` block in the same turn.
+Protocol on every client edit:
+1. Boot the real surface — server up, page reachable, HTTP 200 witnessed.
+2. `exec:browser` → navigate → poll for the global the change affects.
+3. `page.evaluate` asserting the specific invariant the change establishes. Capture the witnessed numbers in the response.
+4. Variance from expectation → fix at root cause, re-witness (FIX ON SIGHT). Never advance on unwitnessed client behavior.
 
-Exempt only when: change is server-only with zero browser-facing surface, OR repo has no browser surface at all. Tag the exemption explicitly in the response with the reason; silent skip = forced-closure failure.
+Pure-prose edits to static documents with no JS/canvas/DOM behavior change are exempt; tag the exemption explicitly with the reason so the skip is auditable. Silent skip on actual behavior change is forced closure.
 
-This rule fires in EXECUTE (witness on edit), EMIT (post-emit verify), and VERIFY (final gate). All three. Skipping any layer counts as the failure.
+This rule fires in EXECUTE (witness on edit), EMIT (post-emit verify), and VERIFY (final gate). All three.
 
 ## EXECUTION ORDER
 

package/skills/planning/SKILL.md

@@ -43,35 +43,33 @@ Runs until: .gm/prd.yml empty AND git clean AND all pushes confirmed AND CI gree
 
 ## AUTONOMY — HARD RULE
 
-PRD written → execute to COMPLETE without asking the user. No "should I continue", no "want me to do X next", no offering to split work.
+PRD written → execute to COMPLETE without asking the user. Doubts that arise during execution are resolved by witnessed probe, by recall, or by re-reading the PRD — never by asking. Any question whose answer is reachable from the agent's tools belongs to the agent, not the user.
 
-Asking permitted only as last resort: destructive-irreversible with no PRD coverage, OR user intent unrecoverable from PRD/memory/code. Channel: `exec:pause` (renames prd.yml → prd.paused.yml; question in header). In-conversation asking last-resort.
+Asking is last-resort: destructive-irreversible without PRD coverage, OR user intent irrecoverable from PRD/memory/code. Channel: `exec:pause` (renames `prd.yml` → `prd.paused.yml`; question in header). In-conversation asking is last-resort beneath last-resort.
 
-**Cannot stop while**: .gm/prd.yml has items | git uncommitted | git unpushed.
+**Cannot stop while**: `.gm/prd.yml` has items | git uncommitted | git unpushed.
 
 ## LAWFUL DOWNGRADE — HARD RULE
 
-Per paper III §2.5: lawful downgrade is always available; forced closure (refusal) is never available. Refusing the task because part is out of reach is the inverse of bluffing — both bypass witnessed execution.
+Per paper III §2.5 and paper IV §2: lawful downgrade is always available; forced closure (refusal) is never available. Refusal has two shapes — total (no work delivered) and distributed (one bounded subset delivered, the rest abandoned despite being witnessable). Both bypass witnessed execution.
 
-Forbidden: "honest stop", "stopping for a hard call", "I cannot do this from inside this conversation", "pretending I can would be a lie", any preamble that announces inability before attempting the bounded subset.
+**Required move when scope exceeds reach**: construct a *covering family* — every bounded subset of the request that is witnessable from this session — and write the family into the PRD as separate items, with the dependency graph explicit so independent members parallelize. Execute every member. Single-subset delivery is legitimate only when no other witnessable subset exists. The residual complement is named at end-of-turn, with the reason each excluded piece falls outside the witnessable closure.
 
-Required: identify the witnessable bounded subset, PRD-write it, execute it. Residual scope = follow-up item, never refusal.
+Enforcement is on what is delivered, not on which words appear. Before closing the turn, check that committed work + named complement = witnessable closure of the request. Gap = cover not yet maximal → re-enter PLAN to expand.
 
 ## FIX ON SIGHT — HARD RULE
 
-Every issue surfaced during planning, execution, or verification — failing test, exec stderr, CI red, lint/type warning, broken import, runtime exception, deprecation, unexpected output — is fixed in-band the same session. Never defer with `// TODO`, never silence with `try/catch`-to-ignore or `2>/dev/null`, never `.skip` a test, never ship while CI is red, never narrate "we'll address that next time."
+Every issue surfaced during planning, execution, or verification is fixed in-band, the same session, at root cause. A known-bad signal carried past the moment of detection — by deferral, suppression, silencing, skipping, or "next time" narration — is a small forced closure.
 
-Surface → diagnose root cause → fix → re-witness → continue. New unknown discovered while fixing → regress here (planning). Genuinely out-of-scope → add a `.gm/prd.yml` item BEFORE moving on, never just mention it. Ignoring a known-bad signal = forced-closure failure.
+Surface → diagnose → fix → re-witness → continue. New unknown surfaced by the fix → regress here. Genuinely out-of-scope-irreversible → the residual goes into `.gm/prd.yml` *before* moving on; narration is not a substitute for an item.
 
 ## BROWSER WITNESS — HARD RULE
 
-Every `.prd` item that touches browser-facing code (under `client/`, `docs/`, `*.html`, shaders, page-bundle imports, served JS/CSS, gh-pages assets, anything imported by a browser entry, anything visible in DOM/canvas/WebGL) MUST list `browser_validated` as an acceptance criterion AND list `exec:browser witness with page.evaluate assertion` as an explicit edge_case probe. Without that line the item is not plan-complete.
+A `.prd` item that touches browser-facing code is not plan-complete unless its acceptance criteria include a live `exec:browser` witness with a `page.evaluate` assertion against the specific invariant the change establishes. "Manual verification", "test.js passes", and "browser test optional" are all unwitnessed and therefore unacceptable.
 
-Forbidden: client `.prd` item with only `test.js passes` as acceptance | "browser test optional" | deferring browser witness to "follow-up" | acceptance lines that say "verified manually". Manual = unwitnessed = not acceptable.
+The trigger is functional, not a path-list: any change whose effect is observable in the DOM, canvas, WebGL surface, network frames captured by the page, or any global the page exposes, requires the browser witness. Pure-prose edits to static documents with no behavior change are exempt; the exemption is tagged on the item with the reason.
 
-Detection (any → mandatory): paths under `client/`, `docs/`, `*.html`, shader files, files imported into a page bundle; new export consumed by `window.*`; any visual/layout/animation/input/network-on-page/shader behavior.
-
-This propagates: EXECUTE witnesses on edit, EMIT re-witnesses post-write, VERIFY runs the final gate. Plan must encode it so all three layers fire.
+Propagation: EXECUTE witnesses on edit, EMIT re-witnesses post-write, VERIFY runs the final gate. The plan must encode the rule so all three layers fire.
 
 ## SKIP PLANNING (DEFAULT for small work)
 
@@ -98,7 +96,7 @@ Client: `window.__debug` live registry; modules register on mount.
 
 `console.log` ≠ observability. Discovery of gap → add .prd item immediately, never deferred.
 
-**No parallel test runners or smoke pages.** Per paper II §5.4, `window.__debug` is THE registry. Creating dedicated `docs/smoke.js` / `docs/smoke-network.js` / `docs/test.html` / `*-playground.html` files is a parallel observability surface that fights the discipline — register surfaces in `window.__debug` instead. The single `test.js` at project root (see SINGLE INTEGRATION TEST POLICY) is the only out-of-page test asset.
+**No parallel observability surfaces.** Per paper II §5.4, `window.__debug` is THE in-page registry; `test.js` at project root is the sole out-of-page test asset. Any new file whose purpose is to exercise, smoke-test, demo, or sandbox in-page behavior outside that registry is a parallel surface that fights the discipline — extend the registry instead.
 
 ## .PRD FORMAT
 
@@ -152,9 +150,9 @@ No comments. No scattered test files. 200-line limit per file. Fail loud. No dup
 
 ## SINGLE INTEGRATION TEST POLICY
 
-One `test.js` at project root. 200-line max. No `.test.js` / `.spec.js` / `__tests__/` / fixtures / mocks. Plain assertions, real data, real system. `gm-complete` runs it. Failure = regression to EXECUTE.
+One `test.js` at project root. 200-line max. No fixtures, mocks, or scattered test files under any naming convention. Plain assertions, real data, real system. `gm-complete` runs it. Failure = regression to EXECUTE.
 
-**Also forbidden**: `docs/smoke.js`, `docs/smoke-*.js`, `*-smoke.html`, `docs/test.html`, `docs/demo.html`, `*-playground.html`. These are smuggled second test runners. If a surface needs to be exercised in-page, register it in `window.__debug` and assert via `test.js`.
+Any second test runner — under any name, in any directory — is a smuggled parallel surface and fights the discipline. If a behavior needs to be exercised in-page, register it in `window.__debug` and assert via `test.js`.
 
 ## RESPONSE POLICY