@yemi33/minions 0.1.2100 → 0.1.2102

package/dashboard-build.js

@@ -49,4 +49,36 @@ function buildDashboardHtml() {
     .replace('/* __JS__ */', () => jsHtml);
 }
 
-module.exports = { buildDashboardHtml };
+// Slim-UX surface (feature flag 'slim-ux'). Same fragment-assembly model as
+// the main dashboard: a shell layout with /* __CSS__ */, <!-- __BODY__ -->,
+// /* __JS__ */ placeholders, filled from dashboard/slim/. The JS is one shared
+// IIFE scope, so the parts are concatenated in dependency order (matching the
+// original single-file source) inside the wrapper that layout.html provides.
+const SLIM_JS_ORDER = [
+  'helpers', 'settings', 'link-pr', 'chat', 'projects',
+  'command-send', 'status', 'members', 'modals-tiles', 'history',
+];
+
+function buildSlimHtml() {
+  const slimDir = path.join(MINIONS_DIR, 'dashboard', 'slim');
+  const layoutPath = path.join(slimDir, 'layout.html');
+  if (!fs.existsSync(layoutPath)) {
+    throw new Error(`Slim layout not found: ${layoutPath}. The dashboard/slim/ directory must exist.`);
+  }
+  const layout = safeRead(layoutPath);
+  const css = safeRead(path.join(slimDir, 'styles.css'));
+  const body = safeRead(path.join(slimDir, 'body.html'));
+  // Join with a newline so a fragment that loses its trailing newline can't
+  // glue two statements together (e.g. `}var foo`). Parts share one IIFE
+  // scope, so order is load-bearing — see SLIM_JS_ORDER.
+  const js = SLIM_JS_ORDER.map(f => safeRead(path.join(slimDir, 'js', f + '.js'))).join('\n');
+
+  return layout
+    .replace('/* __CSS__ */', () => css)
+    // Tolerate CRLF drift in layout.html (LF is enforced by .gitattributes, but
+    // an exact '\n' match would silently no-op and ship an empty body on CRLF).
+    .replace(/<!-- __BODY__ -->\r?\n/, () => body)
+    .replace('/* __JS__ */', () => js);
+}
+
+module.exports = { buildDashboardHtml, buildSlimHtml, SLIM_JS_ORDER };

package/dashboard.js

@@ -9559,23 +9559,24 @@ What would you like to discuss or change? When you're happy, say "approve" and I
   }
 
   // Slim UX surface for the experimental redesigned dashboard.
-  // The HTML lives in dashboard/slim.html so the human can iterate on the
-  // markup directly — we read the file from disk on each request (no in-
-  // memory cache) so editing it and refreshing the browser shows the change
-  // without a server restart. Gating happens in the request dispatcher: this
-  // helper is only invoked when features.isFeatureOn('slim-ux', CONFIG) is
-  // true at request time, so the flag toggle takes effect with no restart.
+  // The markup/CSS/JS live as fragments under dashboard/slim/ (layout.html +
+  // styles.css + body.html + js/*.js) and are assembled by buildSlimHtml() —
+  // freshly on each request (no in-memory cache) so editing a fragment and
+  // refreshing the browser shows the change without a server restart. Gating
+  // happens in the request dispatcher: this helper is only invoked when
+  // features.isFeatureOn('slim-ux', CONFIG) is true at request time, so the
+  // flag toggle takes effect with no restart.
   async function serveSlimUx(req, res) {
     try {
-      const slimPath = path.join(MINIONS_DIR, 'dashboard', 'slim.html');
-      const html = fs.readFileSync(slimPath, 'utf8')
+      const { buildSlimHtml } = require('./dashboard-build');
+      const html = buildSlimHtml()
         .replace(/\{\{favicon_emoji\}\}/g, FAVICON_EMOJI)
         .replace(/\{\{title_suffix\}\}/g, TITLE_SUFFIX);
       res.statusCode = 200;
       res.setHeader('Content-Type', 'text/html; charset=utf-8');
       res.setHeader('Cache-Control', 'no-store');
-      // slim.html ships an inline <script> IIFE for the chatbox + settings dialog
-      // and a data: SVG favicon. Override the baseline strict CSP from
+      // The assembled slim HTML ships an inline <script> IIFE for the chatbox +
+      // settings dialog and a data: SVG favicon. Override the baseline strict CSP from
       // buildSecurityHeaders() (which forbids inline scripts) the same way the
       // full SPA route does — strict CSP still applies to all /api/* responses.
       res.setHeader(

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.2100",
+  "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"