@yemi33/minions 0.1.2016 → 0.1.2017

package/dashboard/js/qa.js

@@ -465,28 +465,17 @@ function qaOpenRunAgent(workItemId, agentId) {
 }
 
 // ── Page-navigation hooks ──────────────────────────────────────────────────
-// switchPage wrapper:
-//  - clears the runs polling interval (section 3) so the QA page stops
-//    polling when the user navigates away
-//  - closes any open managed-log SSE stream so a modal opened from /engine
-//    doesn't keep streaming behind the new page
-//  - lazily kicks off QA page loads + polling when entering /qa
-(function () {
-  if (typeof switchPage !== 'function' || switchPage.__qaWrapped) return;
-  const _origSwitchPage = switchPage;
-  window.switchPage = function (page, pushState) {
-    try { if (typeof closeManagedLog === 'function') closeManagedLog(); } catch {}
-    try { _stopQaRunsPoll(); } catch {}
-    const ret = _origSwitchPage(page, pushState);
-    if (page === 'qa') {
-      try { loadQaTargets(); } catch {}
-      try { loadQaRunbooks(); } catch {}
-      try { _startQaRunsPoll(); } catch {}
-    }
-    return ret;
-  };
-  window.switchPage.__qaWrapped = true;
-})();
+// W-mpgb0xa7000d90d4 — the per-tab switchPage monkey-patch this file used to
+// install (__qaWrapped wrapper that called closeManagedLog + _stopQaRunsPoll
+// on every navigation and kicked off loadQaTargets / loadQaRunbooks /
+// _startQaRunsPoll on enter) has been generalized into one canonical
+// lifecycle. See `PAGE_LAZY_LOADERS` + `PAGE_LEAVE_HOOKS` in state.js:
+//   - QA enter hooks live in PAGE_LAZY_LOADERS.qa
+//   - closeManagedLog + _stopQaRunsPoll live in PAGE_LEAVE_HOOKS (fire on
+//     every page transition — both are no-ops when nothing is active)
+// The loader / stop functions themselves stay co-located with the QA UI here
+// and are resolved by name through window[name] at switchPage time, so this
+// file no longer needs to wrap switchPage.
 
 // Refresh log previews after every runs render — _qaFillLogPreviews is a
 // no-op for already-loaded blocks, so polling repeatedly is safe.

package/dashboard/js/refresh.js

@@ -26,12 +26,58 @@ function _detectPageChanges(data) {
   return changes;
 }
 
-// Change detection — skip renders for sections that haven't changed since last refresh
+// Change detection — skip renders for sections that haven't changed since last refresh.
+//
+// RENDER_VERSIONS is the in-process cache-bust knob (R3, W-mpgb0xgc000hf1d3).
+// _changed() caches JSON.stringify(value) per key, so when the input data is
+// byte-identical between ticks the render is skipped. That's the right call
+// 99% of the time, but it has a sharp edge: when a renderer body itself is
+// edited (hot-reloaded via dashboard-build.js or a freshly shipped bundle)
+// and the input stays the same, the stale render persists forever because
+// the cache key still matches. F8 / "projects chip" class of bug.
+//
+// Bump the matching entry below whenever a renderer's *output* may change
+// for the same input. Cross-restart safety lives in the dashboardBuildId
+// reload path below — RENDER_VERSIONS handles the within-process case.
+const RENDER_VERSIONS = {
+  agents: 1,
+  prdProgress: 1,
+  prdPrs: 1,
+  inbox: 1,
+  projects: 1,
+  notes: 1,
+  prd: 1,
+  prs: 1,
+  archivedPrds: 1,
+  engine: 1,
+  version: 1,
+  adoThrottle: 1,
+  ghThrottle: 1,
+  dispatch: 1,
+  engineLog: 1,
+  metrics: 1,
+  workItems: 1,
+  skills: 1,
+  mcpServers: 1,
+  schedules: 1,
+  watches: 1,
+  meetings: 1,
+  pipelines: 1,
+  pinned: 1,
+};
 const _sectionCache = {};
-function _changed(key, value) {
+const _sectionCacheVersions = {};
+function _changed(key, value, version) {
+  var v = version == null ? (RENDER_VERSIONS[key] || 0) : version;
+  // Drop the stale-version entry so the cache doesn't grow unbounded across bumps.
+  if (_sectionCacheVersions[key] !== undefined && _sectionCacheVersions[key] !== v) {
+    delete _sectionCache[key + ':v' + _sectionCacheVersions[key]];
+  }
+  _sectionCacheVersions[key] = v;
+  var cacheKey = key + ':v' + v;
   var json = JSON.stringify(value);
-  if (_sectionCache[key] === json) return false;
-  _sectionCache[key] = json;
+  if (_sectionCache[cacheKey] === json) return false;
+  _sectionCache[cacheKey] = json;
   return true;
 }
 
@@ -191,6 +237,14 @@ function _processStatusUpdate(data) {
 }
 
 let _knownDashboardStartId = null;
+// Hard-reload trigger when the assembled dashboard HTML (and therefore any
+// renderer body) has changed since the page was first loaded. Mirrors the
+// _knownDashboardStartId pattern (R3, W-mpgb0xgc000hf1d3): catches restart-
+// crossing renderer drift that RENDER_VERSIONS (in-process bump) can't see,
+// since a server restart wipes the JS module identity entirely. data.version.
+// dashboardBuildId is the md5 of the assembled HTML — bumps automatically on
+// hot-reload + on cold restart with any /dashboard/** change.
+let _knownDashboardBuildId = null;
 // /api/status ETag cache (W-mpehsyhv0017085a). The dashboard polls every 4 s
 // but the server-side cache only changes every 10–60 s. Sending If-None-Match
 // lets the server short-circuit ~60 %+ of polls into a 304 with no body —
@@ -232,6 +286,16 @@ async function refresh() {
       return;
     }
     if (dashId) _knownDashboardStartId = dashId;
+    // Auto-reload when the assembled dashboard HTML changed (renderer body or
+    // any other concat'd JS) — catches drift the in-process RENDER_VERSIONS
+    // bump can't see (R3, W-mpgb0xgc000hf1d3).
+    const buildId = (data.version && data.version.dashboardBuildId) || null;
+    if (buildId && _knownDashboardBuildId && buildId !== _knownDashboardBuildId) {
+      console.log('Dashboard build changed — reloading page');
+      location.reload();
+      return;
+    }
+    if (buildId) _knownDashboardBuildId = buildId;
     _processStatusUpdate(data);
   } catch(e) { console.error('refresh error', e); }
   finally { _refreshInFlight = false; }

package/dashboard/js/state.js

@@ -25,11 +25,47 @@ function getPageFromUrl() {
 
 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.
+//
+// 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).
+// PAGE_LEAVE_HOOKS: functions to invoke on EVERY switchPage call regardless
+// of source/destination. Each leave hook must be safe to invoke when there
+// is nothing to clean up (idempotent / no-op when inactive) — _stopPlanPoll,
+// _stopMeetingPoll, _stopQaRunsPoll all clearInterval on a nullable handle;
+// closeDetail / closeManagedLog short-circuit when no panel/stream is open.
+const PAGE_LAZY_LOADERS = {
+  qa: ['loadQaTargets', 'loadQaRunbooks', '_startQaRunsPoll'],
+  plans: ['refreshPlans'],
+  inbox: ['refreshKnowledgeBase'],
+};
+
+const PAGE_LEAVE_HOOKS = [
+  '_stopPlanPoll',
+  '_stopMeetingPoll',
+  'closeDetail',
+  '_stopQaRunsPoll',
+  'closeManagedLog',
+];
+
+function _invokePageHooks(names) {
+  if (!names || !names.length) return;
+  const scope = (typeof window !== 'undefined') ? window
+    : (typeof globalThis !== 'undefined' ? globalThis : {});
+  for (const name of names) {
+    const fn = scope[name];
+    if (typeof fn !== 'function') continue;
+    try { fn(); } catch { /* per-hook isolation — one bad hook can't break the lifecycle */ }
+  }
+}
+
 function switchPage(page, pushState) {
-  // Clean up intervals and panels from previous page
-  try { _stopPlanPoll(); } catch {}
-  try { _stopMeetingPoll(); } catch {}
-  try { closeDetail(); } catch {}
+  _invokePageHooks(PAGE_LEAVE_HOOKS);
 
   currentPage = page;
   document.querySelectorAll('.page').forEach(p => p.classList.remove('active'));
@@ -46,6 +82,8 @@ function switchPage(page, pushState) {
     const url = page === 'home' ? '/' : '/' + page;
     history.pushState({ page }, '', url);
   }
+
+  _invokePageHooks(PAGE_LAZY_LOADERS[page]);
 }
 
 // Browser back/forward navigation
@@ -160,4 +198,4 @@ function safeFetch(url, opts) {
   return fetch(url, fetchOpts).finally(function() { clearTimeout(timer); });
 }
 
-window.MinionsState = { getPageFromUrl, switchPage, getPrdRequeueState, setPrdRequeueState, clearPrdRequeueState, prunePrdRequeueState, rerenderPrdFromCache, safeFetch };
+window.MinionsState = { getPageFromUrl, switchPage, getPrdRequeueState, setPrdRequeueState, clearPrdRequeueState, prunePrdRequeueState, rerenderPrdFromCache, safeFetch, PAGE_LAZY_LOADERS, PAGE_LEAVE_HOOKS };

package/dashboard.js

@@ -1152,6 +1152,10 @@ function rebuildDashboardHtml() {
     HTML = HTML_RAW;
     HTML_GZ = zlib.gzipSync(HTML);
     HTML_ETAG = '"' + require('crypto').createHash('md5').update(HTML).digest('hex') + '"';
+    // Bust the /api/status cache so the new dashboardBuildId propagates on the
+    // next poll — refresh.js compares it against its first-observed value and
+    // hard-reloads on mismatch (R3, W-mpgb0xgc000hf1d3).
+    try { invalidateStatusCache(); } catch { /* status cache may not be initialized yet */ }
     console.log('  Dashboard hot-reloaded');
     // Push reload to all connected browsers via status-stream (saves a connection)
     for (const res of _statusStreamClients) {
@@ -1684,6 +1688,12 @@ function _buildStatusSlowState() {
         dashboardRunning: _dashboardVersion.codeVersion,
         dashboardRunningCommit: _dashboardVersion.codeCommit,
         dashboardStartedAt: _dashboardVersion.startedAt,
+        // dashboardBuildId — md5 of the assembled HTML (built JS + pages + css).
+        // Refresh.js compares this against its first-observed value and hard-
+        // reloads on mismatch so renderer hot-edits across restarts always land
+        // on the client (R3, W-mpgb0xgc000hf1d3). Quotes stripped from the
+        // weak/strong ETag form so consumers see a bare hex digest.
+        dashboardBuildId: HTML_ETAG ? HTML_ETAG.replace(/^"|"$/g, '') : null,
         disk: diskVersion,
         diskCommit,
         engineStale,
@@ -9306,6 +9316,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         engineRunningCommit: engine.codeCommit || null,
         dashboardRunning: _dashboardVersion.codeVersion,
         dashboardRunningCommit: _dashboardVersion.codeCommit,
+        dashboardBuildId: HTML_ETAG ? HTML_ETAG.replace(/^"|"$/g, '') : null,
         latest: npm.latest,
         updateAvailable: !isGitRepo && !!(diskVersion && npm.latest && _compareVersions(npm.latest, diskVersion) > 0),
         engineStale,

package/package.json

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