gm-qwen 2.0.796 → 2.0.798

package/bin/bootstrap.js

@@ -32,6 +32,11 @@ function binaryName() {
   return key.startsWith('win32') ? `plugkit-${key}.exe` : `plugkit-${key}`;
 }
 
+function rtkBinaryName() {
+  const key = platformKey();
+  return key.startsWith('win32') ? `rtk-${key}.exe` : `rtk-${key}`;
+}
+
 function cacheRoot() {
   const home = os.homedir();
   if (process.env.PLUGKIT_CACHE_DIR) return process.env.PLUGKIT_CACHE_DIR;
@@ -58,8 +63,8 @@ function readVersionFile(wrapperDir) {
   return fs.readFileSync(p, 'utf8').trim();
 }
 
-function readShaManifest(wrapperDir) {
-  const p = path.join(wrapperDir, 'plugkit.sha256');
+function readShaManifest(wrapperDir, manifestName) {
+  const p = path.join(wrapperDir, manifestName || 'plugkit.sha256');
   if (!fs.existsSync(p)) return null;
   const out = {};
   for (const line of fs.readFileSync(p, 'utf8').split(/\r?\n/)) {
@@ -275,12 +280,63 @@ async function bootstrap(opts) {
     fs.writeFileSync(okSentinel, new Date().toISOString());
     log(`installed ${finalPath}`);
     pruneOldVersions(root, version);
+    // Best-effort rtk fetch: failures here never block plugkit usage
+    try { await bootstrapRtk(verDir, version, wrapperDir, opts.silent); }
+    catch (err) { log(`rtk fetch skipped: ${err.message}`); }
     return finalPath;
   } finally {
     releaseLock(lockPath);
   }
 }
 
+async function bootstrapRtk(verDir, version, wrapperDir, silent) {
+  const rtkName = rtkBinaryName();
+  const rtkPath = path.join(verDir, rtkName);
+  const rtkOk = path.join(verDir, '.rtk-ok');
+  if (fs.existsSync(rtkPath) && fs.existsSync(rtkOk)) {
+    if (!silent) log(`rtk cache hit: ${rtkPath}`);
+    return rtkPath;
+  }
+  const rtkSha = readShaManifest(wrapperDir, 'rtk.sha256');
+  const expected = rtkSha ? rtkSha[rtkName] : null;
+  const tmp = `${rtkPath}.partial`;
+  const url = `https://github.com/${RELEASE_REPO}/releases/download/v${version}/${rtkName}`;
+  await downloadWithRetry(url, tmp);
+  if (expected) {
+    const got = await sha256OfFile(tmp);
+    if (got !== expected) {
+      try { fs.unlinkSync(tmp); } catch (_) {}
+      throw new Error(`rtk sha256 mismatch: expected ${expected}, got ${got}`);
+    }
+  }
+  try { fs.renameSync(tmp, rtkPath); }
+  catch (err) {
+    if (err.code === 'EEXIST' || err.code === 'EPERM') {
+      try { fs.unlinkSync(rtkPath); } catch (_) {}
+      fs.renameSync(tmp, rtkPath);
+    } else throw err;
+  }
+  if (os.platform() !== 'win32') { try { fs.chmodSync(rtkPath, 0o755); } catch (_) {} }
+  fs.writeFileSync(rtkOk, new Date().toISOString());
+  log(`installed ${rtkPath}`);
+  return rtkPath;
+}
+
+function resolveCachedRtk(opts) {
+  opts = opts || {};
+  const wrapperDir = opts.wrapperDir || __dirname;
+  const version = opts.version || readVersionFile(wrapperDir);
+  const root = (() => {
+    try { const r = cacheRoot(); ensureDir(r); return r; }
+    catch (_) { const r = fallbackCacheRoot(); ensureDir(r); return r; }
+  })();
+  const verDir = path.join(root, `v${version}`);
+  const rtkPath = path.join(verDir, rtkBinaryName());
+  const rtkOk = path.join(verDir, '.rtk-ok');
+  if (fs.existsSync(rtkPath) && fs.existsSync(rtkOk)) return rtkPath;
+  return null;
+}
+
 function resolveCachedBinary(opts) {
   opts = opts || {};
   const wrapperDir = opts.wrapperDir || __dirname;
@@ -296,7 +352,7 @@ function resolveCachedBinary(opts) {
   return null;
 }
 
-module.exports = { bootstrap, resolveCachedBinary, platformKey, binaryName, cacheRoot };
+module.exports = { bootstrap, resolveCachedBinary, resolveCachedRtk, platformKey, binaryName, rtkBinaryName, cacheRoot };
 
 if (require.main === module) {
   bootstrap({ silent: false })

package/bin/plugkit.js

@@ -3,10 +3,18 @@
 const { spawn, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const { bootstrap, resolveCachedBinary } = require('./bootstrap');
+const { bootstrap, resolveCachedBinary, resolveCachedRtk } = require('./bootstrap');
 
 const dir = __dirname;
 
+function envWithRtkOnPath() {
+  const rtkPath = resolveCachedRtk({ wrapperDir: dir });
+  if (!rtkPath) return process.env;
+  const rtkDir = path.dirname(rtkPath);
+  const sep = process.platform === 'win32' ? ';' : ':';
+  return { ...process.env, PATH: `${rtkDir}${sep}${process.env.PATH || ''}` };
+}
+
 async function resolveBinary() {
   const cached = resolveCachedBinary({ wrapperDir: dir });
   if (cached) return cached;
@@ -27,18 +35,20 @@ async function main() {
     else process.exit(1);
   }
 
+  const env = envWithRtkOnPath();
+
   if (isHook && !process.stdin.isTTY) {
     const chunks = [];
     process.stdin.on('data', c => chunks.push(c));
     process.stdin.on('end', () => {
-      const child = spawn(bin, args, { stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true });
+      const child = spawn(bin, args, { stdio: ['pipe', 'inherit', 'inherit'], windowsHide: true, env });
       child.stdin.end(Buffer.concat(chunks));
       child.on('close', code => process.exit(code ?? 1));
       child.on('error', () => process.exit(1));
     });
     process.stdin.on('error', () => process.exit(1));
   } else {
-    const result = spawnSync(bin, args, { stdio: 'inherit', windowsHide: true });
+    const result = spawnSync(bin, args, { stdio: 'inherit', windowsHide: true, env });
     process.exit(result.status ?? 1);
   }
 }

package/bin/plugkit.sha256

@@ -1,6 +1,6 @@
-603038716d558efcac3b24e68400b4a2486a2c78e4ced414194c9fbbbbd547da  plugkit-win32-x64.exe
-cca898364d36c545a2d1f0f26b6cc3dd2a6e31b9618637861268ec849c14ca32  plugkit-win32-arm64.exe
-d5c71d0db807d4ce8c1f9e90ff7eb83dbb7660302772e4c7e6c66852ceb80291  plugkit-darwin-x64
-afa78bbe82ee25e1c623f047a89428d3c5b6e6b8791b9f8cf938e155181accce  plugkit-darwin-arm64
-778e584a8eaeedf48c68aa5bbc0b44686a2932375d372d40711ec2436bb3cebe  plugkit-linux-x64
-fde889403b76ec6a4b4672dfc77693a63253b2547a8ecec8b06b278887ceb5b0  plugkit-linux-arm64
+94dbf530ce616160fce13770fc8e6ba139895634a1787a984531f288f1e3359a  plugkit-win32-x64.exe
+5ff80e5f5209e56f7b0483b7491351e620b110530fa6c091b67ad68e0c8aff62  plugkit-win32-arm64.exe
+12feecb6a02413d48862d8ce3cdf8d42249d7980e3b9037051aabcf879628e74  plugkit-darwin-x64
+7ef0cbc8dbb199c0964bc59662d8321251ea402a46417ca024e23f9df9b750a0  plugkit-darwin-arm64
+10e0e1f83e20252bc201dd681437f8b6248689e1238f3187e7cd9d6807a7a52b  plugkit-linux-x64
+bdd907fb31b011297e5f0658cd0746683c55469619c0c31e9730cee6ed86d50f  plugkit-linux-arm64

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.257
+0.1.258

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.796",
+  "version": "2.0.798",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "plugkitVersion": "0.1.257"
+  "plugkitVersion": "0.1.258"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-qwen",
-  "version": "2.0.796",
+  "version": "2.0.798",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/skills/gm/SKILL.md

@@ -41,6 +41,8 @@ Multiple facts → parallel Agent calls in ONE message. End-of-turn: scan for un
 
 ## AUTONOMY — HARD RULE
 
+**USER REQUEST = AUTHORIZATION — HARD RULE.** The user's first message asking for X *is* the approval to do X. Re-asking "want me to do X?", "should I proceed with X?", "which shape of X do you want?" after the user already said "do X" is forced closure dressed as deference — the user already authorized the work and waits while the agent stalls. The PRD is *how* the agent records the authorization, not a second permission gate; the agent writes it and proceeds. Surfacing tradeoffs is allowed *inside* the same chain (one sentence: "going with shape A because Y") so the user can interrupt — never as a stop-and-wait. The bar to legitimately ask before starting is the same bar that applies mid-chain: destructive-irreversible AND not covered by the request, OR genuinely ambiguous *intent* (not "which of two viable approaches"). Defaulting to the deeper / more thorough / cross-repo shape when the user said "deeply integrate" is the obvious read of the request — pick it and execute. Multi-repo scope, build cost, and CI duration are never grounds to re-confirm.
+
 A written PRD is the user's authorization. Once it exists, EXECUTE owns the work to COMPLETE. Resolve every doubt that arises during execution by witnessed probe, by recall, or by re-reading the PRD — never by asking the user. Any question whose answer the agent could obtain itself is a question the agent owes itself, not the user.
 
 **FINISH ALL REMAINING STEPS — HARD RULE**: when a request enumerates or implies multiple work items ("all", "any", "everything", "the rest", "remaining"), or after a covering family is constructed under MAXIMAL COVER, the agent finishes every witnessable item in the same turn. Stopping after one item to ask "which next?" is forbidden — the answer is *all of them*, in one chain, until `.gm/prd.yml` is empty and git is clean and pushed. Mid-chain "should I…", "want me to…", "which would you like…" prompts are forced closure; replace them with the next skill invocation.

package/skills/planning/SKILL.md

@@ -43,6 +43,8 @@ Runs until: .gm/prd.yml empty AND git clean AND all pushes confirmed AND CI gree
 
 ## AUTONOMY — HARD RULE
 
+**USER REQUEST = AUTHORIZATION.** The user's message asking for X is the green light. PLAN's job is to translate that ask into a PRD and start — not to re-confirm. "Want me to do X?", "should I take shape A or B?", "this is multi-repo work, OK to proceed?" after the user said "do X" are all forced closure. When the user surfaces a tradeoff (deep vs light, single-file vs cross-repo), pick the read that matches the obvious meaning of the request — "deeply integrate" means deep, "all platforms" means all — declare the choice in one line ("going with A because Y") and execute. Multi-repo scope, build cost, CI duration, binary-size impact, and "this will take a while" are never grounds to re-confirm. The user already knows; that's why they asked.
+
 PRD written → execute to COMPLETE without asking the user. Doubts that arise during execution are resolved by witnessed probe, by recall, or by re-reading the PRD — never by asking. Any question whose answer is reachable from the agent's tools belongs to the agent, not the user.
 
 Asking is last-resort: destructive-irreversible without PRD coverage, OR user intent irrecoverable from PRD/memory/code/web. Channel: `exec:pause` (renames `prd.yml` → `prd.paused.yml`; question in header). In-conversation asking is last-resort beneath last-resort.