gm-skill 2.0.1161 → 2.0.1163

package/README.md

@@ -35,7 +35,7 @@ An earlier generation fanned out fifteen per-platform downstream repos (gm-cc, g
 
 ## Version
 
-`2.0.1161` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` (or any cascading sibling crate) republishes this package.
+`2.0.1163` — auto-bumped from the canonical `gm` repo. Every push to `AnEntrypoint/gm` (or any cascading sibling crate) republishes this package.
 
 ## Source of truth
 

package/bin/bootstrap.js

@@ -7,7 +7,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 
-const NPM_PACKAGE = '@anentrypoint/plugkit-wasm';
+const NPM_PACKAGE = 'plugkit-wasm';
 const ATTEMPT_TIMEOUT_MS = 10 * 60 * 1000;
 const MAX_ATTEMPTS = 3;
 const BACKOFF_MS = [5000, 15000];

package/gm-plugkit/bootstrap.js

@@ -7,7 +7,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { spawn, spawnSync } = require('child_process');
 
-const NPM_PACKAGE = '@anentrypoint/plugkit-wasm';
+const NPM_PACKAGE = 'plugkit-wasm';
 const ATTEMPT_TIMEOUT_MS = 10 * 60 * 1000;
 const MAX_ATTEMPTS = 3;
 const BACKOFF_MS = [5000, 15000];
@@ -811,6 +811,37 @@ function getBinaryPath() {
   return getWasmPath();
 }
 
+function probeUnsupervisedWatcher(spoolDir) {
+  try {
+    const statusPath = path.join(spoolDir, '.status.json');
+    const supervisorPath = path.join(spoolDir, '.supervisor.json');
+    const markerPath = path.join(spoolDir, '.pre-supervised-watcher.json');
+    if (!fs.existsSync(statusPath)) {
+      try { fs.unlinkSync(markerPath); } catch (_) {}
+      return;
+    }
+    const status = JSON.parse(fs.readFileSync(statusPath, 'utf-8'));
+    const age = Date.now() - (status && status.ts || 0);
+    if (age > 30_000) {
+      try { fs.unlinkSync(markerPath); } catch (_) {}
+      return;
+    }
+    if (fs.existsSync(supervisorPath)) {
+      try { fs.unlinkSync(markerPath); } catch (_) {}
+      return;
+    }
+    const marker = {
+      ts: Date.now(),
+      reason: 'running-watcher-has-no-supervisor',
+      watcher_pid: status.pid,
+      watcher_version: status.version,
+      severity: 'warn',
+      instruction: 'A running watcher was started under an older bootstrap that did not spawn a supervisor. Unplanned-restart recovery and idle-teardown coordination are dormant. To migrate, stop the current watcher (taskkill /F /T /PID <watcher_pid> on Windows or kill <watcher_pid> on POSIX) and let the next bootstrap re-spawn it under supervisor.js.',
+    };
+    fs.writeFileSync(markerPath, JSON.stringify(marker, null, 2));
+  } catch (_) {}
+}
+
 function startSpoolDaemon() {
   try {
     const wrapper = path.join(gmToolsDir(), 'plugkit-wasm-wrapper.js');
@@ -821,6 +852,7 @@ function startSpoolDaemon() {
     const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
     const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
     fs.mkdirSync(spoolDir, { recursive: true });
+    probeUnsupervisedWatcher(spoolDir);
     const logPath = path.join(spoolDir, '.watcher.log');
     try {
       const stat = fs.statSync(logPath);

package/gm-plugkit/supervisor.js

@@ -216,6 +216,7 @@ process.on('SIGTERM', () => {
 
 writeSupervisorStatus('starting', {});
 logEvent('supervisor.starting', { spool_dir: spoolDir });
+try { fs.unlinkSync(path.join(spoolDir, '.pre-supervised-watcher.json')); } catch (_) {}
 spawnWatcher('initial');
 setInterval(checkWatcherHealth, POLL_INTERVAL_MS);
 setInterval(() => writeSupervisorStatus('watching', { watcher_pid: currentChildPid, boot_reason: currentBootReason }), 10_000);

package/gm.json

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

package/lib/spool-dispatch.js

@@ -170,6 +170,25 @@ function markInstructionSeen(sessionId) {
   } catch (_) {}
 }
 
+const DEFER_MARKERS = [
+  'next pass', 'next session', 'next turn',
+  'defer to later', 'deferred to later', 'deferred for later',
+  'future pass', 'future session', 'future turn',
+  'address it next', 'address this next', 'leave for next',
+  'documented for next', 'documented for future',
+  'below criticality', 'skip for now', 'punt for now',
+  'do later', 'fix later', 'later pass',
+];
+
+function deferMarkerIn(text) {
+  if (!text) return null;
+  const lower = String(text).toLowerCase();
+  for (const m of DEFER_MARKERS) {
+    if (lower.includes(m)) return m;
+  }
+  return null;
+}
+
 function checkDispatchGates(sessionId, operation, extra) {
   const cwd = process.cwd();
   const gm = path.join(cwd, '.gm');
@@ -226,6 +245,17 @@ function checkDispatchGates(sessionId, operation, extra) {
     logDeviation('deviation.mutable-without-evidence', { mutable_id: extra.id || null });
   }
 
+  if (operation === 'git' && extra && extra.commit_message) {
+    const marker = deferMarkerIn(extra.commit_message);
+    if (marker) {
+      logDeviation('deviation.commit-message-defer', { marker, operation });
+      return {
+        allowed: false,
+        reason: `commit message rejected: deferral phrase '${marker}' detected. Per paper §22 Fix on Sight, defer markers are forced closure. Either inline-fix and re-witness, or split the deferred work as a separate PRD item with blockedBy: [external] before committing. Rewrite the commit message and retry.`,
+      };
+    }
+  }
+
   if (!['write', 'edit', 'git'].includes(operation)) return { allowed: true };
 
   if (fs.existsSync(prdPath) && fs.existsSync(needsGmPath) && !fs.existsSync(gmFiredPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1161",
+  "version": "2.0.1163",
   "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",
@@ -39,7 +39,7 @@
     "gm.json"
   ],
   "dependencies": {
-    "gm-plugkit": "^2.0.1161"
+    "gm-plugkit": "^2.0.1163"
   },
   "engines": {
     "node": ">=16.0.0"

package/skills/gm-skill/SKILL.md

@@ -20,6 +20,10 @@ If the `instruction` response carries a non-null `update_available`, plugkit dri
 
 If `running_tasks` is non-empty, you own them — every entry is a subprocess you started that's still consuming CPU/memory. Stop ones that have outlived their purpose with `task-stop` (write `.gm/exec-spool/in/task-stop/<N>.txt` with `{id: "t<n>"}`). The 15-min idle reaper is the last resort, not a substitute for hygiene. If `stuck_spool` is non-empty, dispatches are wedged — the watcher's host_exec_js is synchronous and a stuck body blocks every other verb until it returns. Diagnose via `.watcher.log` and consider rebootstrapping if it doesn't clear; spool bodies are Turing-complete and can loop forever. Long-running work goes through `task-spawn` (returns a `task_id` immediately, body runs detached), not through the sync `nodejs`/`bash`/`python` language verbs.
 
+If `should_residual_scan` is true, dispatch `residual-scan` before any text response that reads like a stop. The marker is one-shot per stopping window — re-checking after you've fired it is fine; firing it for the first time in a session that has pending work is non-negotiable. If `unsupervised_watcher` is non-null, the running watcher predates supervisor.js and has no unplanned-restart recovery; stop the named PID and let the next bootstrap re-spawn it under supervision.
+
+No deferral phrasing. "Next pass", "next session", "future work", "defer to later", "address it next", "below criticality", "do later", "fix later" are all forced closure dressed up. `prd-add` rejects items whose description/subject/notes contain these markers unless the item carries `blockedBy: [external]` or `blockedBy: [out-of-reach]`. The dispatch gate also rejects git commits whose message contains them. Per §22 Fix on Sight: in-spirit reachable work is executed this turn, not deferred. If the work is genuinely unreachable, declare it with blockedBy; that's an auditable refusal, not a defer.
+
 The wasm artifact lives at `~/.claude/gm-tools/plugkit.wasm`; the spool watcher runs it. The watcher's own stdout/stderr is appended to `.gm/exec-spool/.watcher.log` — Read it to see plugkit's internal trace, dispatch timings, sweep actions, errors.
 
 The watcher self-shuts-down after 15 minutes idle (no spool I/O, no live browser session) and is restarted on next agent activity by a detached supervisor. `.gm/exec-spool/.unplanned-restart.json` is a critical-failure marker — present means a prior watcher died without a planned shutdown. Treat as a PRD-worthy incident on sight: diagnose via `.watcher.log` and `gm-log/<day>/plugkit.jsonl` events `supervisor.watcher-exited-unexpectedly` and `supervisor.heartbeat-stale` around the prior_status.ts timestamp, then delete the marker once root cause is named.