@yemi33/minions 0.1.1616 → 0.1.1617

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.1.1617 (2026-04-29)
+
+### Fixes
+- guard stale build & conflict auto-fixes with live pre-dispatch check (#1851)
+
 ## 0.1.1616 (2026-04-29)
 
 ### Features

package/engine/ado.js

@@ -844,6 +844,77 @@ async function checkLiveReviewStatus(pr, project) {
   }
 }
 
+/**
+ * Cheap pre-dispatch freshness check for build status and merge-conflict state.
+ * Mirrors checkLiveReviewStatus — fetches PR data once, classifies builds for the
+ * current merge commit, and reports whether ADO still considers the PR conflicted.
+ *
+ * Returns null if the check can't run (no token, no PR number, network error) so
+ * callers can fall back to cached state. Otherwise returns:
+ *   {
+ *     buildStatus: 'failing' | 'passing' | 'running' | 'none' | null,
+ *     mergeConflict: 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).
+ */
+async function checkLiveBuildAndConflict(pr, project) {
+  try {
+    const token = await getAdoToken();
+    if (!token) return null;
+    const orgBase = shared.getAdoOrgBase(project);
+    const prNum = shared.getPrNumber(pr);
+    if (!prNum) return null;
+    const repoBase = `${orgBase}/${project.adoProject}/_apis/git/repositories/${project.repositoryId}`;
+    const prUrl = `${repoBase}/pullrequests/${prNum}?api-version=7.1`;
+    // 4s timeout — same budget as checkLiveReviewStatus. This is a pre-dispatch
+    // gate; we'd rather miss a freshness signal and fall back to cache than
+    // block dispatch on a slow ADO call.
+    const prData = await adoFetch(prUrl, token, { timeout: 4000 });
+    if (!prData) return null;
+
+    // Conflict signal — ADO reports `mergeStatus: 'conflicts'` when the merge
+    // would conflict; anything else means clean (or recomputing).
+    const mergeConflict = prData.mergeStatus === 'conflicts';
+
+    // Build signal — only meaningful when the PR is still open. We replicate
+    // pollPrStatus's narrowing logic so the live check and the cached poll
+    // agree on what 'failing' / 'passing' / 'running' / 'none' mean.
+    let buildStatus = null;
+    if (prData.status === 'active') {
+      const mergeCommitId = prData.lastMergeCommit?.commitId;
+      if (mergeCommitId) {
+        try {
+          const mergeRef = encodeURIComponent(`refs/pull/${prNum}/merge`);
+          const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${project.repositoryId}&repositoryType=TfsGit&$top=25&api-version=7.1`;
+          const buildsData = await adoFetch(buildsUrl, token, { timeout: 4000 });
+          const allBuilds = buildsData?.value || [];
+          const prBuilds = allBuilds.filter(b => b.sourceVersion === mergeCommitId);
+          if (prBuilds.length > 0) {
+            buildStatus = classifyBuildStatus(prBuilds);
+          } else if (allBuilds.length === 0) {
+            buildStatus = 'none';
+          }
+          // else: merge-commit mismatch — leave buildStatus null so caller
+          // falls back to cached state (issue #1233).
+        } catch (e) { log('warn', `Live build check builds query for ${pr.id}: ${e.message}`); }
+      } else {
+        // No merge commit yet — likely conflict or fresh PR. Treat as 'none'
+        // so a stale 'failing' cache can be cleared by the caller.
+        buildStatus = 'none';
+      }
+    }
+
+    return { buildStatus, mergeConflict };
+  } catch (e) {
+    log('warn', `Live build/conflict check for ${pr.id}: ${e.message}`);
+    return null;
+  }
+}
+
 async function fetchAdoPrMetadata(prNum, adoOrg, adoProj, adoRepo) {
   const token = await getAdoToken();
   if (!token) return null;
@@ -968,6 +1039,22 @@ function _setAdoThrottleForTest(state) {
   _adoThrottle._setForTest(state);
 }
 
+/** Inject a token into the cache — exported for testing only.
+ *  Lets tests exercise functions that call getAdoToken() without invoking azureauth.
+ *  Pass null to force getAdoToken() to return null synchronously (no exec). */
+function _setAdoTokenForTest(token) {
+  if (token == null) {
+    // Clear cache AND set a future failure backoff so getAdoToken short-circuits
+    // to null without spawning azureauth — otherwise tests would hang on the
+    // 15s execAsync timeout or open a real auth popup.
+    _adoTokenCache = { token: null, expiresAt: 0 };
+    _adoTokenFailedUntil = Date.now() + 60 * 60 * 1000;
+  } else {
+    _adoTokenCache = { token, expiresAt: Date.now() + 30 * 60 * 1000 };
+    _adoTokenFailedUntil = 0;
+  }
+}
+
 module.exports = {
   getAdoToken,
   adoFetch,
@@ -975,6 +1062,7 @@ module.exports = {
   pollPrHumanComments,
   reconcilePrs,
   checkLiveReviewStatus,
+  checkLiveBuildAndConflict,
   needsAdoPollRetry,
   isAdoAuthError, // exported for testing
   isAdoThrottled,
@@ -984,4 +1072,5 @@ module.exports = {
   findOpenPrOnBranch,
   _resetAdoThrottle, // exported for testing
   _setAdoThrottleForTest, // exported for testing
+  _setAdoTokenForTest, // exported for testing
 };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-04-29T00:05:48.131Z"
+  "cachedAt": "2026-04-29T01:10:14.567Z"
 }

package/engine/github.js

@@ -789,11 +789,79 @@ async function checkLiveReviewStatus(pr, project) {
   }
 }
 
+/**
+ * Cheap pre-dispatch freshness check for build status and merge-conflict state.
+ * Mirrors checkLiveReviewStatus — fetches PR data once, classifies check-runs
+ * for the current head SHA, and reports whether GitHub still considers the PR
+ * unmergeable.
+ *
+ * Returns null if the check can't run (no slug/PR/network) so callers can fall
+ * back to cached state. Otherwise returns:
+ *   {
+ *     buildStatus: 'failing' | 'passing' | 'running' | 'none' | null,
+ *     mergeConflict: boolean,
+ *   }
+ *
+ * `mergeConflict` is true only when GitHub explicitly reports `mergeable: false`
+ * — `mergeable: null` means GitHub is still computing the merge state, so the
+ * caller should treat that as "no fresh signal" and trust the cache.
+ *
+ * `buildStatus` is null when we couldn't query check-runs or the PR isn't open;
+ * caller falls back to cached value.
+ */
+async function checkLiveBuildAndConflict(pr, project) {
+  try {
+    const slug = getRepoSlug(project);
+    if (!slug) return null;
+    const prNum = shared.getPrNumber(pr);
+    if (!prNum) return null;
+    const prData = await ghApi(`/pulls/${prNum}`, slug);
+    if (!prData || prData === GH_NOT_FOUND) return null;
+
+    // Conflict signal — only treat `mergeable === false` as a positive
+    // conflict. `null` means "GitHub still computing" → we have no fresh
+    // info, so fall back to whatever the cache says.
+    let mergeConflict;
+    if (prData.mergeable === false) mergeConflict = true;
+    else if (prData.mergeable === true) mergeConflict = false;
+    else mergeConflict = !!pr._mergeConflict; // computing — preserve cached view
+
+    // Build signal — only meaningful for open PRs. Mirrors pollPrStatus's
+    // check-runs classification so the live read and cached poll agree on
+    // 'failing' / 'passing' / 'running' / 'none'.
+    let buildStatus = null;
+    if (prData.state === 'open' && prData.head?.sha) {
+      try {
+        const checksData = await ghApi(`/commits/${prData.head.sha}/check-runs`, slug);
+        if (checksData && Array.isArray(checksData.check_runs)) {
+          const runs = checksData.check_runs;
+          if (runs.length === 0) {
+            buildStatus = 'none';
+          } else {
+            const hasFailed = runs.some(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
+            const allDone = runs.every(r => r.status === 'completed');
+            const allPassed = runs.every(r => r.conclusion === 'success' || r.conclusion === 'skipped' || r.conclusion === 'neutral');
+            if (hasFailed) buildStatus = 'failing';
+            else if (allDone && allPassed) buildStatus = 'passing';
+            else buildStatus = 'running';
+          }
+        }
+      } catch (e) { log('warn', `Live build check checks query for ${pr.id}: ${e.message}`); }
+    }
+
+    return { buildStatus, mergeConflict };
+  } catch (e) {
+    log('warn', `Live build/conflict check for ${pr.id}: ${e.message}`);
+    return null;
+  }
+}
+
 module.exports = {
   pollPrStatus,
   pollPrHumanComments,
   reconcilePrs,
   checkLiveReviewStatus,
+  checkLiveBuildAndConflict,
   isGhThrottled,
   getGhThrottleState,
   // Exported for testing

package/engine.js

@@ -1581,8 +1581,8 @@ function reconcileItemsWithPrs(items, allPrs, { onlyIds } = {}) {
 // ─── Inbox Consolidation (extracted to engine/consolidation.js) ──────────────
 
 const { consolidateInbox } = require('./engine/consolidation');
-const { pollPrStatus, pollPrHumanComments, reconcilePrs, checkLiveReviewStatus: adoCheckLiveReview, needsAdoPollRetry, getAdoToken, isAdoThrottled } = require('./engine/ado');
-const { pollPrStatus: ghPollPrStatus, pollPrHumanComments: ghPollPrHumanComments, reconcilePrs: ghReconcilePrs, checkLiveReviewStatus: ghCheckLiveReview, isGhThrottled } = require('./engine/github');
+const { pollPrStatus, pollPrHumanComments, reconcilePrs, checkLiveReviewStatus: adoCheckLiveReview, checkLiveBuildAndConflict: adoCheckLiveBuildAndConflict, needsAdoPollRetry, getAdoToken, isAdoThrottled } = require('./engine/ado');
+const { pollPrStatus: ghPollPrStatus, pollPrHumanComments: ghPollPrHumanComments, reconcilePrs: ghReconcilePrs, checkLiveReviewStatus: ghCheckLiveReview, checkLiveBuildAndConflict: ghCheckLiveBuildAndConflict, isGhThrottled } = require('./engine/github');
 
 // ─── State Snapshot ─────────────────────────────────────────────────────────
 
@@ -2255,6 +2255,39 @@ async function discoverFromPrs(config, project) {
 
       const key = `build-fix-${project?.name || 'default'}-${prDisplayId}`;
       if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
+
+      // Pre-dispatch live build check — cached buildStatus may be stale: ADO can
+      // recompute the merge commit when master moves and pollPrStatus deliberately
+      // preserves the previous 'failing' value (issue #1233); GitHub check-runs
+      // may have flipped to 'passing' minutes before the next 12-tick poll. Mirror
+      // the review/re-review live-vote guard so we don't dispatch a fix for a
+      // build that has already recovered.
+      try {
+        const checkBcFn = project.repoHost === 'github' ? ghCheckLiveBuildAndConflict : adoCheckLiveBuildAndConflict;
+        const live = await checkBcFn(pr, project);
+        if (live && live.buildStatus && live.buildStatus !== 'failing') {
+          log('info', `Pre-dispatch build check: ${pr.id} build is ${live.buildStatus} (cached was failing) — skipping build-fix`);
+          // Persist the fresh status so subsequent ticks don't re-check on every pass
+          try {
+            mutatePullRequests(projectPrPath(project), prs => {
+              const target = shared.findPrRecord(prs, pr, project);
+              if (!target) return;
+              target.buildStatus = live.buildStatus;
+              if (live.buildStatus === 'passing') {
+                delete target.buildErrorLog;
+                delete target.buildFailReason;
+                delete target._buildFailNotified;
+                if (target.buildFixAttempts) {
+                  delete target.buildFixAttempts;
+                  delete target.buildFixEscalated;
+                }
+              }
+            });
+          } catch {}
+          continue;
+        }
+      } catch (e) { log('warn', `Pre-dispatch build check for ${pr.id}: ${e.message} — skipping dispatch`); continue; }
+
       const agentId = resolveAgent('fix', config, pr.agent);
       if (!agentId) continue;
 
@@ -2306,22 +2339,47 @@ async function discoverFromPrs(config, project) {
       const conflictFixedAt = pr._conflictFixedAt;
       const withinLag = conflictFixedAt && Date.now() - new Date(conflictFixedAt).getTime() < 10 * 60 * 1000;
       if (!withinLag && !fixThrottled && !isAlreadyDispatched(key) && !isOnCooldown(key, cooldownMs)) {
-        const agentId = resolveAgent('fix', config, pr.agent);
-        if (agentId) {
-          const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
-            pr_id: pr.id, pr_branch: pr.branch || '',
-            review_note: `This PR has merge conflicts with the target branch. Resolve the conflicts:\n\n1. Pull latest from main/master\n2. Resolve all conflicts (prefer PR branch changes unless main has critical fixes)\n3. Build and test after resolving\n4. Push the resolved branch`,
-          }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
-          if (item) {
-            newWork.push(item);
-            setCooldown(key);
-            // Record dispatch timestamp so re-dispatch is suppressed during ADO lag window
+        // Pre-dispatch live conflict check — cached `_mergeConflict` may be
+        // stale: ADO/GitHub recompute mergeStatus asynchronously (1–5 min lag),
+        // so a successful upstream merge can leave the flag set even after the
+        // conflict is gone. Mirror the review/re-review live-vote guard so we
+        // don't dispatch a conflict-fix for a PR that's already clean.
+        let liveSkip = false;
+        try {
+          const checkBcFn = project.repoHost === 'github' ? ghCheckLiveBuildAndConflict : adoCheckLiveBuildAndConflict;
+          const live = await checkBcFn(pr, project);
+          if (live && live.mergeConflict === false) {
+            log('info', `Pre-dispatch conflict check: ${pr.id} reports clean merge (cached was conflict) — skipping conflict-fix`);
             try {
               mutatePullRequests(projectPrPath(project), prs => {
                 const target = shared.findPrRecord(prs, pr, project);
-                if (target) target._conflictFixedAt = new Date().toISOString();
+                if (!target) return;
+                delete target._mergeConflict;
+                delete target._conflictFixedAt;
               });
-            } catch (e) { log('warn', `conflict-fix timestamp: ${e.message}`); }
+            } catch {}
+            liveSkip = true;
+          }
+        } catch (e) { log('warn', `Pre-dispatch conflict check for ${pr.id}: ${e.message} — skipping dispatch`); liveSkip = true; }
+
+        if (!liveSkip) {
+          const agentId = resolveAgent('fix', config, pr.agent);
+          if (agentId) {
+            const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
+              pr_id: pr.id, pr_branch: pr.branch || '',
+              review_note: `This PR has merge conflicts with the target branch. Resolve the conflicts:\n\n1. Pull latest from main/master\n2. Resolve all conflicts (prefer PR branch changes unless main has critical fixes)\n3. Build and test after resolving\n4. Push the resolved branch`,
+            }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: pr.branch, project: projMeta });
+            if (item) {
+              newWork.push(item);
+              setCooldown(key);
+              // Record dispatch timestamp so re-dispatch is suppressed during ADO lag window
+              try {
+                mutatePullRequests(projectPrPath(project), prs => {
+                  const target = shared.findPrRecord(prs, pr, project);
+                  if (target) target._conflictFixedAt = new Date().toISOString();
+                });
+              } catch (e) { log('warn', `conflict-fix timestamp: ${e.message}`); }
+            }
           }
         }
       }

package/package.json

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