@yemi33/minions 0.1.2101 → 0.1.2102

package/docs/pr-review-fix-loop.md

@@ -75,11 +75,11 @@ Each fix cause (build-failure, review-feedback, human-feedback, merge-conflict,
 
 A paused cause **suppresses further auto-dispatch for that cause** until cleared. Recovery paths (any one):
 
-1. **Push a new SHA to the PR branch** — the next poll refreshes `pr.headSha`, the evidence fingerprint shifts, and `clearPrNoOpFixAttempt` runs on the next non-noop completion.
+1. **Push a new SHA to the PR branch** — the next poll refreshes `pr.headSha`, the evidence fingerprint shifts, and `clearPrNoOpFixAttempt` runs on the next non-noop completion. Since #2979 (head-SHA in BUILD_FAILURE + REVIEW_FEEDBACK fingerprints) and W-mpx44p05000ze8d8 (proactive GC sweep in `pollPrStatus`), a force-push also drops the stale `_noOpFixes[cause]` record on the next poll — the dashboard `_pausedCauses` chip clears without waiting for a fresh fix dispatch.
 2. **Click the red chip on the dashboard** — confirms, then `POST /api/pull-requests/clear-paused-cause` (`dashboard.js`, issue #2969) validates the cause against `shared.PR_FIX_CAUSE`, locates the PR via `mutatePullRequests` across project/central files, and calls `clearPrNoOpFixAttempt` to wipe the cause record.
 3. **Direct API call** — `POST /api/pull-requests/clear-paused-cause` with `{ prId, cause }`.
 
-The exported `recordPrNoOpFixAttempt` / `clearPrNoOpFixAttempt` helpers in `engine/lifecycle.js` are the only sanctioned entry points; the dispatch evaluator in `engine/lifecycle.js` (search `_noOpFixes[cause]`) gates re-dispatch on `record.paused === true`.
+The exported `recordPrNoOpFixAttempt` / `clearPrNoOpFixAttempt` / `sweepStalePrNoOpFixes` helpers in `engine/lifecycle.js` are the only sanctioned entry points. The dispatch evaluator gates re-dispatch on `shared.isPrNoOpFixCausePaused(pr, cause)` (which re-validates the fingerprint per call), the dashboard chip surface uses `shared.getPrPausedCauses(pr)` (same gate), and the `pollPrStatus` callback in `engine/ado.js` + `engine/github.js` calls `sweepStalePrNoOpFixes(pr)` each tick to GC records whose fingerprint no longer matches the live PR.
 
 ## 5. Fix completes
 

package/engine/ado.js

@@ -24,6 +24,12 @@ function engine() {
 let _dispatch = null;
 function dispatchModule() { if (!_dispatch) _dispatch = require('./dispatch'); return _dispatch; }
 
+// Lazy require for lifecycle module — only needed for the stale-noopfix sweep
+// in pollPrStatus (W-mpx44p05000ze8d8). lifecycle.js lazy-requires ado.js back,
+// so this MUST stay lazy to avoid a circular import at module-load time.
+let _lifecycle = null;
+function lifecycleModule() { if (!_lifecycle) _lifecycle = require('./lifecycle'); return _lifecycle; }
+
 const stripRefsHeads = s => (s || '').replace('refs/heads/', '');
 const getAdoPrUrl = (project, prNumber) => {
   if (project.prUrlBase) return `${project.prUrlBase}${prNumber}`;
@@ -1476,6 +1482,21 @@ async function pollPrStatus(config) {
       updated = true;
     }
 
+    // W-mpx44p05000ze8d8 — Proactive GC for stale `_noOpFixes` records. Any
+    // cause whose stored evidence fingerprint no longer matches the live PR
+    // (head SHA shifted, build failure reason changed, new human comment,
+    // review status flipped, etc.) is dropped via clearPrNoOpFixAttempt. The
+    // dispatch gate already ignores these stale records (isPrNoOpFixCausePaused
+    // re-validates the fingerprint), but without this sweep they linger in
+    // pull-requests.json forever — bloating the file and confusing the
+    // dashboard `pr-paused-chip`. Runs AFTER all live-field updates so the
+    // fingerprint comparison uses post-poll PR state.
+    try {
+      if (lifecycleModule().sweepStalePrNoOpFixes(pr)) updated = true;
+    } catch (e) {
+      log('warn', `sweepStalePrNoOpFixes for ${pr.id}: ${e.message}`);
+    }
+
     return updated;
     } catch (err) {
       // Auth errors → mark build status stale so dashboard shows uncertainty

package/engine/github.js

@@ -23,6 +23,12 @@ function engine() {
 let _dispatch = null;
 function dispatchModule() { if (!_dispatch) _dispatch = require('./dispatch'); return _dispatch; }
 
+// Lazy require for lifecycle module — only needed for the stale-noopfix sweep
+// in pollPrStatus (W-mpx44p05000ze8d8). lifecycle.js lazy-requires github.js
+// back, so this MUST stay lazy to avoid a circular import at module-load time.
+let _lifecycle = null;
+function lifecycleModule() { if (!_lifecycle) _lifecycle = require('./lifecycle'); return _lifecycle; }
+
 // W-mp5trwh60008386d: test seam so unit tests can mock `gh api` shell-outs
 // without spawning the real CLI. Production code goes through the real
 // `execAsync` from shared; tests call `_setExecAsyncForTest(fn)` to swap in
@@ -1021,6 +1027,21 @@ async function pollPrStatus(config) {
       }
     }
 
+    // W-mpx44p05000ze8d8 — Proactive GC for stale `_noOpFixes` records. Any
+    // cause whose stored evidence fingerprint no longer matches the live PR
+    // (head SHA shifted, build failure reason changed, new human comment,
+    // review status flipped, etc.) is dropped via clearPrNoOpFixAttempt. The
+    // dispatch gate already ignores these stale records (isPrNoOpFixCausePaused
+    // re-validates the fingerprint), but without this sweep they linger in
+    // pull-requests.json forever — bloating the file and confusing the
+    // dashboard `pr-paused-chip`. Runs AFTER all live-field updates so the
+    // fingerprint comparison uses post-poll PR state.
+    try {
+      if (lifecycleModule().sweepStalePrNoOpFixes(pr)) updated = true;
+    } catch (e) {
+      log('warn', `sweepStalePrNoOpFixes for ${pr.id}: ${e.message}`);
+    }
+
     return updated;
   });
 

package/engine/lifecycle.js

@@ -2090,6 +2090,37 @@ function clearPrNoOpFixAttempt(target, cause) {
   }
 }
 
+// W-mpx44p05000ze8d8 — Proactive GC for stale `_noOpFixes` records. Called
+// from `engine/ado.js` + `engine/github.js` `pollPrStatus` after the live PR
+// fields (headSha, buildStatus, humanFeedback, mergeStatus, reviewStatus,
+// lastPushedAt, etc.) have been refreshed for the current tick. Any
+// `_noOpFixes[cause]` whose stored `evidenceFingerprint` no longer matches
+// the live one is dropped via `clearPrNoOpFixAttempt` — same cleanup the
+// resume endpoint and successful-fix path already use. Records without a
+// stored `evidenceFingerprint` (impossible from `recordPrNoOpFixAttempt`
+// today, but safe against future / legacy data) also drop, because the
+// dispatch gate already ignores them. Returns true when any record was
+// removed so the poll caller can flip its `updated` flag to persist the
+// purge.
+function sweepStalePrNoOpFixes(target) {
+  if (!target || !target._noOpFixes || typeof target._noOpFixes !== 'object') return false;
+  let modified = false;
+  // Snapshot cause keys before mutation — clearPrNoOpFixAttempt deletes the
+  // whole `_noOpFixes` object once the last record is removed, which would
+  // invalidate a live `Object.keys()` iterator.
+  const causes = Object.keys(target._noOpFixes);
+  for (const cause of causes) {
+    const record = target._noOpFixes[cause];
+    if (!record || typeof record !== 'object') continue;
+    const liveFp = shared.prFixEvidenceFingerprint(target, cause);
+    if (record.evidenceFingerprint !== liveFp) {
+      clearPrNoOpFixAttempt(target, cause);
+      modified = true;
+    }
+  }
+  return modified;
+}
+
 function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId = '') {
   if (!pr?.id) return;
   if (!options || typeof options !== 'object' || Array.isArray(options)) {
@@ -5137,6 +5168,10 @@ module.exports = {
   // Issue #2969 — exported so dashboard.js can clear a paused cause from the
   // resume endpoint.
   clearPrNoOpFixAttempt,
+  // W-mpx44p05000ze8d8 — exported so engine/ado.js + engine/github.js can
+  // drop stale `_noOpFixes` records during their PR status poll, and so
+  // unit tests can exercise the sweep helper directly.
+  sweepStalePrNoOpFixes,
   // Issue #2969 — exported for direct unit testing of the pause-flip alert
   // path without going through updatePrAfterFix's many guards.
   recordPrNoOpFixAttempt,

package/engine/shared.js

@@ -5261,20 +5261,18 @@ function isPrNoOpFixCausePaused(pr, cause) {
   return record.evidenceFingerprint === prFixEvidenceFingerprint(pr, cause);
 }
 
-// Issue #2969 — Derive the list of currently-paused causes for surfacing on
-// `/api/pull-requests` + the dashboard PR card. Returns deduped cause strings
-// from `_noOpFixes[c].paused === true`. Does NOT re-validate evidence
-// fingerprints (the dashboard surface shows the persisted pause flag — when
-// evidence drifts and the discovery filter ignores the stale record, the
-// next fix dispatch overwrites `_noOpFixes[cause]` and naturally re-derives
-// this field on the following enrichment pass).
+// Issue #2969 / W-mpx44p05000ze8d8 — Derive the list of currently-paused
+// causes for surfacing on `/api/pull-requests` + the dashboard PR card.
+// Mirrors `isPrNoOpFixCausePaused` exactly: a cause is "paused" only when
+// `record.paused === true` AND the stored `evidenceFingerprint` still
+// matches the live PR's fingerprint. Without the fingerprint check the chip
+// surfaced stale pauses for PRs the dispatch gate had already cleared (the
+// engine would re-dispatch but the dashboard kept showing ⏸).
 function getPrPausedCauses(pr) {
   if (!pr || !pr._noOpFixes || typeof pr._noOpFixes !== 'object') return [];
   const causes = [];
-  for (const [cause, record] of Object.entries(pr._noOpFixes)) {
-    if (record && typeof record === 'object' && record.paused === true) {
-      causes.push(cause);
-    }
+  for (const cause of Object.keys(pr._noOpFixes)) {
+    if (isPrNoOpFixCausePaused(pr, cause)) causes.push(cause);
   }
   return causes;
 }

package/package.json

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