gm-skill 2.0.1624 → 2.0.1626

package/bin/install.js

@@ -7,7 +7,6 @@ const os = require('os');
 const readline = require('readline');
 
 const SKILL_NAME = 'gm';
-const AUTOCOMPACT_WINDOW = 380000;
 
 function out(msg) { process.stdout.write(msg + '\n'); }
 function err(msg) { process.stderr.write(msg + '\n'); }
@@ -102,8 +101,6 @@ function applyClaudeSettings(home) {
     const backup = settingsPath + '.bak';
     try { fs.copyFileSync(settingsPath, backup); err(`existing settings.json was malformed; backed up to ${backup}`); } catch (_) {}
   }
-  obj.autoCompactEnabled = true;
-  obj.autoCompactWindow = AUTOCOMPACT_WINDOW;
   obj.effortLevel = 'low';
   obj.alwaysThinkingEnabled = false;
   fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
@@ -116,8 +113,6 @@ function applyClaudeSettings(home) {
 
 const SETTINGS_EXPLAINER = [
   'Claude Code settings applied:',
-  '  autoCompactEnabled = true      keep long sessions coherent by auto-compacting context',
-  `  autoCompactWindow  = ${AUTOCOMPACT_WINDOW}  absolute token count (38% of a 1M window), not a percentage`,
   "  effortLevel        = low       thinking effort lowered",
   '  alwaysThinkingEnabled = false  explicit thinking turned off',
   '',
@@ -136,7 +131,7 @@ async function offerClaudeSettings(home) {
   try {
     out('');
     out('Claude Code detected. gm works best with reasoning-in-code rather than hidden thinking tokens.');
-    out('Offer to set: autoCompactEnabled=true, autoCompactWindow=' + AUTOCOMPACT_WINDOW + ', effortLevel=low, alwaysThinkingEnabled=false.');
+    out('Offer to set: effortLevel=low, alwaysThinkingEnabled=false.');
     const ans = (await ask(rl, 'Apply these Claude Code settings now? [y/N] ')).trim().toLowerCase();
     if (ans === 'y' || ans === 'yes') {
       const r = applyClaudeSettings(home);

package/gm-plugkit/package.json

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

@@ -163,7 +163,6 @@ function dispatchVerbToWasmInternal(instance, verb, body) {
   if (!dispatch) return null;
   const verbBytes = new TextEncoder().encode(verb);
   const bodyBytes = new TextEncoder().encode(body || '');
-  // writeWasmInput re-reads memory.buffer fresh after each alloc (avoids the detached-buffer write bug).
   let verbPtr = 0, bodyPtr = 0;
   try { verbPtr = writeWasmInput(instance, verbBytes, `dispatch_verb(${verb}).verb`); }
   catch (e) { throw new Error(`wasm-alloc-failed for dispatch_verb(${verb}): ${e.message}`); }
@@ -1054,10 +1053,6 @@ function startManagedBrowser(pw, profileDir) {
     '--disable-default-apps',
     '--disable-gpu-process-crash-limit',
   ];
-  // In containers where unprivileged user namespaces are disabled, Chromium's
-  // sandbox cannot initialize and the remote-debugging port never binds (the CDP
-  // "did not become ready" failure). Opt in to running without the sandbox (plus
-  // the small-/dev/shm workaround common in containers) via GM_BROWSER_NO_SANDBOX=1.
   if (process.env.GM_BROWSER_NO_SANDBOX === '1') {
     args.push('--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage');
   }
@@ -1375,33 +1370,18 @@ function guardWasmRange(buffer, ptr, len, where) {
   }
 }
 
-// Decode a packed (ptr,len) i64 dispatch result into a JS string, the ONE correct way.
-// Two bugs this consolidates (they only surface once the wasm memory grows past a threshold --
-// e.g. a large .gm state file -> a big plugkit_alloc -> the memory grows past ~2GB / the linear
-// memory is re-grown mid-dispatch):
-//   1. SIGNED i64 result. dispatch_verb returns an i64; a high bit set (large ptr or a packed
-//      len in the top 32 bits) makes `result` a NEGATIVE BigInt. `result >> 32n` on a negative
-//      BigInt arithmetic-shifts in sign bits -> a garbage/negative len, and the low-word mask can
-//      misread too. Normalize to unsigned 64-bit FIRST: BigInt.asUintN(64, result).
-//   2. DETACHED buffer. `instance.exports.memory.buffer` captured before plugkit_alloc/dispatch is
-//      a STALE ArrayBuffer once the wasm linear memory grows (the old buffer detaches). Reading the
-//      result against it throws 'Start offset N is outside the bounds of the buffer'. Always re-read
-//      instance.exports.memory.buffer FRESH at the moment of the view, never reuse a captured one.
 function decodeWasmResult(instance, result, where) {
-  const u = BigInt.asUintN(64, BigInt(result));   // (1) normalize the i64 to unsigned before splitting
+  const u = BigInt.asUintN(64, BigInt(result));
   const ptr = Number(u & 0xffffffffn);
   const len = Number(u >> 32n);
   if (ptr === 0 || len === 0) return '';
-  const buffer = instance.exports.memory.buffer;  // (2) FRESH buffer (post-grow), never a stale capture
+  const buffer = instance.exports.memory.buffer;
   guardWasmRange(buffer, ptr, len, where);
   const out = new TextDecoder().decode(new Uint8Array(buffer, ptr, len));
   try { instance.exports.plugkit_free(ptr, len); } catch (_) {}
   return out;
 }
 
-// Write input bytes into wasm memory, re-reading memory.buffer FRESH after the alloc so a memory
-// grow during plugkit_alloc never leaves us writing into a detached buffer (the write-side half of
-// the detached-buffer bug). Returns the ptr (caller frees) or throws on alloc failure.
 function writeWasmInput(instance, bytes, where) {
   if (bytes.length === 0) return 0;
   const ptr = instance.exports.plugkit_alloc(bytes.length);
@@ -2151,8 +2131,12 @@ function makeHostFunctions(instanceRef) {
         const modeMatch = evalBody.match(/^(capture|profile)[ \t]*\n([\s\S]*)$/);
         const debugSetup = `const __logs=[],__errs=[],__net=[];\n`
           + `try{page.on('console',m=>{try{__logs.push({type:m.type(),text:m.text()});}catch(_){}});`
-          + `page.on('pageerror',e=>{try{__errs.push(String(e&&e.message||e));}catch(_){}});`
-          + `page.on('requestfinished',r=>{try{const t=r.timing();__net.push({url:String(r.url()).slice(0,120),dur_ms:Math.round(t.responseEnd),ttfb_ms:Math.round(t.responseStart)});}catch(_){}});}catch(_){}\n`;
+          + `page.on('pageerror',e=>{try{__errs.push({type:'pageerror',msg:String(e&&e.message||e)});}catch(_){}});`
+          + `page.on('error',e=>{try{__errs.push({type:'uncaught',msg:String(e&&e.message||e),stack:String(e&&e.stack||'')});}catch(_){}});`
+          + `page.on('requestfinished',r=>{try{const t=r.timing();__net.push({url:String(r.url()).slice(0,120),dur_ms:Math.round(t.responseEnd),ttfb_ms:Math.round(t.responseStart)});}catch(_){}});`
+          + `page.on('requestfailed',r=>{try{const err=r.failure();__errs.push({type:'fetch',msg:String(err&&err.errorText||'request failed'),url:String(r.url()).slice(0,120)});}catch(_){}});`
+          + `page.evaluateOnNewDocument(()=>{window.__gmErrors=[];window.onerror=(msg,src,line,col,err)=>{try{window.__gmErrors.push({type:'error',msg:String(msg),src:String(src).slice(0,80),line,col,stack:String(err&&err.stack||'')});}catch(_){};return false;};window.onunhandledrejection=(e)=>{try{window.__gmErrors.push({type:'unhandledRejection',msg:String(e.reason&&e.reason.message||e.reason),stack:String(e.reason&&e.reason.stack||'')});}catch(_){}};});`
+          + `}catch(_){}\n`;
         const perfRead = `let __perf=null;try{__perf=await page.evaluate(()=>{const n=performance.getEntriesByType('navigation')[0];return n?{load_ms:Math.round(n.loadEventEnd||0),dcl_ms:Math.round(n.domContentLoadedEventEnd||0),resources:performance.getEntriesByType('resource').length,now:Math.round(performance.now())}:null;});}catch(_){}\n`;
         const blankProbe = startUrl ? '' : `try{const __u=page.url();if(__u==='about:blank'||__u===''){console.error('__GM_BLANK__');}}catch(_){}\n`;
         if (modeMatch && modeMatch[1] === 'profile') {
@@ -2162,18 +2146,22 @@ function makeHostFunctions(instanceRef) {
             + `let __profile=null,__profileError=null;\n`
             + `let __cdp=null;\n`
             + `try{__cdp=await page.context().newCDPSession(page);await __cdp.send('Profiler.enable');await __cdp.send('Profiler.setSamplingInterval',{interval:${intervalUs}});await __cdp.send('Profiler.start');}catch(e){__profileError=String(e&&e.message||e);__cdp=null;}\n`
-            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}${userScript}\n})();\n`
+            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}try{${userScript}}catch(e){__errs.push({type:'exec',msg:String(e&&e.message||e),stack:String(e&&e.stack||'')});throw e;}\n})();\n`
             + `if(__cdp){try{const __r=await __cdp.send('Profiler.stop');__profile=__r&&__r.profile||null;}catch(e){__profileError=String(e&&e.message||e);}}\n`
+            + `const __wmErrors=await page.evaluate(()=>window.__gmErrors||[]);\n`
             + perfRead
             + AGGREGATE_CPU_PROFILE_SRC + `\n`
             + `const __agg = __profile ? aggregateCpuProfile(__profile) : {timeframe:null,culprits:[]};\n`
-            + `return {result:__result,profile:__agg,profile_error:__profileError,debug:{console:__logs,pageErrors:__errs,network:__net.slice(0,30),performance:__perf}};`;
+            + `const __allErrors=[...__errs,...__wmErrors];\n`
+            + `return {result:__result,profile:__agg,profile_error:__profileError,debug:{console:__logs,pageErrors:__allErrors,network:__net.slice(0,30),performance:__perf}};`;
         } else if (modeMatch && modeMatch[1] === 'capture') {
           const userScript = modeMatch[2];
           evalBody = debugSetup
-            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}${userScript}\n})();\n`
+            + `const __result = await (async () => {\n${blankProbe}${gotoPrefix}try{${userScript}}catch(e){__errs.push({type:'exec',msg:String(e&&e.message||e),stack:String(e&&e.stack||'')});throw e;}\n})();\n`
+            + `const __wmErrors=await page.evaluate(()=>window.__gmErrors||[]);\n`
             + perfRead
-            + `return {result:__result,debug:{console:__logs,pageErrors:__errs,network:__net.slice(0,30),performance:__perf}};`;
+            + `const __allErrors=[...__errs,...__wmErrors];\n`
+            + `return {result:__result,debug:{console:__logs,pageErrors:__allErrors,network:__net.slice(0,30),performance:__perf}};`;
         } else if (startUrl) {
           evalBody = `${gotoPrefix}${evalBody}`;
         } else if (blankProbe) {
@@ -3275,7 +3263,6 @@ async function runSpoolWatcher(instance, spoolDir) {
         }
       }
 
-      // writeWasmInput re-reads memory.buffer fresh after each alloc (detached-buffer write fix).
       const verbPtr = writeWasmInput(instance, verbBytes, `spool-dispatch:${verb}.verb`);
       const bodyPtr = writeWasmInput(instance, bodyBytes, `spool-dispatch:${verb}.body`);
 
@@ -3283,8 +3270,6 @@ async function runSpoolWatcher(instance, spoolDir) {
       const result = dispatch(verbPtr, verbBytes.length, bodyPtr, bodyBytes.length);
       clearVerbActive();
 
-      // decodeWasmResult normalizes the i64 (BigInt.asUintN), re-reads the buffer FRESH (post-grow),
-      // guards the range, AND frees the result ptr -- so the (ptr,len) free below is dropped.
       let resultStr = decodeWasmResult(instance, result, `spool-dispatch:${verb}`);
 
       if (autoRecallPayload) {
@@ -3338,7 +3323,6 @@ async function runSpoolWatcher(instance, spoolDir) {
 
       try { instance.exports.plugkit_free(verbPtr, verbBytes.length); } catch (_) {}
       try { instance.exports.plugkit_free(bodyPtr, bodyBytes.length); } catch (_) {}
-      // (the result ptr is freed inside decodeWasmResult above)
 
       try { if (fs.existsSync(filePath)) fs.unlinkSync(filePath); } catch (_) {}
       unmarkProcessed(key);

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1624",
+  "version": "2.0.1626",
   "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.1624",
+  "version": "2.0.1626",
   "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",
@@ -57,7 +57,9 @@
     "gm.json"
   ],
   "dependencies": {
-    "gm-plugkit": "^2.0.1310"
+    "gm-plugkit": "^2.0.1310",
+    "gmsniff": "^1.0.0",
+    "ccsniff": "^1.1.0"
   },
   "engines": {
     "node": ">=16.0.0"