gm-skill 2.0.1781 → 2.0.1794

package/bin/bootstrap.js

@@ -606,6 +606,29 @@ function writeDaemonVersion(v) {
   try { fs.writeFileSync(daemonVersionSentinel(), String(v)); } catch (_) {}
 }
 
+function pidCommandLineForKillGuard(pid) {
+  try {
+    const { spawnSync } = require('child_process');
+    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 });
+      return String((r && r.stdout) || '');
+    }
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 });
+    return String((r && r.stdout) || '');
+  } catch (_) { return ''; }
+}
+
+function pidIsPlugkitProcess(pid) {
+  return /plugkit-wasm-wrapper\.js|plugkit-supervisor\.js|gm-plugkit[\\\/]supervisor\.js/i.test(pidCommandLineForKillGuard(pid));
+}
+
+function writeKillAttribution(targetSpoolDir, info) {
+  try {
+    fs.mkdirSync(targetSpoolDir, { recursive: true });
+    fs.writeFileSync(path.join(targetSpoolDir, '.kill-attribution.json'), JSON.stringify({ killer_pid: process.pid, killer_cwd: process.cwd(), killer_script: __filename, ts: Date.now(), ...info }, null, 2));
+  } catch (_) {}
+}
+
 function killPid(pid) {
   if (!Number.isFinite(pid) || pid === process.pid || !pidAlive(pid)) return false;
   try { process.kill(pid, 'SIGTERM'); }
@@ -624,6 +647,12 @@ function killSpoolWatcherInCwd(reason) {
     const pidPath = path.join(process.cwd(), '.gm', 'exec-spool', '.watcher.pid');
     if (!fs.existsSync(pidPath)) return null;
     const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+    if (pidAlive(pid) && !pidIsPlugkitProcess(pid)) {
+      obsEvent('bootstrap', 'watcher.kill-skipped-pid-reused', { pid, reason });
+      try { fs.unlinkSync(pidPath); } catch (_) {}
+      return null;
+    }
+    writeKillAttribution(path.join(process.cwd(), '.gm', 'exec-spool'), { reason, target_pid: pid, via: 'killSpoolWatcherInCwd' });
     if (killPid(pid)) {
       obsEvent('bootstrap', 'watcher.killed', { pid, reason });
       try { fs.unlinkSync(pidPath); } catch (_) {}

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.808
+0.1.819

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-14ca32983cb5e377ec053e0aad070fc1b469d79b8cf21dfb19ab5e9815ffe8a9  plugkit.wasm
+6a4cd71644fb10f35340c1bf17091eb671cef43246b98a36352935aafed0a41c  plugkit.wasm

package/gm-plugkit/bootstrap.js

@@ -450,6 +450,28 @@ function writeDaemonVersion(v) {
   try { fs.writeFileSync(daemonVersionSentinel(), String(v)); } catch (_) {}
 }
 
+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 });
+      return String((r && r.stdout) || '');
+    }
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 });
+    return String((r && r.stdout) || '');
+  } catch (_) { return ''; }
+}
+
+function pidIsPlugkitProcess(pid) {
+  return /plugkit-wasm-wrapper\.js|plugkit-supervisor\.js|gm-plugkit[\\\/]supervisor\.js/i.test(pidCommandLineForKillGuard(pid));
+}
+
+function writeKillAttribution(targetSpoolDir, info) {
+  try {
+    fs.mkdirSync(targetSpoolDir, { recursive: true });
+    fs.writeFileSync(path.join(targetSpoolDir, '.kill-attribution.json'), JSON.stringify({ killer_pid: process.pid, killer_cwd: process.cwd(), killer_script: __filename, ts: Date.now(), ...info }, null, 2));
+  } catch (_) {}
+}
+
 function killPid(pid) {
   if (!Number.isFinite(pid) || pid === process.pid || !pidAlive(pid)) return false;
   try { process.kill(pid, 'SIGTERM'); }
@@ -465,6 +487,12 @@ function killSpoolWatcherInCwd(reason) {
     const pidPath = path.join(process.cwd(), '.gm', 'exec-spool', '.watcher.pid');
     if (!fs.existsSync(pidPath)) return null;
     const pid = parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+    if (pidAlive(pid) && !pidIsPlugkitProcess(pid)) {
+      obsEvent('bootstrap', 'watcher.kill-skipped-pid-reused', { pid, reason });
+      try { fs.unlinkSync(pidPath); } catch (_) {}
+      return null;
+    }
+    writeKillAttribution(path.join(process.cwd(), '.gm', 'exec-spool'), { reason, target_pid: pid, via: 'killSpoolWatcherInCwd' });
     if (killPid(pid)) {
       obsEvent('bootstrap', 'watcher.killed', { pid, reason });
       try { fs.unlinkSync(pidPath); } catch (_) {}

package/gm-plugkit/package.json

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

@@ -74,6 +74,28 @@ function emitShutdownReason(reason, err) {
   } catch (_) {}
 }
 
+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 });
+      return String((r && r.stdout) || '');
+    }
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 });
+    return String((r && r.stdout) || '');
+  } catch (_) { return ''; }
+}
+
+function pidIsPlugkitProcess(pid) {
+  return /plugkit-wasm-wrapper\.js|plugkit-supervisor\.js|gm-plugkit[\\\/]supervisor\.js/i.test(pidCommandLineForKillGuard(pid));
+}
+
+function writeKillAttribution(targetSpoolDir, info) {
+  try {
+    fs.mkdirSync(targetSpoolDir, { recursive: true });
+    fs.writeFileSync(path.join(targetSpoolDir, '.kill-attribution.json'), JSON.stringify({ killer_pid: process.pid, killer_cwd: process.cwd(), killer_script: 'plugkit-wasm-wrapper', ts: Date.now(), ...info }, null, 2));
+  } catch (_) {}
+}
+
 function writeVerbActive(verb, task) {
   __currentVerbContext = { verb, task, started_at_ms: Date.now(), pid: process.pid };
   try {
@@ -1558,7 +1580,8 @@ function cosineSim(a, b) {
 }
 
 let __wasmAbortFlag = { aborted: false, code: 0 };
-const WASI_FILESYSTEM_ROOT = path.join(GM_TOOLS_ROOT, 'wasi-fs');
+const WASI_PROJECT_SLUG = crypto.createHash('sha256').update(String(process.env.CLAUDE_PROJECT_DIR || process.cwd()).toLowerCase().replace(/\\/g, '/')).digest('hex').slice(0, 16);
+const WASI_FILESYSTEM_ROOT = path.join(GM_TOOLS_ROOT, 'wasi-fs', WASI_PROJECT_SLUG);
 const wasiOpenFiles = new Map();
 let wasiNextFd = 100;
 
@@ -2256,6 +2279,19 @@ function makeHostFunctions(instanceRef) {
       }
     },
 
+    host_fs_remove: (pathPtr, pathLen) => {
+      try {
+        const filePath = readWasmStr(instanceRef.value, pathPtr, pathLen);
+        if (!filePath) return 0;
+        const st = fs.statSync(filePath);
+        if (st.isDirectory()) return 0;
+        fs.unlinkSync(filePath);
+        return 1;
+      } catch (e) {
+        return 0;
+      }
+    },
+
     host_fs_readdir: (pathPtr, pathLen) => {
       try {
         const dirPath = readWasmStr(instanceRef.value, pathPtr, pathLen);
@@ -3038,7 +3074,12 @@ async function runSpoolWatcher(instance, spoolDir) {
                 holder_sha: holderSha,
               }));
             } catch (_) {}
-            try { process.kill(parseInt(pidStr, 10), 'SIGTERM'); } catch (_) {}
+            if (pidIsPlugkitProcess(holderPidNum)) {
+              writeKillAttribution(spoolDir, { reason: 'peer-stale-takeover', target_pid: holderPidNum, via: 'lock-takeover', holder_sha: holderSha });
+              try { process.kill(holderPidNum, 'SIGTERM'); } catch (_) {}
+            } else {
+              try { logEvent('plugkit', 'takeover-kill-skipped-pid-reused', { holder_pid: pidStr }); } catch (_) {}
+            }
             return 'takeover';
           } else {
             const msg = JSON.stringify({ ok: false, reason: 'another-watcher-active', pid: pidStr, age_ms: age });
@@ -3249,6 +3290,11 @@ async function runSpoolWatcher(instance, spoolDir) {
       try {
         process.kill(peerPid, 0);
       } catch (_) { continue; }
+      if (!pidIsPlugkitProcess(peerPid)) {
+        logEvent('plugkit', 'peer.kill-skipped-pid-reused', { peer_cwd: peerCwd, peer_pid: peerPid });
+        continue;
+      }
+      writeKillAttribution(path.join(peerCwd, '.gm', 'exec-spool'), { reason: 'peer-stale-takeover', target_pid: peerPid, via: 'peer-sweep', peer_sha: peerSha, own_sha: _ownWrapperSha12 });
       logEvent('plugkit', 'peer.stale-wrapper-killed', { peer_cwd: peerCwd, peer_pid: peerPid, peer_sha: peerSha, own_sha: _ownWrapperSha12, lock_age_ms: age });
       console.error(`[plugkit-wasm] peer-sweep killing stale-wrapper watcher pid=${peerPid} cwd=${peerCwd} sha=${peerSha} (own=${_ownWrapperSha12})`);
       try {

package/gm-plugkit/plugkit.version

@@ -1 +1 @@
-0.1.808
+0.1.819

package/gm-plugkit/supervisor.js

@@ -64,6 +64,28 @@ function writeSupervisorStatus(state, extra) {
   } catch (_) {}
 }
 
+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 });
+      return String((r && r.stdout) || '');
+    }
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 });
+    return String((r && r.stdout) || '');
+  } catch (_) { return ''; }
+}
+
+function pidIsPlugkitProcess(pid) {
+  return /plugkit-wasm-wrapper\.js|plugkit-supervisor\.js|gm-plugkit[\\\/]supervisor\.js/i.test(pidCommandLineForKillGuard(pid));
+}
+
+function writeKillAttribution(targetSpoolDir, info) {
+  try {
+    fs.mkdirSync(targetSpoolDir, { recursive: true });
+    fs.writeFileSync(path.join(targetSpoolDir, '.kill-attribution.json'), JSON.stringify({ killer_pid: process.pid, killer_cwd: process.cwd(), killer_script: __filename, ts: Date.now(), ...info }, null, 2));
+  } catch (_) {}
+}
+
 function pidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; } catch (_) { return false; }
@@ -100,9 +122,14 @@ function acquireSingleInstance() {
             spool_status_age_ms: now - spoolTs,
             severity: 'critical',
           });
-          try { process.kill(other, 'SIGTERM'); } catch (_) {}
-          if (process.platform === 'win32') {
-            try { spawnSync('taskkill', ['/F', '/T', '/PID', String(other)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
+          if (pidIsPlugkitProcess(other)) {
+            writeKillAttribution(spoolDir, { reason: 'supervisor-takeover-wedged', target_pid: other, via: 'supervisor-duel' });
+            try { process.kill(other, 'SIGTERM'); } catch (_) {}
+            if (process.platform === 'win32') {
+              try { spawnSync('taskkill', ['/F', '/T', '/PID', String(other)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
+            }
+          } else {
+            logEvent('supervisor.takeover-kill-skipped-pid-reused', { existing_pid: other, severity: 'warn' });
           }
         }
         try { fs.unlinkSync(SUPERVISOR_PID_PATH); } catch (_) {}

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1781",
+  "version": "2.0.1794",
   "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.808"
+  "plugkitVersion": "0.1.819"
 }

package/lib/skill-bootstrap.js

@@ -406,6 +406,26 @@ function isProcessRunning() {
   return findPlugkitWasmPids().length > 0;
 }
 
+function pidCommandLineForKillGuard(pid) {
+  try {
+    if (process.platform === 'win32') {
+      return execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', `(Get-CimInstance Win32_Process -Filter "ProcessId=${Number(pid)}").CommandLine`], { encoding: 'utf8', windowsHide: true, timeout: 5000 }) || '';
+    }
+    return execFileSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 5000 }) || '';
+  } catch (_) { return ''; }
+}
+
+function pidIsPlugkitProcess(pid) {
+  return /plugkit-wasm-wrapper\.js|plugkit-supervisor\.js|gm-plugkit[\\\/]supervisor\.js/i.test(pidCommandLineForKillGuard(pid));
+}
+
+function writeKillAttribution(targetSpoolDir, info) {
+  try {
+    fs.mkdirSync(targetSpoolDir, { recursive: true });
+    fs.writeFileSync(path.join(targetSpoolDir, '.kill-attribution.json'), JSON.stringify({ killer_pid: process.pid, killer_cwd: process.cwd(), killer_script: __filename, ts: Date.now(), ...info }, null, 2));
+  } catch (_) {}
+}
+
 function killExistingPlugkit() {
   try {
     const pids = findPlugkitWasmPids();
@@ -413,17 +433,24 @@ function killExistingPlugkit() {
       emitBootstrapEvent('info', 'No existing plugkit WASM watcher to kill');
       return;
     }
+    const killed = [];
     for (const pid of pids) {
+      if (!pidIsPlugkitProcess(pid)) {
+        emitBootstrapEvent('warn', 'Kill skipped: pid is not a plugkit process (stale or reused pid)', { pid });
+        continue;
+      }
+      writeKillAttribution(path.join(process.cwd(), '.gm', 'exec-spool'), { reason: 'bootstrap-refresh', target_pid: Number(pid), via: 'killExistingPlugkit' });
       try {
         if (process.platform === 'win32') {
           execFileSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore', windowsHide: true });
         } else {
           execFileSync('kill', ['-9', String(pid)], { stdio: 'ignore' });
         }
+        killed.push(pid);
       } catch (e) {
       }
     }
-    emitBootstrapEvent('info', 'Killed existing plugkit WASM watcher', { pids });
+    emitBootstrapEvent('info', 'Killed existing plugkit WASM watcher', { pids: killed });
   } catch (e) {
     emitBootstrapEvent('warn', 'Failed to kill existing plugkit', { error: e.message });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1781",
+  "version": "2.0.1794",
   "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",