@yemi33/minions 0.1.2062 → 0.1.2064

package/dashboard/js/modal.js

@@ -4,11 +4,6 @@ function closeModal() {
   const modalEl = document.querySelector('#modal .modal');
   if (modalEl) modalEl.classList.remove('modal-wide');
   document.getElementById('modal').classList.remove('open');
-  // Clear the WI-detail auto-refresh tracker so renderWorkItems stops
-  // rewriting #modal-body each tick. Safe to do unconditionally — if the
-  // closed modal wasn't a WI detail, these vars were already null.
-  if (typeof _wiModalOpenId !== 'undefined') { _wiModalOpenId = null; }
-  if (typeof _wiModalHydratedFields !== 'undefined') { _wiModalHydratedFields = null; }
   clearModalBackStack();
   // Hide Q&A section (only shown for document modals)
   document.getElementById('modal-qa').style.display = 'none';

package/dashboard/js/render-agents.js

@@ -69,18 +69,24 @@ function renderAgents(agents) {
   `).join('');
 }
 
-// Re-render the detail-panel header (name + emoji + runtime/model chips +
-// status badge + lastAction + blocking-tool / resultSummary blocks) from a
-// slim agentData record. Extracted so renderAgents can call it every poll
-// tick to keep an open detail panel live without re-fetching the expensive
-// /api/agent/<id> charter/history/output payload. SEC-03 Phase A rules
-// still apply: emoji/name/role go through textContent.
-function _renderAgentDetailHeader(agent) {
+async function openAgentDetail(id) {
+  const agent = agentData.find(a => a.id === id);
+  if (!agent) return;
+  currentAgentId = id;
+  currentTab = (agent.status === 'working') ? 'live' : 'thought-process';
+
+  // SEC-03 Phase A: Build the detail header via DOM + textContent instead of innerHTML.
+  // Emoji, name and role are all user-controlled fields; routing them through textContent
+  // guarantees no HTML interpretation even if the escape function were ever bypassed.
   const nameEl = document.getElementById('detail-agent-name');
-  if (!nameEl) return;
   const emojiSpan = document.createElement('span');
   emojiSpan.style.fontSize = '22px';
   emojiSpan.textContent = agent.emoji || '';
+  // Runtime tag \u2014 uses the inline-SVG logo from the same RUNTIME_TAGS map the
+  // card uses, so the visual is consistent. The container's user-controlled
+  // text fields stay on the textContent path; the SVG is a hardcoded literal
+  // from RUNTIME_TAGS keyed by the runtime string (server-controlled, finite
+  // set), so injecting via innerHTML on the icon-only span is safe.
   const runtimeMeta = RUNTIME_TAGS[agent.runtime];
   const runtimeSpan = document.createElement('span');
   runtimeSpan.title = 'Runtime: ' + (runtimeMeta?.label || agent.runtime || 'unknown');
@@ -94,6 +100,9 @@ function _renderAgentDetailHeader(agent) {
     runtimeSpan.style.cssText += ';font-size:10px;font-weight:600;letter-spacing:0.4px;text-transform:uppercase;padding:2px 6px;border:1px solid var(--muted);border-radius:3px;color:var(--muted)';
     runtimeSpan.textContent = agent.runtime || 'unknown';
   }
+  // W-mpmwxk4y00053271 — mirror the model chip the card shows so the detail
+  // header stays in sync. textContent path keeps the model string from being
+  // interpreted as HTML.
   const modelSpan = (agent.model && typeof agent.model === 'string')
     ? (() => {
         const s = document.createElement('span');
@@ -112,27 +121,12 @@ function _renderAgentDetailHeader(agent) {
   nameEl.replaceChildren(...children);
 
   const badgeClass = agent.status;
-  const statusEl = document.getElementById('detail-status-line');
-  if (statusEl) {
-    // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; status is an internal bounded enum and all user data is wrapped in escapeHtml()/renderMd() (fields: lastAction, blocking tool, resultSummary)
-    statusEl.innerHTML =
-      '<span class="status-badge ' + badgeClass + '">' + agent.status.toUpperCase() + '</span> ' +
-      '<span style="color:var(--muted)">' + escapeHtml(agent.lastAction) + '</span>' +
-      (agent._blockingToolCall ? '<div style="margin-top:4px;padding:4px 8px;background:rgba(130,160,210,0.13);border:1px solid rgba(130,160,210,0.3);border-radius:4px;font-size:11px;color:var(--muted)">&#x23F3; Blocking tool call (' + escapeHtml(agent._blockingToolCall.tool) + ') &mdash; silent ' + Math.round(agent._blockingToolCall.silentMs/60000) + 'min, timeout in ' + Math.round(agent._blockingToolCall.remainingMs/60000) + 'min</div>' : '') +
-      (agent.resultSummary ? '<div style="margin-top:4px;font-size:11px;color:var(--text);line-height:1.4">' + renderMd(agent.resultSummary.slice(0, 300)) + '</div>' : '');
-  }
-}
-
-async function openAgentDetail(id) {
-  const agent = agentData.find(a => a.id === id);
-  if (!agent) return;
-  currentAgentId = id;
-  currentTab = (agent.status === 'working') ? 'live' : 'thought-process';
-
-  // SEC-03 Phase A: Build the detail header via DOM + textContent instead of innerHTML.
-  // Emoji, name and role are all user-controlled fields; routing them through textContent
-  // guarantees no HTML interpretation even if the escape function were ever bypassed.
-  _renderAgentDetailHeader(agent);
+  // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; status is an internal bounded enum and all user data is wrapped in escapeHtml()/renderMd() (fields: lastAction, blocking tool, resultSummary)
+  document.getElementById('detail-status-line').innerHTML =
+    '<span class="status-badge ' + badgeClass + '">' + agent.status.toUpperCase() + '</span> ' +
+    '<span style="color:var(--muted)">' + escapeHtml(agent.lastAction) + '</span>' +
+    (agent._blockingToolCall ? '<div style="margin-top:4px;padding:4px 8px;background:rgba(130,160,210,0.13);border:1px solid rgba(130,160,210,0.3);border-radius:4px;font-size:11px;color:var(--muted)">&#x23F3; Blocking tool call (' + escapeHtml(agent._blockingToolCall.tool) + ') &mdash; silent ' + Math.round(agent._blockingToolCall.silentMs/60000) + 'min, timeout in ' + Math.round(agent._blockingToolCall.remainingMs/60000) + 'min</div>' : '') +
+    (agent.resultSummary ? '<div style="margin-top:4px;font-size:11px;color:var(--text);line-height:1.4">' + renderMd(agent.resultSummary.slice(0, 300)) + '</div>' : '');
 
   // Show panel immediately with loading state — don't wait for API
   document.getElementById('detail-content').innerHTML = '<div style="padding:24px;text-align:center;color:var(--muted)">Loading...</div>';
@@ -167,12 +161,7 @@ function _tickAgentRuntimes() {
     el.textContent = 'Running: ' + (hr > 0 ? hr + 'h ' : '') + min + 'm ' + sec + 's';
   });
 }
-// Start ticker after each render if working agents exist, and refresh the
-// open agent-detail panel header so status / lastAction / blocking-tool /
-// resultSummary track the latest /api/status slice without re-fetching the
-// expensive /api/agent/<id> charter/history/output payload. The body tabs
-// (thought-process, live, output, etc.) are loaded once on open via
-// openAgentDetail's safeFetch — they stay as-is until the user reopens.
+// Start ticker after each render if working agents exist
 var _origRenderAgents = renderAgents;
 renderAgents = function(agents) {
   _origRenderAgents(agents);
@@ -181,10 +170,6 @@ renderAgents = function(agents) {
     _tickAgentRuntimes();
     _agentRuntimeTimer = setInterval(_tickAgentRuntimes, 1000);
   }
-  if (currentAgentId) {
-    var open = agents.find(function(a) { return a.id === currentAgentId; });
-    if (open) _renderAgentDetailHeader(open);
-  }
 };
 
 window.MinionsAgents = { renderAgents, openAgentDetail };

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

@@ -4,18 +4,6 @@ let allWorkItems = [];
 let wiPage = 0;
 const WI_PER_PAGE = 20;
 
-// Track open WI detail modal so renderWorkItems can re-render its body
-// every poll tick. Without this the modal stays frozen on the snapshot
-// from the moment it was opened — status flips / agent assignments /
-// PR link arrival are invisible until the user closes + reopens or
-// hard-refreshes. Mirrors the same fix that drove the section-render
-// gate sweep (8ad48509 / W-mpn7keq9000302c9). `_wiModalHydratedFields`
-// caches the heavy free-text fields (description, acceptanceCriteria,
-// references) loaded once by openWorkItemDetail's GET /api/work-items/<id>
-// hydration call so per-tick re-renders don't lose them.
-let _wiModalOpenId = null;
-let _wiModalHydratedFields = null;
-
 // Track retry state per work item so loading/success/error survives re-renders
 const _wiRetryState = {}; // { [id]: { status: 'pending'|'done'|'error', message?, until? } }
 function setWiRetryState(id, state) { _wiRetryState[id] = state; }
@@ -167,27 +155,6 @@ function renderWorkItems(items) {
     const newWrap = el.querySelector('.pr-table-wrap');
     if (newWrap) newWrap.scrollLeft = savedScroll;
   }
-  // Refresh the open WI detail modal in-place so its status badge,
-  // agent assignment, PR link, etc. reflect the latest /api/status slice.
-  // The heavy free-text fields (description, AC, references) live in
-  // `_wiModalHydratedFields` from the one-time GET /api/work-items/<id>
-  // hydration and survive across these re-renders.
-  if (_wiModalOpenId) {
-    const slim = items.find(i => i.id === _wiModalOpenId);
-    if (slim) {
-      const merged = Object.assign({}, _wiModalHydratedFields || {}, slim);
-      const body = document.getElementById('modal-body');
-      if (body) {
-        // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escapeHtml() or renderMd() by _wiRenderDetail()
-        body.innerHTML = _wiRenderDetail(merged);
-      }
-      const title = document.getElementById('modal-title');
-      if (title) title.textContent = slim.title || slim.id;
-    }
-    // If the WI dropped out of the slim slice (deleted/archived), leave
-    // the modal as-is — the user will close it normally; we don't want
-    // to auto-dismiss in case they're still reading.
-  }
 }
 
 async function editWorkItem(id, source) {
@@ -682,15 +649,6 @@ function openWorkItemDetail(id) {
     (cached.referencesCount > 0 && !Array.isArray(cached.references));
 
   const initial = needsHydration ? Object.assign({}, cached, { _descriptionLoading: true }) : cached;
-  // Track which WI's modal is open so renderWorkItems can re-render the
-  // modal body each poll tick. Reset the hydrated cache; openWorkItemDetail
-  // is the only authoritative source of the heavy free-text fields.
-  _wiModalOpenId = id;
-  _wiModalHydratedFields = needsHydration ? null : {
-    description: cached.description,
-    acceptanceCriteria: Array.isArray(cached.acceptanceCriteria) ? cached.acceptanceCriteria : undefined,
-    references: Array.isArray(cached.references) ? cached.references : undefined,
-  };
   document.getElementById('modal-title').textContent = initial.title || initial.id;
   // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escapeHtml() or renderMd() by _wiRenderDetail() (fields: title, description, agent, source, reasons, references, artifacts, PR links)
   document.getElementById('modal-body').innerHTML = _wiRenderDetail(initial);
@@ -704,22 +662,18 @@ function openWorkItemDetail(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.
-      if (_wiModalOpenId !== id) return;
+      var title = document.getElementById('modal-title');
+      if (!title || title.textContent !== (initial.title || initial.id)) return;
       var full = data && data.item;
       if (!full) return;
-      // Cache the heavy free-text fields so per-tick re-renders preserve
-      // them. We keep them separate from the slim slice (which renderWorkItems
-      // refreshes on every tick).
-      _wiModalHydratedFields = {
-        description: full.description || cached.description || '',
-        acceptanceCriteria: Array.isArray(full.acceptanceCriteria) ? full.acceptanceCriteria : undefined,
-        references: Array.isArray(full.references) ? full.references : undefined,
-      };
       // 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, _wiModalHydratedFields);
+      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;
       // eslint-disable-next-line no-unsanitized/property -- reason: structural HTML is a string literal; all user data wrapped in escapeHtml() or renderMd() by _wiRenderDetail() (fields: title, description, agent, source, reasons, references, artifacts, PR links)
       document.getElementById('modal-body').innerHTML = _wiRenderDetail(merged);
     })

package/dashboard.js

@@ -1540,18 +1540,26 @@ function parsePinnedEntries(content) {
   return entries;
 }
 
-// Two-tier status cache: fast state (10s) for frequently-changing data, slow state (60s) for rarely-changing data.
-// Combined into _statusCache for API/SSE consumers — no API contract change.
-let _fastState = null;
-let _fastStateTs = 0;
-const FAST_STATE_TTL = 10000; // 10s — dispatch, agents, metrics, work items, etc.
-let _slowState = null;
-let _slowStateTs = 0;
-const SLOW_STATE_TTL = 60000; // 60s — skills, PRDs, pinned, version, projects, etc.
-// Heartbeat staleness threshold. Computed server-side at snapshot build time so
-// the client renders off a boolean instead of doing wall-clock math against a
-// possibly-cached heartbeat (which produced false-positive STALE banners after
-// control.json was dropped from the mtime tracker in W-mpg8aapw001d7e0c).
+// /api/status cache — single comprehensive layer.
+//
+// Pre-2026-05-27 the cache was split into fast (10s TTL) and slow (60s TTL)
+// tiers with separate mtime registries. Each layer was added for a real
+// reason (perf, staleness, race) but the result was 6 caches disagreeing
+// about freshness — every "I had to hard refresh" bug we shipped fixes for
+// (agents, workItems, prdProgress, …) came from a layer not knowing about
+// a change that another layer had already noticed.
+//
+// New model: ONE cache, ONE comprehensive mtime registry (union of the
+// former fast+slow registries via queries.getStatus{Fast,Slow}StateMtimePaths).
+// Steady state = single mtime check. Any file change → cache invalidated →
+// full rebuild on the next call → fresh response on the next /api/status
+// poll, always. No TTL fallback — the mtime registry is the source of
+// truth; missing a file there is a bug to fix, not a cost to amortize.
+//
+// _buildStatusFastState + _buildStatusSlowState stay as organizational
+// helpers below so the build code stays grouped + the async path can yield
+// the event loop between them (CC SSE heartbeats keep flowing during the
+// slower slice).
 const ENGINE_HEARTBEAT_STALE_MS = 120000;
 let _statusCache = null;
 let _statusCacheJson = null; // cached JSON.stringify(_statusCache) — avoids double-serialization for SSE
@@ -1601,27 +1609,33 @@ function _ifNoneMatchHasEtag(headerValue, currentEtag) {
   return false;
 }
 
-// mtime-based cache invalidation (W-mpftp7na000td0f4).
+// mtime-based cache invalidation.
 //
 // Engine and dashboard are independent processes; `invalidateStatusCache()`
-// lives in dashboard.js memory and is unreachable from engine code. The
-// fast-state TTL is 10 s, but we want sub-second visibility for engine-side
-// state flips (work-item pending→done, PR status changes, dispatch.json
-// mutations). The fix: every `getStatus()` call statSyncs a small set of
-// tracked files; if any mtime advanced since the last rebuild, fast-state
-// is rebuilt and `_statusCacheVersion` bumps (which busts the ETag, so the
-// next /api/status poll sees a 200 + fresh body instead of a 304).
+// lives in dashboard.js memory and is unreachable from engine code. We
+// detect engine-side state flips (WI pending→done, PR status changes,
+// dispatch.json mutations, PRD progress derived from work-items, …) by
+// statSync'ing a registry of input files on every status request. Any
+// mtime advance → cache busted → fresh rebuild on the same poll.
 //
-// The tracked list lives in `engine/queries.js → getStatusFastStateMtimePaths()`
-// as a single source of truth — colocated with the read-side aggregation
-// layer that owns the rest of the fast-state assembly. Add a new tracked
-// file there (one line), NOT here. The dashboard side stays a thin
-// delegate so any module that contributes to `_buildStatusFastState()` can
-// register its mtime inputs in one place.
-const _mtimeTrackedFiles = () => queries.getStatusFastStateMtimePaths(CONFIG);
-const _slowMtimeTrackedFiles = () => queries.getStatusSlowStateMtimePaths(CONFIG);
-let _lastMtimes = {}; // { filePath: mtimeMs } — fast-state baseline
-let _lastSlowMtimes = {}; // { filePath: mtimeMs } — slow-state baseline
+// The two source-of-truth lists live in `engine/queries.js`:
+//   - getStatusFastStateMtimePaths — engine-driven hot writes (dispatch,
+//     work-items, PR files, watches, qa runs, inbox, notes, meetings, …).
+//   - getStatusSlowStateMtimePaths — slower-cadence writes (PRD JSON,
+//     schedule/pipeline runs, pinned, skill discovery roots, MCP configs,
+//     git refs, …).
+// We union them here. Adding a new tracked file means adding ONE line to
+// the appropriate list in queries.js — the dashboard side stays a thin
+// delegate that doesn't need to know about per-source semantics anymore.
+function _mtimeTrackedFiles() {
+  const fast = queries.getStatusFastStateMtimePaths(CONFIG);
+  const slow = queries.getStatusSlowStateMtimePaths(CONFIG);
+  // Dedup with a Set — many paths (per-project work-items, git refs) appear
+  // in both registries since both fast (workItems slice) and slow (PRD
+  // progress derived from same data) read them.
+  return Array.from(new Set([...fast, ...slow]));
+}
+let _lastMtimes = {}; // { filePath: mtimeMs } — baseline since last build
 
 // Stat a tracked path with transient-error tolerance. ENOENT (file/dir doesn't
 // exist) is normal — fresh installs, deleted projects, empty PRD dirs all hit
@@ -1648,23 +1662,12 @@ function _getMtimes() {
   return result;
 }
 
-function _getSlowMtimes() {
-  const result = {};
-  for (const fp of _slowMtimeTrackedFiles()) {
-    result[fp] = _statMtimeMs(fp, _lastSlowMtimes);
-  }
-  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() {
+// Reset the per-source caches whose TTL would otherwise serve stale data
+// across rebuilds. Skill files (`queries._skillsCache` 30s) and MCP servers
+// (`_mcpServersCache` 5min) are the two with TTLs longer than our poll
+// cadence, and both back slices the user sees on screen. Called on every
+// mtime-detected rebuild so the rebuild always reads fresh disk state.
+function _invalidateInnerCachesForRebuild() {
   try { queries.invalidateSkillsCache(); } catch { /* optional */ }
   _mcpServersCache = null;
   _mcpServersCacheTs = 0;
@@ -1681,18 +1684,15 @@ function _mtimesChanged(prev, curr) {
   return false;
 }
 
-function invalidateStatusCache(opts) {
-  _fastState = null;
-  _fastStateTs = 0;
-  // Slow state continues on its own TTL by default — mutations of slow-state data
-  // (pinned.md, schedules, etc.) must opt in via { includeSlow: true } for immediate visibility.
-  if (opts && opts.includeSlow) {
-    _slowState = null;
-    _slowStateTs = 0;
-  }
+// Flush the single status cache. `opts` is accepted (and ignored) for
+// backward-compat — callers used to pass `{ includeSlow: true }` when they
+// wanted to bust the slow tier; with a unified cache the option is moot.
+// Renamed to `_opts` so eslint stops warning about the unused param.
+function invalidateStatusCache(_opts) {
   _statusCache = null;
   _statusCacheJson = null;
   _statusCacheGzip = null;
+  _lastMtimes = {};
   // Tell any in-flight refreshStatusAsync() that its result is stale and must
   // not be published. Bumping the generation also forces the next ETag to
   // differ from anything a client already has cached.
@@ -2098,64 +2098,26 @@ function _markStatusCacheBuilt() {
 }
 
 function getStatus() {
-  const now = Date.now();
-
-  // Fast state: 10s TTL with mtime-based validation for early exit
-  let fastStale = !_fastState || (now - _fastStateTs) >= FAST_STATE_TTL;
-  if (!fastStale) {
-    // Within TTL — check mtimes for early return (skip rebuild if no tracked files changed)
+  // Steady-state fast path: cache present + no tracked file changed → return
+  // cached snapshot. Single mtime check covers both fast + slow tracker
+  // contributions (see _mtimeTrackedFiles).
+  if (_statusCache) {
     const currMtimes = _getMtimes();
-    if (_mtimesChanged(_lastMtimes, currMtimes)) fastStale = true;
-  }
-
-  // Slow state: 60s TTL with mtime-based validation for early bust.
-  // The mtime tracker covers engine-driven slow-state writes (PRD updates,
-  // pipeline-runs.json, schedule-runs.json, verify guides, project skills)
-  // 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;
-      slowMtimeChanged = true;
-    }
-  }
-
-  // If nothing stale, return cached merged result
-  if (!fastStale && !slowStale && _statusCache) return _statusCache;
-
-  // Rebuild fast state (frequently-changing data: ~12-15 reads)
-  if (fastStale) {
-    // Reload config on fast-state miss — picks up external changes (minions init, minions add)
-    reloadConfig();
-    // Snapshot mtimes BEFORE the rebuild reads disk. If an engine write lands
-    // mid-rebuild (dispatch.json, work-items.json, pull-requests.json), the
-    // snapshot reflects pre-write state, but capturing _lastMtimes AFTER would
-    // record the post-write mtime — silently masking the change. Subsequent
-    // polls would then see no mtime delta and return 304 with stale data until
-    // FAST_STATE_TTL expires. Capturing pre-build at worst forces one extra
-    // (no-op) rebuild on the next poll; capturing post-build loses the update.
-    const preBuildMtimes = _getMtimes();
-    _fastState = _buildStatusFastState();
-    _fastStateTs = now;
-    _lastMtimes = preBuildMtimes;
-  }
-
-  // Rebuild slow state (rarely-changing data: ~8-15 reads, 60s TTL).
-  // 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;
-    _lastSlowMtimes = preBuildSlowMtimes;
-  }
-
-  // Merge both tiers — no API contract change
-  _statusCache = { ..._fastState, ..._slowState, timestamp: new Date().toISOString() };
+    if (!_mtimesChanged(_lastMtimes, currMtimes)) return _statusCache;
+  }
+  // Stale or first-call: rebuild everything. Reload config first so newly-
+  // added projects / agents land before the slice builders read them.
+  reloadConfig();
+  // Snapshot mtimes BEFORE the rebuild reads disk. If an engine write lands
+  // mid-rebuild, the post-build _getMtimes() would record the post-write
+  // mtime — silently masking the change. Pre-build snapshot at worst forces
+  // one extra (no-op) rebuild on the next poll; post-build loses the update.
+  const preBuildMtimes = _getMtimes();
+  _invalidateInnerCachesForRebuild();
+  const fast = _buildStatusFastState();
+  const slow = _buildStatusSlowState();
+  _statusCache = { ...fast, ...slow, timestamp: new Date().toISOString() };
+  _lastMtimes = preBuildMtimes;
   _markStatusCacheBuilt();
   return _statusCache;
 }
@@ -2221,74 +2183,50 @@ function refreshStatusAsync() {
     let fastBuildMs = 0;
     let slowBuildMs = 0;
     try {
-      const now = Date.now();
       const startGeneration = _statusInvalidationGeneration;
 
-      let fastStale = !_fastState || (now - _fastStateTs) >= FAST_STATE_TTL;
-      if (!fastStale) {
+      // Steady-state fast path — same single mtime check as the sync getStatus.
+      if (_statusCache) {
         const currMtimes = _getMtimes();
-        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;
-          slowMtimeChanged = true;
+        if (!_mtimesChanged(_lastMtimes, currMtimes)) {
+          if (profile) {
+            _emitStatusTiming({
+              phase: 'cache-hit',
+              total: Number(process.hrtime.bigint() - tOverall) / 1e6,
+              cacheV: _statusCacheVersion,
+            });
+          }
+          return _statusCache;
         }
       }
 
-      if (!fastStale && !slowStale && _statusCache) {
-        if (profile) {
-          _emitStatusTiming({
-            phase: 'cache-hit',
-            total: Number(process.hrtime.bigint() - tOverall) / 1e6,
-            fastStale: false, slowStale: false, cacheV: _statusCacheVersion,
-          });
-        }
-        return _statusCache;
-      }
-
-      let fast = _fastState;
-      // Pre-build mtime snapshot (see getStatus() for the rationale). The async
-      // path has an even wider race window than the sync path because of the
-      // `await _yieldEventLoop()` below — any write that lands between disk
-      // reads and the post-build `_getMtimes()` capture would be lost.
-      let preBuildMtimes = null;
-      if (fastStale) {
-        reloadConfig();
-        preBuildMtimes = _getMtimes();
-        const tFast = profile ? process.hrtime.bigint() : null;
-        fast = _buildStatusFastState();
-        if (profile) fastBuildMs = Number(process.hrtime.bigint() - tFast) / 1e6;
-      }
-
-      // Unconditional cooperative yield between phases — guarantees the event
-      // loop is available to SSE heartbeats / other I/O at least once mid-rebuild
-      // regardless of whether the test hook is installed. Combined with the
-      // optional async hook below, also lets stress tests inject artificial
-      // delay to simulate a slow filesystem without freezing the loop.
+      // Stale or first-call → rebuild. Reload config first so newly-added
+      // projects/agents land before the slice builders see them. Pre-build
+      // mtime snapshot (rationale: a write that lands mid-rebuild would be
+      // silently masked if we snapshotted post-build).
+      reloadConfig();
+      const preBuildMtimes = _getMtimes();
+      _invalidateInnerCachesForRebuild();
+      const tFast = profile ? process.hrtime.bigint() : null;
+      const fast = _buildStatusFastState();
+      if (profile) fastBuildMs = Number(process.hrtime.bigint() - tFast) / 1e6;
+
+      // Cooperative yield between the fast + slow halves — guarantees the
+      // event loop is available to SSE heartbeats / other I/O at least once
+      // mid-rebuild regardless of whether the test hook is installed.
       await _yieldEventLoop();
       if (typeof _statusRefreshHook === 'function') {
         try { await _statusRefreshHook(); } catch { /* hook errors must not break rebuild */ }
       }
 
-      let slow = _slowState;
-      let preBuildSlowMtimes = null;
-      if (slowStale) {
-        if (slowMtimeChanged) _invalidateSlowInnerCachesForMtimeChange();
-        preBuildSlowMtimes = _getSlowMtimes();
-        const tSlow = profile ? process.hrtime.bigint() : null;
-        slow = _buildStatusSlowState();
-        if (profile) slowBuildMs = Number(process.hrtime.bigint() - tSlow) / 1e6;
-      }
+      const tSlow = profile ? process.hrtime.bigint() : null;
+      const slow = _buildStatusSlowState();
+      if (profile) slowBuildMs = Number(process.hrtime.bigint() - tSlow) / 1e6;
 
       // Invalidation-race guard: if an invalidation fired during the await
       // window, this rebuild was based on potentially stale signals — drop
       // the result silently. _statusCache stays as invalidated (null) so the
-      // next sync getStatus() OR async refreshStatusAsync() rebuilds fresh
-      // against the post-invalidate generation.
+      // next sync getStatus() OR async refreshStatusAsync() rebuilds fresh.
       if (_statusInvalidationGeneration !== startGeneration) {
         if (profile) {
           _emitStatusTiming({
@@ -2301,24 +2239,15 @@ function refreshStatusAsync() {
         return _statusCache;
       }
 
-      if (fastStale) {
-        _fastState = fast;
-        _fastStateTs = now;
-        _lastMtimes = preBuildMtimes;
-      }
-      if (slowStale) {
-        _slowState = slow;
-        _slowStateTs = now;
-        _lastSlowMtimes = preBuildSlowMtimes;
-      }
-      _statusCache = { ..._fastState, ..._slowState, timestamp: new Date().toISOString() };
+      _statusCache = { ...fast, ...slow, timestamp: new Date().toISOString() };
+      _lastMtimes = preBuildMtimes;
       _markStatusCacheBuilt();
       if (profile) {
         _emitStatusTiming({
           phase: 'rebuilt',
           fastBuild: fastBuildMs, slowBuild: slowBuildMs,
           total: Number(process.hrtime.bigint() - tOverall) / 1e6,
-          fastStale, slowStale, cacheV: _statusCacheVersion,
+          cacheV: _statusCacheVersion,
         });
       }
       return _statusCache;
@@ -2340,10 +2269,6 @@ function _getStatusCacheVersion() {
   return _statusCacheVersion;
 }
 function _resetStatusCacheForTesting() {
-  _fastState = null;
-  _fastStateTs = 0;
-  _slowState = null;
-  _slowStateTs = 0;
   _statusCache = null;
   _statusCacheJson = null;
   _statusCacheGzip = null;
@@ -2352,7 +2277,6 @@ function _resetStatusCacheForTesting() {
   _statusInvalidationGeneration = 0;
   _statusRefreshHook = null;
   _lastMtimes = {};
-  _lastSlowMtimes = {};
 }
 
 /** Return cached JSON string of status — single stringify, reused by SSE and /api/status */

package/package.json

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