gm-skill 2.0.1848 → 2.0.1850

package/gm-plugkit/bootstrap.js

@@ -1047,13 +1047,12 @@ function probeUnsupervisedWatcher(spoolDir) {
 }
 
 function resolveNodeRuntime() {
-  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
   const candidates = [];
-  if (isNodeExe(process.env.GM_NODE_PATH)) candidates.push(process.env.GM_NODE_PATH);
-  if (isNodeExe(process.execPath)) candidates.push(process.execPath);
+  if (process.env.PLUGKIT_RUNTIME) candidates.push(process.env.PLUGKIT_RUNTIME);
+  candidates.push('bun');
   try {
     const which = process.platform === 'win32' ? 'where' : 'which';
-    const out = require('child_process').spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+    const out = require('child_process').spawnSync(which, ['bun'], { encoding: 'utf8', windowsHide: true });
     if (out && out.stdout) {
       const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
       if (first) candidates.push(first);
@@ -1062,6 +1061,21 @@ function resolveNodeRuntime() {
   for (const c of candidates) {
     try { const r = require('child_process').spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
   }
+  const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
+  const nodeCandidates = [];
+  if (isNodeExe(process.env.GM_NODE_PATH)) nodeCandidates.push(process.env.GM_NODE_PATH);
+  if (isNodeExe(process.execPath)) nodeCandidates.push(process.execPath);
+  try {
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const out = require('child_process').spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+    if (out && out.stdout) {
+      const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+      if (first) nodeCandidates.push(first);
+    }
+  } catch (_) {}
+  for (const c of nodeCandidates) {
+    try { const r = require('child_process').spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+  }
   return process.execPath;
 }
 

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1848",
+  "version": "2.0.1850",
   "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-wasm-wrapper.js

@@ -117,12 +117,14 @@ function clearVerbActive() {
 
 process.on('uncaughtException', (err) => {
   try { console.error('[plugkit-wasm] uncaught:', err && err.stack || err); } catch (_) {}
+  try { killAllTasks('crash:uncaughtException'); } catch (_) {}
   emitShutdownReason('uncaughtException', err);
   process.exit(1);
 });
 
 process.on('unhandledRejection', (reason) => {
   try { console.error('[plugkit-wasm] unhandled rejection:', reason && reason.stack || reason); } catch (_) {}
+  try { killAllTasks('crash:unhandledRejection'); } catch (_) {}
   emitShutdownReason('unhandledRejection', reason instanceof Error ? reason : new Error(String(reason)));
   process.exit(1);
 });
@@ -745,23 +747,23 @@ function aggregateCpuProfile(profile, topN) {
 const BROWSER_RUNNER_BIN = process.env.GM_BROWSER_RUNNER_BIN || 'playwriter';
 
 function findBrowserRunner() {
-  const npmR = spawnSync('npm', ['root', '-g'], { encoding: 'utf-8', shell: true });
-  if (npmR.status === 0 && npmR.stdout.trim()) {
-    const root = npmR.stdout.trim().split(/\r?\n/).pop();
-    const binJs = path.join(root, BROWSER_RUNNER_BIN, 'bin.js');
+  const bunGlobalRoots = [
+    path.join(os.homedir(), '.bun', 'install', 'global', 'node_modules', BROWSER_RUNNER_BIN, 'bin.js'),
+  ];
+  for (const binJs of bunGlobalRoots) {
     if (fs.existsSync(binJs)) return { cmd: process.execPath, baseArgs: [binJs], shell: false };
   }
   const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+  const bunR = spawnSync(whichCmd, ['bun'], { encoding: 'utf-8', shell: true });
+  if (bunR.status === 0 && bunR.stdout.trim()) {
+    return { cmd: 'bun', baseArgs: ['x', `${BROWSER_RUNNER_BIN}@latest`], shell: true };
+  }
   const r = spawnSync(whichCmd, [BROWSER_RUNNER_BIN], { encoding: 'utf-8', shell: true });
   if (r.status === 0 && r.stdout.trim()) {
     const candidates = r.stdout.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
     const cmd = candidates.find(c => c.toLowerCase().endsWith('.cmd')) || candidates.find(c => !c.toLowerCase().endsWith('.ps1')) || candidates[0];
     if (cmd) return { cmd, baseArgs: [], shell: process.platform === 'win32' };
   }
-  const bunR = spawnSync(whichCmd, ['bun'], { encoding: 'utf-8', shell: true });
-  if (bunR.status === 0 && bunR.stdout.trim()) {
-    return { cmd: 'bun', baseArgs: ['x', `${BROWSER_RUNNER_BIN}@latest`], shell: true };
-  }
   const npxR = spawnSync(whichCmd, ['npx'], { encoding: 'utf-8', shell: true });
   if (npxR.status === 0 && npxR.stdout.trim()) {
     return { cmd: 'npx', baseArgs: ['-y', BROWSER_RUNNER_BIN], shell: true };
@@ -2116,8 +2118,25 @@ function nextTaskId(cwd) {
   return `t${n}`;
 }
 
+let _jsRuntimeCmd = null;
+function resolveJsRuntimeCmd() {
+  if (_jsRuntimeCmd) return _jsRuntimeCmd;
+  if (!/(^|[\\/])node(\.exe)?$/i.test(String(process.execPath || ''))) {
+    _jsRuntimeCmd = process.execPath;
+    return _jsRuntimeCmd;
+  }
+  try {
+    const which = process.platform === 'win32' ? 'where' : 'which';
+    const out = spawnSync(which, ['bun'], { encoding: 'utf-8', windowsHide: true });
+    const first = (out && out.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+    if (first) { _jsRuntimeCmd = first; return _jsRuntimeCmd; }
+  } catch (_) {}
+  _jsRuntimeCmd = process.execPath;
+  return _jsRuntimeCmd;
+}
+
 function langToCmd(lang, code) {
-  if (lang === 'nodejs' || lang === 'js' || lang === 'javascript' || lang === 'node') return { cmd: process.execPath, args: ['-e', code], stdinCode: null };
+  if (lang === 'nodejs' || lang === 'js' || lang === 'javascript' || lang === 'node') return { cmd: resolveJsRuntimeCmd(), args: ['-e', code], stdinCode: null };
   if (lang === 'python' || lang === 'py') return { cmd: 'python', args: ['-c', code], stdinCode: null };
   if (lang === 'bash' || lang === 'sh' || lang === 'shell' || lang === 'zsh') return { cmd: 'bash', args: ['-c', code], stdinCode: null };
   if (lang === 'powershell' || lang === 'ps1') return { cmd: 'powershell', args: ['-NoProfile', '-NonInteractive', '-Command', code], stdinCode: null };
@@ -2125,10 +2144,15 @@ function langToCmd(lang, code) {
   return null;
 }
 
+const TASK_MAX_TIMEOUT_MS = 10 * 60 * 1000;
+
 function spawnTask({ cwd, lang, code, timeoutMs }) {
   const id = nextTaskId(cwd);
   const built = langToCmd(lang, code);
   if (!built) return { ok: false, error: `unsupported lang: ${lang}` };
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > TASK_MAX_TIMEOUT_MS) {
+    timeoutMs = TASK_MAX_TIMEOUT_MS;
+  }
   const outLog = taskOutPath(cwd, id, 'stdout');
   const errLog = taskOutPath(cwd, id, 'stderr');
   let outFd = null, errFd = null;
@@ -2261,6 +2285,43 @@ function killAllTasks(reason) {
   return killed;
 }
 
+function pidAliveLocal(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (_) { return false; }
+}
+
+function sweepOrphanedTaskMetaOnBoot(cwd) {
+  let swept = 0;
+  try {
+    const dir = tasksDir(cwd);
+    const now = Date.now();
+    for (const name of fs.readdirSync(dir)) {
+      if (!/^t\d+\.json$/.test(name)) continue;
+      const metaPath = path.join(dir, name);
+      let meta = null;
+      try { meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8')); } catch (_) { continue; }
+      if (!meta || meta.status !== 'running') continue;
+      const stale = !pidAliveLocal(meta.pid) || (meta.deadline_ms && now > meta.deadline_ms);
+      if (!stale) continue;
+      if (pidAliveLocal(meta.pid)) {
+        try {
+          if (process.platform === 'win32') {
+            spawnSync('taskkill', ['/F', '/T', '/PID', String(meta.pid)], { stdio: 'ignore', windowsHide: true, timeout: 3000 });
+          } else {
+            try { process.kill(-meta.pid, 'SIGKILL'); } catch (_) { try { process.kill(meta.pid, 'SIGKILL'); } catch (_) {} }
+          }
+        } catch (_) {}
+      }
+      meta.status = 'reaped-on-boot';
+      meta.ended_ms = now;
+      try { fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2)); } catch (_) {}
+      swept += 1;
+    }
+  } catch (_) {}
+  if (swept > 0) logEvent('plugkit', 'task.bootSweepReaped', { cwd: cwd || process.cwd(), count: swept });
+  return swept;
+}
+
 function hostTaskProc(action, params) {
   switch (action) {
     case 'spawn': return spawnTask(params);
@@ -3394,6 +3455,8 @@ async function runSpoolWatcher(instance, spoolDir) {
     process.exit(0);
   }
 
+  try { sweepOrphanedTaskMetaOnBoot(process.cwd()); } catch (_) {}
+
   setInterval(() => {
     try { reapTimedOutTasks(); } catch (_) {}
   }, 5000);

package/gm-plugkit/supervisor.js

@@ -194,14 +194,13 @@ function spawnWatcher(bootReason) {
   }
 
   const isNodeExe = (p) => /(^|[\\/])node(\.exe)?$/i.test(String(p || ''));
-  const resolveNode = () => {
+  const resolveRuntime = () => {
     const candidates = [];
-    if (isNodeExe(process.env.PLUGKIT_RUNTIME)) candidates.push(process.env.PLUGKIT_RUNTIME);
-    if (isNodeExe(process.execPath)) candidates.push(process.execPath);
-    if (process.env.GM_NODE_PATH) candidates.push(process.env.GM_NODE_PATH);
+    if (process.env.PLUGKIT_RUNTIME) candidates.push(process.env.PLUGKIT_RUNTIME);
+    candidates.push('bun');
     try {
       const which = process.platform === 'win32' ? 'where' : 'which';
-      const out = spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+      const out = spawnSync(which, ['bun'], { encoding: 'utf8', windowsHide: true });
       if (out && out.stdout) {
         const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
         if (first) candidates.push(first);
@@ -210,9 +209,23 @@ function spawnWatcher(bootReason) {
     for (const c of candidates) {
       try { const r = spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
     }
+    const nodeCandidates = [];
+    if (isNodeExe(process.execPath)) nodeCandidates.push(process.execPath);
+    if (process.env.GM_NODE_PATH) nodeCandidates.push(process.env.GM_NODE_PATH);
+    try {
+      const which = process.platform === 'win32' ? 'where' : 'which';
+      const out = spawnSync(which, ['node'], { encoding: 'utf8', windowsHide: true });
+      if (out && out.stdout) {
+        const first = out.stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0];
+        if (first) nodeCandidates.push(first);
+      }
+    } catch (_) {}
+    for (const c of nodeCandidates) {
+      try { const r = spawnSync(c, ['--version'], { stdio: 'ignore', windowsHide: true }); if (r && r.status === 0) return c; } catch (_) {}
+    }
     return process.execPath;
   };
-  let cmd = resolveNode();
+  let cmd = resolveRuntime();
   let args = [wrapper, 'spool'];
 
   let logFd = null;

package/gm.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-skill",
-  "version": "2.0.1848",
+  "version": "2.0.1850",
   "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/fifth-dimension-engine/SKILL.md

@@ -43,7 +43,7 @@ Use **especially** for:
 - Research questions (turning ideas into research kernels)
 - Engineering failures (root cause analysis, repair paths)
 - Product/positioning work (audience, launch strategy)
-- High-strangeness problems (mixing themes into research)
+- Mixed-theme problems (combining unrelated ideas into research)
 
 ## How to Use
 
@@ -53,16 +53,6 @@ Use **especially** for:
 shoot + [your problem]
 ```
 
-Examples:
-
-```
-shoot + Seven Millennium Problems
-shoot + should I quit my job
-shoot + Death + AI
-shoot + P vs NP
-shoot + How to fix my broken deployment pipeline
-```
-
 ### The Engine Returns
 
 A structured route containing:
@@ -113,51 +103,25 @@ You get:
 
 Use the engine for *depth*, WFGY-Method for *direction*.
 
-## Modes and Use Cases
+## Modes
 
-### Seven Millennium Problems
+### Theorem and Formal Work
 
-Shoot the flagship: all seven famous unsolved mathematics problems simultaneously using the same underlying engine logic.
-
-```
-shoot + Seven Millennium Problems
-```
+Shoot a theorem or formal problem; the engine returns a proof-route structure that can be checked against a formal verification standard.
 
-See `references/seven-millennium-problems.md` for the flagship claim and what it does and does not assert.
+### Mixing Themes
 
-### Baseline-50 + Frontier-50
-
-- **Baseline-50**: Known-truth math problems (check engine accuracy)
-- **Frontier-50**: Unknown century-level problems (explore frontier)
-
-### High-Strangeness Math Lab
-
-Mix two unrelated themes and let the engine find the mathematical skeleton:
+Give the engine two unrelated themes and let it find the mathematical skeleton underneath them:
 
 ```
 shoot + [theme 1] + [theme 2]
 ```
 
-Examples:
-- Death + AI -> digital exit operators, hell-state boundaries
-- Dream + Physics -> dream-observer collapse, reality drift
-- Love + Source Poisoning -> attachment trust graph, false-closure lemmas
+See `references/research-kernel-extraction.md` for how mixed themes become research kernels.
 
-See `references/research-kernel-extraction.md` for how strange themes become research kernels.
+### Everyday Problems
 
-### Everyday Shoot Modes
-
-The same engine works on everyday problems:
-
-| Mode | Use For |
-|---|---|
-| Life Decision Shoot | Quitting, moving, major choices |
-| Relationship Shoot | Conversations, behavior, hidden tension |
-| Work / Career Shoot | Bottlenecks, career drift, stuck loops |
-| Product / Startup Shoot | Positioning, audience, launch route |
-| Research / Learning Shoot | Turning ideas into research kernels |
-| Engineering / Debugging Shoot | Root cause, system debt, repair paths |
-| Meme / Absurd Shoot | Small, weird, funny targets made structured |
+The same engine works on ordinary decisions, work problems, product questions, and engineering failures — any well-specified target benefits from being shot into a route rather than answered directly.
 
 ## Verification
 
@@ -178,7 +142,6 @@ This skill does not:
 
 See `references/` directory for:
 - `route-structure.md` — what a route is and how it is structured
-- `seven-millennium-problems.md` — the flagship demonstration
 - `research-kernel-extraction.md` — turning ideas into research kernels
 - `route-inspection-guide.md` — how to verify and attack a route
 - `skills/polaris-protocol/SKILL.md` — the Polaris Protocol tree root and state machine

package/skills/fifth-dimension-engine/references/research-kernel-extraction.md

@@ -1,25 +1,15 @@
 # Research Kernel Extraction — Fifth-Dimension Engine
 
-The High-Strangeness Math Lab is a Fifth-Dimension Engine mode that turns two unrelated themes into a theorem-shaped research kernel. The same mechanic generalizes to ordinary research questions.
+Mixing two unrelated themes turns them into a theorem-shaped research kernel. The same mechanic generalizes to ordinary research questions.
 
 ## The mechanic
 
-Give the engine two strange themes. It finds the mathematical skeleton underneath them.
+Give the engine two unrelated themes. It finds the mathematical skeleton underneath them.
 
 ```
 shoot + [theme 1] + [theme 2]
 ```
 
-Upstream examples:
-
-| Input | Possible kernel |
-|---|---|
-| Death + AI | Digital exit operator, hell-state boundary |
-| Dream + Physics | Dream-observer collapse, reality drift functional |
-| Meme + Epidemic | Narrative infection number, meme mutation bound |
-| Love + Source Poisoning | Attachment trust graph, false-closure lemma |
-| JudgmentDay + Tension Universe | Seven-Trumpet grand challenge system |
-
 ## From myth to model
 
 The engine's job is to move a target from symbol to structure:
@@ -31,17 +21,11 @@ The engine's job is to move a target from symbol to structure:
 
 ## Everyday research use
 
-The same pattern works without strangeness:
-
-```
-shoot + why do distributed consensus algorithms face a safety-liveness-cost tradeoff?
-```
-
-The engine returns a route: candidate theoretical bounds, objections, open questions. You then verify the lemmas and expand the open debt into real research.
+The same pattern works without strangeness — shoot an ordinary open research question directly. The engine returns a route: candidate theoretical bounds, objections, open questions. You then verify the lemmas and expand the open debt into real research.
 
 ## What this does NOT claim
 
-- It does not claim the strange pairing is itself a theorem. It claims the engine can propose a structure worth attacking.
+- It does not claim a strange pairing is itself a theorem. It claims the engine can propose a structure worth attacking.
 - It does not replace domain expertise or formal proof. The kernel is a starting point for inspection, not a result.
 
 See `../SKILL.md` for the engine interface and `route-inspection-guide.md` for how to verify what comes back.

package/skills/polaris-protocol/SKILL.md

@@ -63,7 +63,7 @@ CLOSED --next atom------------------------------------> COMPILED
 ## Canonical syntax (pro-rata — use exactly this)
 
 - **Compile first. Execute one active atom. Verify before unlock. Claim only what is supported.** (Goal Compiler)
-- **shoot + [your problem]** — the Fifth-Dimension Engine interface. Examples: `shoot + Seven Millennium Problems`, `shoot + Death + AI`, `shoot + should I quit my job`.
+- **shoot + [your problem]** — the Fifth-Dimension Engine interface.
 - **ΔS = 1 − cos(I, G)** — drift between current state (I) and goal (G). Without a real embedding call, ΔS is a qualitative label ("ΔS looks high here"), never a computed decimal — unless a real `similarity` verb is available (see WFGY-Method).
 
 "Compile first. Then shoot." is the spine of the whole protocol.

package/skills/fifth-dimension-engine/references/seven-millennium-problems.md

@@ -1,41 +0,0 @@
-# Seven Millennium Problems — the Fifth-Dimension Engine flagship
-
-This is the flagship demonstration of WFGY 5.0's Fifth-Dimension Engine.
-
-## The claim, stated precisely
-
-> One engine. One underlying logic. One simultaneous attack on all seven Millennium Problems.
-
-- **Same engine** — the seven problems are not handled by seven unrelated methods.
-- **Same logic** — the underlying route structure is generated from one high-dimensional engine.
-- **Seven together** — the Seven Millennium Problems are treated as one world-scale proof target.
-- **Open engine** — you can run it, inspect it, challenge it, and shoot again.
-
-The current public evidence layer behind this includes experiment packages with raw outputs, parsed outputs, verdict files, token accounting, audit records, and SHA256 integrity records. Those are the public evidence layer, not the main product surface.
-
-## How to run it
-
-```
-shoot + Seven Millennium Problems
-```
-
-Or, more generally:
-
-```
-Use WFGY 5.0 Fifth-Dimension Engine to simultaneously shoot the seven Millennium Problems.
-```
-
-For mathematics specifically, the upstream also points to Native Lean no-sorry materials — because theorem-complete work plus Native Lean no-sorry is one of the hardest standards in formal mathematics.
-
-## What this does NOT claim
-
-- It does **not** claim the seven are handled separately. The core claim is one engine, one underlying logic.
-- It does **not** claim this is only a replay of a fixed result. The point is that the same engine logic can shoot the seven again.
-- It does **not** claim every shoot becomes a final theorem. A shoot creates a structured route; final proof depends on verification, review, formalization, or testing.
-- It does **not** ask you to believe the author. The engine and prompt are public — run it yourself.
-
-## Why it matters as a stress test
-
-Mathematics is the hardest stress test for a structured-reasoning engine: the output is formally checkable. If the route structure holds up to inspection and formalization, that is real evidence. If it does not, the inspection itself is the value — you caught the weakness before promoting it to a claim.
-
-See `../SKILL.md` for the engine interface, and `skills/polaris-protocol/SKILL.md` for where this sits in the Polaris Protocol state machine.