gm-copilot-cli 2.0.1066 → 2.0.1067

package/lib/skill-bootstrap.js

@@ -0,0 +1,410 @@
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync, spawn } = require('child_process');
+const crypto = require('crypto');
+const os = require('os');
+const spool = require('./spool.js');
+
+const PLUGKIT_TOOLS_DIR = path.join(os.homedir(), '.claude', 'gm-tools');
+const PLUGKIT_VERSION_FILE = path.join(PLUGKIT_TOOLS_DIR, 'plugkit.version');
+const BOOTSTRAP_STATUS_FILE = path.join(os.homedir(), '.gm', 'bootstrap-status.json');
+const BOOTSTRAP_ERROR_FILE = path.join(os.homedir(), '.gm', 'bootstrap-error.json');
+const LOG_DIR = path.join(os.homedir(), '.claude', 'gm-log');
+const PLATFORM_MAP = {
+  win32: { suffix: '-win32-x64.exe', altSuffix: '-win32-arm64.exe' },
+  darwin: { suffix: '-darwin-x64', altSuffix: '-darwin-arm64' },
+  linux: { suffix: '-linux-x64', altSuffix: '-linux-arm64' },
+};
+
+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 getExpectedBinaryName() {
+  const plat = getPlatformKey();
+  const suffix = PLATFORM_MAP[plat].suffix;
+  return `plugkit${suffix}`;
+}
+
+function getPlugkitPath() {
+  const name = getExpectedBinaryName();
+  return path.join(PLUGKIT_TOOLS_DIR, name);
+}
+
+function emitBootstrapEvent(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, 'bootstrap.jsonl');
+    const entry = {
+      ts: new Date().toISOString(),
+      severity,
+      message,
+      ...details,
+    };
+    fs.appendFileSync(logFile, JSON.stringify(entry) + '\n');
+  } catch (e) {
+    console.error(`[bootstrap] Failed to emit event: ${e.message}`);
+  }
+}
+
+function readManifest() {
+  try {
+    const gmJsonPath = path.join(process.cwd(), 'gm-starter', 'gm.json');
+    if (!fs.existsSync(gmJsonPath)) {
+      throw new Error('gm-starter/gm.json not found');
+    }
+    const gm = JSON.parse(fs.readFileSync(gmJsonPath, 'utf8'));
+    const version = gm.plugkitVersion;
+
+    const sha256Path = path.join(process.cwd(), 'gm-starter', 'bin', 'plugkit.sha256');
+    if (!fs.existsSync(sha256Path)) {
+      throw new Error('gm-starter/bin/plugkit.sha256 not found');
+    }
+    const sha256Lines = fs.readFileSync(sha256Path, 'utf8').split('\n').filter(Boolean);
+    const binaryName = getExpectedBinaryName();
+    const hashLine = sha256Lines.find(line => line.includes(binaryName));
+    if (!hashLine) {
+      throw new Error(`No hash found for ${binaryName}`);
+    }
+    const expectedHash = hashLine.split(/\s+/)[0];
+
+    return { version, expectedHash };
+  } catch (e) {
+    emitBootstrapEvent('error', 'Failed to read manifest', { error: e.message });
+    throw e;
+  }
+}
+
+function getInstalledVersion() {
+  try {
+    if (fs.existsSync(PLUGKIT_VERSION_FILE)) {
+      return fs.readFileSync(PLUGKIT_VERSION_FILE, 'utf8').trim();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function computeFileHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+async function downloadPlugkitBinary(version) {
+  const binaryName = getExpectedBinaryName();
+  const url = `https://github.com/AnEntrypoint/plugkit-bin/releases/download/${version}/${binaryName}`;
+
+  emitBootstrapEvent('info', 'Starting binary download', { version, binaryName, url });
+
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { timeout: 30000 }, (res) => {
+        if (res.statusCode === 404) {
+          reject(new Error(`Binary not found: ${binaryName} v${version}`));
+          return;
+        }
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode} downloading ${binaryName}`));
+          return;
+        }
+
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const data = Buffer.concat(chunks);
+          emitBootstrapEvent('info', 'Binary download complete', { bytes: data.length });
+          resolve(data);
+        });
+      })
+      .on('error', (e) => {
+        emitBootstrapEvent('error', 'Download failed', { error: e.message });
+        reject(e);
+      });
+  });
+}
+
+function isProcessRunning(pidOrName) {
+  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] === 'plugkit.exe' || parts[0] === pidOrName;
+      });
+    } else {
+      try {
+        execSync(`ps -p ${pidOrName} > /dev/null 2>&1`);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  } catch (e) {
+    return false;
+  }
+}
+
+function killExistingPlugkit() {
+  try {
+    const plat = getPlatformKey();
+    if (plat === 'win32') {
+      execSync('taskkill /IM plugkit.exe /F 2>nul || true', { shell: true });
+      emitBootstrapEvent('info', 'Killed existing plugkit process on Windows');
+    } else {
+      execSync('pkill -f "plugkit" || true', { shell: true });
+      emitBootstrapEvent('info', 'Killed existing plugkit process on Unix');
+    }
+  } catch (e) {
+    emitBootstrapEvent('warn', 'Failed to kill existing plugkit', { error: e.message });
+  }
+}
+
+async function ensureBinaryWritable(filePath) {
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  } catch (e) {
+    throw new Error(`Cannot write to ${filePath}: ${e.message}`);
+  }
+}
+
+async function writeBinaryWithRetry(filePath, data, maxRetries = 3) {
+  let lastErr;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      await ensureBinaryWritable(filePath);
+      fs.writeFileSync(filePath, data);
+      fs.chmodSync(filePath, 0o755);
+      emitBootstrapEvent('info', 'Binary written successfully', { path: filePath });
+      return;
+    } catch (e) {
+      lastErr = e;
+      emitBootstrapEvent('warn', `Write attempt ${attempt + 1} failed`, { error: e.message });
+      if (attempt < maxRetries - 1) {
+        await new Promise(r => setTimeout(r, 50 * Math.pow(2, attempt)));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+async function verifyBinaryHealth(filePath) {
+  try {
+    if (process.platform === 'win32') {
+      execSync(`"${filePath}" health > nul 2>&1`, { timeout: 5000, shell: true });
+    } else {
+      execSync(`"${filePath}" health > /dev/null 2>&1`, { timeout: 5000 });
+    }
+    emitBootstrapEvent('info', 'Binary health check passed');
+    return true;
+  } catch (e) {
+    emitBootstrapEvent('warn', 'Binary health check failed', { error: e.message });
+    return false;
+  }
+}
+
+async function spawnPlugkitWatcher(filePath) {
+  try {
+    emitBootstrapEvent('info', 'Spawning plugkit watcher daemon');
+
+    const cmd = process.platform === 'win32' ? filePath : filePath;
+    const proc = spawn(cmd, ['watch', '--once=false'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+
+    const pid = proc.pid;
+    proc.unref();
+
+    emitBootstrapEvent('info', 'Plugkit watcher spawned', { pid });
+    return pid;
+  } catch (e) {
+    emitBootstrapEvent('error', 'Failed to spawn plugkit watcher', { error: e.message });
+    throw e;
+  }
+}
+
+async function bootstrapPlugkit() {
+  const startTime = Date.now();
+
+  try {
+    emitBootstrapEvent('info', 'Bootstrap started');
+
+    const { version: manifestVersion, expectedHash } = readManifest();
+    const installedVersion = getInstalledVersion();
+    const plugkitPath = getPlugkitPath();
+
+    const versionMismatch = installedVersion !== manifestVersion;
+    const binaryMissing = !fs.existsSync(plugkitPath);
+
+    if (!binaryMissing && !versionMismatch) {
+      emitBootstrapEvent('info', 'Binary up-to-date', { version: installedVersion });
+
+      if (isProcessRunning('plugkit')) {
+        emitBootstrapEvent('info', 'Plugkit watcher already running');
+        const statusPayload = {
+          ok: true,
+          version: installedVersion,
+          status: 'running',
+          timestamp: new Date().toISOString(),
+          durationMs: Date.now() - startTime,
+        };
+        fs.mkdirSync(path.dirname(BOOTSTRAP_STATUS_FILE), { recursive: true });
+        fs.writeFileSync(BOOTSTRAP_STATUS_FILE, JSON.stringify(statusPayload, null, 2));
+        return { ok: true };
+      }
+    }
+
+    if (binaryMissing || versionMismatch) {
+      emitBootstrapEvent('info', 'Downloading binary', {
+        reason: binaryMissing ? 'missing' : 'version-mismatch',
+        version: manifestVersion,
+      });
+
+      let binaryData;
+      try {
+        binaryData = await downloadPlugkitBinary(manifestVersion);
+      } catch (downloadErr) {
+        emitBootstrapEvent('error', 'Download failed, checking for cached binary', {
+          error: downloadErr.message,
+          fallback: fs.existsSync(plugkitPath),
+        });
+
+        if (!fs.existsSync(plugkitPath)) {
+          throw downloadErr;
+        }
+        emitBootstrapEvent('info', 'Using cached binary as fallback');
+        binaryData = null;
+      }
+
+      if (binaryData) {
+        const downloadedHash = crypto.createHash('sha256').update(binaryData).digest('hex');
+        if (downloadedHash !== expectedHash) {
+          throw new Error(`Hash mismatch: got ${downloadedHash}, expected ${expectedHash}`);
+        }
+
+        killExistingPlugkit();
+        await writeBinaryWithRetry(plugkitPath, binaryData);
+
+        fs.mkdirSync(path.dirname(PLUGKIT_VERSION_FILE), { recursive: true });
+        fs.writeFileSync(PLUGKIT_VERSION_FILE, manifestVersion + '\n');
+        emitBootstrapEvent('info', 'Binary installed', { version: manifestVersion });
+      }
+    }
+
+    const isHealthy = await verifyBinaryHealth(plugkitPath);
+    if (!isHealthy) {
+      emitBootstrapEvent('warn', 'Binary health check failed, but proceeding');
+    }
+
+    const watcherRunning = isProcessRunning('plugkit');
+    let watcherPid;
+    if (!watcherRunning) {
+      watcherPid = await spawnPlugkitWatcher(plugkitPath);
+    } else {
+      watcherPid = 'already-running';
+      emitBootstrapEvent('info', 'Watcher already running');
+    }
+
+    const currentVersion = getInstalledVersion() || manifestVersion;
+    const statusPayload = {
+      ok: true,
+      version: currentVersion,
+      watcherPid,
+      timestamp: new Date().toISOString(),
+      durationMs: Date.now() - startTime,
+    };
+
+    fs.mkdirSync(path.dirname(BOOTSTRAP_STATUS_FILE), { recursive: true });
+    fs.writeFileSync(BOOTSTRAP_STATUS_FILE, JSON.stringify(statusPayload, null, 2));
+
+    emitBootstrapEvent('info', 'Bootstrap completed successfully', statusPayload);
+    return { ok: true };
+  } catch (err) {
+    const errorPayload = {
+      ok: false,
+      error: err.message,
+      timestamp: new Date().toISOString(),
+      durationMs: Date.now() - startTime,
+      stack: err.stack,
+    };
+
+    fs.mkdirSync(path.dirname(BOOTSTRAP_ERROR_FILE), { recursive: true });
+    fs.writeFileSync(BOOTSTRAP_ERROR_FILE, JSON.stringify(errorPayload, null, 2));
+
+    emitBootstrapEvent('error', 'Bootstrap failed', errorPayload);
+    console.error(`[skill-bootstrap] ${err.message}`);
+
+    return { ok: false, error: err.message };
+  }
+}
+
+async function checkPortReachable(host, port, timeoutMs = 500) {
+  try {
+    const result = await spool.execSpool('health', 'health', { timeoutMs, sessionId: process.env.CLAUDE_SESSION_ID || 'unknown' });
+    return !!(result && result.ok);
+  } catch (e) {
+    return false;
+  }
+}
+
+async function bootstrapAcptoapi() {
+  const port = 4800;
+  const running = await checkPortReachable('127.0.0.1', port);
+  if (running) return { ok: true, status: 'already-running' };
+
+  emitBootstrapEvent('info', 'Spawning acptoapi daemon');
+  try {
+    const child = spawn('bun', ['x', 'acptoapi@latest'], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+    child.unref();
+    emitBootstrapEvent('info', 'acptoapi spawned', { pid: child.pid });
+    return { ok: true, status: 'spawned', pid: child.pid };
+  } catch (e) {
+    emitBootstrapEvent('error', 'Failed to spawn acptoapi', { error: e.message });
+    return { ok: false, error: e.message };
+  }
+}
+
+async function getSnapshot(sessionId, cwd) {
+  const plugkitPath = getPlugkitPath();
+  if (!fs.existsSync(plugkitPath)) {
+    return { git: { ok: false }, tasks: [], error: 'plugkit not found' };
+  }
+
+  try {
+    const sid = sessionId || process.env.CLAUDE_SESSION_ID || 'default';
+    const c = cwd || process.cwd();
+    const cmd = `"${plugkitPath}" snapshot --session "${sid}" --cwd "${c}"`;
+    const output = execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return JSON.parse(output);
+  } catch (e) {
+    emitBootstrapEvent('warn', 'Failed to get snapshot', { error: e.message });
+    return { git: { ok: false }, tasks: [], error: e.message };
+  }
+}
+
+module.exports = { 
+  bootstrapPlugkit,
+  bootstrapAcptoapi,
+  getSnapshot,
+  checkPortReachable
+};

package/lib/spool-dispatch.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+async function dispatchSpool(cmd, lang, body, timeoutMs, sessionId) {
+  const taskId = `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+  const langDir = lang.match(/^(nodejs|python|bash|typescript|go|rust|c|cpp|java|deno)$/) ? lang : 'nodejs';
+  const ext = {
+    nodejs: 'js',
+    python: 'py',
+    bash: 'sh',
+    typescript: 'ts',
+    go: 'go',
+    rust: 'rs',
+    c: 'c',
+    cpp: 'cpp',
+    java: 'java',
+    deno: 'ts'
+  }[langDir] || 'js';
+
+  const inDir = path.join(process.cwd(), '.gm', 'exec-spool', 'in', langDir);
+  const outDir = path.join(process.cwd(), '.gm', 'exec-spool', 'out');
+  const inFile = path.join(inDir, `${taskId}.${ext}`);
+  const jsonFile = path.join(outDir, `${taskId}.json`);
+
+  fs.mkdirSync(inDir, { recursive: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  const code = sessionId ? `const SESSION_ID = '${sessionId}';\n${body}` : body;
+  fs.writeFileSync(inFile, code, 'utf8');
+
+  return pollForCompletion(jsonFile, timeoutMs, taskId);
+}
+
+async function pollForCompletion(jsonFile, timeoutMs, taskId) {
+  const start = Date.now();
+  const interval = 50;
+
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(jsonFile)) {
+      try {
+        const metadata = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+        const outFile = jsonFile.replace(/\.json$/, '.out');
+        const errFile = jsonFile.replace(/\.json$/, '.err');
+        const stdout = fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf8') : '';
+        const stderr = fs.existsSync(errFile) ? fs.readFileSync(errFile, 'utf8') : '';
+        return {
+          ok: metadata.exitCode === 0 && !metadata.timedOut,
+          exitCode: metadata.exitCode,
+          stdout,
+          stderr,
+          durationMs: metadata.durationMs,
+          taskId,
+          timedOut: metadata.timedOut || false
+        };
+      } catch (e) {
+        await new Promise(r => setTimeout(r, interval));
+      }
+    } else {
+      await new Promise(r => setTimeout(r, interval));
+    }
+  }
+
+  return {
+    ok: false,
+    exitCode: -1,
+    stdout: '',
+    stderr: `[spool dispatch timeout after ${timeoutMs}ms]`,
+    durationMs: Date.now() - start,
+    taskId,
+    timedOut: true
+  };
+}
+
+module.exports = { dispatchSpool };

package/lib/spool.js

@@ -0,0 +1,201 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getSpoolBaseDir() {
+  const cwd = process.cwd();
+  return path.join(cwd, '.gm', 'exec-spool');
+}
+
+function generateTaskId() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+}
+
+function validateLang(lang) {
+  const valid = ['nodejs', 'python', 'bash', 'typescript', 'go', 'rust', 'c', 'cpp', 'java', 'deno'];
+  return valid.includes(lang) ? lang : 'nodejs';
+}
+
+function getExtForLang(lang) {
+  const langExt = {
+    nodejs: 'js',
+    python: 'py',
+    bash: 'sh',
+    typescript: 'ts',
+    go: 'go',
+    rust: 'rs',
+    c: 'c',
+    cpp: 'cpp',
+    java: 'java',
+    deno: 'ts'
+  };
+  return langExt[lang] || 'js';
+}
+
+function validateVerb(verb) {
+  const valid = ['codesearch', 'recall', 'memorize', 'wait', 'sleep', 'status', 'close', 'browser', 'runner', 'type', 'kill-port', 'forget', 'feedback', 'learn-status', 'learn-debug', 'learn-build', 'discipline', 'pause', 'health'];
+  return valid.includes(verb) ? verb : 'status';
+}
+
+function writeSpool(body, lang = 'nodejs', options = {}) {
+  const validLang = validateLang(lang);
+  const ext = getExtForLang(validLang);
+  const taskId = options.taskId || generateTaskId();
+
+  const baseDir = getSpoolBaseDir();
+  const inDir = path.join(baseDir, 'in', validLang);
+  const inFile = path.join(inDir, `${taskId}.${ext}`);
+
+  fs.mkdirSync(inDir, { recursive: true });
+
+  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID;
+  const code = sessionId ? `const SESSION_ID = '${sessionId}';\n${body}` : body;
+
+  fs.writeFileSync(inFile, code, 'utf8');
+
+  return {
+    id: taskId,
+    path: inFile,
+    lang: validLang,
+    ext
+  };
+}
+
+function writeSpoolVerb(body, verb, options = {}) {
+  const validVerb = validateVerb(verb);
+  const taskId = options.taskId || generateTaskId();
+  const baseDir = getSpoolBaseDir();
+  const inDir = path.join(baseDir, 'in', validVerb);
+  const inFile = path.join(inDir, `${taskId}.txt`);
+  fs.mkdirSync(inDir, { recursive: true });
+  fs.writeFileSync(inFile, body, 'utf8');
+  return { id: taskId, path: inFile, verb: validVerb };
+}
+
+function readSpoolOutput(id) {
+  const baseDir = getSpoolBaseDir();
+  const outDir = path.join(baseDir, 'out');
+
+  const outFile = path.join(outDir, `${id}.out`);
+  const errFile = path.join(outDir, `${id}.err`);
+  const jsonFile = path.join(outDir, `${id}.json`);
+
+  const stdout = fs.existsSync(outFile) ? fs.readFileSync(outFile, 'utf8') : '';
+  const stderr = fs.existsSync(errFile) ? fs.readFileSync(errFile, 'utf8') : '';
+
+  let metadata = {};
+  if (fs.existsSync(jsonFile)) {
+    try {
+      metadata = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+    } catch (e) {
+      metadata = { error: 'Failed to parse metadata' };
+    }
+  }
+
+  return {
+    id,
+    stdout,
+    stderr,
+    metadata,
+    exitCode: metadata.exitCode,
+    durationMs: metadata.durationMs,
+    timedOut: metadata.timedOut || false
+  };
+}
+
+async function waitForCompletion(id, timeoutMs = 30000) {
+  const baseDir = getSpoolBaseDir();
+  const outDir = path.join(baseDir, 'out');
+  const jsonFile = path.join(outDir, `${id}.json`);
+
+  const start = Date.now();
+  const interval = 50;
+
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(jsonFile)) {
+      try {
+        const metadata = JSON.parse(fs.readFileSync(jsonFile, 'utf8'));
+        const output = readSpoolOutput(id);
+        return {
+          ok: metadata.exitCode === 0 && !metadata.timedOut,
+          ...output
+        };
+      } catch (e) {
+        await new Promise(r => setTimeout(r, interval));
+      }
+    } else {
+      await new Promise(r => setTimeout(r, interval));
+    }
+  }
+
+  const output = readSpoolOutput(id);
+  return {
+    ok: false,
+    ...output,
+    timedOut: true,
+    stderr: output.stderr + `\n[spool timeout after ${timeoutMs}ms]`
+  };
+}
+
+async function execSpool(body, lang, options = {}) {
+  const timeoutMs = options.timeoutMs || 30000;
+  const sessionId = options.sessionId || process.env.CLAUDE_SESSION_ID;
+  const task = lang === 'nodejs' || lang === 'bash' ? writeSpool(body, lang, { sessionId }) : writeSpoolVerb(body, lang, {});
+  const result = await waitForCompletion(task.id, timeoutMs);
+  if (options.cleanup !== false) {
+    try { fs.unlinkSync(task.path); } catch (e) {}
+  }
+  return result;
+}
+
+async function execCodesearch(query, options = {}) { return execSpool(query, 'codesearch', options); }
+async function execRecall(query, options = {}) { return execSpool(query, 'recall', options); }
+async function execMemorize(fact, options = {}) { return execSpool(fact, 'memorize', options); }
+
+function getAllOutputs() {
+  const baseDir = getSpoolBaseDir();
+  const outDir = path.join(baseDir, 'out');
+
+  if (!fs.existsSync(outDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(outDir);
+  const taskIds = new Set();
+
+  files.forEach(file => {
+    const match = file.match(/^(.+?)\.(out|err|json)$/);
+    if (match) {
+      taskIds.add(match[1]);
+    }
+  });
+
+  return Array.from(taskIds).map(id => readSpoolOutput(id));
+}
+
+async function getEvents(sessionId, cwd) {
+  try {
+    const { getSnapshot } = require('./skill-bootstrap');
+    return await getSnapshot(sessionId, cwd);
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+module.exports = {
+  writeSpool,
+  writeSpoolVerb,
+  readSpoolOutput,
+  waitForCompletion,
+  execSpool,
+  execCodesearch,
+  execRecall,
+  execMemorize,
+  getAllOutputs,
+  getSpoolBaseDir,
+  generateTaskId,
+  validateLang,
+  getExtForLang,
+  validateVerb,
+  getEvents
+};

package/manifest.yml

@@ -1,5 +1,5 @@
 name: gm
-version: 2.0.1066
+version: 2.0.1067
 description: State machine agent with hooks, skills, and automated git enforcement
 author: AnEntrypoint