gm-plugkit 2.0.1634 → 2.0.1636

package/SKILL.md

@@ -34,7 +34,7 @@ Every turn: dispatch `instruction`, read it, follow the imperative, dispatch the
 cat .gm/exec-spool/.status.json 2>/dev/null; echo ---; cat .gm/exec-spool/.turn-summary.json 2>/dev/null; echo ---; date +%s%3N
 ```
 
-`.turn-summary.json` carries `phase`, `last_skill`, `prd_pending`, `last_instruction_ts`, `last_instruction_age_ms`, `long_gap_threshold_ms`, `browser_sessions_alive`, `update_available`, `deviations_30m`, `watcher_uptime_ms`. Age over threshold: your next non-orienting verb is gated, dispatch `instruction` first. `update_available` non-null: eager-upgrade with `bun x gm-plugkit@latest --kill-stale-watchers; bun x gm-plugkit@latest spool` (the spool call blocks until serving), then read `.status.json` to confirm `version`. `deviations_30m` non-zero indicates active drift to investigate before continuing.
+`.turn-summary.json` carries `phase`, `last_skill`, `prd_pending`, `last_instruction_ts`, `last_instruction_age_ms`, `long_gap_threshold_ms`, `browser_sessions_alive`, `update_available`, `deviations_30m`, `watcher_uptime_ms`. Age over threshold: your next non-orienting verb is gated, dispatch `instruction` first. `update_available` non-null: the watcher auto-updates itself when idle (cache-busted self-respawn to latest), so it usually clears on its own within a few minutes -- keep working. To land it immediately, just re-run the idempotent `bun x gm-plugkit@latest spool` (blocks until serving); only add `--kill-stale-watchers` first if it stays stuck across several turns. `PLUGKIT_NO_AUTO_UPDATE=1` pins the version. `deviations_30m` non-zero indicates active drift to investigate before continuing.
 
 Compare `.status.json` `ts` to the printed epoch: gap > 15000 = dead, boot it. Exception: a future `busy_until` means a long verb (browser/chromium spawn blocks the heartbeat ~15-18s) -- wait, do not boot a second watcher.
 

package/instructions/browser.md

@@ -46,6 +46,8 @@ dom=<css-selector>\n
 
 **One session per run -- reuse it, then close it.** A browser session is keyed by its spool `sessionId`; every dispatch carrying the SAME sessionId reuses the SAME chromium. A DIFFERENT sessionId opens its OWN chromium -- so a run that invents `probe`/`w2`/`w3`/... names leaks one browser per name. Pick one sessionId, use it for every dispatch, and end with `session close` so nothing is left open; the eval envelope carries a `multi_session_warning` the moment a second distinct session opens. The idle reaper (closes sessions unused past the idle window) and the OS-orphan reaper (kills managed chromiums no live session owns, sparing in-use ones and your own Chrome) are backstops for crashes, not a license to leave sessions open -- close yours.
 
+**The session closes when YOU expect it to, not under you.** A session stays open across turns and think-gaps -- the idle window is generous (15 min of no use), measured from the END of your last dispatch, so a long read or a slow eval never shortens it. A dispatch in flight is never closed mid-run: the idle reaper and the orphan reaper both skip a session while its eval is executing, and a just-launched browser has a grace period before any reaper can touch it. An explicit `session close` is immediate. If the idle/orphan backstop did close a session and you dispatch to it again, it transparently re-launches and the envelope carries `session_relaunched: true` with a `relaunch_note` -- your in-page `window.*` state was reset, so re-establish it; you are told, never silently surprised.
+
 ## Envelope
 
 `{ok, stdout, stderr, exit_code, session_id?, navigation_requested, landed_on_blank?, hint?, multi_session_warning?}`. `stdout` = stringified eval result; `stderr` = page errors + launch diagnostics; `exit_code` non-zero = the dispatch did not land -- read `stderr` and re-dispatch, never blind. `navigation_requested` reflects whether the dispatch carried a `url=`/bare-URL navigation; `landed_on_blank: true` with a `hint` means the expression ran against `about:blank` -- prefix `url=<target>` and re-dispatch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1634",
+  "version": "2.0.1636",
   "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/plugkit-wasm-wrapper.js

@@ -308,7 +308,7 @@ function injectUpdateWarning(parsed) {
   if (!upd || !upd.installed || !upd.latest || upd.installed === upd.latest) return;
   const target = (parsed.data && typeof parsed.data === 'object') ? parsed.data : parsed;
   target.update_available = { installed: upd.installed, latest: upd.latest, update_url: upd.update_url || null };
-  target.update_warning = `STALE RUNTIME: running plugkit ${upd.installed} but ${upd.latest} is published and not yet running. Restart onto the new version now: bun x gm-plugkit@latest --kill-stale-watchers; bun x gm-plugkit@latest spool. This warning repeats every turn until the running version catches up.`;
+  target.update_warning = `STALE RUNTIME: running plugkit ${upd.installed} but ${upd.latest} is published. The watcher auto-updates when idle (cache-busted self-respawn to latest), so this usually clears on its own within a few minutes; just keep working. If it persists, re-run the idempotent boot to land latest now: bun x gm-plugkit@latest spool (add --kill-stale-watchers first only if it stays stuck). Set PLUGKIT_NO_AUTO_UPDATE=1 to pin. This warning repeats until the running version catches up.`;
 }
 
 function mergeAutoRecallIntoInstructionResponse(resultStr, autoRecall) {
@@ -874,6 +874,39 @@ function reapOrphanBrowserSessions(pw, cwd, claudeSessionId, reason) {
 }
 
 const __openedSessionIds = new Set();
+const __idleClosedSessions = new Set();
+const __inflightDispatch = new Map();
+const __launchingPids = new Map();
+const INFLIGHT_MAX_MS = 130000;
+const LAUNCH_GRACE_MS = 30000;
+function markInflight(sessionId, pid) {
+  __inflightDispatch.set(sessionId, { pid: pid || null, ts: Date.now() });
+}
+function clearInflight(sessionId) {
+  __inflightDispatch.delete(sessionId);
+}
+function inflightPids() {
+  const now = Date.now();
+  const pids = new Set();
+  const sids = new Set();
+  for (const [sid, v] of __inflightDispatch) {
+    if (now - v.ts > INFLIGHT_MAX_MS) { __inflightDispatch.delete(sid); continue; }
+    sids.add(sid);
+    if (Number.isFinite(v.pid)) pids.add(v.pid);
+  }
+  return { pids, sids };
+}
+function markLaunching(pid) { if (Number.isFinite(pid)) __launchingPids.set(pid, Date.now()); }
+function clearLaunching(pid) { __launchingPids.delete(pid); }
+function launchingPidsFresh() {
+  const now = Date.now();
+  const pids = new Set();
+  for (const [pid, ts] of __launchingPids) {
+    if (now - ts > LAUNCH_GRACE_MS) { __launchingPids.delete(pid); continue; }
+    pids.add(pid);
+  }
+  return pids;
+}
 function enumerateManagedChromiums(profileRootMarker) {
   const marker = String(profileRootMarker || '').toLowerCase().replace(/\\/g, '/');
   const out = [];
@@ -918,9 +951,11 @@ function reapOrphanChromiums(cwd, reason) {
     for (const ent of Object.values(ports)) {
       if (ent && Number.isFinite(ent.pid) && isProcessAliveSync(ent.pid)) livePids.add(ent.pid);
     }
+    const { pids: protectedInflight } = inflightPids();
+    const launching = launchingPidsFresh();
     let reaped = 0;
     for (const { pid } of procs) {
-      if (livePids.has(pid)) continue;
+      if (livePids.has(pid) || protectedInflight.has(pid) || launching.has(pid)) continue;
       try { killPidQuiet(pid); reaped++; logEvent('plugkit', 'browser.os-orphan-reaped', { pid, reason: reason || 'sweep' }); } catch (_) {}
     }
     return { reaped };
@@ -1348,6 +1383,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
     logEvent('plugkit', 'browser.start', { profileDir });
     ({ pid: browserPid, port, wsEndpoint } = startManagedBrowser(pw, profileDir));
   }
+  markLaunching(browserPid);
   const r = runBrowserRunner(pw, ['session', 'new', '--direct', wsEndpoint], 30000, cwd, claudeSessionId);
   if (!r || r.status !== 0) {
     const errTxt = scrubBrowserRunnerText((r && (r.stderr || r.stdout)) || 'unknown');
@@ -1363,6 +1399,7 @@ function getOrCreateBrowserSession(cwd, claudeSessionId, pw) {
   sessions[claudeSessionId] = [pwSessionId];
   writeJsonFile(portsFile, ports);
   writeJsonFile(sessionsFile, sessions);
+  clearLaunching(browserPid);
   if (!__openedSessionIds.has(claudeSessionId) && __openedSessionIds.size >= 1) {
     logEvent('hook', 'deviation.browser-multi-session', { sid: claudeSessionId, already_open: Array.from(__openedSessionIds), reason: 'a 2nd distinct browser sessionId launched its own chromium this run -- reuse one session per run and close it when done' });
   }
@@ -2281,8 +2318,13 @@ function makeHostFunctions(instanceRef) {
           });
         }
 
+        const wasIdleClosed = __idleClosedSessions.has(sessionId);
         const pwSessionId = getOrCreateBrowserSession(cwd, sessionId, pw);
+        const curPid = (() => { try { const e = readJsonFile(browserPortsFile(cwd), {})[sessionId]; return e && e.pid; } catch (_) { return null; } })();
+        const wasRelaunched = wasIdleClosed;
+        __idleClosedSessions.delete(sessionId);
         stampBrowserLastUse(cwd, sessionId);
+        markInflight(sessionId, curPid);
         let evalBody = body;
         let timeoutMs = 120000;
         const timeoutMatch = body.match(/^timeout=(\d+)\s*\n([\s\S]*)$/);
@@ -2409,7 +2451,13 @@ function makeHostFunctions(instanceRef) {
           evalBody = `const __RET=await (async()=>{${evalBody}})();\n` + emitResult + `return __RET;`;
         }
         const outerTimeoutMs = Math.min(timeoutMs + 6000, 126000);
-        const r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-e', evalBody], outerTimeoutMs, cwd, sessionId);
+        let r;
+        try {
+          r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-e', evalBody], outerTimeoutMs, cwd, sessionId);
+        } finally {
+          clearInflight(sessionId);
+          stampBrowserLastUse(cwd, sessionId);
+        }
         const ok = r.status === 0;
         if (!ok && r.status === null) {
           logEvent('plugkit', 'browser.runner-timeout', { session_id: pwSessionId, timeout_ms: timeoutMs, body_bytes: evalBody.length });
@@ -2436,6 +2484,10 @@ function makeHostFunctions(instanceRef) {
           timeout_ms_used: timeoutMs,
         };
         if (resultParsed) envelope.result = parsedResult;
+        if (wasRelaunched) {
+          envelope.session_relaunched = true;
+          envelope.relaunch_note = 'This session was closed (idle/orphan reaper) and re-launched fresh -- any window.* globals or in-page state from earlier dispatches are gone. Re-establish them before relying on them.';
+        }
         envelope.navigation_requested = !!startUrl;
         if (__openedSessionIds.size > 1) {
           envelope.multi_session_warning = `${__openedSessionIds.size} distinct browser sessions opened this run, each its own chromium -- reuse ONE sessionId per run and 'session close' it when done to avoid leaking browsers.`;
@@ -2824,6 +2876,7 @@ async function runSpoolWatcher(instance, spoolDir) {
       }
       try { fs.unlinkSync(portsFile); } catch (_) {}
       try { fs.unlinkSync(sessionsFile); } catch (_) {}
+      try { __inflightDispatch.clear(); __launchingPids.clear(); reapOrphanChromiums(process.cwd(), `teardown:${reason}`); } catch (_) {}
     } catch (_) {}
 
     try {
@@ -2851,6 +2904,10 @@ async function runSpoolWatcher(instance, spoolDir) {
   let _selfStaleProbeErrorLogged = false;
   function probeGmPlugkitSelfStale() {
     try {
+      if (process.env.PLUGKIT_NO_AUTO_UPDATE === '1') return;
+      const { sids: _ifSids } = (typeof inflightPids === 'function') ? inflightPids() : { sids: new Set() };
+      if (_ifSids.size > 0) return;
+      if ((Date.now() - lastActivityMs) < 30000) return;
       const ownPkgVersionFile = path.join(GM_TOOLS_ROOT, 'gm-plugkit.version');
       const ownPkgJsonFile = path.join(__dirname, 'package.json');
       let own = null;
@@ -2922,7 +2979,7 @@ async function runSpoolWatcher(instance, spoolDir) {
               try {
                 const cp = _childProcess;
                 const bunPath = process.env.GM_BUN_PATH || 'bun';
-                const bustCache = sameStaleAsBefore || cameFromSelfRespawn;
+                const bustCache = true;
                 if (bustCache) {
                   try { cp.execFileSync(bunPath, ['pm', 'cache', 'rm'], { stdio: 'ignore', timeout: 30000, windowsHide: true }); } catch (_) {}
                   try {
@@ -2949,7 +3006,7 @@ async function runSpoolWatcher(instance, spoolDir) {
                   env: { ...process.env, PLUGKIT_BOOT_REASON: 'self-respawn-from-self-stale' },
                 });
                 child.unref();
-                try { logEvent('plugkit', 'gm-plugkit.self-stale-respawn', { running_version: own, latest_version: latest, cache_busted: bustCache, attempt: (respawnGuard.attempts || 0) + 1 }); } catch (_) {}
+                try { logEvent('plugkit', 'update.auto-applying', { running_version: own, latest_version: latest, cache_busted: bustCache, attempt: (respawnGuard.attempts || 0) + 1, note: 'auto-update: cache-busted self-respawn to latest' }); } catch (_) {}
                 try { fs.writeFileSync(path.join(spoolDir, '.shutdown-reason.json'), JSON.stringify({ reason: 'gm-plugkit-self-stale', ts: Date.now(), pid: process.pid, running_version: own, latest_version: latest })); } catch (_) {}
                 const myPid = process.pid;
                 const respawnDeadline = Date.now() + 90000;
@@ -3189,7 +3246,7 @@ async function runSpoolWatcher(instance, spoolDir) {
     }
   }, 60_000);
 
-  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 3 * 60 * 1000;
+  const BROWSER_IDLE_LIMIT_MS = parseInt(process.env.PLUGKIT_BROWSER_IDLE_LIMIT_MS, 10) || 15 * 60 * 1000;
   setInterval(() => {
     try {
       const portsFile = browserPortsFile(process.cwd());
@@ -3197,13 +3254,15 @@ async function runSpoolWatcher(instance, spoolDir) {
       const ports = readJsonFile(portsFile, {});
       const sessions = readJsonFile(sessionsFile, {});
       const now = Date.now();
-      const idle = selectIdleBrowserSessions(ports, now, BROWSER_IDLE_LIMIT_MS);
+      const { sids: inflightSids } = inflightPids();
+      const idle = selectIdleBrowserSessions(ports, now, BROWSER_IDLE_LIMIT_MS).filter((x) => !inflightSids.has(x.sid));
       const idleSids = new Set(idle.map((x) => x.sid));
       let mutated = false;
       for (const { sid, entry, idleMs } of idle) {
         if (Number.isFinite(entry.pid) && isProcessAliveSync(entry.pid)) {
           try { gracefulCloseBrowser(entry, 'browser-idle'); } catch (_) {}
         }
+        try { __idleClosedSessions.add(sid); } catch (_) {}
         delete ports[sid];
         delete sessions[sid];
         mutated = true;