@yemi33/minions 0.1.2448 → 0.1.2450

package/engine/{queries.js → core/queries.js}

@@ -1,5 +1,5 @@
 /**
- * engine/queries.js — Shared read-only state queries for Minions engine + dashboard.
+ * engine/core/queries.js — Shared read-only state queries for Minions engine + dashboard.
  * Single source of truth for all data reading/aggregation.
  * Both engine.js and dashboard.js require() this module.
  */
@@ -9,7 +9,7 @@ const fsp = require('fs').promises;
 const path = require('path');
 const os = require('os');
 const shared = require('./shared');
-const steering = require('./steering');
+const steering = require('../agents/steering');
 const { normalizeExecutionModel, resolveWorkItemModel } = require('./execution-model');
 
 const { safeRead, safeReadDir, safeJson, safeJsonObj, safeWrite, getProjects, mutateJsonFileLocked,
@@ -32,7 +32,7 @@ const _prEnrichmentInFlight = new Set();
 let _lifecycleModule = null;
 function _lifecycle() {
   if (!_lifecycleModule) {
-    try { _lifecycleModule = require('./lifecycle'); }
+    try { _lifecycleModule = require('../orchestration/lifecycle'); }
     catch { _lifecycleModule = null; }
   }
   return _lifecycleModule;
@@ -248,7 +248,7 @@ function getDispatch() {
   const now = Date.now();
   if (_dispatchCache && (now - _dispatchCacheAt) < 2000) return _dispatchCache;
   // SQL is the canonical (and only) dispatch store after Phase 9.
-  const store = require('./dispatch-store');
+  const store = require('../persistence/dispatch-store');
   _dispatchCache = store.readDispatchSectioned();
   _dispatchCacheAt = now;
   return _dispatchCache;
@@ -388,7 +388,7 @@ function getDispatchQueue() {
   const d = getDispatch();
   const allCompleted = d.completed || [];
   // Lifetime total from metrics (dispatch.completed is capped at 100)
-  const metrics = require('./metrics-store').readMetrics() || {};
+  const metrics = require('../observability/metrics-store').readMetrics() || {};
   // Periodically prune cache entries for dispatches that have rotated out of the queue.
   if (_completionReportCache.size >= 200) {
     const activeIds = new Set();
@@ -420,18 +420,18 @@ function getNotesWithMeta() {
 
 function getEngineLog() {
   // SQL is the canonical (and only) log store after Phase 9.
-  const store = require('./logs-store');
+  const store = require('../observability/logs-store');
   return store.readRecentLogsChronological(50) || [];
 }
 
 function getMetrics() {
   // SQL is the canonical (and only) metrics store after Phase 9.
-  const store = require('./metrics-store');
+  const store = require('../observability/metrics-store');
   const metrics = store.readMetrics() || {};
   const config = getConfig();
   const engineConfig = config.engine || {};
   const configuredAgents = config.agents || {};
-  const { resolveRuntime } = require('./runtimes');
+  const { resolveRuntime } = require('../runtimes');
 
   for (const [agentId, m] of Object.entries(metrics)) {
     if (agentId.startsWith('_')) continue;
@@ -448,7 +448,7 @@ function getMetrics() {
   const prRejectedByAgent = {};
   for (const pr of allPrs) {
     const agent = (pr.agent || '').toLowerCase();
-    if (!agent || agent.startsWith('temp-')) continue;
+    if (!agent || agent === shared.PR_AGENT_HUMAN || agent.startsWith('temp-')) continue;
     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',
@@ -519,7 +519,7 @@ function getInboxFiles() {
 // P-34fa5d79 — Note ↔ Work Item ↔ KB Entry linkage.
 //
 // Parse the YAML frontmatter from a note body and return the parsed fields.
-// Same minimal contract as engine/kb-sweep.js#_parseFrontmatter — a single
+// Same minimal contract as engine/memory/kb-sweep.js#_parseFrontmatter — a single
 // shared regex would have been nicer but importing kb-sweep from queries
 // would form a circular dep with lifecycle (queries → kb-sweep → … →
 // queries), so we keep a local copy of the four-line parser.
@@ -737,7 +737,7 @@ function resolveRuntimeModelDisplay({ runtime, configuredModel, agentId, dispatc
  * model). An active dispatch is the live run and always beats a completed one;
  * among entries of the same kind the most recently started wins.
  *
- * Note `dispatch.completed` is capped (engine/dispatch.js), so an old work item
+ * Note `dispatch.completed` is capped (engine/orchestration/dispatch.js), so an old work item
  * can legitimately have no entry here — callers must handle that.
  */
 function buildWorkItemDispatchIndex(dispatch) {
@@ -773,7 +773,7 @@ function resolveConfiguredAgentModel(config, agentId, cache) {
   const configured = shared.resolveAgentModel(agentConfig, engine) || null;
   let model = configured;
   try {
-    const runtime = require('./runtimes').resolveRuntime(runtimeName);
+    const runtime = require('../runtimes').resolveRuntime(runtimeName);
     if (typeof runtime?.resolveModel === 'function') model = runtime.resolveModel(configured) || configured;
   } catch { /* registry unavailable — fall back to the raw configured value */ }
   const resolved = { runtimeName, model };
@@ -1017,7 +1017,7 @@ function getAgentDetail(id) {
 
 function getPrs(project) {
   if (project) {
-    const store = require('./pull-requests-store');
+    const store = require('../persistence/pull-requests-store');
     const prs = store.readPullRequestsForScope(project.name) || [];
     shared.normalizePrRecords(prs, project);
     return prs;
@@ -1137,7 +1137,7 @@ function _pickPrDedupeWinner(group, projects) {
 // W-mr3mvgfe — terminal PR statuses (done being polled/reviewed) get pushed
 // to the bottom of the PR tab's default sort. Includes `CLOSED` (a PR closed
 // without merging, distinct from `ABANDONED` but equally inactive — see
-// engine/github.js `newStatus = PR_STATUS.CLOSED` on `prData.state === 'closed'`
+// engine/providers/github.js `newStatus = PR_STATUS.CLOSED` on `prData.state === 'closed'`
 // without `merged`) alongside `MERGED`/`ABANDONED`.
 function _isTerminalPrStatus(status) {
   return status === PR_STATUS.MERGED || status === PR_STATUS.ABANDONED || status === PR_STATUS.CLOSED;
@@ -1152,7 +1152,7 @@ function getPullRequests(config) {
   const allPrs = [];
 
   // SQL is the canonical (and only) PR store after Phase 9.
-  const store = require('./pull-requests-store');
+  const store = require('../persistence/pull-requests-store');
   const sqlPrs = store.readAllPullRequests() || [];
 
   // W-mqba5ulq000nd255 — Read-side de-dupe across project scopes. When the
@@ -1361,6 +1361,92 @@ let _getSkillsResultCacheTs = 0;
 let _getSkillsResultCacheKey = null;
 const SKILLS_CACHE_TTL = 30000; // 30s — skill files change rarely (agent extraction, manual authoring)
 
+// ── Nested project-embedded skill discovery (W-ms3a68j2) ────────────────────
+// A configured project can be a massive monorepo (e.g. `src` = C:/office/src),
+// and project-embedded skills can live in deeply nested `.claude/skills` /
+// `.github/skills` / `.agents/skills` dirs far below the repo root (observed:
+// `loop/app/android/android/.claude/skills/*`). The repo-root-only project skill
+// roots exposed by the runtime adapters miss these. `collectSkillFiles` does a
+// single bounded walk per project to find every nested skill root. The defensive
+// caps mirror engine/agents/harness-context.js's "Defensive caps" pattern so the walk
+// can never balloon or wander into node_modules/.git/build output.
+const SKILL_WALK_MAX_DEPTH = 12;        // directory levels below the project root before we stop descending
+const SKILL_WALK_MAX_ENTRIES = 40000;   // directory dirents inspected across one project walk (files are free)
+
+// Test seam: allow lowering the directory-dirent budget so the entry cap can be
+// exercised without materializing 40k directories. Falls back to the real cap.
+function _skillWalkMaxEntries() {
+  const override = Number(process.env.MINIONS_SKILL_WALK_MAX_ENTRIES);
+  return Number.isFinite(override) && override > 0 ? override : SKILL_WALK_MAX_ENTRIES;
+}
+const SKILL_WALK_PRUNE_DIRS = new Set([
+  '.git', 'node_modules', 'bin', 'obj', 'build', 'dist', 'out', 'output',
+  'target', '.gradle', '.venv', 'venv', 'vendor', '.next', '.nuxt', 'coverage',
+  '.idea', '.vs', '.cache', '__pycache__', '.terraform', 'Pods', 'DerivedData',
+]);
+
+// Sort skill dirs shallowest-first so repo-root skills keep priority over deeper
+// ones during the per-project name dedup.
+function _sortSkillDirsShallowFirst(dirs) {
+  return dirs.sort((a, b) => {
+    const da = a.split(/[\\/]/).length;
+    const db = b.split(/[\\/]/).length;
+    return da - db || a.localeCompare(b);
+  });
+}
+
+// Bounded recursive walk of a project checkout that returns every nested
+// skill-root directory (absolute path) of the form `**/<marker>/skills`, where
+// `<marker>` is one of `markerNames` (e.g. `.claude`, `.github`, `.agents`).
+// Marker names are derived from the runtime adapters' own project skill roots so
+// discovery stays runtime-agnostic (no hard-coded runtime name checks). The walk
+// is bounded by depth, total dirents, and a heavy-dir prune set. Marker dirs are
+// never descended into, so we never surface skills nested inside build output.
+function _findNestedProjectSkillDirs(projectRoot, markerNames) {
+  const found = [];
+  if (!projectRoot || !markerNames || markerNames.size === 0) return found;
+  const seenDirs = new Set();
+  const maxEntries = _skillWalkMaxEntries();
+  let dirsScanned = 0;
+  // Breadth-first drain (FIFO via an index cursor) so the directory budget is
+  // spent shallowest-first — matching _sortSkillDirsShallowFirst's declared
+  // priority. A depth-first walk would let a single fat subtree exhaust the
+  // budget before sibling subtrees are ever visited, so nested discovery would
+  // silently no-op depending on directory-name ordering (e.g. a monorepo whose
+  // skills sort after a 40k-file tree). Only *directory* dirents count toward
+  // SKILL_WALK_MAX_ENTRIES — a file can never be a skill root, so files are free
+  // and don't starve the walk.
+  const queue = [{ dir: projectRoot, depth: 0 }];
+  for (let head = 0; head < queue.length; head++) {
+    const { dir, depth } = queue[head];
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const dirent of entries) {
+      let isDir = false;
+      try { isDir = dirent.isDirectory(); } catch { isDir = false; }
+      if (!isDir) continue;
+      if (dirsScanned >= maxEntries) return _sortSkillDirsShallowFirst(found);
+      dirsScanned++;
+      const name = dirent.name;
+      const childPath = path.join(dir, name);
+      if (markerNames.has(name)) {
+        // `<marker>/skills` — record if present; never descend into the marker dir.
+        const skillsDir = path.join(childPath, 'skills');
+        let st = null;
+        try { st = fs.statSync(skillsDir); } catch { st = null; }
+        if (st && st.isDirectory()) {
+          const abs = path.resolve(skillsDir);
+          if (!seenDirs.has(abs)) { seenDirs.add(abs); found.push(abs); }
+        }
+        continue;
+      }
+      if (SKILL_WALK_PRUNE_DIRS.has(name)) continue;
+      if (depth + 1 <= SKILL_WALK_MAX_DEPTH) queue.push({ dir: childPath, depth: depth + 1 });
+    }
+  }
+  return _sortSkillDirsShallowFirst(found);
+}
+
 function invalidateSkillsCache() {
   _skillsCache = null;
   _skillsCacheTs = 0;
@@ -1422,7 +1508,7 @@ function _collectHarnessesScope(scopeFilter, runtimeOpts) {
   const mcpsByPath = new Map();
   let runtimeNames = [];
   try {
-    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    const { listRuntimes, resolveRuntime } = require('../runtimes');
     runtimeNames = listRuntimes();
     for (const runtimeName of runtimeNames) {
       let runtime;
@@ -1511,7 +1597,7 @@ function collectSkillFiles(config) {
     return seenByScope.get(key);
   }
   try {
-    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    const { listRuntimes, resolveRuntime } = require('../runtimes');
     for (const runtimeName of listRuntimes()) {
       const runtime = resolveRuntime(runtimeName);
       if (typeof runtime.getSkillRoots !== 'function') continue;
@@ -1525,15 +1611,42 @@ function collectSkillFiles(config) {
 
   // Project-scope skill roots: aggregate across runtimes via the shared
   // getProjectHarnesses helper so dedup-by-absolute-path happens once
-  // (e.g. `<repo>/.agents/skills` is exposed by both Codex and Copilot).
+  // (e.g. `<repo>/.agents/skills` is exposed by both Codex and Copilot). In
+  // addition to the repo-root roots the adapters expose, walk each checkout for
+  // nested project-embedded skill dirs (`**/.claude/skills`, `**/.github/skills`,
+  // `**/.agents/skills`) so deeply-nested skills (e.g.
+  // `loop/app/android/android/.claude/skills/*` in a monorepo) are discovered too.
   for (const project of projects) {
     if (!project.localPath) continue;
-    for (const root of getProjectHarnesses(project).skills) {
-      if (root.scope !== 'project') continue;
-      _collectNativeSkillsDir(root.dir, root.scope, seenFor(root.scope, root.projectName), skillFiles, {
+    const projectSkillRoots = getProjectHarnesses(project).skills.filter(r => r.scope === 'project');
+    if (projectSkillRoots.length === 0) continue;
+    const projectName = projectSkillRoots[0].projectName;
+    const dedup = seenFor('project', projectName);
+
+    // Marker dir names (`.claude` / `.github` / `.agents`) come from the adapter
+    // roots themselves, keeping nested discovery runtime-agnostic. Track the
+    // repo-root skill dirs so the nested walk doesn't re-enumerate them.
+    const markerNames = new Set();
+    const rootLevelDirs = new Set();
+    for (const root of projectSkillRoots) {
+      rootLevelDirs.add(path.resolve(root.dir));
+      const rel = path.relative(project.localPath, root.dir);
+      const firstSeg = rel.split(/[\\/]/)[0];
+      if (firstSeg && !firstSeg.startsWith('..')) markerNames.add(firstSeg);
+    }
+
+    // 1. Repo-root skill roots exposed by the adapters (`<repo>/.claude/skills`).
+    for (const root of projectSkillRoots) {
+      _collectNativeSkillsDir(root.dir, root.scope, dedup, skillFiles, {
         projectName: root.projectName,
       });
     }
+
+    // 2. Nested project-embedded skill roots anywhere under the checkout.
+    for (const nestedDir of _findNestedProjectSkillDirs(project.localPath, markerNames)) {
+      if (rootLevelDirs.has(path.resolve(nestedDir))) continue; // already enumerated above
+      _collectNativeSkillsDir(nestedDir, 'project', dedup, skillFiles, { projectName });
+    }
   }
 
   // 1b. Installed plugin skills: ~/.claude/plugins/installed_plugins.json
@@ -1717,7 +1830,7 @@ function collectCommandFiles(config) {
   // `~/.claude/commands`; Copilot exposes `~/.copilot/commands` and Codex
   // currently returns nothing — adapters fall in/out as their CLIs evolve).
   try {
-    const { listRuntimes, resolveRuntime } = require('./runtimes');
+    const { listRuntimes, resolveRuntime } = require('../runtimes');
     for (const runtimeName of listRuntimes()) {
       const runtime = resolveRuntime(runtimeName);
       if (typeof runtime.getCommandRoots !== 'function') continue;
@@ -1993,7 +2106,83 @@ function invalidateWorkItemsCache() {
   _workItemsLeanCacheAt = 0;
 }
 
-// getWorkItems(config, { enrich })
+// attachWorkItemPrLinks(items, config) — backfill the _pr / _prUrl fields the
+// /api/work-items LIST rows render (dashboard/js/render-work-items.js `wiRow`).
+// This is the ONLY cross-reference the list rows need; the far more expensive
+// _artifacts/_notes/_model enrichment stays detail-only (GET /api/work-items/<id>).
+//
+// Root-cause perf note (W-mscir7fv000u6321): the list endpoint used to run the
+// FULL enrich over the entire work-item history on every 4 s poll, whose
+// _artifacts/_notes step is an O(items × files) synchronous KB/inbox/archive/
+// agent-dir scan that hard-froze the single dashboard event loop (~26-30 s
+// requests at ~2,281 completed items), starving /api/health and Command Center
+// SSE. Extracting the cheap PR link-up lets the endpoint paginate FIRST and then
+// attach links to just the page slice. This helper is deliberately map-based —
+// O(items + prs), never O(items × prs) — and performs NO filesystem access, so
+// it is safe to call on the full list or a single page. Mutates and returns
+// `items` (same semantics the enrich block relied on).
+function attachWorkItemPrLinks(items, config) {
+  if (!Array.isArray(items) || items.length === 0) return items || [];
+  config = config || getConfig();
+  const projects = getProjects(config);
+  const allPrs = getPullRequests(config);
+  // Prebuilt lookups so each item is O(1) instead of scanning allPrs.
+  const prById = new Map();
+  const prsByDisplayId = new Map();
+  const prByProjectPrdItem = new Map();
+  const prByProjectBranch = new Map();
+  for (const p of allPrs) {
+    if (p.id != null && !prById.has(p.id)) prById.set(p.id, p);
+    const disp = shared.getPrDisplayId(p);
+    if (disp != null) {
+      const bucket = prsByDisplayId.get(disp);
+      if (bucket) bucket.push(p); else prsByDisplayId.set(disp, [p]);
+    }
+    if (p._project) {
+      for (const wid of (p.prdItems || [])) {
+        const key = p._project + '\0' + wid;
+        if (!prByProjectPrdItem.has(key)) prByProjectPrdItem.set(key, p);
+      }
+      if (p.branch) {
+        const bkey = p._project + '\0' + p.branch;
+        if (!prByProjectBranch.has(bkey)) prByProjectBranch.set(bkey, p);
+      }
+    }
+  }
+  for (const item of items) {
+    if (item._pr && !item._prUrl) {
+      const project = shared.resolveProjectSource(item.project || item._source, projects, { allowCentral: false }).project || null;
+      const canonicalPrId = shared.getCanonicalPrId(project, item._pr);
+      const displayPrId = shared.getPrDisplayId(item._pr);
+      const exactPr = prById.get(canonicalPrId);
+      const displayMatches = exactPr ? [] : (prsByDisplayId.get(displayPrId) || []);
+      const pr = exactPr || (displayMatches.length === 1 ? displayMatches[0] : null);
+      if (pr) {
+        item._pr = pr.id;
+        item._prUrl = pr.url;
+      }
+    }
+    if (!item._pr) {
+      // Derive from PR.prdItems (single source of truth), then fall back to
+      // branch identity. The branch fallback heals decomposed-child WIs whose
+      // PR-opening agent only stamped the parent id into prdItems — branch
+      // names (`work/<wi-id>`) are unique per WI within a project, so a
+      // branch hit is as authoritative as a prdItems hit. Scoped to the same
+      // project so cross-repo branch collisions don't false-link.
+      // (W-mpn0b76200044eed)
+      const itemProject = item.project || item._source;
+      const linkedPr = prByProjectPrdItem.get(itemProject + '\0' + item.id)
+        || (item.branch ? prByProjectBranch.get(itemProject + '\0' + item.branch) : null);
+      if (linkedPr) {
+        item._pr = linkedPr.id;
+        item._prUrl = linkedPr.url;
+      }
+    }
+  }
+  return items;
+}
+
+// getWorkItems(config, { enrich, onlyId })
 //   enrich (default true): also cross-reference PRs and populate the
 //     detail-modal _artifacts/_notes fields. The /api/work-items list payload
 //     needs these (PR badges + note chips).
@@ -2003,11 +2192,26 @@ function invalidateWorkItemsCache() {
 //     never read _artifacts/_notes (getAgentStatus fallback, count-only callers)
 //     so the agent roster / CC preamble don't pay the enrichment cost on every
 //     cold rebuild.
+//   onlyId (W-mscmqk6b03ha5673, enrich-only) — narrow the per-item detail
+//     enrichment to the row(s) carrying this work-item id. The single-record
+//     GET /api/work-items/<id> handler needs ONE fully-enriched row, but paid
+//     the whole-history enrichment on every detail-modal open (at ~2.3k items
+//     that's the same multi-second synchronous block the polled list endpoint
+//     was fixed for, just triggered by a click). The full list is still
+//     returned and the cheap pre-enrich dispatch cross-reference still runs
+//     over everything, so _pendingReason/_skipReason/_blockedBy resolve
+//     identically and the caller can still resolve the complete id-matched set
+//     for its ambiguity check before reading the enriched row.
 function getWorkItems(config, opts) {
   const enrich = !(opts && opts.enrich === false);
+  const onlyId = enrich && opts && typeof opts.onlyId === 'string' && opts.onlyId !== ''
+    ? opts.onlyId
+    : null;
   const now = Date.now();
   config = config || getConfig();
   if (enrich) {
+    // An onlyId caller can be served the fully-enriched cache verbatim — it is
+    // a strict superset of what the caller asked for.
     if (_workItemsCache && (now - _workItemsCacheAt) < 1000) return _workItemsCache;
   } else if (_workItemsLeanCache && (now - _workItemsLeanCacheAt) < 1000) {
     return _workItemsLeanCache;
@@ -2015,7 +2219,7 @@ function getWorkItems(config, opts) {
   let allItems = [];
 
   // SQL is the canonical (and only) work-items store after Phase 9.
-  const store = require('./work-items-store');
+  const store = require('../planning/work-items-store');
   allItems = store.readAllWorkItems() || [];
 
   // Cross-reference with dispatch (fill in agent from active dispatch if missing on work item)
@@ -2063,42 +2267,24 @@ function getWorkItems(config, opts) {
     }
   }
 
+  // Rows that pay the per-item detail enrichment below. Without `onlyId` this
+  // is the whole list, exactly as before.
+  const enrichTargets = onlyId ? allItems.filter(it => it && it.id === onlyId) : allItems;
+  // An `onlyId` lookup that matches nothing (the caller's 404 path) skips the
+  // block wholesale, so a miss pays none of the once-per-call prep either.
+  // Callers without `onlyId` keep today's behaviour exactly, empty store
+  // included.
+  const skipEnrichment = onlyId !== null && enrichTargets.length === 0;
+
   // Detail-modal enrichment (PR cross-ref + _artifacts/_notes). Skipped for
   // enrich:false callers — see the getWorkItems header.
-  if (enrich) {
-  const projects = getProjects(config);
-  // Cross-reference with PRs
-  const allPrs = getPullRequests(config);
-  for (const item of allItems) {
-    if (item._pr && !item._prUrl) {
-      const project = shared.resolveProjectSource(item.project || item._source, projects, { allowCentral: false }).project || null;
-      const canonicalPrId = shared.getCanonicalPrId(project, item._pr);
-      const displayPrId = shared.getPrDisplayId(item._pr);
-      const exactPr = allPrs.find(p => p.id === canonicalPrId);
-      const displayMatches = exactPr ? [] : allPrs.filter(p => shared.getPrDisplayId(p) === displayPrId);
-      const pr = exactPr || (displayMatches.length === 1 ? displayMatches[0] : null);
-      if (pr) {
-        item._pr = pr.id;
-        item._prUrl = pr.url;
-      }
-    }
-    if (!item._pr) {
-      // Derive from PR.prdItems (single source of truth), then fall back to
-      // branch identity. The branch fallback heals decomposed-child WIs whose
-      // PR-opening agent only stamped the parent id into prdItems — branch
-      // names (`work/<wi-id>`) are unique per WI within a project, so a
-      // branch hit is as authoritative as a prdItems hit. Scoped to the same
-      // project so cross-repo branch collisions don't false-link.
-      // (W-mpn0b76200044eed)
-      const itemProject = item.project || item._source;
-      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;
-        item._prUrl = linkedPr.url;
-      }
-    }
-  }
+  if (enrich && !skipEnrichment) {
+  // Cross-reference with PRs (the _pr/_prUrl LIST-row fields). Extracted to a
+  // shared, map-based helper so the /api/work-items list endpoint can attach
+  // the same links to a PAGINATED slice without the expensive _artifacts/_notes
+  // filesystem scan below (W-mscir7fv000u6321). Narrowed to enrichTargets so an
+  // onlyId detail lookup only links its own row (W-mscmqk6b03ha5673).
+  attachWorkItemPrLinks(enrichTargets, config);
 
   // Populate _artifacts for the work item detail modal
   // Build dispatch ID → work item ID lookup from completed dispatches
@@ -2135,11 +2321,14 @@ function getWorkItems(config, opts) {
   // 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(dispatch);
+  // `_workItemIdCounts` stays a full-list tally even under `onlyId` — the
+  // `hasUniqueId` note-linkage guard below asks whether an id collides
+  // ANYWHERE, so narrowing it would change the enriched row's output.
   const _workItemIdCounts = new Map();
   for (const item of allItems) {
     _workItemIdCounts.set(item.id, (_workItemIdCounts.get(item.id) || 0) + 1);
   }
-  for (const item of allItems) {
+  for (const item of enrichTargets) {
     const arts = shared.isPlainObject(item._artifacts) ? { ...item._artifacts } : {};
     const agentId = item.dispatched_to || item.agent;
     // W-ms0ytfdd000d5a26 — the model this item actually ran on (or, for items
@@ -2235,10 +2424,14 @@ function getWorkItems(config, opts) {
   // >= 1 000 ms and miss the cache, defeating the cache entirely.
   // (W-mr00aooc000i1d6b — queries-work-items-cache CI failure on slow runners)
   const cacheSetAt = Date.now();
-  if (enrich) {
+  // An `onlyId` result is only PARTIALLY enriched, so it must never be
+  // published as either module cache: as the enriched cache it would serve
+  // unenriched rows to the next list caller, and as the lean cache it would
+  // carry enrichment the lean shape does not promise.
+  if (enrich && !onlyId) {
     _workItemsCache = allItems;
     _workItemsCacheAt = cacheSetAt;
-  } else {
+  } else if (!enrich) {
     _workItemsLeanCache = allItems;
     _workItemsLeanCacheAt = cacheSetAt;
   }
@@ -2258,7 +2451,7 @@ let _prdResultInputHash = '';          // SQL event version + authored-plan mtim
 function _getPrdInputHash() {
   const mtimes = [];
   try {
-    const row = require('./db').getDb().prepare('SELECT COALESCE(MAX(id), 0) AS version FROM events').get();
+    const row = require('../db').getDb().prepare('SELECT COALESCE(MAX(id), 0) AS version FROM events').get();
     mtimes.push(Number(row?.version) || 0);
   } catch { mtimes.push(0); }
   // W-mqacrzis0003df4a — Source-plan markdown mtimes. Without this, the
@@ -2294,6 +2487,10 @@ function getPrdInfo(config) {
   // filename so render-prd.js#renderE2eSection can merge them with the live
   // tracker and keep rendering a merged aggregate after its live record is swept.
   const verifyPrsByPlan = {};
+  // W-msa0mrus00mh466f — live (non-archived) PRD objects keyed by filename so
+  // the revision-state derivation below can run once, server-side, after the
+  // work-item index is built.
+  const livePlansByFile = {};
   let latestUpdatedAt = 0;
 
   // Phase 10 step 4.3 — FK-based WI↔PRD-item join scaffolding. `prdItemIdByKey`
@@ -2332,6 +2529,7 @@ function getPrdInfo(config) {
       completedAt: plan.completedAt || '',
       _archived: isArch,
     });
+    if (!isArch) livePlansByFile[pf] = plan;
     if (Array.isArray(plan.verifyPrs) && plan.verifyPrs.length > 0) {
       verifyPrsByPlan[pf] = plan.verifyPrs.map(r => ({
         id: r.id, url: r.url || '', title: r.title || '',
@@ -2365,7 +2563,7 @@ function getPrdInfo(config) {
   // feature-id string match.
   if (useFkJoin) {
     try {
-      const db = require('./db').getDb();
+      const db = require('../db').getDb();
       const map = new Map();
       for (const r of db.prepare('SELECT p.filename AS filename, p.archived AS archived, pi.feature_id AS feature_id, pi.id AS id FROM prd_items pi JOIN prds p ON p.id = pi.prd_id WHERE pi.feature_id IS NOT NULL').all()) {
         map.set(`${r.archived ? 1 : 0} ${r.filename} ${r.feature_id}`, r.id);
@@ -2375,7 +2573,7 @@ function getPrdInfo(config) {
   }
 
   // SQLite is the unconditional PRD source.
-  const prdStore = require('./prd-store');
+  const prdStore = require('../planning/prd-store');
   for (const { filename, archived, plan, updatedAt } of prdStore.listPrdRows()) {
     try {
       latestUpdatedAt = Math.max(latestUpdatedAt, updatedAt);
@@ -2394,7 +2592,7 @@ 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 wi of require('./work-items-store').readAllWorkItems()) {
+  for (const wi of require('../planning/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;
@@ -2403,13 +2601,27 @@ function getPrdInfo(config) {
     if (wi.sourcePlan && !wiById[wi.id]) wiById[wi.id] = wi;
   }
 
+  // W-msa0mrus00mh466f — canonical PRD revision state, derived ONCE here.
+  // `revision-requested` and `planStale` can both be true on the same PRD; the
+  // dashboard must not offer competing recovery paths, so the server decides
+  // which state applies and the renderer just paints it.
+  const planRevisions = {};
+  const allWorkItemList = Object.values(allWiById);
+  for (const [pf, plan] of Object.entries(livePlansByFile)) {
+    try {
+      const revisionWi = shared.findPrdRevisionWorkItem(plan, pf, allWorkItemList);
+      const revision = shared.derivePrdRevisionState(plan, revisionWi);
+      if (revision.state !== shared.PRD_REVISION_STATE.NONE) planRevisions[pf] = revision;
+    } catch { /* a malformed PRD must not break the whole PRD read */ }
+  }
+
   // 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) {
     try {
-      const db = require('./db').getDb();
+      const db = require('../db').getDb();
       const fkByWiId = new Map();
       for (const r of db.prepare('SELECT id, prd_item_id FROM work_items WHERE prd_item_id IS NOT NULL').all()) {
         if (!fkByWiId.has(r.id)) fkByWiId.set(r.id, r.prd_item_id);
@@ -2578,7 +2790,7 @@ function getPrdInfo(config) {
 
   const progress = {
     total, complete, inProgress, paused, missing, donePercent, planTimings,
-    verifyPrsByPlan,
+    verifyPrsByPlan, planRevisions,
     items: items.map(i => ({
       id: i.id, name: i.name || i.title, priority: i.priority,
       complexity: i.estimated_complexity || i.size, status: i.status || 'missing',
@@ -2733,7 +2945,9 @@ function _gitExec(localPath, args) {
       // Belt-and-suspenders: explicitly kill the stuck child so it can't
       // linger as an orphaned git.exe. SIGKILL on Unix, forced termination
       // on Windows (Node maps both to TerminateProcess via libuv).
-      try { if (child && typeof child.kill === 'function') child.kill('SIGKILL'); }
+      try {
+        if (child) shared.terminateProcess('engine.query.git-probe-timeout', child);
+      }
       catch { /* child may already be dead */ }
       reject(new Error(`git probe watchdog: \`git ${args.join(' ')}\` did not settle within ${watchdogMs}ms`));
     }, watchdogMs);
@@ -3444,7 +3658,7 @@ module.exports = {
   getKnowledgeBaseEntries, getKnowledgeBaseEntriesSnapshot, getKnowledgeBaseIndex,
 
   // Work items & PRD
-  getWorkItems, invalidateWorkItemsCache, getPrdInfo,
+  getWorkItems, attachWorkItemPrLinks, invalidateWorkItemsCache, getPrdInfo,
 
   // W-mq5uzmc6001d708f — test hooks for the defensive PR enrichment cache.
   _resetPrEnrichmentCacheForTest,

package/engine/{safe-expr.js → core/safe-expr.js}

@@ -1,5 +1,5 @@
 /**
- * engine/safe-expr.js — Hand-rolled recursive-descent expression evaluator.
+ * engine/core/safe-expr.js — Hand-rolled recursive-descent expression evaluator.
  *
  * Phase 3.1 of feat/plan-resilient-watches (P-w6f4a3e8). Used by watch action
  * guards (P-w7c5d8b3) and predicate-based watches (Phase 2.x) to evaluate