@yemi33/minions 0.1.2061 → 0.1.2062

package/engine/queries.js

@@ -789,12 +789,24 @@ let _skillsCacheKey = null;
 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
+// 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
+// invalidateSkillsCache() call still flushes everything.
+let _getSkillsResultCache = null;
+let _getSkillsResultCacheTs = 0;
+let _getSkillsResultCacheKey = null;
 const SKILLS_CACHE_TTL = 30000; // 30s — skill files change rarely (agent extraction, manual authoring)
 
 function invalidateSkillsCache() {
   _skillsCache = null;
   _skillsCacheTs = 0;
   _skillsCacheKey = null;
+  _getSkillsResultCache = null;
+  _getSkillsResultCacheTs = 0;
+  _getSkillsResultCacheKey = null;
   _skillIndexCache = null;
   _skillIndexCacheTs = 0;
   _skillIndexCacheKey = null;
@@ -906,6 +918,18 @@ 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
+  // 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
+  // flushes everything in one shot.
+  const now = Date.now();
+  config = config || getConfig();
+  const cacheKey = _skillsCacheKeyFor(config, os.homedir());
+  if (_getSkillsResultCache && _getSkillsResultCacheKey === cacheKey && (now - _getSkillsResultCacheTs) < SKILLS_CACHE_TTL) {
+    return _getSkillsResultCache;
+  }
   const all = [];
   for (const { file: f, dir, scope, projectName, skillName } of collectSkillFiles(config)) {
     try {
@@ -923,6 +947,9 @@ function getSkills(config) {
       });
     } catch { /* optional */ }
   }
+  _getSkillsResultCache = all;
+  _getSkillsResultCacheTs = now;
+  _getSkillsResultCacheKey = cacheKey;
   return all;
 }
 
@@ -2143,8 +2170,34 @@ function resetProjectGitStatusCache() {
  * so a 5-project fleet runs 14 statSync calls per cache miss — bounded
  * and unmeasurable in benchmarks.
  */
+// Cache the slow-state path list: it only changes when projects are added/
+// removed or runtimes are registered/deregistered (essentially process-
+// lifetime stable in practice). Without it we walked runtime-registry +
+// projects + resolved per-project gitdir/commondir on every /api/status
+// rebuild — ~7.5ms per call. The fast-state list is cheaper (~2ms) but
+// we cache it too for symmetry. Cache key is keyed off the project list
+// shape so a new project (rare event, goes through configMutation +
+// invalidateStatusCache) invalidates correctly.
+let _fastMtimePathsCache = null;
+let _fastMtimePathsCacheKey = null;
+let _slowMtimePathsCache = null;
+let _slowMtimePathsCacheKey = null;
+function _mtimePathsCacheKey(config) {
+  const projects = getProjects(config).map(p => (p.name || '') + '|' + (p.localPath || ''));
+  return projects.join(';');
+}
+function _invalidateMtimePathsCache() {
+  _fastMtimePathsCache = null;
+  _fastMtimePathsCacheKey = null;
+  _slowMtimePathsCache = null;
+  _slowMtimePathsCacheKey = null;
+}
+
 function getStatusFastStateMtimePaths(config) {
-  const projects = getProjects(config || getConfig());
+  config = config || getConfig();
+  const cacheKey = _mtimePathsCacheKey(config);
+  if (_fastMtimePathsCache && _fastMtimePathsCacheKey === cacheKey) return _fastMtimePathsCache;
+  const projects = getProjects(config);
   const files = [
     // Engine-level state surfaced by getDispatchQueue. `control.json`,
     // `log.json`, and `metrics.json` are intentionally omitted — see the
@@ -2234,6 +2287,8 @@ function getStatusFastStateMtimePaths(config) {
       files.push(path.join(commonGitDir, 'FETCH_HEAD'));
     }
   }
+  _fastMtimePathsCache = files;
+  _fastMtimePathsCacheKey = cacheKey;
   return files;
 }
 
@@ -2307,6 +2362,8 @@ function getStatusFastStateMtimePaths(config) {
  */
 function getStatusSlowStateMtimePaths(config) {
   config = config || getConfig();
+  const cacheKey = _mtimePathsCacheKey(config);
+  if (_slowMtimePathsCache && _slowMtimePathsCacheKey === cacheKey) return _slowMtimePathsCache;
   const projects = getProjects(config);
   const homeDir = os.homedir();
   const files = [
@@ -2328,6 +2385,15 @@ function getStatusSlowStateMtimePaths(config) {
     // invalidateStatusCache({includeSlow:true}); tracker entry catches any
     // CLI/editor edit that bypasses the API.
     path.join(MINIONS_DIR, 'pinned.md'),
+    // work-items.json — central + per-project files (per-project pushed below
+    // alongside the PR paths). The PRD progress slice in slow-state is
+    // *derived* from work-item statuses via getPrdInfo's input-hash, so a
+    // WI flipping dispatched→done changes prdProgress without touching any
+    // file in this tracker. Without this entry the slow-state cache hangs
+    // on stale PRD progress for up to 60s after a WI completes (user
+    // report: visit /plans, see all items active; switch to /home + hard
+    // refresh; the WIs are done; return to /plans, now items show as done).
+    path.join(MINIONS_DIR, 'work-items.json'),
   ];
 
   // Skill discovery roots (surfaced by _buildStatusSlowState → getSkills).
@@ -2378,8 +2444,17 @@ function getStatusSlowStateMtimePaths(config) {
     const commonGitDir = _resolveCommonGitDir(gitDir);
     files.push(path.join(gitDir, 'logs', 'HEAD'));
     files.push(path.join(commonGitDir, 'FETCH_HEAD'));
+    // Per-project work-items.json + pull-requests.json — same reason as the
+    // central work-items.json above: the prdProgress slice is derived from
+    // their contents via getPrdInfo's input hash. A WI completion in a
+    // project that uses its own work-items.json file would otherwise hang
+    // slow-state until TTL.
+    try { files.push(projectWorkItemsPath(project)); } catch { /* path helper optional */ }
+    try { files.push(projectPrPath(project)); } catch { /* path helper optional */ }
   }
 
+  _slowMtimePathsCache = files;
+  _slowMtimePathsCacheKey = cacheKey;
   return files;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2061",
+  "version": "0.1.2062",
   "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"