gm-skill 2.0.1822 → 2.0.1824

package/README.md

@@ -16,6 +16,8 @@ disclaimer: this is extremely opinionated. it will block bash, redirect your too
 
 A Claude Code Agent Skill is just a directory at `~/.claude/skills/<name>/SKILL.md` (personal, all projects) or `.claude/skills/<name>/SKILL.md` (one project). The directory name becomes the slash command. No marketplace, no `npx skills` library -- the installer copies the directory into place.
 
+**The npm package is `gm-skill`, not `gm`.** `npx gm@latest` resolves to an unrelated, unmaintained GraphicsMagick wrapper (`gm` on npm, last published years ago) with no `install` command -- it fails with `could not determine executable to run`. Always spell out the full package name below.
+
 Interactive (offers Claude Code settings):
 
 ```

package/bin/bootstrap.js

@@ -17,58 +17,62 @@ function log(msg) {
   try { process.stderr.write(`[plugkit-bootstrap] ${msg}\n`); } catch (_) {}
 }
 
+const BOOTSTRAP_BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+
 function ensureSkillMdCurrent(wrapperDir) {
-  try {
-    const candidates = [
-      path.join(wrapperDir, '..', 'skills', 'gm', 'SKILL.md'),
-      path.join(wrapperDir, '..', '..', 'skills', 'gm', 'SKILL.md'),
-      path.join(wrapperDir, '..', 'SKILL.md'),
-    ];
-    const bundledPath = candidates.find(p => { try { return fs.existsSync(p); } catch (_) { return false; } });
-    if (!bundledPath) return { skipped: 'bundled-not-found' };
-    const bundled = fs.readFileSync(bundledPath, 'utf8');
-    const _norm = s => s.replace(/\r\n/g, '\n');
-    const bundledHash = crypto.createHash('sha256').update(_norm(bundled)).digest('hex');
-    const home = os.homedir();
-    const targets = [
-      path.join(home, '.agents', 'skills', 'gm', 'SKILL.md'),
-      path.join(home, '.claude', 'skills', 'gm', 'SKILL.md'),
-    ];
-    for (const legacy of [
-      path.join(home, '.agents', 'skills', 'gm-skill'),
-      path.join(home, '.claude', 'skills', 'gm-skill'),
-    ]) {
-      try { if (fs.existsSync(legacy)) fs.rmSync(legacy, { recursive: true, force: true }); } catch (_) {}
-    }
-    const refreshed = [];
-    for (const target of targets) {
-      try {
-        let needsWrite = true;
-        if (fs.existsSync(target)) {
-          const existing = fs.readFileSync(target, 'utf8');
-          const existingHash = crypto.createHash('sha256').update(_norm(existing)).digest('hex');
-          if (existingHash === bundledHash) needsWrite = false;
+  const home = os.homedir();
+  const allRefreshed = [];
+  for (const skillName of BOOTSTRAP_BUNDLED_SKILLS) {
+    try {
+      const candidates = [
+        path.join(wrapperDir, '..', 'skills', skillName, 'SKILL.md'),
+        path.join(wrapperDir, '..', '..', 'skills', skillName, 'SKILL.md'),
+      ];
+      const bundledPath = candidates.find(p => { try { return fs.existsSync(p); } catch (_) { return false; } });
+      if (!bundledPath) { obsEvent('bootstrap', 'skill-md.refresh.bundled-not-found', { skillName }); continue; }
+      const bundled = fs.readFileSync(bundledPath, 'utf8');
+      const _norm = s => s.replace(/\r\n/g, '\n');
+      const bundledHash = crypto.createHash('sha256').update(_norm(bundled)).digest('hex');
+      const targets = [
+        path.join(home, '.agents', 'skills', skillName, 'SKILL.md'),
+        path.join(home, '.claude', 'skills', skillName, 'SKILL.md'),
+      ];
+      if (skillName === 'gm') {
+        for (const legacy of [
+          path.join(home, '.agents', 'skills', 'gm-skill'),
+          path.join(home, '.claude', 'skills', 'gm-skill'),
+        ]) {
+          try { if (fs.existsSync(legacy)) fs.rmSync(legacy, { recursive: true, force: true }); } catch (_) {}
         }
-        if (needsWrite) {
-          fs.mkdirSync(path.dirname(target), { recursive: true });
-          const tmp = target + '.tmp';
-          fs.writeFileSync(tmp, bundled);
-          fs.renameSync(tmp, target);
-          refreshed.push(target);
+      }
+      for (const target of targets) {
+        try {
+          let needsWrite = true;
+          if (fs.existsSync(target)) {
+            const existing = fs.readFileSync(target, 'utf8');
+            const existingHash = crypto.createHash('sha256').update(_norm(existing)).digest('hex');
+            if (existingHash === bundledHash) needsWrite = false;
+          }
+          if (needsWrite) {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            const tmp = target + '.tmp';
+            fs.writeFileSync(tmp, bundled);
+            fs.renameSync(tmp, target);
+            allRefreshed.push(target);
+          }
+        } catch (e) {
+          obsEvent('bootstrap', 'skill-md.refresh.target-failed', { target, error: e.message });
         }
-      } catch (e) {
-        obsEvent('bootstrap', 'skill-md.refresh.target-failed', { target, error: e.message });
       }
+    } catch (e) {
+      obsEvent('bootstrap', 'skill-md.refresh.failed', { skillName, error: e.message });
     }
-    if (refreshed.length > 0) {
-      log(`SKILL.md refreshed (sha=${bundledHash.slice(0, 12)}): ${refreshed.join(', ')}`);
-      obsEvent('bootstrap', 'skill-md.refreshed', { hash: bundledHash.slice(0, 12), targets: refreshed });
-    }
-    return { refreshed, bundledHash };
-  } catch (e) {
-    obsEvent('bootstrap', 'skill-md.refresh.failed', { error: e.message });
-    return { error: e.message };
   }
+  if (allRefreshed.length > 0) {
+    log(`SKILL.md refreshed: ${allRefreshed.join(', ')}`);
+    obsEvent('bootstrap', 'skill-md.refreshed', { targets: allRefreshed });
+  }
+  return { refreshed: allRefreshed };
 }
 
 function ensureNextStepWiring(cwd) {

package/bin/install.js

@@ -6,7 +6,7 @@ const path = require('path');
 const os = require('os');
 const readline = require('readline');
 
-const BUNDLED_SKILLS = ['gm', 'wfgy-method'];
+const BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
 
 function out(msg) { process.stdout.write(msg + '\n'); }
 function err(msg) { process.stderr.write(msg + '\n'); }

package/bin/plugkit.version

@@ -1 +1 @@
-0.1.834
+0.1.835

package/bin/plugkit.wasm.sha256

@@ -1 +1 @@
-06a2301e7233c3a59cb8e96ad2707c83809deab8cfc60acf012ce4b610558bdf  plugkit.wasm
+dae6507c9f7c28e66cb4ca0000b1ed3cc6077b943b4af3d35b975f7abba88951  plugkit.wasm

package/gm-plugkit/package.json

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

@@ -1 +1 @@
-0.1.834
+0.1.835

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1822",
+  "version": "2.0.1824",
   "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.834"
+  "plugkitVersion": "0.1.835"
 }

package/lib/skill-bootstrap.js

@@ -290,57 +290,64 @@ function ensureBuildToolIgnores(cwd) {
 }
 
 
+const BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+
 function ensureSkillMdCurrent() {
-  try {
-    const bundledPath = resolveFromCandidates([
-      path.join(__dirname, '..', 'skills', 'gm', 'SKILL.md'),
-      path.join(__dirname, '..', '..', 'skills', 'gm', 'SKILL.md'),
-    ], 'gm-skill/skills/gm/SKILL.md');
-    if (!bundledPath || !fs.existsSync(bundledPath)) {
-      emitBootstrapEvent('warn', 'bundled SKILL.md not found; skipping refresh');
-      return { refreshed: [], skipped: true };
-    }
-    const bundled = fs.readFileSync(bundledPath, 'utf8');
-    const _norm = s => s.replace(/\r\n/g, '\n');
-    const bundledHash = crypto.createHash('sha256').update(_norm(bundled)).digest('hex');
-    const targets = [
-      path.join(os.homedir(), '.agents', 'skills', 'gm', 'SKILL.md'),
-      path.join(os.homedir(), '.claude', 'skills', 'gm', 'SKILL.md'),
-    ];
-    for (const legacy of [
-      path.join(os.homedir(), '.agents', 'skills', 'gm-skill'),
-      path.join(os.homedir(), '.claude', 'skills', 'gm-skill'),
-    ]) {
-      try { if (fs.existsSync(legacy)) fs.rmSync(legacy, { recursive: true, force: true }); } catch (_) {}
-    }
-    const refreshed = [];
-    for (const target of targets) {
-      try {
-        let needsWrite = true;
-        if (fs.existsSync(target)) {
-          const existing = fs.readFileSync(target, 'utf8');
-          const existingHash = crypto.createHash('sha256').update(_norm(existing)).digest('hex');
-          if (existingHash === bundledHash) needsWrite = false;
+  const allRefreshed = [];
+  let anySkipped = false;
+  for (const skillName of BUNDLED_SKILLS) {
+    try {
+      const bundledPath = resolveFromCandidates([
+        path.join(__dirname, '..', 'skills', skillName, 'SKILL.md'),
+        path.join(__dirname, '..', '..', 'skills', skillName, 'SKILL.md'),
+      ], `gm-skill/skills/${skillName}/SKILL.md`);
+      if (!bundledPath || !fs.existsSync(bundledPath)) {
+        emitBootstrapEvent('warn', 'bundled SKILL.md not found; skipping refresh', { skillName });
+        anySkipped = true;
+        continue;
+      }
+      const bundled = fs.readFileSync(bundledPath, 'utf8');
+      const _norm = s => s.replace(/\r\n/g, '\n');
+      const bundledHash = crypto.createHash('sha256').update(_norm(bundled)).digest('hex');
+      const targets = [
+        path.join(os.homedir(), '.agents', 'skills', skillName, 'SKILL.md'),
+        path.join(os.homedir(), '.claude', 'skills', skillName, 'SKILL.md'),
+      ];
+      if (skillName === 'gm') {
+        for (const legacy of [
+          path.join(os.homedir(), '.agents', 'skills', 'gm-skill'),
+          path.join(os.homedir(), '.claude', 'skills', 'gm-skill'),
+        ]) {
+          try { if (fs.existsSync(legacy)) fs.rmSync(legacy, { recursive: true, force: true }); } catch (_) {}
         }
-        if (needsWrite) {
-          fs.mkdirSync(path.dirname(target), { recursive: true });
-          const tmp = target + '.tmp';
-          fs.writeFileSync(tmp, bundled);
-          fs.renameSync(tmp, target);
-          refreshed.push(target);
+      }
+      for (const target of targets) {
+        try {
+          let needsWrite = true;
+          if (fs.existsSync(target)) {
+            const existing = fs.readFileSync(target, 'utf8');
+            const existingHash = crypto.createHash('sha256').update(_norm(existing)).digest('hex');
+            if (existingHash === bundledHash) needsWrite = false;
+          }
+          if (needsWrite) {
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            const tmp = target + '.tmp';
+            fs.writeFileSync(tmp, bundled);
+            fs.renameSync(tmp, target);
+            allRefreshed.push(target);
+          }
+        } catch (e) {
+          emitBootstrapEvent('warn', 'SKILL.md refresh failed for target', { target, error: e.message });
         }
-      } catch (e) {
-        emitBootstrapEvent('warn', 'SKILL.md refresh failed for target', { target, error: e.message });
       }
+    } catch (e) {
+      emitBootstrapEvent('warn', 'ensureSkillMdCurrent failed for skill', { skillName, error: e.message });
     }
-    if (refreshed.length > 0) {
-      emitBootstrapEvent('info', 'SKILL.md refreshed', { hash: bundledHash.slice(0, 12), targets: refreshed });
-    }
-    return { refreshed, bundledHash };
-  } catch (e) {
-    emitBootstrapEvent('warn', 'ensureSkillMdCurrent failed', { error: e.message });
-    return { refreshed: [], error: e.message };
   }
+  if (allRefreshed.length > 0) {
+    emitBootstrapEvent('info', 'SKILL.md refreshed', { targets: allRefreshed });
+  }
+  return { refreshed: allRefreshed, skipped: anySkipped };
 }
 
 function writeSessionSidecar(sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1822",
+  "version": "2.0.1824",
   "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

@@ -8,7 +8,7 @@ allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 
 **No tool call = stop; mid-chain stop = cardinal failure.** Agents read only tool calls + outputs -- prose-only turn ends the session. In-flight (`phase != COMPLETE OR prd_pending_count > 0`): every turn ends in a chain-advancing dispatch (`instruction`, the named next verb, or `transition`). No summaries, no "here's what I did," no closure narration. A turn-final sentence naming the next move instead of taking it is the same stop -- take the move.
 
-**At genuine `phase=COMPLETE AND prd_pending_count=0`, the only allowed next step is loading another skill, never a bare prose ending.** Dispatch `Skill` one more time: reload `gm` and instruct it to search for remaining work first (fresh `codesearch`/`recall` orient against the original request's closure, not memory). Two outcomes: (a) it finds none -- that re-entry itself reaches PLAN, confirms `prd_pending_count=0` with nothing new to add, and THAT turn is the actual stop, prose-only, no further `Skill` dispatch required; (b) it finds real remaining work -- `prd-add` the rows and keep walking, the chain was never actually done. If a prior `gm` walk already ran to COMPLETE without resolving everything and the same class of gap keeps recurring, load `wfgy-method` instead of `gm` on the next handoff, to apply its BBCR bounded-retry-then-surface discipline before any further `gm` re-entry. This closes the loop without infinite recursion: at most one extra `gm` re-entry to confirm nothing was missed, and that confirming turn is where prose-only is finally earned.
+**At genuine `phase=COMPLETE AND prd_pending_count=0`, the only allowed next step is dispatching `Skill(skill="gm-continue")`, never a bare prose ending.** That dedicated skill does the remaining-work search and the `gm`/`wfgy-method` handoff decision -- do not inline that logic here or improvise it; dispatch the skill and follow what it does.
 
 **Done is plugkit's word, never yours.** COMPLETE gate is the sole arbiter; not-COMPLETE = a next transition to seek, never a stopping point. Idle mid-chain is a deviation, not a pause. If uncertain what's next, dispatch `phase-status`, read the phase, then keep walking -- "uncertain" is never grounds to stop.
 
@@ -60,6 +60,8 @@ Spool input from PowerShell must be UTF-8 no-BOM (`-Encoding utf8` or `[System.I
 
 **Apply "every possible" to every noun, at PLAN and every re-entry to it.** PLAN is exhaustive, not minimal: every noun the request touches gets every possible task/validation/mutable/corner-case/caveat/failure-mode/empty-overflow-reentry-degenerate state as its own PRD row. A single-digit PRD count on a non-trivial or long-horizon request means it stopped early -- re-orient, re-enumerate, push more rows. Long-horizon prompts routinely produce high-tens-to-hundreds of rows; density at PLAN is the only protection against silently stopping with work undone. `blockedBy: external` is exhaustively narrow (outside-session authority only) -- never a way to shrink the row count for tedious/large/multi-step work.
 
+**Every PLAN pass also asks: what architectural change makes this practical and low-maintenance going forward, not just correct right now?** For each row, before accepting the literal ask as the whole scope: is there a structural change (removing an obsolete mechanism, consolidating duplicated logic, replacing a bespoke reimplementation with a maintained one, fixing a wrong abstraction at its root instead of patching around it) that would make this and future similar work cheaper, not just this one instance? If yes, that becomes its own PRD row alongside the literal ask -- never silently skipped as "out of scope" or "nice to have." A plan that only satisfies the literal request while leaving an obvious maintenance burden in place under-covers by the same standard as a plan that misses a corner case.
+
 **EXECUTE resolves all mutables before EMIT, discovers more, resolves those too, rearchitects immediately on in-spirit discovery.** Any architectural improvement discovered mid-EXECUTE is an immediate `transition to=PLAN`, re-`prd-add` the affected row with its existing id (re-scope, never delete-and-re-add) -- maximal-effort correctness over preservation-for-its-own-sake, no deferral, no "note for later."
 
 VERIFY is adversarial, never confirmatory: run the real code path and read its actual output via `exec_js` or `browser` -- a finding is only real once witnessed by execution this turn. Never assert a crash, pass, or defect from memory, prior session state, or written prose alone. A gate denial (e.g. `residual.skipped` on dirty worktree) is resolved immediately by the named recovery action (commit or revert the listed files, then re-dispatch the same verb) in the same turn -- it is never grounds to re-enter PLAN, add unrelated PRD rows, or narrate the blocker instead of clearing it.

package/skills/gm-continue/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: gm-continue
+description: The mandatory final handoff after a gm walk reaches phase=COMPLETE with prd_pending_count=0. Never end a gm session with prose alone -- dispatch this skill instead. It searches for genuinely remaining work and reloads gm if any exists; if gm already ran a full walk without resolving everything, it loads wfgy-method instead to apply bounded-retry-then-surface discipline before any further gm re-entry. Use immediately after any gm chain reaches its terminal state, never as a substitute for gm itself.
+allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
+---
+
+# gm-continue
+
+This is the only allowed next step when a `gm` walk reaches `phase=COMPLETE AND prd_pending_count=0`. Never end that turn with prose alone -- dispatch this skill instead, every time, no exceptions for "it looks finished."
+
+## What this skill does
+
+1. Read `.gm/exec-spool/.turn-summary.json` for the current `phase`, `prd_pending`, and how many times this repo has already round-tripped through `gm-continue` this session (track via a counter file, see below).
+2. Read `.gm/prd.yml` and `.gm/mutables.yml` directly for any row marked `blockedBy: [external]`/`[out-of-reach]` or otherwise deferred. **A prior `external`/`out-of-reach` marking is not a closed door -- it is remaining work by definition.** Re-examine each one now: is the blocker still genuinely unreachable this turn, or was it marked that way under time/scope pressure when it was actually solvable? Anything reachable now goes back into scope, re-`prd-add`'d (re-scope the existing id, never delete-and-re-add) as work to actually solve, not left marked external.
+3. Fan out `codesearch` + `recall` against the ORIGINAL request's full closure, not against memory of what was already done -- a fresh look, same discipline as `gm`'s own PLAN orient.
+4. If `.gm/prd.yml` has ANY items at all (pending, or reopened `external` rows from step 2), that alone is remaining work -- skip straight to the dispatch below, no further search needed.
+5. Two outcomes, decided by what steps 2-4 actually find:
+   - **Real remaining work found** (any PRD item at all, a reopened external/out-of-reach row, an unaddressed noun from the request, an edge case never exercised, a residual never triaged, a sibling repo never checked): dispatch `Skill(skill="gm")` and instruct it explicitly to finish ALL remaining tasks in `.gm/prd.yml` and fix any issues that arise while doing so -- not a narrow slice, not "just the reopened ones." Tell it plainly what was found so it lands directly in PLAN with real rows, not a blind re-orient.
+   - **Nothing found, but this is the first `gm-continue` dispatch this session**: dispatch `Skill(skill="gm")` anyway, once, to let a full independent PLAN pass confirm it from inside `gm`'s own discipline (fresh `codesearch`/`recall`, `prd_pending_count=0` reached with nothing new added). That confirming turn inside `gm` is the actual stopping point -- prose-only is earned there, not here.
+   - **Nothing found, and `gm-continue` already ran that confirming pass this session** (counter >= 1): the loop is closed. Prose-only summary is authorized. Do not dispatch anything further.
+
+## When to load `wfgy-method` instead of `gm`
+
+If a prior `gm` walk reached COMPLETE but the same class of gap keeps recurring across repeat `gm-continue` invocations (the confirming pass itself found new work more than once, or a stuck-loop-escalation was seen during the walk), dispatch `Skill(skill="wfgy-method")` instead of reloading `gm` directly. Apply its BBCR bounded-retry-then-surface discipline first -- checkpoint, name the unresolved tension, surface it plainly -- before any further `gm` re-entry. Reloading `gm` blind into a recurring gap repeats the same failure; `wfgy-method` exists to break that specific pattern.
+
+## Recursion bound
+
+Track invocation count in `.gm/.gm-continue-count` (plain integer, reset by a fresh user prompt). This skill dispatches `gm` or `wfgy-method` at most twice per user turn before it is required to stop and report to the user directly: once to check, once more only if that check found real work and the subsequent `gm` walk needs its own confirming `gm-continue` pass. A third consecutive "nothing new, re-check again" cycle is itself the stuck-loop signal -- surface it, do not keep looping silently.
+
+## Never a substitute for `gm`
+
+This skill does no PRD work, no EXECUTE, no EMIT, no VERIFY itself -- it only orients, decides, and hands off. All actual work happens inside `gm` (or `wfgy-method`'s recovery discipline), dispatched via `Skill`, never inlined here.