@yemi33/minions 0.1.2379 → 0.1.2381

package/engine/queries.js

@@ -12,13 +12,13 @@ const shared = require('./shared');
 const steering = require('./steering');
 
 const { safeRead, safeReadDir, safeJson, safeJsonObj, safeWrite, getProjects, mutateJsonFileLocked,
-  projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
+  parseSkillFrontmatter, KB_CATEGORIES,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS } = shared;
 
 // ─── Defensive PR enrichment cache (W-mq5uzmc6001d708f) ──────────────────────
 //
 // buildPrdProgress runs on every /api/status poll. When a work item carries
-// `_pr` but no canonical row exists in pull-requests.json, the synthesis
+// `_pr` but no canonical tracked row exists, the synthesis
 // fallback below used to default to PR_STATUS.ACTIVE forever (blue ○). Now
 // we cache the resolved status per canonical id and kick off a best-effort
 // fire-and-forget enrollment so the next poll cycle sees the real status.
@@ -74,14 +74,14 @@ function _resetPrEnrichmentCacheForTest() {
 
 // W-mrcs8yqk001o6893 — shared enrichment-fallback resolver. Both the prLinks
 // loop and the wi._pr fallback loop in getPrdInfo() need the SAME defensive
-// behavior when the canonical PR id has no live record in pull-requests.json
+// behavior when the canonical PR id has no live tracked record
 // (e.g. it was merged and then swept by the merged-PR cleanup routine): check
 // the enrichment cache first, else synthesize PR_STATUS.ACTIVE as a
 // placeholder and kick off a fire-and-forget enrollment so the next poll
 // (within PR_ENRICHMENT_TTL_MS) resolves the real status. Previously only the
 // wi._pr loop did this (W-mq5uzmc6001d708f); the prLinks loop hardcoded
 // `pr?.status || PR_STATUS.ACTIVE` with no self-heal, so PRs reached only via
-// pr_links stayed 'active' forever once removed from pull-requests.json.
+// pr_links stayed 'active' forever once removed from tracked PR state.
 function _resolvePrStatusWithEnrichment(pr, canonicalPrId, project, itemId) {
   if (pr?.status) return pr.status;
   if (!canonicalPrId) return PR_STATUS.ACTIVE;
@@ -162,8 +162,6 @@ const ARCHIVE_DIR = path.join(MINIONS_DIR, 'notes', 'archive');
 
 const CONFIG_PATH = path.join(MINIONS_DIR, 'config.json');
 const CONTROL_PATH = path.join(ENGINE_DIR, 'control.json');
-const DISPATCH_PATH = path.join(ENGINE_DIR, 'dispatch.json');
-const LOG_PATH = path.join(ENGINE_DIR, 'log.json');
 const NOTES_PATH = path.join(MINIONS_DIR, 'notes.md');
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -245,7 +243,7 @@ function getDispatch() {
   // status derivation, work-item PR enrichment, etc.) but only changes on
   // mutateDispatch. SQL reads are sub-millisecond, so the cache is now
   // mostly a per-request memo rather than the disk-read amortizer it used
-  // to be when dispatch.json could be 1+ MB.
+  // to be with legacy megabyte-scale dispatch files.
   const now = Date.now();
   if (_dispatchCache && (now - _dispatchCacheAt) < 2000) return _dispatchCache;
   // SQL is the canonical (and only) dispatch store after Phase 9.
@@ -438,7 +436,7 @@ function getMetrics() {
     };
   }
 
-  // Enrich agent PR counts from pull-requests.json (source of truth)
+  // Enrich agent PR counts from tracked PR state.
   const allPrs = getPullRequests();
   const prCountByAgent = {};
   const prApprovedByAgent = {};
@@ -449,7 +447,7 @@ function getMetrics() {
     prCountByAgent[agent] = (prCountByAgent[agent] || 0) + 1;
     if (pr.reviewStatus === shared.REVIEW_STATUS.APPROVED || pr.status === shared.PR_STATUS.MERGED) prApprovedByAgent[agent] = (prApprovedByAgent[agent] || 0) + 1;
     // BUG-H13 / P-h13-rejected: this used to compare to the literal 'rejected',
-    // which never appears in pull-requests.json — the canonical enum value is
+    // which never appears in tracked PR state — the canonical enum value is
     // REVIEW_STATUS.CHANGES_REQUESTED ('changes-requested'). The miscompare
     // permanently zeroed prRejectedByAgent, and the snapshot then clobbered
     // shared.trackReviewMetric()'s cumulative counter at the apply step below.
@@ -536,6 +534,37 @@ function _wiIdFromNoteFrontmatter(fm) {
   return fm.work_item || fm.wi || fm.sourceItem || null;
 }
 
+const WORK_ITEM_KEY_SEPARATOR = '\u0000';
+
+function _workItemIdentityKey(item, fallbackScope = null) {
+  if (!item?.id) return null;
+  const scope = item._source || fallbackScope || item.project || 'central';
+  return `${scope}${WORK_ITEM_KEY_SEPARATOR}${item.id}`;
+}
+
+function _dispatchWorkItemIdentityKey(entry) {
+  const item = entry?.meta?.item;
+  if (!item?.id) return null;
+  const fallbackScope = entry.meta.source === 'central-work-item'
+    || entry.meta.source === 'central-work-item-fanout'
+    ? 'central'
+    : (entry.meta.project?.name || item.project || 'central');
+  return _workItemIdentityKey(item, fallbackScope);
+}
+
+function _noteIdentityKey(fm, dispatchIdentityById) {
+  const wiId = _wiIdFromNoteFrontmatter(fm);
+  if (!wiId) return null;
+  const explicitScope = fm.work_item_scope || fm.scope;
+  if (explicitScope) return `${explicitScope}${WORK_ITEM_KEY_SEPARATOR}${wiId}`;
+  if (fm.dispatchId && dispatchIdentityById.has(fm.dispatchId)) {
+    return dispatchIdentityById.get(fm.dispatchId);
+  }
+  const inferredScope = fm.project || fm.sourceProject;
+  if (inferredScope) return `${inferredScope}${WORK_ITEM_KEY_SEPARATOR}${wiId}`;
+  return wiId;
+}
+
 // Archive notes-by-WI cache. The archive dir accumulates thousands of
 // immutable note files (2000+ and growing); reading + frontmatter-parsing all
 // of them was the single dominant SYNCHRONOUS cost inside getWorkItems()
@@ -558,7 +587,7 @@ let _archiveNotesByWiCacheMtime = null;
 // full multi-thousand-file re-read on a fixed cadence when nothing changed.
 const ARCHIVE_NOTES_BY_WI_TTL = 300000; // 5 min
 
-function _buildArchiveNotesByWiMap() {
+function _buildArchiveNoteRefs() {
   let dirMtime = null;
   try { dirMtime = fs.statSync(ARCHIVE_DIR).mtimeMs; } catch { dirMtime = null; }
   const now = Date.now();
@@ -567,14 +596,13 @@ function _buildArchiveNotesByWiMap() {
     && _archiveNotesByWiCacheMtime === dirMtime) {
     return _archiveNotesByWiCache;
   }
-  const out = Object.create(null);
+  const out = [];
   for (const f of safeReadDir(ARCHIVE_DIR)) {
     if (!f.endsWith('.md')) continue;
     const fm = _parseNoteFrontmatter(safeRead(path.join(ARCHIVE_DIR, f)));
     const wiId = _wiIdFromNoteFrontmatter(fm);
     if (!wiId) continue;
-    if (!out[wiId]) out[wiId] = [];
-    out[wiId].push('archive:' + f);
+    out.push({ fm, token: 'archive:' + f });
   }
   _archiveNotesByWiCache = out;
   _archiveNotesByWiCacheAt = now;
@@ -586,26 +614,30 @@ function _buildArchiveNotesByWiMap() {
 // Archive entries are prefixed with `archive:` so the dashboard renderer can
 // tell them apart (matches the convention already used by _artifacts.notes).
 // Pure-function helper exposed for testing.
-function _buildNotesByWiMap() {
+function _buildNotesByWiMap(dispatch) {
   const out = Object.create(null);
-  const addNote = (wiId, token) => {
-    if (!wiId || !token) return;
-    if (!out[wiId]) out[wiId] = [];
-    if (!out[wiId].includes(token)) out[wiId].push(token);
+  const dispatchIdentityById = new Map();
+  for (const section of ['pending', 'active', 'completed', 'review']) {
+    for (const entry of (dispatch?.[section] || [])) {
+      const key = _dispatchWorkItemIdentityKey(entry);
+      if (entry?.id && key) dispatchIdentityById.set(entry.id, key);
+    }
+  }
+  const addNote = (fm, token) => {
+    const key = _noteIdentityKey(fm, dispatchIdentityById);
+    if (!key || !token) return;
+    if (!out[key]) out[key] = [];
+    if (!out[key].includes(token)) out[key].push(token);
   };
   // Inbox: tiny and churns constantly — scan fresh every call.
   for (const f of safeReadDir(INBOX_DIR)) {
     if (!f.endsWith('.md')) continue;
     const fm = _parseNoteFrontmatter(safeRead(path.join(INBOX_DIR, f)));
-    const wiId = _wiIdFromNoteFrontmatter(fm);
-    if (wiId) addNote(wiId, f);
+    addNote(fm, f);
   }
   // Archive: large + immutable — served from the mtime-gated cache so we don't
   // re-read thousands of files on every getWorkItems() rebuild.
-  const archiveMap = _buildArchiveNotesByWiMap();
-  for (const wiId in archiveMap) {
-    for (const token of archiveMap[wiId]) addNote(wiId, token);
-  }
+  for (const ref of _buildArchiveNoteRefs()) addNote(ref.fm, ref.token);
   return out;
 }
 
@@ -613,10 +645,16 @@ function _buildNotesByWiMap() {
 // `archive:<filename>`) whose frontmatter cites this WI id. Returns [] when
 // nothing matches. Scans inbox + archive each call; for the bulk WI list
 // payload getWorkItems() pre-builds the map once per cache cycle.
-function notesForWorkItem(wiId) {
+function notesForWorkItem(wiId, scope) {
   if (!wiId) return [];
   const map = _buildNotesByWiMap();
-  return map[wiId] || [];
+  if (scope) return map[`${scope}${WORK_ITEM_KEY_SEPARATOR}${wiId}`] || map[wiId] || [];
+  const matches = [...(map[wiId] || [])];
+  const suffix = `${WORK_ITEM_KEY_SEPARATOR}${wiId}`;
+  for (const key of Object.keys(map)) {
+    if (key.endsWith(suffix)) matches.push(...map[key]);
+  }
+  return [...new Set(matches)];
 }
 
 function getInbox() {
@@ -636,7 +674,7 @@ function getInbox() {
 
 // ── Agents ──────────────────────────────────────────────────────────────────
 
-// Agent status is DERIVED from dispatch.json — single source of truth.
+// Agent status is derived from dispatch state.
 // dispatch.active entry for this agent → working
 // dispatch.completed (most recent) → done/error
 // neither → idle
@@ -684,7 +722,7 @@ function getAgentStatus(agentId) {
   }
 
   // Fallback: derive active state from work-item markers.
-  // This protects UI status when dispatch.json briefly desyncs from work-item files.
+  // This protects UI status when dispatch and work-item state briefly desync.
   // Guard: only trust dispatched state within 2x stale-orphan timeout to prevent stale
   // dispatched items from permanently showing an agent as working after a dead process.
   try {
@@ -720,7 +758,7 @@ function getAgentStatus(agentId) {
   return { status: 'idle', task: null, started_at: null, completed_at: null };
 }
 
-// setAgentStatus removed — agent status is derived from dispatch.json.
+// setAgentStatus removed — agent status is derived from dispatch state.
 // Status.json files no longer exist.
 
 function getAgents(config) {
@@ -755,7 +793,7 @@ function getAgents(config) {
     const inboxFiles = allInboxFiles.filter(f => f.includes(a.id));
     let steeringInboxFiles = [];
     try { steeringInboxFiles = steering.listUnreadSteeringMessages(a.id); } catch { steeringInboxFiles = []; }
-    const s = getAgentStatus(a.id); // derives from dispatch.json
+    const s = getAgentStatus(a.id); // derives from dispatch state
 
     let lastAction = 'Waiting for assignment';
     let lastActionPrefix = null;
@@ -812,7 +850,7 @@ function getAgentDetail(id) {
   let outputLog = safeRead(path.join(agentDir, 'output.log')) || '';
   if (outputLog.length > 50000) outputLog = '…(truncated — showing last 50KB)\n\n' + outputLog.slice(-50000);
 
-  const statusData = getAgentStatus(id); // derives from dispatch.json
+  const statusData = getAgentStatus(id); // derives from dispatch state
 
   const inboxContents = safeReadDir(INBOX_DIR)
     .filter(f => f.includes(id))
@@ -846,7 +884,7 @@ function getAgentDetail(id) {
 function getPrs(project) {
   if (project) {
     const store = require('./pull-requests-store');
-    const prs = store.readPullRequestsForScope(store.scopeForFilePath(projectPrPath(project))) || [];
+    const prs = store.readPullRequestsForScope(project.name) || [];
     shared.normalizePrRecords(prs, project);
     return prs;
   }
@@ -1796,22 +1834,14 @@ function getKnowledgeBaseIndex() {
 // (W-mpodww9h000b460a). The dashboard's `_buildStatusFastState` calls it
 // directly for the `workItems` slice, AND every idle agent's
 // `getAgentStatus()` fallback re-reads it to derive a work-item-marker
-// "working" state when dispatch.json briefly desyncs from per-project
-// work-items.json. With 5 agents (3 idle) and a 890 KB central
-// work-items.json, the pre-cache cost was ~300 ms per fast-state rebuild —
+// "working" state when dispatch state briefly desyncs from work-item state.
+// With 5 agents (3 idle), the pre-cache cost was ~300 ms per rebuild —
 // the single biggest hot-path offender. Mirrors `_prsCache` / `_dispatchCache`
 // (1 s TTL eliminates intra-request duplication without masking real
 // updates from the next 4 s SPA poll cycle).
 //
-// mtime-gated freshness (W-mpodww9h000b460a): bare TTL is not enough because
-// callers like tests and `safeWrite` write the central + per-project files
-// without going through `mutateWorkItems` (which busts the cache via
-// `invalidateWorkItemsCache`). One cheap `statSync` per file per cache hit
-// catches those writes within ~10 ms regardless of the TTL. Files that
-// don't exist record `null` so subsequent appearance still busts.
 let _workItemsCache = null;
 let _workItemsCacheAt = 0;
-let _workItemsCacheMtimes = null;
 // Lean cache for getWorkItems(config, { enrich: false }) — core fields only,
 // skipping the PR cross-reference + per-item _artifacts/_notes detail-modal
 // enrichment (the synchronous KB-scan + agent-dir reads that the detail modal
@@ -1822,41 +1852,11 @@ let _workItemsCacheMtimes = null;
 // objects each call, so the two caches never share mutable references.
 let _workItemsLeanCache = null;
 let _workItemsLeanCacheAt = 0;
-let _workItemsLeanCacheMtimes = null;
 function invalidateWorkItemsCache() {
   _workItemsCache = null;
   _workItemsCacheAt = 0;
-  _workItemsCacheMtimes = null;
   _workItemsLeanCache = null;
   _workItemsLeanCacheAt = 0;
-  _workItemsLeanCacheMtimes = null;
-}
-
-function _workItemsFilePaths(config) {
-  const projects = getProjects(config);
-  const out = [path.join(MINIONS_DIR, 'work-items.json')];
-  for (const p of projects) {
-    try { out.push(projectWorkItemsPath(p)); } catch { /* missing path helper output */ }
-  }
-  return out;
-}
-function _snapshotWorkItemsMtimes(config) {
-  const out = Object.create(null);
-  for (const fp of _workItemsFilePaths(config)) {
-    try { out[fp] = fs.statSync(fp).mtimeMs; }
-    catch { out[fp] = null; /* ENOENT → null; flipping to present must bust */ }
-  }
-  return out;
-}
-function _workItemsMtimesDiffer(prev, curr) {
-  if (!prev || !curr) return true;
-  for (const fp of Object.keys(curr)) {
-    if (prev[fp] !== curr[fp]) return true;
-  }
-  for (const fp of Object.keys(prev)) {
-    if (!(fp in curr)) return true;
-  }
-  return false;
 }
 
 // getWorkItems(config, { enrich })
@@ -1874,13 +1874,9 @@ function getWorkItems(config, opts) {
   const now = Date.now();
   config = config || getConfig();
   if (enrich) {
-    if (_workItemsCache && (now - _workItemsCacheAt) < 1000) {
-      const currMtimes = _snapshotWorkItemsMtimes(config);
-      if (!_workItemsMtimesDiffer(_workItemsCacheMtimes, currMtimes)) return _workItemsCache;
-    }
+    if (_workItemsCache && (now - _workItemsCacheAt) < 1000) return _workItemsCache;
   } else if (_workItemsLeanCache && (now - _workItemsLeanCacheAt) < 1000) {
-    const currMtimes = _snapshotWorkItemsMtimes(config);
-    if (!_workItemsMtimesDiffer(_workItemsLeanCacheMtimes, currMtimes)) return _workItemsLeanCache;
+    return _workItemsLeanCache;
   }
   let allItems = [];
 
@@ -1890,10 +1886,10 @@ function getWorkItems(config, opts) {
 
   // Cross-reference with dispatch (fill in agent from active dispatch if missing on work item)
   const dispatch = getDispatch();
-  const activeByWiId = new Map((dispatch.active || []).map(d => [d.meta?.item?.id, d.agent]));
+  const activeByWiId = new Map((dispatch.active || []).map(d => [_dispatchWorkItemIdentityKey(d), d.agent]));
   for (const item of allItems) {
     if (item.status === WI_STATUS.DISPATCHED && !item.dispatched_to && !item.agent) {
-      const activeAgent = activeByWiId.get(item.id);
+      const activeAgent = activeByWiId.get(_workItemIdentityKey(item));
       if (activeAgent) item.dispatched_to = activeAgent;
     }
   }
@@ -1902,7 +1898,7 @@ function getWorkItems(config, opts) {
   const pendingByWiId = new Map();
   for (const d of (dispatch.pending || [])) {
     if (d.meta?.item?.id && d.skipReason) {
-      pendingByWiId.set(d.meta.item.id, d);
+      pendingByWiId.set(_dispatchWorkItemIdentityKey(d), d);
     }
   }
   if (pendingByWiId.size > 0) {
@@ -1912,7 +1908,7 @@ function getWorkItems(config, opts) {
       if (d.meta?.branch) branchToAgent.set(d.meta.branch, d.agentName || d.agent || '');
     }
     for (const item of allItems) {
-      const pendingEntry = pendingByWiId.get(item.id);
+      const pendingEntry = pendingByWiId.get(_workItemIdentityKey(item));
       if (!pendingEntry) continue;
       item._skipReason = pendingEntry.skipReason;
       if (pendingEntry.skipReason === 'branch_locked' && pendingEntry.meta?.branch) {
@@ -1953,7 +1949,7 @@ function getWorkItems(config, opts) {
       // project so cross-repo branch collisions don't false-link.
       // (W-mpn0b76200044eed)
       const itemProject = item.project || item._source;
-      const linkedPr = allPrs.find(p => (p.prdItems || []).includes(item.id))
+      const linkedPr = allPrs.find(p => p._project === itemProject && (p.prdItems || []).includes(item.id))
         || (item.branch && allPrs.find(p => p.branch === item.branch && p._project === itemProject));
       if (linkedPr) {
         item._pr = linkedPr.id;
@@ -1966,12 +1962,12 @@ function getWorkItems(config, opts) {
   // Build dispatch ID → work item ID lookup from completed dispatches
   const dispatchByWiId = {};
   for (const d of (dispatch.completed || [])) {
-    const wiId = d.meta?.item?.id;
-    if (wiId) dispatchByWiId[wiId] = d.id; // last completed dispatch wins
+    const key = _dispatchWorkItemIdentityKey(d);
+    if (key) dispatchByWiId[key] = d.id; // last completed dispatch wins
   }
   for (const d of (dispatch.active || [])) {
-    const wiId = d.meta?.item?.id;
-    if (wiId) dispatchByWiId[wiId] = d.id;
+    const key = _dispatchWorkItemIdentityKey(d);
+    if (key) dispatchByWiId[key] = d.id;
   }
   const _agentDirCache = {};
   const _inboxFiles = safeReadDir(INBOX_DIR);
@@ -1993,13 +1989,17 @@ function getWorkItems(config, opts) {
   const _archiveByAgent = {}; // agentId → archive filenames that include agentId
   // P-34fa5d79 — pre-build the wiId → notes map so each item's _notes lookup
   // is O(1) instead of re-scanning inbox+archive per item.
-  const _notesByWi = _buildNotesByWiMap();
+  const _notesByWi = _buildNotesByWiMap(dispatch);
+  const _workItemIdCounts = new Map();
+  for (const item of allItems) {
+    _workItemIdCounts.set(item.id, (_workItemIdCounts.get(item.id) || 0) + 1);
+  }
   for (const item of allItems) {
     const arts = shared.isPlainObject(item._artifacts) ? { ...item._artifacts } : {};
     const agentId = item.dispatched_to || item.agent;
     if (agentId) {
       // Output log — match by dispatch ID (output-{dispatchId}.log)
-      const dispatchId = dispatchByWiId[item.id];
+      const dispatchId = dispatchByWiId[_workItemIdentityKey(item)];
       if (dispatchId) {
         if (!_agentDirCache[agentId]) {
           _agentDirCache[agentId] = safeReadDir(path.join(MINIONS_DIR, 'agents', agentId)).filter(f => f.startsWith('output-') && f.endsWith('.log'));
@@ -2009,14 +2009,19 @@ function getWorkItems(config, opts) {
       }
       // Notes: inbox → KB (via source field) → archive (fallback if KB was swept)
       const itemId = item.id || '___';
-      const matchInbox = _inboxFiles.filter(f => f.includes(agentId) && f.includes(itemId));
+      const hasUniqueId = _workItemIdCounts.get(itemId) === 1;
+      const matchInbox = hasUniqueId
+        ? _inboxFiles.filter(f => f.includes(agentId) && f.includes(itemId))
+        : [];
       // Lazily bucket KB by agentId (computed once per distinct agent), then
       // filter the small bucket by itemId — same result as filtering all of
       // _kbEntries by (agentId AND itemId), without the per-item full scan.
       if (_kbByAgent[agentId] === undefined) {
         _kbByAgent[agentId] = _kbEntries.filter(kb => kb.source && kb.source.includes(agentId));
       }
-      const matchKb = _kbByAgent[agentId].filter(kb => kb.source.includes(itemId));
+      const matchKb = hasUniqueId
+        ? _kbByAgent[agentId].filter(kb => kb.source.includes(itemId))
+        : [];
       const allNotes = [
         ...matchInbox,
         ...matchKb.map(kb => 'kb:' + kb.cat + '/' + kb.file),
@@ -2028,7 +2033,9 @@ function getWorkItems(config, opts) {
         if (_archiveByAgent[agentId] === undefined) {
           _archiveByAgent[agentId] = _archiveFiles.filter(f => f.includes(agentId));
         }
-        const matchArchive = _archiveByAgent[agentId].filter(f => f.includes(itemId));
+        const matchArchive = hasUniqueId
+          ? _archiveByAgent[agentId].filter(f => f.includes(itemId))
+          : [];
         for (const f of matchArchive) allNotes.push('archive:' + f);
       }
       if (allNotes.length > 0) arts.notes = _mergeArtifactNotes(arts.notes, allNotes);
@@ -2044,7 +2051,9 @@ function getWorkItems(config, opts) {
     // prefixed with `archive:` so the dashboard chip renderer can pick the
     // right open path. Field is left undefined (not []) when empty so the
     // /api/work-items JSON stays compact for the common no-notes case.
-    const mentions = _notesByWi[item.id];
+    const identityKey = _workItemIdentityKey(item);
+    const mentions = _notesByWi[identityKey]
+      || (_workItemIdCounts.get(item.id) === 1 ? _notesByWi[item.id] : null);
     if (mentions && mentions.length > 0) item._notes = mentions;
   }
   } // end if (enrich)
@@ -2064,7 +2073,7 @@ function getWorkItems(config, opts) {
     return (b.created || '').localeCompare(a.created || '');
   });
 
-  const cacheMtimes = _snapshotWorkItemsMtimes(config);
+
   // Use Date.now() here (not the `now` captured at function entry) so the
   // 1 s TTL is measured from when the cache was BUILT, not from when the
   // call started. On a slow or loaded machine the first cold call can take
@@ -2076,11 +2085,9 @@ function getWorkItems(config, opts) {
   if (enrich) {
     _workItemsCache = allItems;
     _workItemsCacheAt = cacheSetAt;
-    _workItemsCacheMtimes = cacheMtimes;
   } else {
     _workItemsLeanCache = allItems;
     _workItemsLeanCacheAt = cacheSetAt;
-    _workItemsLeanCacheMtimes = cacheMtimes;
   }
   return allItems;
 }
@@ -2234,31 +2241,17 @@ function getPrdInfo(config) {
   //                so they don't masquerade as a 2nd PRD item in the aggregate guard (W-mpem52qn).
   const wiById = {};
   const allWiById = {};
-  for (const project of projects) {
-    try {
-      const workItems = readJsonNoRestore(projectWorkItemsPath(project)) || [];
-      for (const wi of workItems) {
-        if (!wi?.id) { console.warn(`[queries] Skipping work item without id in ${project.name}:`, JSON.stringify(wi).slice(0, 120)); continue; }
-        if (!allWiById[wi.id]) allWiById[wi.id] = wi;
-        if (wi.sourcePlan) wiById[wi.id] = wi;
-      }
-    } catch { /* optional */ }
-  }
-  // Also check central work-items.json
-  try {
-    const centralWi = readJsonNoRestore(path.join(MINIONS_DIR, 'work-items.json')) || [];
-    for (const wi of centralWi) {
-      if (!wi?.id) { console.warn('[queries] Skipping central work item without id:', JSON.stringify(wi).slice(0, 120)); continue; }
-      if (!allWiById[wi.id]) allWiById[wi.id] = wi;
-      if (wi.sourcePlan && !wiById[wi.id]) wiById[wi.id] = wi;
+  for (const wi of require('./work-items-store').readAllWorkItems()) {
+    if (!wi?.id) {
+      console.warn(`[queries] Skipping work item without id in ${wi?._source || 'unknown'}:`, JSON.stringify(wi).slice(0, 120));
+      continue;
     }
-  } catch { /* optional */ }
+    if (!allWiById[wi.id]) allWiById[wi.id] = wi;
+    if (wi.sourcePlan && !wiById[wi.id]) wiById[wi.id] = wi;
+  }
 
-  // Phase 10 step 4.3 — index the (JSON-sourced) work items by their stable SQL
-  // FK so the per-item join can resolve PRD item → WI by prd_items.id rather
-  // than the feature-id string. The FK itself lives only in SQL (it's not in the
-  // JSON mirror), so read work_items.prd_item_id once and join it to the WI
-  // objects we already loaded, keyed by wi.id (first-wins, matching allWiById).
+  // Index work items by their stable SQL FK so the per-item join can resolve
+  // PRD item → WI by prd_items.id rather than the feature-id string.
   // Best-effort: null map → the join falls back to the legacy string match.
   let wiByPrdItemId = null;
   if (useFkJoin && prdItemIdByKey) {
@@ -2325,7 +2318,7 @@ function getPrdInfo(config) {
     for (const itemId of (itemIds || [])) {
       if (!prdToPr[itemId]) prdToPr[itemId] = [];
       // W-mrcs8yqk001o6893 — when the pr_links mapping outlives the PR record
-      // (merged-PR sweep removes it from pull-requests.json but pr_links is
+      // (merged-PR sweep removes it from tracked PR state but pr_links is
       // never pruned), resolve the item's project so we can self-heal the
       // status the same way the wi._pr fallback loop below does.
       let itemProject = null;
@@ -2419,7 +2412,7 @@ function getPrdInfo(config) {
   const missing = (byStatus['missing'] || []).length;
   const donePercent = total > 0 ? Math.round((complete / total) * 100) : 0;
 
-  // Plan timings — use wiById (already includes central work-items.json)
+  // Plan timings — wiById already includes the central scope.
   const planTimings = {};
   for (const wi of Object.values(wiById)) {
     if (!wi.sourcePlan) continue;
@@ -3075,71 +3068,8 @@ function _getProjectGitStatusCacheForTest() {
   return _projectGitStatusCache;
 }
 
-/**
- * Files whose mtime must trigger a dashboard `_fastState` rebuild
- * (W-mpftp7na000td0f4). Single source of truth for the dashboard's
- * cache-invalidation tracker — adding a new fast-state-surfaced JSON file
- * is a **one-line change here**, next to the related fast-state getters.
- *
- * Contract for additions:
- *   1. The file must be read (directly or transitively) by something in
- *      `dashboard._buildStatusFastState` (e.g. `getPullRequests`,
- *      `getDispatchQueue`, `watchesMod.getWatches`). Files surfaced only
- *      in `_buildStatusSlowState` (60 s TTL) should NOT be added — fast-
- *      state mtime invalidation has no effect on slow state, and they
- *      will silently no-op.
- *   2. The file must be mutated through a `mutate*` helper (so writes
- *      actually advance mtime via `safeWrite`'s rename). Append-only logs
- *      can also be added, but expect rebuilds on every line write.
- *   3. Per-project files must use `shared.projectPrPath` / `shared.
- *      projectWorkItemsPath` so newly-added projects are picked up
- *      automatically.
- *
- * Files intentionally NOT tracked:
- *   - `engine/log.json` — append-only log written many times per tick
- *     (PR polls, dispatch transitions, heartbeat). Its mtime advances
- *     every few seconds in steady state, which by itself was enough to
- *     bust the ETag cache on every poll and reduce the /api/status 304
- *     short-circuit to 0% hit rate (W-mpg8aapw001d7e0c). Log tail is
- *     surfaced by `getEngineLog()` and accepts the 10 s `FAST_STATE_TTL`
- *     backstop — log entries are not UX-blocking.
- *   - `engine/control.json` — heartbeat writes advance mtime every tick
- *     (~60 s) plus on any control-side mutation, dominating legitimate
- *     state changes. Engine state (running/paused/stopped) is surfaced
- *     by `getEngineState()`; the dashboard-side mutating handlers
- *     (`handleEngineRestart` etc.) call `invalidateStatusCache()`
- *     directly, and the 10 s TTL covers CLI-driven control-file edits.
- *   - `engine/state.json` — surfaced via `getEngineState()` but changes
- *     only on engine startup / reconcile. Negligible benefit.
- *   - `engine/metrics.json` — surfaced via `getMetrics()` but written by
- *     `trackEngineUsage()` / `trackAgentMetric()` / the engine tick itself
- *     (~10 s batched flush plus every per-agent metric event). Like
- *     `log.json` and `control.json`, its mtime advances at noise-floor
- *     cadence — every engine tick (~60 s) plus several per-agent writes
- *     in between, so with multiple agents active it bumps every few
- *     seconds and busts the ETag cache on /api/status before steady-state
- *     304s can engage (W-mphejzct00065d8c). The engine-page metrics tile
- *     is not the hot path and the 10 s `FAST_STATE_TTL` is plenty for
- *     metric freshness; mutating handlers that need immediate metrics
- *     visibility should call `invalidateStatusCache()` directly.
- *   - `engine/cooldowns.json`, `engine/pr-links.json`, `engine/pending-
- *     rebases.json`, `agents/<id>/managed-spawn.json` — not in the
- *     `/api/status` payload.
- *   - `pinned.md`, `schedules`, `pipeline-runs.json`, `schedule-runs.json`,
- *     PRD JSON — slow-state only (see `getStatusSlowStateMtimePaths`).
- *
- * Files tracked PER-FILE rather than via dir mtime:
- *   - `meetings/<id>.json` — round transitions edit each file in-place via
- *     `engine/meeting.js#mutateMeeting`. The parent dir's mtime does not
- *     advance on Windows NTFS for in-place edits inside an existing file,
- *     so tracking each meeting JSON individually catches round/status flips
- *     that dir mtime would miss. Bounded by active meeting count.
- *
- * Performance: `_getMtimes()` in dashboard.js does `fs.statSync` per path
- * per `getStatus()` call. Roughly N=4 engine paths + 2 per project today,
- * so a 5-project fleet runs 14 statSync calls per cache miss — bounded
- * and unmeasurable in benchmarks.
- */
+// Runtime state invalidates through SQL events; these caches only track
+// intentionally file-backed dashboard inputs.
 // Cache the slow-state path list: it only changes when projects are added/
 // removed or runtimes are registered/deregistered (essentially process-
 // lifetime stable in practice). Without it we walked runtime-registry +
@@ -3157,22 +3087,7 @@ function _mtimePathsCacheKey(config) {
   return projects.join(';');
 }
 function getStatusFastStateMtimePaths(config) {
-  // Issue #2949 — /api/status was slimmed to just engine/throttle state +
-  // skills/mcp/projects/version. dispatch.json, work-items.json,
-  // pull-requests.json, watches.json, notes.md, INBOX_DIR, qa-runs.json,
-  // and the meetings dir all moved to dedicated /api/<x> endpoints which
-  // have their OWN input-mtime ETags. Continuing to track those files in
-  // the fast-state registry would bust the /api/status outer cache on
-  // every engine write to them — pure wasted rebuild for slices that no
-  // longer appear in the payload.
-  //
-  // Fast-state inputs are now exclusively in-memory (engine heartbeat,
-  // ADO/GH throttle counters) so no file-mtime tracking is required.
-  // Returning [] makes the fast tracker a no-op; the slow tracker still
-  // catches the few file-derived slices that remain (skills, mcp,
-  // projects/git, autoMode/config). The cache version is bumped by
-  // `emitStateEvent` (db-events) when the slow registry detects a
-  // change OR when explicit invalidateStatusCache() callers fire.
+  // Fast state is in memory or SQL, so file-mtime tracking is unnecessary.
   config = config || getConfig();
   const cacheKey = _mtimePathsCacheKey(config);
   if (_fastMtimePathsCache && _fastMtimePathsCacheKey === cacheKey) return _fastMtimePathsCache;
@@ -3185,22 +3100,8 @@ function getStatusFastStateMtimePaths(config) {
 /**
  * Slow-state mtime tracker — symmetric with the fast-state registry above.
  *
- * Slow-state slices (`prdProgress`, `prd`, `verifyGuides`, `archivedPrds`,
- * `skills`, `mcpServers`, `schedules`, `pipelines`, `pinned`, `projects`,
- * `version`, etc.) live behind a 60 s TTL in `dashboard.js`. Without mtime
- * tracking, engine-driven writes to `prd/*.json`, `engine/schedule-runs.json`,
- * `engine/pipeline-runs.json`, or `prd/guides/*.md` waited up to the full
- * 60 s before surfacing in the dashboard — which produced the visible
- * "plan status doesn't update, pipelines never advance" symptom.
- *
- * The same conventions as fast-state apply:
- *   - Entries must back something `_buildStatusSlowState()` reads; otherwise
- *     the rebuild silently no-ops on detected change.
- *   - Files mutated through a `mutate*` helper are reliable (`safeWrite`
- *     rename advances mtime). Append-only logs reset the cache often but
- *     are not relevant here.
- *   - Per-project paths must use `shared.project*` so newly-added projects
- *     are picked up without registry edits.
+ * Slow-state mtime tracking covers only intentionally file-backed inputs such
+ * as config, skills, MCP settings, and project git metadata.
  *
  * Skill and MCP source paths (W-mphfdgwv000bf549):
  *   - Skill discovery roots (`~/.claude/skills`, `~/.copilot/skills`,
@@ -3332,7 +3233,7 @@ function getStatusSlowStateMtimePaths(config) {
 module.exports = {
   // Paths (for modules that need direct access)
   MINIONS_DIR, AGENTS_DIR, ENGINE_DIR, INBOX_DIR, PLANS_DIR, PRD_DIR, SKILLS_DIR, KNOWLEDGE_DIR, ARCHIVE_DIR,
-  CONFIG_PATH, CONTROL_PATH, DISPATCH_PATH, LOG_PATH, NOTES_PATH,
+  CONFIG_PATH, CONTROL_PATH, NOTES_PATH,
 
   // Helpers
   timeSince,