gm-skill 2.0.1621 → 2.0.1623

package/AGENTS.md

@@ -160,7 +160,7 @@ Orchestration state is tracked via `.gm/` marker files, not hook events; the CLI
 
 **Dead-watcher recovery uses `bun x gm-plugkit@latest spool`, never direct-node boot** (mechanism in rs-learn: `recall: dead-watcher recovery bun x not direct-node`).
 
-**Apparent tooling failure is mechanical self-recovery, NEVER a question for the user and never an a/b-test/blind-restart.** "The spooler is not working" / a missing spool response / a stale watcher is the agent's own job to fix: honor a future `busy_until` (wait), else boot the watcher and re-dispatch; on a transient boot hiccup (`FailedToOpenSocket`) retry `@latest`, never the non-`@latest` cache (stale). The spooler is sound by construction -- `.status.json` is written atomically (temp+rename, `atomicWriteJson`) and every long verb advertises `busy_until` -- so a transient unreadable/stale read is a respawn/idle-teardown window to boot through, not a broken tool; asking the user to do what a verb can do is a paper-spirit violation. Debug the live page via `window.*` globals + the `browser` verb's `page.evaluate` as a process of elimination, never variant-after-variant a/b testing. This IS the core gm method on every surface including its own tooling: record all mutables, eliminate each by witness, discover more, keep going.
+**Apparent tooling failure is mechanical self-recovery, NEVER a question for the user and never an a/b-test/blind-restart.** A missing spool response / stale watcher is the agent's own job: honor a future `busy_until` else boot the watcher and re-dispatch -- the spooler is sound by construction, so asking the user to do what a verb can do is a paper-spirit violation. Recovery mechanics (atomic `.status.json`, `FailedToOpenSocket` retry, debug-via-`window.*`-globals) in rs-learn (`recall: spooler self-recovery mechanics`).
 
 **Process-of-elimination is the debugging paradigm EVERYWHERE, and manual real-services witness is the verification paradigm EVERYWHERE.** Every debug -- code, wasm, cascade, browser, the spooler itself -- enumerates candidate causes as mutables and eliminates each by a witness read against real input (`exec_js`/`codesearch`/`Read`/`browser page.evaluate`), each elimination revealing the next, never guess-and-restart/a-b-test/shotgun. Every verification is manual labour against the real thing -- the single mock-free `test.js`, the live page, the real service, the live wasm -- never an automated unit/mock suite standing in for the real-services witness (the conventional-testing tell-tale gm replaces). Stated in `instructions/execute.md` (the served EXECUTE prose) so it reaches every LLM in-session.
 
@@ -178,5 +178,7 @@ One-shot system-state probe: dispatch `plugkit health` via the file-spool before
 
 Site build + landing render is single-surface detail, fully drained to rs-learn (`recall: gm site build details`).
 
+**The site consumes the `anentrypoint-design` SDK pro-rata, never overriding it.** `site/theme.mjs` loads the SDK at runtime (`unpkg.com/anentrypoint-design@latest`) and the local `<style>` carries ONLY render-mode plumbing (flatspace html-class toggles `article-flow`/`landing-cap`, the crumb media query) plus site article-layout rhythm that is not an SDK component -- never a themed visual component. Every graphic-design change (a token, a component's look, TOC/cli/panel/card/callout styling) is made IN the SDK repo (`../anentrypoint-design`, GitHub `AnEntrypoint/design`, npm `anentrypoint-design`) as a token-only sheet and published; the site picks it up via `@latest`. A new local CSS rule that styles a visual component is a deviation -- it belongs in the SDK. SDK component sheets are lint-gated literal-free (every color a `var(--token)`); the SDK build prefixes all selectors with the `.ds-247420` scope. Mechanism in rs-learn (`recall: design SDK pro-rata consumption`).
+
 
 @.gm/next-step.md

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1621",
+  "version": "2.0.1623",
   "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-plugkit/plugkit-wasm-wrapper.js

@@ -2277,13 +2277,14 @@ function readInstanceVersion(instance) {
     const result = fn();
     let ptr, len;
     if (typeof result === 'bigint') {
-      ptr = Number(result & 0xffffffffn);
-      len = Number(result >> 32n);
+      const u = BigInt.asUintN(64, result);   // normalize the i64 to unsigned before splitting (signed-ptr fix)
+      ptr = Number(u & 0xffffffffn);
+      len = Number(u >> 32n);
     } else {
-      ptr = Number(result) & 0xffffffff;
+      ptr = Number(result) >>> 0;   // unsigned 32-bit
       len = 0;
     }
-    const buf = new Uint8Array(instance.exports.memory.buffer, ptr, 64);
+    const buf = new Uint8Array(instance.exports.memory.buffer, ptr, 64);   // fresh buffer (post fn() grow)
     if (len === 0) {
       let end = 0;
       while (end < buf.length && buf[end] !== 0) end++;
@@ -3274,20 +3275,17 @@ async function runSpoolWatcher(instance, spoolDir) {
         }
       }
 
-      const verbPtr = instance.exports.plugkit_alloc(verbBytes.length);
-      const bodyPtr = instance.exports.plugkit_alloc(bodyBytes.length);
-      new Uint8Array(instance.exports.memory.buffer, verbPtr, verbBytes.length).set(verbBytes);
-      new Uint8Array(instance.exports.memory.buffer, bodyPtr, bodyBytes.length).set(bodyBytes);
+      // writeWasmInput re-reads memory.buffer fresh after each alloc (detached-buffer write fix).
+      const verbPtr = writeWasmInput(instance, verbBytes, `spool-dispatch:${verb}.verb`);
+      const bodyPtr = writeWasmInput(instance, bodyBytes, `spool-dispatch:${verb}.body`);
 
       writeVerbActive(verb, taskBase);
       const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
       clearVerbActive();
 
-      const ptr = Number(result & 0xffffffffn);
-      const len = Number(result >> 32n);
-      guardWasmRange(instance.exports.memory.buffer, ptr, len, `spool-dispatch:${verb}`);
-      const resultBytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
-      let resultStr = new TextDecoder().decode(resultBytes);
+      // decodeWasmResult normalizes the i64 (BigInt.asUintN), re-reads the buffer FRESH (post-grow),
+      // guards the range, AND frees the result ptr -- so the (ptr,len) free below is dropped.
+      let resultStr = decodeWasmResult(instance, result, `spool-dispatch:${verb}`);
 
       if (autoRecallPayload) {
         resultStr = mergeAutoRecallIntoInstructionResponse(resultStr, autoRecallPayload);
@@ -3340,7 +3338,7 @@ async function runSpoolWatcher(instance, spoolDir) {
 
       try { instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
       try { instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
-      try { instance.exports.plugkit_free(ptr, len); } catch (_) {}
+      // (the result ptr is freed inside decodeWasmResult above)
 
       try { if (fs.existsSync(filePath)) fs.unlinkSync(filePath); } catch (_) {}
       unmarkProcessed(key);
@@ -3988,15 +3986,12 @@ if (_isCliEntry) (async () => {
       const dispatch = instance.exports.dispatch_verb;
       const verbBytes = new TextEncoder().encode(verb);
       const bodyBytes = new TextEncoder().encode(body);
-      const verbPtr = instance.exports.plugkit_alloc(verbBytes.length);
-      const bodyPtr = instance.exports.plugkit_alloc(bodyBytes.length);
-      new Uint8Array(instance.exports.memory.buffer, verbPtr, verbBytes.length).set(verbBytes);
-      new Uint8Array(instance.exports.memory.buffer, bodyPtr, bodyBytes.length).set(bodyBytes);
+      const verbPtr = writeWasmInput(instance, verbBytes, `cli-dispatch:${verb}.verb`);
+      const bodyPtr = writeWasmInput(instance, bodyBytes, `cli-dispatch:${verb}.body`);
       const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
-      const ptr = Number(result & 0xffffffffn);
-      const len = Number(result >> 32n);
-      guardWasmRange(instance.exports.memory.buffer, ptr, len, `cli-dispatch:${verb}`);
-      const out = new TextDecoder().decode(new Uint8Array(instance.exports.memory.buffer, ptr, len));
+      const out = decodeWasmResult(instance, result, `cli-dispatch:${verb}`);   // normalized i64 + fresh buffer
+      try { instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
+      try { instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
       process.stdout.write(out);
       let parsed;
       try { parsed = JSON.parse(out); } catch (_) { parsed = null; }

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1621",
+  "version": "2.0.1623",
   "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.1621",
+  "version": "2.0.1623",
   "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",