@yemi33/minions 0.1.2087 → 0.1.2089

package/dashboard/js/refresh.js

@@ -2,43 +2,109 @@
 
 // Sidebar activity indicators — detect changes between refreshes
 // Registry: add one line per page. Counter returns a value; badge shows when value increases.
+// Sidebar activity-dot signatures. Each function returns a STRING (sig
+// computed from the page's underlying state) OR `null` when the cache
+// isn't populated yet — null suppresses the comparison so a slice going
+// from undefined → populated does NOT flip the dot on the first tick
+// after a fetch resolves. Once a signature is computable, it's compared
+// against the previously-stored one; any change fires the dot.
+//
+// All migrated slices read from window._lastX globals set inside async
+// /api/<x> .then handlers (issue #2949). Returning null while those
+// globals are still undefined prevents the timing race where _detectPage-
+// Changes runs synchronously at the end of _processStatusUpdate before
+// the .then handlers have populated the caches.
+//
+// dispatch.completed is capped at 20 server-side, so length-based counters
+// peg once the cap is hit; we fingerprint the LAST completed entry's id +
+// completed_at instead so a new completion rotates the signature whether
+// the cap is reached or not.
 const _pageCounters = {
-  home:      function(d) { return (d.dispatch?.completed || []).length; },
-  // work signature: total + in-flight count. State transitions (pending /
-  // dispatched → done) flip the dot; per-item title/updatedAt churn doesn't (F9/S4).
-  work:      function(d) { return (d.workItems || []).length + '|' + (d.workItems || []).filter(function(w) { return w.status === 'pending' || w.status === 'dispatched'; }).length; },
-  plans:     function(d) { return (d.prdProgress?.complete || 0) + '|' + (d.plans || []).length + '|' + (d.plans || []).map(function(p) { return p.status || ''; }).join(','); },
-  prs:       function(d) { return (d.pullRequests || []).length + '|' + (d.pullRequests || []).filter(function(p) { return p.status === 'merged'; }).length; },
-  inbox:     function(d) { return (d.inbox || []).length + '|' + (d.notes?.content || '').length; },
-  // watches signature: count + max(last_triggered). Dot fires when any watch
-  // triggers or the count changes; triggerCount removed because it advances
-  // on the same event as last_triggered (F9/S4).
-  watches:   function(d) { return (d.watches || []).length + '|' + (d.watches || []).reduce(function(m, w) { return Math.max(m, new Date(w.last_triggered || 0).getTime() || 0); }, 0); },
-  // meetings signature: full count + sum of all rounds. Uses meetingsTotal
-  // (top-level full count of meetings on disk) NOT meetings.length — the
-  // latter is the slim slice which drops terminal meetings >7d via
-  // statusMeetingsRetentionDays, so an archived meeting reaching round 3
-  // would silently fail to flip the dot. Round-sum stays on the slim slice
-  // (we don't track per-meeting round in meetingsTotal) — operators who
-  // care about archived-meeting round transitions can crank the retention
-  // window or set it to 0. (W-mphlrxx6000a8760)
-  meetings:  function(d) { return (d.meetingsTotal ?? (d.meetings || []).length) + '|' + (d.meetings || []).reduce(function(s, m) { return s + (m.round || 0); }, 0); },
-  pipelines: function(d) { return (d.pipelines || []).length + '|' + (d.pipelines || []).reduce(function(s, p) { return s + (p.runs || []).length; }, 0); },
-  schedule:  function(d) { return (d.schedules || []).length; },
-  // tools signature: skills count + mcp servers count.
-  tools:     function(d) { return (d.skills || []).length + '|' + (d.mcpServers || []).length; },
-  engine:    function(d) { return (d.dispatch?.completed || []).filter(function(c) { return c.result === 'error'; }).length; },
-  qa:        function(d) { return (d.qaRuns?.total || 0) + '|' + (d.qaRuns?.sig || ''); },
+  home: function(d) {
+    // dispatch is on /api/dispatch — wait for the cache.
+    const dispatch = window._lastDispatch || d.dispatch;
+    if (!dispatch) return null;
+    const completed = dispatch.completed || [];
+    const last = completed[completed.length - 1];
+    return completed.length + '|' + (last?.id || '') + '|' + (last?.completed_at || '');
+  },
+  work: function(d) {
+    if (!Array.isArray(window._lastWorkItems) && !Array.isArray(d.workItems)) return null;
+    const wis = window._lastWorkItems || d.workItems || [];
+    return wis.length + '|' + wis.filter(function(w) { return w.status === 'pending' || w.status === 'dispatched'; }).length;
+  },
+  plans: function(d) {
+    // /api/plans → window._lastPlans (refreshPlans()); /api/prd →
+    // window._lastPrdProgress. Both must be populated before we sig.
+    if (!Array.isArray(window._lastPlans) || window._lastPrdProgress === undefined) return null;
+    const prog = window._lastPrdProgress || {};
+    const plans = window._lastPlans;
+    return (prog.complete || 0) + '|' + plans.length + '|' + plans.map(function(p) { return (p.file || '') + ':' + (p.status || ''); }).join(',');
+  },
+  prs: function(d) {
+    if (!Array.isArray(window._lastPullRequests) && !Array.isArray(d.pullRequests)) return null;
+    const prs = window._lastPullRequests || d.pullRequests || [];
+    const counts = {};
+    for (const p of prs) counts[p.status || ''] = (counts[p.status || ''] || 0) + 1;
+    return prs.length + '|' + Object.keys(counts).sort().map(function(k) { return k + ':' + counts[k]; }).join(',');
+  },
+  inbox: function(d) {
+    // Wait for BOTH inbox and notes to populate — either alone gives a
+    // half-stale sig on first arrival.
+    if (!Array.isArray(window._lastInbox) || window._lastNotes === undefined) return null;
+    const ib = window._lastInbox;
+    const notes = window._lastNotes || {};
+    return ib.length + '|' + (notes.content || '').length;
+  },
+  watches: function(d) {
+    if (!Array.isArray(window._lastWatches) && !Array.isArray(d.watches)) return null;
+    const ws = window._lastWatches || d.watches || [];
+    return ws.length + '|' + ws.reduce(function(m, w) { return Math.max(m, new Date(w.last_triggered || 0).getTime() || 0); }, 0);
+  },
+  meetings: function(d) {
+    // Meetings total comes from /api/meetings-total; list from /state/meetings.
+    if (window._lastMeetingsTotal === undefined && d.meetingsTotal === undefined) return null;
+    const total = window._lastMeetingsTotal ?? d.meetingsTotal ?? 0;
+    const list = window._lastMeetings || d.meetings || [];
+    return total + '|' + list.reduce(function(s, m) { return s + (m.round || 0); }, 0);
+  },
+  pipelines: function(d) {
+    if (!Array.isArray(window._lastPipelines) && !Array.isArray(d.pipelines)) return null;
+    const pls = window._lastPipelines || d.pipelines || [];
+    return pls.length + '|' + pls.reduce(function(s, p) { return s + (p.runs || []).length; }, 0);
+  },
+  schedule: function(d) {
+    if (!Array.isArray(window._lastSchedules) && !Array.isArray(d.schedules)) return null;
+    const sch = window._lastSchedules || d.schedules || [];
+    return sch.length + '|' + sch.map(function(s) { return (s.id || '') + ':' + (s.enabled === false ? '0' : '1') + ':' + (s.cron || ''); }).sort().join(',');
+  },
+  tools: function(d) {
+    // skills + mcpServers are on /api/status directly, no cache to wait for.
+    return (d.skills || []).length + '|' + (d.mcpServers || []).length;
+  },
+  engine: function(d) {
+    const dispatch = window._lastDispatch || d.dispatch;
+    if (!dispatch) return null;
+    const errors = (dispatch.completed || []).filter(function(c) { return c.result === 'error'; });
+    const lastErr = errors[errors.length - 1];
+    return errors.length + '|' + (lastErr?.id || '') + '|' + (lastErr?.completed_at || '');
+  },
+  qa: function(d) {
+    if (!window._lastQaRunsSummary && !d.qaRuns) return null;
+    const q = window._lastQaRunsSummary || d.qaRuns || {};
+    return (q.total || 0) + '|' + (q.sig || '');
+  },
 };
 let _prevCounts = {};
 function _detectPageChanges(data) {
   var changes = {};
-  var counts = {};
   for (var page in _pageCounters) {
-    counts[page] = String(_pageCounters[page](data));
-    if (_prevCounts[page] !== undefined && counts[page] !== _prevCounts[page]) changes[page] = true;
+    var sig = _pageCounters[page](data);
+    if (sig === null) continue;  // cache not ready yet — skip both compare and record
+    var sigStr = String(sig);
+    if (_prevCounts[page] !== undefined && sigStr !== _prevCounts[page]) changes[page] = true;
+    _prevCounts[page] = sigStr;
   }
-  _prevCounts = counts;
   return changes;
 }
 
@@ -116,7 +182,6 @@ let _lastChangedFlags = null;
 function _safeRender(name, fn) {
   try { fn(); }
   catch (e) {
-    // eslint-disable-next-line no-console
     console.error('[render] ' + name + ' threw:', e);
   }
 }
@@ -246,23 +311,100 @@ function _startNextTickTicker() {
   _engineNextTickTimer = setInterval(_updateNextTickChip, 1000);
 }
 
-function _processStatusUpdate(data) {
-  // Detect fresh install — clear stale browser state AND reload so module-scoped
-  // 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).
-  if (data.installId) {
-    const prev = localStorage.getItem('minions-install-id');
-    if (prev && prev !== data.installId) {
-      localStorage.clear();
-      // Write the new install-id BEFORE reload — the post-reload poll must see
-      // a matching id so it stops looping. clear() above wiped it, so set it again.
-      localStorage.setItem('minions-install-id', data.installId);
-      console.log('Minions: fresh install detected, reloading to reset module caches');
-      location.reload();
-      return;
+// Background-poll the sidebar-counter summaries from their dedicated
+// endpoints (issue #2949). Results land on window._last* globals which
+// _pageCounters reads with a /api/status field fallback. Fire-and-forget
+// — no awaits — so this never blocks the synchronous render chain. The
+// fetched values arrive ~1 tick late on the FIRST refresh after page load;
+// subsequent ticks see fresh signatures from the dedicated endpoints with
+// no /api/status outer-cache staleness.
+// Fire the F1/F3 cross-slice triggers when work-items / pull-requests /
+// dispatch resolves with NEW data on this tick. Cross-slice dependency graph:
+//   workItems → {prs (+N follow-up chip), plans (derivePlanStatus)}
+//   pullRequests → {plans (derivePlanStatus)}
+//   dispatch → {plans (derivePlanStatus reads .active/.pending)} (Round-3 #5.)
+//
+// Signature is a CHEAP fingerprint derived from key fields, NOT a full
+// JSON.stringify — the latter allocated multi-MB strings on every tick
+// for the typical WI/PR payloads and contradicted the dashboard event-loop
+// budget. Catch-fallback uses a STABLE token (not Date.now()) so a payload
+// whose getter throws doesn't perpetually re-fire. (Round-4 #1 + #3.)
+const _crossSliceSig = { workItems: '', pullRequests: '', dispatch: '' };
+function _cheapSig(value) {
+  try {
+    if (!value) return 'null';
+    if (Array.isArray(value)) {
+      const head = value[0] || {};
+      const tail = value[value.length - 1] || {};
+      return value.length + '|' + (head.id || '') + ':' + (head.status || head.state || '') + '|' + (tail.id || '') + ':' + (tail.status || tail.state || head.updatedAt || '');
     }
+    if (typeof value === 'object') {
+      // Dispatch shape: {pending, active, completed} — fingerprint the lengths
+      // + first id of each so any insertion/removal advances the sig.
+      const p = Array.isArray(value.pending) ? value.pending : [];
+      const a = Array.isArray(value.active) ? value.active : [];
+      const c = Array.isArray(value.completed) ? value.completed : [];
+      return 'd:' + p.length + ':' + (p[0]?.id || '') + '/' + a.length + ':' + (a[0]?.id || '') + '/' + c.length + ':' + (c[c.length - 1]?.id || '');
+    }
+    return String(value);
+  } catch { return '__err__'; }
+}
+// F3 coalescer: batch multiple advancing-key calls into ONE renderPlans per
+// tick. Without this, a tick where all three of workItems/pullRequests/
+// dispatch advance would re-render plans 3-4 times back-to-back for
+// identical output. (Round-4 #2.)
+let _planRerenderQueued = false;
+function _queuePlanRerender() {
+  if (_planRerenderQueued) return;
+  _planRerenderQueued = true;
+  Promise.resolve().then(function () {
+    _planRerenderQueued = false;
+    if (Array.isArray(window._lastPlans) && typeof renderPlans === 'function') {
+      _safeRender('plans:cross-slice', function() { renderPlans(window._lastPlans); });
+    }
+  });
+}
+function _fireCrossSliceRender(key, value) {
+  const sig = _cheapSig(value);
+  if (_crossSliceSig[key] === sig) return false;
+  _crossSliceSig[key] = sig;
+  // F1 — re-render PRs (+N follow-up chip count depends on the WI list).
+  // Fires for both workItems and pullRequests keys so a late PR fetch
+  // refreshes the +N chip against the cached WI list. (Round-3 #7.)
+  if ((key === 'workItems' || key === 'pullRequests') && Array.isArray(window._lastPullRequests)) {
+    _safeRender('prs:cross-slice', function() { renderPrs(window._lastPullRequests); });
+  }
+  // F3 — coalesced via microtask so 3 advancing keys → 1 plans render.
+  _queuePlanRerender();
+  return true;
+}
+
+function _refreshSidebarCounterSummaries() {
+  fetch('/api/qa-runs-summary')
+    .then(function (r) { return r.ok ? r.json() : null; })
+    .then(function (s) { if (s && typeof s === 'object') window._lastQaRunsSummary = s; })
+    .catch(function () { /* sidebar counter degrades to /api/status fallback */ });
+  fetch('/api/meetings-total')
+    .then(function (r) { return r.ok ? r.json() : null; })
+    .then(function (s) { if (s && typeof s.total === 'number') window._lastMeetingsTotal = s.total; })
+    .catch(function () { /* optional */ });
+  // /api/verify-guides is now fetched in parallel with /api/prd inside the
+  // prdProgress block so renderPrd's guideByPlan lookup uses the SAME tick's
+  // guide list as the PRD progress data. (Round-2 review finding #5.)
+  // QA sessions summary was previously fetched here, but no _pageCounters
+  // entry read it — drop the dead endpoint + fetch. (Review finding #9.)
+}
+
+function _processStatusUpdate(data, opts) {
+  opts = opts || {};
+  // Kick off the dedicated-endpoint summary refreshes (issue #2949). They
+  // run in the background and update window._last* globals that the sidebar
+  // _pageCounters read. No await — the current tick continues immediately.
+  _refreshSidebarCounterSummaries();
+  // Fresh install id tracking — kept ONLY to update localStorage so the
+  // value is available to other code that introspects it; the tab does
+  // NOT auto-reload on a MINIONS_HOME swap. User decides when to refresh.
+  if (data.installId) {
     localStorage.setItem('minions-install-id', data.installId);
   }
   // Always update cheap elements
@@ -305,8 +447,12 @@ function _processStatusUpdate(data) {
   // refactor that adds a window._last* read to those renderers will see
   // fresh data on the same tick, not the previous one. Covered by
   // dashboard-resilience.test.js source-inspection assertions.
-  window._lastDispatch = data.dispatch;
-  window._lastWorkItems = data.workItems || [];
+  // window._lastDispatch + window._lastWorkItems are now exclusively set
+  // inside the /api/dispatch + /api/work-items .then handlers (issue #2949).
+  // The hoist here used to read data.dispatch / data.workItems from the
+  // /api/status slim slices — both undefined post-slim — and overwrite the
+  // freshly-fetched values from the prior tick with undefined/[], which
+  // caused first-tick sidebar-dot flashes on every migrated page.
   window._lastStatus = data;
 
 
@@ -318,24 +464,113 @@ function _processStatusUpdate(data) {
   // cycled out of the slim /api/status payload. Per-call try/catch keeps
   // each renderer independent; throws log to Console (no UI banner).
   //
-  // We KEEP the `_changed(...)` CALLS (their side effect of populating
-  // `_lastChangedFlags` is still load-bearing for the diag ring-buffer
-  // and for the `_workItemsChanged` / `_prsChanged` cross-slice triggers
-  // below — F1 / F3 / W-mpgb0xbh000e3b86) but no longer use the return
-  // value to gate the render. Each renderer is a contained DOM rewrite
-  // (~ a few KB of HTML); ~10–20 of them per 4s tick is well under one
-  // frame's budget.
-  _changed('agents', data.agents);
-  _safeRender('agents', function() { renderAgents(data.agents); });
-  _safeRender('cmdUpdateAgentList', function() { cmdUpdateAgentList(data.agents); });
-  // prdProgress + prdPrs are captured together so both flags publish to
-  // the diag buffer; the renderer + cachePrdItems run unconditionally.
-  _changed('prdProgress', data.prdProgress);
-  _changed('prdPrs', data.pullRequests?.length);
-  _safeRender('prdProgress', function() { renderPrdProgress(data.prdProgress); });
-  _safeRender('cachePrdItems', function() { _cachePrdItems(data.prdProgress); });
-  _changed('inbox', data.inbox);
-  _safeRender('inbox', function() { renderInbox(data.inbox || []); });
+  // The per-slice _changed(key, data[key]) calls were dropped for every
+  // migrated slice (issue #2949) — data[key] is undefined post-slim, so
+  // every call fed a permanently-stable 'undefined' signature into the
+  // section cache that no consumer reads. The F1/F3 cross-slice triggers
+  // that previously gated on _workItemsChanged / _prsChanged moved into
+  // the /api/work-items + /api/pull-requests .then handlers
+  // (_fireCrossSliceRender) where the FRESH fetched lists are available.
+  // Agents now come from /api/agents — a dedicated fresh-JSON endpoint with
+  // input-mtime ETag (issue #2949). No /api/status outer cache in the path.
+  // cmdUpdateAgentList consumes the same slice but renders the command-line
+  // chip pop-up so we feed it the fresh array too.
+  _safeRender('agents', function() {
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.agents = seq;
+    fetch('/api/agents')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.agents || 0)) return;
+        const list = Array.isArray(fresh) ? fresh : window._lastAgents;
+        if (list) window._lastAgents = list;
+        _safeRender('agents', function() { renderAgents(list); });
+        _safeRender('cmdUpdateAgentList', function() { cmdUpdateAgentList(list); });
+      })
+      .catch(function () {
+        // Re-render against last known good data; leave DOM as-is on cold
+        // start. (Review finding #4.)
+        if (window._lastAgents) {
+          _safeRender('agents', function() { renderAgents(window._lastAgents); });
+          _safeRender('cmdUpdateAgentList', function() { cmdUpdateAgentList(window._lastAgents); });
+        }
+      });
+  });
+  // PRD slice now comes from /api/prd — a dedicated fresh-JSON endpoint
+  // that re-runs getPrdInfo() on every request with input-mtime ETag.
+  // Returns { status, progress }. prdProgress + the standalone PRD
+  // section share one fetch so they always agree on the same tick.
+  // /api/prd returns { status, progress }. prdProgress, the standalone PRD
+  // section, and the cross-tick item cache all run inside ONE .then so they
+  // see the same fresh data on the same tick — previously the standalone
+  // renderPrd block ran synchronously, BEFORE this .then resolved, and
+  // always saw the prior tick's stash (or undefined on first render).
+  // (Review finding #10.)
+  _safeRender('prdProgress', function() {
+    // Fetch /api/prd and /api/verify-guides IN PARALLEL so renderPrd's
+    // verifyGuides lookup uses the SAME tick's guide list as the PRD
+    // progress data. Previously /api/verify-guides was fetched separately
+    // by _refreshSidebarCounterSummaries with no ordering guarantee,
+    // causing a one-tick lag whenever a fresh guide dropped alongside a
+    // PRD status update. (Round-2 review finding #5.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.prd = seq;
+    Promise.all([
+      fetch('/api/prd').then(function (r) { return r.ok ? r.json() : null; }),
+      fetch('/api/verify-guides').then(function (r) { return r.ok ? r.json() : null; }),
+    ])
+      .then(function (results) {
+        // Drop late arrivals — out-of-order resolution from a prior tick
+        // must not clobber the current tick's window._last* state.
+        // (Round-2 review finding #6.)
+        if (seq < (window._lastRequestedSeq.prd || 0)) return;
+        const prdInfo = results[0];
+        const guides = results[1];
+        const status = prdInfo && prdInfo.status != null ? prdInfo.status : window._lastPrdStatus;
+        const progress = prdInfo && prdInfo.progress != null ? prdInfo.progress : window._lastPrdProgress;
+        window._lastPrdStatus = status;
+        window._lastPrdProgress = progress;
+        if (Array.isArray(guides)) window._lastVerifyGuides = guides;
+        _safeRender('prdProgress', function() { renderPrdProgress(progress); });
+        _safeRender('cachePrdItems', function() { _cachePrdItems(progress); });
+        // renderPrd handles null status/progress gracefully (early-returns
+        // on falsy prd, uses progress?.items || []). Calling it
+        // unconditionally is required for the "last PRD archived" case to
+        // clear the previously-rendered list — round-2 #10's guard was
+        // too aggressive and trapped stale content on screen.
+        // (Round-3 #3.)
+        _safeRender('prd', function() { renderPrd(status, progress); });
+      })
+      .catch(function () {
+        // `!== undefined` (NOT a truthy check) so the cache-was-null
+        // post-archive state still triggers a re-render against null —
+        // renderPrd's own null-handling paints the empty 'No PRD found'
+        // affordance. Truthy gating would conflate cache-was-null with
+        // never-fetched. (Round-3 #8.)
+        if (window._lastPrdProgress !== undefined) {
+          _safeRender('prdProgress', function() { renderPrdProgress(window._lastPrdProgress); });
+          _safeRender('cachePrdItems', function() { _cachePrdItems(window._lastPrdProgress); });
+          _safeRender('prd', function() { renderPrd(window._lastPrdStatus, window._lastPrdProgress); });
+        }
+      });
+  });
+  // Inbox is now sourced from /state/notes/inbox (dir listing + per-file
+  // content fetch) instead of the /api/status inbox slice (issue #2949).
+  // Falls back to data.inbox when the fetch returns null (offline, network
+  // race, dir missing) so the renderer is never starved.
+  _safeRender('inbox', function() {
+    Promise.resolve(fetchInboxFromDisk())
+      .then(function (fresh) {
+        const list = fresh && fresh.length ? fresh : (window._lastInbox || []);
+        window._lastInbox = list;
+        _safeRender('inbox', function() { renderInbox(list); });
+      })
+      .catch(function () {
+        if (window._lastInbox) _safeRender('inbox', function() { renderInbox(window._lastInbox); });
+      });
+  });
   _changed('projects', data.projects);
   _safeRender('cmdUpdateProjectList', function() { cmdUpdateProjectList(data.projects || []); });
   _safeRender('projects', function() { renderProjects(data.projects || []); });
@@ -346,18 +581,76 @@ function _processStatusUpdate(data) {
   if (typeof renderFre === 'function') {
     _safeRender('fre', function() { renderFre(data); });
   }
-  _changed('notes', data.notes);
-  _safeRender('notes', function() { renderNotes(data.notes); });
-  _changed('prd', [data.prd, data.prdProgress]);
-  _safeRender('prd', function() { renderPrd(data.prd, data.prdProgress); });
-  // 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);
-  _safeRender('prs', function() { renderPrs(data.pullRequests || []); });
-  _changed('archivedPrds', data.archivedPrds);
-  _safeRender('archiveButtons', function() { renderArchiveButtons(data.archivedPrds || []); });
+  // Notes file (notes.md) is now sourced from /state/notes.md. Same shape
+  // as the legacy /api/status notes slice ({ content, updatedAt }); the
+  // ETag mtime is parsed out of the response header for updatedAt.
+  _safeRender('notes', function() {
+    Promise.resolve(fetchNotesFromDisk())
+      .then(function (fresh) {
+        const notes = fresh || window._lastNotes;
+        if (notes) window._lastNotes = notes;
+        _safeRender('notes', function() { renderNotes(notes); });
+      })
+      .catch(function () {
+        if (window._lastNotes) _safeRender('notes', function() { renderNotes(window._lastNotes); });
+      });
+  });
+  // _changed('prd', ...) used to gate a now-deleted synchronous renderPrd
+  // block. Dropped along with the renderer (issue #2949 + Round-2 finding
+  // #1) — leaving a permanently-stable signature in _sectionCache would
+  // silently break any future renderer wired to the same key.
+  //
+  // F1/F3 cross-slice triggers used to be driven by _changed('workItems',
+  // data.workItems) + _changed('prs', data.pullRequests). After the slim,
+  // data.workItems / data.pullRequests are both undefined every tick so
+  // those signatures never advance and the triggers never fire. They are
+  // now fired inline from the /api/work-items + /api/pull-requests .then
+  // handlers (see _fireCrossSliceRender below) where the FRESH fetched
+  // lists are available. (Round-2 review findings #1 + #2.)
+  // Pull requests now come from /api/pull-requests — a dedicated fresh-
+  // JSON endpoint that re-runs getPullRequests() server-side on every
+  // request with input-mtime ETag (issue #2949).
+  _safeRender('prs', function() {
+    // Stamp the request with a monotonic seq so late arrivals from a
+    // prior tick can't clobber fresh state. (Round-2 review finding #6.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.prs = seq;
+    fetch('/api/pull-requests')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.prs || 0)) return;
+        const list = Array.isArray(fresh) ? fresh : (window._lastPullRequests || []);
+        const wasFirstNonEmpty = !Array.isArray(window._lastPullRequests);
+        window._lastPullRequests = list;
+        _safeRender('prs', function() { renderPrs(list); });
+        _fireCrossSliceRender('pullRequests', list);
+        // First-arrival case: if /api/work-items already fired its
+        // cross-slice trigger before _lastPullRequests was populated, the
+        // F1 +N follow-up chip on PRs reads a stale cached count. Force
+        // a one-shot re-fire by clearing the workItems sig. (Round-3 #7.)
+        if (wasFirstNonEmpty && Array.isArray(window._lastWorkItems)) {
+          _crossSliceSig.workItems = '';
+          _fireCrossSliceRender('workItems', window._lastWorkItems);
+        }
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastPullRequests)) _safeRender('prs', function() { renderPrs(window._lastPullRequests); });
+      });
+  });
+  // Archived PRDs come from /api/archived-prds (issue #2949).
+  _safeRender('archiveButtons', function() {
+    fetch('/api/archived-prds')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        const list = Array.isArray(fresh) ? fresh : (window._lastArchivedPrds || []);
+        window._lastArchivedPrds = list;
+        _safeRender('archiveButtons', function() { renderArchiveButtons(list); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastArchivedPrds)) _safeRender('archiveButtons', function() { renderArchiveButtons(window._lastArchivedPrds); });
+      });
+  });
   _changed('engine', data.engine);
   if (data.engine) _safeRender('engineStatus', function() { renderEngineStatus(data.engine); });
   _safeRender('engineQuickStats', function() {
@@ -390,13 +683,79 @@ function _processStatusUpdate(data) {
   _safeRender('adoThrottle', function() { renderAdoThrottleAlert(data.adoThrottle); });
   _changed('ghThrottle', data.ghThrottle);
   _safeRender('ghThrottle', function() { renderGhThrottleAlert(data.ghThrottle); });
-  _changed('dispatch', data.dispatch);
-  _safeRender('dispatch', function() { renderDispatch(data.dispatch); });
-  _safeRender('prunePrdRequeueState', function() { prunePrdRequeueState(window._lastWorkItems); });
-  _changed('engineLog', data.engineLog);
-  _safeRender('engineLog', function() { renderEngineLog(data.engineLog || []); });
-  _changed('metrics', data.metrics);
-  _safeRender('metrics', function() { renderMetrics(data.metrics || {}); });
+  // Dispatch now comes from /api/dispatch — a dedicated fresh-JSON
+  // endpoint that re-runs getDispatchQueue() server-side on every
+  // request (issue #2949). Completion-report sidecars are now loaded
+  // server-side too, so the client no longer needs the cached overlay.
+  // Scroll-preservation opts (preserveCompletedScroll) are threaded
+  // through to renderDispatch so the completed-dispatch pane keeps its
+  // scroll position across refreshes (W-mpp75wkg000b3018).
+  _safeRender('dispatch', function() {
+    const dispatchOpts = { preserveCompletedScroll: opts.preserveCompletedScroll };
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.dispatch = seq;
+    fetch('/api/dispatch')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.dispatch || 0)) return;
+        const d = fresh || window._lastDispatch;
+        if (d) window._lastDispatch = d;
+        _safeRender('dispatch', function() { renderDispatch(d, dispatchOpts); });
+        // Dispatch is the third cross-slice edge: derivePlanStatus reads
+        // window._lastDispatch.active/.pending for executing/converting
+        // plan-status badges. Without this trigger, plan-status pills lag
+        // by ticks when a dispatch is added/completed but no WI or PR
+        // delta accompanies it. (Round-3 #5.)
+        _fireCrossSliceRender('dispatch', d);
+      })
+      .catch(function () {
+        if (window._lastDispatch) _safeRender('dispatch', function() { renderDispatch(window._lastDispatch, dispatchOpts); });
+      });
+  });
+  // prunePrdRequeueState moved into the /api/work-items .then handler so it
+  // operates on the fresh fetched list rather than the synchronously-empty
+  // window._lastWorkItems. (Review finding #5.)
+  // Engine log (last 50 entries) comes from /state/engine/log.json with a
+  // client-side .slice(-50) to mirror queries.js getEngineLog (issue #2949).
+  // Scroll-preservation opts (preserveEngineLogScroll) are threaded through
+  // to renderEngineLog so the log pane keeps its scroll position across
+  // refreshes (W-mpp75wkg000b3018).
+  _safeRender('engineLog', function() {
+    const logOpts = { preserveEngineLogScroll: opts.preserveEngineLogScroll };
+    Promise.resolve(fetchEngineLogFromDisk())
+      .then(function (fresh) {
+        const list = fresh && fresh.length ? fresh : (window._lastEngineLog || []);
+        window._lastEngineLog = list;
+        _safeRender('engineLog', function() { renderEngineLog(list, logOpts); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastEngineLog)) _safeRender('engineLog', function() { renderEngineLog(window._lastEngineLog, logOpts); });
+      });
+  });
+  // Metrics now come from /api/metrics (issue #2949) — the enrichment
+  // join (PR counts, runtime totals) runs server-side fresh on every
+  // request with input-mtime ETag.
+  _safeRender('metrics', function() {
+    // Seq guard: metrics.json is mutated on every dispatch completion +
+    // PR/build state change via trackEngineUsage. Out-of-order tick
+    // resolution could revert tasksCompleted / USD spend counters to the
+    // pre-completion state. (Round-3 #10.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.metrics = seq;
+    fetch('/api/metrics')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.metrics || 0)) return;
+        const m = fresh && typeof fresh === 'object' ? fresh : (window._lastMetrics || {});
+        window._lastMetrics = m;
+        _safeRender('metrics', function() { renderMetrics(m); });
+      })
+      .catch(function () {
+        if (window._lastMetrics) _safeRender('metrics', function() { renderMetrics(window._lastMetrics); });
+      });
+  });
   // managed-processes panel — ETag-gated so unchanged ticks return 304 with
   // no body (P-6e2a8b13). Sequenced BEFORE the keep-processes call below via
   // .then() so the keep renderer reads a populated managed-PID cache for
@@ -415,28 +774,150 @@ function _processStatusUpdate(data) {
       .catch(function () { /* keep render even if managed fetch failed — getLastItems() returns the last good cache (or []) */ })
       .then(function () { try { renderKeepProcesses(); } catch {} });
   }
-  _safeRender('workItems', function() { renderWorkItems(data.workItems || []); });
+  // Work items now come from /api/work-items — a dedicated fresh-JSON
+  // endpoint that re-runs getWorkItems() server-side on every request
+  // with input-mtime ETag (issue #2949). The previous /state/ + stale-
+  // enrichment-overlay path is gone: enrichment runs server-side fresh,
+  // so _pr/_prUrl/_pendingReason/_skipReason are guaranteed current.
+  _safeRender('workItems', function() {
+    // Stamp the request with a monotonic seq — late arrivals from a prior
+    // tick can't clobber fresh state. (Round-2 review finding #6.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.workItems = seq;
+    fetch('/api/work-items')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.workItems || 0)) return;
+        const list = Array.isArray(fresh) ? fresh : (window._lastWorkItems || []);
+        window._lastWorkItems = list;
+        _safeRender('workItems', function() { renderWorkItems(list); });
+        // prunePrdRequeueState reads the FRESH fetched list rather than the
+        // synchronously-empty window._lastWorkItems. (Review finding #5.)
+        _safeRender('prunePrdRequeueState', function() { prunePrdRequeueState(list); });
+        // F1/F3 cross-slice trigger fires here so the +N follow-up chip on
+        // PRs and the plan-status badges update when WI state actually
+        // changes. (Round-2 review findings #1 + #2.)
+        _fireCrossSliceRender('workItems', list);
+      })
+      .catch(function () {
+        // Re-render against the last known good list rather than blanking
+        // the panel. Skip prunePrdRequeueState entirely on the catch arm —
+        // calling it against a stale list could delete optimistic UI chips
+        // the user just set between the fetch dispatch and the failure.
+        // (Round-2 review finding #8.)
+        if (Array.isArray(window._lastWorkItems)) {
+          _safeRender('workItems', function() { renderWorkItems(window._lastWorkItems); });
+        }
+      });
+  });
   _changed('skills', data.skills);
   _safeRender('skills', function() { renderSkills(data.skills || []); });
   _changed('mcpServers', data.mcpServers);
   _safeRender('mcpServers', function() { renderMcpServers(data.mcpServers || []); });
-  _changed('schedules', data.schedules);
-  _safeRender('schedules', function() { renderSchedules(data.schedules || []); });
-  _changed('watches', data.watches);
-  _safeRender('watches', function() { renderWatches(data.watches || []); });
-  _changed('meetings', data.meetings);
-  _safeRender('meetings', function() { renderMeetings(data.meetings || []); });
-  _changed('pipelines', data.pipelines);
+  // Schedule definitions stay on /api/status (config-derived), but the
+  // _lastRun/_lastResult overlay is re-applied client-side from
+  // /state/engine/schedule-runs.json so a freshly-fired schedule lights up
+  // within one 4 s poll (issue #2949).
+  // Schedules now come from /api/schedules — a dedicated fresh-JSON endpoint
+  // that merges config.schedules with schedule-runs.json server-side, ETag
+  // off input mtimes (issue #2949).
+  _safeRender('schedules', function() {
+    fetch('/api/schedules')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        const list = Array.isArray(fresh) ? fresh : (data.schedules || []);
+        window._lastSchedules = list;
+        _safeRender('schedules', function() { renderSchedules(list); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastSchedules)) _safeRender('schedules', function() { renderSchedules(window._lastSchedules); });
+      });
+  });
+  // Watches array comes from /state/engine/watches.json (issue #2949).
+  _safeRender('watches', function() {
+    // Seq guard — watches.json is mutated every 3 ticks by engine/watches.js
+    // (mutateWatches on watch-fire / pause). (Round-4 #10.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.watches = seq;
+    Promise.resolve(fetchWatchesFromDisk())
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.watches || 0)) return;
+        const list = fresh && fresh.length ? fresh : (window._lastWatches || []);
+        window._lastWatches = list;
+        _safeRender('watches', function() { renderWatches(list); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastWatches)) _safeRender('watches', function() { renderWatches(window._lastWatches); });
+      });
+  });
+  // Meetings come from /state/meetings (dir listing + per-file fetch),
+  // slimmed client-side to match dashboard.js _slimMeetingForStatus.
+  // Issue #2949 — same outer-cache staleness fix as work-items + PRs.
+  _safeRender('meetings', function() {
+    Promise.resolve(fetchMeetingsFromDisk())
+      .then(function (fresh) {
+        const list = fresh && fresh.length ? fresh : (window._lastMeetings || []);
+        window._lastMeetings = list;
+        _safeRender('meetings', function() { renderMeetings(list); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastMeetings)) _safeRender('meetings', function() { renderMeetings(window._lastMeetings); });
+      });
+  });
   if (typeof renderPipelines === 'function') {
-    _safeRender('pipelines', function() { renderPipelines(data.pipelines || []); });
+    // Definitions stay on /api/status, runs overlay (last 5 per pipeline)
+    // is re-applied client-side from /state/engine/pipeline-runs.json so a
+    // newly-started run lights the panel within one 4 s poll (issue #2949).
+    // Pipelines now come from /api/pipelines — a dedicated fresh-JSON
+    // endpoint that merges pipelines/*.json with pipeline-runs.json
+    // (last 5 runs per pipeline) server-side (issue #2949).
+    _safeRender('pipelines', function() {
+      // Seq guard — pipeline-runs.json is mutated on every pipeline run
+      // start/completion; out-of-order resolution could revert run state.
+      // (Round-4 #10.)
+      const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+      window._lastRequestedSeq = window._lastRequestedSeq || {};
+      window._lastRequestedSeq.pipelines = seq;
+      fetch('/api/pipelines')
+        .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+        .then(function (fresh) {
+          if (seq < (window._lastRequestedSeq.pipelines || 0)) return;
+          const list = Array.isArray(fresh) ? fresh : (window._lastPipelines || []);
+          window._lastPipelines = list;
+          _safeRender('pipelines', function() { renderPipelines(list); });
+        })
+        .catch(function () {
+          if (Array.isArray(window._lastPipelines)) _safeRender('pipelines', function() { renderPipelines(window._lastPipelines); });
+        });
+    });
   }
-  _changed('pinned', data.pinned);
-  _safeRender('pinned', function() { renderPinned(data.pinned || []); });
-  // Sidebar counts (cheap)
+  // Pinned notes come from /api/pinned (issue #2949).
+  _safeRender('pinned', function() {
+    // Seq guard — pinned.md is user-mutated via POST /api/pinned. (Round-4 #10.)
+    const seq = (window._refreshSeq = (window._refreshSeq || 0) + 1);
+    window._lastRequestedSeq = window._lastRequestedSeq || {};
+    window._lastRequestedSeq.pinned = seq;
+    fetch('/api/pinned')
+      .then(function (r) { return r.ok ? r.json() : Promise.reject(); })
+      .then(function (fresh) {
+        if (seq < (window._lastRequestedSeq.pinned || 0)) return;
+        const list = Array.isArray(fresh) ? fresh : (window._lastPinned || []);
+        window._lastPinned = list;
+        _safeRender('pinned', function() { renderPinned(list); });
+      })
+      .catch(function () {
+        if (Array.isArray(window._lastPinned)) _safeRender('pinned', function() { renderPinned(window._lastPinned); });
+      });
+  });
+  // Sidebar counts — read from the dedicated-endpoint caches; data.workItems
+  // / data.pullRequests are undefined post-slim. Renders empty until the
+  // first /api/work-items + /api/pull-requests fetches resolve.
   const swi = document.getElementById('sidebar-wi');
-  if (swi) swi.textContent = (data.workItems || []).length || '';
+  if (swi) swi.textContent = (window._lastWorkItems || []).length || '';
   const spr = document.getElementById('sidebar-pr');
-  if (spr) spr.textContent = (data.pullRequests || []).length || '';
+  if (spr) spr.textContent = (window._lastPullRequests || []).length || '';
   // 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:
@@ -450,26 +931,11 @@ function _processStatusUpdate(data) {
   _safeRender('refreshKnowledgeBase', function() { refreshKnowledgeBase(); });
   _safeRender('refreshPlans', function() { 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 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.
-    _safeRender('prs:cross-slice', function() { renderPrs(data.pullRequests || []); });
-  }
-  if ((_workItemsChanged || _prsChanged) && Array.isArray(window._lastPlans) && typeof renderPlans === 'function') {
-    // F3: derivePlanStatus + _renderVerifyBadge derive from pullRequests +
-    // 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.
-    _safeRender('plans:cross-slice', function() { renderPlans(window._lastPlans); });
-  }
+  // F1/F3 cross-slice triggers moved into the /api/work-items + /api/pull-
+  // requests .then handlers (see _fireCrossSliceRender helper). The
+  // synchronous-tick versions used to fire off _changed signatures derived
+  // from data.workItems / data.pullRequests, both undefined after the
+  // /api/status slim. (Round-2 review findings #1 + #2.)
 
   // Sidebar activity indicators — show red dot on pages with new activity
   try {
@@ -482,22 +948,12 @@ function _processStatusUpdate(data) {
   } catch { /* expected on first load */ }
 }
 
+// Auto-reload policy (2026-05-29):
+// Reload only on dashboardStartedAt change (signal that `minions restart`
+// happened and the process is new). dashboardBuildId / runningCommit /
+// installId mismatch DO NOT auto-reload anymore — code edits and engine
+// commits must not silently interrupt the operator's open session.
 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;
-// Hard-reload trigger when the *engine* commit changes — `minions restart`
-// after a `git pull` swaps engine code but doesn't touch any
-// /dashboard/** asset, so `dashboardBuildId` stays the same and the
-// existing buildId reload above never fires. Without this, the stale
-// "Engine running v… — disk has v…" banner persists in already-open tabs
-// until the (hourly by default) /api/version repoll catches up.
-let _knownEngineRunningCommit = 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 —
@@ -696,7 +1152,8 @@ document.addEventListener('visibilitychange', function() {
   _lastVisibilityChangeAt = now;
 });
 
-async function refresh() {
+async function refresh(opts) {
+  opts = opts || {};
   if (_refreshInFlight) return;
   // Backoff gate — only active while the unreachable banner is up. Skips
   // setInterval ticks until _nextPollAllowedAt is reached so a downed
@@ -761,7 +1218,19 @@ async function refresh() {
         _diagEntry.bytes_received = cl != null && cl !== '' ? Number(cl) : null;
       }
     }
-    // Auto-reload when dashboard restarts (stale connections cause "Failed to fetch" on CC/doc-chat)
+    // Auto-reload policy (2026-05-29):
+    //   - dashboardStartedAt change → reload  (covers `minions restart`)
+    //   - dashboardBuildId change   → DO NOT reload  (dashboard/** edits
+    //     while dev'ing the UI must not silently kick connected tabs)
+    //   - runningCommit change      → DO NOT reload  (engine git-pull is
+    //     not a dashboard restart — engine code change doesn't justify
+    //     interrupting an open dashboard session)
+    //   - installId change          → DO NOT reload  (MINIONS_HOME swap
+    //     is the operator's call to refresh, not ours)
+    //
+    // The user explicitly wants `minions restart` to reload the tab so
+    // they pick up any updated code; they do NOT want any other code-
+    // change signal to trigger a reload.
     const dashId = (data.version && data.version.dashboardStartedAt) || null;
     if (dashId && _knownDashboardStartId && dashId !== _knownDashboardStartId) {
       console.log('Dashboard restarted — reloading page');
@@ -769,31 +1238,7 @@ 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;
-    // Auto-reload when the engine's commit changed (engine code was updated
-    // and process restarted, e.g. via `minions restart` after `git pull`).
-    // dashboardBuildId only hashes HTML/JS/CSS assets, so engine-only code
-    // updates don't trigger that path — leaving stale "Engine running v… —
-    // disk has v…" banners until the hourly /api/version repoll.
-    const engineCommit = (data.version && data.version.runningCommit) || null;
-    if (engineCommit && _knownEngineRunningCommit && engineCommit !== _knownEngineRunningCommit) {
-      console.log('Engine code changed — reloading page');
-      location.reload();
-      return;
-    }
-    if (engineCommit) _knownEngineRunningCommit = engineCommit;
-    // Successful poll — clear unreachable state. Placed AFTER the reload
-    // guards above so a dashboard restart still triggers location.reload()
-    // instead of just dismissing the banner.
+    // Successful poll — clear unreachable state.
     _lastStatusOkAt = Date.now();
     _consecutiveStatusFails = 0;
     _nextPollAllowedAt = 0;
@@ -805,14 +1250,16 @@ async function refresh() {
       _lastChangedFlags = _diagChanges;
     }
     try {
-      _processStatusUpdate(data);
+      _processStatusUpdate(data, opts);
     } finally {
       if (_diagOn) {
         _lastChangedFlags = null;
         _diagEntry.render_duration_ms = Date.now() - _renderStart;
         _diagEntry.changed = _diagChanges;
         _diagEntry.workItems_changed = !!(_diagChanges && _diagChanges.workItems);
-        _diagEntry.workItems_count = (data.workItems || []).length;
+        // Post-slim, data.workItems is undefined; read from the dedicated
+        // endpoint cache.
+        _diagEntry.workItems_count = (window._lastWorkItems || []).length;
         _diagEntry.statusCacheVersion = (data.version && data.version.statusCacheVersion) != null
           ? data.version.statusCacheVersion
           : null;