@yemi33/minions 0.1.2312 → 0.1.2313

package/dashboard/js/render-prs.js

@@ -187,6 +187,30 @@ function prRow(pr) {
         + '⏸ paused: ' + escapeHtml(cause) + ' ▶</button>';
     }).join('');
   }
+  // #639 follow-up — build-fix-ineffective chip. Distinct from the generic
+  // no-op pausedCauses above: pr._buildFixIneffective is set when a
+  // BUILD_FAILURE fix reported "no branch change" AND a live CI re-poll
+  // confirmed the build is STILL failing on that same head (see
+  // engine/lifecycle.js recordBuildFixIneffective). This is a separate,
+  // headSha-keyed pause distinct from _noOpFixes, so it needs its own,
+  // clearly-labeled indicator — a still-red build after an unchanged fix
+  // attempt usually means the failure isn't fixable by another agent pass
+  // (flaky infra, external outage, etc.), hence "infra issue suspected".
+  // No resume action is wired here (clearing this record is an engine-side
+  // change out of scope for this UI-only follow-up) — informational only.
+  var buildFixIneffective = pr._buildFixIneffective;
+  if (buildFixIneffective && typeof buildFixIneffective === 'object' && buildFixIneffective.paused === true) {
+    var bfiTitle = 'Build-fix reported no branch change, and a live CI re-poll confirmed the build is still "'
+      + (buildFixIneffective.liveBuildStatus || 'failing') + '" on the same commit ('
+      + (buildFixIneffective.headSha || 'unknown head') + ') after '
+      + (buildFixIneffective.count || '?') + ' ineffective attempt(s). Reason: '
+      + (buildFixIneffective.reason || 'unknown')
+      + '. A new push to this branch will reset this pause.';
+    pausedChips += ' <span class="pr-badge rejected pr-build-fix-ineffective-chip" '
+      + 'style="font-size:var(--text-xs)" '
+      + 'title="' + escapeHtml(bfiTitle) + '">'
+      + '⏸ infra issue suspected ▶</span>';
+  }
   const titleText = pr.title || 'Untitled';
   // Polish (W-mqv5ccn7): flatten Markdown in the body so the preview shows
   // plain text instead of raw `##` / `**…**` / backtick source.

package/engine/lifecycle.js

@@ -2647,6 +2647,104 @@ async function detectPrFixBranchChange(meta, config) {
   return { changed: null, beforeHead, afterHead: remoteHead || '', reason: 'unable to prove branch head after fix' };
 }
 
+// #639 — lazy requires for the host-specific live build/conflict checkers.
+// engine/github.js and engine/ado.js both lazy-require lifecycle.js (see
+// their `lifecycleModule()` helpers), so a top-level require here would form
+// an import cycle. Deferring to first call avoids that.
+let _githubPrModule = null;
+function githubPrModule() { if (!_githubPrModule) _githubPrModule = require('./github'); return _githubPrModule; }
+let _adoPrModule = null;
+function adoPrModule() { if (!_adoPrModule) _adoPrModule = require('./ado'); return _adoPrModule; }
+
+// #639 — No-op fix detection previously only proved whether the agent pushed
+// a NEW commit; it never checked whether the build the fix was dispatched
+// against had actually turned green. That let a stuck failure get marked
+// "handled"/no-op forever: a fix commit lands and gets recorded as handled,
+// CI re-runs and fails again with the SAME signature against that exact
+// commit, and every subsequent build-fix dispatch finds "the fix is already
+// on the branch" (branch unchanged) and concludes no-op — without ever
+// re-checking that the build is still red. Call this right before accepting
+// a BUILD_FAILURE "no branch change" outcome as a clean no-op so the caller
+// can distinguish "genuinely nothing to do" from "fix was ineffective".
+async function checkBuildStillFailingLive(pr, project) {
+  if (!pr || !project) return null;
+  try {
+    const checkFn = project.repoHost === 'github'
+      ? githubPrModule().checkLiveBuildAndConflict
+      : adoPrModule().checkLiveBuildAndConflict;
+    if (typeof checkFn !== 'function') return null;
+    const live = await checkFn(pr, project);
+    // A stale/errored live read carries no fresh evidence — don't let it
+    // masquerade as a confirmed still-failing result.
+    if (!live || live.buildStatusStale) return null;
+    return live.buildStatus || null;
+  } catch (err) {
+    log('warn', `Live build re-check for ${pr.id || pr.url || '(unknown PR)'}: ${err.message}`);
+    return null;
+  }
+}
+
+// #639 — Records a build-fix dispatch that reported "no branch change" AND
+// was verified (via live re-poll) to still be failing on the same head.
+// Tracked deliberately separately from `_noOpFixes[BUILD_FAILURE]` — see
+// `shared.isBuildFixIneffectivePaused` for why sharing that counter would
+// let a genuinely-broken build get stuck paused forever with no distinct
+// signal. The dispatch-eligibility gate for BUILD_FAILURE reads BOTH
+// `shared.isPrNoOpFixCausePaused` and `shared.isBuildFixIneffectivePaused`
+// (engine.js), and neither this record's `outcome` nor its pause state
+// suppresses the same-head skip guard tied to `outcome === 'noop'` — so the
+// engine keeps re-dispatching (subject to the normal cooldown) with a fresh
+// instruction to inspect the CURRENT failure rather than assume the prior
+// commit already fixed it, until either a real fix lands (head moves) or
+// the attempt cap is reached and a human is alerted.
+function recordBuildFixIneffective(target, dispatchItem, config, liveBuildStatus) {
+  const headSha = getPrFixBaselineHead(target);
+  const prior = target._buildFixIneffective && typeof target._buildFixIneffective === 'object'
+    ? target._buildFixIneffective : null;
+  const sameHead = !!prior && !!headSha && prior.headSha === headSha;
+  const count = sameHead ? (Number(prior.count) || 0) + 1 : 1;
+  const pauseAfter = Number(config?.engine?.prNoOpFixPauseAttempts) || ENGINE_DEFAULTS.prNoOpFixPauseAttempts;
+  const paused = count >= pauseAfter;
+  const flippedToPaused = paused && !(sameHead && prior?.paused === true);
+  const now = ts();
+  const reason = `build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${String(headSha || '').slice(0, 12)}`;
+  target._buildFixIneffective = {
+    count,
+    paused,
+    headSha,
+    liveBuildStatus: liveBuildStatus || 'failing',
+    firstAt: sameHead ? (prior.firstAt || now) : now,
+    lastAt: now,
+    dispatchId: dispatchItem?.id || null,
+    reason,
+  };
+  if (flippedToPaused) {
+    try {
+      const prNumber = target.prNumber || shared.getPrNumber(target) || target.id || 'unknown';
+      const noteBody = `# Build fix ineffective: ${target.id || prNumber}\n\n`
+        + `**PR:** ${target.url || target.id || '(unknown)'}\n`
+        + `**Branch:** ${target.branch || '(unknown)'}\n`
+        + `**Head:** ${String(headSha || '').slice(0, 40) || '(unknown)'}\n`
+        + `**Attempt:** ${count}/${pauseAfter} (paused)\n\n`
+        + `A build-failure fix dispatch reported no branch change, but re-polling live CI showed the build is STILL \`${liveBuildStatus || 'failing'}\` against that exact commit. `
+        + `The engine reached \`engine.prNoOpFixPauseAttempts\` (${pauseAfter}) consecutive ineffective-fix attempts against the same head and has paused build-failure automation for this PR.\n\n`
+        + `**Recovery options:**\n`
+        + `1. A new head SHA on this PR auto-clears the pause (a real fix attempt landed).\n`
+        + `2. Manually inspect the live CI logs — the automated fixes may be addressing the wrong failure, or the failure may not be fixable by re-pushing (flaky infra, protected branch, etc).\n`;
+      shared.writeToInbox(
+        'engine',
+        `build-fix-ineffective-${prNumber}`,
+        noteBody,
+        null,
+        { wi: dispatchItem?.meta?.item?.id || null, pr: target.id || null, cause: shared.PR_FIX_CAUSE.BUILD_FAILURE }
+      );
+    } catch (err) {
+      log('warn', `build-fix-ineffective inbox alert for ${target.id || '(unknown)'}: ${err.message}`);
+    }
+  }
+  return target._buildFixIneffective;
+}
+
 function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChange, config, noopReason) {
   const evidenceFingerprint = shared.prFixEvidenceFingerprint(target, cause);
   const prior = shared.getPrNoOpFixRecord(target, cause);
@@ -2992,6 +3090,22 @@ function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId =
       return prs;
     }
     if (explicitlyChangedBranch && options.branchChange?.changed === false) {
+      // #639 — a BUILD_FAILURE fix that reported "no branch change" is only a
+      // genuine no-op if the build the fix was dispatched against actually
+      // recovered. `options.buildStillFailing` (set by the caller from a live
+      // re-poll of the current head commit) proves it did NOT — the same
+      // failure persists against the exact commit the agent left in place.
+      // Route through the distinct fixIneffective counter instead of the
+      // shared no-op/pause counter so a stuck-red build gets its own signal
+      // and its own (non-sticky-forever) pause, rather than silently
+      // consuming the generic no-op pause budget with no way to tell "there
+      // was truly nothing to do" apart from "the fix didn't work".
+      if (cause === shared.PR_FIX_CAUSE.BUILD_FAILURE && options.buildStillFailing) {
+        const record = recordBuildFixIneffective(target, options.dispatchItem, options.config, options.buildStillFailing);
+        result = { noOp: true, cause, fixIneffective: true, paused: !!record.paused, count: record.count };
+        log('warn', `Updated ${pr.id} → build-fix reported no branch change, but live CI is still ${options.buildStillFailing} on the same head; recorded fixIneffective attempt ${record.count}${record.paused ? ' (paused)' : ''}`);
+        return prs;
+      }
       const record = recordPrNoOpFixAttempt(target, cause, source, options.dispatchItem, options.branchChange, options.config, options.noopReason);
       result = { noOp: true, cause, paused: !!record.paused, count: record.count };
       log('warn', `Updated ${pr.id} → recorded no-op ${cause} fix attempt ${record.count}${record.paused ? ' (paused)' : ''}; PR branch was unchanged`);
@@ -3022,6 +3136,10 @@ function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId =
       target._buildFixPushedAt = ts();
       delete target._buildFixPushFailedCount;
       delete target._buildFixNeedsHumanRebase;
+      // #639 — a genuine branch-changing fix landed; drop any stale
+      // fixIneffective pause from a prior head so the next ineffective
+      // detection (if any) starts a fresh count against the new commit.
+      delete target._buildFixIneffective;
     }
     if (source === 'pr-human-feedback') {
       const clearPendingFix = shouldClearHumanFeedbackPendingFix(target, pr, automationCauseKey);
@@ -5729,6 +5847,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Archive is manual — user archives plans from the dashboard when ready
 
   let prFixBranchChange = null;
+  let prFixBuildStillFailing = null;
   if (type === WORK_TYPE.FIX && effectiveSuccess && meta?.pr?.id) {
     try {
       prFixBranchChange = await detectPrFixBranchChange(meta, config);
@@ -5736,6 +5855,30 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       log('warn', `PR fix no-op detection for ${meta.pr.id}: ${err.message}`);
       prFixBranchChange = { changed: null, reason: err.message };
     }
+    // #639 — a BUILD_FAILURE fix that didn't change the branch is not
+    // necessarily a genuine no-op: the agent may have found its own (or a
+    // prior dispatch's) fix commit already present and concluded "nothing to
+    // change" without checking whether CI actually turned green on that
+    // commit. Re-poll live CI for the head before letting updatePrAfterFix
+    // accept the no-op — if it's still failing, flag it so the no-op path
+    // records a distinct fixIneffective signal instead of a clean no-op.
+    if (prFixBranchChange?.changed === false) {
+      const fixCause = shared.getPrFixAutomationCause({
+        dispatchKey: dispatchItem?.meta?.dispatchKey,
+        source: meta?.source,
+        task: dispatchItem?.task,
+      });
+      if (fixCause === shared.PR_FIX_CAUSE.BUILD_FAILURE) {
+        try {
+          const liveStatus = await checkBuildStillFailingLive(meta.pr, meta.project);
+          if (liveStatus === shared.BUILD_STATUS.FAILING) {
+            prFixBuildStillFailing = liveStatus;
+          }
+        } catch (err) {
+          log('warn', `Live build re-check for ${meta.pr.id}: ${err.message}`);
+        }
+      }
+    }
   }
 
   // Scheduled task back-reference: update schedule-runs.json and write linked inbox note
@@ -5854,6 +5997,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       automationCauseKey: meta?.automationCauseKey,
       dispatchItem,
       branchChange: prFixBranchChange,
+      buildStillFailing: prFixBuildStillFailing,
       config,
       noopReason: noopRationale || meta?._noopReason || '',
     });
@@ -6666,6 +6810,11 @@ module.exports = {
   // Issue #2969 — exported for direct unit testing of the pause-flip alert
   // path without going through updatePrAfterFix's many guards.
   recordPrNoOpFixAttempt,
+  // #639 — exported for direct unit testing of the build-fix-ineffective
+  // detection path (no-op branch + still-failing live CI) without spinning
+  // up the full ADO/GH poller stack.
+  checkBuildStillFailingLive,
+  recordBuildFixIneffective,
   // W-mq5uzmc6001d708f — post-hoc PR enrollment for orphan `_pr` pointers.
   enrollPrFromCanonicalId,
   _setEnrollmentGhRunnerForTest,

package/engine/shared.js

@@ -8671,6 +8671,24 @@ function getPrPausedCauses(pr) {
   return causes;
 }
 
+// #639 — Distinct pause signal for "fix reported no branch change, but a live
+// re-poll proved the build is STILL failing on that exact (unchanged) head".
+// This is deliberately tracked separately from `_noOpFixes[BUILD_FAILURE]`:
+// that record's evidence fingerprint includes `headRefOid`, so when the head
+// never moves (the agent genuinely pushed nothing) the fingerprint never
+// changes either — a real "build never actually got fixed" case would get
+// stuck paused forever with no distinguishing signal from a benign "nothing
+// needed doing" no-op (see #639). `_buildFixIneffective` re-validates against
+// the live head SHA the same way `isPrNoOpFixCausePaused` re-validates the
+// fingerprint: a new head SHA (real fix attempt landed) always releases the
+// pause, even though the underlying counter never got a fresh evidence key.
+function isBuildFixIneffectivePaused(pr) {
+  const record = pr?._buildFixIneffective;
+  if (!record || typeof record !== 'object' || record.paused !== true) return false;
+  const currentHead = _prHeadSha(pr);
+  return !!currentHead && record.headSha === currentHead;
+}
+
 /**
  * Recursively purge Windows reserved-name pseudo-files (NUL, CON, PRN, AUX, etc.)
  * using the \\?\ extended path prefix that bypasses reserved-name interpretation.
@@ -9460,6 +9478,7 @@ module.exports = {
   getPrNoOpFixRecord,
   isPrNoOpFixCausePaused,
   getPrPausedCauses,
+  isBuildFixIneffectivePaused,
   parseSkillFrontmatter,
   sleepMs,
   killGracefully,

package/engine.js

@@ -6619,6 +6619,18 @@ function isPrNoOpFixCauseSuppressed(pr, cause) {
   return true;
 }
 
+// #639 — distinct suppression check for the build-fix-ineffective pause
+// (see shared.isBuildFixIneffectivePaused / engine/lifecycle.js
+// recordBuildFixIneffective). Kept separate from isPrNoOpFixCauseSuppressed
+// so the log line is unambiguous about WHY build-fix automation stopped:
+// repeated attempts genuinely found nothing to change vs. repeated attempts
+// left the build still red on the same commit.
+function isBuildFixIneffectiveSuppressed(pr) {
+  if (!shared.isBuildFixIneffectivePaused(pr)) return false;
+  log('warn', `PR ${pr.id}: suppressing build-failure automation — live CI stayed failing across repeated fix attempts on the same head; waiting for a new commit or human resume`);
+  return true;
+}
+
 const PR_PENDING_MISSING_BRANCH = shared.PR_PENDING_REASON.MISSING_BRANCH;
 
 function normalizePrBranch(value) {
@@ -7330,7 +7342,8 @@ async function discoverFromPrs(config, project) {
     }
     if (pollEnabled && autoFixBuilds && pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing'
       && !fixDispatched
-      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.BUILD_FAILURE)) {
+      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.BUILD_FAILURE)
+      && !isBuildFixIneffectiveSuppressed(pr)) {
       // W-mpritzcr0004afc5 (#2955): "don't fan out a parallel build-failure
       // fix while the review-feedback path owns the PR" — implemented via
       // the `!fixDispatched` gate above (mirrors the merge-conflict block

package/package.json

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