gm-skill 2.0.1779 → 2.0.1793

package/AGENTS.md

@@ -66,9 +66,7 @@ Record only non-obvious multi-run-cost caveats; prune stale; never document the
 
 **No graphical symbols; convert to industry-standard text on sight.** Any non-ASCII decorative glyph (arrows, box/geometric glyphs, stars, dots, bullets, checks/crosses, emojis) is forbidden in all output and source -- convert it to its plain-ASCII equivalent the same turn (the word, `->`, `-`/`*`, `[x]`/`[ ]`, done/todo/pass/fail). Tell-tale-AI class: one sighting spawns the full-codebase sweep, never a one-off edit. Exempt: functional code operators (`=>`, `??`, `?.`, comparison/math), frozen changelog/git-log entries, binary stores, intentional icon-font/CSS-content product glyphs, and canonical CS/formal-logic notation in `.gm/constraints.md` / `gm-plugkit/constraints-default.md` (`.`, `->` as function-space, `|-`, set/quantifier symbols) -- these are semantic operators in a formal constraints spec, not decorative flourish. `ccsniff --glyph-discipline` flags decorative glyphs post-hoc (run each audit, like `--git-discipline`/`--search-discipline`).
 
-**Skill SKILL.md files:** strip explanatory prose; keep ONLY invocation syntax, transition markers (`->`), gate conditions, constraint lists, exact-usage code examples.
-
-**Implicit, not explicit, in skill prose.** Skill files (and prompt-submit.txt) elicit, never describe: terse imperatives triggering already-learned dispositions, not numbered procedures. Describes = agent could re-derive from the goal (recipe, do-X-then-Y, trigger-instance list, over-explained rationale, restated mechanism) -- convert. Elicits = constructs a predicament where the wrong move is structurally incoherent -- keep. Exception: boot-edge ABI (exact spool paths, JSON fields, verb names, globs, deviation ids, gate names) is non-derivable, stays explicit regardless. Forbidden: step-by-step recipes, "see paper section X", site/paper citations, multi-step manuals -- manual-shaped skill gets imitated as script, breaks at first edge case. Papers/site are discipline OUTPUTS, never link from a skill into docs. Cross-cutting rules needing citation belong here, not in skills.
+**Implicit, not explicit, in skill prose**: skill files elicit, never describe -- terse imperatives, no recipes/citations/manuals; boot-edge ABI (spool paths, JSON fields, verb names, deviation ids, gate names) stays explicit; SKILL.md keeps only invocation syntax, transition markers, gate conditions, constraints, exact-usage examples. Full criteria: rs-learn (`recall: implicit-not-explicit skill prose criteria`).
 
 ## Build
 
@@ -92,9 +90,9 @@ Every skill's `allowed-tools:` reduced to `Skill, Read, Write` (plus SKILL.md bo
 
 ## Core Rules
 
-**Shared memory & search index are tracked, never ignored**: `.gm/rs-learn.db`, `.gm/code-search/` committed -- state shares cross-machine/session/CI. Never gitignore `.gm/`, `.gm/rs-learn.db`, `.gm/code-search/`, legacy `.code-search/`; transient `.gm/*` entries listed one-by-one between managed markers (parent-re-include caveat). Entry list + `ensureGitignored` mechanics: rs-learn (`recall: gm managed-gitignore mechanics`). Project-local persistent state -> `.gm/<name>/`, never top-level dotfile/dotdir.
+**Memory is human-readable md, tracked; derived stores are transient, never tracked**: canonical memory = `.gm/memories/<key>.md` (project facts) + `.gm/disciplines/<name>/memories/<key>.md` (transferable discipline knowledge), frontmatter `key/ns/created/updated`, UTF-8 no BOM, LF -- text shares cross-machine/session/CI as reviewable diffs. Legacy flat-JSON KV (`.gm/disciplines/<ns>/*.json`) remains the live recall read path until rs-plugkit's md read-path cutover lands; it stays tracked until then, then retires. Derived state (embeddings/`*-vec`, codeinsight manifests/digests, local sqlite/index dbs) is rebuildable-from-corpus, listed one-by-one between managed gitignore markers (parent-re-include caveat). Entry list + `ensureGitignored` mechanics: rs-learn (`recall: gm managed-gitignore mechanics`). Project-local persistent state -> `.gm/<name>/`, never top-level dotfile/dotdir.
 
-**Disciplines are isolated knowledge stores**: per-project `<project>/.gm/disciplines/<name>/{rs-learn.db, code-search/}`, own DB+index each. `@<name>` sigil = strict isolation (cross-discipline reads forbidden). Sigil-less reads (recall/codesearch) fan across `default` + every `enabled.txt` line, merge-ranked `[discipline:<name>]`-prefixed; sigil-less writes -> `default` only. Tracked, never ignored (`ensureGitignored` excludes `.gm/disciplines`). Harness + every spool verb propagate `@<name>` verbatim.
+**Disciplines are isolated knowledge stores**: per-project `<project>/.gm/disciplines/<name>/{memories/, code-search/}`, own corpus+index each; memorize-time routing auto-creates a not-previously-known discipline's store rather than mixing it into project memories. `@<name>` sigil = strict isolation (cross-discipline reads forbidden). Sigil-less reads (recall/codesearch) fan across `default` + every `enabled.txt` line, merge-ranked `[discipline:<name>]`-prefixed; sigil-less writes -> project store only. Tracked, never ignored (`ensureGitignored` excludes `.gm/disciplines`); derived per-discipline caches follow the transient rule above. Harness + every spool verb propagate `@<name>` verbatim.
 
 **Nothing fake in source the user runs**: stub/mock/placeholder-return/fixture-only-path/demo-mode-short-circuit/"TODO: implement" forbidden in shipped code. Scaffolds/shims permitted only delegating to real behavior (upstream API, subprocess, disk); check for an existing library before adding a shim. Detection = behavioral: always-succeeds, input-invariant, or type-signature-satisfying short-circuit = stub. Acceptance = real input through real code into real output, witnessed.
 

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.807
+0.1.818

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-fef755b5d1f6d510182fa9ee0130a643dd054f95d62c70c62ef01813dd110b7e  plugkit.wasm
+5cfcad879b84f2443f28e5ce9182d725bc6ebfeae1bf2c84a5b21d5a84a55a1e  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.1779",
+  "version": "2.0.1793",
   "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.807
+0.1.818

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.1779",
+  "version": "2.0.1793",
   "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.807"
+  "plugkitVersion": "0.1.818"
 }

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.1779",
+  "version": "2.0.1793",
   "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",