@yemi33/minions 0.1.2036 → 0.1.2038

package/dashboard/js/refresh.js

@@ -84,6 +84,12 @@ const RENDER_VERSIONS = {
 const _sectionCache = {};
 const _lastValueByKey = {};
 const _sectionCacheVersions = {};
+// Refresh diagnostics: when refresh() opens a tick, it sets _lastChangedFlags
+// to a fresh object so every _changed() call publishes its boolean result
+// here. After _processStatusUpdate() returns, refresh() captures the map
+// into the ring-buffer entry then resets _lastChangedFlags to null so steady-
+// state has no side effect. See "Refresh diagnostics" block below.
+let _lastChangedFlags = null;
 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.
@@ -98,11 +104,18 @@ function _changed(key, value, version) {
   var cacheKey = key + ':v' + v;
   // Reference-equality short-circuit: skip the stringify entirely when the
   // server returned 304 and the same object reference is being re-checked.
-  if (_lastValueByKey[key] === value) return false;
+  if (_lastValueByKey[key] === value) {
+    if (_lastChangedFlags) _lastChangedFlags[key] = false;
+    return false;
+  }
   _lastValueByKey[key] = value;
   var json = JSON.stringify(value);
-  if (_sectionCache[cacheKey] === json) return false;
+  if (_sectionCache[cacheKey] === json) {
+    if (_lastChangedFlags) _lastChangedFlags[key] = false;
+    return false;
+  }
   _sectionCache[cacheKey] = json;
+  if (_lastChangedFlags) _lastChangedFlags[key] = true;
   return true;
 }
 
@@ -122,7 +135,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 +265,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 +293,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);
   }
 
@@ -311,9 +333,78 @@ let _lastStatusData = null;
 // when the first hasn't finished — the next interval fire picks up the
 // fresh state anyway.
 let _refreshInFlight = false;
+
+// ── Refresh diagnostics (W-mphejzx100081972) ─────────────────────────────
+// Ring buffer capturing the last 50 /api/status poll cycles so a user
+// reporting "the dashboard didn't auto-update when X changed" can paste
+// `window._refreshDiagnostics()` from devtools or click the "diag" footer
+// chip to surface a table. Gated behind feature flag
+// `dashboard-refresh-diagnostics` (engine/features.js) — disabled in
+// production, enabled in dev. When disabled, the helpers below are no-ops
+// (the boolean check is the first line of every collection path) so the
+// steady-state poll loop is byte-identical to its pre-flag behaviour.
+const _DIAG_RING_SIZE = 50;
+const _refreshDiagBuf = [];
+let _prevRefreshTs = 0;
+let _diagHiddenSinceMs = 0; // ts when tab last went hidden; 0 when visible
+let _lastVisibilityChangeAt = 0;
+function _isRefreshDiagOn() {
+  try {
+    return !!(window.MinionsFeatures && window.MinionsFeatures.isOn('dashboard-refresh-diagnostics'));
+  } catch { return false; }
+}
+function _pushDiagEntry(entry) {
+  _refreshDiagBuf.push(entry);
+  if (_refreshDiagBuf.length > _DIAG_RING_SIZE) _refreshDiagBuf.shift();
+}
+// Expose a copy of the ring buffer so devtools paste-back captures a
+// stable snapshot — not a live reference the user could accidentally mutate.
+window._refreshDiagnostics = function() { return _refreshDiagBuf.slice(); };
+window._refreshDiagnosticsClear = function() { _refreshDiagBuf.length = 0; };
+document.addEventListener('visibilitychange', function() {
+  if (!_isRefreshDiagOn()) return;
+  const now = Date.now();
+  const vs = document.visibilityState;
+  let hiddenForMs = null;
+  if (vs === 'visible' && _diagHiddenSinceMs > 0) {
+    hiddenForMs = now - _diagHiddenSinceMs;
+    _diagHiddenSinceMs = 0;
+  } else if (vs === 'hidden') {
+    _diagHiddenSinceMs = now;
+  }
+  _pushDiagEntry({
+    ts: now,
+    kind: 'visibility',
+    visibility: vs,
+    hidden_for_ms: hiddenForMs,
+    gap_since_prev_ms: _lastVisibilityChangeAt ? now - _lastVisibilityChangeAt : null,
+  });
+  _lastVisibilityChangeAt = now;
+});
+
 async function refresh() {
   if (_refreshInFlight) return;
   _refreshInFlight = true;
+  const _diagOn = _isRefreshDiagOn();
+  const _t0 = _diagOn ? Date.now() : 0;
+  const _gap = _diagOn && _prevRefreshTs ? _t0 - _prevRefreshTs : null;
+  if (_diagOn) _prevRefreshTs = _t0;
+  const _diagEntry = _diagOn ? {
+    ts: _t0,
+    kind: 'refresh',
+    gap_since_prev_ms: _gap,
+    visibility: (typeof document !== 'undefined' && document.visibilityState) || null,
+    response_status: null,
+    etag_sent: _lastStatusEtag,
+    etag_received: null,
+    bytes_received: null,
+    statusCacheVersion: null,
+    workItems_changed: null,
+    workItems_count: null,
+    changed: null,
+    render_duration_ms: null,
+    error_message: null,
+  } : null;
   try {
     const headers = {};
     if (_lastStatusEtag) headers['If-None-Match'] = _lastStatusEtag;
@@ -322,6 +413,10 @@ async function refresh() {
     if (res.status === 304 && _lastStatusData) {
       // Cache hit — reuse last payload, skip parsing entirely.
       data = _lastStatusData;
+      if (_diagEntry) {
+        _diagEntry.response_status = '304';
+        _diagEntry.bytes_received = 0;
+      }
     } else {
       data = await res.json();
       const etag = res.headers && (res.headers.get ? res.headers.get('etag') : null);
@@ -329,6 +424,12 @@ async function refresh() {
         _lastStatusEtag = etag;
         _lastStatusData = data;
       }
+      if (_diagEntry) {
+        _diagEntry.response_status = String(res.status);
+        _diagEntry.etag_received = etag || null;
+        const cl = res.headers && (res.headers.get ? res.headers.get('content-length') : null);
+        _diagEntry.bytes_received = cl != null && cl !== '' ? Number(cl) : null;
+      }
     }
     // Auto-reload when dashboard restarts (stale connections cause "Failed to fetch" on CC/doc-chat)
     const dashId = (data.version && data.version.dashboardStartedAt) || null;
@@ -348,9 +449,37 @@ async function refresh() {
       return;
     }
     if (buildId) _knownDashboardBuildId = buildId;
-    _processStatusUpdate(data);
-  } catch(e) { console.error('refresh error', e); }
-  finally { _refreshInFlight = false; }
+    const _renderStart = _diagOn ? Date.now() : 0;
+    let _diagChanges = null;
+    if (_diagOn) {
+      _diagChanges = {};
+      _lastChangedFlags = _diagChanges;
+    }
+    try {
+      _processStatusUpdate(data);
+    } 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;
+        _diagEntry.statusCacheVersion = (data.version && data.version.statusCacheVersion) != null
+          ? data.version.statusCacheVersion
+          : null;
+      }
+    }
+  } catch(e) {
+    console.error('refresh error', e);
+    if (_diagEntry && !_diagEntry.response_status) {
+      _diagEntry.response_status = (e && e.name === 'AbortError') ? 'abort' : 'error';
+      _diagEntry.error_message = String((e && e.message) || e);
+    }
+  }
+  finally {
+    _refreshInFlight = false;
+    if (_diagEntry) _pushDiagEntry(_diagEntry);
+  }
 }
 
 refresh();
@@ -366,3 +495,134 @@ document.querySelectorAll('.sidebar-link').forEach(link => {
 switchPage(currentPage);
 
 window.MinionsRefresh = { refresh };
+
+// ── Refresh-diagnostic footer chip + modal (W-mphejzx100081972) ───────────
+// Injected only when the dashboard-refresh-diagnostics feature flag is on
+// (engine/features.js → MINIONS_FEATURES.flags). The chip floats bottom-right
+// and opens a simple table view of the ring buffer plus a "send to engine"
+// button that POSTs the snapshot to /api/diagnostics/refresh. No DOM is
+// touched (and no listeners installed beyond the visibilitychange handler
+// above, which itself short-circuits when the flag is off) when the flag is
+// disabled — production behaviour stays untouched.
+(function installRefreshDiagChip() {
+  if (!_isRefreshDiagOn()) return;
+  try {
+    const chip = document.createElement('button');
+    chip.id = 'refresh-diag-chip';
+    chip.type = 'button';
+    chip.textContent = 'diag';
+    chip.title = 'Open dashboard refresh diagnostics';
+    chip.style.cssText = 'position:fixed;right:12px;bottom:12px;z-index:9999;background:var(--surface,#222);color:var(--muted,#aaa);border:1px solid var(--border,#444);border-radius:10px;padding:3px 8px;font-size:10px;font-family:inherit;cursor:pointer;opacity:0.75';
+    chip.addEventListener('click', _openRefreshDiagModal);
+    document.body.appendChild(chip);
+  } catch { /* DOM may not be ready in unusual test embeds */ }
+})();
+
+function _openRefreshDiagModal() {
+  // Remove any prior instance so re-clicks re-render against the latest buffer.
+  const prior = document.getElementById('refresh-diag-modal');
+  if (prior) prior.remove();
+  const entries = window._refreshDiagnostics();
+  const overlay = document.createElement('div');
+  overlay.id = 'refresh-diag-modal';
+  overlay.style.cssText = 'position:fixed;inset:0;background:rgba(0,0,0,0.5);z-index:10000;display:flex;align-items:center;justify-content:center;padding:24px';
+  overlay.addEventListener('click', function(e) { if (e.target === overlay) overlay.remove(); });
+  const panel = document.createElement('div');
+  panel.style.cssText = 'background:var(--surface,#1c1c1c);color:var(--text,#ddd);border:1px solid var(--border,#444);border-radius:8px;max-width:1200px;max-height:80vh;width:100%;display:flex;flex-direction:column;overflow:hidden;font-family:inherit;font-size:11px';
+  const head = document.createElement('div');
+  head.style.cssText = 'padding:10px 14px;border-bottom:1px solid var(--border,#444);display:flex;align-items:center;justify-content:space-between;gap:8px';
+  const title = document.createElement('div');
+  title.style.cssText = 'font-weight:700;color:var(--blue,#58a6ff);font-size:13px';
+  title.textContent = 'Refresh diagnostics — ' + entries.length + ' / ' + _DIAG_RING_SIZE + ' entries';
+  const actions = document.createElement('div');
+  actions.style.cssText = 'display:flex;gap:6px';
+  const sendBtn = document.createElement('button');
+  sendBtn.type = 'button';
+  sendBtn.textContent = 'Send to engine';
+  sendBtn.style.cssText = 'background:var(--blue,#1f6feb);color:#fff;border:none;border-radius:4px;padding:4px 10px;font-size:11px;cursor:pointer';
+  sendBtn.addEventListener('click', function() {
+    sendBtn.disabled = true;
+    sendBtn.textContent = 'Sending…';
+    safeFetch('/api/diagnostics/refresh', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ entries: window._refreshDiagnostics() }),
+    })
+      .then(function(r) { return r.json().catch(function() { return {}; }).then(function(j) { return { ok: r.ok, body: j }; }); })
+      .then(function(r) {
+        sendBtn.textContent = r.ok ? ('Sent (' + (r.body && r.body.written) + ')') : ('Failed: ' + (r.body && r.body.error || r.ok));
+      })
+      .catch(function(e) { sendBtn.textContent = 'Error: ' + (e && e.message || e); })
+      .finally(function() { setTimeout(function() { sendBtn.disabled = false; sendBtn.textContent = 'Send to engine'; }, 2500); });
+  });
+  const clearBtn = document.createElement('button');
+  clearBtn.type = 'button';
+  clearBtn.textContent = 'Clear';
+  clearBtn.style.cssText = 'background:none;color:var(--muted,#aaa);border:1px solid var(--border,#444);border-radius:4px;padding:4px 10px;font-size:11px;cursor:pointer';
+  clearBtn.addEventListener('click', function() { window._refreshDiagnosticsClear(); overlay.remove(); });
+  const closeBtn = document.createElement('button');
+  closeBtn.type = 'button';
+  closeBtn.textContent = 'Close';
+  closeBtn.style.cssText = 'background:none;color:var(--muted,#aaa);border:1px solid var(--border,#444);border-radius:4px;padding:4px 10px;font-size:11px;cursor:pointer';
+  closeBtn.addEventListener('click', function() { overlay.remove(); });
+  actions.appendChild(sendBtn);
+  actions.appendChild(clearBtn);
+  actions.appendChild(closeBtn);
+  head.appendChild(title);
+  head.appendChild(actions);
+  const body = document.createElement('div');
+  body.style.cssText = 'overflow:auto;padding:8px 14px';
+  body.appendChild(_renderRefreshDiagTable(entries));
+  panel.appendChild(head);
+  panel.appendChild(body);
+  overlay.appendChild(panel);
+  document.body.appendChild(overlay);
+}
+
+function _renderRefreshDiagTable(entries) {
+  const table = document.createElement('table');
+  table.style.cssText = 'width:100%;border-collapse:collapse;font-family:monospace;font-size:11px';
+  const cols = ['ts', 'kind', 'gap', 'vis', 'status', 'etag↓', 'bytes', 'cacheV', 'wi', 'wiΔ', 'changed', 'render(ms)', 'note'];
+  const thead = document.createElement('thead');
+  const trh = document.createElement('tr');
+  for (const c of cols) {
+    const th = document.createElement('th');
+    th.textContent = c;
+    th.style.cssText = 'text-align:left;padding:3px 6px;border-bottom:1px solid var(--border,#444);color:var(--muted,#aaa);font-weight:600';
+    trh.appendChild(th);
+  }
+  thead.appendChild(trh);
+  table.appendChild(thead);
+  const tbody = document.createElement('tbody');
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    const tr = document.createElement('tr');
+    const changedKeys = e.changed ? Object.keys(e.changed).filter(function(k) { return e.changed[k]; }) : [];
+    const isVis = e.kind === 'visibility';
+    const cells = [
+      new Date(e.ts).toLocaleTimeString(),
+      e.kind || 'refresh',
+      e.gap_since_prev_ms != null ? e.gap_since_prev_ms + 'ms' : '',
+      e.visibility || '',
+      isVis ? (e.hidden_for_ms != null ? 'hidden ' + e.hidden_for_ms + 'ms' : '—') : (e.response_status || ''),
+      e.etag_received ? String(e.etag_received).slice(0, 12) + '…' : '',
+      e.bytes_received != null ? e.bytes_received : '',
+      e.statusCacheVersion != null ? e.statusCacheVersion : '',
+      e.workItems_count != null ? e.workItems_count : '',
+      e.workItems_changed === true ? '✓' : (e.workItems_changed === false ? '' : ''),
+      changedKeys.join(',') || '',
+      e.render_duration_ms != null ? e.render_duration_ms : '',
+      e.error_message || '',
+    ];
+    for (const v of cells) {
+      const td = document.createElement('td');
+      td.textContent = String(v);
+      td.style.cssText = 'padding:3px 6px;border-bottom:1px solid rgba(255,255,255,0.05);vertical-align:top';
+      tr.appendChild(td);
+    }
+    if (isVis) tr.style.background = 'rgba(63,185,80,0.05)';
+    tbody.appendChild(tr);
+  }
+  table.appendChild(tbody);
+  return table;
+}

package/dashboard/js/render-work-items.js

@@ -82,8 +82,20 @@ function wiRow(item) {
     '<td>' + prLink + '</td>' +
     '<td><span class="pr-date">' + escapeHtml((item.created || '').slice(0, 16).replace('T', ' ')) + '</span></td>' +
     '<td style="white-space:nowrap;font-size:9px;color:var(--muted)">' +
-      (item.references && item.references.length ? '<span title="' + item.references.length + ' reference(s)" style="margin-right:4px">&#x1F517;' + item.references.length + '</span>' : '') +
-      (item.acceptanceCriteria && item.acceptanceCriteria.length ? '<span title="' + item.acceptanceCriteria.length + ' acceptance criteria">&#x2611;' + item.acceptanceCriteria.length + '</span>' : '') +
+      (function() {
+        // /api/status slims the full arrays into integer counts
+        // (dashboard.js:1796-1797: referencesCount / acceptanceCriteriaCount).
+        // Read those first; fall back to the array length for callers that
+        // still pass the full record (e.g. legacy fixtures, hydrated detail).
+        var refCount = (typeof item.referencesCount === 'number')
+          ? item.referencesCount
+          : (Array.isArray(item.references) ? item.references.length : 0);
+        var acCount = (typeof item.acceptanceCriteriaCount === 'number')
+          ? item.acceptanceCriteriaCount
+          : (Array.isArray(item.acceptanceCriteria) ? item.acceptanceCriteria.length : 0);
+        return (refCount ? '<span title="' + refCount + ' reference(s)" style="margin-right:4px">&#x1F517;' + refCount + '</span>' : '') +
+               (acCount ? '<span title="' + acCount + ' acceptance criteria">&#x2611;' + acCount + '</span>' : '');
+      })() +
     '</td>' +
     '<td style="white-space:nowrap">' +
       ((item.status === 'pending' || item.status === 'failed') ? '<button class="pr-pager-btn" style="font-size:9px;padding:1px 6px;color:var(--blue);border-color:var(--blue);margin-right:4px" onclick="event.stopPropagation();editWorkItem(\'' + escapeHtml(item.id) + '\',\'' + escapeHtml(item._source || '') + '\')" title="Edit work item">&#x270E;</button>' : '') +
@@ -144,9 +156,42 @@ function renderWorkItems(items) {
   }
 }
 
-function editWorkItem(id, source) {
-  const item = allWorkItems.find(i => i.id === id);
-  if (!item) return;
+async function editWorkItem(id, source) {
+  const cached = allWorkItems.find(i => i.id === id);
+  if (!cached) return;
+  // Hydrate the full record before rendering the form. The /api/status slice
+  // strips `description`, `references`, and `acceptanceCriteria` (replacing
+  // the arrays with referencesCount / acceptanceCriteriaCount integers — see
+  // dashboard.js:1796-1797). Without hydration the textareas would pre-fill
+  // with empty values, and Save would POST description='', references=[],
+  // acceptanceCriteria=[] back to handleWorkItemsUpdate, which treats those
+  // as defined (dashboard.js:5157, :5164-5165) and silently wipes the stored
+  // values: data-loss on every pencil-edit of a pending/failed WI.
+  // See PR #2816 review feedback.
+  let item = cached;
+  const needsHydration = !cached.description ||
+    (cached.acceptanceCriteriaCount > 0 && !Array.isArray(cached.acceptanceCriteria)) ||
+    (cached.referencesCount > 0 && !Array.isArray(cached.references));
+  if (needsHydration) {
+    try {
+      const r = await fetch('/api/work-items/' + encodeURIComponent(id));
+      if (!r.ok) throw new Error('HTTP ' + r.status);
+      const data = await r.json();
+      const full = data && data.item;
+      if (!full) throw new Error('no item in response');
+      // Cached cross-slice fields (_pr, _source, _artifacts, _pendingReason,
+      // etc.) WIN over the on-disk record — they only exist on the engine's
+      // in-memory enrichment pass. The full record contributes description,
+      // acceptanceCriteria, and references back.
+      item = Object.assign({}, full, cached);
+      if (full.description != null) item.description = full.description;
+      if (Array.isArray(full.acceptanceCriteria)) item.acceptanceCriteria = full.acceptanceCriteria;
+      if (Array.isArray(full.references)) item.references = full.references;
+    } catch (e) {
+      alert('Failed to load work item for editing: ' + (e && e.message ? e.message : e) + '. Refusing to open the edit form with empty fields — saving would wipe the stored values.');
+      return;
+    }
+  }
   const types = ['implement', 'fix', 'review', 'plan', 'verify', 'decompose', 'meeting', 'investigate', 'refactor', 'test', 'explore', 'ask', 'docs', 'setup'];
   const priorities = ['critical', 'high', 'medium', 'low'];
   const agentOpts = (cmdAgents || []).map(a => '<option value="' + escapeHtml(a.id) + '"' + (item.agent === a.id ? ' selected' : '') + '>' + escapeHtml(a.name) + '</option>').join('');
@@ -467,11 +512,7 @@ async function _submitCreateWorkItem(e) {
   } catch (e) { alert('Error: ' + e.message); openCreateWorkItemModal(); }
 }
 
-function openWorkItemDetail(id) {
-  if (window.getSelection && window.getSelection().toString().length > 0) return;
-  const item = allWorkItems.find(i => i.id === id);
-  if (!item) return;
-
+function _wiRenderDetail(item) {
   const field = (label, value) => value ? '<div style="margin-bottom:8px"><span style="color:var(--muted);font-size:10px;text-transform:uppercase;letter-spacing:0.5px">' + label + '</span><div style="margin-top:2px">' + value + '</div></div>' : '';
   const badge = (cls, text) => '<span class="pr-badge ' + cls + '">' + escapeHtml(text) + '</span>';
   const statusCls = item.status === 'failed' ? 'rejected' : item.status === 'dispatched' ? 'building' : item.status === 'done' ? 'approved' : 'active';
@@ -483,7 +524,20 @@ function openWorkItemDetail(id) {
     '<span class="dispatch-type ' + (item.type || 'implement') + '">' + escapeHtml(item.type || 'implement') + '</span>' +
     '<span class="prd-item-priority ' + (item.priority || '') + '">' + escapeHtml(item.priority || 'medium') + '</span>' +
     '</div>';
-  html += field('Description', '<div style="font-size:12px;max-height:320px;overflow-y:auto;padding:8px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:var(--radius-sm)">' + renderMd(item.description || item.title || '—') + '</div>');
+  // Description: rendered from the FULL record once it's hydrated. The /api/status
+  // slice drops `description` to keep the SPA payload <500KB; on first paint we
+  // either render the title as a placeholder or, when description is already
+  // present (legacy/full record), render it directly. The hydration pass below
+  // re-renders this section in place once the fetch lands.
+  var _descHtml;
+  if (item.description) {
+    _descHtml = renderMd(item.description);
+  } else if (item._descriptionLoading) {
+    _descHtml = '<span style="color:var(--muted)">Loading description…</span>';
+  } else {
+    _descHtml = escapeHtml(item.title || '—');
+  }
+  html += field('Description', '<div id="wi-detail-desc" style="font-size:12px;max-height:320px;overflow-y:auto;padding:8px 10px;background:var(--surface2);border:1px solid var(--border);border-radius:var(--radius-sm)">' + _descHtml + '</div>');
   html += field('Agent', escapeHtml(item.dispatched_to || item.agent || 'Auto'));
   html += field('Source', escapeHtml(item._source || 'central'));
   if (item.created) html += field('Created', escapeHtml(formatLocalDateTime(item.created)));
@@ -522,9 +576,19 @@ function openWorkItemDetail(id) {
     : (typeof item.acceptanceCriteria === 'string' && item.acceptanceCriteria.trim()
         ? item.acceptanceCriteria.split(/\r?\n/).map(s => s.trim()).filter(Boolean)
         : []);
-  if (ac.length) html += field('Acceptance Criteria', '<ul style="margin:0;padding-left:20px">' + ac.map(c => '<li>' + escapeHtml(c) + '</li>').join('') + '</ul>');
+  if (ac.length) {
+    html += field('Acceptance Criteria', '<ul style="margin:0;padding-left:20px">' + ac.map(c => '<li>' + escapeHtml(c) + '</li>').join('') + '</ul>');
+  } else if (item.acceptanceCriteriaCount > 0) {
+    // Count-only marker from the slim /api/status slice; full list arrives
+    // on the next hydration pass (or is already loading).
+    html += field('Acceptance Criteria', '<span style="color:var(--muted)">' + item.acceptanceCriteriaCount + ' criteria — loading…</span>');
+  }
   var refs = Array.isArray(item.references) ? item.references.filter(r => r && typeof r === 'object' && r.url) : [];
-  if (refs.length) html += field('References', refs.map(r => '<a href="' + escapeHtml(r.url) + '" target="_blank" style="color:var(--blue)">' + escapeHtml(r.title || r.url) + '</a>' + (r.type ? ' <span style="color:var(--muted);font-size:10px">(' + escapeHtml(r.type) + ')</span>' : '')).join('<br>'));
+  if (refs.length) {
+    html += field('References', refs.map(r => '<a href="' + escapeHtml(r.url) + '" target="_blank" style="color:var(--blue)">' + escapeHtml(r.title || r.url) + '</a>' + (r.type ? ' <span style="color:var(--muted);font-size:10px">(' + escapeHtml(r.type) + ')</span>' : '')).join('<br>'));
+  } else if (item.referencesCount > 0) {
+    html += field('References', '<span style="color:var(--muted)">' + item.referencesCount + ' reference(s) — loading…</span>');
+  }
   if (item._humanFeedback) html += field('Human Feedback', (item._humanFeedback.rating === 'up' ? '👍' : '👎') + (item._humanFeedback.comment ? ' — ' + escapeHtml(item._humanFeedback.comment) : ''));
   if (item._pr) html += field('Pull Request', '<a href="' + escapeHtml(item._prUrl || '#') + '" target="_blank" style="color:var(--blue)">' + escapeHtml(item._pr) + '</a>');
 
@@ -562,12 +626,55 @@ function openWorkItemDetail(id) {
   if (item._totalInputTokens) html += field('Total Input Tokens', Number(item._totalInputTokens).toLocaleString());
   if (item._totalOutputTokens) html += field('Total Output Tokens', Number(item._totalOutputTokens).toLocaleString());
   html += '</div>';
+  return html;
+}
 
-  document.getElementById('modal-title').textContent = item.title || item.id;
-  document.getElementById('modal-body').innerHTML = html;
+function openWorkItemDetail(id) {
+  if (window.getSelection && window.getSelection().toString().length > 0) return;
+  const cached = allWorkItems.find(i => i.id === id);
+  if (!cached) return;
+
+  // Render the modal immediately from the cached (slim) record so the click
+  // feels instant. The /api/status slice is the source of badges, status,
+  // PR link, artifacts, etc. — everything except the heavy free-text fields
+  // (description, full acceptanceCriteria, full references) — see
+  // W-mphejzmj000718bf. We then hydrate the missing fields from
+  // GET /api/work-items/<id> and re-render in place.
+  const needsHydration = !cached.description ||
+    (cached.acceptanceCriteriaCount > 0 && !Array.isArray(cached.acceptanceCriteria)) ||
+    (cached.referencesCount > 0 && !Array.isArray(cached.references));
+
+  const initial = needsHydration ? Object.assign({}, cached, { _descriptionLoading: true }) : cached;
+  document.getElementById('modal-title').textContent = initial.title || initial.id;
+  document.getElementById('modal-body').innerHTML = _wiRenderDetail(initial);
   document.getElementById('modal-body').style.fontFamily = "'Segoe UI', system-ui, sans-serif";
   document.getElementById('modal-body').style.whiteSpace = 'normal';
   document.getElementById('modal').classList.add('open');
+
+  if (!needsHydration) return;
+
+  fetch('/api/work-items/' + encodeURIComponent(id))
+    .then(function(r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+    .then(function(data) {
+      // Guard against modal navigation away from this WI during the fetch.
+      var title = document.getElementById('modal-title');
+      if (!title || title.textContent !== (initial.title || initial.id)) return;
+      var full = data && data.item;
+      if (!full) return;
+      // Merge: cached cross-slice fields (_pr, _artifacts, etc.) WIN over
+      // the on-disk record so we don't lose engine enrichment that lives
+      // only on the in-memory pass. The full record contributes description,
+      // acceptanceCriteria, and references back to the rendered shape.
+      var merged = Object.assign({}, full, cached);
+      merged.description = full.description || cached.description || '';
+      if (Array.isArray(full.acceptanceCriteria)) merged.acceptanceCriteria = full.acceptanceCriteria;
+      if (Array.isArray(full.references)) merged.references = full.references;
+      document.getElementById('modal-body').innerHTML = _wiRenderDetail(merged);
+    })
+    .catch(function() {
+      var desc = document.getElementById('wi-detail-desc');
+      if (desc) desc.innerHTML = '<span style="color:var(--red)">Failed to load full record.</span>';
+    });
 }
 
 function openAllWorkItems() {

package/dashboard/js/settings.js

@@ -88,6 +88,7 @@ async function openSettings() {
       settingsField('Restart Grace Period', 'set-restartGracePeriod', e.restartGracePeriod || 1200000, 'ms', 'Grace period before orphan detection on restart') +
       settingsField('Meeting Round Timeout', 'set-meetingRoundTimeout', e.meetingRoundTimeout || 900000, 'ms', 'Auto-advance meeting round after this') +
       settingsField('Operator login (used in branch names)', 'set-operatorLogin', e.operatorLogin || '', '', 'Override the human operator login used in user/<loginname>/<wi-id>-<slug> branches. Empty = auto-resolve via gh / git email / OS username (currently resolves to: ' + (e._resolvedOperatorLogin || 'unknown') + ')') +
+      settingsField('Status WorkItems Retention', 'set-statusWorkItemsRetentionDays', e.statusWorkItemsRetentionDays ?? 7, 'days', 'Trim done/failed/cancelled work items older than N days from the /api/status workItems slice (active items are always shipped). Cuts SPA payload from ~3MB to <500KB. Set to 0 to disable trimming (full list shipped, restoring legacy behavior).') +
     '</div>' +
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">Automation</h3>' +
     '<div style="display:flex;flex-direction:column;gap:6px;margin-bottom:16px">' +
@@ -597,6 +598,7 @@ async function saveSettings() {
       restartGracePeriod: document.getElementById('set-restartGracePeriod').value,
       meetingRoundTimeout: document.getElementById('set-meetingRoundTimeout').value,
       operatorLogin: (document.getElementById('set-operatorLogin')?.value ?? '').trim(),
+      statusWorkItemsRetentionDays: document.getElementById('set-statusWorkItemsRetentionDays').value,
       autoApprovePlans: document.getElementById('set-autoApprovePlans').checked,
       evalLoop: document.getElementById('set-evalLoop').checked,
       autoDecompose: document.getElementById('set-autoDecompose').checked,

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;
@@ -1694,7 +1708,7 @@ function _buildStatusFastState() {
     dispatch: getDispatchQueue(),
     engineLog: getEngineLog(),
     metrics: getMetrics(),
-    workItems: getWorkItems(),
+    workItems: _slimWorkItemsForStatus(getWorkItems()),
     watches: watchesMod.getWatches(),
     meetings: _safeStatusSlice('meetings', () => meetingMod.getMeetings(), []),
     // QA runs — surfaced for the sidebar activity-dot counter and any future
@@ -1731,6 +1745,105 @@ function _safeStatusSlice(name, fn, fallback) {
   }
 }
 
+// ── /api/status workItems slimming (W-mphejzmj000718bf) ─────────────────────
+// Strip down the workItems slice shipped on /api/status to (a) drop terminal
+// (done/failed/cancelled) items older than engine.statusWorkItemsRetentionDays
+// and (b) project each surviving item onto a narrow shape that omits the
+// large free-text fields (description, full acceptanceCriteria, full
+// references). The dashboard never renders description/AC/references-detail
+// off the cached slice — `wiRow` only needs counts + status/badge fields,
+// and `openWorkItemDetail` fetches the full record on demand via
+// GET /api/work-items/<id>. Live measurement at task time: 796 items / ~3MB
+// → ~50–100 items / <500KB typical. Active items (pending/dispatched/queued)
+// are ALWAYS kept regardless of age.
+//
+// Set engine.statusWorkItemsRetentionDays = 0 to disable trimming entirely
+// (returns the full list unchanged, restoring legacy behavior).
+const _ACTIVE_WI_STATUSES_FOR_STATUS = new Set(['pending', 'dispatched', 'queued', 'paused', 'decomposed']);
+const _TERMINAL_WI_STATUSES_FOR_STATUS = new Set(['done', 'failed', 'cancelled']);
+function _resolveStatusWorkItemsRetentionDays() {
+  const raw = CONFIG?.engine?.statusWorkItemsRetentionDays;
+  if (raw === 0 || raw === '0') return 0;
+  const n = Number(raw);
+  if (Number.isFinite(n) && n >= 0) return n;
+  return shared.ENGINE_DEFAULTS.statusWorkItemsRetentionDays;
+}
+function _slimWorkItemForStatus(item) {
+  const slim = {
+    id: item.id,
+    title: item.title,
+    status: item.status,
+    type: item.type,
+    priority: item.priority,
+    _source: item._source,
+    created: item.created,
+  };
+  if (item.dispatched_to !== undefined) slim.dispatched_to = item.dispatched_to;
+  if (item.agent !== undefined) slim.agent = item.agent;
+  if (item._pr !== undefined) slim._pr = item._pr;
+  if (item._prUrl !== undefined) slim._prUrl = item._prUrl;
+  if (item._skipReason !== undefined) slim._skipReason = item._skipReason;
+  if (item._blockedBy !== undefined) slim._blockedBy = item._blockedBy;
+  if (item._humanFeedback !== undefined) slim._humanFeedback = item._humanFeedback;
+  if (Array.isArray(item.completedAgents)) slim.completedAgents = item.completedAgents;
+  if (item.failReason !== undefined) slim.failReason = item.failReason;
+  if (item.branchStrategy !== undefined) slim.branchStrategy = item.branchStrategy;
+  if (item.scope !== undefined) slim.scope = item.scope;
+  if (item.completedAt !== undefined) slim.completedAt = item.completedAt;
+  if (item.dispatched_at !== undefined) slim.dispatched_at = item.dispatched_at;
+  if (item._reopened !== undefined) slim._reopened = item._reopened;
+  if (item._pendingReason !== undefined) slim._pendingReason = item._pendingReason;
+  if (item._managedSpawnPartial !== undefined) slim._managedSpawnPartial = item._managedSpawnPartial;
+  if (item._securityFlag !== undefined) slim._securityFlag = item._securityFlag;
+  if (item._artifacts !== undefined) slim._artifacts = item._artifacts;
+  // Cross-slice fields read by derivePlanStatus / render-prd / refresh.js
+  // (sourcePlan, planFile, itemType, project, parent_id). Without these the
+  // plan-status derivation and decomposed-children rollup regress.
+  if (item.sourcePlan !== undefined) slim.sourcePlan = item.sourcePlan;
+  if (item.planFile !== undefined) slim.planFile = item.planFile;
+  if (item.itemType !== undefined) slim.itemType = item.itemType;
+  if (item.project !== undefined) slim.project = item.project;
+  if (item.parent_id !== undefined) slim.parent_id = item.parent_id;
+  // PR follow-up subobject is small and drives the +N chip + row badge.
+  if (item.meta && item.meta.pr_followup) slim.meta = { pr_followup: item.meta.pr_followup };
+  // Counts only — the modal fetches full arrays on demand via /api/work-items/<id>.
+  slim.referencesCount = Array.isArray(item.references) ? item.references.length : 0;
+  slim.acceptanceCriteriaCount = Array.isArray(item.acceptanceCriteria) ? item.acceptanceCriteria.length : 0;
+  return slim;
+}
+function _slimWorkItemsForStatus(items) {
+  if (!Array.isArray(items)) return items;
+  const retentionDays = _resolveStatusWorkItemsRetentionDays();
+  if (retentionDays <= 0) {
+    // Trimming disabled — keep full list but still flatten via slim shape
+    // so wire format is consistent (renderers never have to handle the old
+    // heavy fields). Set retentionDays to a huge value if you want EVERY
+    // terminal item, not just recent ones — 0 means "skip the date filter".
+    return items.map(_slimWorkItemForStatus);
+  }
+  const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  const surviving = [];
+  for (const item of items) {
+    if (!item) continue;
+    const status = item.status || 'pending';
+    if (_TERMINAL_WI_STATUSES_FOR_STATUS.has(status)) {
+      const ts = item.completedAt || item.dispatched_at || item.created || '';
+      const tsMs = ts ? Date.parse(ts) : NaN;
+      // Drop only when we have a parseable timestamp and it's beyond the
+      // window. Items with missing/unparseable timestamps stay visible —
+      // we'd rather over-include than silently hide them.
+      if (Number.isFinite(tsMs) && tsMs < cutoffMs) {
+        continue;
+      }
+    } else if (!_ACTIVE_WI_STATUSES_FOR_STATUS.has(status)) {
+      // Unknown status — keep, so a future status value isn't silently
+      // hidden until the constant set is updated.
+    }
+    surviving.push(_slimWorkItemForStatus(item));
+  }
+  return surviving;
+}
+
 // Build the slow-state slice (rarely-changing data: ~60s TTL).
 function _buildStatusSlowState() {
   const prdInfo = getPrdInfo();
@@ -1798,6 +1911,13 @@ function _buildStatusSlowState() {
         // 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,
+        // Monotonic counter bumped on every successful /api/status cache rebuild.
+        // Surfaced so the dashboard refresh-diagnostics ring buffer
+        // (dashboard/js/refresh.js, W-mphejzx100081972) can correlate "did the
+        // server cache actually advance between two ticks" — distinguishes
+        // (b) server kept returning 304 with stale data from (c) renderer
+        // change-detection caches skipped the render on fresh data.
+        statusCacheVersion: _statusCacheVersion,
         disk: diskVersion,
         diskCommit,
         engineStale,
@@ -1838,9 +1958,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 +1991,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 +2037,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 +2073,7 @@ function refreshStatusAsync() {
       let slow = _slowState;
       let preBuildSlowMtimes = null;
       if (slowStale) {
+        if (slowMtimeChanged) _invalidateSlowInnerCachesForMtimeChange();
         preBuildSlowMtimes = _getSlowMtimes();
         slow = _buildStatusSlowState();
       }
@@ -4797,6 +4927,31 @@ const server = http.createServer(async (req, res) => {
     } catch (e) { console.error('Archive fetch error:', e.message); return jsonReply(res, e.statusCode || 500, { error: e.message }); }
   }
 
+  // GET /api/work-items/<id> — return a single FULL work-item record by id
+  // (W-mphejzmj000718bf). The /api/status workItems slice ships a slimmed
+  // shape that omits description, full acceptanceCriteria, and full references
+  // to keep the SPA payload <500KB. The work-item detail modal calls this
+  // endpoint on click to fetch the full record on demand.
+  async function handleWorkItemsById(req, res, match) {
+    try {
+      const id = decodeURIComponent(match[1] || '').trim();
+      if (!id) return jsonReply(res, 400, { error: 'id required' });
+      // Reserved sub-paths handled by their own static routes — never fall
+      // through to this regex; defense-in-depth in case ordering ever
+      // changes.
+      if (id === 'archive' || id === 'retry' || id === 'update' || id === 'delete' ||
+          id === 'cancel' || id === 'reopen' || id === 'feedback') {
+        return jsonReply(res, 404, { error: 'work item not found' });
+      }
+      // Search central + every project's work-items.json for this id. The
+      // engine never enforces global id uniqueness in the file system, but
+      // collisions in practice are nil — first hit wins.
+      const found = getWorkItems().find(w => w && w.id === id);
+      if (!found) return jsonReply(res, 404, { error: 'work item not found' });
+      return jsonReply(res, 200, { item: found });
+    } catch (e) { return jsonReply(res, 500, { error: e.message }); }
+  }
+
   async function handleWorkItemsReopen(req, res) {
     try {
       const body = await readBody(req);
@@ -8368,6 +8523,21 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
         // String fields
         if (e.worktreeRoot !== undefined) _setEngineConfig('worktreeRoot', String(e.worktreeRoot || D.worktreeRoot));
+        // W-mphejzmj000718bf: /api/status workItems retention window. Handled
+        // outside the numericFields loop because `Number(0) || D[key]`
+        // collapses the "disable trim" value (0) back to the default — we
+        // want 0 to actually persist as "skip the date filter".
+        if (e.statusWorkItemsRetentionDays !== undefined) {
+          const raw = e.statusWorkItemsRetentionDays;
+          if (raw === '' || raw === null) {
+            _deleteEngineConfig('statusWorkItemsRetentionDays');
+          } else {
+            let val = Number(raw);
+            if (!Number.isFinite(val) || val < 0) val = D.statusWorkItemsRetentionDays;
+            if (val > 365) { _clamped.push(`statusWorkItemsRetentionDays: ${val} → 365 (range: 0–365)`); val = 365; }
+            _setEngineConfig('statusWorkItemsRetentionDays', val);
+          }
+        }
         // W-mpejf0fq000e84d6: operator login override. Empty string clears
         // the override (engine falls back to gh/git/os resolution); any other
         // value pins the login used in `user/<login>/<wi-id>-<slug>` branches.
@@ -8699,6 +8869,52 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
   }
 
+  // Refresh diagnostics — append the browser-side ring buffer to a rotating
+  // log so a user clicking "send to engine" from the diag chip persists the
+  // last ~50 /api/status polls for offline triage (W-mphejzx100081972).
+  // Rotated at 1 MB to bound disk usage; CSRF/origin-gated by the dispatcher
+  // (MUTATING_METHODS guard at dashboard.js:4337+).
+  const DASHBOARD_DIAGNOSTICS_LOG = path.join(ENGINE_DIR, 'dashboard-diagnostics.log');
+  const DASHBOARD_DIAGNOSTICS_ROTATE_BYTES = 1024 * 1024;
+  const DASHBOARD_DIAGNOSTICS_MAX_ENTRIES = 500;
+
+  async function handleDiagnosticsRefresh(req, res) {
+    try {
+      const body = await readBody(req);
+      const entries = body && Array.isArray(body.entries) ? body.entries : null;
+      if (!entries) return jsonReply(res, 400, { error: 'entries array required' });
+      if (entries.length > DASHBOARD_DIAGNOSTICS_MAX_ENTRIES) {
+        return jsonReply(res, 400, { error: `entries length ${entries.length} exceeds cap ${DASHBOARD_DIAGNOSTICS_MAX_ENTRIES}` });
+      }
+      // Rotate before write if the existing log is already at/over the cap.
+      // Single rolled file (.1) — older rotations are discarded; this is a
+      // diagnostic capture surface, not a long-term audit log.
+      try {
+        const st = fs.statSync(DASHBOARD_DIAGNOSTICS_LOG);
+        if (st.size >= DASHBOARD_DIAGNOSTICS_ROTATE_BYTES) {
+          const rolled = DASHBOARD_DIAGNOSTICS_LOG + '.1';
+          try { fs.unlinkSync(rolled); } catch { /* may not exist */ }
+          try { fs.renameSync(DASHBOARD_DIAGNOSTICS_LOG, rolled); } catch { /* best effort */ }
+        }
+      } catch { /* file may not exist yet */ }
+      const header = {
+        ts: new Date().toISOString(),
+        ua: String(req.headers['user-agent'] || '').slice(0, 200),
+        tab: String(req.headers['x-minions-dashboard-tab'] || '').slice(0, 80),
+        url: String(req.headers['x-minions-dashboard-url'] || '').slice(0, 200),
+        count: entries.length,
+      };
+      // One line per record: header line followed by one line per entry. JSON-
+      // Lines makes the file trivially `jq`-able for later analysis.
+      const lines = [JSON.stringify({ kind: 'batch', ...header })];
+      for (const e of entries) {
+        try { lines.push(JSON.stringify(e)); } catch { /* skip un-serialisable entry */ }
+      }
+      fs.appendFileSync(DASHBOARD_DIAGNOSTICS_LOG, lines.join('\n') + '\n');
+      return jsonReply(res, 200, { ok: true, written: entries.length, path: path.relative(MINIONS_DIR, DASHBOARD_DIAGNOSTICS_LOG) });
+    } catch (e) { return jsonReply(res, e.statusCode || 500, { error: e.message }); }
+  }
+
   // Slim UX surface for the experimental redesigned dashboard.
   // The HTML lives in dashboard/slim.html so the human can iterate on the
   // markup directly — we read the file from disk on each request (no in-
@@ -9569,6 +9785,13 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true });
     }},
+    // GET /api/work-items/<id> — fetch a single FULL work-item record by id.
+    // Registered AFTER all static /api/work-items/* routes so the regex never
+    // shadows them (route matching is sequential, first match wins).
+    // W-mphejzmj000718bf: the /api/status workItems slice drops description /
+    // acceptanceCriteria-detail / references-detail to cut payload size; the
+    // detail modal calls this endpoint on click to fetch the full record.
+    { method: 'GET', path: /^\/api\/work-items\/([^/?]+)$/, template: '/api/work-items/<id>', desc: 'Fetch a single full work-item record by id (description, acceptanceCriteria, references). The /api/status workItems slice ships a slimmed shape; this endpoint backs the detail modal.', handler: handleWorkItemsById },
 
     // Pinned notes
     { method: 'GET', path: '/api/pinned', desc: 'Get pinned notes', handler: async (req, res) => {
@@ -10181,6 +10404,9 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     // Feature flags (experimental / in-progress UX gates — see engine/features.js)
     { method: 'GET', path: '/api/features', desc: 'List registered feature flags with current enabled state', handler: handleFeaturesList },
     { method: 'POST', path: '/api/features/toggle', desc: 'Enable/disable a registered feature flag', params: 'id, enabled', handler: handleFeaturesToggle },
+
+    // Diagnostics — refresh ring buffer persistence (W-mphejzx100081972).
+    { method: 'POST', path: '/api/diagnostics/refresh', desc: 'Append a dashboard refresh-diagnostic ring buffer batch to engine/dashboard-diagnostics.log (rotated at 1 MB)', params: 'entries[]', handler: handleDiagnosticsRefresh },
   ];
 
   // ── Route Dispatcher ────────────────────────────────────────────────────────

package/engine/features.js

@@ -53,6 +53,20 @@ const FEATURES = {
     addedIn: '0.1.1916',
     requiredCcRuntime: 'copilot',
   },
+  // dashboard-refresh-diagnostics — W-mphejzx100081972. Enables the in-browser
+  // /api/status poll telemetry ring buffer in dashboard/js/refresh.js: per-cycle
+  // ETag/status/bytes/render-duration capture, visibility-transition tracking,
+  // a small "diag" footer chip that opens a table modal, and a "send to engine"
+  // button that POSTs the buffer to /api/diagnostics/refresh for offline triage.
+  // Default OFF in production; flip ON in dev (or via env-var override) before
+  // reproducing a "didn't auto-update" complaint so the telemetry is captured.
+  // Disabled => the poll loop is byte-identical to its pre-flag steady state
+  // (the diagnostic helpers no-op via _isRefreshDiagOn() at the top of refresh()).
+  'dashboard-refresh-diagnostics': {
+    description: 'Capture the last 50 dashboard /api/status poll cycles (timing, ETag, status code, render duration, per-renderer change flags) in a browser-side ring buffer accessible via window._refreshDiagnostics, a footer "diag" chip, and POST /api/diagnostics/refresh.',
+    default: false,
+    addedIn: '0.1.2034',
+  },
 };
 
 const ENV_TRUTHY = new Set(['1', 'true', 'on', 'yes']);

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/engine/shared.js

@@ -2032,6 +2032,15 @@ const ENGINE_DEFAULTS = {
   // Settings UI exposes this as a free-text input; clearing the field deletes
   // the override and falls back to auto-resolution.
   operatorLogin: null,
+  // ── /api/status workItems retention (W-mphejzmj000718bf) ────────────────────
+  // Trim done/failed/cancelled work items older than this many days from the
+  // /api/status workItems slice to cut the SPA payload (live: 796 items / 3MB
+  // → ~50–100 items / <500KB typical). Active items (pending/dispatched/queued)
+  // are ALWAYS shipped regardless of age — only terminal items past the
+  // window are dropped. The detail modal fetches the full record on demand
+  // via GET /api/work-items/<id> when description/references/AC are needed.
+  // 0 disables the trim (full list shipped, restoring legacy behavior).
+  statusWorkItemsRetentionDays: 7,
 };
 
 // ─── Runtime Fleet Resolution (P-3b8e5f1d) ──────────────────────────────────

package/package.json

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