gm-skill 2.0.1440 → 2.0.1442

package/AGENTS.md

@@ -158,6 +158,8 @@ Orchestration state is tracked via marker files in `.gm/` instead of hook events
 
 **Dead-watcher recovery prefers `bun x gm-plugkit@latest spool`, not direct-node boot**: when the watcher is dead and you reboot, use `bun x gm-plugkit@latest spool` (the npm-fetch path) rather than `node ~/.gm-tools/plugkit-wasm-wrapper.js spool`. The direct-node form runs the installed wrapper as-is and skips `ensureWrapperInstalled`, so a just-published wrapper fix stays undeployed, the running watcher carries stale wrapper code even though npm has the fix. The `bun x` path sha-checks and refreshes the installed wrapper before booting. After any wrapper-level fix is published, verify deployment by grepping the installed `~/.gm-tools/plugkit-wasm-wrapper.js` for the new code, not just the npm version, npm-published is not the same as installed-and-running.
 
+**The first verb after any multi-minute wait is `instruction`, to reset the long-gap clock**: a version transition (kill + `bun x gm-plugkit@latest spool` downloads a ~149MB wasm, minutes of idle), a long CI watch, or any wait that exceeds the 300s `long_gap_threshold_ms` leaves the gap clock run out, so the very next non-`instruction` verb (`memorize-fire`, `learn`, `browser`, …) trips `deviation.long-gap-no-instruction` from `rs-plugkit/gates`. The gate is correct, the deviation is yours, and it is fully predictable: after waiting out a version transition or any multi-minute pause, dispatch `instruction` FIRST (it resets `last_instruction_ts`), then proceed. Recovering verb-by-verb after each gate denial works but emits a burst of deviations; pre-empting with one `instruction` dispatch emits zero.
+
 **A stop-hook firing on a terminal chain does not authorize re-polling**: when a stop-hook or unsatisfiable condition fires while the chain is already at `phase=COMPLETE` AND `prd_pending_count=0`, re-dispatching `instruction` or `phase-status` to "re-confirm" terminality is itself a deviation, it emits `deviation.complete-chain-poll` (`instructions/mod.rs`) and marks the agent as polling a closed chain. COMPLETE already authorizes the prose-only turn; the hook cannot be satisfied by more poll dispatches over elapsed work, and re-running already-committed work to manufacture skill-driven activity is the fabrication `Nothing Fake` forbids. Two admissible responses only: (a) a prose-only turn (the COMPLETE pronouncement is in hand), or (b) genuinely new planned work opened with a FRESH `{"prompt":...}` body, which resets phase to PLAN and is driven through the skill from inception. Repeatedly answering the same already-acknowledged hook is a loop; state the terminal facts once and stop, or open new work.
 
 **Session lifecycle**: Session-end kills background tasks via `killSessionTasks` RPC on real-exit reasons (clear/logout/prompt_input_exit). Every possible browser session and background task persists across turn-stops, cleanup happens exclusively on real-exit reasons. Residual-scan fires when PRD is empty/missing AND no open browser sessions AND no running tasks; agent either expands PRD with in-spirit residuals or explicitly states none.

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.581
+0.1.582

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-4046ba34646fa5639610b5ab9a6a9276531bea8b90a968d901c3f0b8cb417552  plugkit.wasm
+e2e1c3833f428925bd7c52f79dad706c9fe23ced05871f75532b273d00370a75  plugkit.wasm

package/gm-plugkit/bootstrap.js

@@ -879,13 +879,32 @@ function probeUnsupervisedWatcher(spoolDir) {
   } catch (_) {}
 }
 
+function resolveNodeRuntime() {
+  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
+  const candidates = [];
+  if (isNodeExe(process.env.GM_NODE_PATH)) candidates.push(process.env.GM_NODE_PATH);
+  if (isNodeExe(process.execPath)) candidates.push(process.execPath);
+  try {
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const out = require('child_process').spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+    if (out && out.stdout) {
+      const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+      if (first) candidates.push(first);
+    }
+  } catch (_) {}
+  for (const c of candidates) {
+    try { const r = require('child_process').spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+  }
+  return process.execPath;
+}
+
 function startSpoolDaemon() {
   try {
     const wrapper = path.join(gmToolsDir(), 'plugkit-wasm-wrapper.js');
     if (!fs.existsSync(wrapper)) {
       return { ok: false, error: `wrapper not at ${wrapper} — ensureReady() must run first` };
     }
-    const runtime = process.execPath;
+    const runtime = resolveNodeRuntime();
     const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
     const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
     fs.mkdirSync(spoolDir, { recursive: true });
@@ -919,7 +938,7 @@ function startSpoolDaemon() {
 
     const logFd = fs.openSync(logPath, 'a');
     try { fs.writeSync(logFd, `\n--- supervisor spawn ${new Date().toISOString()} parent=${process.pid} ---\n`); } catch (_) {}
-    const child = require('child_process').spawn(process.execPath, [supervisor], {
+    const child = require('child_process').spawn(runtime, [supervisor], {
       detached: true,
       stdio: ['ignore', logFd, logFd],
       windowsHide: true,

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1440",
+  "version": "2.0.1442",
   "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/supervisor.js

@@ -94,15 +94,27 @@ function spawnWatcher(bootReason) {
     process.exit(3);
   }
 
-  let runtime = process.env.PLUGKIT_RUNTIME || 'bun';
-  let cmd = runtime;
+  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
+  const resolveNode = () => {
+    const candidates = [];
+    if (isNodeExe(process.env.PLUGKIT_RUNTIME)) candidates.push(process.env.PLUGKIT_RUNTIME);
+    if (isNodeExe(process.execPath)) candidates.push(process.execPath);
+    if (process.env.GM_NODE_PATH) candidates.push(process.env.GM_NODE_PATH);
+    try {
+      const which = process.platform === 'win32' ? 'where' : 'which';
+      const out = spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+      if (out && out.stdout) {
+        const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+        if (first) candidates.push(first);
+      }
+    } catch (_) {}
+    for (const c of candidates) {
+      try { const r = spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+    }
+    return process.execPath;
+  };
+  let cmd = resolveNode();
   let args = [wrapper, 'spool'];
-  try {
-    spawnSync(runtime, ['--version'], { stdio: 'ignore', windowsHide: true });
-  } catch (_) {
-    cmd = process.execPath;
-    args = [wrapper, 'spool'];
-  }
 
   let logFd = null;
   try { logFd = fs.openSync(LOG_PATH, 'a'); } catch (_) {}

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1440",
+  "version": "2.0.1442",
   "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.581"
+  "plugkitVersion": "0.1.582"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1440",
+  "version": "2.0.1442",
   "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/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: gm-skill
 description: Plugkit-served instruction stream. Three-layer admission (cost, bounds, direction) over every possible mutation. Closure on first emit; partial = non-monotonic.
-allowed-tools: Skill, Read, Write, Bash(node *), Bash(bun *)
+allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 ---
 
 # gm
@@ -10,6 +10,8 @@ allowed-tools: Skill, Read, Write, Bash(node *), Bash(bun *)
 
 **Done is what plugkit says is done, never your claim.** The COMPLETE gate is the single arbiter. If the chain is not at COMPLETE, there is a next transition to seek; idle mid-chain is a deviation.
 
+**Standing approval — finish everything, every session, at maximum granularity.** Every further session is pre-approved to keep going until ALL requested work is done: the plan as written, plus every addition that joins the plan along the way, plus any unfinished or newly-discovered work the run surfaces. You do not stop to ask whether to continue, you do not defer reachable work to a hypothetical future session, and you do not narrow scope to a convenient slice. Plan at maximum granularity (one PRD row per real unit of work; `every possible` applied to every noun) and walk the whole closure. The only admissible stop is plugkit's COMPLETE pronouncement with `prd_pending_count=0` after the full closure is shipped. `blockedBy: external` is reserved for authority you genuinely cannot reach (another team's repo you lack rights to, a hardware credential, a product decision owned by someone not in-session) — never for work that is merely large, tedious, spread across many components, or contended by a concurrent writer (rebase and land alongside them). Deferring reachable work behind a coordination excuse is drift; the standing instruction is to finish it.
+
 **Every possible action begins and ends with `instruction`.** When in doubt, dispatch instruction. When denied, dispatch instruction. When the next move is unclear, dispatch instruction. There is no other recovery primitive and there is no situation in which improvising beats re-reading the prose.
 
 **You are the state machine.** Plugkit is the durable memory and gate-checker you write into; you are the actor that walks PLAN → EXECUTE → EMIT → VERIFY → COMPLETE. Every possible phase transition, every possible PRD resolution, every possible mutable witness, every possible residual scan is a verb YOU dispatch by writing `.gm/exec-spool/in/<verb>/<N>.txt`. Plugkit does not advance. Plugkit does not validate in the background. Plugkit does not "process" while you wait. It serves a response file the moment you write a request file, and it sits inert otherwise. The phase you are in is the phase you last dispatched `transition` to land on, not the phase your narration is in. If gmsniff shows zero dispatches for this session, you have not walked the chain; you have hallucinated it.