@yemi33/minions 0.1.2015 → 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;
 }
 
@@ -99,7 +145,12 @@ function _processStatusUpdate(data) {
   }
   if (_changed('notes', data.notes)) renderNotes(data.notes);
   if (_changed('prd', [data.prd, data.prdProgress])) renderPrd(data.prd, data.prdProgress);
-  if (_changed('prs', data.pullRequests)) renderPrs(data.pullRequests || []);
+  // Capture prs + workItems change signals once — also reused by the cross-slice
+  // render triggers at the bottom of this function (F1/F3, W-mpgb0xbh000e3b86).
+  // _changed mutates _sectionCache so it must be called exactly once per key.
+  var _prsChanged = _changed('prs', data.pullRequests);
+  var _workItemsChanged = _changed('workItems', data.workItems);
+  if (_prsChanged) renderPrs(data.pullRequests || []);
   if (_changed('archivedPrds', data.archivedPrds)) renderArchiveButtons(data.archivedPrds || []);
   if (_changed('engine', data.engine)) {
     renderEngineStatus(data.engine);
@@ -136,7 +187,7 @@ function _processStatusUpdate(data) {
       .catch(function () { /* keep render even if managed fetch failed — getLastItems() returns the last good cache (or []) */ })
       .then(function () { try { renderKeepProcesses(); } catch {} });
   }
-  if (_changed('workItems', data.workItems)) renderWorkItems(data.workItems || []);
+  if (_workItemsChanged) renderWorkItems(data.workItems || []);
   if (_changed('skills', data.skills)) renderSkills(data.skills || []);
   if (_changed('mcpServers', data.mcpServers)) renderMcpServers(data.mcpServers || []);
   if (_changed('schedules', data.schedules)) renderSchedules(data.schedules || []);
@@ -153,6 +204,27 @@ function _processStatusUpdate(data) {
   if (!window._kbRefreshCount) window._kbRefreshCount = 0;
   if (window._kbRefreshCount++ % 3 === 0) { 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*
+  // 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
+    // above, so the +N follow-up chip would otherwise stay stale until the
+    // next PR mutation.
+    renderPrs(data.pullRequests || []);
+  }
+  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).
+    renderPlans(window._lastPlans);
+  }
+
   // Sidebar activity indicators — show red dot on pages with new activity
   try {
     const changes = _detectPageChanges(data);
@@ -165,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 —
@@ -173,7 +253,15 @@ let _knownDashboardStartId = null;
 // downstream consumers of `data`.
 let _lastStatusEtag = null;
 let _lastStatusData = null;
+// In-flight gate (S5 — dashboard-refresh-audit). setInterval(refresh, 4000)
+// can interleave two ticks inside _processStatusUpdate if a refresh takes
+// >4 s (cold server cache + slow JSON + network blip). Skip the second tick
+// when the first hasn't finished — the next interval fire picks up the
+// fresh state anyway.
+let _refreshInFlight = false;
 async function refresh() {
+  if (_refreshInFlight) return;
+  _refreshInFlight = true;
   try {
     const headers = {};
     if (_lastStatusEtag) headers['If-None-Match'] = _lastStatusEtag;
@@ -198,8 +286,19 @@ 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; }
 }
 
 refresh();

package/dashboard/js/render-kb.js

@@ -32,8 +32,16 @@ function _formatSweepElapsed(startedAt) {
 
 async function refreshKnowledgeBase() {
   try {
+    // Always update _kbData — cross-slice readers (e.g. command-center.js
+    // suggestion lookup) depend on it staying fresh even when the renderer is
+    // skipped (S1).
     _kbData = await fetch('/api/knowledge').then(r => r.json());
-    renderKnowledgeBase();
+    // Skip the full kb-list/kb-tabs rewrite when /api/knowledge returned the
+    // same payload as last tick. Dedicated cache key 'kbPayload' avoids
+    // colliding with any other tracked slice (S1).
+    if (typeof _changed !== 'function' || _changed('kbPayload', _kbData)) {
+      renderKnowledgeBase();
+    }
   } catch (e) { console.error('kb refresh:', e.message); }
 }
 

package/dashboard/js/render-meetings.js

@@ -1,7 +1,7 @@
 // render-meetings.js — Team meeting rendering
 
 let _showArchived = false;
-const MTG_PER_PAGE = 10;
+const MTG_PER_PAGE = 25;
 let _mtgPage = 0;
 let _lastMeetingHash = '';
 let _lastMeetingsForPaging = [];

package/dashboard/js/render-pipelines.js

@@ -3,6 +3,9 @@
 let _pipelinesData = [];
 let _pipelinePollId = null;
 let _pipelinePollInterval = null;
+const PIPELINE_PER_PAGE = 25;
+let _pipelinePage = 0;
+let _pipelineTotalPages = 1;
 function _stopPipelinePoll() { if (_pipelinePollInterval) { clearInterval(_pipelinePollInterval); _pipelinePollInterval = null; } _pipelinePollId = null; }
 
 /**
@@ -293,11 +296,18 @@ function renderPipelines(pipelines) {
   if (!pipelines || pipelines.length === 0) {
     countEl.textContent = '0';
     el.innerHTML = '<p class="empty">No pipelines yet. Create one to chain stages like audit \u2192 meeting \u2192 plan \u2192 merge.</p>';
+    _pipelineTotalPages = 1;
     return;
   }
   countEl.textContent = pipelines.length;
 
-  el.innerHTML = pipelines.map(function(p) {
+  const totalPages = Math.ceil(pipelines.length / PIPELINE_PER_PAGE);
+  _pipelineTotalPages = totalPages;
+  if (_pipelinePage >= totalPages) _pipelinePage = Math.max(0, totalPages - 1);
+  const start = _pipelinePage * PIPELINE_PER_PAGE;
+  const pageItems = pipelines.slice(start, start + PIPELINE_PER_PAGE);
+
+  el.innerHTML = pageItems.map(function(p) {
     const activeRun = _getPipelineActiveRun(p);
     const lastRun = (p.runs || []).slice(-1)[0];
     const statusColor = activeRun ? 'var(--blue)' : lastRun?.status === 'completed' ? 'var(--green)' : lastRun?.status === 'failed' ? 'var(--red)' : lastRun?.status === 'stopped' ? 'var(--yellow)' : 'var(--muted)';
@@ -336,6 +346,29 @@ function renderPipelines(pipelines) {
       progressHtml +
     '</div>';
   }).join('');
+
+  if (pipelines.length > PIPELINE_PER_PAGE) {
+    el.insertAdjacentHTML('beforeend', '<div class="pr-pager">' +
+      '<span class="pr-page-info">Showing ' + (start + 1) + ' to ' + Math.min(start + PIPELINE_PER_PAGE, pipelines.length) + ' of ' + pipelines.length + '</span>' +
+      '<div class="pr-pager-btns">' +
+        '<button class="pr-pager-btn ' + (_pipelinePage === 0 ? 'disabled' : '') + '" onclick="_pipelinePrev()">Prev</button>' +
+        '<button class="pr-pager-btn ' + (_pipelinePage >= totalPages - 1 ? 'disabled' : '') + '" onclick="_pipelineNext()">Next</button>' +
+      '</div></div>');
+  }
+}
+
+function _pipelinePrev() {
+  if (_pipelinePage > 0) {
+    _pipelinePage--;
+    renderPipelines(_pipelinesData);
+  }
+}
+
+function _pipelineNext() {
+  if (_pipelinePage < _pipelineTotalPages - 1) {
+    _pipelinePage++;
+    renderPipelines(_pipelinesData);
+  }
 }
 
 function openPipelineDetail(id) {

package/dashboard/js/render-plans.js

@@ -56,8 +56,16 @@ async function _submitCreatePlan(e) {
 async function refreshPlans() {
   try {
     const plans = await fetch('/api/plans').then(r => r.json());
-    window._lastPlans = plans; // Store globally so plan modal can access
-    renderPlans(plans);
+    // Cross-slice readers (renderMeetings, plan modal, command-center, etc.)
+    // depend on _lastPlans staying current — assign BEFORE the change gate so
+    // they see fresh data even when the renderer is skipped (F2/F3).
+    window._lastPlans = plans;
+    // Skip the full plans-list innerHTML rewrite when /api/plans returned the
+    // same payload as last tick. Dedicated cache key 'plansPayload' avoids
+    // colliding with the 'plans' slice tracked by _processStatusUpdate (F6).
+    if (typeof _changed !== 'function' || _changed('plansPayload', plans)) {
+      renderPlans(plans);
+    }
   } catch (e) { console.error('plans refresh:', e.message); }
 }
 

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.2015",
+  "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"