gm-skill 2.0.1155 → 2.0.1157

package/README.md

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

package/gm-plugkit/bootstrap.js

@@ -777,14 +777,6 @@ function startSpoolDaemon() {
       return { ok: false, error: `wrapper not at ${wrapper} — ensureReady() must run first` };
     }
     const runtime = process.platform === 'win32' ? 'bun.exe' : 'bun';
-    let cmd = runtime;
-    let args = [wrapper, 'spool'];
-    try {
-      require('child_process').execFileSync(runtime, ['--version'], { stdio: 'ignore' });
-    } catch (_) {
-      cmd = process.execPath;
-      args = [wrapper, 'spool'];
-    }
     const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
     const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
     fs.mkdirSync(spoolDir, { recursive: true });
@@ -796,18 +788,43 @@ function startSpoolDaemon() {
         fs.renameSync(logPath, path.join(spoolDir, '.watcher.log.1'));
       }
     } catch (_) {}
+
+    const supervisor = path.join(__dirname, 'supervisor.js');
+    if (process.env.PLUGKIT_SKIP_SUPERVISOR === '1' || !fs.existsSync(supervisor)) {
+      let cmd = runtime;
+      let args = [wrapper, 'spool'];
+      try {
+        require('child_process').execFileSync(runtime, ['--version'], { stdio: 'ignore' });
+      } catch (_) {
+        cmd = process.execPath;
+        args = [wrapper, 'spool'];
+      }
+      const logFd = fs.openSync(logPath, 'a');
+      try { fs.writeSync(logFd, `\n--- daemon spawn ${new Date().toISOString()} parent=${process.pid} (no supervisor) ---\n`); } catch (_) {}
+      const child = require('child_process').spawn(cmd, args, {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        windowsHide: true,
+        env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir, PLUGKIT_BOOT_REASON: 'direct-no-supervisor' },
+      });
+      try { fs.closeSync(logFd); } catch (_) {}
+      const pid = child.pid;
+      child.unref();
+      return { ok: true, pid, wrapper, runtime: cmd, logPath, supervised: false };
+    }
+
     const logFd = fs.openSync(logPath, 'a');
-    try { fs.writeSync(logFd, `\n--- daemon spawn ${new Date().toISOString()} parent=${process.pid} ---\n`); } catch (_) {}
-    const child = require('child_process').spawn(cmd, args, {
+    try { fs.writeSync(logFd, `\n--- supervisor spawn ${new Date().toISOString()} parent=${process.pid} ---\n`); } catch (_) {}
+    const child = require('child_process').spawn(process.execPath, [supervisor], {
       detached: true,
       stdio: ['ignore', logFd, logFd],
       windowsHide: true,
-      env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir },
+      env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir, PLUGKIT_RUNTIME: runtime },
     });
     try { fs.closeSync(logFd); } catch (_) {}
     const pid = child.pid;
     child.unref();
-    return { ok: true, pid, wrapper, runtime: cmd, logPath };
+    return { ok: true, pid, wrapper, supervisor, runtime, logPath, supervised: true };
   } catch (e) {
     return { ok: false, error: e.message };
   }

package/gm-plugkit/plugkit-wasm-wrapper.js

@@ -4,10 +4,17 @@ import os from 'os';
 import crypto from 'crypto';
 import https from 'https';
 import { watch } from 'fs';
-import { spawn, spawnSync } from 'child_process';
+import { spawn as _rawSpawn, spawnSync as _rawSpawnSync } from 'child_process';
 import net from 'net';
 import { fileURLToPath } from 'url';
 
+function spawnSync(cmd, args, opts) {
+  return _rawSpawnSync(cmd, args, { windowsHide: true, ...(opts || {}) });
+}
+function spawn(cmd, args, opts) {
+  return _rawSpawn(cmd, args, { windowsHide: true, ...(opts || {}) });
+}
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -116,8 +123,33 @@ function emitOrchestratorEvents(verb, taskBase, resultStr) {
 }
 
 const TMP_DIR = os.tmpdir();
-const BROWSER_PORTS_FILE = path.join(TMP_DIR, 'plugkit-browser-ports.json');
-const BROWSER_SESSIONS_FILE = path.join(TMP_DIR, 'plugkit-browser-sessions.json');
+const LEGACY_BROWSER_PORTS_FILE = path.join(TMP_DIR, 'plugkit-browser-ports.json');
+const LEGACY_BROWSER_SESSIONS_FILE = path.join(TMP_DIR, 'plugkit-browser-sessions.json');
+
+function browserStateDir(cwd) {
+  const dir = path.join(cwd || process.cwd(), '.gm', 'exec-spool');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch (_) {}
+  return dir;
+}
+function browserPortsFile(cwd) { return path.join(browserStateDir(cwd), 'browser-ports.json'); }
+function browserSessionsFile(cwd) { return path.join(browserStateDir(cwd), 'browser-sessions.json'); }
+
+function migrateLegacyBrowserState(cwd) {
+  const dst1 = browserPortsFile(cwd);
+  const dst2 = browserSessionsFile(cwd);
+  try {
+    if (!fs.existsSync(dst1) && fs.existsSync(LEGACY_BROWSER_PORTS_FILE)) {
+      const legacy = JSON.parse(fs.readFileSync(LEGACY_BROWSER_PORTS_FILE, 'utf-8'));
+      if (legacy && typeof legacy === 'object') fs.writeFileSync(dst1, JSON.stringify(legacy, null, 2));
+    }
+  } catch (_) {}
+  try {
+    if (!fs.existsSync(dst2) && fs.existsSync(LEGACY_BROWSER_SESSIONS_FILE)) {
+      const legacy = JSON.parse(fs.readFileSync(LEGACY_BROWSER_SESSIONS_FILE, 'utf-8'));
+      if (legacy && typeof legacy === 'object') fs.writeFileSync(dst2, JSON.stringify(legacy, null, 2));
+    }
+  } catch (_) {}
+}
 
 function readJsonFile(fp, fallback) {
   try { return JSON.parse(fs.readFileSync(fp, 'utf-8')); } catch (_) { return fallback; }
@@ -239,8 +271,11 @@ function runPlaywriter(pw, args, timeoutMs) {
 }
 
 function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
-  const ports = readJsonFile(BROWSER_PORTS_FILE, {});
-  const sessions = readJsonFile(BROWSER_SESSIONS_FILE, {});
+  migrateLegacyBrowserState(cwd);
+  const portsFile = browserPortsFile(cwd);
+  const sessionsFile = browserSessionsFile(cwd);
+  const ports = readJsonFile(portsFile, {});
+  const sessions = readJsonFile(sessionsFile, {});
   const existing = ports[claudeSessionId];
   if (existing && existing.port && isPortAliveSync(existing.port)) {
     const pwIds = sessions[claudeSessionId] || [];
@@ -258,6 +293,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     '--disable-features=Translate',
   ];
   const child = spawn(chrome, chromeArgs, { detached: true, stdio: 'ignore' });
+  const chromePid = child.pid;
   child.unref();
   const deadline = Date.now() + 10000;
   let alive = false;
@@ -281,10 +317,10 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     try { const j = JSON.parse(out); pwSessionId = j.id || j.session_id || j.session; } catch (_) {}
   }
   if (!pwSessionId) throw new Error(`could not parse playwriter session id from: ${out}`);
-  ports[claudeSessionId] = { port, profileDir };
+  ports[claudeSessionId] = { port, profileDir, pid: chromePid };
   sessions[claudeSessionId] = [pwSessionId];
-  writeJsonFile(BROWSER_PORTS_FILE, ports);
-  writeJsonFile(BROWSER_SESSIONS_FILE, sessions);
+  writeJsonFile(portsFile, ports);
+  writeJsonFile(sessionsFile, sessions);
   return pwSessionId;
 }
 
@@ -735,6 +771,83 @@ async function runSpoolWatcher(instance, spoolDir) {
   }
   acquireLock();
   setInterval(refreshLock, 5000);
+
+  const IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_IDLE_LIMIT_MS, 10) || 15 * 60 * 1000;
+  const IDLE_CHECK_MS = 60_000;
+  const SHUTDOWN_REASON_PATH = path.join(spoolDir, '.shutdown-reason.json');
+  const STATUS_PATH_FOR_TEARDOWN = path.join(spoolDir, '.status.json');
+  const ACPTOAPI_STATUS_PATH = path.join(process.cwd(), '.gm', 'acptoapi-status.json');
+  let lastActivityMs = Date.now();
+  function markActivity(source) {
+    lastActivityMs = Date.now();
+  }
+
+  function killPidQuiet(pid) {
+    if (!Number.isFinite(pid) || pid <= 0 || pid === process.pid) return false;
+    try { process.kill(pid, 'SIGTERM'); } catch (_) {}
+    if (process.platform === 'win32') {
+      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(pid)], { stdio: 'ignore', timeout: 3000 }); } catch (_) {}
+    }
+    return true;
+  }
+
+  function teardownAll(reason) {
+    try {
+      logEvent('plugkit', 'watcher.teardown', { reason, idle_ms: Date.now() - lastActivityMs });
+      console.log(`[plugkit-wasm] teardown reason=${reason}`);
+    } catch (_) {}
+
+    try {
+      if (fs.existsSync(ACPTOAPI_STATUS_PATH)) {
+        const status = JSON.parse(fs.readFileSync(ACPTOAPI_STATUS_PATH, 'utf-8'));
+        if (status && Number.isFinite(status.pid)) killPidQuiet(status.pid);
+        try { fs.unlinkSync(ACPTOAPI_STATUS_PATH); } catch (_) {}
+      }
+    } catch (_) {}
+
+    try {
+      const portsFile = browserPortsFile(process.cwd());
+      const sessionsFile = browserSessionsFile(process.cwd());
+      const ports = readJsonFile(portsFile, {});
+      for (const [sid, entry] of Object.entries(ports)) {
+        if (entry && Number.isFinite(entry.pid)) killPidQuiet(entry.pid);
+      }
+      try { fs.unlinkSync(portsFile); } catch (_) {}
+      try { fs.unlinkSync(sessionsFile); } catch (_) {}
+    } catch (_) {}
+
+    try {
+      fs.writeFileSync(SHUTDOWN_REASON_PATH, JSON.stringify({
+        reason,
+        ts: Date.now(),
+        pid: process.pid,
+        idle_ms: Date.now() - lastActivityMs,
+      }));
+    } catch (_) {}
+
+    try { fs.unlinkSync(STATUS_PATH_FOR_TEARDOWN); } catch (_) {}
+    try { releaseLock(); } catch (_) {}
+    process.exit(0);
+  }
+
+  setInterval(() => {
+    try {
+      const idleMs = Date.now() - lastActivityMs;
+      if (idleMs < IDLE_LIMIT_MS) return;
+      try {
+        const ports = readJsonFile(browserPortsFile(process.cwd()), {});
+        let browserAlive = false;
+        for (const entry of Object.values(ports)) {
+          if (entry && Number.isFinite(entry.port) && isPortAliveSync(entry.port)) { browserAlive = true; break; }
+        }
+        if (browserAlive) { markActivity('browser-port-alive'); return; }
+      } catch (_) {}
+      teardownAll('idle');
+    } catch (e) {
+      console.error(`[idle-check] error: ${e.message}`);
+    }
+  }, IDLE_CHECK_MS);
+
   process.on('SIGINT', () => { releaseLock(); process.exit(0); });
   process.on('SIGTERM', () => { releaseLock(); process.exit(0); });
   process.on('exit', releaseLock);
@@ -760,7 +873,49 @@ async function runSpoolWatcher(instance, spoolDir) {
   const _bootVersion = resolveVersion(instance);
   console.log(`[plugkit-wasm] plugkit v${_bootVersion} (wasm)`);
   console.log(`[plugkit-wasm] watching ${inDir}`);
-  logEvent('plugkit', 'watcher.boot', { version: _bootVersion, in_dir: inDir, out_dir: outDir, spool_dir: spoolDir });
+
+  let _priorShutdown = null;
+  let _priorStatus = null;
+  try { _priorShutdown = JSON.parse(fs.readFileSync(SHUTDOWN_REASON_PATH, 'utf-8')); } catch (_) {}
+  try { _priorStatus = JSON.parse(fs.readFileSync(STATUS_PATH_FOR_TEARDOWN, 'utf-8')); } catch (_) {}
+  const _bootReason = process.env.PLUGKIT_BOOT_REASON || 'unknown';
+  const _supervisorPid = parseInt(process.env.PLUGKIT_SUPERVISOR_PID, 10) || null;
+  const restartContext = {
+    boot_reason: _bootReason,
+    supervisor_pid: _supervisorPid,
+    prior_shutdown: _priorShutdown,
+    prior_status: _priorStatus,
+    prior_status_age_ms: _priorStatus && Number.isFinite(_priorStatus.ts) ? Date.now() - _priorStatus.ts : null,
+  };
+  const _isPlannedBoot = _priorShutdown && (_priorShutdown.reason === 'idle' || _priorShutdown.reason === 'sigterm' || _priorShutdown.reason === 'version-change');
+  const _isFirstBoot = !_priorShutdown && !_priorStatus;
+  const UNPLANNED_RESTART_MARKER = path.join(spoolDir, '.unplanned-restart.json');
+  if (!_isPlannedBoot && !_isFirstBoot) {
+    const incidentPayload = {
+      ts: Date.now(),
+      version: _bootVersion,
+      severity: 'critical',
+      ...restartContext,
+      log_tail_path: path.join(spoolDir, '.watcher.log'),
+      gm_log_dir: GM_LOG_ROOT,
+      instruction: 'Prior watcher died without a planned shutdown. This is treated as a critical failure. Inspect .watcher.log and gm-log/<day>/plugkit.jsonl events supervisor.watcher-exited-unexpectedly + supervisor.heartbeat-stale around the prior_status.ts timestamp to diagnose root cause.',
+    };
+    logEvent('plugkit', 'watcher.unplanned-restart', incidentPayload);
+    try {
+      let history = [];
+      try { history = JSON.parse(fs.readFileSync(UNPLANNED_RESTART_MARKER, 'utf-8')).history || []; } catch (_) {}
+      history.push(incidentPayload);
+      if (history.length > 20) history = history.slice(-20);
+      fs.writeFileSync(UNPLANNED_RESTART_MARKER, JSON.stringify({
+        latest: incidentPayload,
+        count: history.length,
+        history,
+      }, null, 2));
+    } catch (_) {}
+    console.error(`[plugkit-wasm] UNPLANNED RESTART detected — prior watcher died without writing .shutdown-reason.json. prior_status_age_ms=${restartContext.prior_status_age_ms} boot_reason=${_bootReason}`);
+  }
+  try { fs.unlinkSync(SHUTDOWN_REASON_PATH); } catch (_) {}
+  logEvent('plugkit', 'watcher.boot', { version: _bootVersion, in_dir: inDir, out_dir: outDir, spool_dir: spoolDir, ...restartContext });
 
   const PROCESSED_MAX = 10000;
   const processed = new Map();
@@ -927,6 +1082,7 @@ async function runSpoolWatcher(instance, spoolDir) {
 
   const pollInterval = setInterval(async () => {
     const existing = walkDir(inDir);
+    if (existing.length > 0) markActivity('poll');
     for (const fullPath of existing) {
       await processFile(fullPath);
     }
@@ -997,6 +1153,7 @@ async function runSpoolWatcher(instance, spoolDir) {
   watch(inDir, { recursive: true }, (eventType, filename) => {
     if (!filename) return;
     const fullPath = path.join(inDir, filename);
+    markActivity('watch');
 
     clearTimeout(debounce[fullPath]);
     debounce[fullPath] = setTimeout(async () => {

package/gm-plugkit/supervisor.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const spoolDir = path.join(projectDir, '.gm', 'exec-spool');
+fs.mkdirSync(spoolDir, { recursive: true });
+
+const STATUS_PATH = path.join(spoolDir, '.status.json');
+const SHUTDOWN_REASON_PATH = path.join(spoolDir, '.shutdown-reason.json');
+const SUPERVISOR_PATH = path.join(spoolDir, '.supervisor.json');
+const LOG_PATH = path.join(spoolDir, '.watcher.log');
+const GM_LOG_ROOT = process.env.GM_LOG_DIR || path.join(os.homedir(), '.claude', 'gm-log');
+
+const POLL_INTERVAL_MS = 10_000;
+const STATUS_STALE_MS = 30_000;
+const MAX_RESTART_BURST = 5;
+const RESTART_WINDOW_MS = 60_000;
+
+function logEvent(event, fields) {
+  try {
+    const day = new Date().toISOString().slice(0, 10);
+    const dir = path.join(GM_LOG_ROOT, day);
+    fs.mkdirSync(dir, { recursive: true });
+    const line = JSON.stringify({
+      ts: Date.now(),
+      sub: 'plugkit',
+      event,
+      pid: process.pid,
+      sess: process.env.CLAUDE_SESSION_ID || '',
+      cwd: process.cwd(),
+      role: 'supervisor',
+      ...fields,
+    }) + '\n';
+    fs.appendFileSync(path.join(dir, 'plugkit.jsonl'), line);
+  } catch (_) {}
+}
+
+function writeSupervisorStatus(state, extra) {
+  try {
+    fs.writeFileSync(SUPERVISOR_PATH, JSON.stringify({
+      pid: process.pid,
+      ts: Date.now(),
+      state,
+      ...(extra || {}),
+    }));
+  } catch (_) {}
+}
+
+function pidAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (_) { return false; }
+}
+
+function readStatus() {
+  try { return JSON.parse(fs.readFileSync(STATUS_PATH, 'utf-8')); } catch (_) { return null; }
+}
+
+function readShutdownReason() {
+  try { return JSON.parse(fs.readFileSync(SHUTDOWN_REASON_PATH, 'utf-8')); } catch (_) { return null; }
+}
+
+let lastSpawnedAt = 0;
+let restartTimestamps = [];
+let currentChildPid = null;
+let currentBootReason = 'initial';
+
+function spawnWatcher(bootReason) {
+  lastSpawnedAt = Date.now();
+  restartTimestamps.push(Date.now());
+  restartTimestamps = restartTimestamps.filter(t => Date.now() - t < RESTART_WINDOW_MS);
+  if (restartTimestamps.length > MAX_RESTART_BURST) {
+    logEvent('supervisor.giving-up', {
+      reason: 'restart-burst-exceeded',
+      restarts_in_window: restartTimestamps.length,
+      window_ms: RESTART_WINDOW_MS,
+      max: MAX_RESTART_BURST,
+      severity: 'critical',
+    });
+    writeSupervisorStatus('giving-up', { reason: 'restart-burst-exceeded' });
+    process.exit(2);
+  }
+
+  const wrapper = path.join(os.homedir(), '.claude', 'gm-tools', 'plugkit-wasm-wrapper.js');
+  if (!fs.existsSync(wrapper)) {
+    logEvent('supervisor.wrapper-missing', { wrapper, severity: 'critical' });
+    writeSupervisorStatus('error', { error: 'wrapper-missing' });
+    process.exit(3);
+  }
+
+  let runtime = process.env.PLUGKIT_RUNTIME || 'bun';
+  let cmd = runtime;
+  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 (_) {}
+  try {
+    if (logFd !== null) fs.writeSync(logFd, `\n--- watcher spawn ${new Date().toISOString()} supervisor=${process.pid} reason=${bootReason} ---\n`);
+  } catch (_) {}
+
+  const child = spawn(cmd, args, {
+    detached: false,
+    stdio: ['ignore', logFd || 'ignore', logFd || 'ignore'],
+    windowsHide: true,
+    env: {
+      ...process.env,
+      CLAUDE_PROJECT_DIR: projectDir,
+      PLUGKIT_BOOT_REASON: bootReason,
+      PLUGKIT_SUPERVISOR_PID: String(process.pid),
+    },
+  });
+
+  try { if (logFd !== null) fs.closeSync(logFd); } catch (_) {}
+  currentChildPid = child.pid;
+  currentBootReason = bootReason;
+  writeSupervisorStatus('watching', { watcher_pid: child.pid, boot_reason: bootReason });
+  logEvent('supervisor.spawned-watcher', { watcher_pid: child.pid, boot_reason: bootReason, runtime: cmd });
+
+  child.on('exit', (code, signal) => {
+    const shutdownReason = readShutdownReason();
+    const reason = shutdownReason && shutdownReason.reason;
+    const idleClean = reason === 'idle';
+    logEvent(idleClean ? 'supervisor.watcher-exited-idle' : 'supervisor.watcher-exited-unexpectedly', {
+      watcher_pid: currentChildPid,
+      exit_code: code,
+      signal,
+      shutdown_reason: reason || null,
+      had_shutdown_reason_file: shutdownReason !== null,
+      severity: idleClean ? 'info' : 'critical',
+      uptime_ms: Date.now() - lastSpawnedAt,
+    });
+    if (idleClean) {
+      writeSupervisorStatus('exited-idle', { watcher_pid: currentChildPid });
+      try { fs.unlinkSync(SUPERVISOR_PATH); } catch (_) {}
+      process.exit(0);
+    }
+    writeSupervisorStatus('restarting', {
+      prior_watcher_pid: currentChildPid,
+      prior_exit_code: code,
+      prior_signal: signal,
+      prior_shutdown_reason: reason || null,
+    });
+    setTimeout(() => spawnWatcher('unplanned-restart-after-exit'), 1500);
+  });
+
+  child.on('error', (err) => {
+    logEvent('supervisor.spawn-error', { error: err.message, severity: 'critical' });
+  });
+}
+
+function checkWatcherHealth() {
+  if (!currentChildPid) return;
+  if (!pidAlive(currentChildPid)) {
+    return;
+  }
+  const status = readStatus();
+  if (!status) {
+    logEvent('supervisor.status-missing', {
+      watcher_pid: currentChildPid,
+      severity: 'warn',
+    });
+    return;
+  }
+  const age = Date.now() - (status.ts || 0);
+  if (age > STATUS_STALE_MS) {
+    logEvent('supervisor.heartbeat-stale', {
+      watcher_pid: currentChildPid,
+      status_pid: status.pid,
+      status_age_ms: age,
+      stale_limit_ms: STATUS_STALE_MS,
+      severity: 'critical',
+    });
+    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
+    if (process.platform === 'win32') {
+      try { spawnSync('taskkill', ['/F', '/T', '/PID', String(currentChildPid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 }); } catch (_) {}
+    }
+  }
+}
+
+process.on('SIGINT', () => {
+  logEvent('supervisor.shutdown', { reason: 'sigint' });
+  writeSupervisorStatus('shutdown', { reason: 'sigint' });
+  if (currentChildPid && pidAlive(currentChildPid)) {
+    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
+  }
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
+  logEvent('supervisor.shutdown', { reason: 'sigterm' });
+  writeSupervisorStatus('shutdown', { reason: 'sigterm' });
+  if (currentChildPid && pidAlive(currentChildPid)) {
+    try { process.kill(currentChildPid, 'SIGTERM'); } catch (_) {}
+  }
+  process.exit(0);
+});
+
+writeSupervisorStatus('starting', {});
+logEvent('supervisor.starting', { spool_dir: spoolDir });
+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.1155",
+  "version": "2.0.1157",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/lib/daemon-bootstrap.js

@@ -120,7 +120,7 @@ function computeIndexDigest(cwd = process.cwd()) {
   }
 }
 
-function writeStatusFile(daemonName, status, sessionId) {
+function writeStatusFile(daemonName, status, sessionId, childPid) {
   try {
     fs.mkdirSync(GM_STATE_DIR, { recursive: true });
     const statusFile = path.join(GM_STATE_DIR, `${daemonName}-status.json`);
@@ -129,7 +129,8 @@ function writeStatusFile(daemonName, status, sessionId) {
       status,
       sessionId,
       timestamp: new Date().toISOString(),
-      pid: process.pid,
+      pid: Number.isFinite(childPid) ? childPid : process.pid,
+      parent_pid: process.pid,
     };
     fs.writeFileSync(statusFile, JSON.stringify(payload, null, 2));
     emitDaemonEvent(daemonName, 'info', 'Status written', { file: statusFile });
@@ -220,7 +221,7 @@ async function ensureAcptoapiRunning() {
       });
       child.unref();
       emitDaemonEvent('acptoapi', 'info', 'Daemon spawned', { pid: child.pid, port, sessionId });
-      writeStatusFile('acptoapi', 'spawned', sessionId);
+      writeStatusFile('acptoapi', 'spawned', sessionId, child.pid);
       return { ok: true, message: 'acptoapi spawned', pid: child.pid };
     } catch (spawnErr) {
       emitDaemonEvent('acptoapi', 'warn', 'Spawn failed, fallback to SDK', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1155",
+  "version": "2.0.1157",
   "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.1155"
+    "gm-plugkit": "^2.0.1157"
   },
   "engines": {
     "node": ">=16.0.0"

package/skills/gm-skill/SKILL.md

@@ -20,6 +20,8 @@ If the `instruction` response carries a non-null `update_available`, plugkit dri
 
 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.
+
 ## Boot the spool watcher (first turn only)
 
 Check `.gm/exec-spool/.status.json`. If absent or `ts` > 15s old, boot via the npm package — `bun x gm-plugkit@latest spool` fetches the freshest plugkit (wasm + wrapper), copies them into `~/.claude/gm-tools/`, then enters spool mode: