gm-skill 2.0.1518 → 2.0.1520

package/AGENTS.md

@@ -34,6 +34,8 @@ The plugkit stack runs as a wasm cdylib loaded by `plugkit-wasm-wrapper.js` unde
 
 **Every single-instance / lock guard is atomic, never check-then-act.** A guard that does `existsSync` -> read -> decide -> `writeFileSync` is TOCTOU: under a concurrent burst (the bootstrap spawns several supervisors in the same millisecond per skill-load) every caller passes the check before any writes, so all proceed and the duplicate it was meant to prevent happens anyway. The supervisor single-instance guard, the `.watcher.lock`, and any future pid/lock file all acquire via an atomic primitive — `fs.openSync(path, 'wx')` (O_EXCL exclusive-create, succeeds for exactly one racer) or atomic-rename — then on `EEXIST` read the holder and refuse-if-alive / take-over-if-stale. The trap: a check-then-write guard passes sequential testing (a later boot sees the prior holder) and silently fails only under concurrency, so when a guard is in place and the duplicate STILL occurs, suspect non-atomicity before suspecting absence. Full incident (three mis-diagnoses) in rs-learn (`recall: supervisor churn TOCTOU atomic guard`).
 
+**Count plugkit processes by executable Name, never by command-line substring.** A `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*plugkit-wasm-wrapper*' }` (or `-match 'plugkit-supervisor'`) also matches the bash/powershell command running the query itself — its eval string contains those literals — so it fabricates phantom processes and inflates the count (it reported `8 watchers + 4 supervisors` when the truth was `4 watchers, 0 supervisors`). Always constrain to the real runtime: `Where-Object { ($_.Name -eq 'node.exe' -or $_.Name -eq 'bun.exe') -and $_.CommandLine -match 'plugkit-wasm-wrapper\.js' }`. The phantom count made a working atomic-guard fix look unconverged across two fires; a wrong measurement is as costly as a wrong diagnosis. Full incident in rs-learn (`recall: supervisor churn TOCTOU atomic guard`).
+
 ## Spool dispatch ABI
 
 Agents dispatch verbs by writing to `.gm/exec-spool/in/<verb>/<N>.txt` (request body) and reading the response from `.gm/exec-spool/out/<verb>-<N>.json` (nested verbs) or `.gm/exec-spool/out/<N>.json` (root verbs). The wasm orchestrator services every possible verb; the harness never executes side effects directly.

package/gm-plugkit/bootstrap.js

@@ -665,6 +665,20 @@ function ensureWrapperFresh() {
   } catch (_) { return false; }
 }
 
+function ensureGmPlugkitVersionFresh() {
+  try {
+    const ownPkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf-8'));
+    if (!ownPkg || !ownPkg.version) return false;
+    const dst = path.join(gmToolsDir(), 'gm-plugkit.version');
+    let cur = null;
+    try { cur = fs.readFileSync(dst, 'utf-8').trim(); } catch (_) {}
+    if (cur === ownPkg.version) return false;
+    fs.mkdirSync(gmToolsDir(), { recursive: true });
+    fs.writeFileSync(dst, ownPkg.version);
+    return true;
+  } catch (_) { return false; }
+}
+
 function ensureSkillMdFresh() {
   try {
     const candidates = [
@@ -820,8 +834,9 @@ async function ensureReady(opts) {
   if (isReady() && !versionDrift) {
     const wasmPath = getWasmPath();
     const wrapperUpdated = ensureWrapperFresh();
+    const versionMarkerUpdated = ensureGmPlugkitVersionFresh();
     ensureSkillMdFresh();
-    return { ok: true, wasmPath, binaryPath: wasmPath, status: wrapperUpdated ? 'wrapper-refreshed' : 'already-ready', version: installed };
+    return { ok: true, wasmPath, binaryPath: wasmPath, status: (wrapperUpdated || versionMarkerUpdated) ? 'wrapper-refreshed' : 'already-ready', version: installed };
   }
   if (versionDrift) {
     try { killRunningDaemons(`version_drift:${installed}->${targetVersion}`); } catch (_) {}

package/gm-plugkit/child-script-alias.test.js

@@ -0,0 +1,25 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const wrapper = fs.readFileSync(path.join(__dirname, 'plugkit-wasm-wrapper.js'), 'utf-8');
+
+const aliasInChildScript = /\bspawnSync\s*\(\s*process\.execPath\s*,\s*\[\s*['"]-e['"]\s*,\s*`[^`]*\b_(?:net|http|https|crypto|childProcess)Module\b[^`]*`/;
+
+(function noParentAliasInChildEvalTemplates() {
+  assert.strictEqual(
+    aliasInChildScript.test(wrapper),
+    false,
+    'no spawnSync(process.execPath, ["-e", `...`]) child-script template may reference a parent-scope _*Module alias; the spawned child has no such binding (use require() inside the template). This regression broke findFreePortSync/isPort*/fetchJsonSync and surfaced only as "could not allocate free port" at browser-spawn time.'
+  );
+})();
+
+(function childTemplatesUseRequire() {
+  const childEvalBlocks = wrapper.match(/spawnSync\s*\(\s*process\.execPath\s*,\s*\[\s*['"]-e['"]\s*,\s*`[^`]*`/g) || [];
+  for (const block of childEvalBlocks) {
+    if (/\brequire\s*\(\s*['"](?:net|http|https)['"]\s*\)/.test(block) || !/\b(?:net|http|https)\b/.test(block)) continue;
+    assert.fail(`child -e template uses a node builtin without require(): ${block.slice(0, 80)}...`);
+  }
+})();
+
+console.log('child-script-alias.test.js: all assertions passed');

package/gm-plugkit/package.json

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

@@ -807,6 +807,49 @@ function cleanDeadProfileFragments(cwd) {
   }
 }
 
+function parsePlaywriterSessionList(stdout) {
+  const rows = [];
+  if (!stdout) return rows;
+  const lines = stdout.split(/\r?\n/);
+  for (const line of lines) {
+    const m = line.match(/^\s*(\d+)\s+\S+\s+\S+\s+\S+\s+(\S+)/);
+    if (!m) continue;
+    const id = m[1];
+    let cwd = m[2];
+    if (cwd === '-') cwd = '';
+    rows.push({ id, cwd });
+  }
+  return rows;
+}
+
+function reapOrphanBrowserSessions(pw, cwd, claudeSessionId, reason) {
+  try {
+    const ports = readJsonFile(browserPortsFile(cwd), {});
+    const activeIds = new Set();
+    for (const ent of Object.values(ports)) {
+      if (ent && ent.pwSessionId) activeIds.add(String(ent.pwSessionId));
+    }
+    const r = runBrowserRunner(pw, ['session', 'list'], 15000, cwd, claudeSessionId);
+    if (!r || r.status !== 0) return { reaped: 0 };
+    const rows = parsePlaywriterSessionList(r.stdout || '');
+    const norm = (p) => String(p || '').replace(/[\\/]+$/, '').toLowerCase();
+    const wantCwd = norm(cwd);
+    let reaped = 0;
+    for (const { id, cwd: rowCwd } of rows) {
+      if (rowCwd && norm(rowCwd) !== wantCwd) continue;
+      if (activeIds.has(String(id))) continue;
+      const d = runBrowserRunner(pw, ['session', 'delete', id], 15000, cwd, claudeSessionId);
+      if (d && d.status === 0) {
+        reaped++;
+        try { logEvent('plugkit', 'browser.orphan-session-reaped', { session_id: id, reason: reason || 'boot', cwd }); } catch (_) {}
+      }
+    }
+    return { reaped };
+  } catch (_) {
+    return { reaped: 0 };
+  }
+}
+
 function resolveWindowsExeLocal(cmd) {
   if (process.platform !== 'win32') return cmd;
   try {
@@ -828,7 +871,7 @@ function resolveWindowsExeLocal(cmd) {
 
 function isPortReachableSync(host, port, timeoutMs) {
   const r = spawnSync(process.execPath, ['-e', `
-    const net = _netModule;
+    const net = require('net');
     const s = net.connect({ port: ${port}, host: ${JSON.stringify(host)} });
     let done = false;
     s.on('connect', () => { done = true; s.destroy(); process.exit(0); });
@@ -840,7 +883,7 @@ function isPortReachableSync(host, port, timeoutMs) {
 
 function findFreePortSync() {
   const r = spawnSync(process.execPath, ['-e', `
-    const net = _netModule;
+    const net = require('net');
     const srv = net.createServer();
     srv.listen(0, '127.0.0.1', () => { const p = srv.address().port; srv.close(() => { process.stdout.write(String(p)); }); });
     srv.on('error', e => { process.stderr.write(e.message); process.exit(1); });
@@ -851,7 +894,7 @@ function findFreePortSync() {
 
 function isPortAliveSync(port) {
   const r = spawnSync(process.execPath, ['-e', `
-    const net = _netModule;
+    const net = require('net');
     const s = net.connect({ port: ${port}, host: '127.0.0.1' });
     s.on('connect', () => { s.destroy(); process.exit(0); });
     s.on('error', () => process.exit(1));
@@ -949,7 +992,7 @@ function findInstalledChromiumBinary() {
 
 function fetchJsonSync(url, timeoutMs) {
   const r = spawnSync(process.execPath, ['-e', `
-    const http = _httpModule;
+    const http = require('http');
     const req = http.get(${JSON.stringify(url)}, (res) => {
       let buf = '';
       res.on('data', d => buf += d);
@@ -1057,7 +1100,7 @@ function gracefulCloseBrowser(entry, reason) {
       const info = fetchJsonSync(`http://127.0.0.1:${port}/json/version`, 600);
       if (info && info.webSocketDebuggerUrl) {
         spawnSync(process.execPath, ['-e', `
-          const http = _httpModule;
+          const http = require('http');
           const req = http.request({host:'127.0.0.1',port:${port},path:'/json/close/browser',method:'GET',timeout:1500},
             res => { res.resume(); res.on('end', () => process.exit(0)); });
           req.on('error', () => process.exit(1));
@@ -1137,6 +1180,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     }
   }
   cleanDeadProfileFragments(cwd);
+  reapOrphanBrowserSessions(pw, cwd, claudeSessionId, 'pre-spawn');
   const profileDir = acquireProfileDir(cwd, claudeSessionId);
   const aliveCdpForProfile = (() => {
     for (const key of Object.keys(ports)) {
@@ -2085,6 +2129,8 @@ async function runSpoolWatcher(instance, spoolDir) {
     fs.writeFileSync(path.join(gmDir, 'long-gap-retry-state'), '');
   } catch (_) {}
 
+  try { reapOrphanBrowserSessions(findBrowserRunner(), process.cwd(), process.env.CLAUDE_SESSION_ID || 'claude-loop-iter', 'watcher-boot'); } catch (_) {}
+
 
   const LOCK_PATH = path.join(spoolDir, '.watcher.lock');
   try {
@@ -2369,8 +2415,33 @@ async function runSpoolWatcher(instance, spoolDir) {
             }
             const latest = JSON.parse(body).version;
             const stalePath = path.join(spoolDir, '.gm-plugkit-stale.json');
+            const respawnGuardPath = path.join(spoolDir, '.gm-plugkit-respawn-guard.json');
             if (!latest || latest === own) {
               if (fs.existsSync(stalePath)) { try { fs.unlinkSync(stalePath); } catch (_) {} }
+              if (fs.existsSync(respawnGuardPath)) { try { fs.unlinkSync(respawnGuardPath); } catch (_) {} }
+              return;
+            }
+            let respawnGuard = { attempts: 0, last_own: null, last_latest: null, first_ts: Date.now() };
+            try {
+              if (fs.existsSync(respawnGuardPath)) respawnGuard = JSON.parse(fs.readFileSync(respawnGuardPath, 'utf8'));
+            } catch (_) {}
+            const sameStaleAsBefore = respawnGuard.last_own === own && respawnGuard.last_latest === latest;
+            const cameFromSelfRespawn = process.env.PLUGKIT_BOOT_REASON === 'self-respawn-from-self-stale';
+            if (sameStaleAsBefore && respawnGuard.attempts >= 3) {
+              try { fs.writeFileSync(stalePath, JSON.stringify({
+                ts: new Date().toISOString(),
+                reason: 'gm-plugkit-self-stale-respawn-exhausted',
+                running_version: own,
+                latest_version: latest,
+                respawn_attempts: respawnGuard.attempts,
+                instruction: `gm-plugkit ${own} cannot self-upgrade to ${latest}: ${respawnGuard.attempts} respawns all came up ${own} (bun/npx cache is serving the stale tarball). Respawn loop halted to keep this watcher alive and serving verbs. Fix manually: bun pm cache rm; npm cache clean --force; rm -rf ~/AppData/Local/npm-cache/_npx ~/.bun/install/cache; then bun x gm-plugkit@latest --kill-stale-watchers; bun x gm-plugkit@latest spool`,
+                detected_by: 'watcher-periodic-probe',
+              }, null, 2)); } catch (_) {}
+              if (!_selfStaleLoggedOnce) {
+                _selfStaleLoggedOnce = true;
+                try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn-exhausted', { running_version: own, latest_version: latest, attempts: respawnGuard.attempts }); } catch (_) {}
+                console.error(`[plugkit-wasm] gm-plugkit self-stale respawn EXHAUSTED after ${respawnGuard.attempts} attempts (cache serving stale ${own} for latest ${latest}); halting respawn loop and staying alive to serve verbs`);
+              }
               return;
             }
             const marker = {
@@ -2389,6 +2460,25 @@ async function runSpoolWatcher(instance, spoolDir) {
               try {
                 const cp = _childProcess;
                 const bunPath = process.env.GM_BUN_PATH || 'bun';
+                const bustCache = sameStaleAsBefore || cameFromSelfRespawn;
+                if (bustCache) {
+                  try { cp.execFileSync(bunPath, ['pm', 'cache', 'rm'], { stdio: 'ignore', timeout: 30000, windowsHide: true }); } catch (_) {}
+                  try {
+                    const home = process.env.USERPROFILE || process.env.HOME || '';
+                    for (const rel of ['AppData/Local/npm-cache/_npx', '.npm/_npx', '.bun/install/cache']) {
+                      try { fs.rmSync(path.join(home, rel), { recursive: true, force: true }); } catch (_) {}
+                    }
+                  } catch (_) {}
+                  try { logEvent('plugkit', 'gm-plugkit.self-stale-cache-busted', { running_version: own, latest_version: latest, attempt: (respawnGuard.attempts || 0) + 1 }); } catch (_) {}
+                }
+                try { fs.writeFileSync(respawnGuardPath, JSON.stringify({
+                  attempts: (sameStaleAsBefore ? (respawnGuard.attempts || 0) : 0) + 1,
+                  last_own: own,
+                  last_latest: latest,
+                  first_ts: respawnGuard.first_ts || Date.now(),
+                  last_ts: Date.now(),
+                  cache_busted: bustCache,
+                }, null, 2)); } catch (_) {}
                 const child = cp.spawn(bunPath, ['x', `gm-plugkit@${latest}`, 'spool'], {
                   cwd: process.cwd(),
                   detached: true,
@@ -2397,7 +2487,7 @@ async function runSpoolWatcher(instance, spoolDir) {
                   env: { ...process.env, PLUGKIT_BOOT_REASON: 'self-respawn-from-self-stale' },
                 });
                 child.unref();
-                try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn', { running_version: own, latest_version: latest }); } catch (_) {}
+                try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn', { running_version: own, latest_version: latest, cache_busted: bustCache, attempt: (respawnGuard.attempts || 0) + 1 }); } catch (_) {}
                 try { fs.writeFileSync(path.join(spoolDir, '.shutdown-reason.json'), JSON.stringify({ reason: 'gm-plugkit-self-stale', ts: Date.now(), pid: process.pid, running_version: own, latest_version: latest })); } catch (_) {}
                 // Wait for the replacement's fresh heartbeat before exiting (mirror the
                 // version-drift path) instead of a blind 2s exit: the gm-plugkit download can
@@ -2406,13 +2496,17 @@ async function runSpoolWatcher(instance, spoolDir) {
                 const myPid = process.pid;
                 const respawnDeadline = Date.now() + 90000;
                 const exitSelfStale = () => { try { process.exit(0); } catch (_) {} };
+                const ownVersionFile = path.join(GM_TOOLS_ROOT, 'gm-plugkit.version');
                 const pollSelfStaleReplacement = () => {
                   try {
                     const st = JSON.parse(fs.readFileSync(STATUS_PATH_FOR_TEARDOWN, 'utf8'));
                     const freshHeartbeat = st && st.ts && (Date.now() - st.ts) < 15000;
                     const differentProc = st && st.pid && st.pid !== myPid;
-                    if (freshHeartbeat && differentProc) {
-                      try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn-confirmed', { old_pid: myPid, new_pid: st.pid, new_version: st.version, latest_version: latest }); } catch (_) {}
+                    let replacementOnLatest = false;
+                    try { replacementOnLatest = fs.readFileSync(ownVersionFile, 'utf-8').trim() === latest; } catch (_) {}
+                    if (freshHeartbeat && differentProc && replacementOnLatest) {
+                      try { fs.unlinkSync(respawnGuardPath); } catch (_) {}
+                      try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn-confirmed', { old_pid: myPid, new_pid: st.pid, new_version: st.version, latest_version: latest, replacement_gm_plugkit: latest }); } catch (_) {}
                       return exitSelfStale();
                     }
                   } catch (_) {}
@@ -2674,6 +2768,7 @@ async function runSpoolWatcher(instance, spoolDir) {
         try { writeJsonFile(portsFile, ports); } catch (_) {}
         try { writeJsonFile(sessionsFile, sessions); } catch (_) {}
       }
+      try { reapOrphanBrowserSessions(findBrowserRunner(), process.cwd(), process.env.CLAUDE_SESSION_ID || 'claude-loop-iter', 'idle-sweep'); } catch (_) {}
     } catch (e) {
       console.error(`[browser-idle] error: ${e.message}`);
     }

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1518",
+  "version": "2.0.1520",
   "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.1518",
+  "version": "2.0.1520",
   "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",