gm-skill 2.0.2013 → 2.0.2015

package/AGENTS.md

@@ -106,7 +106,7 @@ A task that reduces to read/investigate/report, or a change confined to files th
 
 **Done is plugkit's pronouncement, never the agent's claim**: COMPLETE only when `transition to=COMPLETE` returns COMPLETE phase, on-disk state reflects it. COMPLETE gate (gates.rs) = sole arbiter -- refuses on PRD-open, mutables-unresolved, dirty worktree, missing residual-scan marker. Agent drives into gate-allowing state, dispatches, reads response; every alternative is narration.
 
-**Every residual is triaged this turn, never named-and-deferred**: every `git status --porcelain` entry at residual-scan/COMPLETE-attempt triaged now -- (a) commit (real work), (b) managed-gitignore-block (transient runtime emission, e.g. `.gm/witness/`, `.gm/exec-spool/.*-stale.json`), (c) revert (junk). "Pre-existing" = the (a)/(c) outcome, never a stop excuse. `blockedBy: external` admissible only when triage needs unreachable authority; local-tree files always agent-authoritative. Disciplines + new memorize-fire `mem-*.json` committed. Managed block (`# >>> plugkit managed` markers) carries only zero-future-read-value runtime artifacts.
+**Every residual is triaged this turn, never named-and-deferred**: every `git status --porcelain` entry at residual-scan/COMPLETE-attempt triaged now -- (a) commit (real work), (b) managed-gitignore-block (transient runtime emission, e.g. `.gm/witness/`, `.gm/exec-spool/.*-stale.json`), (c) revert (junk). "Pre-existing" = the (a)/(c) outcome, never a stop excuse. Everything is fixable: when triage points outside the local tree, the row's job is the concrete reach action that builds past it (open the PR, script the credential path, replace/drive-directly the broken tool), never a `blockedBy: external` resting state -- `blockedBy` only transiently carries that reach path forward while it is built, and local-tree files are always agent-authoritative to fix now. Disciplines + new memorize-fire `mem-*.json` committed. Managed block (`# >>> plugkit managed` markers) carries only zero-future-read-value runtime artifacts.
 
 **"Every possible" is the load-bearing test, applied to every noun the request names** -- PRD density at PLAN, second-pass corner-case transform: the recall store (`recall: PLAN-phase PRD density rule`).
 

package/gm-plugkit/package.json

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

@@ -2564,6 +2564,9 @@ function makeHostFunctions(instanceRef) {
         const __topNM = modeOpts.match(/topN=(\d+)/);
         const sampleIntervalUs = __intervalM && parseInt(__intervalM[1], 10) > 0 ? parseInt(__intervalM[1], 10) : 100;
         const profileTopNBrowser = __topNM && parseInt(__topNM[1], 10) > 0 ? parseInt(__topNM[1], 10) : 20;
+        const rawUserScript = (screenshotPath || domSelector)
+          ? null
+          : (modeMatch ? modeMatch[3] : evalBody);
         // Real, pre-existing bug fixed here: this block previously called `page.evaluateOnNewDocument`,
         // which is a PUPPETEER method name -- playwriter's `page` object is a real Playwright Page,
         // whose equivalent is `page.addInitScript`. evaluateOnNewDocument does not exist on a
@@ -2772,13 +2775,51 @@ function makeHostFunctions(instanceRef) {
         // A temp .js file has no such length limit -- this sidesteps the Bun bug class entirely rather
         // than working around it script-by-script.
         const scriptFile = path.join(os.tmpdir(), `gm-browser-eval-${process.pid}-${execProfileSeq++}.js`);
-        try {
-          fs.writeFileSync(scriptFile, evalBody, 'utf-8');
-          r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-f', scriptFile], outerTimeoutMs, cwd, sessionId);
-        } finally {
-          try { fs.unlinkSync(scriptFile); } catch (_) {}
-          clearInflight(sessionId);
-          stampBrowserLastUse(cwd, sessionId);
+        // The playwriter relay's attach+eval hop crashes with a UV_HANDLE_CLOSING native
+        // assertion on Windows. When the session already has a live Chrome CDP endpoint
+        // (chromium launched with --remote-debugging-port, recorded in browser-ports.json),
+        // drive that endpoint directly via the proven wrapper/cdp-eval.js helper instead --
+        // it connects over the DevTools websocket and runs the raw user script through
+        // Runtime.evaluate, never spawning the crashing relay. This is gated strictly on a
+        // live CDP port AND a self-contained raw user script (screenshot=/dom= bodies build
+        // page.screenshot/page.evaluate calls that need the Playwright page object cdp-eval.js
+        // does not provide, so rawUserScript is null for those and the playwriter path runs).
+        let usedCdp = false;
+        if (rawUserScript != null) {
+          let cdpPort = null;
+          let cdpWs = null;
+          try {
+            const ent = readJsonFile(browserPortsFile(cwd), {})[sessionId];
+            if (ent && Number.isFinite(ent.port)) { cdpPort = ent.port; cdpWs = ent.wsEndpoint || null; }
+          } catch (_) {}
+          const cdpLive = cdpPort != null && !!fetchJsonSync(`http://127.0.0.1:${cdpPort}/json/version`, 1000);
+          if (cdpLive) {
+            const cdpEvalScript = path.join(os.tmpdir(), `gm-cdp-eval-${process.pid}-${execProfileSeq++}.js`);
+            try {
+              fs.writeFileSync(cdpEvalScript, rawUserScript, 'utf-8');
+              const cfg = JSON.stringify({ port: cdpPort, wsEndpoint: cdpWs, startUrl, scriptFile: cdpEvalScript, resultFile, timeoutMs });
+              r = spawnSync(process.execPath, [path.join(__dirname, 'wrapper', 'cdp-eval.js'), cfg], {
+                encoding: 'utf-8',
+                timeout: outerTimeoutMs,
+                windowsHide: true,
+              });
+              usedCdp = true;
+            } finally {
+              try { fs.unlinkSync(cdpEvalScript); } catch (_) {}
+              clearInflight(sessionId);
+              stampBrowserLastUse(cwd, sessionId);
+            }
+          }
+        }
+        if (!usedCdp) {
+          try {
+            fs.writeFileSync(scriptFile, evalBody, 'utf-8');
+            r = runBrowserRunner(pw, ['-s', pwSessionId, '--timeout', String(timeoutMs), '-f', scriptFile], outerTimeoutMs, cwd, sessionId);
+          } finally {
+            try { fs.unlinkSync(scriptFile); } catch (_) {}
+            clearInflight(sessionId);
+            stampBrowserLastUse(cwd, sessionId);
+          }
         }
         const ok = r.status === 0;
         if (!ok && r.status === null) {

package/gm-plugkit/wrapper/cdp-eval.js

@@ -0,0 +1,123 @@
+import fs from 'fs';
+import http from 'http';
+
+function httpJson(url, timeoutMs) {
+  return new Promise((resolve) => {
+    const req = http.get(url, { timeout: timeoutMs }, (res) => {
+      let body = '';
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => { try { resolve(JSON.parse(body)); } catch (_) { resolve(null); } });
+    });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+  });
+}
+
+async function pickPageTarget(port, startUrl, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const list = await httpJson(`http://127.0.0.1:${port}/json/list`, 2000);
+    if (Array.isArray(list)) {
+      const page = list.find((t) => t.type === 'page' && t.webSocketDebuggerUrl);
+      if (page) return page;
+    }
+    if (startUrl) {
+      const created = await httpJson(`http://127.0.0.1:${port}/json/new?${encodeURIComponent(startUrl)}`, 3000);
+      if (created && created.webSocketDebuggerUrl) return created;
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return null;
+}
+
+function cdpSession(wsUrl, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    let nextId = 1;
+    const pending = new Map();
+    const timer = setTimeout(() => { try { ws.close(); } catch (_) {} reject(new Error('cdp timeout')); }, timeoutMs);
+    ws.addEventListener('open', () => {
+      resolve({
+        send(method, params) {
+          const id = nextId++;
+          return new Promise((res, rej) => {
+            pending.set(id, { res, rej });
+            ws.send(JSON.stringify({ id, method, params: params || {} }));
+          });
+        },
+        close() { clearTimeout(timer); try { ws.close(); } catch (_) {} },
+      });
+    });
+    ws.addEventListener('message', (ev) => {
+      let msg;
+      try { msg = JSON.parse(ev.data); } catch (_) { return; }
+      if (msg.id && pending.has(msg.id)) {
+        const { res, rej } = pending.get(msg.id);
+        pending.delete(msg.id);
+        if (msg.error) rej(new Error(msg.error.message || 'cdp error'));
+        else res(msg.result);
+      }
+    });
+    ws.addEventListener('error', () => { clearTimeout(timer); reject(new Error('cdp websocket error')); });
+  });
+}
+
+// Direct CDP evaluation, replacing the playwriter relay attach+eval that crashes
+// with UV_HANDLE_CLOSING on Windows. Everything up to obtaining Chrome's CDP
+// endpoint is already done by the wrapper (it launches Chrome with
+// --remote-debugging-port and polls /json/version); this drives that endpoint
+// directly over the DevTools websocket, so the crashing relay process is never
+// spawned. Reads {port, startUrl, scriptFile, resultFile, timeoutMs} from argv[2]
+// as JSON, runs the script via Runtime.evaluate (awaitPromise, returnByValue),
+// and writes the returned value to resultFile -- the same result channel the
+// playwriter path used.
+async function main() {
+  const cfg = JSON.parse(process.argv[2]);
+  const { port, startUrl, scriptFile, resultFile, timeoutMs } = cfg;
+  const script = fs.readFileSync(scriptFile, 'utf-8');
+  const target = await pickPageTarget(port, startUrl, Math.min(timeoutMs, 30000));
+  if (!target) {
+    fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: 'no page target on CDP endpoint' }));
+    process.stderr.write('cdp-eval: no page target\n');
+    process.exit(1);
+  }
+  const sess = await cdpSession(target.webSocketDebuggerUrl, timeoutMs);
+  try {
+    await sess.send('Runtime.enable', {});
+    if (startUrl) {
+      await sess.send('Page.enable', {});
+      await sess.send('Page.navigate', { url: startUrl });
+      await new Promise((r) => setTimeout(r, 1200));
+    }
+    // The wrapper's eval body is a function body ending in `return __RET;`.
+    // Wrap it in an async IIFE so Runtime.evaluate resolves the returned value.
+    const wrapped = `(async () => { ${script} })()`;
+    const res = await sess.send('Runtime.evaluate', {
+      expression: wrapped,
+      awaitPromise: true,
+      returnByValue: true,
+      userGesture: true,
+      timeout: timeoutMs,
+    });
+    if (res.exceptionDetails) {
+      const msg = res.exceptionDetails.exception && res.exceptionDetails.exception.description
+        ? res.exceptionDetails.exception.description
+        : (res.exceptionDetails.text || 'evaluate exception');
+      fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: msg }));
+      process.stderr.write(`cdp-eval: exception ${msg}\n`);
+      sess.close();
+      process.exit(1);
+    }
+    const value = res.result && ('value' in res.result) ? res.result.value : null;
+    fs.writeFileSync(resultFile, JSON.stringify(value === undefined ? null : value));
+    sess.close();
+    process.exit(0);
+  } catch (e) {
+    fs.writeFileSync(resultFile, JSON.stringify({ __cdpError: String(e && e.message || e) }));
+    process.stderr.write(`cdp-eval: ${e && e.message || e}\n`);
+    try { sess.close(); } catch (_) {}
+    process.exit(1);
+  }
+}
+
+main();

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.2013",
+  "version": "2.0.2015",
   "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.2013",
+  "version": "2.0.2015",
   "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.md

@@ -94,7 +94,7 @@ If similar symptoms recur (stub-like responses, silent truncation, debug fields
 
 **Windows-specific transient flakiness that is NOT a plugkit/wrapper bug, just retry it:** `bun x <pkg>@<version>` occasionally hangs indefinitely at "Resolving dependencies" with zero further output even with a pinned exact cached version (a known intermittent Bun/Windows dependency-resolution stall, reproducible with plain `bun x playwriter@<version> session list` outside any wrapper). A bare re-dispatch of the exact same body, or a fresh direct CLI retry, has resolved it every time observed. Do not chase this as a code bug -- 2-3 retries is the correct response, same bound as the raw-CLI fragility note below.
 
-**Raw-playwriter-CLI fallback, only if the `browser` verb itself is genuinely down (last resort, rare):** a headed `playwriter session new` (no `--browser headless`) requires a real Chrome + the Playwriter browser extension already paired and connected -- it does NOT auto-launch a visible window in this environment, it times out with "Extension did not connect" / "No connected browsers detected" (use `--direct` with an explicit `--remote-debugging-port`-launched Chrome instead if a visible/headed session is genuinely required, not bare `session new`). Sessions (both plugkit-relayed and raw-CLI) have been observed torn down between consecutive CLI invocations even a few seconds apart ("Session N not found"), and a `UV_HANDLE_CLOSING` native assertion crash in playwriter's own relay process on Windows has recurred multiple times ("Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\\win\\async.c, line 76"), most often right after a `resume()`/`reload()`/session-teardown call -- recover via `playwriter session reset <id>`, or if that also fails, `playwriter session delete <id>` + relaunch. This is upstream Windows-native fragility in playwriter itself, not fixable from inside a `gm` session. Do not burn more than 2-3 retries chasing a single flaky browser witness on Windows -- if the real `browser` verb and raw CLI both fail repeatedly for the same script, record it as a genuine `blockedBy: external` tooling gap on the relevant PRD/mutable row (with what was tried) rather than looping indefinitely.
+**The browser verb drives Chrome directly over CDP -- the playwriter relay is no longer on the eval path.** The `UV_HANDLE_CLOSING` native crash in playwriter's own relay process on Windows ("Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\\win\\async.c, line 76") was resolved by removing the dependency on that relay: the wrapper already launches Chrome with `--remote-debugging-port` and obtains a live DevTools `webSocketDebuggerUrl` (playwriter-free), and `gm-plugkit/wrapper/cdp-eval.js` now runs the script in-page via `Runtime.evaluate` over that websocket directly, so the crashing relay attach+eval is never spawned. This is the standing browser eval path. A flaky browser witness is therefore a real bug to root-cause in the CDP path or the Chrome launch, never a `blockedBy: external` tooling gap -- everything is fixable: if a browser dispatch fails, read the CDP endpoint (`http://127.0.0.1:<port>/json/version`), check the Chrome launch args, and fix the actual failure rather than parking it. There is no accepted "external tooling gap" resolution for the browser verb.
 
 Spool input from PowerShell must be UTF-8 no-BOM (`-Encoding utf8` or `[System.IO.File]::WriteAllText`); UTF-16+BOM causes `spool.body-encoding-recoded`. First-turn body is `{"prompt":"<user request>"}` (derives orient_nouns + recall_hits); later turns may use `{}`. Batch independent dispatches: multiple `prd-add`, `prd-resolve`, `mutable-add`, `recall`+`codesearch`, or inspection `Read` calls in a single tool block. Avoid editing the same file twice in one block; collapse changes into a single Edit.