gm-plugkit 2.0.1848 → 2.0.1850

package/SKILL-fifth-dimension-engine.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/SKILL-polaris-protocol.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/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/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/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/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;