@yemi33/minions 0.1.2013 → 0.1.2014

package/dashboard/js/render-prs.js

@@ -32,8 +32,10 @@ function prRow(pr) {
   const reviewLabel = sq.status === 'waiting' ? 'reviewing (minions)' : sq.status ? sq.status + ' (minions)' : (effectiveReviewStatus || 'pending');
   const reviewTitle = '';
   const buildClass = pr._buildStatusStale ? 'build-stale' : pr.buildStatus === 'passing' ? 'build-pass' : pr.buildStatus === 'failing' ? 'build-fail' : pr.buildStatus === 'running' ? 'building' : 'no-build';
-  const buildLabel = (pr.buildStatus || 'none') + (pr._buildStatusStale ? ' (stale)' : '');
-  const buildTitle = pr._buildStatusDetail || '';
+  const buildLabel = (pr.buildStatus || 'none') + (pr._buildStatusStale ? ' (stale)' : '') + (pr.buildStaleMergeCommit ? ' (stale merge commit)' : '');
+  const buildTitle = pr.buildStaleMergeCommit
+    ? 'ADO has builds on this PR\'s merge ref, but none target the current merge commit (typically after a rebase or target-branch advance). Engine classified from the pre-rebase build set and queued a fresh build (rate limited 30m). See Issue #2747.'
+    : (pr._buildStatusDetail || '');
   const statusClass = pr.status === 'merged' ? 'merged' : pr.status === 'abandoned' ? 'rejected' : pr.status === 'active' ? 'active' : 'draft';
   const statusLabel = pr.status || 'active';
   const branchError = pr._branchResolutionError?.reason || '';

package/engine/ado.js

@@ -407,6 +407,70 @@ function classifyBuildStatus(prBuilds) {
   return 'none';
 }
 
+/**
+ * Stale merge-commit fallback classifier (Issue #2747). When ADO returns
+ * builds on a PR's merge ref but none target the current merge commit
+ * (ADO recomputed merge-commit after a target-branch advance / rebase
+ * without re-queueing), classify the stale set:
+ *   - Stale-failing → 'failing' + buildStaleMergeCommit:true. A stale
+ *     failing signal is strictly more actionable than 'none'; a fix WI
+ *     either does real work (failure still in the branch) or verifies
+ *     green via push (rebase resolved it).
+ *   - Stale-succeeded/other → preserve cached pr.buildStatus (or 'none')
+ *     and do NOT set the stale-merge flag. Succeeded-on-pre-rebase is
+ *     ambiguous and could be false confidence.
+ * Returns { buildStatus, buildStaleMergeCommit }.
+ */
+function classifyStaleBuilds(allBuilds, cachedBuildStatus) {
+  const staleStatus = classifyBuildStatus(allBuilds);
+  if (staleStatus === 'failing') {
+    return { buildStatus: 'failing', buildStaleMergeCommit: true };
+  }
+  return { buildStatus: cachedBuildStatus || 'none', buildStaleMergeCommit: false };
+}
+
+/**
+ * Filter for PR-validation builds — only these should be re-queued on
+ * stale-merge-commit detection. ADO records `triggerInfo.pullRequestId`
+ * when a build was triggered by a PR validation policy; some pipelines
+ * are conventionally named with "PR" in the title (e.g. "Office - PR"),
+ * which we also accept as a fallback signal.
+ */
+function isPrValidationBuild(build) {
+  if (!build) return false;
+  if (build.triggerInfo && build.triggerInfo.pullRequestId) return true;
+  const name = String(build?.definition?.name || '');
+  return /\bPR\b/i.test(name);
+}
+
+// Rate-limit window for stale-merge-commit fresh-build requeue: at most one
+// queue per PR per 30 min, tracked via pr._lastBuildRequeueAt timestamp.
+const PR_BUILD_REQUEUE_INTERVAL_MS = 30 * 60 * 1000;
+
+function shouldRequeueStaleBuild(pr, nowMs) {
+  if (!pr) return false;
+  const last = Number(pr._lastBuildRequeueAt) || 0;
+  const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+  return (now - last) >= PR_BUILD_REQUEUE_INTERVAL_MS;
+}
+
+/**
+ * Queue a fresh PR-validation build via the ADO Builds REST API
+ * (equivalent of `az pipelines build queue --definition-id <id>
+ * --branch refs/pull/<n>/merge` but uses the engine's existing PAT and
+ * adoFetch wrapper — no external `az` CLI dependency). Forces ADO to
+ * recompute the merge commit so the next poll has real data. Failures
+ * are non-fatal — callers should try/catch and log warn.
+ */
+async function queueFreshAdoBuild({ orgBase, project, prNumber, definitionId, token }) {
+  const url = `${orgBase}/${project.adoProject}/_apis/build/builds?api-version=7.1`;
+  const body = JSON.stringify({
+    definition: { id: definitionId },
+    sourceBranch: `refs/pull/${prNumber}/merge`,
+  });
+  return adoFetch(url, token, { method: 'POST', body });
+}
+
 /** Map ADO reviewer vote array to a review status string. */
 function votesToReviewStatus(votes) {
   if (votes.some(v => v === -10)) return 'changes-requested';
@@ -1167,6 +1231,8 @@ async function pollPrStatus(config) {
     let buildFailureSignature = pr.buildFailureSignature || '';
     let buildStatusResolved = true;
     let buildStatusStaleDetail = '';
+    let buildStaleMergeCommit = false;
+    let staleFailingDefinitions = []; // PR-validation defs to re-queue when stale-failing
 
     if (prNumber && mergeCommitId) {
       const buildRepositoryGuid = await resolveAdoBuildRepositoryGuid(project, token, orgBase, 'ADO build polling');
@@ -1194,17 +1260,43 @@ async function pollPrStatus(config) {
                 failed?.status,
               ].filter(Boolean).join('\n') || buildFailReason, 80);
             }
-          } else if (allBuilds.length > 0 && pr.buildStatus) {
-            // Stale merge-commit fallback — ADO returned builds for this PR's merge ref
-            // but none target the current `mergeCommitId`. Most likely the target branch
-            // moved, ADO recomputed the merge commit, but no new source-side changes
-            // triggered a rebuild. Preserve the previous `pr.buildStatus` so the tracker
-            // reflects the last known truth instead of flipping to a spurious 'none'.
-            // Also log a warn so stale states are detectable in engine logs. Issue #1233.
+          } else if (allBuilds.length > 0) {
+            // Stale merge-commit classification (Issue #2747). ADO returned
+            // builds for this PR's merge ref but none target the current
+            // `mergeCommitId` — most likely the target branch moved (rebase
+            // or push), ADO recomputed the merge commit, but no new
+            // source-side changes triggered a rebuild. Classify the stale
+            // set: stale-failing flips to 'failing' + buildStaleMergeCommit
+            // (strictly more actionable than 'none'); stale-succeeded/other
+            // preserves cached state (no false confidence).
+            const stale = classifyStaleBuilds(allBuilds, pr.buildStatus);
+            buildStatus = stale.buildStatus;
+            buildStaleMergeCommit = stale.buildStaleMergeCommit;
+            if (buildStaleMergeCommit) {
+              const failed = allBuilds.find(b => b.result === 'failed') || allBuilds.find(b => b.result === 'canceled');
+              buildFailReason = failed?.definition?.name || 'Build failed (stale merge commit)';
+              buildFailureSignature = shared.safeSlugComponent([
+                failed?.definition?.name,
+                failed?.result,
+                failed?.status,
+                'stale-merge-commit',
+              ].filter(Boolean).join('\n') || buildFailReason, 80);
+              // Collect PR-validation definitions with failures for fresh-build queue.
+              const seenDefIds = new Set();
+              for (const b of allBuilds) {
+                if ((b.result === 'failed' || b.result === 'canceled') && isPrValidationBuild(b)) {
+                  const defId = b?.definition?.id;
+                  if (defId != null && !seenDefIds.has(defId)) {
+                    seenDefIds.add(defId);
+                    staleFailingDefinitions.push({ id: defId, name: b?.definition?.name || `id=${defId}` });
+                  }
+                }
+              }
+            } else if (pr.buildFailReason && buildStatus === pr.buildStatus) {
+              buildFailReason = pr.buildFailReason;
+            }
             const sampleSv = (allBuilds[0]?.sourceVersion || '').slice(0, 8);
-            log('warn', `PR ${pr.id} build: merge-commit mismatch — ${allBuilds.length} build(s) on merge ref, none target current merge commit ${String(mergeCommitId).slice(0, 8)} (sample sourceVersion ${sampleSv}); preserving previous buildStatus '${pr.buildStatus}'`);
-            buildStatus = pr.buildStatus;
-            if (pr.buildFailReason) buildFailReason = pr.buildFailReason;
+            log('warn', `PR ${pr.id} build: merge-commit mismatch — ${allBuilds.length} build(s) on merge ref, none target current merge commit ${String(mergeCommitId).slice(0, 8)} (sample sourceVersion ${sampleSv}); classified '${buildStatus}' from stale set${buildStaleMergeCommit ? ' (stale failing — will queue fresh build if rate limit allows)' : ''}`);
           }
         } catch (e) {
           buildStatusResolved = false;
@@ -1272,6 +1364,47 @@ async function pollPrStatus(config) {
           updated = true;
         }
       }
+      // Persist buildStaleMergeCommit flag (Issue #2747) so the dashboard
+      // can render the distinction and the auto-queue decision below has
+      // a stable cross-tick signal. Clear when no longer stale.
+      if (buildStaleMergeCommit) {
+        if (!pr.buildStaleMergeCommit) {
+          pr.buildStaleMergeCommit = true;
+          updated = true;
+        }
+      } else if (pr.buildStaleMergeCommit) {
+        delete pr.buildStaleMergeCommit;
+        updated = true;
+      }
+    }
+
+    // Auto-queue fresh build on stale-failing detection (Issue #2747).
+    // Forces ADO to recompute the merge commit so the next poll has real
+    // data instead of stuck-stale failing builds. Rate-limited to at most
+    // one queue per PR per 30 min via pr._lastBuildRequeueAt. Only PR-
+    // validation definitions are queued; non-PR builds are filtered out
+    // upstream. Failures are non-fatal — logged warn and skipped.
+    if (buildStatusResolved && buildStatus === 'failing' && buildStaleMergeCommit && staleFailingDefinitions.length > 0) {
+      if (shouldRequeueStaleBuild(pr)) {
+        let queuedCount = 0;
+        for (const def of staleFailingDefinitions) {
+          try {
+            await queueFreshAdoBuild({ orgBase, project, prNumber, definitionId: def.id, token });
+            queuedCount++;
+            log('info', `PR ${pr.id} build: queued fresh build for definition '${def.name}' (id=${def.id}) on refs/pull/${prNumber}/merge to refresh stale merge-commit classification`);
+          } catch (e) {
+            log('warn', `PR ${pr.id} build: failed to queue fresh build for definition '${def.name}' (id=${def.id}): ${e.message}`);
+          }
+        }
+        if (queuedCount > 0) {
+          pr._lastBuildRequeueAt = Date.now();
+          updated = true;
+        }
+      } else {
+        const lastAt = Number(pr._lastBuildRequeueAt) || 0;
+        const ageMin = Math.floor((Date.now() - lastAt) / 60000);
+        log('info', `PR ${pr.id} build: stale-failing detected but skipping fresh-queue — last requeue ${ageMin}m ago (rate limit: 30 min)`);
+      }
     }
 
     // Auto-complete: set auto-complete on PR when builds green + review approved
@@ -1766,12 +1899,16 @@ async function resetReviewerNegativeVote(pr, project) {
  *     mergeConflict: boolean,
  *     buildStatusStale?: boolean,
  *     buildStatusDetail?: string,
+ *     buildStaleMergeCommit?: boolean,
  *   }
  *
  * `buildStatus` is null when ADO has builds on the merge ref but none target the
- * current merge commit (target-branch advance with no source-side rebuild yet —
- * matches pollPrStatus's "preserve previous buildStatus" semantics from issue
- * #1233; the caller must trust the cached value).
+ * current merge commit AND the stale set is not failing (target-branch advance
+ * with no source-side rebuild yet — matches pollPrStatus's "preserve previous
+ * buildStatus" semantics from issue #1233; the caller must trust the cached
+ * value). When the stale set IS failing, buildStatus flips to 'failing' and
+ * `buildStaleMergeCommit: true` is returned (Issue #2747) — a stale failing
+ * signal is strictly more actionable than cache fallback.
  */
 async function checkLiveBuildAndConflict(pr, project) {
   try {
@@ -1806,6 +1943,7 @@ async function checkLiveBuildAndConflict(pr, project) {
     let buildStatus = null;
     let buildStatusStale = false;
     let buildStatusDetail = '';
+    let buildStaleMergeCommit = false;
     if (prData.status === 'active') {
       const mergeCommitId = prData.lastMergeCommit?.commitId;
       if (mergeCommitId) {
@@ -1824,9 +1962,19 @@ async function checkLiveBuildAndConflict(pr, project) {
               buildStatus = classifyBuildStatus(prBuilds);
             } else if (allBuilds.length === 0) {
               buildStatus = 'none';
+            } else {
+              // Stale merge-commit (Issue #2747) — mirror pollPrStatus.
+              // Stale-failing flips to 'failing' + buildStaleMergeCommit so
+              // the caller skips the cache fallback and dispatches a fix.
+              // Stale-succeeded leaves buildStatus null so caller falls
+              // back to cached state (no false confidence).
+              const stale = classifyStaleBuilds(allBuilds, pr?.buildStatus || null);
+              if (stale.buildStaleMergeCommit) {
+                buildStatus = stale.buildStatus;
+                buildStaleMergeCommit = true;
+              }
+              // else: leave buildStatus null — caller falls back to cached state (issue #1233).
             }
-            // else: merge-commit mismatch — leave buildStatus null so caller
-            // falls back to cached state (issue #1233).
           } catch (e) {
             buildStatusStale = true;
             buildStatusDetail = `ADO live build query failed: ${e.message}`;
@@ -1844,6 +1992,7 @@ async function checkLiveBuildAndConflict(pr, project) {
       buildStatus,
       mergeConflict,
       ...(buildStatusStale ? { buildStatusStale, buildStatusDetail } : {}),
+      ...(buildStaleMergeCommit ? { buildStaleMergeCommit: true } : {}),
     };
   } catch (e) {
     log('warn', `Live build/conflict check for ${pr.id}: ${e.message}`);
@@ -2222,4 +2371,10 @@ module.exports = {
   VOTE_SNAPSHOT_MAX_AGE_MS,
   STUCK_VOTE_AGE_THRESHOLD_MS,
   STUCK_VOTE_WARN_INTERVAL_MS,
+  // Issue #2747 — stale merge-commit classifier + auto-queue helpers, exported for unit tests.
+  classifyBuildStatus,
+  classifyStaleBuilds,
+  isPrValidationBuild,
+  shouldRequeueStaleBuild,
+  PR_BUILD_REQUEUE_INTERVAL_MS,
 };

package/package.json

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