gm-skill 2.0.1970 → 2.0.1972

package/gm-plugkit/bootstrap.js

@@ -849,6 +849,63 @@ function ensureGmPlugkitVersionFresh() {
   } catch (_) { return false; }
 }
 
+const SEMVER_RE = /^\d+\.\d+\.\d+$/;
+
+function readPinnedGmPlugkitVersion() {
+  try {
+    const p = path.join(gmToolsDir(), 'gm-plugkit.version');
+    if (!fs.existsSync(p)) return null;
+    const v = fs.readFileSync(p, 'utf-8').trim();
+    if (!v || !SEMVER_RE.test(v)) return null;
+    return v;
+  } catch (_) { return null; }
+}
+
+function resolveBunRuntime() {
+  const candidates = process.platform === 'win32' ? ['bun.exe', 'bun'] : ['bun'];
+  for (const c of candidates) {
+    try {
+      const r = spawnSync('where', [c], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true, timeout: 800 });
+      if (r.status === 0) {
+        const lines = (r.stdout || '').split(/\r?\n/).map(l => l.trim()).filter(Boolean);
+        const exe = lines.find(l => /\.exe$/i.test(l)) || lines[0];
+        if (exe) return exe;
+      }
+    } catch (_) {}
+  }
+  return process.platform === 'win32' ? 'bun.exe' : 'bun';
+}
+
+function spawnPinnedBoot(extraArgs) {
+  const args = Array.isArray(extraArgs) ? extraArgs : [];
+  const pinned = readPinnedGmPlugkitVersion();
+  if (!pinned) {
+    return { ok: false, reason: 'no-pin-file', fallback: '@latest' };
+  }
+  const runtime = resolveBunRuntime();
+  const bunxArgs = ['x', `gm-plugkit@${pinned}`, ...args];
+  const startedMs = Date.now();
+  let result;
+  try {
+    result = spawnSync(runtime, bunxArgs, {
+      stdio: 'inherit',
+      windowsHide: true,
+      shell: false,
+      env: { ...process.env, GM_PLUGKIT_PINNED_REEXEC: '1' },
+    });
+  } catch (e) {
+    return { ok: false, reason: 'spawn-failed', error: e.message, pinned_version: pinned, fallback: '@latest' };
+  }
+  const durationMs = Date.now() - startedMs;
+  if (result.error) {
+    return { ok: false, reason: 'spawn-error', error: result.error.message, pinned_version: pinned, fallback: '@latest' };
+  }
+  if (typeof result.status === 'number' && result.status !== 0) {
+    return { ok: false, reason: 'pinned-invocation-nonzero-exit', status: result.status, pinned_version: pinned, duration_ms: durationMs, fallback: '@latest' };
+  }
+  return { ok: true, pinned_version: pinned, duration_ms: durationMs, status: result.status };
+}
+
 function discoverBundledSkillsAndSources() {
   const found = new Map();
   found.set('gm', path.join(__dirname, 'SKILL.md'));
@@ -1213,6 +1270,9 @@ module.exports = {
   ensureGmPlugkitVersionFresh,
   ensureSkillMdFresh,
   ensureWrapperFresh,
+  readPinnedGmPlugkitVersion,
+  resolveBunRuntime,
+  spawnPinnedBoot,
 };
 
 if (require.main === module) {

package/gm-plugkit/cli.js

@@ -5,7 +5,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const cp = require('child_process');
-const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh, ensureWrapperFresh, isReady, getWasmPath } = require('./bootstrap');
+const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh, ensureWrapperFresh, isReady, getWasmPath, readPinnedGmPlugkitVersion, spawnPinnedBoot } = require('./bootstrap');
 
 function getWasmPathSafe() {
   try { return getWasmPath(); } catch (_) { return null; }
@@ -77,6 +77,22 @@ Usage:
                                              wrapper sha differs from on-disk
                                              (lets new wrapper code load on next bootstrap)
   bun x gm-plugkit@latest --help             Show this help
+
+Opt-in pinned fast-path (skips bunx's own @latest npm-registry resolution):
+  GM_PLUGKIT_PREFER_PINNED=1 bun x gm-plugkit@latest spool
+  bun x gm-plugkit@latest spool --pinned
+                                             Reads ~/.gm-tools/gm-plugkit.version
+                                             (written by every successful boot) and
+                                             re-execs 'bun x gm-plugkit@<pinned-exact-version>'
+                                             with the remaining args -- bunx skips registry
+                                             resolution for an exact version once cached, so
+                                             this is genuinely faster than @latest on repeat
+                                             boots. Falls back to normal @latest-driven
+                                             behavior automatically when no pin file exists
+                                             yet (first-ever boot) or the pinned invocation
+                                             fails (stale/unpublished pinned version).
+                                             Opt-in only -- the default boot line above is
+                                             unaffected.
 `;
 
 function readDiskWasmVersion() {
@@ -238,6 +254,25 @@ function writeCliError(phase, err) {
     process.exit(killStaleWatchers());
   }
 
+  const wantsPinned = process.env.GM_PLUGKIT_PREFER_PINNED === '1' || args.includes('--pinned');
+  const alreadyReexecedPinned = process.env.GM_PLUGKIT_PINNED_REEXEC === '1';
+  if (wantsPinned && !alreadyReexecedPinned) {
+    const passArgs = args.filter(a => a !== '--pinned');
+    const pinned = readPinnedGmPlugkitVersion();
+    if (pinned) {
+      writeCliStatus({ phase: 'pinned-fast-path', pinned_version: pinned });
+      const result = spawnPinnedBoot(passArgs);
+      if (result.ok) {
+        process.exit(typeof result.status === 'number' ? result.status : 0);
+      }
+      writeCliStatus({ phase: 'pinned-fast-path-fallback', reason: result.reason, pinned_version: result.pinned_version || null });
+      console.error(`[gm-plugkit] pinned fast-path failed (${result.reason}), falling back to @latest resolution`);
+    } else {
+      writeCliStatus({ phase: 'pinned-fast-path-no-pin-file' });
+      console.error('[gm-plugkit] GM_PLUGKIT_PREFER_PINNED set but no ~/.gm-tools/gm-plugkit.version pin file yet -- falling back to @latest resolution (this boot will write the pin for next time)');
+    }
+  }
+
   ensureSpoolDir();
   writeCliStatus({ phase: 'starting', args });
 

package/gm-plugkit/gm-process.js

@@ -5,7 +5,7 @@ const { spawnSync } = require('child_process');
 function pidCommandLineForKillGuard(pid) {
   try {
     if (process.platform === 'win32') {
-      const r = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${Number(pid)}").CommandLine`], { encoding: 'utf8', windowsHide: true, timeout: 5000 });
+      const r = spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `(Get-WmiObject Win32_Process -Filter "ProcessId=${Number(pid)}").CommandLine`], { encoding: 'utf8', windowsHide: true, timeout: 5000 });
       return String((r && r.stdout) || '');
     }
     const r = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 });

package/gm-plugkit/package.json

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

@@ -2504,6 +2504,69 @@ function hostTaskProc(action, params) {
   }
 }
 
+let _gmRunnerEmbedBinPath;
+function resolveGmRunnerEmbedBin() {
+  if (_gmRunnerEmbedBinPath !== undefined) return _gmRunnerEmbedBinPath;
+  const exe = path.join(GM_TOOLS_ROOT, process.platform === 'win32' ? 'gm-runner.exe' : 'gm-runner');
+  _gmRunnerEmbedBinPath = fs.existsSync(exe) ? exe : null;
+  return _gmRunnerEmbedBinPath;
+}
+
+// Slim-build support: plugkit-core's embed.rs probes host_vec_embed BEFORE
+// ever loading the 133MB wasm-embedded safetensors fallback (see
+// rs-plugkit/crates/plugkit-core/src/embed.rs::init_ctx) -- if this function
+// returns a real embedding, the wasm-side model never loads at all. Wired
+// here to gm-runner's OWN native candle path (crates/gm-runner/src/embed.rs)
+// via its `embed-text` one-shot subcommand (stdin=text,
+// stdout={"embedding":[...]}), a synchronous spawnSync call so the wasm-side
+// caller (a synchronous extern "C" import) can block on it correctly. Used
+// ONLY when a real ~/.gm-tools/gm-runner(.exe) binary is present on this
+// host; if absent, returns null immediately and the caller (host_vec_embed
+// below) falls through to -1, which makes plugkit-core's own probe fail and
+// fall back to loading the wasm-embedded fat-build safetensors model exactly
+// as before -- embedding capability is never silently lost on a host with no
+// gm-runner installed, by design (this is the real fallback the
+// slim-wasm-default-flip PRD row required be live before any default-feature
+// flip).
+function hostEmbedViaGmRunner(text) {
+  const bin = resolveGmRunnerEmbedBin();
+  if (!bin) return null;
+  try {
+    const r = spawnSync(bin, ['embed-text'], {
+      input: text,
+      encoding: 'utf-8',
+      windowsHide: true,
+      timeout: 30000,
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    if (r.error || r.status !== 0) return null;
+    const parsed = JSON.parse(r.stdout || '{}');
+    if (!Array.isArray(parsed.embedding)) return null;
+    return parsed.embedding;
+  } catch (_) {
+    return null;
+  }
+}
+
+globalThis.__hostEmbedSync = function __hostEmbedSync(textPtr, textLen, outPtr, outLen, instance) {
+  try {
+    const text = readWasmStr(instance, textPtr, textLen);
+    if (!text) return -1;
+    const values = hostEmbedViaGmRunner(text);
+    if (!values || values.length === 0) return -1;
+    const dim = Math.min(values.length, outLen >>> 0);
+    const bytes = new Uint8Array(dim * 4);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < dim; i++) view.setFloat32(i * 4, values[i], true);
+    const buffer = instance.exports.memory.buffer;
+    guardWasmRange(buffer, outPtr, dim * 4, '__hostEmbedSync:write');
+    new Uint8Array(buffer, outPtr, dim * 4).set(bytes);
+    return dim;
+  } catch (_) {
+    return -1;
+  }
+};
+
 function makeHostFunctions(instanceRef) {
   return {
     host_fs_read: (pathPtr, pathLen) => {
@@ -4445,6 +4508,7 @@ async function runSpoolWatcher(instance, spoolDir) {
           wasm_aborted: true,
         }));
         fs.renameSync(abortTmpPath, abortOutPath);
+        try { fs.writeFileSync(abortOutPath + '.ready', ''); } catch (_) {}
         try { fs.unlinkSync(filePath); } catch (_) {}
       } catch (_) {}
       unmarkProcessed(key);
@@ -4566,6 +4630,7 @@ async function runSpoolWatcher(instance, spoolDir) {
       const outTmpPath = outPath + '.tmp.' + process.pid;
       fs.writeFileSync(outTmpPath, resultStr);
       fs.renameSync(outTmpPath, outPath);
+      try { fs.writeFileSync(outPath + '.ready', ''); } catch (_) {}
       const dur_ms = Date.now() - t0;
       console.log(`[dispatch] <- verb=${verb} task=${taskBase} ms=${dur_ms} out=${resultStr.length}b`);
       logEvent('plugkit', 'dispatch.end', { verb, task: taskBase, dur_ms, out_bytes: resultStr.length });
@@ -4611,6 +4676,7 @@ async function runSpoolWatcher(instance, spoolDir) {
         const errTmpPath = errOutPath + '.tmp.' + process.pid;
         fs.writeFileSync(errTmpPath, JSON.stringify({ ok: false, error: e.message }));
         fs.renameSync(errTmpPath, errOutPath);
+        try { fs.writeFileSync(errOutPath + '.ready', ''); } catch (_) {}
       } catch (_) {}
       try { fs.unlinkSync(filePath); } catch (_) {}
       unmarkProcessed(key);

package/gm-plugkit/supervisor.js

@@ -29,7 +29,26 @@ const LOG_PATH = path.join(spoolDir, '.watcher.log');
 const GM_LOG_ROOT = _sharedGmLogRoot;
 
 const POLL_INTERVAL_MS = 10_000;
-const STATUS_STALE_MS = 30_000;
+// Was 30s. Live-measured this session under real multi-agent concurrent load
+// (13 parallel gm-skill-driven agents, each booting its own watcher on the
+// same machine): 74 of 94 total watcher restarts logged in one session were
+// heartbeat-stale kills, the dominant restart cause by a wide margin -- each
+// restart drops the process's memory back to near-zero then it climbs again
+// through a fresh cold-embed pass, which is the actual mechanism behind the
+// "memory grows to ~2GB then clears" pattern a user observed and correctly
+// flagged as inefficient. The busy_until shielding mechanism (see writeStatus
+// call sites in plugkit-wasm-wrapper.js) already protects genuinely-busy
+// single dispatches, but under real CPU contention from many concurrent
+// processes, even the setInterval-based busy_until REFRESH callback itself
+// can be delayed past the old 30s window before it fires -- a starvation
+// problem one level above the per-dispatch busy-window fixes already shipped
+// this session. Raising the stale threshold gives real contention more slack
+// before concluding a process is dead, trading a slightly slower true-dead
+// detection for far fewer false-positive kills-and-restarts (each restart is
+// far more expensive than the extra wait -- a full cold embed pass observed
+// taking 90-120s+ under load) -- a clear net win under the contention this
+// session repeatedly measured.
+const STATUS_STALE_MS = 90_000;
 const MAX_RESTART_BURST = 5;
 const RESTART_WINDOW_MS = 60_000;
 const BURST_BACKOFF_MS = 60_000;

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1970",
+  "version": "2.0.1972",
   "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.1970",
+  "version": "2.0.1972",
   "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",