gm-skill 2.0.1332 → 2.0.1334

package/gm-plugkit/package.json

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

@@ -2344,7 +2344,29 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
 
     try {
-      const content = fs.readFileSync(filePath, 'utf8');
+      const rawBuf = fs.readFileSync(filePath);
+      let content;
+      let _detectedEncoding = 'utf-8';
+      if (rawBuf.length >= 2 && rawBuf[0] === 0xFF && rawBuf[1] === 0xFE) {
+        content = rawBuf.slice(2).toString('utf16le');
+        _detectedEncoding = 'utf-16le-bom';
+      } else if (rawBuf.length >= 2 && rawBuf[0] === 0xFE && rawBuf[1] === 0xFF) {
+        const swapped = Buffer.alloc(rawBuf.length - 2);
+        for (let i = 2; i + 1 < rawBuf.length; i += 2) {
+          swapped[i - 2] = rawBuf[i + 1];
+          swapped[i - 1] = rawBuf[i];
+        }
+        content = swapped.toString('utf16le');
+        _detectedEncoding = 'utf-16be-bom';
+      } else if (rawBuf.length >= 3 && rawBuf[0] === 0xEF && rawBuf[1] === 0xBB && rawBuf[2] === 0xBF) {
+        content = rawBuf.slice(3).toString('utf8');
+        _detectedEncoding = 'utf-8-bom';
+      } else {
+        content = rawBuf.toString('utf8');
+      }
+      if (_detectedEncoding !== 'utf-8') {
+        try { logEvent('plugkit', 'spool.body-encoding-recoded', { task: path.basename(filePath, path.extname(filePath)), encoding: _detectedEncoding, bytes: rawBuf.length }); } catch (_) {}
+      }
       const relPath = path.relative(inDir, filePath);
       const dir = path.dirname(relPath);
       const verb = dir === '.' ? path.basename(filePath, path.extname(filePath)) : dir;
@@ -2555,8 +2577,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)) {
@@ -2570,9 +2610,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.1332",
+  "version": "2.0.1334",
   "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.1332",
+  "version": "2.0.1334",
   "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.