gm-skill 2.0.1391 → 2.0.1393

package/gm-plugkit/package.json

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

@@ -1868,7 +1868,9 @@ async function runSpoolWatcher(instance, spoolDir) {
         const holderSha = parts[2] || '';
         const lockTs = parseInt(tsStr, 10);
         const age = Date.now() - lockTs;
-        if (age < 15000) {
+        const holderPidNum = parseInt(pidStr, 10);
+        const holderAlive = Number.isFinite(holderPidNum) && isProcessAliveSync(holderPidNum);
+        if (age < 15000 && holderAlive) {
           if (_ownWrapperSha12 && holderSha && holderSha !== _ownWrapperSha12) {
             try { logEvent('plugkit', 'peer.stale-wrapper-takeover', { holder_pid: pidStr, holder_sha: holderSha, own_sha: _ownWrapperSha12, lock_age_ms: age }); } catch (_) {}
             console.error(`[plugkit-wasm] peer wrapper-sha mismatch (holder=${holderSha} own=${_ownWrapperSha12}); killing pid=${pidStr} and taking over`);
@@ -1896,6 +1898,9 @@ async function runSpoolWatcher(instance, spoolDir) {
             } catch (_) {}
             process.exit(75);
           }
+        } 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 (_) {}
         } else {
           console.error(`[plugkit-wasm] stale lock (age=${age}ms); taking over`);
         }
@@ -2742,6 +2747,57 @@ async function runSpoolWatcher(instance, spoolDir) {
   setInterval(writeStatus, 5000);
   writeStatus();
 
+  const TURN_SUMMARY_PATH = path.join(spoolDir, '.turn-summary.json');
+  function writeTurnSummary() {
+    try {
+      const cwd = process.cwd();
+      const gmDir = path.join(cwd, '.gm');
+      let phase = null, lastSkill = null, prdPending = 0, browserSessions = 0;
+      let lastInstructionTs = null, lastInstructionAgeMs = null;
+      try {
+        const ts = JSON.parse(fs.readFileSync(path.join(gmDir, 'turn-state.json'), 'utf-8'));
+        phase = ts.phase || null;
+        lastSkill = ts.last_skill || null;
+      } catch (_) {}
+      try {
+        const prdRaw = fs.readFileSync(path.join(gmDir, 'prd.yml'), 'utf-8');
+        const openRe = /\n\s*status:\s*(pending|in_progress|unknown)\b/g;
+        const matches = prdRaw.match(openRe);
+        prdPending = matches ? matches.length : 0;
+      } catch (_) {}
+      try {
+        const tsRaw = fs.readFileSync(path.join(gmDir, 'last-instruction-ts'), 'utf-8');
+        const n = parseInt(tsRaw.trim(), 10);
+        if (Number.isFinite(n) && n > 0) {
+          lastInstructionTs = n;
+          lastInstructionAgeMs = Date.now() - n;
+        }
+      } catch (_) {}
+      try {
+        const ports = readJsonFile(browserPortsFile(cwd), {});
+        for (const entry of Object.values(ports)) {
+          if (entry && Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) browserSessions++;
+        }
+      } catch (_) {}
+      const fileV = readFileVersionOnly() || null;
+      const instV = _instanceVersionAtBoot || null;
+      fs.writeFileSync(TURN_SUMMARY_PATH, JSON.stringify({
+        ts: Date.now(),
+        watcher_pid: process.pid,
+        watcher_version: instV || fileV,
+        phase,
+        last_skill: lastSkill,
+        prd_pending: prdPending,
+        last_instruction_ts: lastInstructionTs,
+        last_instruction_age_ms: lastInstructionAgeMs,
+        long_gap_threshold_ms: 300000,
+        browser_sessions_alive: browserSessions,
+      }));
+    } catch (_) {}
+  }
+  setInterval(writeTurnSummary, 5000);
+  writeTurnSummary();
+
   const UPDATE_AVAILABLE_PATH = path.join(spoolDir, '.update-available.json');
   const UPDATE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
   const UPDATE_CHECK_SHARED_CACHE = path.join(GM_TOOLS_ROOT, '.update-check-cache.json');

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1391",
+  "version": "2.0.1393",
   "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.1391",
+  "version": "2.0.1393",
   "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

@@ -22,13 +22,15 @@ Every turn: dispatch `instruction` (you are the one dispatching it), read the re
 
 **Boot before dispatching. Always check first.** Writing to `.gm/exec-spool/in/instruction/N.txt` while the watcher is dead is the canonical cold-start failure — the request sits forever, you read no response, you fabricate the chain from memory of the prose. The spool directory's existence does NOT mean the watcher is alive; `.status.json` mtime within the last 15s does. The leftover `.status.json` from yesterday's dead watcher is the most common trap.
 
-Your first tool call of every session is the boot probe, in one Bash invocation:
+Your first tool call of every session is the boot probe, in one Bash invocation. Read `.status.json` (liveness) and `.turn-summary.json` (orientation) together — the watcher precomputes both every 5s, so the two files give you everything you'd otherwise extract via gmsniff queries, git, yaml-parse, and ports-file scans:
 
 ```bash
-cat .gm/exec-spool/.status.json 2>/dev/null; date +%s%3N
+cat .gm/exec-spool/.status.json 2>/dev/null; echo ---; cat .gm/exec-spool/.turn-summary.json 2>/dev/null; echo ---; date +%s%3N
 ```
 
-Compare the `ts` field to the printed epoch ms. If the gap is >15000, the watcher is dead — boot it:
+`.turn-summary.json` carries `phase`, `last_skill`, `prd_pending`, `last_instruction_ts`, `last_instruction_age_ms`, `long_gap_threshold_ms`, `browser_sessions_alive`. When age exceeds the threshold, your next non-orienting verb will be gated — dispatch `instruction` first.
+
+Compare `.status.json` `ts` field to the printed epoch ms. If the gap is >15000, the watcher is dead — boot it:
 
 ```bash
 bun x gm-plugkit@latest spool > /dev/null 2>&1 &