gm-skill 2.0.1159 → 2.0.1161

package/README.md

@@ -35,7 +35,7 @@ An earlier generation fanned out fifteen per-platform downstream repos (gm-cc, g
 
 ## Version
 
-`2.0.1159` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` (or any cascading sibling crate) republishes this package.
+`2.0.1161` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` (or any cascading sibling crate) republishes this package.
 
 ## Source of truth
 

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.418
+0.1.419

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-ffb68924055bffd275db6a174fb5d286c1fcaf5a135f968345bf221b9976544f  plugkit.wasm
+623152434c8b0f75b20cb89f48551e3a1677f132275e0fc43e261db7a69afeed  plugkit.wasm

package/gm-plugkit/bootstrap.js

@@ -153,6 +153,23 @@ function sha256OfFile(filePath) {
   });
 }
 
+function resolveNpxJsCli() {
+  if (process.platform !== 'win32') return null;
+  const candidates = [];
+  if (process.env.npm_config_prefix) {
+    candidates.push(path.join(process.env.npm_config_prefix, 'node_modules', 'npm', 'bin', 'npx-cli.js'));
+  }
+  const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+  candidates.push(path.join(programFiles, 'nodejs', 'node_modules', 'npm', 'bin', 'npx-cli.js'));
+  candidates.push(path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npx-cli.js'));
+  const appdata = process.env.APPDATA;
+  if (appdata) candidates.push(path.join(appdata, 'npm', 'node_modules', 'npm', 'bin', 'npx-cli.js'));
+  for (const c of candidates) {
+    try { if (fs.existsSync(c)) return c; } catch (_) {}
+  }
+  return null;
+}
+
 async function extractNpmPackageWasm(destPath, version) {
   const tempDir = path.join(path.dirname(destPath), '.npm-extract-' + Date.now());
   try {
@@ -161,16 +178,28 @@ async function extractNpmPackageWasm(destPath, version) {
     log(`extracting npm package ${NPM_PACKAGE}@${version} to ${tempDir}`);
     obsEvent('bootstrap', 'npm.extract.start', { package: NPM_PACKAGE, version });
 
-    const result = spawnSync(
-      process.platform === 'win32' ? 'npx.cmd' : 'npx',
-      [NPM_PACKAGE + '@' + version, '--prefix', tempDir],
-      {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: ATTEMPT_TIMEOUT_MS,
-        encoding: 'utf8',
-        windowsHide: true,
+    let cmd, args;
+    if (process.platform === 'win32') {
+      const npxCli = resolveNpxJsCli();
+      if (npxCli) {
+        cmd = process.execPath;
+        args = [npxCli, NPM_PACKAGE + '@' + version, '--prefix', tempDir];
+      } else {
+        cmd = 'npx.cmd';
+        args = [NPM_PACKAGE + '@' + version, '--prefix', tempDir];
       }
-    );
+    } else {
+      cmd = 'npx';
+      args = [NPM_PACKAGE + '@' + version, '--prefix', tempDir];
+    }
+
+    const result = spawnSync(cmd, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: ATTEMPT_TIMEOUT_MS,
+      encoding: 'utf8',
+      windowsHide: true,
+      shell: process.platform === 'win32' && cmd === 'npx.cmd',
+    });
 
     if (result.error) throw result.error;
     if (result.status !== 0) {
@@ -192,25 +221,37 @@ async function extractNpmPackageWasm(destPath, version) {
 
 function httpGetBuffer(url, timeoutMs) {
   const https = require('https');
+  const idleTimeoutMs = timeoutMs || 30000;
+  const totalDeadlineMs = (timeoutMs || 30000) * 2;
   return new Promise((resolve, reject) => {
-    const req = https.get(url, { timeout: timeoutMs || 30000, headers: { 'user-agent': 'gm-plugkit-bootstrap' } }, (res) => {
+    let bytesReceived = 0;
+    let settled = false;
+    const settleReject = (err) => { if (!settled) { settled = true; reject(err); } };
+    const settleResolve = (v) => { if (!settled) { settled = true; resolve(v); } };
+    const absTimer = setTimeout(() => {
+      try { req.destroy(new Error(`abs-deadline ${totalDeadlineMs}ms ${url} after ${bytesReceived} bytes`)); } catch (_) {}
+      settleReject(new Error(`abs-deadline ${totalDeadlineMs}ms ${url} after ${bytesReceived} bytes`));
+    }, totalDeadlineMs);
+    const req = https.get(url, { timeout: idleTimeoutMs, headers: { 'user-agent': 'gm-plugkit-bootstrap' } }, (res) => {
       if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
         res.resume();
-        httpGetBuffer(res.headers.location, timeoutMs).then(resolve, reject);
+        clearTimeout(absTimer);
+        httpGetBuffer(res.headers.location, timeoutMs).then(settleResolve, settleReject);
         return;
       }
       if (res.statusCode !== 200) {
         res.resume();
-        reject(new Error(`HTTP ${res.statusCode} ${url}`));
+        clearTimeout(absTimer);
+        settleReject(new Error(`HTTP ${res.statusCode} ${url}`));
         return;
       }
       const chunks = [];
-      res.on('data', c => chunks.push(c));
-      res.on('end', () => resolve(Buffer.concat(chunks)));
-      res.on('error', reject);
+      res.on('data', c => { chunks.push(c); bytesReceived += c.length; });
+      res.on('end', () => { clearTimeout(absTimer); settleResolve(Buffer.concat(chunks)); });
+      res.on('error', (e) => { clearTimeout(absTimer); settleReject(e); });
     });
-    req.on('timeout', () => req.destroy(new Error(`timeout ${url}`)));
-    req.on('error', reject);
+    req.on('timeout', () => { try { req.destroy(new Error(`idle-timeout ${idleTimeoutMs}ms ${url}`)); } catch (_) {} settleReject(new Error(`idle-timeout ${idleTimeoutMs}ms ${url}`)); });
+    req.on('error', (e) => { clearTimeout(absTimer); settleReject(e); });
   });
 }
 

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

@@ -932,6 +932,22 @@ function resolveVersion(instance) {
   return 'unknown';
 }
 
+function readFileVersionOnly() {
+  try { return fs.readFileSync(path.join(os.homedir(), '.claude', 'gm-tools', 'plugkit.version'), 'utf8').trim(); } catch (_) { return null; }
+}
+
+function readInstanceVersion(instance) {
+  try {
+    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();
+  } catch (_) { return null; }
+}
+
 async function runSpoolWatcher(instance, spoolDir) {
   const inDir = path.join(spoolDir, 'in');
   const outDir = path.join(spoolDir, 'out');
@@ -947,8 +963,11 @@ async function runSpoolWatcher(instance, spoolDir) {
         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);
+          const msg = JSON.stringify({ ok: false, reason: 'another-watcher-active', pid: pidStr, age_ms: age });
+          console.error(`[plugkit-wasm] ${msg}; refusing to start`);
+          try { fs.writeFileSync(path.join(spoolDir, '.lock-rejection.json'), msg); } catch (_) {}
+          try { logEvent('plugkit', 'watcher.lock-rejected', { holder_pid: pidStr, lock_age_ms: age }); } catch (_) {}
+          process.exit(75);
         }
         console.error(`[plugkit-wasm] stale lock (age=${age}ms); taking over`);
       }
@@ -1035,6 +1054,35 @@ async function runSpoolWatcher(instance, spoolDir) {
     try { reapTimedOutTasks(); } catch (_) {}
   }, 5000);
 
+  const _instanceVersionAtBoot = readInstanceVersion(instance);
+  setInterval(() => {
+    try {
+      const fileV = readFileVersionOnly();
+      const instV = _instanceVersionAtBoot;
+      if (!fileV || !instV || fileV === instV) return;
+      logEvent('plugkit', 'version.drift', {
+        instance_version: instV,
+        file_version: fileV,
+        action: 'exit-for-respawn',
+      });
+      console.error(`[plugkit-wasm] version drift detected: instance=${instV} file=${fileV} → exiting so supervisor reloads fresh wasm`);
+      try {
+        fs.writeFileSync(path.join(spoolDir, '.shutdown-reason.json'), JSON.stringify({
+          reason: 'version-change',
+          ts: Date.now(),
+          pid: process.pid,
+          instance_version: instV,
+          file_version: fileV,
+        }));
+      } catch (_) {}
+      try { releaseLock(); } catch (_) {}
+      try { fs.unlinkSync(STATUS_PATH_FOR_TEARDOWN); } catch (_) {}
+      process.exit(0);
+    } catch (e) {
+      console.error(`[version-drift-check] error: ${e.message}`);
+    }
+  }, 60_000);
+
   setInterval(() => {
     try {
       const idleMs = Date.now() - lastActivityMs;

package/gm-plugkit/supervisor.js

@@ -130,27 +130,37 @@ function spawnWatcher(bootReason) {
     const shutdownReason = readShutdownReason();
     const reason = shutdownReason && shutdownReason.reason;
     const idleClean = reason === 'idle';
-    logEvent(idleClean ? 'supervisor.watcher-exited-idle' : 'supervisor.watcher-exited-unexpectedly', {
+    const plannedReasons = new Set(['idle', 'sigterm', 'version-change']);
+    const isPlanned = plannedReasons.has(reason);
+    const eventName = idleClean
+      ? 'supervisor.watcher-exited-idle'
+      : reason === 'version-change'
+        ? 'supervisor.watcher-exited-for-update'
+        : 'supervisor.watcher-exited-unexpectedly';
+    logEvent(eventName, {
       watcher_pid: currentChildPid,
       exit_code: code,
       signal,
       shutdown_reason: reason || null,
       had_shutdown_reason_file: shutdownReason !== null,
-      severity: idleClean ? 'info' : 'critical',
+      severity: isPlanned ? 'info' : 'critical',
       uptime_ms: Date.now() - lastSpawnedAt,
+      ...(shutdownReason || {}),
     });
     if (idleClean) {
       writeSupervisorStatus('exited-idle', { watcher_pid: currentChildPid });
       try { fs.unlinkSync(SUPERVISOR_PATH); } catch (_) {}
       process.exit(0);
     }
+    const respawnReason = reason === 'version-change' ? 'planned-restart-version-change' : 'unplanned-restart-after-exit';
     writeSupervisorStatus('restarting', {
       prior_watcher_pid: currentChildPid,
       prior_exit_code: code,
       prior_signal: signal,
       prior_shutdown_reason: reason || null,
+      respawn_reason: respawnReason,
     });
-    setTimeout(() => spawnWatcher('unplanned-restart-after-exit'), 1500);
+    setTimeout(() => spawnWatcher(respawnReason), 1500);
   });
 
   child.on('error', (err) => {

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1159",
+  "version": "2.0.1161",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -17,5 +17,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "plugkitVersion": "0.1.418"
+  "plugkitVersion": "0.1.419"
 }

package/package.json

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

package/skills/gm-skill/SKILL.md

@@ -18,6 +18,8 @@ Before any apparent stop, dispatch `residual-scan`. If it returns work that fits
 
 If the `instruction` response carries a non-null `update_available`, plugkit drift has been detected on disk and the running watcher is behind. Rebootstrap before continuing — newer fixes are sitting on disk unused, and every dispatch is wasted on stale code. `bun x gm-plugkit@latest` (or `npx -y gm-plugkit@latest`) is the one-shot: it fetches the new wasm, replaces the artifact, and the watcher reloads. Drift past one version is a deviation.
 
+If `running_tasks` is non-empty, you own them — every entry is a subprocess you started that's still consuming CPU/memory. Stop ones that have outlived their purpose with `task-stop` (write `.gm/exec-spool/in/task-stop/<N>.txt` with `{id: "t<n>"}`). The 15-min idle reaper is the last resort, not a substitute for hygiene. If `stuck_spool` is non-empty, dispatches are wedged — the watcher's host_exec_js is synchronous and a stuck body blocks every other verb until it returns. Diagnose via `.watcher.log` and consider rebootstrapping if it doesn't clear; spool bodies are Turing-complete and can loop forever. Long-running work goes through `task-spawn` (returns a `task_id` immediately, body runs detached), not through the sync `nodejs`/`bash`/`python` language verbs.
+
 The wasm artifact lives at `~/.claude/gm-tools/plugkit.wasm`; the spool watcher runs it. The watcher's own stdout/stderr is appended to `.gm/exec-spool/.watcher.log` — Read it to see plugkit's internal trace, dispatch timings, sweep actions, errors.
 
 The watcher self-shuts-down after 15 minutes idle (no spool I/O, no live browser session) and is restarted on next agent activity by a detached supervisor. `.gm/exec-spool/.unplanned-restart.json` is a critical-failure marker — present means a prior watcher died without a planned shutdown. Treat as a PRD-worthy incident on sight: diagnose via `.watcher.log` and `gm-log/<day>/plugkit.jsonl` events `supervisor.watcher-exited-unexpectedly` and `supervisor.heartbeat-stale` around the prior_status.ts timestamp, then delete the marker once root cause is named.
@@ -106,7 +108,7 @@ Stop only when `phase` is `COMPLETE` AND `residual-scan` returns empty AND the w
 
 ## Orchestrator verbs
 
-`instruction`, `transition`, `phase-status`, `prd-add`, `prd-resolve`, `prd-list`, `mutable-add`, `mutable-resolve`, `mutable-list`, `memorize-fire`, `residual-scan`, `auto-recall`.
+`instruction`, `transition`, `phase-status`, `prd-add`, `prd-resolve`, `prd-list`, `mutable-add`, `mutable-resolve`, `mutable-list`, `memorize-fire`, `residual-scan`, `auto-recall`, `task-spawn`, `task-list`, `task-stop`, `task-output`.
 
 ## Host verbs