gm-skill 2.0.1619 → 2.0.1621

package/AGENTS.md

@@ -72,7 +72,7 @@ Record only non-obvious technical caveats that cost multiple runs to discover; r
 
 No build step; the repo root is the published artifact. `npm publish` from root publishes `gm-skill` (npm package id is permanent; only the skill DIRECTORY is `skills/gm`, so the command is `/gm`). `package.json` `files:` pins the shipped paths. `AnEntrypoint/gm-skill` is a back-compat mirror receiving only `skills/gm/SKILL.md` per release.
 
-`bin/install.js` is the canonical installer -- no npx `skills` library, no marketplace. It copies `skills/gm` into `<home>/.claude/skills/gm/` (personal) or `.claude/skills/gm/` (`--project`); the dir name IS the `/command`. Non-interactive (`-y`/`--yes` or non-TTY) SETS four Claude Code settings (`autoCompactEnabled:true`, `autoCompactWindow:380000` -- an ABSOLUTE token count = 38% of 1M, not a percentage -- `effortLevel:"low"`, `alwaysThinkingEnabled:false`) and explains the revert; interactive OFFERS them. The reasoning-in-code framing it prints is load-bearing: the LLM still thinks, it tests its thoughts in code (execution as reasoning). `test.js checkRenameAndInstaller()` is the structural guard (asserts no `skills/gm-skill`, package id stays `gm-skill`, installer lands the skill + writes the four keys into an isolated temp HOME).
+`bin/install.js` is the canonical installer (no npx `skills` library, no marketplace); the dir name it lands IS the `/command`, and `test.js checkRenameAndInstaller()` is the structural guard. Copy-target, the four Claude Code settings it sets non-interactively, the reasoning-in-code framing, and the guard assertions in rs-learn (`recall: gm installer detail`).
 
 ## The agent is the orchestrator; plugkit is the brain it drives
 

package/gm-plugkit/instructions/browser.md

@@ -26,7 +26,7 @@ capture\n<expression>
 profile\n<expression>
 ```
 
-**Open on the page you want to test, not a blank one.** A bare `https://...` URL body navigates the session straight to that page and returns `{url, title}` -- the simplest "show me this page." `url=<url>\n<expression>` navigates first, then runs your expression on the loaded page, so the global/DOM you assert is already there in one dispatch instead of a blank surface you must `page.goto` yourself. `url=` composes with `timeout=` and `capture` -- stack the prefix lines in order `timeout=`, then `url=`, then `capture`, the expression last; the prepended `page.goto` rides inside the capture so its navigation console/network is captured too. A bare expression with no URL prefix and no live session opens against `about:blank`; with a live session it reuses it. `session new` returns the id you carry; with more than one open, target it via `session=<id>\n<expr>`. (`session close` and `session kill` are aliases.) Default per-eval timeout 120000ms; operations that legitimately exceed it prefix `timeout=<ms>\n` (wrapper clamps to 120000ms). The response carries `timeout_ms_used`; `browser.runner-timeout` fires at the cap -- read `stderr`, narrow or raise, never retry blind at the same budget.
+**Open on the page you want to test, not a blank one.** A bare `https://...` URL body navigates the session straight to that page and returns `{url, title}` -- the simplest "show me this page." `url=<url>\n<expression>` navigates first, then runs your expression on the loaded page, so the global/DOM you assert is already there in one dispatch instead of a blank surface you must `page.goto` yourself. `url=` composes with `timeout=` and `capture` -- stack the prefix lines in order `timeout=`, then `url=`, then `capture`, the expression last; the prepended `page.goto` rides inside the capture so its navigation console/network is captured too. A bare expression with no `url=`/bare-URL prefix runs against whatever the session is already on -- a never-navigated session is on `about:blank`, so the expression evaluates an empty page and the envelope comes back with `landed_on_blank: true` and a `hint` telling you to add `url=`; navigate first and the surprise never happens. `session new` returns the id you carry. (`session close` and `session kill` are aliases.) Default per-eval timeout 120000ms; operations that legitimately exceed it prefix `timeout=<ms>\n` (wrapper clamps to 120000ms). The response carries `timeout_ms_used`; `browser.runner-timeout` fires at the cap -- read `stderr`, narrow or raise, never retry blind at the same budget.
 
 **`capture\n<expression>` is the zero-boilerplate debug path -- prefer it.** Prefix your script with `capture` (or `profile`) on its own line and the wrapper auto-attaches `page.on('console'|'pageerror'|'requestfinished')` before your code runs, runs your script in an async wrapper (your top-level `await`/`return` work unchanged), and returns `{result: <your return>, debug: {console, pageErrors, network, performance}}` -- page console logs, uncaught errors, per-request network timing, and navigation performance, captured for free. Combine with timeout via `timeout=<ms>\ncapture\n<expr>`. Use the bare expression only when you do not want the capture overhead.
 
@@ -34,7 +34,7 @@ profile\n<expression>
 
 ## Envelope
 
-`{ok, stdout, stderr, exit_code, session_id?}`. `stdout` = stringified eval result; `stderr` = page errors + launch diagnostics; `exit_code` non-zero = the dispatch did not land -- read `stderr` and re-dispatch, never blind.
+`{ok, stdout, stderr, exit_code, session_id?, navigation_requested, landed_on_blank?, hint?}`. `stdout` = stringified eval result; `stderr` = page errors + launch diagnostics; `exit_code` non-zero = the dispatch did not land -- read `stderr` and re-dispatch, never blind. `navigation_requested` reflects whether the dispatch carried a `url=`/bare-URL navigation; `landed_on_blank: true` with a `hint` means the expression ran against `about:blank` -- prefix `url=<target>` and re-dispatch.
 
 ## Headed by default
 

package/gm-plugkit/package.json

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

@@ -163,27 +163,19 @@ function dispatchVerbToWasmInternal(instance, verb, body) {
   if (!dispatch) return null;
   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);
-  if ((verbBytes.length > 0 && verbPtr === 0) || (bodyBytes.length > 0 && bodyPtr === 0)) {
-    try { if (verbPtr !== 0) instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
-    try { if (bodyPtr !== 0) instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
-    throw new Error(`wasm-alloc-failed for dispatch_verb(${verb}): plugkit_alloc returned 0 (wasm OOM); refusing to write to a null offset and corrupt the heap`);
-  }
+  // writeWasmInput re-reads memory.buffer fresh after each alloc (avoids the detached-buffer write bug).
+  let verbPtr = 0, bodyPtr = 0;
+  try { verbPtr = writeWasmInput(instance, verbBytes, `dispatch_verb(${verb}).verb`); }
+  catch (e) { throw new Error(`wasm-alloc-failed for dispatch_verb(${verb}): ${e.message}`); }
+  try { bodyPtr = writeWasmInput(instance, bodyBytes, `dispatch_verb(${verb}).body`); }
+  catch (e) { try { if (verbPtr) instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
+    throw new Error(`wasm-alloc-failed for dispatch_verb(${verb}): ${e.message}`); }
   try {
-    new Uint8Array(instance.exports.memory.buffer, verbPtr, verbBytes.length).set(verbBytes);
-    new Uint8Array(instance.exports.memory.buffer, bodyPtr, bodyBytes.length).set(bodyBytes);
     const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
-    const ptr = Number(result & 0xffffffffn);
-    const len = Number(result >> 32n);
-    const buffer = instance.exports.memory.buffer;
-    guardWasmRange(buffer, ptr, len, `dispatch_verb(${verb})`);
-    const out = new TextDecoder().decode(new Uint8Array(buffer, ptr, len));
-    try { instance.exports.plugkit_free(ptr, len); } catch (_) {}
-    return out;
+    return decodeWasmResult(instance, result, `dispatch_verb(${verb})`);   // normalized i64 + fresh buffer
   } finally {
-    try { instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
-    try { instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
+    try { if (verbPtr) instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
+    try { if (bodyPtr) instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
   }
 }
 
@@ -1383,6 +1375,41 @@ function guardWasmRange(buffer, ptr, len, where) {
   }
 }
 
+// Decode a packed (ptr,len) i64 dispatch result into a JS string, the ONE correct way.
+// Two bugs this consolidates (they only surface once the wasm memory grows past a threshold --
+// e.g. a large .gm state file -> a big plugkit_alloc -> the memory grows past ~2GB / the linear
+// memory is re-grown mid-dispatch):
+//   1. SIGNED i64 result. dispatch_verb returns an i64; a high bit set (large ptr or a packed
+//      len in the top 32 bits) makes `result` a NEGATIVE BigInt. `result >> 32n` on a negative
+//      BigInt arithmetic-shifts in sign bits -> a garbage/negative len, and the low-word mask can
+//      misread too. Normalize to unsigned 64-bit FIRST: BigInt.asUintN(64, result).
+//   2. DETACHED buffer. `instance.exports.memory.buffer` captured before plugkit_alloc/dispatch is
+//      a STALE ArrayBuffer once the wasm linear memory grows (the old buffer detaches). Reading the
+//      result against it throws 'Start offset N is outside the bounds of the buffer'. Always re-read
+//      instance.exports.memory.buffer FRESH at the moment of the view, never reuse a captured one.
+function decodeWasmResult(instance, result, where) {
+  const u = BigInt.asUintN(64, BigInt(result));   // (1) normalize the i64 to unsigned before splitting
+  const ptr = Number(u & 0xffffffffn);
+  const len = Number(u >> 32n);
+  if (ptr === 0 || len === 0) return '';
+  const buffer = instance.exports.memory.buffer;  // (2) FRESH buffer (post-grow), never a stale capture
+  guardWasmRange(buffer, ptr, len, where);
+  const out = new TextDecoder().decode(new Uint8Array(buffer, ptr, len));
+  try { instance.exports.plugkit_free(ptr, len); } catch (_) {}
+  return out;
+}
+
+// Write input bytes into wasm memory, re-reading memory.buffer FRESH after the alloc so a memory
+// grow during plugkit_alloc never leaves us writing into a detached buffer (the write-side half of
+// the detached-buffer bug). Returns the ptr (caller frees) or throws on alloc failure.
+function writeWasmInput(instance, bytes, where) {
+  if (bytes.length === 0) return 0;
+  const ptr = instance.exports.plugkit_alloc(bytes.length);
+  if (ptr === 0) throw new Error(`wasm-alloc-failed at ${where}: plugkit_alloc returned 0 (wasm OOM)`);
+  new Uint8Array(instance.exports.memory.buffer, ptr, bytes.length).set(bytes);   // fresh buffer post-alloc
+  return ptr;
+}
+
 function readWasmBytes(instance, ptr, len) {
   if (ptr === 0 || len === 0) return new Uint8Array(0);
   const buffer = instance.exports.memory.buffer;
@@ -2127,6 +2154,7 @@ function makeHostFunctions(instanceRef) {
           + `page.on('pageerror',e=>{try{__errs.push(String(e&&e.message||e));}catch(_){}});`
           + `page.on('requestfinished',r=>{try{const t=r.timing();__net.push({url:String(r.url()).slice(0,120),dur_ms:Math.round(t.responseEnd),ttfb_ms:Math.round(t.responseStart)});}catch(_){}});}catch(_){}\n`;
         const perfRead = `let __perf=null;try{__perf=await page.evaluate(()=>{const n=performance.getEntriesByType('navigation')[0];return n?{load_ms:Math.round(n.loadEventEnd||0),dcl_ms:Math.round(n.domContentLoadedEventEnd||0),resources:performance.getEntriesByType('resource').length,now:Math.round(performance.now())}:null;});}catch(_){}\n`;
+        const blankProbe = startUrl ? '' : `try{const __u=page.url();if(__u==='about:blank'||__u===''){console.error('__GM_BLANK__');}}catch(_){}\n`;
         if (modeMatch && modeMatch[1] === 'profile') {
           const userScript = modeMatch[2];
           const intervalUs = 100;
@@ -2134,7 +2162,7 @@ function makeHostFunctions(instanceRef) {
             + `let __profile=null,__profileError=null;\n`
             + `let __cdp=null;\n`
             + `try{__cdp=await page.context().newCDPSession(page);await __cdp.send('Profiler.enable');await __cdp.send('Profiler.setSamplingInterval',{interval:${intervalUs}});await __cdp.send('Profiler.start');}catch(e){__profileError=String(e&&e.message||e);__cdp=null;}\n`
-            + `const __result = await (async () => {\n${gotoPrefix}${userScript}\n})();\n`
+            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}${userScript}\n})();\n`
             + `if(__cdp){try{const __r=await __cdp.send('Profiler.stop');__profile=__r&&__r.profile||null;}catch(e){__profileError=String(e&&e.message||e);}}\n`
             + perfRead
             + AGGREGATE_CPU_PROFILE_SRC + `\n`
@@ -2143,11 +2171,13 @@ function makeHostFunctions(instanceRef) {
         } else if (modeMatch && modeMatch[1] === 'capture') {
           const userScript = modeMatch[2];
           evalBody = debugSetup
-            + `const __result = await (async () => {\n${gotoPrefix}${userScript}\n})();\n`
+            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}${userScript}\n})();\n`
             + perfRead
             + `return {result:__result,debug:{console:__logs,pageErrors:__errs,network:__net.slice(0,30),performance:__perf}};`;
         } else if (startUrl) {
           evalBody = `${gotoPrefix}${evalBody}`;
+        } else if (blankProbe) {
+          evalBody = `${blankProbe}${evalBody}`;
         }
         const outerTimeoutMs = Math.min(timeoutMs + 6000, 126000);
         const r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-e', evalBody], outerTimeoutMs, cwd, sessionId);
@@ -2155,14 +2185,22 @@ function makeHostFunctions(instanceRef) {
         if (!ok && r.status === null) {
           logEvent('plugkit', 'browser.runner-timeout', { session_id: pwSessionId, timeout_ms: timeoutMs, body_bytes: evalBody.length });
         }
-        return writeWasmJson(instanceRef.value, {
+        const rawStderr = r.stderr || '';
+        const landedOnBlank = !startUrl && rawStderr.includes('__GM_BLANK__');
+        const envelope = {
           ok,
           stdout: scrubBrowserRunnerText(r.stdout || ''),
-          stderr: scrubBrowserRunnerText(r.stderr || ''),
+          stderr: scrubBrowserRunnerText(rawStderr.replace(/^__GM_BLANK__\r?\n?/gm, '')),
           exit_code: r.status === null ? -1 : r.status,
           session_id: pwSessionId,
           timeout_ms_used: timeoutMs,
-        });
+        };
+        envelope.navigation_requested = !!startUrl;
+        if (landedOnBlank) {
+          envelope.landed_on_blank = true;
+          envelope.hint = "page is about:blank: this dispatch did not navigate, so the expression evaluated against an empty page. Prefix the body with 'url=<target>' (or send a bare 'https://...' URL) to open the page you want before evaluating.";
+        }
+        return writeWasmJson(instanceRef.value, envelope);
       } catch (e) {
         return writeWasmJson(instanceRef.value, { ok: false, error: scrubBrowserRunnerText(e.message) });
       }

package/gm.json

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

@@ -56,7 +56,7 @@ bun x gm-plugkit@latest spool > /dev/null 2>&1 &
 
 From PowerShell, write spool input as UTF-8 no-BOM (`-Encoding utf8` or `[System.IO.File]::WriteAllText`); the 5.1 default UTF-16+BOM trips `spool.body-encoding-recoded`. Prefer the `Write` tool for JSON bodies. First-turn body is `{"prompt":"<user request>"}` (derives orient_nouns + recall_hits); later same-conversation turns may use `{}`. A `Write` to `in/<verb>/` that errors `ENOENT` (a fast watcher consumed and unlinked the file before the tool's post-write stat) has STILL dispatched -- confirm via the `out/` response, never blind-retry (a non-idempotent verb like `git_finalize` would double-fire); a Bash heredoc `cat > in/<verb>/<N>.txt` has no post-write stat and never surfaces this.
 
-**Batch writes and reads together.** Write request + Read response is one logical step -- issue both in one block, not three turns. Fan-out is the same: N independent verbs = N Writes in one block then N Reads in one block. Only a real data dependency (verb B needs A's response) forces separate turns.
+**Batch writes and reads together -- one block is the default, the serial single dispatch is the drift.** Write request + Read response is one logical step; issue both in one block, never across turns. Independent dispatches batch as a class -- N `prd-add`, N `prd-resolve`, N `mutable-add`, the orient `recall`+`codesearch`, several inspection `Read`/`codesearch` -- as N Writes in one block then N Reads in one block. A turn that issues one independent verb while three were ready is the miss to correct; the only thing that forces separate turns is a true data dependency, verb B reading verb A's response. Two edges bound the rule. Same-file batching inverts it: two Edits to the SAME file in one block is not fan-out -- the first invalidates the file's read-state and the rest fail `File has been modified since read`, so collapse same-file changes into one Edit (or `replace_all`, or one Write of the whole file) and reserve in-block batching for Edits across DIFFERENT files. And a long verb (browser, an `exec_js` build, `git_finalize`) whose response is not ready on the Write+Read block: the recovery is one block carrying both the wait probe and the re-Read (the `until [ -f .gm/exec-spool/out/<verb>-<N>.json ]; do sleep N; done` and the `Read` together, or honoring an advertised `busy_until` the same way), never a bare wait turn followed by a separate Read turn. Reading a homogeneous fan-out's responses is itself batched: Read all N in one block, or spot-check first and last -- they carry no ordering dependency.
 
 The chain is not COMPLETE until changes are on origin. Commit and push at the end of every session that touched tracked files; do not ask -- the push IS the validation dispatch (`verify.rs`). Only the porcelain check holds it back, and a dirty tree is fixed by stage-commit or revert, not by asking.