gm-skill 2.0.1468 → 2.0.1470

package/AGENTS.md

@@ -40,7 +40,7 @@ Agents dispatch verbs by writing to `.gm/exec-spool/in/<verb>/<N>.txt` (request
 
 **git verbs**: `git_status` returns `{dirty, modified, untracked, deleted, staged}` from `git status --porcelain`. `branch_status` returns `{branch, ahead, behind, remote}`, the `remote-pushed` witness. `git_push` is the ONLY admissible push surface, it gates on `git_porcelain()` non-empty (refuses dirty), emits `deviation.push-dirty` on attempt, and shells the push only when clean. A raw `git push` via Bash bypasses the gate and is itself a deviation; ccsniff `--git-discipline` flags it.
 
-**filter verb**: pure stdout → compact-stdout transformation. Body `{kind, input, ...opts}` where kind is one of `grep`, `ls`, `tree`, `json`, `diff`, `git-status`, `log`. Returns `{output, stats:{bytes_in, bytes_out, saved_pct, ...}}`. Pipe raw command output through filter before letting it enter context, rtk's role, in-wasm, no subprocess. Replaces the legacy detached rtk binary download in bootstrap.
+**filter verb**: pure stdout → compact-stdout transformation. Body `{kind, input, ...opts}` where kind is one of `grep`, `ls`, `tree`, `json`, `diff`, `git-status`, `log`. Returns `{output, stats:{bytes_in, bytes_out, saved_pct, ...}}`. Pipe raw command output through filter before letting it enter context, in-wasm, no subprocess. The bootstrap fetches only `plugkit.wasm`, there is no separate filter/rtk binary download.
 
 ## Documentation Policy
 

package/bin/bootstrap.js

@@ -187,11 +187,6 @@ function obsEvent(subsystem, event, fields) {
 }
 
 
-function rtkBinaryName() {
-  const key = platformKey();
-  return key.startsWith('win32') ? `rtk-${key}.exe` : `rtk-${key}`;
-}
-
 function cacheRoot() {
   const home = os.homedir();
   if (process.env.PLUGKIT_CACHE_DIR) return process.env.PLUGKIT_CACHE_DIR;
@@ -256,12 +251,6 @@ function readVersionFile(wrapperDir) {
   return fs.readFileSync(p, 'utf8').trim();
 }
 
-function readRtkVersion(wrapperDir) {
-  const p = path.join(wrapperDir, 'rtk.version');
-  if (!fs.existsSync(p)) return null;
-  const v = fs.readFileSync(p, 'utf8').trim();
-  return v || null;
-}
 
 function sha256OfFileSync(filePath) {
   const h = crypto.createHash('sha256');
@@ -432,15 +421,12 @@ function isLockStale(lockPath) {
   return false;
 }
 
-function pruneOldVersions(root, keepVersion, keepRtkVersion) {
+function pruneOldVersions(root, keepVersion) {
   try {
     const entries = fs.readdirSync(root);
     for (const e of entries) {
-      const isPlugkit = e.startsWith('v') && !e.startsWith('rtk-');
-      const isRtk = e.startsWith('rtk-v');
-      if (!isPlugkit && !isRtk) continue;
-      if (isPlugkit && e === `v${keepVersion}`) continue;
-      if (isRtk && keepRtkVersion && e === `rtk-v${keepRtkVersion}`) continue;
+      if (!e.startsWith('v')) continue;
+      if (e === `v${keepVersion}`) continue;
       const dir = path.join(root, e);
       const lock = path.join(dir, '.lock');
       if (fs.existsSync(lock) && !isLockStale(lock)) continue;
@@ -502,7 +488,6 @@ async function bootstrap(opts) {
 
   if (healIfShaMatches(wasmFinalPath, wasmExpectedSha, wasmOkSentinel, wasmPartialPath, 'wasm')) {
     obsEvent('bootstrap', 'decision.heal', { reason: 'sha-match', path: wasmFinalPath });
-    spawnDetachedRtkFetch(wrapperDir);
     copyWasmToGmTools(wasmFinalPath, wrapperDir, version);
     clearBootstrapError();
     return wasmFinalPath;
@@ -519,7 +504,6 @@ async function bootstrap(opts) {
     }
     if (healIfShaMatches(wasmFinalPath, wasmExpectedSha, wasmOkSentinel, wasmPartialPath, 'wasm')) {
       obsEvent('bootstrap', 'decision.heal', { reason: 'sha-match-under-lock', path: wasmFinalPath });
-      spawnDetachedRtkFetch(wrapperDir);
       copyWasmToGmTools(wasmFinalPath, wrapperDir, version);
       clearBootstrapError();
       return wasmFinalPath;
@@ -574,8 +558,7 @@ async function bootstrap(opts) {
     fs.writeFileSync(wasmOkSentinel, new Date().toISOString());
     log(`decision: fetch reason: install-complete (${wasmFinalPath})`);
     obsEvent('bootstrap', 'install.done', { path: wasmFinalPath, version, kind: 'wasm' });
-    pruneOldVersions(root, version, readRtkVersion(wrapperDir));
-    spawnDetachedRtkFetch(wrapperDir);
+    pruneOldVersions(root, version);
     copyWasmToGmTools(wasmFinalPath, wrapperDir, version);
 
     clearBootstrapError();
@@ -585,109 +568,6 @@ async function bootstrap(opts) {
   }
 }
 
-function spawnDetachedRtkFetch(wrapperDir) {
-  try {
-    const { spawn } = require('child_process');
-    const child = spawn(process.execPath, [__filename, '--rtk-only', '--wrapper-dir', wrapperDir], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-    });
-    child.unref();
-    obsEvent('bootstrap', 'rtk.detached.spawned', { pid: child.pid, wrapperDir });
-  } catch (err) {
-    log(`rtk detach spawn failed: ${err.message}`);
-  }
-}
-
-function rtkCacheDir(root, wrapperDir, plugkitVerDir) {
-  const rtkVer = readRtkVersion(wrapperDir);
-  if (!rtkVer) return plugkitVerDir;
-  const dir = path.join(root, `rtk-v${rtkVer}`);
-  ensureDir(dir);
-  return dir;
-}
-
-async function bootstrapRtk(plugkitVerDir, plugkitVersion, wrapperDir, silent, root) {
-  const rtkName = rtkBinaryName();
-  const cacheDir = rtkCacheDir(root || cacheRoot(), wrapperDir, plugkitVerDir);
-  const rtkPath = path.join(cacheDir, rtkName);
-  const rtkOk = path.join(cacheDir, '.rtk-ok');
-  if (fs.existsSync(rtkPath) && fs.existsSync(rtkOk)) {
-    if (!silent) log(`rtk cache hit: ${rtkPath}`);
-    return rtkPath;
-  }
-  const rtkSha = readShaManifest(wrapperDir, 'rtk.sha256');
-  const expected = rtkSha ? rtkSha[rtkName] : null;
-  const tmp = `${rtkPath}.partial`;
-  if (healIfShaMatches(rtkPath, expected, rtkOk, tmp, 'rtk')) {
-    if (!silent) log(`rtk cache heal (sha match): ${rtkPath}`);
-    return rtkPath;
-  }
-  const RTKS_RELEASE_REPO = 'AnEntrypoint/plugkit-bin';
-  const url = `https://github.com/${RTKS_RELEASE_REPO}/releases/download/v${plugkitVersion}/${rtkName}`;
-  const startMs = Date.now();
-  let lastErr;
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    try {
-      log(`rtk download attempt ${attempt}/${MAX_ATTEMPTS}: ${url}`);
-      const result = spawnSync(
-        'curl',
-        ['-fSL', '--max-time', String(Math.floor(ATTEMPT_TIMEOUT_MS / 1000)), '-o', tmp, url],
-        { stdio: 'pipe', timeout: ATTEMPT_TIMEOUT_MS + 5000, windowsHide: true }
-      );
-      if (result.error) throw result.error;
-      if (result.status !== 0) throw new Error(`curl failed with status ${result.status}`);
-      break;
-    } catch (err) {
-      lastErr = err;
-      log(`rtk attempt ${attempt} failed: ${err.message}`);
-      obsEvent('bootstrap', 'rtk.download.attempt_failed', { attempt, max: MAX_ATTEMPTS, err: String(err.message || err) });
-      if (attempt < MAX_ATTEMPTS) {
-        const wait = BACKOFF_MS[attempt - 1] || 120000;
-        log(`backing off ${wait}ms`);
-        await new Promise(r => setTimeout(r, wait));
-      }
-    }
-  }
-  if (lastErr) throw lastErr;
-  if (expected) {
-    const got = await sha256OfFile(tmp);
-    if (got !== expected) {
-      try { fs.unlinkSync(tmp); } catch (_) {}
-      throw new Error(`rtk sha256 mismatch: expected ${expected}, got ${got}`);
-    }
-  }
-  try { fs.renameSync(tmp, rtkPath); }
-  catch (err) {
-    if (err.code === 'EEXIST' || err.code === 'EPERM') {
-      try { fs.unlinkSync(rtkPath); } catch (_) {}
-      fs.renameSync(tmp, rtkPath);
-    } else throw err;
-  }
-  if (os.platform() !== 'win32') { try { fs.chmodSync(rtkPath, 0o755); } catch (_) {} }
-  fs.writeFileSync(rtkOk, new Date().toISOString());
-  log(`installed ${rtkPath}`);
-  obsEvent('bootstrap', 'install.done', { path: rtkPath, plugkit_version: plugkitVersion, rtk_version: readRtkVersion(wrapperDir) || plugkitVersion, kind: 'rtk', dur_ms: Date.now() - startMs });
-  return rtkPath;
-}
-
-function resolveCachedRtk(opts) {
-  opts = opts || {};
-  const wrapperDir = opts.wrapperDir || __dirname;
-  const version = opts.version || readVersionFile(wrapperDir);
-  const root = (() => {
-    try { const r = cacheRoot(); ensureDir(r); return r; }
-    catch (_) { const r = fallbackCacheRoot(); ensureDir(r); return r; }
-  })();
-  const plugkitVerDir = path.join(root, `v${version}`);
-  const cacheDir = rtkCacheDir(root, wrapperDir, plugkitVerDir);
-  const rtkPath = path.join(cacheDir, rtkBinaryName());
-  const rtkOk = path.join(cacheDir, '.rtk-ok');
-  if (fs.existsSync(rtkPath) && fs.existsSync(rtkOk)) return rtkPath;
-  return null;
-}
-
 function getWasmPath(opts) {
   opts = opts || {};
   const wrapperDir = opts.wrapperDir || __dirname;
@@ -801,44 +681,24 @@ function killStaleDaemonIfVersionChanged(wrapperDir) {
   writeDaemonVersion(currentVersion);
 }
 
-module.exports = { bootstrap, getWasmPath, resolveCachedRtk, rtkBinaryName, cacheRoot, obsEvent, killRunningDaemons, killStaleDaemonIfVersionChanged, killSpoolWatcherInCwd, proactiveKillForNewInstall };
+module.exports = { bootstrap, getWasmPath, cacheRoot, obsEvent, killRunningDaemons, killStaleDaemonIfVersionChanged, killSpoolWatcherInCwd, proactiveKillForNewInstall };
 
 if (require.main === module) {
   const argv = process.argv.slice(2);
-  if (argv.includes('--rtk-only')) {
-    const wIdx = argv.indexOf('--wrapper-dir');
-    const wrapperDir = wIdx >= 0 ? argv[wIdx + 1] : __dirname;
-    (async () => {
+  bootstrap({ silent: false })
+    .then(p => { process.stdout.write(p + '\n'); process.exit(0); })
+    .catch(err => {
+      log(`FATAL: ${err.message}`);
+      obsEvent('bootstrap', 'fatal', { err: String(err.message || err) });
       try {
-        const version = readVersionFile(wrapperDir);
-        let root = cacheRoot();
-        try { ensureDir(root); }
-        catch (_) { root = fallbackCacheRoot(); ensureDir(root); }
-        const verDir = path.join(root, `v${version}`);
-        ensureDir(verDir);
-        await bootstrapRtk(verDir, version, wrapperDir, true, root);
-        process.exit(0);
-      } catch (err) {
-        obsEvent('bootstrap', 'rtk.detached.failed', { err: String(err.message || err) });
-        process.exit(1);
-      }
-    })();
-  } else {
-    bootstrap({ silent: false })
-      .then(p => { process.stdout.write(p + '\n'); process.exit(0); })
-      .catch(err => {
-        log(`FATAL: ${err.message}`);
-        obsEvent('bootstrap', 'fatal', { err: String(err.message || err) });
-        try {
-          const pinned = (() => { try { return readVersionFile(__dirname); } catch (_) { return null; } })();
-          writeBootstrapError({
-            expected_version: pinned,
-            cached_version: null,
-            error_phase: 'fatal',
-            error_message: String(err && err.message || err),
-          });
-        } catch (_) {}
-        process.exit(1);
-      });
-  }
+        const pinned = (() => { try { return readVersionFile(__dirname); } catch (_) { return null; } })();
+        writeBootstrapError({
+          expected_version: pinned,
+          cached_version: null,
+          error_phase: 'fatal',
+          error_message: String(err && err.message || err),
+        });
+      } catch (_) {}
+      process.exit(1);
+    });
 }

package/gm-plugkit/bootstrap.js

@@ -329,14 +329,6 @@ async function extractNpmPackageWithRetry(destPath, version) {
 }
 
 
-function platformKey() {
-  const p = os.platform();
-  const a = os.arch();
-  if (p === 'win32') return a === 'arm64' ? 'win32-arm64' : 'win32-x64';
-  if (p === 'darwin') return a === 'arm64' ? 'darwin-arm64' : 'darwin-x64';
-  return (a === 'arm64' || a === 'aarch64') ? 'linux-arm64' : 'linux-x64';
-}
-
 function healIfShaMatches(binPath, expectedSha, sentinelPath, partialPath, kind) {
   if (!fs.existsSync(binPath)) return false;
   if (partialPath) { try { if (fs.existsSync(partialPath)) fs.unlinkSync(partialPath); } catch (_) {} }
@@ -428,10 +420,8 @@ function pruneOldVersions(root, keepVersion) {
   try {
     const entries = fs.readdirSync(root);
     for (const e of entries) {
-      const isPlugkit = e.startsWith('v') && !e.startsWith('rtk-');
-      const isRtk = e.startsWith('rtk-v');
-      if (!isPlugkit && !isRtk) continue;
-      if (isPlugkit && e === `v${keepVersion}`) continue;
+      if (!e.startsWith('v')) continue;
+      if (e === `v${keepVersion}`) continue;
       const dir = path.join(root, e);
       const lock = path.join(dir, '.lock');
       if (fs.existsSync(lock) && !isLockStale(lock)) continue;

package/gm-plugkit/package.json

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

@@ -1,6 +1,6 @@
 {
   "name": "gm",
-  "version": "2.0.1468",
+  "version": "2.0.1470",
   "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.1468",
+  "version": "2.0.1470",
   "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/bin/rtk.sha256

@@ -1,6 +0,0 @@
-53224d66572e937507a8d2877c768e4e6cc3da66aa6f8d0f132afaab2edc2a10  rtk-win32-x64.exe
-dedabc1d89641c60c91f09570353b6270dba4f5d53f8597018a708e515265d53  rtk-win32-arm64.exe
-cf3190554b82c7395948b7a478c78bbe2241549b00777e660deff4cbb9e0c4b6  rtk-darwin-x64
-c815bad459b4eaccc8be4a5d74dba397fdfe7d3716e0b6023b188d2351128b82  rtk-darwin-arm64
-7d60dd5abc15f6d46ffd89b5de7253a067e2a3ef6f1cd8ae5a236eda05a504f4  rtk-linux-x64
-cd5dd78035845eef4b362927c61f61e23925af3c12779131024d8334bad87a6b  rtk-linux-arm64

package/lib/codeinsight.js

@@ -1,109 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const spool = require('./spool.js');
-
-const CODEINSIGHT_HOST = '127.0.0.1';
-const CODEINSIGHT_PORT = 4802;
-const REQUEST_TIMEOUT_MS = 30000;
-
-function emitEvent(severity, message, details = {}) {
-  try {
-    const date = new Date().toISOString().split('T')[0];
-    const logDir = path.join(os.homedir(), '.claude', 'gm-log', date);
-    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
-    const entry = { ts: new Date().toISOString(), severity, message, ...details };
-    fs.appendFileSync(path.join(logDir, 'codeinsight.jsonl'), JSON.stringify(entry) + '\n');
-  } catch (e) {
-    console.error(`[codeinsight] emit failed: ${e.message}`);
-  }
-}
-
-async function checkSocketReachable(host = CODEINSIGHT_HOST, port = CODEINSIGHT_PORT, timeoutMs = 1000) {
-  try {
-    const result = await spool.execSpool('health', 'health', { timeoutMs });
-    return !!(result && result.ok);
-  } catch (e) {
-    return false;
-  }
-}
-
-async function sendRequest(request, sessionId = 'unknown') {
-  const startTime = Date.now();
-  const reachable = await checkSocketReachable();
-
-  if (!reachable) {
-    emitEvent('warn', 'Codeinsight socket unreachable', {
-      host: CODEINSIGHT_HOST,
-      port: CODEINSIGHT_PORT,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    });
-    return { ok: false, error: `Codeinsight daemon unavailable at ${CODEINSIGHT_HOST}:${CODEINSIGHT_PORT}`, durationMs: Date.now() - startTime };
-  }
-
-  try {
-    if (request.action === 'search') {
-      const q = request.discipline && request.discipline !== 'default' ? `@${request.discipline} ${request.query}` : request.query;
-      const result = await spool.execCodesearch(q, { timeoutMs: REQUEST_TIMEOUT_MS, sessionId });
-      if (!result.ok) return { ok: false, error: result.stderr || result.stdout || 'codesearch failed', durationMs: Date.now() - startTime };
-      return { ok: true, raw: result.stdout || '', durationMs: Date.now() - startTime };
-    }
-    return { ok: false, error: `Unsupported action via spool: ${request.action}`, durationMs: Date.now() - startTime };
-  } catch (err) {
-    return { ok: false, error: err.message, durationMs: Date.now() - startTime };
-  }
-}
-
-async function searchCode(query, discipline = 'default', sessionId = 'unknown') {
-  if (!query || typeof query !== 'string' || query.trim().length === 0) {
-    return { ok: false, error: 'Query must be a non-empty string' };
-  }
-  const result = await sendRequest({ action: 'search', query: query.trim(), discipline, sessionId }, sessionId);
-  if (result.ok) {
-    emitEvent('info', 'Search completed', { query: query.trim(), discipline, resultCount: (result.results || []).length, sessionId, durationMs: result.durationMs });
-  }
-  return result;
-}
-
-async function indexProject(projectPath, discipline = 'default', sessionId = 'unknown') {
-  if (!projectPath || typeof projectPath !== 'string') {
-    return { ok: false, error: 'Project path must be a non-empty string' };
-  }
-  if (!fs.existsSync(projectPath)) {
-    emitEvent('warn', 'Project path does not exist', { projectPath, discipline, sessionId });
-    return { ok: false, error: `Project path does not exist: ${projectPath}` };
-  }
-  const result = await sendRequest({ action: 'index', projectPath: path.resolve(projectPath), discipline, sessionId }, sessionId);
-  if (result.ok) {
-    emitEvent('info', 'Index completed', { projectPath: path.resolve(projectPath), discipline, filesIndexed: result.filesIndexed, sessionId, durationMs: result.durationMs });
-  }
-  return result;
-}
-
-async function getDiagnostics(projectPath = null, discipline = 'default', sessionId = 'unknown') {
-  if (projectPath && !fs.existsSync(projectPath)) {
-    return { ok: false, error: `Project path does not exist: ${projectPath}` };
-  }
-  const result = await sendRequest({ action: 'diagnostics', projectPath: projectPath ? path.resolve(projectPath) : null, discipline, sessionId }, sessionId);
-  if (result.ok) {
-    emitEvent('info', 'Diagnostics retrieved', { projectPath: projectPath ? path.resolve(projectPath) : 'system-wide', discipline, diagnosticCount: (result.diagnostics || []).length, sessionId, durationMs: result.durationMs });
-  }
-  return result;
-}
-
-async function getIndexStatus(discipline = 'default', sessionId = 'unknown') {
-  const result = await sendRequest({ action: 'status', discipline, sessionId }, sessionId);
-  if (result.ok) {
-    emitEvent('info', 'Index status retrieved', { discipline, indexed: result.indexed, sessionId, durationMs: result.durationMs });
-  }
-  return result;
-}
-
-module.exports = {
-  searchCode,
-  indexProject,
-  getDiagnostics,
-  getIndexStatus,
-  checkSocketReachable,
-};

package/lib/daemon-bootstrap.js

@@ -1,443 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { spawn, execSync } = require('child_process');
-const os = require('os');
-const spool = require('./spool.js');
-
-// Resolve a bare command name to its .exe on Windows. cmd.exe + .cmd shim
-// chains re-enter conhost (visible window flash) even with windowsHide:true
-// on the parent. Spawning the real .exe directly lets CREATE_NO_WINDOW
-// propagate cleanly. Falls back to the original name if no .exe is found.
-// See [[windows-spawn-cmd-shim-flash]] for the discipline rationale.
-function resolveWindowsExe(cmd) {
-  if (process.platform !== 'win32') return cmd;
-  try {
-    const out = execSync(`where ${cmd}`, {
-      encoding: 'utf-8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-      windowsHide: true,
-      timeout: 800,
-    });
-    const lines = out.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
-    const exe = lines.find(l => /\.exe$/i.test(l));
-    const shim = lines.find(l => /\.(cmd|bat)$/i.test(l));
-    return exe || shim || cmd;
-  } catch {
-    return cmd;
-  }
-}
-
-// When spawning a .cmd/.bat shim with shell:true on Windows, cmd.exe re-parses
-// the command string and breaks on unquoted spaces (e.g. "C:\Program Files\...").
-// Quote the cmd and any space-containing args so cmd.exe sees them as single tokens.
-function shellQuoteWin(cmdOrArg) {
-  const s = String(cmdOrArg);
-  if (!/[\s"]/.test(s)) return s;
-  return `"${s.replace(/"/g, '\\"')}"`;
-}
-
-const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
-const GM_STATE_DIR = path.join(os.homedir(), '.gm');
-
-function emitDaemonEvent(daemon, severity, message, details) {
-  try {
-    const date = new Date().toISOString().split('T')[0];
-    const logDir = path.join(LOG_DIR, date);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
-    const logFile = path.join(logDir, 'daemon.jsonl');
-    const entry = {
-      ts: new Date().toISOString(),
-      daemon,
-      severity,
-      message,
-      ...details,
-    };
-    fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
-  } catch (e) {
-    console.error(`[daemon-bootstrap] Failed to emit event: ${e.message}`);
-  }
-}
-
-function getPlatformKey() {
-  const plat = process.platform;
-  if (plat === 'win32') return plat;
-  if (plat === 'darwin') return plat;
-  if (plat === 'linux') return plat;
-  throw new Error(`Unsupported platform: ${plat}`);
-}
-
-function getSessionId() {
-  return process.env.CLAUDE_SESSION_ID || 'unknown';
-}
-
-function isDaemonRunning(daemonName) {
-  try {
-    const plat = getPlatformKey();
-    if (plat === 'win32') {
-      const output = execSync('tasklist /FO CSV /NH', { encoding: 'utf8' });
-      const lines = output.split('\n').filter(Boolean);
-      return lines.some(line => {
-        const parts = line.split(',').map(p => p.trim().replace(/^"/, '').replace(/"$/, ''));
-        return parts[0].includes(daemonName);
-      });
-    } else {
-      try {
-        execSync(`pgrep -f "${daemonName}" > /dev/null 2>&1`);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  } catch (e) {
-    return false;
-  }
-}
-
-function checkPortReachable(host, port, timeoutMs = 500) {
-  return spool.execSpool('health', 'health', { timeoutMs, sessionId: getSessionId() })
-    .then((r) => !!(r && r.ok))
-    .catch(() => false);
-}
-
-function computeIndexDigest(cwd = process.cwd()) {
-  try {
-    let mtimeSum = 0;
-    const walkDir = (dir) => {
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
-              walkDir(path.join(dir, entry.name));
-            }
-          } else {
-            const fullPath = path.join(dir, entry.name);
-            const stat = fs.statSync(fullPath);
-            mtimeSum += stat.mtimeMs;
-          }
-        }
-      } catch (e) {
-        return;
-      }
-    };
-
-    walkDir(cwd);
-
-    let gitHead = '';
-    try {
-      gitHead = execSync('git rev-parse HEAD', { cwd, encoding: 'utf8' }).trim();
-    } catch {
-      gitHead = 'unknown';
-    }
-
-    let dirtyStatus = 'clean';
-    try {
-      const porcelain = execSync('git status --porcelain', { cwd, encoding: 'utf8' }).trim();
-      if (porcelain.length > 0) {
-        dirtyStatus = 'dirty';
-      }
-    } catch {
-      dirtyStatus = 'unknown';
-    }
-
-    const digestInput = `${mtimeSum}:${gitHead}:${dirtyStatus}`;
-    const digest = crypto.createHash('sha256').update(digestInput).digest('hex');
-    return `v1:${digest}:files=${mtimeSum}`;
-  } catch (e) {
-    emitDaemonEvent('digest', 'error', 'Failed to compute digest', { error: e.message });
-    return '';
-  }
-}
-
-function writeStatusFile(daemonName, status, sessionId, childPid) {
-  try {
-    fs.mkdirSync(GM_STATE_DIR, { recursive: true });
-    const statusFile = path.join(GM_STATE_DIR, `${daemonName}-status.json`);
-    const payload = {
-      daemon: daemonName,
-      status,
-      sessionId,
-      timestamp: new Date().toISOString(),
-      pid: Number.isFinite(childPid) ? childPid : process.pid,
-      parent_pid: process.pid,
-    };
-    fs.writeFileSync(statusFile, JSON.stringify(payload, null, 2));
-    emitDaemonEvent(daemonName, 'info', 'Status written', { file: statusFile });
-  } catch (e) {
-    emitDaemonEvent(daemonName, 'warn', 'Failed to write status file', { error: e.message });
-  }
-}
-
-async function ensureRsLearningDaemonRunning() {
-  const daemonName = 'rs-learn';
-  const sessionId = getSessionId();
-  const startTime = Date.now();
-
-  try {
-    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
-
-    if (isDaemonRunning(daemonName)) {
-      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
-      writeStatusFile(daemonName, 'running', sessionId);
-      return { ok: true, already_running: true };
-    }
-
-    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
-
-    const env = Object.assign({}, process.env, {
-      CLAUDE_SESSION_ID: sessionId,
-    });
-
-    // CREATE_NO_WINDOW (0x08000000) is inherited by all descendants —
-    // .cmd shims that bun-x downloads/launches never get a console window.
-    // DETACHED_PROCESS (0x00000008) detaches the process group. Windows-only;
-    // Node ignores creationFlags on POSIX.
-    const bunExe = resolveWindowsExe('bun');
-    const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bunExe);
-    const proc = spawn(
-      useShell ? shellQuoteWin(bunExe) : bunExe,
-      useShell ? ['x', 'rs-learn@latest'].map(shellQuoteWin) : ['x', 'rs-learn@latest'],
-      {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-        env,
-        ...(useShell ? { shell: true } : {}),
-        creationFlags: 0x08000000 | 0x00000008,
-      }
-    );
-
-    const pid = proc.pid;
-    proc.unref();
-
-    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
-    writeStatusFile(daemonName, 'started', sessionId);
-
-    return {
-      ok: true,
-      pid,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    };
-  } catch (e) {
-    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
-      error: e.message,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    });
-    writeStatusFile(daemonName, 'error', sessionId);
-    throw e;
-  }
-}
-
-async function ensureRsCodeinsightDaemonRunning() {
-  const daemonName = 'rs-codeinsight';
-  const sessionId = getSessionId();
-  const startTime = Date.now();
-
-  try {
-    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
-
-    if (isDaemonRunning(daemonName)) {
-      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
-      writeStatusFile(daemonName, 'running', sessionId);
-      return { ok: true, already_running: true };
-    }
-
-    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
-
-    const env = Object.assign({}, process.env, {
-      CLAUDE_SESSION_ID: sessionId,
-    });
-
-    const bunExe = resolveWindowsExe('bun');
-    const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bunExe);
-    const proc = spawn(
-      useShell ? shellQuoteWin(bunExe) : bunExe,
-      useShell ? ['x', 'rs-codeinsight@latest'].map(shellQuoteWin) : ['x', 'rs-codeinsight@latest'],
-      {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-        env,
-        ...(useShell ? { shell: true } : {}),
-        creationFlags: 0x08000000 | 0x00000008,
-      }
-    );
-
-    const pid = proc.pid;
-    proc.unref();
-
-    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
-    writeStatusFile(daemonName, 'started', sessionId);
-
-    return { ok: true, pid, sessionId, durationMs: Date.now() - startTime };
-  } catch (e) {
-    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
-      error: e.message,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    });
-    writeStatusFile(daemonName, 'error', sessionId);
-    throw e;
-  }
-}
-
-async function ensureRsSearchDaemonRunning() {
-  const daemonName = 'rs-search';
-  const sessionId = getSessionId();
-  const startTime = Date.now();
-
-  try {
-    emitDaemonEvent(daemonName, 'info', 'Daemon startup check initiated', { sessionId });
-
-    if (isDaemonRunning(daemonName)) {
-      emitDaemonEvent(daemonName, 'info', 'Daemon already running', { sessionId });
-      writeStatusFile(daemonName, 'running', sessionId);
-      return { ok: true, already_running: true };
-    }
-
-    emitDaemonEvent(daemonName, 'info', 'Spawning daemon', { sessionId });
-
-    const env = Object.assign({}, process.env, {
-      CLAUDE_SESSION_ID: sessionId,
-    });
-
-    const bunExe = resolveWindowsExe('bun');
-    const useShell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(bunExe);
-    const proc = spawn(
-      useShell ? shellQuoteWin(bunExe) : bunExe,
-      useShell ? ['x', 'rs-search@latest'].map(shellQuoteWin) : ['x', 'rs-search@latest'],
-      {
-        detached: true,
-        stdio: 'ignore',
-        windowsHide: true,
-        env,
-        ...(useShell ? { shell: true } : {}),
-        creationFlags: 0x08000000 | 0x00000008,
-      }
-    );
-
-    const pid = proc.pid;
-    proc.unref();
-
-    emitDaemonEvent(daemonName, 'info', 'Daemon spawned successfully', { pid, sessionId });
-    writeStatusFile(daemonName, 'started', sessionId);
-
-    return { ok: true, pid, sessionId, durationMs: Date.now() - startTime };
-  } catch (e) {
-    emitDaemonEvent(daemonName, 'error', 'Daemon spawn failed', {
-      error: e.message,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    });
-    writeStatusFile(daemonName, 'error', sessionId);
-    throw e;
-  }
-}
-
-async function ensureRsCodeinsightReady(sessionId = getSessionId()) {
-  const startTime = Date.now();
-  const daemonName = 'rs-codeinsight';
-  const host = '127.0.0.1';
-  const port = 4802;
-
-  try {
-    emitDaemonEvent(daemonName, 'info', 'Ensuring daemon readiness', { sessionId, host, port });
-
-    await ensureRsCodeinsightDaemonRunning();
-
-    const maxWaitMs = 30000;
-    const pollIntervalMs = 500;
-    const deadline = Date.now() + maxWaitMs;
-
-    while (Date.now() < deadline) {
-      const reachable = await checkPortReachable(host, port, 1000);
-      if (reachable) {
-        emitDaemonEvent(daemonName, 'info', 'Daemon ready', {
-          host,
-          port,
-          elapsedMs: Date.now() - startTime,
-          sessionId,
-        });
-        writeStatusFile(daemonName, 'ready', sessionId);
-        return { ok: true, host, port, sessionId, durationMs: Date.now() - startTime };
-      }
-
-      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-    }
-
-    emitDaemonEvent(daemonName, 'warn', 'Timeout waiting for readiness', {
-      host,
-      port,
-      maxWaitMs,
-      sessionId,
-      elapsedMs: Date.now() - startTime,
-    });
-    writeStatusFile(daemonName, 'timeout', sessionId);
-    return { ok: false, error: 'Timeout waiting for codeinsight daemon', durationMs: Date.now() - startTime };
-  } catch (e) {
-    emitDaemonEvent(daemonName, 'error', 'Failed to ensure readiness', {
-      error: e.message,
-      sessionId,
-      durationMs: Date.now() - startTime,
-    });
-    writeStatusFile(daemonName, 'error', sessionId);
-    return { ok: false, error: e.message, durationMs: Date.now() - startTime };
-  }
-}
-
-async function ensureBrowserReady(sessionId = getSessionId()) {
-  const startTime = Date.now();
-  const host = '127.0.0.1';
-  const port = 5000;
-
-  try {
-    emitDaemonEvent('browser', 'info', 'Checking browser readiness', { sessionId, host, port });
-
-    const maxWaitMs = 10000;
-    const pollIntervalMs = 250;
-    const deadline = Date.now() + maxWaitMs;
-
-    while (Date.now() < deadline) {
-      const reachable = await checkPortReachable(host, port, 1000);
-      if (reachable) {
-        emitDaemonEvent('browser', 'info', 'Browser ready', {
-          host,
-          port,
-          elapsedMs: Date.now() - startTime,
-          sessionId,
-        });
-        return { ok: true, host, port, sessionId, durationMs: Date.now() - startTime };
-      }
-
-      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-    }
-
-    emitDaemonEvent('browser', 'warn', 'Browser not available', {
-      host,
-      port,
-      maxWaitMs,
-      sessionId,
-    });
-    return { ok: false, error: 'Browser API not available at 127.0.0.1:5000', durationMs: Date.now() - startTime };
-  } catch (e) {
-    emitDaemonEvent('browser', 'error', 'Failed to check browser', {
-      error: e.message,
-      sessionId,
-    });
-    return { ok: false, error: e.message, durationMs: Date.now() - startTime };
-  }
-}
-
-module.exports = {
-  ensureRsCodeinsightDaemonRunning,
-  ensureRsCodeinsightReady,
-  ensureRsSearchDaemonRunning,
-  ensureRsLearningDaemonRunning,
-  ensureBrowserReady,
-  checkPortReachable,
-};

package/lib/learning.js

@@ -1,169 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const spool = require('./spool.js');
-
-const RS_LEARN_HOST = '127.0.0.1';
-const RS_LEARN_PORT = 4801;
-const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
-
-let daemonBootstrap = null;
-function getDaemonBootstrap() {
-  if (!daemonBootstrap) {
-    try {
-      daemonBootstrap = require('./daemon-bootstrap.js');
-    } catch (e) {
-      console.error('[learning] Failed to load daemon-bootstrap:', e.message);
-      return null;
-    }
-  }
-  return daemonBootstrap;
-}
-
-let requestIdCounter = 1000;
-
-function getRequestId() {
-  return ++requestIdCounter;
-}
-
-function emitLearningEvent(action, severity, message, details = {}) {
-  try {
-    const date = new Date().toISOString().split('T')[0];
-    const logDir = path.join(LOG_DIR, date);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
-    const logFile = path.join(logDir, 'learning.jsonl');
-    const entry = {
-      ts: new Date().toISOString(),
-      action,
-      severity,
-      message,
-      ...details,
-    };
-    fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
-  } catch (e) {
-    console.error(`[learning] Failed to emit event: ${e.message}`);
-  }
-}
-
-async function ensureDaemonRunning(sessionId = null) {
-  const sid = sessionId || process.env.CLAUDE_SESSION_ID || 'unknown';
-  const bootstrap = getDaemonBootstrap();
-
-  if (!bootstrap) {
-    emitLearningEvent('daemon', 'warn', 'daemon-bootstrap not available, skipping spawn', { sessionId: sid });
-    return false;
-  }
-
-  try {
-    const startTime = Date.now();
-    const result = await bootstrap.ensureRsLearningDaemonRunning();
-    emitLearningEvent('daemon', 'info', 'daemon spawn result', {
-      sessionId: sid,
-      ok: result.ok,
-      already_running: result.already_running,
-      durationMs: Date.now() - startTime,
-    });
-    return result.ok === true;
-  } catch (error) {
-    emitLearningEvent('daemon', 'warn', 'daemon spawn failed', {
-      sessionId: sid,
-      error: error.message,
-    });
-    return false;
-  }
-}
-
-async function checkLearningAvailable(timeoutMs = 500) {
-  const sessionId = process.env.CLAUDE_SESSION_ID || 'unknown';
-  try {
-    const result = await spool.execSpool('health', 'health', { timeoutMs, sessionId });
-    const ok = !!(result && result.ok);
-    emitLearningEvent('check', ok ? 'info' : 'warn', ok ? 'rs-learn reachable (spool)' : 'rs-learn unavailable (spool)', { sessionId, timeoutMs });
-    return ok;
-  } catch (e) {
-    emitLearningEvent('check', 'warn', 'rs-learn availability check failed (spool)', { sessionId, timeoutMs, error: e.message });
-    return false;
-  }
-}
-
-async function queryLearning(query, discipline = 'default', sessionId = null) {
-  const sid = sessionId || process.env.CLAUDE_SESSION_ID || 'unknown';
-  const startTime = Date.now();
-
-  try {
-    emitLearningEvent('query', 'info', `Learning query: ${query}`, { sessionId: sid, query, discipline });
-
-    const available = await checkLearningAvailable();
-    if (!available) {
-      emitLearningEvent('query', 'warn', 'Learning unavailable', { sessionId: sid, query });
-      return null;
-    }
-
-    const payload = discipline && discipline !== 'default' ? `@${discipline} ${query}` : query;
-    const result = await spool.execRecall(payload, { timeoutMs: 5000, sessionId: sid });
-    if (!result.ok) throw new Error(result.stderr || result.stdout || 'recall failed');
-
-    emitLearningEvent('query', 'info', 'Learning query completed', {
-      sessionId: sid,
-      query,
-      discipline,
-      hitCount: (result.stdout || '').length > 0 ? 1 : 0,
-      durationMs: Date.now() - startTime,
-    });
-
-    return result.stdout || '';
-  } catch (error) {
-    emitLearningEvent('query', 'error', `Learning query failed: ${query}`, {
-      sessionId: sid,
-      query,
-      error: error.message,
-      durationMs: Date.now() - startTime,
-    });
-    return null;
-  }
-}
-
-async function persistLearning(fact, discipline = 'default', sessionId = null) {
-  const sid = sessionId || process.env.CLAUDE_SESSION_ID || 'unknown';
-  const startTime = Date.now();
-
-  try {
-    emitLearningEvent('persist', 'info', 'Learning persist initiated', { sessionId: sid, discipline, factLength: fact.length });
-
-    const available = await checkLearningAvailable();
-    if (!available) {
-      emitLearningEvent('persist', 'error', 'Learning unavailable for persist', { sessionId: sid, discipline });
-      throw new Error('rs-learn daemon not available');
-    }
-
-    const payload = discipline && discipline !== 'default' ? `@${discipline}\n${fact}` : fact;
-    const result = await spool.execMemorize(payload, { timeoutMs: 5000, sessionId: sid });
-    if (!result.ok) throw new Error(result.stderr || result.stdout || 'memorize failed');
-
-    emitLearningEvent('persist', 'info', 'Learning persist completed', {
-      sessionId: sid,
-      discipline,
-      durationMs: Date.now() - startTime,
-    });
-
-    return result;
-  } catch (error) {
-    emitLearningEvent('persist', 'error', `Learning persist failed: ${error.message}`, {
-      sessionId: sid,
-      discipline,
-      durationMs: Date.now() - startTime,
-    });
-    throw error;
-  }
-}
-
-module.exports = {
-  checkLearningAvailable,
-  queryLearning,
-  persistLearning,
-  ensureDaemonRunning,
-  RS_LEARN_HOST,
-  RS_LEARN_PORT,
-};