gm-plugkit 2.0.1823 → 2.0.1825

package/SKILL-gm-continue.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.

package/SKILL-wfgy-method.md

@@ -0,0 +1,91 @@
+---
+name: wfgy-method
+description: Applies WFGY (Wan Fa Gui Yi), a portable reasoning discipline for reducing drift and incoherence across multi-step agent work, adapted from onestardao/WFGY's core mechanism. Compares each step against the stated goal, considers more than one approach before committing to ambiguous or high-stakes decisions, and checkpoints before risky steps so it can revert and bounded-retry instead of compounding a mistake. Records durable lessons in this project so future sessions inherit them. Use when starting any non-trivial multi-step task, when a task risks losing track of its original goal over many steps, when facing a decision with real alternatives worth comparing, or when the agent notices it has contradicted itself or gone in circles and needs a disciplined way to recover.
+license: MIT
+compatibility: Designed for Claude Code. No external services, embedding models, or network access required for the core discipline.
+metadata:
+  origin: adapted-from-onestardao-wfgy
+  provenance: independent-honest-reimplementation-not-verbatim
+---
+
+# WFGY method
+
+WFGY (Wan Fa Gui Yi, "all methods return to one") is a reasoning-drift-control technique from `onestardao/WFGY`. This skill ports its genuinely portable behavioral core to a text-generating agent's own multi-step work. It does **not** reproduce the original project's TXT-OS prompt file, its hardcoded demo-benchmark output, or its user-skepticism-deflection script — see `references/honesty-and-provenance.md` for exactly what was kept, what was dropped, and why.
+
+The original names four "Big Bang" modules (BBMC, BBPF, BBCR, BBAM) plus a numeric drift score, ΔS = 1 − cos(I, G) (I = current state, G = goal/anchor), and a trend classifier over consecutive ΔS values (convergent/recursive/divergent/chaotic). All of this is ported below. Where the original relies on real computation this skill cannot perform (real embeddings for ΔS, real attention-weight statistics for BBAM), the instruction explicitly hands that judgment to you, the calling agent, to make in plain language instead — see `references/wfgy-core-mechanism.md` for the full technical basis of every claim in this file, and `references/honesty-and-provenance.md` for exactly what was reframed and why.
+
+**On ΔS**: absent a real embedding call, any numeric ΔS you produce is your own qualitative estimate, not a measurement. Use the label ("ΔS is climbing," "ΔS looks high here") as shorthand for "this step is drifting from the stated goal" — never present a specific decimal (e.g. "ΔS = 0.42") as if it were computed, because it is not, unless real embeddings are actually available (see below).
+
+**If a gm-plugkit spool is running in this project** (check `.gm/exec-spool/.status.json`; most gm-managed repos have one), a real `similarity` verb is available: dispatch `{"text_a": "<G>", "text_b": "<current state>"}` to it and read back `{"similarity", "distance"}` — `distance` is a genuine `1 - cos(I, G)` computed from real BGE-small-en-v1.5 embeddings, not a self-estimate. When available, use this real value as ΔS directly and say so explicitly ("ΔS = 0.31, computed"). When not available, fall back to the qualitative label above and say so explicitly too ("ΔS looks high here, my own estimate, no embedding tool available"). Never let the reader assume one when you did the other.
+
+## G · the anchor (BBMC pattern: compare state against goal)
+
+At the start of any task this skill applies to, write one sentence stating the actual goal (G) — not the first sub-task, the actual end state the user wants. Re-read it before any step that could plausibly have drifted: a long tool-call chain, a pivot in approach, a request to "also" do something adjacent.
+
+- [ ] Stated G in one sentence before starting.
+- [ ] Before each major step, ask: does what I'm about to do still serve G, or have I started solving a different, adjacent problem?
+- [ ] If drift is real (not just "this step looks different from the last one" — actual scope change, contradicted earlier decision, answering a different question than asked), say so explicitly and re-anchor before continuing.
+
+Gotcha: the temptation is to silently keep going once you notice drift, because stopping to say "wait, I've drifted" feels like an interruption. Don't suppress it — a silently-corrected drift is invisible to the user and looks like it never happened; a stated one is a real signal they can act on.
+
+## BBPF pattern · consider more than one path before committing
+
+Applies to decisions with real alternatives, not every trivial step. The original's gate condition (a candidate path proceeds only if it measurably reduces ΔS and stays within a stability bound) translates to: when a decision is ambiguous or high-stakes, generate more than one real candidate approach, then commit to whichever one most clearly and verifiably advances G — not the first idea, not the most familiar one.
+
+- [ ] Is this decision ambiguous or high-stakes enough to warrant comparing options? (Most steps are not — do not apply this to routine, unambiguous work.)
+- [ ] If yes: name at least two real candidate approaches before picking one.
+- [ ] State which one you picked and why it advances G more clearly than the alternative(s).
+- [ ] If no candidate is clearly better, that is itself a signal worth surfacing to the user rather than picking arbitrarily and moving on.
+
+## BBCR pattern · checkpoint, bounded retry, then surface rather than confabulate
+
+The original's collapse-and-retry loop resets to a last-known-good state on detected instability, retries a bounded number of times (its own reference implementation defaults to 3), and gives up cleanly rather than looping forever.
+
+- [ ] Before a risky or exploratory step (one that could leave things in a worse state than before), note what "last known good" looks like right now, in enough detail to actually get back to it.
+- [ ] If you notice real incoherence — repeated self-contradiction, circular reasoning, a mistake you catch yourself making — stop, return to the last checkpoint, and retry.
+- [ ] Retry at most 2-3 times for the same unresolved tension. After that, stop retrying silently.
+- [ ] Surface the specific unresolved problem to the user explicitly — state what you tried, why each attempt didn't resolve it, and what you need from them — rather than picking an answer anyway and moving on as if it were resolved.
+
+Gotcha: "bounded" is load-bearing. An agent that keeps trying indefinitely without ever surfacing the struggle is worse than one that fails fast and asks — the original's own design treats "give up and report" as a real, intended exit path, not a failure of the technique.
+
+## BBAM pattern · notice and correct over-narrow focus (agent-delegated: no real attention weights are read)
+
+The original computes `logits * exp(-gamma * sigma(logits))` — rescaling an actual attention/logit distribution by its own variance, flattening it when it's too peaked. A text-generating agent cannot read its own attention weights or logits; there is no real signal here for this skill to compute. Instead of dropping this module, the intelligence work is handed to you directly: periodically ask yourself whether your recent output has narrowed onto one aspect of a broader task and stayed there past the point of usefulness (repeating the same point, elaborating one sub-detail while leaving the rest of the task untouched, treating one hypothesis as settled without checking alternatives). If so, deliberately widen back out — this is you doing, in plain judgment, what the original technique's math does mechanically to a real attention distribution.
+
+- [ ] Periodically (not every step) ask: has my recent output been unusually narrow or repetitive relative to the task's actual breadth?
+- [ ] If yes: name what got left unexamined, and deliberately address it before continuing down the narrow path.
+
+## Trend classifier · is drift getting better or worse over the whole task
+
+The original tracks the step-to-step change in ΔS plus a rolling average over the last several steps, and labels the trajectory:
+
+- **convergent** — drift shrinking, each step measurably closer to G than the last.
+- **recursive** — drift roughly flat, oscillating in a narrow band without real progress or real regression.
+- **divergent** — drift growing, with some back-and-forth (not a clean slide, but net movement away from G).
+- **chaotic** — drift growing sharply, or the goal itself has become internally inconsistent (two things you've stated as true now contradict).
+
+This is a judgment the calling agent makes about its own trajectory across a task, not a computed statistic. Apply it at natural checkpoints (after a major milestone, before a significant pivot, when asked directly "how is this going") rather than every single step: state which of the four labels best fits the last several steps, and if the answer is divergent or chaotic, that is itself the trigger to apply the BBCR checkpoint-and-retry discipline above rather than continuing forward.
+
+## Named failure modes to watch for
+
+`references/failure-modes.md` adapts a broader set of specific failure patterns from WFGY's own problem taxonomy (hallucination from ungrounded claims, context drift over a long task, entropy collapse into rambling/repetition, logic collapse at a reasoning dead end, symbolic/abstract-reasoning collapse, memory/persona incoherence, multi-agent contradiction) into checklist items scoped to general agent work. Read it once per project (or whenever a failure feels like it matches one of these named shapes) — it is more specific and example-driven than the compressed disciplines above.
+
+## Recording durable lessons (the self-learning surface)
+
+This is this project's own addition on top of the adapted WFGY pattern, not part of the original technique — see `references/honesty-and-provenance.md` for why that distinction matters.
+
+The moment a bounded-retry cycle above resolves (whether it succeeded or had to surface to the user), or the moment you catch a concrete, non-obvious mistake anywhere in the task, append an entry to `<project-root>/.wfgy/lessons.md` (create the file and its parent directory if they don't exist yet) before finishing the turn. Use this exact shape, matching the style in `references/lessons-template.md`:
+
+```
+## <date> — <one-line summary>
+Goal (G): <what you were actually trying to accomplish>
+What drifted / what went wrong: <specific, concrete>
+Fix / resolution: <specific, concrete>
+Generalizes to: <what future work in this project should watch for because of this>
+```
+
+Read `.wfgy/lessons.md` at the start of a new task in this project, if it exists, before applying the disciplines above — a lesson already recorded here is exactly the kind of drift this skill exists to catch earlier next time.
+
+## What this skill is not
+
+It does not compute real embeddings, real cosine similarity, or real attention-weight statistics — every place the original relies on that computation, this skill hands the equivalent judgment to you, the calling agent, explicitly (see the ΔS note above, and the BBAM section). It does not reproduce the original TXT-OS file's scripted demo output or its skepticism-deflection behavior — those are named and explicitly rejected in `references/honesty-and-provenance.md`. It is not a site-maintenance or project-specific tool; it carries no assumptions about what project it's applied in.

package/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/bootstrap.js

@@ -774,71 +774,72 @@ function ensureGmPlugkitVersionFresh() {
   } catch (_) { return false; }
 }
 
+const BOOTSTRAP_JS_BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+
 function ensureSkillMdFresh() {
-  try {
-    const candidates = [
-      path.join(__dirname, 'SKILL.md'),
-      path.join(__dirname, '..', 'gm-skill', 'skills', 'gm', 'SKILL.md'),
-      path.join(__dirname, '..', '..', 'gm-skill', 'skills', 'gm', 'SKILL.md'),
-      path.join(__dirname, '..', 'skills', 'gm', 'SKILL.md'),
-    ];
-    const bundledPath = candidates.find(p => {
-      try { return fs.existsSync(p); } catch (_) { return false; }
-    });
-    if (!bundledPath) {
-      try {
-        obsEvent('bootstrap', 'skill-md.refresh.bundled-not-found', { searched: candidates });
-      } catch (_) {}
-      return { skipped: 'bundled-not-found' };
-    }
-    const bundled = fs.readFileSync(bundledPath, 'utf-8');
-    const crypto = require('crypto');
-    const _norm = s => s.replace(/\r\n/g, '\n');
-    const bundledHash = crypto.createHash('sha256').update(_norm(bundled)).digest('hex');
-    const home = process.env.HOME || process.env.USERPROFILE || require('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, 'utf-8');
-          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);
-          refreshed.push(target);
+  const home = process.env.HOME || process.env.USERPROFILE || require('os').homedir();
+  const crypto = require('crypto');
+  const _norm = s => s.replace(/\r\n/g, '\n');
+  const allRefreshed = [];
+  const sources = {};
+  for (const skillName of BOOTSTRAP_JS_BUNDLED_SKILLS) {
+    try {
+      const candidates = [
+        path.join(__dirname, skillName === 'gm' ? 'SKILL.md' : `SKILL-${skillName}.md`),
+        path.join(__dirname, '..', 'gm-skill', 'skills', skillName, 'SKILL.md'),
+        path.join(__dirname, '..', '..', 'gm-skill', 'skills', skillName, 'SKILL.md'),
+        path.join(__dirname, '..', 'skills', skillName, 'SKILL.md'),
+      ];
+      const bundledPath = candidates.find(p => {
+        try { return fs.existsSync(p); } catch (_) { return false; }
+      });
+      if (!bundledPath) {
+        try { obsEvent('bootstrap', 'skill-md.refresh.bundled-not-found', { skillName, searched: candidates }); } catch (_) {}
+        continue;
+      }
+      const bundled = fs.readFileSync(bundledPath, 'utf-8');
+      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 (_) {}
         }
-      } catch (e) {
+      }
+      sources[skillName] = bundledPath;
+      for (const target of targets) {
         try {
-          obsEvent('bootstrap', 'skill-md.refresh.target-failed', { target, error: e.message });
-        } catch (_) {}
+          let needsWrite = true;
+          if (fs.existsSync(target)) {
+            const existing = fs.readFileSync(target, 'utf-8');
+            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) {
+          try { obsEvent('bootstrap', 'skill-md.refresh.target-failed', { target, error: e.message }); } catch (_) {}
+        }
       }
+    } catch (e) {
+      try { obsEvent('bootstrap', 'skill-md.refresh.failed', { skillName, error: e.message }); } catch (_) {}
     }
-    if (refreshed.length > 0) {
-      log(`SKILL.md refreshed (sha=${bundledHash.slice(0, 12)}): ${refreshed.length} target(s)`);
-      try {
-        obsEvent('bootstrap', 'skill-md.refreshed', { hash: bundledHash.slice(0, 12), targets: refreshed, source: bundledPath });
-      } catch (_) {}
-    }
-    return { refreshed, bundledHash, source: bundledPath };
-  } catch (e) {
-    try { obsEvent('bootstrap', 'skill-md.refresh.failed', { error: e.message }); } catch (_) {}
-    return { error: e.message };
   }
+  if (allRefreshed.length > 0) {
+    log(`SKILL.md refreshed: ${allRefreshed.length} target(s)`);
+    try { obsEvent('bootstrap', 'skill-md.refreshed', { targets: allRefreshed, sources }); } catch (_) {}
+  }
+  return { refreshed: allRefreshed, sources };
 }
 
 function installedVersionAtTools() {
@@ -1103,6 +1104,7 @@ module.exports = {
   daemonVersionSentinel,
   readVersionFile,
   ensureGmPlugkitVersionFresh,
+  ensureSkillMdFresh,
 };
 
 if (require.main === module) {

package/cli.js

@@ -5,7 +5,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const cp = require('child_process');
-const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh } = require('./bootstrap');
+const { ensureReady, startSpoolDaemon, gmToolsDir, readVersionFile, ensureGmPlugkitVersionFresh, ensureSkillMdFresh } = require('./bootstrap');
 
 function readUpdateAvailableMarker(dir) {
   try {
@@ -215,12 +215,15 @@ function writeCliError(phase, err) {
   const versionDrifted = localVersionDrifted || remoteVersionDrifted;
   if (statusServing(already, 12000) && !versionDrifted) {
     try { ensureGmPlugkitVersionFresh(); } catch (_) {}
+    let skillRefresh = null;
+    try { skillRefresh = ensureSkillMdFresh(); } catch (_) {}
     writeCliStatus({ phase: 'ready', already_serving: true, watcher_pid: already.pid });
     console.log(JSON.stringify({
       ok: true,
       already_serving: true,
       watcher_pid: already.pid,
       version: already.version,
+      skills_refreshed: skillRefresh && skillRefresh.refreshed || [],
       message: 'plugkit already serving, no bootstrap/spawn needed',
     }));
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1823",
+  "version": "2.0.1825",
   "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": {
@@ -17,6 +17,8 @@
     "plugkit.version",
     "plugkit.sha256",
     "SKILL.md",
+    "SKILL-gm-continue.md",
+    "SKILL-wfgy-method.md",
     "instructions/"
   ],
   "keywords": [