gm-skill 2.0.1575 → 2.0.1577

package/AGENTS.md

@@ -148,13 +148,13 @@ Push to any rs-* sibling triggers `cascade.yml` -> rs-plugkit `release.yml` -> s
 
 Orchestration state is tracked via `.gm/` marker files, not hook events; the CLI layer calls `checkDispatchGates()` before tool execution to gate Write/Edit/git. Marker set (`prd.yml, mutables.yml, needs-gm, gm-fired-<sessionId>, residual-check-fired`) + SpoolDispatcher mechanism in rs-learn (`recall: gate enforcement layer`, `recall: spool dispatch gates marker files`).
 
-**gm-skill tool-use sequencing**: `Skill(skill="gm-skill")` writes `.gm/gm-fired-<sessionId>` to clear the needs-gm gate (cleared at turn start to reset it). One shipped skill, no subagent variant.
+**gm-skill tool-use sequencing**: `Skill(skill="gm-skill")` clears the needs-gm gate. One shipped skill, no subagent variant. Marker mechanics in rs-learn (`recall: gm-skill tool-use sequencing mechanics`).
 
 **The skill is the driver, not a post-hoc witness**: when a request carries the standing instruction to use gm-skill (every `/loop` fire, any prompt naming `/gm-skill`), the FIRST working action is `Skill(skill="gm-skill")`, and the skill prose drives the chain PLAN->COMPLETE. Dispatching spool verbs directly without first entering the skill executes the work outside the skill the user asked to drive it; entering only at the end to confirm terminal state does NOT satisfy the instruction. The boot probe (`cat .gm/exec-spool/.status.json` ...) is prescribed by the skill and may precede invocation; everything that mutates state happens inside the skill-driven session.
 
 **Dead-watcher recovery uses `bun x gm-plugkit@latest spool`, never direct-node boot** (mechanism in rs-learn: `recall: dead-watcher recovery bun x not direct-node`).
 
-**The first verb after a genuine multi-minute IDLE is `instruction`, to reset the long-gap clock**: the gate fires on genuine idle only (>300s since the last instruction AND >300s since any verb), so active back-to-back work verbs keep the chain alive without an interleaved `instruction` -- do not inject defensive instruction dispatches between active work. A true wait (version download, overnight, long external CI watch) trips it, and the first verb back is `instruction`. When the wait is self-inflicted and predictable (a blocking `TaskOutput`/`gh run watch`), dispatch `instruction` immediately BEFORE entering the wait, not only after. "Work verbs"/"any verb" here means SPOOL dispatches -- platform `Bash`/`Read`/`Edit`/`Grep` do NOT reset the clock, so a long investigation run purely in them (the audit `gmsniff`/`ccsniff` sweep + source reading/editing exceeding 300s) trips a false `mid-chain-stall` even while actively working; interleave a `prd-add` (convert each finding as it emerges per density-grows-along-the-walk) or an `instruction` to keep the clock warm. Mechanism in rs-learn (`recall: first verb after multi-minute wait instruction long-gap`).
+**The first verb after a genuine multi-minute IDLE is `instruction`, to reset the long-gap clock**: gate fires when >300s since last instruction AND >300s since any SPOOL verb. Platform `Bash`/`Read`/`Edit`/`Grep` do NOT reset the clock -- a long investigation run in them trips a false stall; interleave `prd-add` or `instruction` to keep warm. For a predictable blocking wait (`TaskOutput`/`gh run watch`), dispatch `instruction` BEFORE entering the wait. Detail + platform-tool exception in rs-learn (`recall: first verb after multi-minute wait instruction long-gap`).
 
 **A stop-hook firing on a terminal chain does not authorize re-polling**: when a stop-hook fires while already at `phase=COMPLETE` AND `prd_pending_count=0`, re-dispatching `instruction`/`phase-status` to "re-confirm" is a deviation (`deviation.complete-chain-poll`, `instructions/mod.rs`). Two admissible responses: (a) a prose-only turn (COMPLETE is in hand), or (b) genuinely new planned work opened with a FRESH `{"prompt":...}` body (resets phase to PLAN, driven through the skill). Repeatedly answering the same hook is a loop; state the terminal facts once and stop, or open new work.
 

package/gm-plugkit/package.json

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

@@ -2139,8 +2139,8 @@ async function runSpoolWatcher(instance, spoolDir) {
   }
   function lockBody() { return `${process.pid}|${Date.now()}|${_ownWrapperSha12}`; }
   function acquireLock() {
-    try {
-      if (fs.existsSync(LOCK_PATH)) {
+    function checkExistingHolder() {
+      try {
         const content = fs.readFileSync(LOCK_PATH, 'utf-8').trim();
         const parts = content.split('|');
         const pidStr = parts[0];
@@ -2164,6 +2164,7 @@ async function runSpoolWatcher(instance, spoolDir) {
               }));
             } catch (_) {}
             try { process.kill(parseInt(pidStr, 10), 'SIGTERM'); } catch (_) {}
+            return 'takeover';
           } else {
             const msg = JSON.stringify({ ok: false, reason: 'another-watcher-active', pid: pidStr, age_ms: age });
             console.error(`[plugkit-wasm] ${msg}; refusing to start`);
@@ -2181,11 +2182,32 @@ async function runSpoolWatcher(instance, spoolDir) {
         } else if (!holderAlive) {
           console.error(`[plugkit-wasm] stale lock (holder pid=${pidStr} dead, age=${age}ms); taking over`);
           try { logEvent('plugkit', 'watcher.lock-pid-dead-takeover', { stale_pid: pidStr, lock_age_ms: age }); } catch (_) {}
+          return 'takeover';
         } else {
           console.error(`[plugkit-wasm] stale lock (age=${age}ms); taking over`);
+          return 'takeover';
         }
+      } catch (_) {
+        return 'takeover';
+      }
+    }
+    try {
+      let fd;
+      try {
+        fd = fs.openSync(LOCK_PATH, 'wx');
+      } catch (e) {
+        if (e.code !== 'EEXIST') throw e;
+        const action = checkExistingHolder();
+        if (action !== 'takeover') return;
+        try { fs.unlinkSync(LOCK_PATH); } catch (_) {}
+        fd = fs.openSync(LOCK_PATH, 'wx');
+      }
+      try {
+        const body = Buffer.from(lockBody(), 'utf-8');
+        fs.writeSync(fd, body);
+      } finally {
+        fs.closeSync(fd);
       }
-      fs.writeFileSync(LOCK_PATH, lockBody());
     } catch (e) {
       console.error(`[plugkit-wasm] lock acquire failed: ${e.message}`);
       process.exit(1);

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1575",
+  "version": "2.0.1577",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/lib/spool-dispatch.js

@@ -330,7 +330,9 @@ function checkDispatchGates(sessionId, operation, extra) {
         if (content.includes('status: unknown')) {
           residuals.push('unresolved mutables present -- resolve with witness_evidence before declaring done');
         }
-      } catch (_) {}
+      } catch (e) {
+        residuals.push(`mutables.yml unreadable (${e.message}) -- cannot verify mutable state`);
+      }
     }
     const dirty = isWorktreeDirty(cwd);
     if (dirty.available && dirty.dirty) {

package/lib/spool.js

@@ -49,7 +49,7 @@ function writeSpool(body, lang = 'nodejs', options = {}) {
   fs.mkdirSync(inDir, { recursive: true });
 
   const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID;
-  const code = sessionId ? `const SESSION_ID = '${sessionId}';\n${body}` : body;
+  const code = sessionId ? `const SESSION_ID = ${JSON.stringify(sessionId)};\n${body}` : body;
 
   fs.writeFileSync(inFile, code, 'utf8');
 

package/package.json

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