gm-skill 2.0.1333 → 2.0.1335

package/gm-plugkit/package.json

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

@@ -1752,17 +1752,8 @@ function resolveVersion(instance) {
   try {
     return fs.readFileSync(path.join(GM_TOOLS_ROOT, 'plugkit.version'), 'utf8').trim();
   } catch (_) {}
-  try {
-    const fn = instance && instance.exports && instance.exports.plugkit_version;
-    if (typeof fn === 'function') {
-      const result = fn();
-      const ptr = Number(result & 0xffffffffn);
-      const len = Number(result >> 32n);
-      const bytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
-      return new TextDecoder().decode(bytes).trim();
-    }
-  } catch (_) {}
-  return 'unknown';
+  const fromInstance = readInstanceVersion(instance);
+  return fromInstance || 'unknown';
 }
 
 function readFileVersionOnly() {
@@ -1774,10 +1765,22 @@ function readInstanceVersion(instance) {
     const fn = instance && instance.exports && instance.exports.plugkit_version;
     if (typeof fn !== 'function') return null;
     const result = fn();
-    const ptr = Number(result & 0xffffffffn);
-    const len = Number(result >> 32n);
-    const bytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
-    return new TextDecoder().decode(bytes).trim();
+    let ptr, len;
+    if (typeof result === 'bigint') {
+      ptr = Number(result & 0xffffffffn);
+      len = Number(result >> 32n);
+    } else {
+      ptr = Number(result) & 0xffffffff;
+      len = 0;
+    }
+    const buf = new Uint8Array(instance.exports.memory.buffer, ptr, 64);
+    if (len === 0) {
+      let end = 0;
+      while (end < buf.length && buf[end] !== 0) end++;
+      len = end;
+    }
+    if (len === 0) return null;
+    return new TextDecoder().decode(buf.subarray(0, len)).trim() || null;
   } catch (_) { return null; }
 }
 
@@ -2577,8 +2580,26 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 5000);
 
+  let _sweepErrLogged = false;
   setInterval(() => {
     try {
+      if (!fs.existsSync(outDir)) {
+        try {
+          fs.mkdirSync(outDir, { recursive: true });
+          fs.mkdirSync(inDir, { recursive: true });
+          console.log(`[retention] recreated missing spool dirs: ${outDir}, ${inDir}`);
+          logEvent('plugkit', 'spool.dirs-recreated', { outDir, inDir, reason: 'sweep-found-missing' });
+          _sweepErrLogged = false;
+          return;
+        } catch (mke) {
+          if (!_sweepErrLogged) {
+            console.error(`[retention] cannot recreate ${outDir}: ${mke.message}`);
+            logEvent('plugkit', 'spool.dirs-recreate-failed', { outDir, error: mke.message });
+            _sweepErrLogged = true;
+          }
+          return;
+        }
+      }
       const cutoff = Date.now() - 3600_000;
       let swept = 0;
       for (const entry of fs.readdirSync(outDir)) {
@@ -2592,9 +2613,13 @@ async function runSpoolWatcher(instance, spoolDir) {
         console.log(`[retention] swept ${swept} out/ files older than 1h`);
         logEvent('plugkit', 'sweep.retention', { swept });
       }
+      _sweepErrLogged = false;
     } catch (e) {
-      console.error(`[retention] sweep error: ${e.message}`);
-      logEvent('plugkit', 'sweep.retention.error', { error: String(e.message || e) });
+      if (!_sweepErrLogged) {
+        console.error(`[retention] sweep error: ${e.message}`);
+        logEvent('plugkit', 'sweep.retention.error', { error: String(e.message || e) });
+        _sweepErrLogged = true;
+      }
     }
   }, 60_000);
 

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1333",
+  "version": "2.0.1335",
   "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.1333",
+  "version": "2.0.1335",
   "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/SKILL.md

@@ -38,6 +38,8 @@ bun x gm-plugkit@latest spool > /dev/null 2>&1 &
 
 Never poll the spool dir with `sleep && ls` or `Start-Sleep && Test-Path` — plugkit is synchronous from your view; if the response is not there, the watcher is dead (re-check `.status.json` mtime) or the verb is slow (check `.gm/exec-spool/.watcher.log`), not "still processing."
 
+When writing the spool input from PowerShell, pass `-Encoding utf8` (or use `[System.IO.File]::WriteAllText($path, $body)` which defaults to UTF-8 no-BOM). PowerShell 5.1's default `Out-File` / `Set-Content` write UTF-16 LE with BOM, which the watcher detects and re-decodes (`spool.body-encoding-recoded` event in gmsniff), but the deviation is a fingerprint of an instruction you missed. Use `bash -c "echo -n '...' > ..."` or `Write` tool instead when the body is structured JSON.
+
 First turn body must be `{"prompt":"<user request>"}` so orient_nouns and recall_hits derive from the request; subsequent turns in the same conversation may use empty body `{}`.
 
 **Batch writes, waits, and reads together.** Each agent turn costs cycles; the dispatch shape `Write request → wait → Read response` is one logical step, not three. Issue all three in a single message — the Write tool call and the Read tool call go in the same `<function_calls>` block. The Read may return "file does not exist" if plugkit is mid-verb; that's fine, retry with one more Read in the next message rather than spreading the cycle across three turns. Fan-out is the same shape — dispatching three independent verbs (`prd-add g1`, `prd-add g2`, `prd-add g3`) means three Write tool calls in one block, then three Read tool calls in one block. Serial dispatch when you could be parallel is wasted cycles. The only sequencing constraint is real data dependency: if verb B needs the response of verb A, those go in separate turns; otherwise batch.