gm-skill 2.0.1828 → 2.0.1830

package/bin/bootstrap.js

@@ -17,12 +17,26 @@ function log(msg) {
   try { process.stderr.write(`[plugkit-bootstrap] ${msg}\n`); } catch (_) {}
 }
 
-const BOOTSTRAP_BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+function discoverBundledSkills(wrapperDir) {
+  const roots = [
+    path.join(wrapperDir, '..', 'skills'),
+    path.join(wrapperDir, '..', '..', 'skills'),
+  ];
+  const root = roots.find(r => { try { return fs.existsSync(r) && fs.statSync(r).isDirectory(); } catch (_) { return false; } });
+  if (!root) return [];
+  try {
+    return fs.readdirSync(root, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name)
+      .filter(name => { try { return fs.existsSync(path.join(root, name, 'SKILL.md')); } catch (_) { return false; } })
+      .sort();
+  } catch (_) { return []; }
+}
 
 function ensureSkillMdCurrent(wrapperDir) {
   const home = os.homedir();
   const allRefreshed = [];
-  for (const skillName of BOOTSTRAP_BUNDLED_SKILLS) {
+  for (const skillName of discoverBundledSkills(wrapperDir)) {
     try {
       const candidates = [
         path.join(wrapperDir, '..', 'skills', skillName, 'SKILL.md'),

package/bin/install.js

@@ -6,11 +6,25 @@ const path = require('path');
 const os = require('os');
 const readline = require('readline');
 
-const BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
-
 function out(msg) { process.stdout.write(msg + '\n'); }
 function err(msg) { process.stderr.write(msg + '\n'); }
 
+function discoverBundledSkills() {
+  const roots = [
+    path.join(__dirname, '..', 'skills'),
+    path.join(__dirname, '..', '..', 'skills'),
+  ];
+  const root = roots.find(r => { try { return fs.existsSync(r) && fs.statSync(r).isDirectory(); } catch (_) { return false; } });
+  if (!root) return [];
+  try {
+    return fs.readdirSync(root, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name)
+      .filter(name => { try { return fs.existsSync(path.join(root, name, 'SKILL.md')); } catch (_) { return false; } })
+      .sort();
+  } catch (_) { return []; }
+}
+
 function parseArgs(argv) {
   const flags = { yes: false, project: false, help: false };
   for (const a of argv) {
@@ -179,7 +193,7 @@ async function main() {
   const nonInteractive = flags.yes || !process.stdin.isTTY;
 
   let anyInstalled = false;
-  for (const skillName of BUNDLED_SKILLS) {
+  for (const skillName of discoverBundledSkills()) {
     const skillSrc = bundledSkillDir(skillName);
     if (!skillSrc) { err(`bundled skill directory skills/${skillName} not found in package`); continue; }
     const installed = installSkillDir(skillSrc, skillName, home, flags.project);

package/gm-plugkit/bootstrap.js

@@ -774,7 +774,32 @@ function ensureGmPlugkitVersionFresh() {
   } catch (_) { return false; }
 }
 
-const BOOTSTRAP_JS_BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+function discoverBundledSkillsAndSources() {
+  const found = new Map();
+  found.set('gm', path.join(__dirname, 'SKILL.md'));
+  try {
+    for (const f of fs.readdirSync(__dirname)) {
+      const m = f.match(/^SKILL-(.+)\.md$/);
+      if (m) found.set(m[1], path.join(__dirname, f));
+    }
+  } catch (_) {}
+  const devSkillsRoots = [
+    path.join(__dirname, '..', 'gm-skill', 'skills'),
+    path.join(__dirname, '..', '..', 'gm-skill', 'skills'),
+    path.join(__dirname, '..', 'skills'),
+  ];
+  for (const root of devSkillsRoots) {
+    try {
+      if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) continue;
+      for (const e of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        const p = path.join(root, e.name, 'SKILL.md');
+        if (fs.existsSync(p) && !found.has(e.name)) found.set(e.name, p);
+      }
+    } catch (_) {}
+  }
+  return found;
+}
 
 function ensureSkillMdFresh() {
   const home = process.env.HOME || process.env.USERPROFILE || require('os').homedir();
@@ -782,19 +807,11 @@ function ensureSkillMdFresh() {
   const _norm = s => s.replace(/\r\n/g, '\n');
   const allRefreshed = [];
   const sources = {};
-  for (const skillName of BOOTSTRAP_JS_BUNDLED_SKILLS) {
+  const discovered = discoverBundledSkillsAndSources();
+  for (const [skillName, bundledPath] of discovered) {
     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 (_) {}
+      if (!fs.existsSync(bundledPath)) {
+        try { obsEvent('bootstrap', 'skill-md.refresh.bundled-not-found', { skillName, searched: [bundledPath] }); } catch (_) {}
         continue;
       }
       const bundled = fs.readFileSync(bundledPath, 'utf-8');

package/gm-plugkit/package.json

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

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

@@ -1087,7 +1087,7 @@ function runBrowserRunner(pw, args, timeoutMs, cwd, claudeSessionId) {
   const sockDir = playwriterHomeFor(cwd, claudeSessionId);
   try { fs.mkdirSync(sockDir, { recursive: true }); } catch (_) {}
   env.PLAYWRITER_HOME = sockDir;
-  _writeStatusBusy((timeoutMs || 30000) + 5000);
+  _writeStatusBusy((timeoutMs || 120000) + 5000);
   return spawnSync(spawnCmd, spawnArgs, {
     encoding: 'utf-8',
     timeout: timeoutMs,

package/gm.json

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1828",
+  "version": "2.0.1830",
   "description": "Spool-dispatch orchestration engine with unified state machine, skills, and automated git enforcement",
   "author": "AnEntrypoint",
   "license": "MIT",

package/lib/skill-bootstrap.js

@@ -290,12 +290,26 @@ function ensureBuildToolIgnores(cwd) {
 }
 
 
-const BUNDLED_SKILLS = ['gm', 'gm-continue', 'wfgy-method'];
+function discoverBundledSkills() {
+  const roots = [
+    path.join(__dirname, '..', 'skills'),
+    path.join(__dirname, '..', '..', 'skills'),
+  ];
+  const root = roots.find(r => { try { return fs.existsSync(r) && fs.statSync(r).isDirectory(); } catch (_) { return false; } });
+  if (!root) return [];
+  try {
+    return fs.readdirSync(root, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => e.name)
+      .filter(name => { try { return fs.existsSync(path.join(root, name, 'SKILL.md')); } catch (_) { return false; } })
+      .sort();
+  } catch (_) { return []; }
+}
 
 function ensureSkillMdCurrent() {
   const allRefreshed = [];
   let anySkipped = false;
-  for (const skillName of BUNDLED_SKILLS) {
+  for (const skillName of discoverBundledSkills()) {
     try {
       const bundledPath = resolveFromCandidates([
         path.join(__dirname, '..', 'skills', skillName, 'SKILL.md'),

package/package.json

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

@@ -14,10 +14,14 @@ allowed-tools: Skill, Read, Write, Bash(bun *), Bash(npx *)
 
 **Standing approval: finish everything, max granularity, no budget constraints.** Every session is pre-approved through ALL requested work -- plan, every addition, every discovered/unfinished item. No stop-and-ask, no deferral, no narrowed slice. Effort is unbounded and never gated on cost, context window, session length, or "budget" of any kind -- there is no such thing as running out mid-cycle in a way that authorizes stopping; if a walk is long, PLAN pushes more rows and EXECUTE keeps walking them, session after session if needed, never pausing to ask which subset to attempt first. A prompt offering the user a menu of "compressed/deferred/partial" options gated on running out of budget is itself the deviation -- make the decision yourself (always: proceed with the full scope, never the partial one) and dispatch, don't present it as a choice. PRD rows are in `.gm/prd.yml`; a long-horizon task means MORE rows pushed onto PLAN as work is discovered, never fewer turns spent working. `blockedBy: external` in mutable status means the blocker is outside this repo/session (another team's repo, unavailable credential, scheduled call) -- it never applies to large/complex/contended/multi-step work that's reachable this turn, and never to "not enough budget"; that work gets more PRD rows, not a stop.
 
+**Naming a token/context count as a reason to change behavior is itself the deviation, full stop -- this applies even while reasoning, not only in the final message.** "32k remaining," "fast-track, no delays," "due to token constraints, finalizing immediately," "given the budget, batch/skip/compress X" -- any of these phrases appearing ANYWHERE in a turn (thinking, prose, or tool-call rationale) is the exact failure this rule exists to name, independent of whether the actions taken afterward look reasonable. There is no quantity of remaining context that changes what you do next; the next action is determined solely by phase + PRD state, identically whether 500k tokens or 500 remain. If you catch yourself estimating/citing a remaining-token number for any reason, that estimate itself is the drift signal -- discard the framing entirely and re-derive the next action from `phase`/`prd_pending_count` alone. This is not a softer version of "no budget constraints" above; it is the same rule restated at the point where it actually breaks -- the rule was violated last not through an explicit stated stop, but through invoking the concept as live context for a decision (batching resolves, skipping witnesses, "fast-tracking" a chain) while still taking real dispatch actions. Real per-row witnessing (one `exec_js`/`browser` dispatch per row, actually reading its output) is mandatory regardless of how many rows remain or how much context is left; a batch `prd-resolve` for N rows justified by "given the budget" is `deviation.prd-resolve-duplicate-witness`-shaped even when each id is individually correct, because the underlying witnesses were never separately produced.
+
 **No task is bounded; "out of scope" naming a real, reachable piece of work must never occur.** A task's actual scope is whatever its closure requires, not whatever fits some assumed limit -- when a row turns out bigger/harder/more multi-part than first estimated, the fix is fitting the bound to the task (more PRD rows, more turns, more sessions if genuinely needed), never fitting the task to an assumed bound by declaring part of it "out of scope," "future work," or "not yet implemented." A design doc describing what a reachable piece of work would look like, in place of doing that work, is the same deviation named above (documenting instead of implementing) wearing the "scoping" costume -- catch it the same way: if it's reachable this session, it is in scope by definition, full stop.
 
 **A gate denied the same way 3+ times in a row is a stuck loop, not a retry target.** Retrying the identical `transition`/verb after an unchanged denial repeats the same failure -- plugkit's own gate response names this explicitly (`stuck-loop-escalation`) once it detects the repeat. On that signal, or on noticing it yourself: stop retrying bare, `prd-add` a row naming the concrete stuck state (what's blocking, what you tried, why it didn't clear), invoke the `wfgy-method` skill's BBCR bounded-retry-then-surface discipline to recover with a checkpoint instead of blind-retrying, then re-attempt the transition once the actual blocker is cleared.
 
+**A fresh session entering a repo already mid-chain checks for a recent `stuck-loop-escalation` or repeated `prd-resolve-unknown-id` before repeating the same fix shape.** If a prior session hit either (guessing at ids never `prd-add`ed this chain, or retrying the same denied transition), the actual PRD rows and their real ids are on disk in `.gm/prd.yml` -- read them directly rather than assuming remembered ids from context are still correct. Re-`prd-add`ing a row under a slightly different id because the original is unknown/forgotten creates an orphaned duplicate; when uncertain of a row's real id, `codesearch`/`recall`/direct `.gm/prd.yml` read settles it, never a guess-and-hope `prd-resolve`.
+
 `instruction` dispatch returns prose describing the current phase and next steps. When uncertain about next action, dispatch `instruction` -- never invent the next step from memory, never stop to ask.
 
 Verbs are written to `.gm/exec-spool/in/<verb>/<N>.txt` as JSON. Plugkit processes on read. Phase transitions are explicit `transition {to:"PHASE"}` dispatches. Phase state is in responses and `.gm/exec-spool/.turn-summary.json`; never assume phase from context.
@@ -42,7 +46,7 @@ Boot probe at session start, one Bash call:
 cat .gm/exec-spool/.status.json 2>/dev/null; echo ---; cat .gm/exec-spool/.turn-summary.json 2>/dev/null; echo ---; date +%s%3N
 ```
 
-`.turn-summary.json` fields: `phase`, `prd_pending`, `last_instruction_age_ms`, `long_gap_threshold_ms`, `update_available`, `deviations_30m`. If `update_available` is set, dispatch `bun x gm-plugkit@latest spool`. If `last_instruction_age_ms` exceeds `long_gap_threshold_ms`, dispatch `instruction` before other verbs. `.status.json` `ts` within 15s = watcher alive; gap > 15s = dead. Exception: if `busy_until` is in the future, watcher is handling a long verb (browser, chromium spawn).
+`.turn-summary.json` fields: `phase`, `prd_pending`, `last_instruction_age_ms`, `long_gap_threshold_ms`, `update_available`, `deviations_30m`. If `update_available` is set, dispatch `bun x gm-plugkit@latest spool`. If `last_instruction_age_ms` exceeds `long_gap_threshold_ms`, dispatch `instruction` before other verbs. `.status.json` `ts` within 5min = watcher alive; gap > 5min = dead. Exception: if `busy_until` is in the future, watcher is handling a long verb (browser, chromium spawn).
 
 ```bash
 bun x gm-plugkit@latest spool
@@ -52,7 +56,7 @@ bun x gm-plugkit@latest spool
 
 **Dispatch shape: Write request + Read response, SAME tool-call block.** Never proceed/narrate/begin work before reading the response and following its `instruction` field. First-read "file does not exist" mid-verb = normal, re-Read next message. Never poll with `sleep && ls` -- plugkit is synchronous; missing response = dead watcher (recheck `ts`) or slow verb, never "still processing."
 
-**Dead-watcher recovery is mandatory, not optional.** Two consecutive missing re-Reads AND stale `ts` (>15s) AND no future `busy_until` = dead: `bun x gm-plugkit@latest spool` boots fresh, re-dispatch the original verb. If `busy_until` is set, the watcher is processing a long verb; wait instead of rebooting. Recovery = notice-dead -> boot -> re-dispatch, always -- never substitute a raw tool for the dead verb.
+**Dead-watcher recovery is mandatory, not optional.** Two consecutive missing re-Reads AND stale `ts` (>5min) AND no future `busy_until` = dead: `bun x gm-plugkit@latest spool` boots fresh, re-dispatch the original verb. If `busy_until` is set, the watcher is processing a long verb; wait instead of rebooting. Recovery = notice-dead -> boot -> re-dispatch, always -- never substitute a raw tool for the dead verb.
 
 **Apparent tooling failure is never grounds to ask the user, never a blind restart.** "Spooler not working" / missing response / stale watcher / `gm_plugkit_stale` flagged in a response = your own mechanical self-recovery: honor a future `busy_until` (wait), else boot + re-dispatch. You have boot authority; asking the user to do what a verb can do is a deviation. Staleness of any kind (stale watcher version, stale served prose vs published source) is itself a deviation to resolve immediately, the same turn it's noticed -- `bun x gm-plugkit@latest spool` first, before any other work.