@yemi33/minions 0.1.2401 → 0.1.2403

package/engine/queries.js

@@ -1219,7 +1219,7 @@ let _skillIndexCache = null;
 let _skillIndexCacheTs = 0;
 let _skillIndexCacheKey = null;
 // Top-level cache for getSkills (the read+parse + meta-build path layered on
-// top of collectSkillFiles). Without this, every /api/status slow-state
+// top of collectSkillFiles). Without this, every /api/tools inventory scan
 // rebuild re-read and re-parsed all ~80 SKILL.md files (~29ms warm even
 // though collectSkillFiles itself was cached) because getSkills did the
 // I/O on the cached file list. Shares the same 30s TTL + cacheKey so an
@@ -1465,8 +1465,8 @@ const SKILL_SOURCE_BY_SCOPE = {
 };
 
 function getSkills(config) {
-  // Cache the entire read+parse round, not just the file list. /api/status
-  // slow-state calls getSkills on every rebuild and re-reading 80+ SKILL.md
+  // Cache the entire read+parse round, not just the file list. /api/tools
+  // historically called getSkills on every rebuild; re-reading 80+ SKILL.md
   // files + re-parsing their YAML frontmatter cost ~29ms each time (the
   // single biggest hot-path offender after getPrdInfo cold). 30s TTL +
   // shared cacheKey with collectSkillFiles so invalidateSkillsCache() still
@@ -1631,8 +1631,8 @@ function _commandTitle(content, fallback) {
 }
 
 // Dashboard-facing wrapper over `collectCommandFiles`. Returns a normalized
-// per-entry shape the tools.html "Slash commands" panel + `/api/status`
-// slow-state slice render directly. Includes the resolved title (from YAML
+// per-entry shape the tools.html "Slash commands" panel + `/api/tools`
+// response renders directly. Includes the resolved title (from YAML
 // `description:` frontmatter or first `# heading`) and a `dir`-with-forward-
 // slashes copy so the renderer can build display strings without re-walking
 // the file on the client. Sort matches getCommandIndex (project → plugin →
@@ -2838,6 +2838,31 @@ function _resolveCommonGitDir(gitDir) {
   return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
 }
 
+async function _resolveGitDirAsync(localPath) {
+  if (!localPath) return null;
+  const gitPath = path.join(localPath, '.git');
+  let stat;
+  try { stat = await fs.promises.stat(gitPath); }
+  catch { return null; }
+  if (stat.isDirectory()) return gitPath;
+  if (!stat.isFile()) return null;
+  let raw;
+  try { raw = (await fs.promises.readFile(gitPath, 'utf8')).slice(0, 4096); }
+  catch { return null; }
+  const match = /^gitdir:\s*(.+?)\s*$/m.exec(raw);
+  if (!match) return null;
+  return path.isAbsolute(match[1]) ? match[1] : path.resolve(localPath, match[1]);
+}
+
+async function _resolveCommonGitDirAsync(gitDir) {
+  if (!gitDir) return null;
+  let raw;
+  try { raw = (await fs.promises.readFile(path.join(gitDir, 'commondir'), 'utf8')).trim(); }
+  catch { return gitDir; }
+  if (!raw) return gitDir;
+  return path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
+}
+
 // Enumerate the per-project git ref files we watch for cache-busting, split
 // into two groups (W-mrb6qnuc000785b2):
 //   identityFiles — HEAD + logs/HEAD, resolved against the PER-WORKTREE
@@ -3084,6 +3109,8 @@ let _fastMtimePathsCache = null;
 let _fastMtimePathsCacheKey = null;
 let _slowMtimePathsCache = null;
 let _slowMtimePathsCacheKey = null;
+let _slowMtimePathsAsyncCache = null;
+let _slowMtimePathsAsyncCacheKey = null;
 function _mtimePathsCacheKey(config) {
   const projects = getProjects(config).map(p => (p.name || '') + '|' + (p.localPath || ''));
   return projects.join(';');
@@ -3102,26 +3129,10 @@ function getStatusFastStateMtimePaths(config) {
 /**
  * Slow-state mtime tracker — symmetric with the fast-state registry above.
  *
- * Slow-state mtime tracking covers only intentionally file-backed inputs such
- * as config, skills, MCP settings, and project git metadata.
- *
- * Skill and MCP source paths (W-mphfdgwv000bf549):
- *   - Skill discovery roots (`~/.claude/skills`, `~/.copilot/skills`,
- *     `~/.agents/skills`, `<project>/.claude/skills`, `<project>/.github/skills`,
- *     `<project>/.agents/skills`) plus plugin registries are tracked here
- *     because manual `SKILL.md` drops bypass the agent-close
- *     `invalidateStatusCache({includeSlow:true})` path that previously
- *     covered the agent-extraction case. Directory mtime advances reliably
- *     on Windows NTFS when a subdirectory is added/removed (verified via
- *     INBOX_DIR). Tracking the user-home dirs means non-Minions skill
- *     installs on this machine also bust the fleet's slow-state — but skill
- *     dirs only mutate on rare events (install / manual edit), not on every
- *     CLI command, so the steady-state noise is negligible.
- *   - MCP config files (`~/.claude.json`, `~/.copilot/mcp-config.json`,
- *     `<project>/.mcp.json`) feed `getMcpServers()`. `~/.claude.json`
- *     stores more than `mcpServers`, but it only flips on intentional
- *     Claude CLI mutations (mcp add/remove, settings edits), not on every
- *     prompt, so whole-file tracking is acceptable.
+ * Slow-state mtime tracking covers only file-backed inputs that remain in
+ * /api/status: config, install/version files, and project git metadata.
+ * Skills, commands, and MCP settings are discovered by the isolated
+ * /api/tools child process and no longer invalidate the global status cache.
  *
  * Per-project `.git/logs/HEAD` + `.git/FETCH_HEAD` ARE tracked here in
  * addition to the fast-state tracker. The project payload (`projects:`
@@ -3142,21 +3153,14 @@ function getStatusFastStateMtimePaths(config) {
  * gitdir, not the per-worktree subdir, so tracking the per-worktree
  * path would silently miss every fetch).
  *
- * NOTE: Detecting a change here busts the dashboard's slow-state cache, but
- * the inner per-source caches (`queries._skillsCache` 30 s, dashboard's
- * `_mcpServersCache` 5 min) survive across `_buildStatusSlowState()` calls.
- * dashboard.js calls `queries.invalidateSkillsCache()` and resets
- * `_mcpServersCache` whenever this tracker fires, so the rebuild reads
- * fresh disk state. Keep that invalidation wired up if you add new sources.
  */
 function getStatusSlowStateMtimePaths(config) {
   config = config || getConfig();
   const cacheKey = _mtimePathsCacheKey(config);
   if (_slowMtimePathsCache && _slowMtimePathsCacheKey === cacheKey) return _slowMtimePathsCache;
   const projects = getProjects(config);
-  const homeDir = os.homedir();
-  // Issue #2949 — slow-state now contains ONLY skills, mcpServers, projects,
-  // autoMode, initialized, installId, version. PRD/PRDProgress/verifyGuides/
+  // Issue #2949 — slow-state now contains ONLY projects, autoMode,
+  // initialized, installId, and version. PRD/PRDProgress/verifyGuides/
   // archivedPrds/schedules/pipelines/pinned/work-items all moved to dedicated
   // /api/<x> endpoints which carry their own ETags; tracking their backing
   // files here would bust the /api/status outer cache for slices that aren't
@@ -3171,40 +3175,6 @@ function getStatusSlowStateMtimePaths(config) {
   files.push(path.join(MINIONS_DIR, '.install-id'));
   files.push(path.join(MINIONS_DIR, 'package.json'));
 
-  // Skill discovery roots (surfaced by _buildStatusSlowState → getSkills).
-  // Mirrors collectSkillFiles' source enumeration so adding a new runtime
-  // adapter automatically extends the tracker. ENOENT is tolerated by
-  // dashboard._statMtimeMs (returns 0), so absent dirs cost nothing.
-  try {
-    const { listRuntimes, resolveRuntime } = require('./runtimes');
-    for (const runtimeName of listRuntimes()) {
-      const runtime = resolveRuntime(runtimeName);
-      if (typeof runtime.getSkillRoots !== 'function') continue;
-      for (const root of runtime.getSkillRoots({ homeDir })) {
-        if (root && root.dir) files.push(root.dir);
-      }
-      for (const project of projects) {
-        if (!project || !project.localPath) continue;
-        for (const root of runtime.getSkillRoots({ homeDir, project })) {
-          if (root && root.dir) files.push(root.dir);
-        }
-      }
-    }
-  } catch { /* runtime registry optional in partial installs */ }
-
-  // Plugin skill registries (also feed collectSkillFiles).
-  files.push(path.join(homeDir, '.claude', 'plugins', 'installed_plugins.json'));
-  files.push(path.join(homeDir, '.copilot', 'installed-plugins'));
-
-  // MCP server config files (surfaced by _buildStatusSlowState → getMcpServers).
-  files.push(path.join(homeDir, '.claude.json'));
-  files.push(path.join(homeDir, '.copilot', 'mcp-config.json'));
-  for (const project of projects) {
-    if (project && project.localPath) {
-      files.push(path.join(project.localPath, '.mcp.json'));
-    }
-  }
-
   // Per-project git refs — see the "Per-project .git/logs/HEAD" note in
   // the header. Same pair the fast-state tracker watches; `logs/HEAD` is
   // per-worktree (resolved via `_resolveGitDir`) while `FETCH_HEAD` lives
@@ -3230,6 +3200,34 @@ function getStatusSlowStateMtimePaths(config) {
   return files;
 }
 
+async function getStatusSlowStateMtimePathsAsync(config) {
+  config = config || getConfig();
+  const cacheKey = _mtimePathsCacheKey(config);
+  if (_slowMtimePathsAsyncCache && _slowMtimePathsAsyncCacheKey === cacheKey) {
+    return _slowMtimePathsAsyncCache;
+  }
+  const files = [
+    CONFIG_PATH,
+    path.join(MINIONS_DIR, '.install-id'),
+    path.join(MINIONS_DIR, 'package.json'),
+  ];
+  const projectPaths = await Promise.all(getProjects(config).map(async project => {
+    if (!project?.localPath) return [];
+    const gitDir = await _resolveGitDirAsync(project.localPath)
+      || path.join(project.localPath, '.git');
+    const commonGitDir = await _resolveCommonGitDirAsync(gitDir);
+    return [
+      path.join(gitDir, 'HEAD'),
+      path.join(gitDir, 'logs', 'HEAD'),
+      path.join(commonGitDir, 'FETCH_HEAD'),
+    ];
+  }));
+  for (const paths of projectPaths) files.push(...paths);
+  _slowMtimePathsAsyncCache = files;
+  _slowMtimePathsAsyncCacheKey = cacheKey;
+  return files;
+}
+
 // ── Exports ─────────────────────────────────────────────────────────────────
 
 module.exports = {
@@ -3255,6 +3253,7 @@ module.exports = {
   // W-mpftp7na000td0f4 — engine→dashboard cache-invalidation registry
   getStatusFastStateMtimePaths,
   getStatusSlowStateMtimePaths,
+  getStatusSlowStateMtimePathsAsync,
 
   // Core state
   getConfig, getControl, getDispatch, getDispatchQueue, getDispatchCompletionReport, invalidateDispatchCache,

package/engine/tools-inventory.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const shared = require('./shared');
+const queries = require('./queries');
+
+function readClaudeUserMcpServers(homeDir = os.homedir()) {
+  try {
+    const data = shared.safeJsonObj(path.join(homeDir, '.claude.json'));
+    const servers = data?.mcpServers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      source: 'Claude user',
+      command: cfg.command || cfg.url || '',
+      args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function readCopilotUserMcpServers(homeDir = os.homedir()) {
+  try {
+    const configPath = path.join(homeDir, '.copilot', 'mcp-config.json');
+    if (!fs.existsSync(configPath)) return [];
+    let raw = fs.readFileSync(configPath, 'utf8');
+    if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
+    const data = JSON.parse(raw);
+    const servers = data?.mcpServers || {};
+    return Object.entries(servers).map(([name, cfg]) => ({
+      name,
+      source: 'Copilot',
+      command: cfg.command || cfg.url || '',
+      args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+    }));
+  } catch {
+    return [];
+  }
+}
+
+function readWorkspaceMcpServers(projects) {
+  const out = [];
+  for (const project of projects || []) {
+    if (!project?.localPath) continue;
+    const data = shared.safeJsonObj(path.join(project.localPath, '.mcp.json'));
+    for (const [name, cfg] of Object.entries(data.mcpServers || {})) {
+      out.push({
+        name,
+        source: `Workspace: ${project.name}`,
+        command: cfg.command || cfg.url || '',
+        args: Array.isArray(cfg.args) ? cfg.args.join(' ') : (cfg.args || ''),
+      });
+    }
+  }
+  return out;
+}
+
+function dedupeMcpServers(entries) {
+  const seen = new Set();
+  const out = [];
+  for (const entry of entries) {
+    const key = `${entry.source}::${entry.name}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(entry);
+  }
+  return out;
+}
+
+function getMcpServers(projects, homeDir = os.homedir()) {
+  return dedupeMcpServers([
+    ...readClaudeUserMcpServers(homeDir),
+    ...readCopilotUserMcpServers(homeDir),
+    ...readWorkspaceMcpServers(projects),
+  ]);
+}
+
+function buildToolsInventory(config = queries.getConfig()) {
+  return {
+    skills: queries.getSkills(config),
+    commands: queries.getCommands(config),
+    mcpServers: getMcpServers(shared.getProjects(config)),
+  };
+}
+
+if (require.main === module) {
+  try {
+    process.stdout.write(JSON.stringify(buildToolsInventory()));
+  } catch (error) {
+    process.stderr.write(`tools-inventory: ${error.message}\n`);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  buildToolsInventory,
+  getMcpServers,
+  readClaudeUserMcpServers,
+  readCopilotUserMcpServers,
+  readWorkspaceMcpServers,
+  dedupeMcpServers,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2401",
+  "version": "0.1.2403",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"