gm-skill 2.0.1109 → 2.0.1111

package/README.md

@@ -28,7 +28,7 @@ npx gm-skill-bootstrap
 
 ## Version
 
-`2.0.1109` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` republishes this package alongside all 15 platform packages.
+`2.0.1111` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` republishes this package alongside all 15 platform packages.
 
 ## Source of truth
 

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import crypto from 'crypto';
 import { watch } from 'fs';
 import { spawn, spawnSync } from 'child_process';
 
@@ -23,14 +24,64 @@ function cosineSim(a, b) {
 const browserSessions = new Map();
 let nextBrowserSessionId = 1;
 
-function createWasiShim() {
-  return new Proxy({}, {
+function createWasiShim(instanceRef) {
+  const getMemory = () => instanceRef.value.exports.memory.buffer;
+  const shim = {
+    proc_exit: (code) => process.exit(code),
+    fd_write: (fd, iovs_ptr, iovs_len, nwritten_ptr) => {
+      try {
+        const buf = getMemory();
+        const dv = new DataView(buf);
+        const chunks = [];
+        let total = 0;
+        for (let i = 0; i < iovs_len; i++) {
+          const base = iovs_ptr + i * 8;
+          const ptr = dv.getUint32(base, true);
+          const len = dv.getUint32(base + 4, true);
+          if (len > 0) {
+            chunks.push(new Uint8Array(buf, ptr, len).slice());
+            total += len;
+          }
+        }
+        const merged = new Uint8Array(total);
+        let off = 0;
+        for (const c of chunks) { merged.set(c, off); off += c.length; }
+        const text = new TextDecoder('utf-8').decode(merged);
+        if (fd === 2) process.stderr.write(text);
+        else process.stdout.write(text);
+        new DataView(getMemory()).setUint32(nwritten_ptr, total, true);
+        return 0;
+      } catch (e) {
+        return 28;
+      }
+    },
+    random_get: (buf_ptr, buf_len) => {
+      try {
+        crypto.randomFillSync(new Uint8Array(getMemory(), buf_ptr, buf_len));
+        return 0;
+      } catch (e) {
+        return 28;
+      }
+    },
+    clock_time_get: (clock_id, precision, time_ptr) => {
+      try {
+        const ns = BigInt(Date.now()) * 1000000n;
+        new DataView(getMemory()).setBigUint64(time_ptr, ns, true);
+        return 0;
+      } catch (e) {
+        return 28;
+      }
+    },
+    environ_get: () => 0,
+    environ_sizes_get: () => 0,
+  };
+  return new Proxy(shim, {
     get(target, prop) {
-      if (prop === 'proc_exit') return (code) => process.exit(code);
-      if (prop === 'fd_write') return () => 0;
-      if (prop === 'environ_get') return () => 0;
-      if (prop === 'environ_sizes_get') return () => 0;
-      return () => 0;
+      if (prop in target) return target[prop];
+      return (...args) => {
+        console.error(`[plugkit-wasm] unimplemented WASI call: ${String(prop)} args=${args.length}`);
+        return 52;
+      };
     }
   });
 }
@@ -374,6 +425,42 @@ async function runSpoolWatcher(instance, spoolDir) {
   fs.mkdirSync(inDir, { recursive: true });
   fs.mkdirSync(outDir, { recursive: true });
 
+  const LOCK_PATH = path.join(spoolDir, '.watcher.lock');
+  function acquireLock() {
+    try {
+      if (fs.existsSync(LOCK_PATH)) {
+        const content = fs.readFileSync(LOCK_PATH, 'utf-8').trim();
+        const [pidStr, tsStr] = content.split('|');
+        const lockTs = parseInt(tsStr, 10);
+        const age = Date.now() - lockTs;
+        if (age < 15000) {
+          console.error(`[plugkit-wasm] another watcher active (pid=${pidStr}, age=${age}ms); refusing to start`);
+          process.exit(1);
+        }
+        console.error(`[plugkit-wasm] stale lock (age=${age}ms); taking over`);
+      }
+      fs.writeFileSync(LOCK_PATH, `${process.pid}|${Date.now()}`);
+    } catch (e) {
+      console.error(`[plugkit-wasm] lock acquire failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+  function refreshLock() {
+    try { fs.writeFileSync(LOCK_PATH, `${process.pid}|${Date.now()}`); } catch (_) {}
+  }
+  function releaseLock() {
+    try {
+      const content = fs.readFileSync(LOCK_PATH, 'utf-8').trim();
+      const [pidStr] = content.split('|');
+      if (pidStr === String(process.pid)) fs.unlinkSync(LOCK_PATH);
+    } catch (_) {}
+  }
+  acquireLock();
+  setInterval(refreshLock, 5000);
+  process.on('SIGINT', () => { releaseLock(); process.exit(0); });
+  process.on('SIGTERM', () => { releaseLock(); process.exit(0); });
+  process.on('exit', releaseLock);
+
   console.log(`[plugkit-wasm] plugkit v${resolveVersion(instance)} (wasm)`);
   console.log(`[plugkit-wasm] watching ${inDir}`);
 
@@ -549,7 +636,7 @@ async function runSpoolWatcher(instance, spoolDir) {
 
     const importObject = {
       env: hostFunctions,
-      wasi_snapshot_preview1: createWasiShim(),
+      wasi_snapshot_preview1: createWasiShim(instanceRef),
     };
 
     const instance = new WebAssembly.Instance(wasmModule, importObject);

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1109",
+  "version": "2.0.1111",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -11,12 +11,6 @@
     "automation"
   ],
   "homepage": "https://github.com/AnEntrypoint/gm",
-  "agents": [
-    {
-      "name": "gm",
-      "description": "Agent (not skill) - immutable programming state machine. Always invoke for all work coordination."
-    }
-  ],
   "engines": {
     "node": ">=16.0.0"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1109",
+  "version": "2.0.1111",
   "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",
@@ -39,7 +39,7 @@
     "gm.json"
   ],
   "dependencies": {
-    "gm-plugkit": "^2.0.1109"
+    "gm-plugkit": "^2.0.1111"
   },
   "engines": {
     "node": ">=16.0.0"

package/skills/gm-skill/SKILL.md

@@ -1,19 +1,27 @@
 ---
 name: gm-skill
-description: Canonical universal harness — AI-native software engineering. Plugkit serves all instructions, state, guardrails on demand via the spool.
+description: AI-native software engineering harness. plugkit serves all instructions, state, guardrails via the spool.
 allowed-tools: Skill, Read, Write
 ---
 
 # gm — single entry point
 
-Plugkit owns every instruction, every phase transition, every guardrail. The skill body is the only thing the agent reads from disk; everything else flows from plugkit verbs.
+The wasm artifact lives at `~/.claude/gm-tools/plugkit.wasm`; the spool watcher runs it. If `.gm/exec-spool/.status.json` is stale or absent, bootstrap has not seeded the watcher yet — re-invoke the skill or start it manually (`node plugkit-wasm-wrapper.js spool &`).
+
+## Dispatch ABI
+
+Write request body to `.gm/exec-spool/in/<verb>/<N>.txt`. Read response from `.gm/exec-spool/out/<verb>-<N>.json` for nested verbs, `.gm/exec-spool/out/<N>.json` for root verbs.
 
 ## The loop
 
-1. Write `.gm/exec-spool/in/instruction/<N>.txt` with empty body (or `phase=<override>` to force a phase). Read `.gm/exec-spool/out/instruction-<N>.json`.
-2. The response contains `phase`, `instruction` (prose to follow), `mutables_pending`, `prd_pending_count`, `next_phase_hint`.
-3. Follow the `instruction` body imperatively. Resolve mutables, execute work, dispatch other verbs (`recall`, `codesearch`, `memorize`, `mutable-resolve`, `transition`, all language stems) as the instruction directs.
-4. When the phase's exit condition is met, dispatch `in/transition/<N>.txt` to advance. Then re-enter step 1 with the new phase.
-5. Loop until `next_phase_hint` is null (phase=COMPLETE) — the chain is done.
+Dispatch `instruction` (empty body for current phase; `phase=<NAME>` line, `{"phase":"<NAME>"}`, or a raw phase name to override). The response carries `{phase, instruction, mutables_pending, prd_pending_count, next_phase_hint}`. Follow the `instruction` prose imperatively — it is the operative guidance for this phase. Resolve every `mutables_pending` entry through `mutable-resolve` before transitioning; the gate will refuse otherwise. When the phase's exit condition is met, dispatch `transition` (body: a phase name from `EXECUTE`/`EMIT`/`VERIFY`/`COMPLETE`, or empty to auto-advance), then re-enter with the new phase. Stop when `next_phase_hint` is null or phase is `COMPLETE`.
+
+## Orchestrator verbs
+
+`instruction`, `transition`, `phase-status`, `mutable-resolve`, `memorize-fire`, `residual-scan`, `auto-recall`.
+
+## Host verbs
+
+`fs_read`, `fs_write`, `fs_stat`, `fs_readdir`, `kv_get`, `kv_put`, `kv_query`, `fetch`, `exec_js`, `env_get`, `recall`, `codesearch`, `memorize`, `health`.
 
-No other skill exists. There is no `gm:planning`, no `gm:gm-execute`, no `gm:gm-emit`. Plugkit serves what those used to be, on demand, per phase.
+Plugkit serves what prior skills (`gm:planning`, `gm:gm-execute`) used to serve, on demand, per phase. There is no other skill.