@yemi33/minions 0.1.2036 → 0.1.2037

package/dashboard/js/refresh.js

@@ -122,7 +122,7 @@ function _formatCcDrawerLabel(autoMode) {
 
 function _processStatusUpdate(data) {
   // Detect fresh install — clear stale browser state AND reload so module-scoped
-  // JS caches (_sectionCache, _prevCounts, _kbRefreshCount, _managedProcessesLastItems,
+  // JS caches (_sectionCache, _prevCounts, _managedProcessesLastItems,
   // _pipelinePollHash, _meetingPollHash, etc.) reinitialise against the new install's
   // data shape. localStorage.clear() alone leaves those caches stale after a
   // MINIONS_HOME swap that doesn't restart the dashboard (F11 / W-mpgcijjo000ce878).
@@ -252,16 +252,25 @@ function _processStatusUpdate(data) {
   if (swi) swi.textContent = (data.workItems || []).length || '';
   const spr = document.getElementById('sidebar-pr');
   if (spr) spr.textContent = (data.pullRequests || []).length || '';
-  // Refresh KB and plans less frequently (every 3rd cycle = ~12s)
-  if (!window._kbRefreshCount) window._kbRefreshCount = 0;
-  if (window._kbRefreshCount++ % 3 === 0) { refreshKnowledgeBase(); refreshPlans(); }
+  // Refresh KB and plans every status cycle (~4s) so plan status flips
+  // (approve/archive/complete) and KB additions surface within the SPA's
+  // 4s poll target. Server-side caches keep this cheap:
+  //   - /api/plans: 5s in-memory TTL + invalidation on every mutating endpoint
+  //     (dashboard.js _plansCache / invalidatePlansCache) — back-to-back polls
+  //     hit the cache; external file edits surface within 5s.
+  //   - /api/knowledge: 30s in-memory TTL + invalidation on POST /api/knowledge
+  //     and after every kb-sweep (engine/queries.js _kbCache / kb-sweep.js).
+  // Previously throttled to every 3rd cycle (~12s) — see W-mphfb6ss000a3b9e
+  // for the cadence audit + Playwright coverage.
+  refreshKnowledgeBase();
+  refreshPlans();
 
   // Cross-slice render triggers (F1/F3, W-mpgb0xbh000e3b86): renderPrs reads
   // window._lastWorkItems for the +N follow-up chip count and derivePlanStatus
   // reads window._lastStatus.pullRequests for verify-follow-up reconciliation.
   // When workItems OR pullRequests change, re-render the dependents against the
-  // freshest cached data — without waiting up to 12s for the next refreshPlans
-  // cycle (F3) or for a PR object to mutate (F1). Runs after the window._last*
+  // freshest cached data — without waiting for the next refreshPlans cycle (F3)
+  // or for a PR object to mutate (F1). Runs after the window._last*
   // assignments above so the cached globals these renderers consult are fresh.
   if (_workItemsChanged && !_prsChanged) {
     // F1: only the work-item slice moved this tick — renderPrs wasn't called
@@ -271,9 +280,9 @@ function _processStatusUpdate(data) {
   }
   if ((_workItemsChanged || _prsChanged) && Array.isArray(window._lastPlans) && typeof renderPlans === 'function') {
     // F3: derivePlanStatus + _renderVerifyBadge derive from pullRequests +
-    // workItems. Re-render against the cached plan list so plan status flips
-    // within one /api/status tick (~4s) instead of one refreshPlans poll
-    // (~12s). No-op when _lastPlans hasn't been populated yet (first load).
+    // workItems. Re-render against cached plans so plan status flips within
+    // one /api/status tick (~4s) instead of one refreshPlans poll. No-op
+    // until _lastPlans is populated.
     renderPlans(window._lastPlans);
   }
 

package/dashboard/js/state.js

@@ -27,10 +27,13 @@ let currentPage = getPageFromUrl();
 
 // W-mpgb0xa7000d90d4 (dashboard-refresh-audit.md F5) — switchPage previously
 // only cleaned intervals and flipped CSS; tabs like /plans and /inbox waited
-// up to ~12s for refresh.js's slow-cycle (refreshKnowledgeBase + refreshPlans
-// every 3rd status tick) before showing fresh data. The QA tab worked around
-// this with its own switchPage monkey-patch in qa.js (__qaWrapped) — that
-// per-tab pattern is now generalized into one canonical lifecycle below.
+// for refresh.js's next slow-cycle (refreshKnowledgeBase + refreshPlans) before
+// showing fresh data. The QA tab worked around this with its own switchPage
+// monkey-patch in qa.js (__qaWrapped) — that per-tab pattern is now generalized
+// into one canonical lifecycle below. (As of W-mphfb6ss000a3b9e the slow-cycle
+// modulo was dropped, so refreshPlans/refreshKnowledgeBase now run every 4s
+// status tick — but the page-enter loader still wins on tab-switch because it
+// fires synchronously without waiting for the next interval boundary.)
 //
 // PAGE_LAZY_LOADERS: functions to invoke when ENTERING a page (resolved by
 // name through window so the function body can live alongside its tab UI).

package/dashboard.js

@@ -1628,6 +1628,20 @@ function _getSlowMtimes() {
   return result;
 }
 
+// Reset the per-source caches that outlive the slow-state TTL when a tracked
+// source file changes (W-mphfdgwv000bf549). The slow-state mtime tracker now
+// covers skill discovery dirs and MCP config files, but
+// `queries._skillsCache` (30 s) and the local `_mcpServersCache` (5 min)
+// would still serve stale data into `_buildStatusSlowState()` — defeating
+// the <4 s freshness goal. Only call this when an mtime delta is detected;
+// TTL-driven rebuilds keep using the inner caches so we don't pay disk-scan
+// cost on every 60 s slow-state rollover.
+function _invalidateSlowInnerCachesForMtimeChange() {
+  try { queries.invalidateSkillsCache(); } catch { /* optional */ }
+  _mcpServersCache = null;
+  _mcpServersCacheTs = 0;
+}
+
 function _mtimesChanged(prev, curr) {
   for (const fp of Object.keys(curr)) {
     if (prev[fp] !== curr[fp]) return true;
@@ -1838,9 +1852,13 @@ function getStatus() {
   // so changes surface within one SPA poll (~4 s) instead of waiting up to
   // 60 s for TTL. Same pre-build snapshot semantics as fast-state below.
   let slowStale = !_slowState || (now - _slowStateTs) >= SLOW_STATE_TTL;
+  let slowMtimeChanged = false;
   if (!slowStale) {
     const currSlowMtimes = _getSlowMtimes();
-    if (_mtimesChanged(_lastSlowMtimes, currSlowMtimes)) slowStale = true;
+    if (_mtimesChanged(_lastSlowMtimes, currSlowMtimes)) {
+      slowStale = true;
+      slowMtimeChanged = true;
+    }
   }
 
   // If nothing stale, return cached merged result
@@ -1867,6 +1885,7 @@ function getStatus() {
   // Same pre-build snapshot pattern as fast-state — capture mtimes BEFORE
   // disk reads so any write landing mid-build busts the next poll.
   if (slowStale) {
+    if (slowMtimeChanged) _invalidateSlowInnerCachesForMtimeChange();
     const preBuildSlowMtimes = _getSlowMtimes();
     _slowState = _buildStatusSlowState();
     _slowStateTs = now;
@@ -1912,9 +1931,13 @@ function refreshStatusAsync() {
         if (_mtimesChanged(_lastMtimes, currMtimes)) fastStale = true;
       }
       let slowStale = !_slowState || (now - _slowStateTs) >= SLOW_STATE_TTL;
+      let slowMtimeChanged = false;
       if (!slowStale) {
         const currSlowMtimes = _getSlowMtimes();
-        if (_mtimesChanged(_lastSlowMtimes, currSlowMtimes)) slowStale = true;
+        if (_mtimesChanged(_lastSlowMtimes, currSlowMtimes)) {
+          slowStale = true;
+          slowMtimeChanged = true;
+        }
       }
 
       if (!fastStale && !slowStale && _statusCache) return _statusCache;
@@ -1944,6 +1967,7 @@ function refreshStatusAsync() {
       let slow = _slowState;
       let preBuildSlowMtimes = null;
       if (slowStale) {
+        if (slowMtimeChanged) _invalidateSlowInnerCachesForMtimeChange();
         preBuildSlowMtimes = _getSlowMtimes();
         slow = _buildStatusSlowState();
       }

package/engine/queries.js

@@ -2079,25 +2079,43 @@ function getStatusFastStateMtimePaths(config) {
  *   - Per-project paths must use `shared.project*` so newly-added projects
  *     are picked up without registry edits.
  *
+ * 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.
+ *
  * Files intentionally NOT tracked here:
- *   - `mcpServers`, version, autoMode, installId — change only on human/
- *     CLI edits, which already pop the slow-state via reloadConfig + the
- *     60 s TTL.
- *   - `~/.claude/skills/`, `~/.copilot/skills/`, `<project>/.claude/skills/`,
- *     `<project>/.github/skills/` — `extractSkillsFromOutput` writes here
- *     from the agent-close path, which already calls
- *     `invalidateStatusCache({includeSlow: true})` directly. Tracking the
- *     user-home dir is additionally harmful because it's shared with every
- *     Claude Code session on the machine; non-Minions activity would
- *     otherwise bust this fleet's dashboard cache.
+ *   - version, autoMode, installId — change only on human/CLI edits, which
+ *     already pop the slow-state via reloadConfig + the 60 s TTL.
  *   - project git state — already invalidated via the
  *     `_setOnProjectGitStatusChanged` callback into `invalidateStatusCache`
  *     (W-mpgrk5cy fix); also tracked in fast-state via `.git/logs/HEAD`.
+ *
+ * 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 accepted for symmetry with getStatusFastStateMtimePaths but
-  // unused — every entry below is a fleet-global path.
-  return [
+function getStatusSlowStateMtimePaths(config) {
+  config = config || getConfig();
+  const projects = getProjects(config);
+  const homeDir = os.homedir();
+  const files = [
     // prd/*.json (surfaced by getPrdInfo) — engine writes via syncPrdFromPrs,
     // the materializer, and plan-to-prd outputs.
     PRD_DIR,
@@ -2117,6 +2135,42 @@ function getStatusSlowStateMtimePaths(_config) {
     // CLI/editor edit that bypasses the API.
     path.join(MINIONS_DIR, 'pinned.md'),
   ];
+
+  // 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'));
+    }
+  }
+
+  return files;
 }
 
 // ── Exports ─────────────────────────────────────────────────────────────────

package/package.json

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