gm-cc 2.0.727 → 2.0.1064

package/bin/plugkit.js

@@ -1,68 +1,110 @@
 #!/usr/bin/env node
 'use strict';
-const { spawn, spawnSync } = require('child_process');
+// Hot path: spawnSync to ~/.claude/gm-tools/plugkit.exe with inherited stdio.
+// Cold path (session-start / prompt-submit OR missing binary): synchronously
+// ensure gm-tools/plugkit{.exe} matches the pinned version, then run hook.
+// Cache-aware: when local matches the pin (sha-checked), zero network calls.
+
+const { spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const { bootstrap, resolveCachedBinary } = require('./bootstrap');
+const os = require('os');
 
-const dir = __dirname;
+const wrapperDir = __dirname;
 
-async function resolveBinary() {
-  const cached = resolveCachedBinary({ wrapperDir: dir });
-  if (cached) return cached;
-  return await bootstrap({ wrapperDir: dir });
+function toolsBin() {
+  const home = process.env.USERPROFILE || process.env.HOME || os.homedir();
+  const exe = process.platform === 'win32' ? 'plugkit.exe' : 'plugkit';
+  return path.join(home, '.claude', 'gm-tools', exe);
 }
 
-async function main() {
-  const args = process.argv.slice(2);
-  const isHook = args[0] === 'hook';
-  let bin;
+function sha256OfFileSync(filePath) {
   try {
-    bin = await resolveBinary();
-  } catch (err) {
-    process.stderr.write(`[plugkit] bootstrap failed: ${err.message}\n`);
-    const legacy = legacyFallback();
-    if (legacy) { bin = legacy; }
-    else if (isHook) { process.exit(0); }
-    else process.exit(1);
-  }
+    const crypto = require('crypto');
+    const h = crypto.createHash('sha256');
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const buf = Buffer.alloc(1 << 20);
+      let n;
+      while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0) h.update(buf.subarray(0, n));
+    } finally { fs.closeSync(fd); }
+    return h.digest('hex');
+  } catch (_) { return null; }
+}
 
-  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 });
-      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 });
-    process.exit(result.status ?? 1);
-  }
+function platformAsset() {
+  const p = process.platform;
+  const a = process.arch;
+  if (p === 'win32') return a === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe';
+  if (p === 'darwin') return a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64';
+  return (a === 'arm64' || a === 'aarch64') ? 'plugkit-linux-arm64' : 'plugkit-linux-x64';
 }
 
-function legacyFallback() {
-  const os = require('os');
-  const p = os.platform();
-  const a = os.arch();
-  let candidates = [];
-  if (p === 'win32') {
-    candidates = [
-      path.join(dir, a === 'arm64' ? 'plugkit-win32-arm64.exe' : 'plugkit-win32-x64.exe'),
-      path.join(dir, 'plugkit.exe'),
-    ];
-  } else if (p === 'darwin') {
-    candidates = [path.join(dir, a === 'arm64' ? 'plugkit-darwin-arm64' : 'plugkit-darwin-x64')];
-  } else {
-    candidates = [path.join(dir, (a === 'arm64' || a === 'aarch64') ? 'plugkit-linux-arm64' : 'plugkit-linux-x64')];
-  }
-  for (const c of candidates) if (fs.existsSync(c)) return c;
+function readPinnedVersion() {
+  try { return fs.readFileSync(path.join(wrapperDir, 'plugkit.version'), 'utf8').trim(); } catch (_) { return null; }
+}
+
+function readExpectedSha() {
+  try {
+    const manifest = fs.readFileSync(path.join(wrapperDir, 'plugkit.sha256'), 'utf8');
+    const asset = platformAsset();
+    for (const line of manifest.split(/\r?\n/)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 2 && parts[parts.length - 1].replace(/^\*/, '') === asset) {
+        return parts[0].toLowerCase();
+      }
+    }
+  } catch (_) {}
   return null;
 }
 
-main().catch(err => {
-  process.stderr.write(`[plugkit] fatal: ${err.message}\n`);
-  process.exit(1);
-});
+// Returns true if gm-tools binary matches pinned version by sha. Fast: no network.
+function isReady() {
+  const bin = toolsBin();
+  if (!fs.existsSync(bin)) return false;
+  const expected = readExpectedSha();
+  if (!expected) return true; // no manifest to compare against — trust existence
+  const actual = sha256OfFileSync(bin);
+  return actual && actual.toLowerCase() === expected;
+}
+
+// Synchronously run bootstrap.js in a child node. Blocks until install finishes
+// (or fails). Bootstrap itself is cache-aware: re-download only when sha differs
+// from manifest. Wraps stdio:inherit so the user sees progress.
+function ensureReady(silent) {
+  if (isReady()) return true;
+  const bootstrap = path.join(wrapperDir, 'bootstrap.js');
+  const r = spawnSync(process.execPath, [bootstrap], {
+    stdio: silent ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'inherit', 'inherit'],
+    windowsHide: true,
+  });
+  return r.status === 0 && isReady();
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const isHook = args[0] === 'hook';
+  const hookSubcmd = isHook ? (args[1] || '') : '';
+
+  // Synchronous readiness check on these hooks. Hot path: isReady() is sha-match
+  // against pinned manifest, returns true in <50ms with no network.
+  const blocksUntilReady = hookSubcmd === 'session-start' || hookSubcmd === 'prompt-submit';
+
+  if (blocksUntilReady) {
+    if (!ensureReady(false)) {
+      process.stderr.write('[plugkit] bootstrap failed; aborting hook\n');
+      process.exit(1);
+    }
+  } else if (!fs.existsSync(toolsBin())) {
+    // For non-blocking hooks (pre-tool-use, post-tool-use, stop, etc.): if the
+    // binary doesn't exist yet, exit cleanly — session-start will populate it.
+    if (isHook) process.exit(0);
+    process.exit(1);
+  }
+
+  const bin = toolsBin();
+  const r = spawnSync(bin, args, { stdio: 'inherit', windowsHide: true });
+  process.exit(r.status ?? 1);
+}
+
+main();

package/bin/plugkit.sha256

@@ -1,6 +1,6 @@
-9dbd63a59e435a3a8cb8a1b89344ecfa4b4865bdf81ec5a3aa53202645f39b01  plugkit-win32-x64.exe
-18f37964c80c20fe7adaeef4c6168b331d8d23a94ff369d9807f0847cc16c757  plugkit-win32-arm64.exe
-2cd123dd7704bd823d0c655ecb815afb155c8de2b5dafaadd475864af676a72c  plugkit-darwin-x64
-df98f857def381b366b6346b613bbd4753b62557c374b5768aee9183f52a3dd0  plugkit-darwin-arm64
-fcfdbba8a28458da1a8937670d5173f774ec6fe6bcd5b820c0bce5ae8d785660  plugkit-linux-x64
-2b6f8a8c9316f7bb1378752d61928575d4f0fcc739daab7376af66ed1b65d82f  plugkit-linux-arm64
+e5569efe81e4ef06c8349678253ca2845571495e619babb0a79be9268ea83c2a  plugkit-win32-x64.exe
+ce2f09f8ea0dd522345a9d9c3e5b04ba44bc37b2046d311d7ff1737f1b3fbf1a  plugkit-win32-arm64.exe
+a1a1d376986551828e5a39e4ae931accf66f00663aceac1439b2778cb4fffd27  plugkit-darwin-x64
+7c36d730edab5cddf678211146ca670c9ce1def17d8b454234ce4bc04a4d7e85  plugkit-darwin-arm64
+c9db60a399caf53c490dc08705713c7d83a1f62db057585a3950d64ab8fa449a  plugkit-linux-x64
+b9ebabaace995b1768d1d96ae13ca18a6dc5e2ca65b774fcdd457f069a7d115c  plugkit-linux-arm64

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.241
+0.1.366

package/bin/rtk.sha256

@@ -0,0 +1,6 @@
+53224d66572e937507a8d2877c768e4e6cc3da66aa6f8d0f132afaab2edc2a10  rtk-win32-x64.exe
+dedabc1d89641c60c91f09570353b6270dba4f5d53f8597018a708e515265d53  rtk-win32-arm64.exe
+cf3190554b82c7395948b7a478c78bbe2241549b00777e660deff4cbb9e0c4b6  rtk-darwin-x64
+c815bad459b4eaccc8be4a5d74dba397fdfe7d3716e0b6023b188d2351128b82  rtk-darwin-arm64
+7d60dd5abc15f6d46ffd89b5de7253a067e2a3ef6f1cd8ae5a236eda05a504f4  rtk-linux-x64
+cd5dd78035845eef4b362927c61f61e23925af3c12779131024d8334bad87a6b  rtk-linux-arm64

package/bin/rtk.version

@@ -0,0 +1 @@
+0.40.0

package/hooks/hooks.json

@@ -9,11 +9,6 @@
             "type": "command",
             "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook pre-tool-use",
             "timeout": 3600
-          },
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/pre-tool-use-hook.js",
-            "timeout": 2000
           }
         ]
       }
@@ -24,8 +19,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/post-tool-use-hook.js",
-            "timeout": 3000
+            "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook post-tool-use",
+            "timeout": 35000
           }
         ]
       }
@@ -38,11 +33,6 @@
             "type": "command",
             "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook session-start",
             "timeout": 180000
-          },
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/session-start-hook.js",
-            "timeout": 3000
           }
         ]
       }
@@ -55,40 +45,6 @@
             "type": "command",
             "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook prompt-submit",
             "timeout": 60000
-          },
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/prompt-submit-hook.js",
-            "timeout": 3000
-          }
-        ]
-      }
-    ],
-    "PreCompact": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook pre-compact",
-            "timeout": 30000
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook stop",
-            "timeout": 15000
-          },
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/bin/plugkit.js hook stop-git",
-            "timeout": 210000
           }
         ]
       }

package/hooks/hooks.spec.json

@@ -0,0 +1,48 @@
+{
+  "schemaVersion": 1,
+  "description": "Hook spec for gm Claude Code extension",
+  "envVar": "CLAUDE_PLUGIN_ROOT",
+  "plugkitInvoker": "node",
+  "events": [
+    {
+      "eventKey": "PreToolUse",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "pre-tool-use",
+          "timeout": 3600
+        }
+      ]
+    },
+    {
+      "eventKey": "PostToolUse",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "post-tool-use",
+          "timeout": 35000
+        }
+      ]
+    },
+    {
+      "eventKey": "SessionStart",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "session-start",
+          "timeout": 180000
+        }
+      ]
+    },
+    {
+      "eventKey": "UserPromptSubmit",
+      "commands": [
+        {
+          "kind": "plugkit",
+          "subcommand": "prompt-submit",
+          "timeout": 60000
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-cc",
-  "version": "2.0.727",
+  "version": "2.0.1064",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",
@@ -58,4 +58,4 @@
       "optional": true
     }
   }
-}
+}

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.727",
+  "version": "2.0.1064",
   "description": "State machine agent with hooks, skills, and automated git enforcement",
   "author": {
     "name": "AnEntrypoint",

package/skills/browser/SKILL.md

@@ -1,18 +1,18 @@
 ---
 name: browser
 description: Browser automation via playwriter. Use when user needs to interact with websites, navigate pages, fill forms, click buttons, take screenshots, extract data, test web apps, or automate any browser task.
-allowed-tools: Bash(browser:*), Bash(exec:browser*)
+allowed-tools: Skill
 ---
 
-# Browser Automation
+# Browser automation
 
-Two pathways — never mix:
+Two pathways — never mix in the same Bash call.
 
-**`exec:browser`** — JS against `page`. `page`, `snapshot`, `screenshotWithAccessibilityLabels`, `state` globals available. 15s live window then backgrounds; drains auto on every subsequent plugkit call.
+`exec:browser` runs JS against `page`. Globals available: `page`, `snapshot`, `screenshotWithAccessibilityLabels`, `state`. 15s live window, then backgrounds; output drains automatically on every subsequent plugkit call.
 
-**`browser:` prefix** — playwriter session management. One command per block.
+`browser:` prefix is playwriter session management. One command per block.
 
-## Core Usage
+## Core
 
 ```
 exec:browser
@@ -30,11 +30,11 @@ browser:
 playwriter -s 1 -e 'await page.goto("http://example.com")'
 ```
 
-Session state persists across `browser:` calls. `-e` arg: single quotes outside, double quotes inside JS strings.
+Session state persists across `browser:` calls. `-e` arg uses single quotes outside, double inside JS strings.
 
 ## Timing
 
-Never `await setTimeout(N)` with N > 10000. Use poll loops:
+Never `await setTimeout(N)` with N > 10000. Poll instead.
 
 ```
 exec:browser
@@ -45,11 +45,12 @@ while (!state.done && Date.now() - start < 12000) {
 console.log(state.result)
 ```
 
-"Assertion failed: UV_HANDLE_CLOSING" = backgrounded normally, ignore noise.
+`Assertion failed: UV_HANDLE_CLOSING` is normal background-on-exit noise; ignore it.
 
-## Common Patterns
+## Patterns
 
 Data extraction:
+
 ```
 exec:browser
 const items = await page.$$eval('.title', els => els.map(e => e.textContent))
@@ -57,6 +58,7 @@ console.log(JSON.stringify(items))
 ```
 
 Console monitoring — set listeners first, then poll:
+
 ```
 exec:browser
 state.logs = []
@@ -68,10 +70,10 @@ exec:browser
 console.log(JSON.stringify(state.logs.slice(-20)))
 ```
 
-## Rules
+## Constraints
 
-- One `playwriter` command per `browser:` block
-- Never mix pathways in same Bash call
-- `exec:browser` = plain JS, no shell quoting
-- All browser tasks drain automatically on every plugkit interaction
-- Sessions reap after 5-15min idle; browser cleaned up on session end
+- One playwriter command per `browser:` block
+- `exec:browser` is plain JS, no shell quoting
+- Browser tasks drain automatically on every plugkit interaction
+- Sessions reap after 5–15 min idle; cleaned up on session end
+- Never write standalone `.mjs`/`.js` Playwright scripts as a fallback — `exec:browser` errors must be debugged through `exec:browser` retries, not by creating test files on disk

package/skills/code-search/SKILL.md

@@ -3,13 +3,15 @@ name: code-search
 description: Mandatory codebase search workflow. Use whenever you need to find anything in the codebase. Start with two words, iterate by changing or adding words until found.
 ---
 
-# CODEBASE SEARCH
+# Codebase search
 
-`exec:codesearch` is the only codebase search tool. `Grep`, `Glob`, `Find`, `Explore`, `grep`/`rg`/`find` inside `exec:bash` = ALL hook-blocked. No fallback path.
+`exec:codesearch` is the only codebase search tool. Grep, Glob, Find, Explore, raw `grep`/`rg`/`find` inside `exec:bash` are all hook-blocked. No fallback.
 
-Handles: exact symbols, exact strings, file-name fragments, regex-ish patterns, natural-language queries, PDF pages (cite `path/doc.pdf:<page>`).
+A `@<discipline>` first-token after the verb scopes the search to that discipline's index; absent the sigil, results fan across default plus enabled disciplines, prefixed by source.
 
-Direct-read exceptions: known absolute path → `Read`. Known dir listing → `exec:nodejs` + `fs.readdirSync`.
+Handles exact symbols, exact strings, file-name fragments, regex-ish patterns, natural-language queries, and PDF pages (cite `path/doc.pdf:<page>`).
+
+Direct-read exceptions: known absolute path → `Read`. Known directory listing → `exec:nodejs` + `fs.readdirSync`.
 
 ## Syntax
 
@@ -18,15 +20,9 @@ exec:codesearch
 <two-word query>
 ```
 
-## Protocol
-
-1. Start: exactly two words
-2. No results → change one word
-3. Still no → add third word
-4. Still no → swap changed word again
-5. Minimum 4 attempts before concluding absent
+## Iteration
 
-Never: one word | full sentence | give up under 4 attempts | switch tools.
+Start at exactly two words. No results → change one word. Still none → add a third. Still none → swap the changed word again. Minimum four attempts before concluding absent. Never one word, never a full sentence, never switch tools.
 
 ## Examples
 
@@ -34,15 +30,19 @@ Never: one word | full sentence | give up under 4 attempts | switch tools.
 exec:codesearch
 session cleanup idle
 ```
-→ no results →
+
+No results, then:
+
 ```
 exec:codesearch
 cleanup sessions timeout
 ```
 
-PDF search:
+PDF:
+
 ```
 exec:codesearch
 usb descriptor endpoint
 ```
-→ returns `docs/usb-spec.pdf:42` — cite page, Read if you need surrounding text.
+
+Returns `docs/usb-spec.pdf:42` — cite the page; `Read` if surrounding text is needed.

package/skills/create-lang-plugin/SKILL.md

@@ -3,48 +3,40 @@ name: create-lang-plugin
 description: Create a lang/ plugin that wires any CLI tool or language runtime into gm-cc — adds exec:<id> dispatch, optional LSP diagnostics, and optional prompt context injection. Zero hook configuration required.
 ---
 
-# CREATE LANG PLUGIN
+# Create lang plugin
 
 Single CommonJS file at `<projectDir>/lang/<id>.js`. Auto-discovered — no hook editing.
 
-## Plugin Shape
+## Plugin shape
 
 ```js
 'use strict';
 module.exports = {
-  id: 'mytool',                         // must match filename
+  id: 'mytool',
   exec: {
     match: /^exec:mytool/,
     run(code, cwd) { /* returns string or Promise<string> */ }
   },
-  lsp: {                                // optional — synchronous only
+  lsp: {
     check(fileContent, cwd) { /* returns Diagnostic[] */ }
   },
-  extensions: ['.ext'],                 // optional — for lsp.check
-  context: `=== mytool ===\n...`       // optional — string or () => string
+  extensions: ['.ext'],
+  context: `=== mytool ===\n...`
 };
 ```
 
 `type Diagnostic = { line: number; col: number; severity: 'error'|'warning'; message: string }`
 
-## How It Works
+`exec.run` runs in a child process, 30s timeout, async OK. Called when Claude writes `exec:mytool\n<code>`. `lsp.check` is synchronous-only, called per prompt-submit. `context` is injected into every prompt, truncated to 2000 chars.
 
-- `exec.run` — child process, 30s timeout, async OK. Called when Claude writes `exec:mytool\n<code>`.
-- `lsp.check` — synchronous, called per prompt submit. Use `spawnSync`/`execFileSync`. No async.
-- `context` — injected into every prompt (truncated 2000 chars).
+## Identify the tool
 
-## Step 1 — Identify Tool
+What is the CLI name or npm package? Does it run a single expression (`tool eval`, `tool -e`, HTTP POST) or a file (`tool run <file>`)? What is its lint/check mode and output format? File extensions? Does it require a running server, or does it run headless?
 
-1. CLI name or npm package?
-2. Run single expression? (`tool eval <expr>`, `tool -e <code>`, HTTP POST...)
-3. Run file? (`tool run <file>`)
-4. Lint/check mode + output format?
-5. File extensions?
-6. Requires running server or headless?
+## exec.run patterns
 
-## Step 2 — exec.run Patterns
+HTTP eval against a running server:
 
-HTTP eval (running server):
 ```js
 function httpPost(port, urlPath, body) {
   return new Promise((resolve, reject) => {
@@ -61,7 +53,8 @@ function httpPost(port, urlPath, body) {
 }
 ```
 
-File-based (headless):
+File-based, headless:
+
 ```js
 function runFile(code, cwd) {
   const tmp = path.join(os.tmpdir(), `plugin_${Date.now()}.ext`);
@@ -71,12 +64,13 @@ function runFile(code, cwd) {
 }
 ```
 
-Single expr detection:
+Single-expression detection:
+
 ```js
 const isSingleExpr = code => !code.trim().includes('\n') && !/\b(func|def|fn |class|import)\b/.test(code);
 ```
 
-## Step 3 — lsp.check
+## lsp.check
 
 ```js
 function check(fileContent, cwd) {
@@ -94,14 +88,15 @@ function check(fileContent, cwd) {
 }
 ```
 
-## Step 4 — context String
+## context
 
 Under 300 chars:
+
 ```js
 context: `=== mytool ===\nexec:mytool\n<expression>\n\nRuns via <how>. Use for <when>.`
 ```
 
-## Step 5 — Write + Verify
+## Verify
 
 ```
 exec:nodejs
@@ -110,6 +105,7 @@ console.log(p.id, typeof p.exec.run, p.exec.match.toString());
 ```
 
 Then test dispatch:
+
 ```
 exec:mytool
 <simple test expression>
@@ -117,9 +113,9 @@ exec:mytool
 
 ## Constraints
 
-- `exec.run` async OK (30s timeout)
+- `exec.run` async OK, 30s timeout
 - `lsp.check` synchronous only — no Promises
 - CommonJS only — no ES module syntax
 - No persistent processes
 - `id` must match filename exactly
-- First match wins — make `match` specific
+- First match wins — keep `match` specific