@yemi33/minions 0.1.2312 → 0.1.2314

package/dashboard/js/refresh.js

@@ -136,7 +136,8 @@ const RENDER_VERSIONS = {
   inbox: 2,
   // Bumped 4→5 for the clickable checkout-mode pill + picker (W-mr1b67zi0006b788).
   // Bumped 5→6 for multi-select hybrid liveValidation.type support (W-mr2m1ute000a9c01).
-  projects: 6,
+  // Bumped 6→7 for the liveValidation.autoDispatch toggle + pill "· auto-validate" suffix (W-mr2q361a00097e5c).
+  projects: 7,
   notes: 1,
   prd: 3,
   prs: 3,
@@ -149,7 +150,9 @@ const RENDER_VERSIONS = {
   dispatch: 2,
   engineLog: 2,
   metrics: 1,
-  workItems: 7,
+  // Bumped 7→8: WI detail modal's branch pill moved out of the Artifacts
+  // chip row into its own non-interactive "Branch" field (W-mr2qjr3b0002522f).
+  workItems: 8,
   skills: 1,
   commands: 1,
   mcpServers: 1,

package/dashboard/js/render-other.js

@@ -112,7 +112,15 @@ function _renderWorktreeModePill(p) {
     if (types.length > 0) {
       const typesText = types.join(', ');
       const vt = escapeHtml(typesText);
-      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type(s) run in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree). Click to change.">⚡ Hybrid · ' + vt + '</span>';
+      // W-mr2q361a00097e5c — visibly distinguish "Hybrid (manual validation)"
+      // from "Hybrid (auto-validate)" so the operator doesn't have to reopen
+      // the picker to discover whether autoDispatch is silently off.
+      const autoDispatch = p.liveValidationAutoDispatch === true;
+      const autoSuffix = autoDispatch ? ' · auto-validate' : '';
+      const autoTitleBit = autoDispatch
+        ? ' A validation work item is automatically dispatched after each coding work item completes.'
+        : ' Auto-validation is OFF — validation must be dispatched manually after each coding work item completes.';
+      return ' <span class="project-mode-pill project-mode-hybrid project-mode-pill-clickable"' + common + ' title="Hybrid live-validation — coding work items author in isolated worktrees; only the &quot;' + vt + '&quot; validation type(s) run in-place on the live checkout (capped to one mutating dispatch, refused on a dirty tree).' + escHtml(autoTitleBit) + ' Click to change.">⚡ Hybrid · ' + vt + escHtml(autoSuffix) + '</span>';
     }
     return ' <span class="project-mode-pill project-mode-live project-mode-pill-clickable"' + common + ' title="Live-checkout dispatch mode — agents run in-place inside the project working tree (no isolated worktree); capped to one mutating dispatch and refused on a dirty tree. Click to change.">⚡ Live checkout</span>';
   }
@@ -276,6 +284,24 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   });
   menu.appendChild(checkboxList);
 
+  // W-mr2q361a00097e5c — "auto-validate" toggle for liveValidation.autoDispatch.
+  // Default UNCHECKED to match today's implicit default (autoDispatch absent
+  // / false) so reopening the picker on a project that has never set this
+  // never silently flips it on; preselect from the project's CURRENT value
+  // when one is already configured (mirrors the type-checkbox preselect
+  // above) so reopening an already-hybrid project reflects its real state.
+  const autoDispatchRow = document.createElement('label');
+  autoDispatchRow.className = 'checkout-mode-menu-checkbox-row checkout-mode-menu-autodispatch-row';
+  const autoDispatchCb = document.createElement('input');
+  autoDispatchCb.type = 'checkbox';
+  autoDispatchCb.className = 'checkout-mode-menu-checkbox checkout-mode-menu-autodispatch-checkbox';
+  autoDispatchCb.checked = project.liveValidationAutoDispatch === true;
+  const autoDispatchText = document.createElement('span');
+  autoDispatchText.textContent = 'Automatically validate after each coding work item completes';
+  autoDispatchRow.appendChild(autoDispatchCb);
+  autoDispatchRow.appendChild(autoDispatchText);
+  menu.appendChild(autoDispatchRow);
+
   const actions = document.createElement('div');
   actions.className = 'checkout-mode-menu-actions';
 
@@ -297,8 +323,9 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
   applyBtn.addEventListener('click', function() {
     const types = checkboxes.filter(function(cb) { return cb.checked; }).map(function(cb) { return cb.value; });
     if (types.length === 0) return; // require at least one selected type
+    const autoDispatch = autoDispatchCb.checked;
     _closeCheckoutModeMenu();
-    _applyCheckoutModeChange(projectName, 'live', types);
+    _applyCheckoutModeChange(projectName, 'live', types, autoDispatch);
   });
   actions.appendChild(applyBtn);
 
@@ -316,18 +343,33 @@ function _renderCheckoutModeHybridStep(menu, projectName) {
 // whichever shape is passed through is what gets POSTed as
 // liveValidation.type, so shared.validateLiveValidation on the server decides
 // the final persisted shape.
-async function _applyCheckoutModeChange(projectName, newMode, liveValidationType) {
+//
+// `autoDispatch` (W-mr2q361a00097e5c, optional, only meaningful for hybrid
+// mode) threads the "auto-validate" checkbox value through to the POST body
+// as liveValidation.autoDispatch. Non-hybrid callers (Worktrees / full Live
+// checkout) omit it, which correctly clears autoDispatch when leaving hybrid
+// mode (liveValidation is null entirely in that case).
+async function _applyCheckoutModeChange(projectName, newMode, liveValidationType, autoDispatch) {
   const project = _findProjectInLastStatus(projectName);
   if (!project) return;
   const typesForLabel = liveValidationType
     ? (Array.isArray(liveValidationType) ? liveValidationType : [liveValidationType])
     : [];
+  const autoDispatchOn = typesForLabel.length > 0 && !!autoDispatch;
   const label = newMode === 'worktree'
     ? 'Worktrees'
     : (typesForLabel.length > 0 ? ('Hybrid (' + typesForLabel.join(', ') + ')') : 'Live checkout');
+  // W-mr2q361a00097e5c — auto-validation is a workflow-changing decision
+  // (agents stop running local builds once it's on), so call it out
+  // explicitly in the confirm message rather than burying it in the label.
+  const autoDispatchNote = typesForLabel.length > 0
+    ? (autoDispatchOn
+      ? ' Auto-validation will be turned ON — a validation work item will be dispatched automatically after each coding work item completes, and coding agents will skip local builds/tests.'
+      : ' Auto-validation will be OFF — you will need to dispatch validation manually after each coding work item completes.')
+    : '';
   const ok = await confirmDialog({
     title: 'Change checkout mode?',
-    message: 'Switch "' + projectName + '" to ' + label + '? This changes how every future dispatch on this project runs.',
+    message: 'Switch "' + projectName + '" to ' + label + '?' + autoDispatchNote + ' This changes how every future dispatch on this project runs.',
     confirmLabel: 'Change mode',
     cancelLabel: 'Cancel',
     danger: newMode !== 'worktree',
@@ -336,11 +378,13 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
 
   const prevMode = project.checkoutMode;
   const prevType = project.liveValidationType;
+  const prevAutoDispatch = project.liveValidationAutoDispatch;
   const nextType = (newMode === 'live' && liveValidationType) ? liveValidationType : null;
   // Optimistic flip BEFORE awaiting the API call (per dashboard convention —
   // see projectChipRemove / removePinnedNote); reverted in the catch below.
   project.checkoutMode = newMode;
   project.liveValidationType = nextType;
+  project.liveValidationAutoDispatch = nextType ? autoDispatchOn : false;
   if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
 
   try {
@@ -351,7 +395,7 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
         projects: [{
           name: projectName,
           checkoutMode: newMode,
-          liveValidation: nextType ? { type: nextType } : null,
+          liveValidation: nextType ? { type: nextType, autoDispatch: autoDispatchOn } : null,
         }],
       }),
     });
@@ -361,6 +405,7 @@ async function _applyCheckoutModeChange(projectName, newMode, liveValidationType
   } catch (err) {
     project.checkoutMode = prevMode;
     project.liveValidationType = prevType;
+    project.liveValidationAutoDispatch = prevAutoDispatch;
     if (window._lastStatus && Array.isArray(window._lastStatus.projects)) renderProjects(window._lastStatus.projects);
     showToast('cmd-toast', 'Failed to update checkout mode: ' + (err && err.message || err), false);
   }

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/dashboard/js/render-work-items.js

@@ -889,8 +889,6 @@ function _wiRenderDetail(item) {
   // chip is needed.
   var arts = item._artifacts || {};
   var artPills = '';
-  var branchStyle = 'display:inline-flex;align-items:center;gap:3px;padding:2px 8px;border-radius:10px;font-size:var(--text-sm);background:var(--surface2);border:1px solid var(--border);color:var(--text);cursor:default';
-  if (arts.branch) artPills += '<span style="' + branchStyle + '">🌿 ' + escapeHtml(arts.branch) + '</span> ';
   if (arts.plan) artPills += renderArtifactLink({ type: 'plan', id: arts.plan, label: 'Plan' }) + ' ';
   if (arts.prd) artPills += renderArtifactLink({ type: 'prd', id: arts.prd, label: 'PRD' }) + ' ';
   if (arts.sourcePlan) artPills += renderArtifactLink({ type: 'plan', id: arts.sourcePlan, label: 'Source Plan' }) + ' ';
@@ -915,6 +913,13 @@ function _wiRenderDetail(item) {
     });
   }
   if (artPills) html += field('Artifacts', '<div style="display:flex;flex-wrap:wrap;gap:4px">' + artPills + '</div>');
+  // Branch is not a clickable artifact link (no navigation target), so it is
+  // rendered as its own plain-text field rather than sharing the Artifacts
+  // pill row's chip styling — matches render-prs.js's PR-modal "Branch:"
+  // field (dashboard/js/render-prs.js:517), which uses a plain <code> tag
+  // instead of the clickable-chip pill style (issue: branch pill looked like
+  // a dead artifact link).
+  if (arts.branch) html += field('Branch', '🌿 <code style="font-size:var(--text-sm);background:var(--surface2);padding:2px 6px;border-radius:var(--radius-sm)">' + escapeHtml(arts.branch) + '</code>');
 
   // P-d5a6f7c4 (Harness Transparency, Stage 3 — surface). Render the harness
   // usage the agent self-reported. Shape:

package/dashboard/styles.css

@@ -1341,6 +1341,9 @@
   }
   .checkout-mode-menu-checkbox-row:hover { background: var(--surface); }
   .checkout-mode-menu-checkbox { cursor: pointer; }
+  .checkout-mode-menu-autodispatch-row {
+    margin-top: 6px; padding-top: 10px; border-top: 1px solid var(--border);
+  }
   .checkout-mode-menu-actions {
     display: flex; justify-content: flex-end; gap: 6px; padding-top: 4px;
   }

package/dashboard.js

@@ -1156,16 +1156,16 @@ function findWorkItemsTargetById(id, source, projects = PROJECTS) {
   if (explicitSource) {
     const target = resolveProjectSourceTarget(source, projects);
     if (target.error) return { error: target.error };
-    const items = shared.safeJson(target.wiPath) || [];
+    const items = shared.safeJsonArr(target.wiPath);
     return { ...target, found: items.some(i => i.id === id) };
   }
 
   const central = resolveProjectSourceTarget('central', projects);
-  const centralItems = shared.safeJson(central.wiPath) || [];
+  const centralItems = shared.safeJsonArr(central.wiPath);
   if (centralItems.some(i => i.id === id)) return { ...central, found: true };
   for (const project of projects) {
     const target = resolveProjectSourceTarget(project.name, projects);
-    const items = shared.safeJson(target.wiPath) || [];
+    const items = shared.safeJsonArr(target.wiPath);
     if (items.some(i => i.id === id)) return { ...target, found: true };
   }
   return { found: false };
@@ -2769,6 +2769,13 @@ function _buildStatusSlowState() {
         liveValidationType: (shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.type)
           ? p.liveValidation.type
           : null,
+        // W-mr2q361a00097e5c — surface liveValidation.autoDispatch alongside
+        // .type so the hybrid picker can preselect the "auto-validate"
+        // checkbox and the pill can visibly distinguish manual vs
+        // auto-validating hybrid projects. Only meaningful when checkoutMode
+        // is 'live'; false otherwise (matches the implicit today-default of
+        // autoDispatch being absent/false).
+        liveValidationAutoDispatch: !!(shared.resolveCheckoutMode(p) === 'live' && p.liveValidation && p.liveValidation.autoDispatch === true),
       };
     }),
     autoMode: {
@@ -8069,7 +8076,7 @@ const server = http.createServer(async (req, res) => {
         const config = queries.getConfig();
         const allWorkItems = queries.getWorkItems(config);
         const planWis = allWorkItems.filter(w => w.sourcePlan === body.file && w.itemType !== 'pr' && w.itemType !== 'verify');
-        const allPrs = PROJECTS.flatMap(p => shared.safeJson(shared.projectPrPath(p)) || []);
+        const allPrs = PROJECTS.flatMap(p => shared.safeJsonArr(shared.projectPrPath(p)));
         const prLinks = shared.getPrLinks();
         const implContext = (plan.missing_features || []).map(f => {
           const wi = planWis.find(w => w.id === f.id);
@@ -11004,7 +11011,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
   async function handleSettingsUpdate(req, res) {
     try {
       const body = await readBody(req);
-      const config = safeJson(CONFIG_PATH) || {};
+      const config = safeJsonObj(CONFIG_PATH);
       if (!config.engine) config.engine = {};
       if (!config.agents) config.agents = {};
       shared.pruneDefaultClaudeConfig(config);
@@ -13298,7 +13305,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
           // (Round-2 review finding #3.)
           const cfg = queries.getConfig() || {};
           const scheds = cfg.schedules || [];
-          const runs = shared.safeJson(path.join(ENGINE_DIR, 'schedule-runs.json')) || {};
+          const runs = shared.safeJsonObj(path.join(ENGINE_DIR, 'schedule-runs.json'));
           return scheds.map(s => {
             const runEntry = runs[s.id];
             const _lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || runEntry?.lastCompletedAt || null);
@@ -13507,7 +13514,7 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     // KB pin state (server-side so CC can pin items)
     { method: 'GET', path: '/api/kb-pins', desc: 'Get pinned KB item keys', handler: async (req, res) => {
-      const pins = shared.safeJson(KB_PINS_PATH) || [];
+      const pins = shared.safeJsonArr(KB_PINS_PATH);
       return jsonReply(res, 200, { pins });
     }},
     { method: 'POST', path: '/api/kb-pins', desc: 'Set pinned KB item keys', params: 'pins[]', handler: async (req, res) => {

package/engine/cleanup.js

@@ -736,7 +736,8 @@ async function runCleanup(config, verbose = false) {
         // claims it.
         if (shared.isWorktreePathLive(full)) {
           log('info', `Cleanup: skip orphan worktree dir ${full} — live dispatch claims it`);
-          shared._writeWorktreeSkipLiveInboxNote(full, 'cleanup.orphanWorktreeDirSweep');
+          const blockingInfo = shared.getWorktreeBlockingDispatchInfo(full);
+          shared._writeWorktreeSkipLiveInboxNote(full, 'cleanup.orphanWorktreeDirSweep', blockingInfo);
           continue;
         }
         try {

package/engine/lifecycle.js

@@ -2647,6 +2647,122 @@ 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();
+  // Human-teammate follow-up on #639/#640: once the automation is actually
+  // PAUSED here (multiple ineffective attempts against the same unchanged
+  // head, with live CI re-confirmed still red), a generic "no-op" label
+  // undersells what's going on — repeated fixes aren't landing, which is a
+  // much stronger signal of an environment/CI infra problem than a code
+  // issue. `label` is the short, canonical diagnostic tag; it stays `null`
+  // while attempts are still accumulating (not yet paused) so callers can
+  // tell "still trying" apart from "give up on code fixes, check infra".
+  // Surfaced on every consumer of this record: the PR record field itself
+  // (`label`, plus `reason` below), the pause inbox alert, and the dashboard
+  // chip (dashboard/js/render-prs.js already renders "infra issue suspected"
+  // for `paused === true` — kept in sync with this same wording here).
+  const label = paused ? 'infra issue suspected' : null;
+  const shortHead = String(headSha || '').slice(0, 12);
+  const reason = paused
+    ? `infra issue suspected — build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${shortHead} after ${count} consecutive ineffective attempt(s)`
+    : `build-fix reported no branch change but live CI is still ${liveBuildStatus || 'failing'} on head ${shortHead}`;
+  target._buildFixIneffective = {
+    count,
+    paused,
+    label,
+    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 — infra issue suspected: ${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`
+        + `**Infra issue suspected:** ${count} fix dispatches in a row landed on this head without moving it, and CI is still red. This pattern usually means the failure isn't fixable by another automated code-fix pass (flaky infra, an external outage, a broken pipeline/runner, a protected-branch or permissions issue, etc.) rather than a code bug — investigate the CI environment before re-dispatching.\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 +3108,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 — infra issue suspected)' : ''}`);
+        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 +3154,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 +5865,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 +5873,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 +6015,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       automationCauseKey: meta?.automationCauseKey,
       dispatchItem,
       branchChange: prFixBranchChange,
+      buildStillFailing: prFixBuildStillFailing,
       config,
       noopReason: noopRationale || meta?._noopReason || '',
     });
@@ -6666,6 +6828,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/queries.js

@@ -11,7 +11,7 @@ const os = require('os');
 const shared = require('./shared');
 const steering = require('./steering');
 
-const { safeRead, safeReadDir, safeJson, safeWrite, getProjects, mutateJsonFileLocked,
+const { safeRead, safeReadDir, safeJson, safeJsonObj, safeWrite, getProjects, mutateJsonFileLocked,
   projectWorkItemsPath, projectPrPath, parseSkillFrontmatter, KB_CATEGORIES,
   WI_STATUS, DONE_STATUSES, WORK_TYPE, PRD_ITEM_STATUS, PR_STATUS, ENGINE_DEFAULTS, DEFAULT_AGENT_METRICS } = shared;
 
@@ -221,7 +221,7 @@ function migrateDeprecatedConfigPollKeysOnce() {
 
 function getConfig() {
   migrateDeprecatedConfigPollKeysOnce();
-  return safeJson(CONFIG_PATH) || {};
+  return safeJsonObj(CONFIG_PATH);
 }
 
 function getControl() {

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.
@@ -8758,11 +8776,60 @@ function isWorktreePathLive(worktreePath, opts = {}) {
   return false;
 }
 
+// P-1d6b1aa7 — separate, best-effort lookup of the specific dispatch row
+// that is blocking a wipe, so callers can fold self-diagnosing detail (id,
+// status, age-in-non-terminal-state) into the skip-live inbox note instead
+// of forcing a human to run a follow-up SQL query against
+// engine/state.db every time W-mq5rwwss000f30a7 recurs. Deliberately kept
+// separate from isWorktreePathLive so that helper's fail-open boolean
+// contract (and its existing callers/tests) are untouched — this is an
+// additional, purely-diagnostic query run only after the guard has already
+// fired. Any failure here (SQL unavailable, no matching row, etc.) resolves
+// to `null` and the note falls back to an "unavailable" label; it must
+// never throw or change wipe/skip behavior.
+function getWorktreeBlockingDispatchInfo(worktreePath, opts = {}) {
+  try {
+    const target = _normalizeWorktreePath(worktreePath);
+    if (!target) return null;
+    const excludeDispatchId = opts.excludeDispatchId ? String(opts.excludeDispatchId) : null;
+    let db = opts.db || null;
+    if (!db) {
+      try { db = require('./db').getDb(); }
+      catch { return null; }
+    }
+    if (!db) return null;
+    const rows = db.prepare(`
+      SELECT id, status, updated_at,
+             json_extract(data, '$.worktreePath') AS top_wt,
+             json_extract(data, '$.meta.worktreePath') AS meta_wt
+      FROM dispatches
+      WHERE status IN ('pending', 'active')
+    `).all();
+    for (const row of rows || []) {
+      if (excludeDispatchId && String(row.id) === excludeDispatchId) continue;
+      const topMatch = row.top_wt && _normalizeWorktreePath(row.top_wt) === target;
+      const metaMatch = row.meta_wt && _normalizeWorktreePath(row.meta_wt) === target;
+      if (topMatch || metaMatch) {
+        const updatedAt = Number(row.updated_at) || 0;
+        const ageMs = updatedAt > 0 ? Math.max(0, Date.now() - updatedAt) : null;
+        return { id: row.id, status: row.status, ageMs };
+      }
+    }
+    return null;
+  } catch {
+    return null; // best-effort diagnostics only — never throw
+  }
+}
+
 // Drop a deduped inbox note when a wipe site skips due to the live guard so
 // operators can see when the guard fires. Filename is keyed on basename +
 // UTC date — a single skip per worktree per day produces one note; further
-// skips that day silently no-op.
-function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
+// skips that day silently no-op. `blockingInfo` (optional, shape
+// `{ id, status, ageMs }` from getWorktreeBlockingDispatchInfo) folds the
+// blocking dispatch's diagnostics into the note body so it is
+// self-diagnosing; when unavailable (no matching row, SQL unreachable,
+// etc.) the note says so explicitly instead of requiring a follow-up query.
+function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag, blockingInfo) {
   try {
     const base = path.basename(String(worktreePath || '').replace(/[\\/]+$/g, '')) || 'unknown';
     const safeBase = base.replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 80);
@@ -8772,6 +8839,13 @@ function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
     try { fs.mkdirSync(inboxDir, { recursive: true }); } catch { /* exists */ }
     const fpath = path.join(inboxDir, fname);
     if (fs.existsSync(fpath)) return; // deduped
+    const diagnosticsLines = (blockingInfo && blockingInfo.id)
+      ? [
+        `- blocking dispatch id: ${blockingInfo.id}`,
+        `- blocking dispatch status: ${blockingInfo.status || 'unknown'}`,
+        `- blocking dispatch age: ${blockingInfo.ageMs != null ? `${Math.round(blockingInfo.ageMs / 1000)}s since last update` : 'unavailable'}`,
+      ]
+      : ['- blocking dispatch diagnostics: unavailable (no matching row found, or SQL was unreachable)'];
     const body = [
       '---',
       `id: NOTE-${crypto.randomBytes(8).toString('hex')}`,
@@ -8784,6 +8858,7 @@ function _writeWorktreeSkipLiveInboxNote(worktreePath, callerTag) {
       `- caller: ${callerTag || 'unknown'}`,
       `- worktree: ${worktreePath}`,
       `- timestamp: ${new Date().toISOString()}`,
+      ...diagnosticsLines,
       '',
       'A non-terminal dispatch row still claims this worktree. The wipe was skipped to',
       'protect agent state. If this fires repeatedly, inspect engine/state.db dispatches',
@@ -8863,7 +8938,8 @@ function removeWorktree(wtPath, gitRoot, worktreeRoot, opts = {}) {
   const excludeDispatchId = opts && opts.excludeDispatchId ? String(opts.excludeDispatchId) : null;
   if (isWorktreePathLive(resolved, excludeDispatchId ? { excludeDispatchId } : undefined)) {
     log('warn', `removeWorktree: skip — live dispatch in ${wtPath}`);
-    _writeWorktreeSkipLiveInboxNote(wtPath, 'shared.removeWorktree');
+    const blockingInfo = getWorktreeBlockingDispatchInfo(resolved, excludeDispatchId ? { excludeDispatchId } : undefined);
+    _writeWorktreeSkipLiveInboxNote(wtPath, 'shared.removeWorktree', blockingInfo);
     return false;
   }
   _pruneRemoveWorktreeFailures();
@@ -9460,6 +9536,7 @@ module.exports = {
   getPrNoOpFixRecord,
   isPrNoOpFixCausePaused,
   getPrPausedCauses,
+  isBuildFixIneffectivePaused,
   parseSkillFrontmatter,
   sleepMs,
   killGracefully,
@@ -9477,6 +9554,7 @@ module.exports = {
   listProcessReachable,
   removeWorktree,
   isWorktreePathLive,
+  getWorktreeBlockingDispatchInfo,
   WORKTREE_OWNER_MARKER,
   writeWorktreeOwnerMarker,
   hasWorktreeOwnerMarker,

package/engine.js

@@ -1697,7 +1697,8 @@ async function _quarantineDirtyWorktree(rootDir, worktreePath, branchName, gitOp
   // agent's git child processes either.
   if (shared.isWorktreePathLive(worktreePath)) {
     log('warn', `_quarantineDirtyWorktree: skip — live dispatch in ${worktreePath}`);
-    shared._writeWorktreeSkipLiveInboxNote(worktreePath, '_quarantineDirtyWorktree');
+    const blockingInfo = shared.getWorktreeBlockingDispatchInfo(worktreePath);
+    shared._writeWorktreeSkipLiveInboxNote(worktreePath, '_quarantineDirtyWorktree', blockingInfo);
     return { quarantinedPath: null, backupRef: null, skipped: true };
   }
 
@@ -6619,6 +6620,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 +7343,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.2314",
   "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"