gm-skill 2.0.1840 → 2.0.1842

package/gm-plugkit/bootstrap.js

@@ -1122,6 +1122,7 @@ module.exports = {
   readVersionFile,
   ensureGmPlugkitVersionFresh,
   ensureSkillMdFresh,
+  ensureWrapperFresh,
 };
 
 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 } = require('./bootstrap');
+const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh, ensureWrapperFresh } = require('./bootstrap');
 
 function readUpdateAvailableMarker(dir) {
   try {
@@ -217,6 +217,8 @@ function writeCliError(phase, err) {
     try { ensureGmPlugkitVersionFresh(); } catch (_) {}
     let skillRefresh = null;
     try { skillRefresh = ensureSkillMdFresh(); } catch (_) {}
+    let wrapperRefreshed = false;
+    try { wrapperRefreshed = ensureWrapperFresh(); } catch (_) {}
     writeCliStatus({ phase: 'ready', already_serving: true, watcher_pid: already.pid });
     console.log(JSON.stringify({
       ok: true,
@@ -224,7 +226,10 @@ function writeCliError(phase, err) {
       watcher_pid: already.pid,
       version: already.version,
       skills_refreshed: skillRefresh && skillRefresh.refreshed || [],
-      message: 'plugkit already serving, no bootstrap/spawn needed',
+      wrapper_refreshed: wrapperRefreshed,
+      message: wrapperRefreshed
+        ? 'plugkit already serving; wrapper file on disk was stale and has been refreshed -- restart the watcher to load it'
+        : 'plugkit already serving, no bootstrap/spawn needed',
     }));
     process.exit(0);
   }

package/gm-plugkit/instructions/plan.md

@@ -18,6 +18,8 @@ PRD = `|F|=1` plan-item store: enumerate every node in the destructive transform
 
 **Inherited rows resume first.** `ready_wave`/`prd_pending>0` at entry = undone transform, not someone else's -- THIS cover's first slice. Resume to `prd-resolve` (witnessed) or explicit re-scope/close before any fresh row; disjoint fresh cover orphaning inherited rows = stopped mid-transform, not finished.
 
+**`prd-resolve` at PLAN is bound by the same false-completion rule as VERIFY, not exempt because the row was inherited.** A `prd-resolve` whose `witness_evidence` says "deferred"/"pending next session"/"pending browser fix"/"awaits [X] recovery"/"user must refresh" is marking undone work done -- forbidden regardless of phase. Real external blockers (browser environment down, credential missing, another team's repo) keep the row `status: pending` with `blockedBy: [external, "<specific reason>"]`; they are never grounds to resolve as `completed`. A session that repeatedly hits the same external blocker (e.g. browser verb crashing every attempt) `prd-add`s a row naming the blocker itself as the thing to fix -- diagnose and repair the tool (see BROWSER discipline), not paper over it with a completed status on the original row.
+
 "Every possible" load-bears: apply to every noun/surface/transform/output the request reaches, each application a row. Single-digit count on non-trivial request = stopped early -- re-orient, re-enumerate. Density, not minimality, is the COMPLETE-time invariant. Inline TODO in response body violates `|F|=1`.
 
 ## Expansion

package/gm-plugkit/package.json

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

@@ -1314,6 +1314,7 @@ function startManagedBrowser(pw, profileDir, cwd) {
     logEvent('plugkit', 'browser.launch-failed', { reason: 'chromium-missing' });
     throw err;
   }
+  try { reapOrphanChromiums(cwd, 'pre-spawn'); } catch (_) {}
   const port = findFreePortSync();
   let noSandbox = process.env.GM_BROWSER_NO_SANDBOX === '1';
   let { pid, chromeLogPath } = spawnChromiumOnce(browserBin, profileDir, port, headless, noSandbox, cwd);
@@ -1366,36 +1367,47 @@ function sleepSyncMs(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms | 0);
 }
 
+const __browserClosingPids = new Set();
+
 function gracefulCloseBrowser(entry, reason) {
   if (!entry) return;
   const { pid, port, profileDir } = entry;
-  if (Number.isFinite(port) && port > 0) {
-    try {
-      const info = fetchJsonSync(`http://127.0.0.1:${port}/json/version`, 600);
-      if (info && info.webSocketDebuggerUrl) {
-        spawnSync(process.execPath, ['-e', `
-          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));
-          req.on('timeout', () => { req.destroy(); process.exit(1); });
-          req.end();
-        `], { timeout: 3000, windowsHide: true });
-      }
-    } catch (_) {}
+  if (Number.isFinite(pid) && pid > 0 && __browserClosingPids.has(pid)) {
+    try { logEvent('plugkit', 'browser.close-skipped-already-closing', { pid, reason: reason || 'close' }); } catch (_) {}
+    return;
   }
-  if (Number.isFinite(pid) && pid > 0) {
-    if (isProcessAliveSync(pid) && !pidIsManagedChromium(pid)) {
-      try { logEvent('plugkit', 'browser.kill-skipped-pid-reused', { pid, reason: reason || 'close' }); } catch (_) {}
-    } else {
-      const deadline = Date.now() + 1500;
-      try { process.kill(pid, 'SIGTERM'); } catch (_) {}
-      while (Date.now() < deadline && isProcessAliveSync(pid)) sleepSyncMs(Math.min(150, deadline - Date.now()));
-      if (isProcessAliveSync(pid)) killPidQuiet(pid);
+  if (Number.isFinite(pid) && pid > 0) __browserClosingPids.add(pid);
+  try {
+    if (Number.isFinite(port) && port > 0) {
+      try {
+        const info = fetchJsonSync(`http://127.0.0.1:${port}/json/version`, 600);
+        if (info && info.webSocketDebuggerUrl) {
+          spawnSync(process.execPath, ['-e', `
+            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));
+            req.on('timeout', () => { req.destroy(); process.exit(1); });
+            req.end();
+          `], { timeout: 3000, windowsHide: true });
+        }
+      } catch (_) {}
+    }
+    if (Number.isFinite(pid) && pid > 0) {
+      if (isProcessAliveSync(pid) && !pidIsManagedChromium(pid)) {
+        try { logEvent('plugkit', 'browser.kill-skipped-pid-reused', { pid, reason: reason || 'close' }); } catch (_) {}
+      } else {
+        const deadline = Date.now() + 1500;
+        try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+        while (Date.now() < deadline && isProcessAliveSync(pid)) sleepSyncMs(Math.min(150, deadline - Date.now()));
+        if (isProcessAliveSync(pid)) killPidQuiet(pid);
+      }
     }
+    purgeProfileLockFiles(profileDir);
+    try { logEvent('plugkit', 'browser.closed', { reason: reason || 'closed', pid, port, profileDir }); } catch (_) {}
+  } finally {
+    if (Number.isFinite(pid) && pid > 0) __browserClosingPids.delete(pid);
   }
-  purgeProfileLockFiles(profileDir);
-  try { logEvent('plugkit', 'browser.closed', { reason: reason || 'closed', pid, port, profileDir }); } catch (_) {}
 }
 
 function checkSessionNavigatedAway(port, claudeSessionId) {

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1840",
+  "version": "2.0.1842",
   "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.1840",
+  "version": "2.0.1842",
   "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",

package/skills/gm/SKILL.md

@@ -70,6 +70,8 @@ Spool input from PowerShell must be UTF-8 no-BOM (`-Encoding utf8` or `[System.I
 
 **EXECUTE resolves all mutables before EMIT, discovers more, resolves those too, rearchitects immediately on in-spirit discovery.** Any architectural improvement discovered mid-EXECUTE is an immediate `transition to=PLAN`, re-`prd-add` the affected row with its existing id (re-scope, never delete-and-re-add) -- maximal-effort correctness over preservation-for-its-own-sake, no deferral, no "note for later."
 
+**`prd-resolve` is bound by the false-completion rule in every phase, PLAN included -- not only at VERIFY.** A row marked `status: completed` whose witness says "deferred", "pending next session", "pending browser fix", "awaits [X] recovery", "user must refresh", or any equivalent hedge is undone work labeled done -- forbidden, the same class as a mock standing in for real code. A genuinely external blocker (browser environment down, credential missing, another team's repo) keeps the row `status: pending` with `blockedBy: [external, "<specific reason>"]`; it is never grounds to resolve as completed. A blocker that recurs across sessions (the same tool crashing every attempt) becomes its own PRD row naming the tool defect to fix -- diagnose and repair it, never paper over the original row with a completed status while the real work stays undone.
+
 VERIFY is adversarial, never confirmatory: run the real code path and read its actual output via `exec_js` or `browser` -- a finding is only real once witnessed by execution this turn. Never assert a crash, pass, or defect from memory, prior session state, or written prose alone. A gate denial (e.g. `residual.skipped` on dirty worktree) is resolved immediately by the named recovery action (commit or revert the listed files, then re-dispatch the same verb) in the same turn -- it is never grounds to re-enter PLAN, add unrelated PRD rows, or narrate the blocker instead of clearing it.
 
 **Every residual is triaged this turn; "pre-existing" is not a stop excuse.** Non-empty `git status --porcelain`: every entry is yours now -- commit (real work), add to managed gitignore (transient runtime files), or revert (stale junk). PRD entries live in `.gm/prd.yml`. `.gm/disciplines/` and new memorize-fire JSON are tracked. `.gm/witness/` and staleness markers go in managed gitignore.