gm-skill 2.0.1987 → 2.0.1989

package/bin/plugkit-slim.wasm.sha256

@@ -0,0 +1 @@
+44fe1ce8f27bc716b366b881d2ece7529487cec1ac1398bd4f8f097c3c291020  plugkit-slim.wasm

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.913
+0.1.914

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-b6977bece035efbc707d35e6c934e67983be885b7d254dcf18bbbfce6f0909ee  plugkit.wasm
+b805b74d1ef2e73fc4b246987ab01a879d7de20063504083a38163163b5ed879  plugkit.wasm

package/gm-plugkit/bootstrap.js

@@ -223,6 +223,26 @@ function gmToolsDir() {
   return primary;
 }
 
+// Slim-artifact eligibility: plugkit-core's embed.rs probes host_vec_embed
+// before ever loading its wasm-embedded safetensors fallback (see
+// rs-plugkit/crates/plugkit-core/src/embed.rs::init_ctx) -- a slim build
+// (feature=slim, no embedded weights at all) is only safe to fetch on a host
+// that actually answers host_vec_embed for real. plugkit-wasm-wrapper.js
+// wires that answer through gm-runner's native candle path
+// (hostEmbedViaGmRunner) or agentplug-runner's shared daemon, both gated on
+// one of these two binaries existing under ~/.gm-tools -- mirrors that same
+// on-disk presence check here so bootstrap-time artifact selection and
+// runtime embed-delegation eligibility never disagree. Absence of both means
+// no host_vec_embed answer will ever come, so fetching fat (which carries its
+// own wasm-side embedding fallback) is the only safe choice.
+function hasNativeEmbedRunner() {
+  const dir = gmToolsDir();
+  const names = process.platform === 'win32'
+    ? ['gm-runner.exe', 'agentplug-runner.exe']
+    : ['gm-runner', 'agentplug-runner'];
+  return names.some(n => { try { return fs.existsSync(path.join(dir, n)); } catch (_) { return false; } });
+}
+
 // Root a project-dir resolution at the git COMMON dir, not the raw cwd/
 // CLAUDE_PROJECT_DIR -- a worktree (e.g. Workflow's isolation:'worktree'
 // agents, each `git worktree add`-ing a fresh physical directory) shares the
@@ -265,8 +285,26 @@ function readVersionFile() {
 function readShaManifest() {
   const p = path.join(wrapperDir, 'plugkit.sha256');
   if (!fs.existsSync(p)) return null;
+  const raw = fs.readFileSync(p, 'utf8');
+  // Two real formats seen in the wild for this file: the checked-in local
+  // gm-plugkit/plugkit.sha256 is a JSON manifest ({"plugkit.wasm":"<sha>"}),
+  // written by the version-bump automation; a GitHub-release .sha256 sidecar
+  // (fetched directly from plugkit-bin releases) is a standard sha256sum-format
+  // line ("<hash>  <filename>"). Try JSON first since that's this file's own
+  // real on-disk shape -- the sha256sum-line regex never matched it, silently
+  // returning {} and skipping verification on every bootstrap call.
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') {
+      const out = {};
+      for (const [name, sha] of Object.entries(parsed)) {
+        if (typeof sha === 'string') out[name] = sha.toLowerCase();
+      }
+      return out;
+    }
+  } catch (_) { /* not JSON, fall through to sha256sum-line parsing */ }
   const out = {};
-  for (const line of fs.readFileSync(p, 'utf8').split(/\r?\n/)) {
+  for (const line of raw.split(/\r?\n/)) {
     const m = line.match(/^([0-9a-f]{64})\s+(\S+)\s*$/i);
     if (m) out[m[2]] = m[1].toLowerCase();
   }
@@ -441,14 +479,39 @@ function httpGetBuffer(url, timeoutMs) {
   });
 }
 
-async function downloadFromGithubReleases(destPath, version) {
+// artifactName selects the REMOTE release asset ('plugkit.wasm' fat or
+// 'plugkit-slim.wasm' slim) -- the local destPath filename is unaffected,
+// same convention gm-runner's own download.rs::bootstrap_plugkit_wasm uses
+// (fixed local name, artifact-selected remote source). A slim fetch that 404s
+// (older release predating the slim publish step, or the asset genuinely
+// missing) falls back to fetching fat rather than failing the whole
+// bootstrap -- a host capable of running the slim build is also always a
+// valid fat-build host (fat is a strict superset of slim's capability), so
+// this fallback never produces incorrect behavior, only a larger download.
+async function downloadFromGithubReleases(destPath, version, artifactName) {
+  const name = artifactName || 'plugkit.wasm';
   const base = `https://github.com/AnEntrypoint/plugkit-bin/releases/download/v${version}`;
-  log(`gh-releases download: ${base}/plugkit.wasm`);
-  const buf = await httpGetBuffer(`${base}/plugkit.wasm`, 60000);
-  if (!buf || buf.length < 1024) throw new Error(`gh-releases download too small: ${buf ? buf.length : 0} bytes`);
+  log(`gh-releases download: ${base}/${name}`);
+  let buf;
+  try {
+    buf = await httpGetBuffer(`${base}/${name}`, 60000);
+  } catch (e) {
+    if (name !== 'plugkit.wasm') {
+      log(`gh-releases slim fetch failed (${e.message}); falling back to fat plugkit.wasm`);
+      return downloadFromGithubReleases(destPath, version, 'plugkit.wasm');
+    }
+    throw e;
+  }
+  if (!buf || buf.length < 1024) {
+    if (name !== 'plugkit.wasm') {
+      log(`gh-releases slim download too small (${buf ? buf.length : 0} bytes); falling back to fat plugkit.wasm`);
+      return downloadFromGithubReleases(destPath, version, 'plugkit.wasm');
+    }
+    throw new Error(`gh-releases download too small: ${buf ? buf.length : 0} bytes`);
+  }
   let remoteSha = '';
   try {
-    const shaBuf = await httpGetBuffer(`${base}/plugkit.wasm.sha256`, 10000);
+    const shaBuf = await httpGetBuffer(`${base}/${name}.sha256`, 10000);
     remoteSha = shaBuf.toString('utf-8').trim().split(/\s+/)[0];
   } catch (e) { log(`gh-releases sha fetch failed: ${e.message}`); }
   if (remoteSha) {
@@ -457,7 +520,7 @@ async function downloadFromGithubReleases(destPath, version) {
     log(`gh-releases sha verified ${got.slice(0, 16)}...`);
   }
   fs.writeFileSync(destPath, buf);
-  log(`gh-releases wrote ${buf.length} bytes to ${destPath}`);
+  log(`gh-releases wrote ${buf.length} bytes to ${destPath} (artifact=${name})`);
 }
 
 async function extractNpmPackageWithRetry(destPath, version) {
@@ -625,14 +688,27 @@ async function bootstrap(opts) {
   opts = opts || {};
   const version = readVersionFile();
   const shaManifest = readShaManifest();
+  // Artifact selection: slim (no wasm-embedded safetensors, ~130MB smaller)
+  // only when this host has a native host_vec_embed answerer on disk
+  // (gm-runner or agentplug-runner under ~/.gm-tools -- see
+  // hasNativeEmbedRunner) -- everyone else fetches fat, unchanged from
+  // before this selection logic existed. remoteArtifact is the release-asset
+  // name; the LOCAL cache filename stays 'plugkit.wasm' either way (matching
+  // gm-runner's own download.rs convention) so nothing downstream that reads
+  // the local wasm path needs to know which variant landed. The cache
+  // sub-directory is kept distinct per-kind (v<version> vs v<version>-slim)
+  // so a fat and slim download of the same version never collide under the
+  // same sha/sentinel check.
+  const useSlim = hasNativeEmbedRunner();
+  const remoteArtifact = useSlim ? 'plugkit-slim.wasm' : 'plugkit.wasm';
   const wasmName = 'plugkit.wasm';
-  const expectedSha = shaManifest ? shaManifest[wasmName] : null;
+  const expectedSha = shaManifest ? (shaManifest[remoteArtifact] || (useSlim ? null : shaManifest[wasmName])) : null;
 
   let root = cacheRoot();
   try { ensureDir(root); }
   catch (_) { root = fallbackCacheRoot(); ensureDir(root); }
 
-  const verDir = path.join(root, `v${version}`);
+  const verDir = path.join(root, useSlim ? `v${version}-slim` : `v${version}`);
   ensureDir(verDir);
 
   const finalPath = path.join(verDir, wasmName);
@@ -696,20 +772,38 @@ async function bootstrap(opts) {
         }
       } catch (_) {}
     }
-    try {
-      await extractNpmPackageWithRetry(partialPath, version);
-    } catch (extractErr) {
-      log(`npm-extract failed (${extractErr.message || extractErr}); falling back to GitHub Releases`);
+    if (useSlim) {
+      // The plugkit-wasm npm package only ever ships the fat artifact (see
+      // release.yml's npm-publish step, which cp's release-assets/plugkit.wasm
+      // -- never plugkit-slim.wasm -- into the package). Skip the npm-extract
+      // attempt entirely for a slim fetch and go straight to GitHub Releases,
+      // which is where slim is actually published.
       try {
-        await downloadFromGithubReleases(partialPath, version);
+        await downloadFromGithubReleases(partialPath, version, remoteArtifact);
       } catch (ghErr) {
         writeBootstrapError({
           expected_version: version, cached_version: null,
-          error_phase: 'npm-extract+gh-fallback',
-          error_message: `npm: ${extractErr.message}; gh: ${ghErr.message}`,
+          error_phase: 'gh-releases-slim',
+          error_message: `gh: ${ghErr.message}`,
         });
         throw ghErr;
       }
+    } else {
+      try {
+        await extractNpmPackageWithRetry(partialPath, version);
+      } catch (extractErr) {
+        log(`npm-extract failed (${extractErr.message || extractErr}); falling back to GitHub Releases`);
+        try {
+          await downloadFromGithubReleases(partialPath, version, remoteArtifact);
+        } catch (ghErr) {
+          writeBootstrapError({
+            expected_version: version, cached_version: null,
+            error_phase: 'npm-extract+gh-fallback',
+            error_message: `npm: ${extractErr.message}; gh: ${ghErr.message}`,
+          });
+          throw ghErr;
+        }
+      }
     }
 
     if (expectedSha) {
@@ -740,7 +834,15 @@ async function bootstrap(opts) {
     log(`decision: fetch reason: install-complete (${finalPath})`);
     obsEvent('bootstrap', 'install.done', { path: finalPath, version, kind: 'plugkit-wasm' });
     proactiveKillForNewInstall(version);
-    pruneOldVersions(root, version);
+    // pruneOldVersions keeps only the dir literally named v<keepVersion> --
+    // verDir uses a '-slim' suffix for the slim cache slot (see useSlim
+    // above), so the keep-token passed here must match that same suffix or
+    // pruneOldVersions deletes the directory just populated by THIS run
+    // before copyWasmToGmTools below can read from it (live-witnessed this
+    // session: a real end-to-end bootstrap() run on a native-runner host hit
+    // exactly this -- 'pruned .../v0.1.906-slim' followed by an ENOENT on the
+    // immediately-following copy, because 'v0.1.906' != 'v0.1.906-slim').
+    pruneOldVersions(root, useSlim ? `${version}-slim` : version);
     copyWasmToGmTools(finalPath, version);
     clearBootstrapError();
     return finalPath;

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1987",
+  "version": "2.0.1989",
   "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-slim.wasm.sha256

@@ -0,0 +1 @@
+44fe1ce8f27bc716b366b881d2ece7529487cec1ac1398bd4f8f097c3c291020  plugkit-slim.wasm

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

@@ -1936,6 +1936,10 @@ globalThis.__hostEmbedSync = function __hostEmbedSync(textPtr, textLen, outPtr,
 
 function makeHostFunctions(instanceRef) {
   return {
+    host_cwd: () => {
+      const cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+      return writeWasmStr(instanceRef.value, cwd);
+    },
     host_fs_read: (pathPtr, pathLen) => {
       try {
         const filePath = readWasmStr(instanceRef.value, pathPtr, pathLen);
@@ -4601,6 +4605,17 @@ async function runSpoolWatcher(instance, spoolDir) {
   await new Promise(() => {});
 }
 
+// Slim eligibility mirrors bootstrap.js's own hasNativeEmbedRunner (same
+// on-disk check, duplicated rather than shared because this file is ESM and
+// bootstrap.js is CJS with no shared module between them today) -- a slim
+// fetch here is only correct when a real host_vec_embed answerer
+// (resolveGmRunnerEmbedBin / resolveAgentplugRunnerBin, both already defined
+// above for the runtime embed-delegation path) is present on disk, since a
+// slim wasm has no fallback embedding path of its own.
+function hasNativeEmbedRunnerForSelfHeal() {
+  return !!(resolveGmRunnerEmbedBin() || resolveAgentplugRunnerBin());
+}
+
 async function selfHealFromGithubReleases() {
   return new Promise((resolve, reject) => {
     const fetchJson = (url) => new Promise((res, rej) => {
@@ -4635,10 +4650,30 @@ async function selfHealFromGithubReleases() {
         const version = meta && meta.version;
         if (!version) throw new Error('no version from npm plugkit-wasm');
         const base = `https://github.com/AnEntrypoint/plugkit-bin/releases/download/v${version}`;
-        const [wasm, sha] = await Promise.all([
-          fetchBuf(`${base}/plugkit.wasm`),
-          fetchBuf(`${base}/plugkit.wasm.sha256`).then(b => b.toString('utf-8').trim().split(/\s+/)[0]).catch(() => ''),
-        ]);
+        // Slim only when a real host_vec_embed answerer is present -- see
+        // hasNativeEmbedRunnerForSelfHeal. A slim asset that 404s (older
+        // release predating slim publish) falls back to fat rather than
+        // failing self-heal entirely, since fat is a strict capability
+        // superset and always a safe (if larger) substitute.
+        const wantSlim = hasNativeEmbedRunnerForSelfHeal();
+        let artifactName = wantSlim ? 'plugkit-slim.wasm' : 'plugkit.wasm';
+        let wasm, sha;
+        try {
+          [wasm, sha] = await Promise.all([
+            fetchBuf(`${base}/${artifactName}`),
+            fetchBuf(`${base}/${artifactName}.sha256`).then(b => b.toString('utf-8').trim().split(/\s+/)[0]).catch(() => ''),
+          ]);
+        } catch (e) {
+          if (artifactName !== 'plugkit.wasm') {
+            artifactName = 'plugkit.wasm';
+            [wasm, sha] = await Promise.all([
+              fetchBuf(`${base}/${artifactName}`),
+              fetchBuf(`${base}/${artifactName}.sha256`).then(b => b.toString('utf-8').trim().split(/\s+/)[0]).catch(() => ''),
+            ]);
+          } else {
+            throw e;
+          }
+        }
         if (sha) {
           const got = crypto.createHash('sha256').update(wasm).digest('hex');
           if (got !== sha) throw new Error(`sha mismatch: got ${got}, expected ${sha}`);
@@ -4664,7 +4699,7 @@ async function selfHealFromGithubReleases() {
         if (path.resolve(wrapperSrc) !== path.resolve(wrapperDst) && fs.existsSync(wrapperSrc)) {
           try { fs.copyFileSync(wrapperSrc, wrapperDst); } catch (_) {}
         }
-        resolve({ ok: true, version, sha });
+        resolve({ ok: true, version, sha, artifact: artifactName });
       } catch (e) { reject(e); }
     })();
   });

package/gm-plugkit/plugkit.version

@@ -1 +1 @@
-0.1.913
+0.1.914

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1987",
+  "version": "2.0.1989",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -17,5 +17,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "plugkitVersion": "0.1.913"
+  "plugkitVersion": "0.1.914"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1987",
+  "version": "2.0.1989",
   "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",
@@ -36,6 +36,7 @@
     "bin/plugkit.sha256",
     "bin/plugkit.version",
     "bin/plugkit.wasm.sha256",
+    "bin/plugkit-slim.wasm.sha256",
     "gm-plugkit/bootstrap.js",
     "gm-plugkit/browser-idle.js",
     "gm-plugkit/cli.js",
@@ -47,6 +48,7 @@
     "gm-plugkit/gm-process.js",
     "gm-plugkit/plugkit.version",
     "gm-plugkit/plugkit.sha256",
+    "gm-plugkit/plugkit-slim.wasm.sha256",
     "gm-plugkit/instructions/",
     "gm-plugkit/scripts/",
     "AGENTS.md",