gm-skill 2.0.1469 → 2.0.1470

package/gm-plugkit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gm-plugkit",
-  "version": "2.0.1469",
+  "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.1469",
+  "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.1469",
+  "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/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,
-};