gm-skill 2.0.1091 → 2.0.1093

package/README.md

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

package/bin/plugkit.js

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
 'use strict';
-// Hot path: spawnSync to ~/.claude/gm-tools/plugkit.exe with inherited stdio.
-// Cold path (session-start / prompt-submit OR missing binary): synchronously
-// ensure gm-tools/plugkit{.exe} matches the pinned version, then run hook.
-// Cache-aware: when local matches the pin (sha-checked), zero network calls.
-
 const { spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
@@ -12,12 +7,6 @@ const os = require('os');
 
 const wrapperDir = __dirname;
 
-function toolsBin() {
-  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
-  const exe = process.platform === 'win32' ? 'plugkit.exe' : 'plugkit';
-  return path.join(home, '.claude', 'gm-tools', exe);
-}
-
 function sha256OfFileSync(filePath) {
   try {
     const crypto = require('crypto');
@@ -32,14 +21,6 @@ function sha256OfFileSync(filePath) {
   } catch (_) { return null; }
 }
 
-function platformAsset() {
-  const p = process.platform;
-  const a = process.arch;
-  if (p === 'win32') return a === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe';
-  if (p === 'darwin') return a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64';
-  return (a === 'arm64' || a === 'aarch64') ? 'plugkit-linux-arm64' : 'plugkit-linux-x64';
-}
-
 function readPinnedVersion() {
   try { return fs.readFileSync(path.join(wrapperDir, 'plugkit.version'), 'utf8').trim(); } catch (_) { return null; }
 }

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.376
+0.1.377

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-858e0b66294f2799a0e14000dc2581f6937516ae11f9d3f5de9f13f3a3fa350c  plugkit.wasm
+26cc527cd72ee8d53711020c5f2bbcd9fad8c252329e5c72bb3ea1434ff4480c  plugkit.wasm

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

@@ -2,44 +2,329 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { watch } from 'fs';
+import { spawn, spawnSync } from 'child_process';
+
+const KV_DIR = path.join(os.homedir(), '.claude', 'gm-tools', 'kv');
+fs.mkdirSync(KV_DIR, { recursive: true });
+
+const RS_LEARN_URL = process.env.RS_LEARN_URL || 'http://127.0.0.1:8000';
+const VEC_K_DEFAULT = 10;
+
+const browserSessions = new Map();
+let nextBrowserSessionId = 1;
 
 function createWasiShim() {
-  const shim = new Proxy({}, {
+  return new Proxy({}, {
     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;
     }
   });
-  return shim;
 }
 
-function memWriteStr(memory, ptr, len, str) {
-  const bytes = new TextEncoder().encode(str);
-  const buf = new Uint8Array(memory.buffer, ptr, len);
-  buf.set(bytes.slice(0, len));
-  return Math.min(bytes.length, len);
+function readWasmBytes(instance, ptr, len) {
+  if (ptr === 0 || len === 0) return new Uint8Array(0);
+  return new Uint8Array(instance.exports.memory.buffer, ptr, len).slice();
 }
 
-function memReadStr(memory, ptr, len) {
-  const buf = new Uint8Array(memory.buffer, ptr, len);
-  return new TextDecoder().decode(buf);
+function readWasmStr(instance, ptr, len) {
+  if (ptr === 0 || len === 0) return '';
+  const bytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
+  return new TextDecoder('utf-8').decode(bytes);
 }
 
-let nextMemPtr = 0x10000;
-function allocInMemory(memory, data) {
-  const ptr = nextMemPtr;
-  const buf = new Uint8Array(memory.buffer, ptr, data.length);
-  buf.set(data);
-  nextMemPtr += data.length;
-  if (nextMemPtr > memory.buffer.byteLength - 4096) nextMemPtr = 0x10000;
-  return { ptr, len: data.length };
+function writeWasmBytes(instance, bytes) {
+  if (bytes.length === 0) return 0n;
+  const ptr = instance.exports.plugkit_alloc(bytes.length);
+  if (ptr === 0) return 0n;
+  new Uint8Array(instance.exports.memory.buffer, ptr, bytes.length).set(bytes);
+  return (BigInt(ptr) & 0xffffffffn) | (BigInt(bytes.length) << 32n);
 }
 
-function packResult(str) {
-  const bytes = new TextEncoder().encode(str);
-  const ptr = Math.random() * 0x100000 | 0;
-  const len = bytes.length;
-  return (BigInt(ptr) & 0xffffffffn) | (BigInt(len) << 32n);
+function writeWasmStr(instance, str) {
+  if (!str) return 0n;
+  return writeWasmBytes(instance, new TextEncoder().encode(str));
+}
+
+function writeWasmJson(instance, value) {
+  return writeWasmStr(instance, JSON.stringify(value));
+}
+
+function kvFilePath(ns, key) {
+  const safeNs = String(ns).replace(/[^A-Za-z0-9._-]/g, '_');
+  const safeKey = String(key).replace(/[^A-Za-z0-9._-]/g, '_');
+  const dir = path.join(KV_DIR, safeNs);
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, safeKey + '.json');
+}
+
+function makeHostFunctions(instanceRef) {
+  return {
+    host_fs_read: (pathPtr, pathLen) => {
+      try {
+        const filePath = readWasmStr(instanceRef.value, pathPtr, pathLen);
+        if (!filePath) return 0n;
+        const data = fs.readFileSync(filePath, 'utf-8');
+        return writeWasmStr(instanceRef.value, data);
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_fs_write: (pathPtr, pathLen, dataPtr, dataLen) => {
+      try {
+        const filePath = readWasmStr(instanceRef.value, pathPtr, pathLen);
+        const data = readWasmStr(instanceRef.value, dataPtr, dataLen);
+        if (!filePath) return 0;
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, data);
+        return 1;
+      } catch (e) {
+        return 0;
+      }
+    },
+
+    host_fs_readdir: (pathPtr, pathLen) => {
+      try {
+        const dirPath = readWasmStr(instanceRef.value, pathPtr, pathLen);
+        if (!dirPath) return 0n;
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true }).map(e => ({
+          name: e.name,
+          is_dir: e.isDirectory(),
+          is_file: e.isFile(),
+        }));
+        return writeWasmJson(instanceRef.value, entries);
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_fs_stat: (pathPtr, pathLen) => {
+      try {
+        const filePath = readWasmStr(instanceRef.value, pathPtr, pathLen);
+        if (!filePath) return 0n;
+        const s = fs.statSync(filePath);
+        return writeWasmJson(instanceRef.value, {
+          is_dir: s.isDirectory(),
+          is_file: s.isFile(),
+          size: s.size,
+          mtime_ms: s.mtimeMs,
+        });
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_fetch: (urlPtr, urlLen, optsPtr, optsLen) => {
+      try {
+        const url = readWasmStr(instanceRef.value, urlPtr, urlLen);
+        const optsStr = readWasmStr(instanceRef.value, optsPtr, optsLen);
+        const opts = optsStr ? JSON.parse(optsStr) : {};
+        const result = spawnSync(process.execPath, ['-e', `
+          const url = ${JSON.stringify(url)};
+          const opts = ${JSON.stringify(opts)};
+          fetch(url, opts).then(r => r.text().then(body => {
+            process.stdout.write(JSON.stringify({ status: r.status, body }));
+          })).catch(e => process.stdout.write(JSON.stringify({ status: 0, error: e.message })));
+        `], { encoding: 'utf-8', timeout: 10000 });
+        if (result.status !== 0) return writeWasmJson(instanceRef.value, { status: 0, error: result.stderr || 'fetch failed' });
+        return writeWasmStr(instanceRef.value, result.stdout || '{}');
+      } catch (e) {
+        return writeWasmJson(instanceRef.value, { status: 0, error: e.message });
+      }
+    },
+
+    host_kv_get: (nsPtr, nsLen, keyPtr, keyLen) => {
+      try {
+        const ns = readWasmStr(instanceRef.value, nsPtr, nsLen);
+        const key = readWasmStr(instanceRef.value, keyPtr, keyLen);
+        if (!ns || !key) return 0n;
+        const fp = kvFilePath(ns, key);
+        if (!fs.existsSync(fp)) return 0n;
+        const data = fs.readFileSync(fp, 'utf-8');
+        return writeWasmStr(instanceRef.value, data);
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_kv_put: (nsPtr, nsLen, keyPtr, keyLen, valPtr, valLen) => {
+      try {
+        const ns = readWasmStr(instanceRef.value, nsPtr, nsLen);
+        const key = readWasmStr(instanceRef.value, keyPtr, keyLen);
+        const val = readWasmStr(instanceRef.value, valPtr, valLen);
+        if (!ns || !key) return 0;
+        fs.writeFileSync(kvFilePath(ns, key), val);
+        return 1;
+      } catch (e) {
+        return 0;
+      }
+    },
+
+    host_kv_query: (nsPtr, nsLen, qPtr, qLen) => {
+      try {
+        const ns = readWasmStr(instanceRef.value, nsPtr, nsLen);
+        const q = readWasmStr(instanceRef.value, qPtr, qLen);
+        if (!ns) return 0n;
+        const dir = path.join(KV_DIR, String(ns).replace(/[^A-Za-z0-9._-]/g, '_'));
+        if (!fs.existsSync(dir)) return writeWasmJson(instanceRef.value, []);
+        const ql = q ? String(q).toLowerCase() : '';
+        const results = [];
+        for (const f of fs.readdirSync(dir)) {
+          if (!f.endsWith('.json')) continue;
+          const value = fs.readFileSync(path.join(dir, f), 'utf-8');
+          if (ql && !value.toLowerCase().includes(ql) && !f.toLowerCase().includes(ql)) continue;
+          results.push({ key: f.replace(/\.json$/, ''), value });
+        }
+        return writeWasmJson(instanceRef.value, results);
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_vec_search: (qPtr, qLen, k) => {
+      try {
+        const q = readWasmStr(instanceRef.value, qPtr, qLen);
+        if (!q) return writeWasmJson(instanceRef.value, []);
+        const k_ = k > 0 ? k : VEC_K_DEFAULT;
+        const body = JSON.stringify({ query: q, limit: k_, scope: 'episodes' });
+        const result = spawnSync(process.execPath, ['-e', `
+          fetch('${RS_LEARN_URL}/search', { method: 'POST', headers: { 'content-type': 'application/json' }, body: ${JSON.stringify(body)} })
+            .then(r => r.text().then(t => process.stdout.write(t)))
+            .catch(e => process.stdout.write(JSON.stringify({ error: e.message, results: [] })));
+        `], { encoding: 'utf-8', timeout: 5000 });
+        if (result.status !== 0 || !result.stdout) return writeWasmJson(instanceRef.value, []);
+        try {
+          const parsed = JSON.parse(result.stdout);
+          return writeWasmJson(instanceRef.value, parsed.results || parsed);
+        } catch (_) {
+          return writeWasmJson(instanceRef.value, []);
+        }
+      } catch (e) {
+        return writeWasmJson(instanceRef.value, []);
+      }
+    },
+
+    host_vec_embed: (textPtr, textLen) => {
+      try {
+        const text = readWasmStr(instanceRef.value, textPtr, textLen);
+        if (!text) return 0n;
+        const body = JSON.stringify({ text });
+        const result = spawnSync(process.execPath, ['-e', `
+          fetch('${RS_LEARN_URL}/embed', { method: 'POST', headers: { 'content-type': 'application/json' }, body: ${JSON.stringify(body)} })
+            .then(r => r.text().then(t => process.stdout.write(t)))
+            .catch(e => process.stdout.write(''));
+        `], { encoding: 'utf-8', timeout: 5000 });
+        if (result.status !== 0 || !result.stdout) return 0n;
+        return writeWasmStr(instanceRef.value, result.stdout);
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_browser_spawn: (urlPtr, urlLen) => {
+      try {
+        const url = readWasmStr(instanceRef.value, urlPtr, urlLen);
+        const id = BigInt(nextBrowserSessionId++);
+        browserSessions.set(id, { url, opened_at: Date.now() });
+        return id;
+      } catch (e) {
+        return 0n;
+      }
+    },
+
+    host_browser_eval: (sessionId, codePtr, codeLen) => {
+      try {
+        const code = readWasmStr(instanceRef.value, codePtr, codeLen);
+        const session = browserSessions.get(BigInt(sessionId));
+        if (!session) return writeWasmJson(instanceRef.value, { error: 'session not found' });
+        return writeWasmJson(instanceRef.value, { ok: false, error: 'browser eval not implemented in JS host; route via spool browser verb' });
+      } catch (e) {
+        return writeWasmJson(instanceRef.value, { error: e.message });
+      }
+    },
+
+    host_browser_close: (sessionId) => {
+      try {
+        return browserSessions.delete(BigInt(sessionId)) ? 1 : 0;
+      } catch (e) {
+        return 0;
+      }
+    },
+
+    host_exec_js: (codePtr, codeLen, optsPtr, optsLen) => {
+      try {
+        const code = readWasmStr(instanceRef.value, codePtr, codeLen);
+        const optsStr = readWasmStr(instanceRef.value, optsPtr, optsLen);
+        const opts = optsStr ? JSON.parse(optsStr) : {};
+        const lang = opts.lang || 'nodejs';
+        const cwd = opts.cwd || process.cwd();
+        const timeoutMs = opts.timeoutMs || 30000;
+        let cmd, args;
+        if (lang === 'nodejs' || lang === 'js') { cmd = process.execPath; args = ['-e', code]; }
+        else if (lang === 'python') { cmd = 'python'; args = ['-c', code]; }
+        else if (lang === 'bash') { cmd = 'bash'; args = ['-c', code]; }
+        else if (lang === 'deno') { cmd = 'deno'; args = ['eval', code]; }
+        else { return writeWasmJson(instanceRef.value, { ok: false, error: `unsupported lang: ${lang}` }); }
+        const result = spawnSync(cmd, args, { encoding: 'utf-8', timeout: timeoutMs, cwd, env: process.env });
+        return writeWasmJson(instanceRef.value, {
+          ok: result.status === 0,
+          stdout: result.stdout || '',
+          stderr: result.stderr || '',
+          exit_code: result.status === null ? -1 : result.status,
+          timed_out: result.signal === 'SIGTERM',
+        });
+      } catch (e) {
+        return writeWasmJson(instanceRef.value, { ok: false, error: e.message });
+      }
+    },
+
+    host_log: (level, msgPtr, msgLen) => {
+      try {
+        const msg = readWasmStr(instanceRef.value, msgPtr, msgLen);
+        const prefix = level >= 3 ? '[plugkit-wasm:err]' : level >= 2 ? '[plugkit-wasm:warn]' : '[plugkit-wasm]';
+        if (level >= 2) console.error(`${prefix} ${msg}`);
+        else console.log(`${prefix} ${msg}`);
+        return 0;
+      } catch (e) {
+        return 0;
+      }
+    },
+
+    host_now_ms: () => BigInt(Date.now()),
+
+    host_env_get: (keyPtr, keyLen) => {
+      try {
+        const key = readWasmStr(instanceRef.value, keyPtr, keyLen);
+        if (!key) return 0n;
+        const v = process.env[key];
+        if (v === undefined) return 0n;
+        return writeWasmStr(instanceRef.value, v);
+      } catch (e) {
+        return 0n;
+      }
+    },
+  };
+}
+
+function resolveVersion(instance) {
+  try {
+    return fs.readFileSync(path.join(os.homedir(), '.claude', 'gm-tools', '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';
 }
 
 async function runSpoolWatcher(instance, spoolDir) {
@@ -48,6 +333,7 @@ async function runSpoolWatcher(instance, spoolDir) {
   fs.mkdirSync(inDir, { recursive: true });
   fs.mkdirSync(outDir, { recursive: true });
 
+  console.log(`[plugkit-wasm] plugkit v${resolveVersion(instance)} (wasm)`);
   console.log(`[plugkit-wasm] watching ${inDir}`);
 
   const processed = new Set();
@@ -69,22 +355,38 @@ async function runSpoolWatcher(instance, spoolDir) {
       const verbBytes = new TextEncoder().encode(verb);
       const bodyBytes = new TextEncoder().encode(body);
 
-      const { ptr: verbPtr, len: verbLen } = allocInMemory(instance.exports.memory, verbBytes);
-      const { ptr: bodyPtr, len: bodyLen } = allocInMemory(instance.exports.memory, bodyBytes);
+      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 result = dispatch(verbPtr, verbLen, bodyPtr, bodyLen);
+      const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
 
       const ptr = Number(result & 0xffffffffn);
       const len = Number(result >> 32n);
-      const resultStr = memReadStr(instance.exports.memory, ptr, len);
+      const resultBytes = new Uint8Array(instance.exports.memory.buffer, ptr, len);
+      const resultStr = new TextDecoder().decode(resultBytes);
+
+      const taskBase = path.basename(filePath, path.extname(filePath));
+      const outName = dir === '.' ? `${taskBase}.json` : `${verb}-${taskBase}.json`;
+      fs.writeFileSync(path.join(outDir, outName), resultStr);
 
-      const taskId = Math.random().toString(36).slice(2);
-      fs.writeFileSync(path.join(outDir, `${taskId}.json`), resultStr);
+      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 (_) {}
 
       fs.unlinkSync(filePath);
       processed.delete(key);
     } catch (e) {
       console.error(`[plugkit-wasm] error processing ${key}: ${e.message}`);
+      const taskBase = path.basename(filePath, path.extname(filePath));
+      const relPath = path.relative(inDir, filePath);
+      const dir = path.dirname(relPath);
+      const verb = dir === '.' ? taskBase : dir;
+      const outName = dir === '.' ? `${taskBase}.json` : `${verb}-${taskBase}.json`;
+      try {
+        fs.writeFileSync(path.join(outDir, outName), JSON.stringify({ ok: false, error: e.message }));
+      } catch (_) {}
       try { fs.unlinkSync(filePath); } catch (_) {}
       processed.delete(key);
     }
@@ -108,6 +410,18 @@ async function runSpoolWatcher(instance, spoolDir) {
     return files;
   }
 
+  const heartbeatPath = path.join(spoolDir, '.watcher.heartbeat');
+  setInterval(() => {
+    try { fs.writeFileSync(heartbeatPath, String(Date.now())); } catch (_) {}
+  }, 5000);
+
+  const pollDeadline = setInterval(async () => {
+    const existing = walkDir(inDir);
+    for (const fullPath of existing) {
+      await processFile(fullPath);
+    }
+  }, 250);
+
   const existing = walkDir(inDir);
   for (const fullPath of existing) {
     await processFile(fullPath);
@@ -139,38 +453,20 @@ async function runSpoolWatcher(instance, spoolDir) {
     const wasmBuffer = fs.readFileSync(wasmPath);
     const wasmModule = new WebAssembly.Module(wasmBuffer);
 
-    const memory = new WebAssembly.Memory({ initial: 256, maximum: 512 });
-
-    const hostFunctions = {
-      host_fs_read: () => 0,
-      host_fs_write: () => 0,
-      host_fs_readdir: () => 0,
-      host_fs_stat: () => 0,
-      host_kv_get: () => 0,
-      host_kv_put: () => 0,
-      host_kv_query: () => 0,
-      host_fetch: () => 0,
-      host_vec_search: () => 0,
-      host_vec_embed: () => 0,
-      host_browser_spawn: () => 0,
-      host_browser_eval: () => 0,
-      host_browser_close: () => 0,
-      host_exec_js: () => 0,
-      host_log: (ptr, len) => { console.log('[host_log]'); return 0; },
-      host_now_ms: () => BigInt(Date.now()),
-      host_env_get: () => 0,
-    };
+    const instanceRef = { value: null };
+    const hostFunctions = makeHostFunctions(instanceRef);
 
     const importObject = {
-      env: { memory, ...hostFunctions },
+      env: hostFunctions,
       wasi_snapshot_preview1: createWasiShim(),
     };
 
     const instance = new WebAssembly.Instance(wasmModule, importObject);
+    instanceRef.value = instance;
 
     const args = process.argv.slice(2);
     if (args.includes('--version')) {
-      console.log('plugkit v0.1.366 (wasm)');
+      console.log(`plugkit v${resolveVersion(instance)} (wasm)`);
       process.exit(0);
     }
 
@@ -178,6 +474,22 @@ async function runSpoolWatcher(instance, spoolDir) {
       const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
       const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
       await runSpoolWatcher(instance, spoolDir);
+    } else if (args[0] === 'dispatch') {
+      const verb = args[1] || '';
+      const body = args[2] || '{}';
+      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 result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
+      const ptr = Number(result & 0xffffffffn);
+      const len = Number(result >> 32n);
+      const out = new TextDecoder().decode(new Uint8Array(instance.exports.memory.buffer, ptr, len));
+      process.stdout.write(out);
+      process.exit(0);
     } else {
       console.log('[plugkit-wasm] args:', args.join(' '));
       process.exit(0);

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1091",
+  "version": "2.0.1093",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "plugkitVersion": "0.1.376"
+  "plugkitVersion": "0.1.377"
 }

package/lang/browser.js

@@ -1,27 +1,24 @@
 'use strict';
 const path = require('path');
 const os = require('os');
-const { spawnSync, execSync } = require('child_process');
+const { spawnSync } = require('child_process');
 const fsSync = require('fs');
 
 function findPlugkit() {
   if (process.env.PLUGKIT_BIN && fsSync.existsSync(process.env.PLUGKIT_BIN)) return process.env.PLUGKIT_BIN;
   const home = os.homedir();
-  const isWin = process.platform === 'win32';
-  const exe = isWin ? 'plugkit.exe' : 'plugkit';
   const candidates = [
-    path.join(home, '.claude', 'gm-tools', exe),
-    path.join(home, '.local', 'bin', exe),
-    path.join(home, '.claude', 'plugins', 'marketplaces', 'gm-cc', 'bin', exe),
+    path.join(__dirname, '..', 'bin', 'plugkit.js'),
+    path.join(home, '.claude', 'gm-tools', 'plugkit.js'),
+    path.join(home, '.claude', 'plugins', 'marketplaces', 'gm-cc', 'bin', 'plugkit.js'),
   ];
   if (process.env.CLAUDE_PLUGIN_ROOT) {
-    candidates.push(path.join(process.env.CLAUDE_PLUGIN_ROOT, 'bin', exe));
+    candidates.push(path.join(process.env.CLAUDE_PLUGIN_ROOT, 'bin', 'plugkit.js'));
   }
   for (const p of candidates) {
     if (fsSync.existsSync(p)) return p;
   }
-  try { execSync('plugkit --version', { encoding: 'utf-8', timeout: 3000 }); return 'plugkit'; } catch (_) {}
-  return 'plugkit';
+  return null;
 }
 
 module.exports = {
@@ -32,8 +29,9 @@ module.exports = {
       try {
         fsSync.writeFileSync(tmp, code, 'utf-8');
         const plugkit = findPlugkit();
+        if (!plugkit) return '[plugkit wrapper not found]';
         const opts = { encoding: 'utf-8', timeout: 120000, windowsHide: true, ...(cwd && { cwd }) };
-        const r = spawnSync(plugkit, ['exec', '--lang', 'browser', '--file', tmp], opts);
+        const r = spawnSync(process.execPath, [plugkit, 'exec', '--lang', 'browser', '--file', tmp], opts);
         const out = (r.stdout || '').trimEnd();
         const err = (r.stderr || '').trimEnd();
         return out && err ? out + '\n[stderr]\n' + err : out || err || '(no output)';

package/lib/skill-bootstrap.js

@@ -113,39 +113,54 @@ async function downloadPlugkitBinary(version) {
   });
 }
 
-function isProcessRunning(pidOrName) {
+function findPlugkitWasmPids() {
+  const pids = [];
   try {
-    const plat = getPlatformKey();
-    if (plat === 'win32') {
-      const output = execSync('tasklist /FO CSV /NH', { encoding: 'utf8' });
+    if (process.platform === 'win32') {
+      const output = execSync('wmic process where "Name=\'bun.exe\' or Name=\'node.exe\'" get ProcessId,CommandLine /FORMAT:CSV', { encoding: 'utf8' });
       const lines = output.split('\n').filter(Boolean);
-      return lines.some(line => {
-        const parts = line.split(',').map(p => p.trim().replace(/^"/, '').replace(/"$/, ''));
-        return parts[0] === 'plugkit.exe' || parts[0] === pidOrName;
-      });
+      for (const line of lines) {
+        if (!line.includes('plugkit-wasm-wrapper.js')) continue;
+        const parts = line.split(',');
+        const pid = parts[parts.length - 1].trim();
+        if (/^\d+$/.test(pid)) pids.push(pid);
+      }
     } else {
-      try {
-        execSync(`ps -p ${pidOrName} > /dev/null 2>&1`);
-        return true;
-      } catch {
-        return false;
+      const output = execSync("ps -eo pid,args", { encoding: 'utf8' });
+      const lines = output.split('\n').filter(Boolean);
+      for (const line of lines) {
+        if (!line.includes('plugkit-wasm-wrapper')) continue;
+        const m = line.trim().match(/^(\d+)\s/);
+        if (m) pids.push(m[1]);
       }
     }
   } catch (e) {
-    return false;
   }
+  return pids;
+}
+
+function isProcessRunning() {
+  return findPlugkitWasmPids().length > 0;
 }
 
 function killExistingPlugkit() {
   try {
-    const plat = getPlatformKey();
-    if (plat === 'win32') {
-      execSync('taskkill /IM plugkit.exe /F 2>nul || true', { shell: true });
-      emitBootstrapEvent('info', 'Killed existing plugkit process on Windows');
-    } else {
-      execSync('pkill -f "plugkit" || true', { shell: true });
-      emitBootstrapEvent('info', 'Killed existing plugkit process on Unix');
+    const pids = findPlugkitWasmPids();
+    if (pids.length === 0) {
+      emitBootstrapEvent('info', 'No existing plugkit WASM watcher to kill');
+      return;
     }
+    for (const pid of pids) {
+      try {
+        if (process.platform === 'win32') {
+          execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
+        } else {
+          execSync(`kill -9 ${pid}`, { stdio: 'ignore' });
+        }
+      } catch (e) {
+      }
+    }
+    emitBootstrapEvent('info', 'Killed existing plugkit WASM watcher', { pids });
   } catch (e) {
     emitBootstrapEvent('warn', 'Failed to kill existing plugkit', { error: e.message });
   }
@@ -235,7 +250,7 @@ async function spawnPlugkitWatcher(wasmPath) {
   }
 }
 
-async function bootstrapPlugkit() {
+async function bootstrapPlugkit(sessionId) {
   const startTime = Date.now();
 
   try {
@@ -251,18 +266,19 @@ async function bootstrapPlugkit() {
     if (!binaryMissing && !versionMismatch) {
       emitBootstrapEvent('info', 'Binary up-to-date', { version: installedVersion });
 
-      if (isProcessRunning('plugkit')) {
+      if (isProcessRunning()) {
         emitBootstrapEvent('info', 'Plugkit watcher already running');
         const statusPayload = {
           ok: true,
           version: installedVersion,
           status: 'running',
+          sessionId: sessionId || null,
           timestamp: new Date().toISOString(),
           durationMs: Date.now() - startTime,
         };
         fs.mkdirSync(path.dirname(BOOTSTRAP_STATUS_FILE), { recursive: true });
         fs.writeFileSync(BOOTSTRAP_STATUS_FILE, JSON.stringify(statusPayload, null, 2));
-        return { ok: true };
+        return { ok: true, binaryPath: PLUGKIT_WASM_PATH };
       }
     }
 
@@ -308,10 +324,10 @@ async function bootstrapPlugkit() {
       emitBootstrapEvent('warn', 'Binary health check failed, but proceeding');
     }
 
-    const watcherRunning = isProcessRunning('plugkit');
+    const watcherRunning = isProcessRunning();
     let watcherPid;
     if (!watcherRunning) {
-      watcherPid = await spawnPlugkitWatcher(plugkitPath);
+      watcherPid = await spawnPlugkitWatcher(PLUGKIT_WASM_PATH);
     } else {
       watcherPid = 'already-running';
       emitBootstrapEvent('info', 'Watcher already running');
@@ -322,6 +338,7 @@ async function bootstrapPlugkit() {
       ok: true,
       version: currentVersion,
       watcherPid,
+      sessionId: sessionId || null,
       timestamp: new Date().toISOString(),
       durationMs: Date.now() - startTime,
     };
@@ -330,7 +347,7 @@ async function bootstrapPlugkit() {
     fs.writeFileSync(BOOTSTRAP_STATUS_FILE, JSON.stringify(statusPayload, null, 2));
 
     emitBootstrapEvent('info', 'Bootstrap completed successfully', statusPayload);
-    return { ok: true };
+    return { ok: true, binaryPath: PLUGKIT_WASM_PATH };
   } catch (err) {
     const errorPayload = {
       ok: false,
@@ -381,17 +398,12 @@ async function bootstrapAcptoapi() {
 }
 
 async function getSnapshot(sessionId, cwd) {
-  const plugkitPath = getPlugkitPath();
-  if (!fs.existsSync(plugkitPath)) {
-    return { git: { ok: false }, tasks: [], error: 'plugkit not found' };
-  }
-
   try {
     const sid = sessionId || process.env.CLAUDE_SESSION_ID || 'default';
     const c = cwd || process.cwd();
-    const cmd = `"${plugkitPath}" snapshot --session "${sid}" --cwd "${c}"`;
-    const output = execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    return JSON.parse(output);
+    const result = await spool.execSpool('snapshot', 'snapshot', { sessionId: sid, cwd: c, timeoutMs: 5000 });
+    if (result && typeof result === 'object') return result;
+    return { git: { ok: false }, tasks: [], error: 'no snapshot result' };
   } catch (e) {
     emitBootstrapEvent('warn', 'Failed to get snapshot', { error: e.message });
     return { git: { ok: false }, tasks: [], error: e.message };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1091",
+  "version": "2.0.1093",
   "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.1091"
+    "gm-plugkit": "^2.0.1093"
   },
   "engines": {
     "node": ">=16.0.0"

package/scripts/run-hook.sh

@@ -1,7 +1,6 @@
 #!/bin/sh
 PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT}}"
 [ -z "$PLUGIN_ROOT" ] && exit 0
-PLUGKIT="$PLUGIN_ROOT/bin/plugkit"
-[ -f "$PLUGIN_ROOT/bin/plugkit.exe" ] && PLUGKIT="$PLUGIN_ROOT/bin/plugkit.exe"
-[ ! -f "$PLUGKIT" ] && exit 0
-"$PLUGKIT" hook "$1"
+PLUGKIT_JS="$PLUGIN_ROOT/bin/plugkit.js"
+[ ! -f "$PLUGKIT_JS" ] && exit 0
+node "$PLUGKIT_JS" hook "$1"