@yemi33/minions 0.1.2039 → 0.1.2041

package/dashboard/js/settings.js

@@ -98,7 +98,7 @@ async function openSettings() {
       settingsToggle('Allow Temp Agents', 'set-allowTempAgents', !!e.allowTempAgents, 'Spawn ephemeral agents when all permanent agents are busy') +
       settingsToggle('Auto-archive Plans', 'set-autoArchive', !!e.autoArchive, 'Automatically archive plans after verify completes (off = manual archive via dashboard)') +
       settingsToggle('Auto-complete PRs', 'set-autoCompletePrs', !!e.autoCompletePrs, 'Auto-merge PRs when builds pass and review is approved (opt-in)') +
-      settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', (e.ccUseWorkerPool === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Default ON for copilot runtime (cold-spawn is ~20s on Windows); default OFF for claude.') +
+      settingsToggle('CC Worker Pool', 'set-ccUseWorkerPool', (e.ccUseWorkerPool === undefined ? ((e.ccCli || e.defaultCli) === 'copilot') : !!e.ccUseWorkerPool), 'Route Command Center / doc-chat through a persistent copilot --acp worker per tab instead of spawning a fresh CLI per turn. Copilot-only (Agent Client Protocol transport); Claude does not implement ACP, so this toggle has no effect when CC runtime is Claude. Default ON for copilot (cold-spawn ~20s on Windows); forced OFF for non-copilot CC runtimes regardless of this toggle.') +
     '</div>' +
 
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">PR Polling &amp; Dispatch Gates</h3>' +

package/engine/features.js

@@ -35,14 +35,23 @@ const FEATURES = {
   // ccUseWorkerPool — sub-tasks B/C/D of W-mp2w003600196c51 (CC perf).
   // Routes Command Center / doc-chat through engine/cc-worker-pool.js
   // (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI
-  // per turn. Saves ~14 s of cold-start cost. Copilot-only — the pool drives
-  // ACP which Claude does not implement.
+  // per turn. Saves ~14 s of cold-start cost.
+  //
+  // **Copilot-only — structural, not just a UX preference.** The pool's
+  // transport is Agent Client Protocol (JSON-RPC over stdin/stdout, framed
+  // initialize → session/new → session/prompt → session/update). Claude Code
+  // has no equivalent `--acp` mode; its only session-reuse path is
+  // per-invocation `--resume <id>` against `~/.claude/projects/<dir>/<id>.jsonl`.
+  // Honoring this flag on a Claude CC runtime would silently switch the
+  // operator's CC turns to copilot — see `shared.resolveCcUseWorkerPool`
+  // which now refuses the override when CC runtime is not copilot
+  // (W-mphlriic00095f69).
   //
   // Resolution: `shared.resolveCcUseWorkerPool(engine)` (engine/shared.js)
   // is the canonical predicate every dashboard.js call site uses. Explicit
-  // `engine.ccUseWorkerPool` true/false in config wins; otherwise the helper
-  // defaults ON for `copilot` and OFF for `claude`. PR #2492 flipped the
-  // default ON for copilot; see that PR for the cold-spawn measurements.
+  // `engine.ccUseWorkerPool` true/false in config wins ONLY when CC runtime
+  // is copilot; otherwise the helper forces `false`. PR #2492 flipped the
+  // copilot default ON; see that PR for the cold-spawn measurements.
   //
   // `requiredCcRuntime: 'copilot'` here is a UX hint — the Settings panel
   // greys out the toggle when the resolved CC runtime mismatches so users

package/engine/shared.js

@@ -1865,7 +1865,7 @@ const ENGINE_DEFAULTS = {
   copilotSuppressAgentsMd: true,     // Copilot --no-custom-instructions: stop AGENTS.md auto-load from fighting Minions playbook prompts
   copilotStreamMode: 'on',           // Copilot --stream <on|off>: 'on' streams assistant.message_delta events live; 'off' batches them
   copilotReasoningSummaries: false,  // Copilot --enable-reasoning-summaries (Anthropic-family models only)
-  ccUseWorkerPool: false,            // Sub-task C of W-mp2w003600196c51 (CC perf): when true, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. Off by default — opt-in feature flag. Engine/agent dispatch path stays per-process regardless.
+  ccUseWorkerPool: false,            // Sub-task C of W-mp2w003600196c51 (CC perf): when true AND CC runtime is copilot, _invokeCcStream routes through engine/cc-worker-pool.js (persistent `copilot --acp` per CC tab) instead of spawning a fresh CLI per turn. Off by default — opt-in feature flag. **Structurally copilot-only**: the pool spawns `copilot --acp` (Agent Client Protocol); Claude Code does not implement ACP, so resolveCcUseWorkerPool returns false on non-copilot CC runtimes even with explicit-true (W-mphlriic00095f69 — prevents silent runtime switch). Engine/agent dispatch path stays per-process regardless.
   maxBudgetUsd: undefined,       // fleet USD ceiling for --max-budget-usd (per-agent override: agents.<id>.maxBudgetUsd). Honors 0 via ?? so a literal cap of $0 works
   disableModelDiscovery: false,  // skip runtime.listModels() REST calls fleet-wide (settings UI falls back to free-text)
   maxPendingContexts: 20, // cap pendingContexts arrays in cooldowns.json to prevent unbounded growth
@@ -2097,22 +2097,31 @@ function resolveCcCli(engine) {
 /**
  * Resolve whether the Command Center / doc-chat path should route through the
  * persistent ACP worker pool. Priority:
- *   1. `engine.ccUseWorkerPool` explicit true/false — operator override always wins
- *   2. Runtime-aware default: ON when CC runtime resolves to `copilot`
+ *   1. CC runtime guard — pool spawns `copilot --acp` (Agent Client Protocol).
+ *      Claude Code does not implement ACP, and `_invokeCcStream` would silently
+ *      switch a Claude operator's CC turns to copilot if the pool ran for them.
+ *      Refuse the pool when CC runtime is not copilot, even if explicit-true is
+ *      set. Future runtimes that don't implement ACP fall into the same bucket.
+ *      (W-mphlriic00095f69)
+ *   2. `engine.ccUseWorkerPool` explicit true/false — operator override wins
+ *      *within* the copilot runtime
+ *   3. Runtime-aware default: ON when CC runtime resolves to `copilot`
  *      (Copilot's cold-spawn is 18-21s on Windows — pool turns subsequent turns
- *      from 47-140s back into a few seconds). Claude's cold-spawn is much
- *      cheaper and the ACP pool wasn't designed for it, so it stays OFF there.
- *   3. ENGINE_DEFAULTS.ccUseWorkerPool — final fallback
+ *      from 47-140s back into a few seconds).
+ *   4. ENGINE_DEFAULTS.ccUseWorkerPool — final fallback
  *
  * Strict boolean check on the override so a literal `false` opts out even on
  * Copilot, matching `_isMeaningful` semantics for boolean flags.
  */
 function resolveCcUseWorkerPool(engine) {
+  // Guard 1 (W-mphlriic00095f69): pool transport is ACP-only. If CC runtime
+  // isn't copilot, the pool cannot run regardless of operator opt-in — don't
+  // silently switch their runtime to copilot.
+  if (resolveCcCli(engine) !== 'copilot') return false;
   if (engine && (engine.ccUseWorkerPool === true || engine.ccUseWorkerPool === false)) {
     return engine.ccUseWorkerPool;
   }
-  if (resolveCcCli(engine) === 'copilot') return true;
-  return !!ENGINE_DEFAULTS.ccUseWorkerPool;
+  return true; // CC runtime is copilot — default ON (cold-start savings)
 }
 
 /**

package/engine.js

@@ -698,6 +698,35 @@ async function runWorktreeAdd(rootDir, worktreePath, addArgs, gitOpts, worktreeC
   if (lastErr) throw lastErr;
 }
 
+// W-mphnm6a1000281b8: probe whether origin already advertises a head for
+// `branchName`. Used by the fresh-create worktree path to choose between
+// `git worktree add <path> <branch>` (checkout, local-track origin) and
+// `git worktree add -b <branch> origin/<mainRef>` (fresh branch off main).
+// Without this probe, PR-targeted fix/review/test/verify dispatches whose
+// source branch is N commits ahead of main upstream (mirror branches like
+// `sync/yemi33-master`, force-pushed PR branches) start their worktree on
+// origin/<mainRef>; the stale-HEAD guard at the top of spawn-agent then
+// trips on every dispatch and the cooldown machinery starves the PR.
+//
+// Returns true only on a confirmed advertised head; ls-remote exit code 2
+// (no matching ref) and any other failure (network/auth) return false so
+// the caller falls back to the existing `-b origin/<mainRef>` path.
+async function probeBranchOnRemote(rootDir, branchName, gitOpts) {
+  if (!branchName || !rootDir) return false;
+  try {
+    await shared.shellSafeGit(
+      ['ls-remote', '--exit-code', '--heads', 'origin', branchName],
+      { ...gitOpts, cwd: rootDir, timeout: 10000 },
+    );
+    return true;
+  } catch (e) {
+    if (e && e.code !== 2) {
+      log('warn', `probeBranchOnRemote: ls-remote --heads origin ${branchName} failed: ${(e.message || '').split('\n')[0].slice(0, 200)} — treating as not-on-remote`);
+    }
+    return false;
+  }
+}
+
 // Detect and remove worktree registrations whose backing directory is missing
 // on disk. `git worktree add` fails with "branch is already used by worktree
 // at <path>" when a prior crash left such an entry behind, sometimes still in
@@ -1188,84 +1217,143 @@ async function spawnAgent(dispatchItem, config) {
           } else {
             log('info', `Creating worktree: ${worktreePath} on branch ${branchName}`);
             const mainRef = sanitizeBranch(shared.resolveMainBranch(rootDir, project.mainBranch));
-            // W-mph6n4p00006ce38: mirror the pool-borrow path (~line 1110-1114)
-            // — fetch fresh origin/<mainRef> and start the new branch off it,
-            // not the local ref. Without this, fresh-create dispatches inherit
-            // whatever stale local master the engine clone happens to be on
-            // (most painful: long-lived engine processes between restarts).
-            // Non-fatal: if the fetch fails (network blip, transient auth),
-            // fall back to local mainRef so the dispatch still progresses;
-            // the dep-merge phase's own fetch + the on-failure
-            // `git reset --hard origin/<mainRef>` recovery remain as safety nets.
-            let _freshCreateBase = mainRef;
-            try {
-              await shared.shellSafeGit(['fetch', 'origin', mainRef], { ..._gitOpts, cwd: rootDir, timeout: 30000 });
-              _freshCreateBase = `origin/${mainRef}`;
-            } catch (mainFetchErr) {
-              log('warn', `Failed to fetch origin/${mainRef} before fresh-create worktree for ${branchName}: ${mainFetchErr.message} — falling back to local ${mainRef}`);
-            }
-            try {
-              await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, worktreeCreateRetries);
-            } catch (e1) {
-              const branchExists = e1.message?.includes('already exists');
-              log('warn', `Worktree -b failed for ${branchName}: ${e1.message?.split('\n')[0]}`);
-              if (!branchExists) {
-                // Transient error (lock, timeout) — prune, clean, and retry -b once more
-                log('info', `Retrying -b create after prune for ${branchName}`);
-                try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
-                removeStaleIndexLock(rootDir);
-                // Clean up partial worktree directory from failed attempt
-                try { if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true }); } catch { /* optional */ }
-                try {
-                  await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, 0);
-                } catch (e1b) {
-                  log('error', `Worktree -b retry also failed for ${branchName}: ${e1b.message?.split('\n')[0]}`);
-                  throw e1b;
-                }
-              } else {
-                // Branch already exists — try checkout without -b
-                try { await shared.shellSafeGit(['fetch', 'origin', branchName], { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
-                try {
-                  await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
-                  log('info', `Reusing existing branch: ${branchName}`);
-                } catch (e2) {
-                  // "already checked out" or "already used by worktree" — find and reuse or recover
-                  const alreadyUsed = e2.message?.includes('already checked out') || e2.message?.includes('already used by worktree')
-                    || e1.message?.includes('already checked out') || e1.message?.includes('already used by worktree');
-                  if (alreadyUsed) {
-                    const existingWtPath = await findExistingWorktree(rootDir, branchName);
-                    if (existingWtPath && fs.existsSync(existingWtPath)) {
-                      // Bug fix: read dispatch under file lock so check-and-act is atomic
-                      let activelyUsed = false;
-                      mutateDispatch((dp) => {
-                        activelyUsed = (dp.active || []).some(d => {
-                          const dBranch = d.meta?.branch ? sanitizeBranch(d.meta.branch) : '';
-                          return dBranch === branchName && d.id !== id;
-                        });
-                        return dp;
+
+            // W-mphnm6a1000281b8: probe whether origin already has this branch.
+            // If yes, prefer `git worktree add <path> <branch>` (checkout +
+            // local-track origin/<branch>) over `-b <branch> origin/<mainRef>`.
+            // The shared-branch path (~line 1158) already does this. PR-targeted
+            // fix/review/test/verify dispatches hit this path with branchName =
+            // the PR's source branch; branching off main when the PR branch is
+            // N commits ahead upstream guarantees the stale-HEAD guard
+            // (~line 1777) trips and the dispatch errors. Live repro:
+            // opg-microsoft/minions PR #57 (sync/yemi33-master, 109 commits
+            // ahead of main) — two consecutive fix dispatches errored on
+            // STALE_HEAD over 10 min and the engine then starved the PR for
+            // the cooldown window (60 min effective).
+            const _branchOnRemote = await probeBranchOnRemote(rootDir, branchName, _gitOpts);
+
+            if (_branchOnRemote) {
+              // Mirror shared-branch fetch+add (~line 1157-1159).
+              log('info', `origin/${branchName} exists — checking out remote branch instead of -b from ${mainRef}`);
+              try { await shared.shellSafeGit(['fetch', 'origin', branchName], { ..._gitOpts, cwd: rootDir, timeout: 30000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+              try {
+                await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
+              } catch (eRemote) {
+                const alreadyUsed = eRemote.message?.includes('already used by worktree') || eRemote.message?.includes('already checked out');
+                if (alreadyUsed) {
+                  const existingWtPath = await findExistingWorktree(rootDir, branchName);
+                  if (existingWtPath && fs.existsSync(existingWtPath)) {
+                    let activelyUsed = false;
+                    mutateDispatch((dp) => {
+                      activelyUsed = (dp.active || []).some(d => {
+                        const dBranch = d.meta?.branch ? sanitizeBranch(d.meta.branch) : '';
+                        return dBranch === branchName && d.id !== id;
                       });
-                      if (activelyUsed) {
-                        log('warn', `Branch ${branchName} actively used by another agent at ${existingWtPath} — cannot create worktree`);
-                        throw e2;
-                      }
-                      try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
-                      catch (assertErr) {
-                        if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
-                        throw assertErr;
+                      return dp;
+                    });
+                    if (activelyUsed) {
+                      log('warn', `Branch ${branchName} actively used by another agent at ${existingWtPath} — cannot create worktree`);
+                      throw eRemote;
+                    }
+                    try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
+                    catch (assertErr) {
+                      if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
+                      throw assertErr;
+                    }
+                    log('info', `Branch ${branchName} already checked out at ${existingWtPath} — reusing`);
+                    worktreePath = existingWtPath;
+                  } else {
+                    const pruned = await pruneStaleWorktreeForBranch(rootDir, branchName, _gitOpts);
+                    if (pruned > 0) {
+                      log('info', `Pruned ${pruned} stale worktree entry(ies) for ${branchName}; retrying worktree add`);
+                      await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, 0);
+                    } else { throw eRemote; }
+                  }
+                } else { throw eRemote; }
+              }
+            } else {
+              // Branch isn't on origin (or probe failed) — start a fresh local
+              // branch from origin/<mainRef>. This is the dominant path for new
+              // implement/decompose dispatches.
+              // W-mph6n4p00006ce38: mirror the pool-borrow path (~line 1110-1114)
+              // — fetch fresh origin/<mainRef> and start the new branch off it,
+              // not the local ref. Without this, fresh-create dispatches inherit
+              // whatever stale local master the engine clone happens to be on
+              // (most painful: long-lived engine processes between restarts).
+              // Non-fatal: if the fetch fails (network blip, transient auth),
+              // fall back to local mainRef so the dispatch still progresses;
+              // the dep-merge phase's own fetch + the on-failure
+              // `git reset --hard origin/<mainRef>` recovery remain as safety nets.
+              let _freshCreateBase = mainRef;
+              try {
+                await shared.shellSafeGit(['fetch', 'origin', mainRef], { ..._gitOpts, cwd: rootDir, timeout: 30000 });
+                _freshCreateBase = `origin/${mainRef}`;
+              } catch (mainFetchErr) {
+                log('warn', `Failed to fetch origin/${mainRef} before fresh-create worktree for ${branchName}: ${mainFetchErr.message} — falling back to local ${mainRef}`);
+              }
+              try {
+                await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, worktreeCreateRetries);
+              } catch (e1) {
+                const branchExists = e1.message?.includes('already exists');
+                log('warn', `Worktree -b failed for ${branchName}: ${e1.message?.split('\n')[0]}`);
+                if (!branchExists) {
+                  // Transient error (lock, timeout) — prune, clean, and retry -b once more
+                  log('info', `Retrying -b create after prune for ${branchName}`);
+                  try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 15000 }); } catch { /* optional */ }
+                  removeStaleIndexLock(rootDir);
+                  // Clean up partial worktree directory from failed attempt
+                  try { if (fs.existsSync(worktreePath)) fs.rmSync(worktreePath, { recursive: true, force: true }); } catch { /* optional */ }
+                  try {
+                    await runWorktreeAdd(rootDir, worktreePath, ['-b', branchName, _freshCreateBase], _worktreeGitOpts, 0);
+                  } catch (e1b) {
+                    log('error', `Worktree -b retry also failed for ${branchName}: ${e1b.message?.split('\n')[0]}`);
+                    throw e1b;
+                  }
+                } else {
+                  // Branch already exists — try checkout without -b
+                  try { await shared.shellSafeGit(['fetch', 'origin', branchName], { ..._gitOpts, cwd: rootDir }); } catch (e) { log('warn', 'git: ' + e.message); }
+                  try {
+                    await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
+                    log('info', `Reusing existing branch: ${branchName}`);
+                  } catch (e2) {
+                    // "already checked out" or "already used by worktree" — find and reuse or recover
+                    const alreadyUsed = e2.message?.includes('already checked out') || e2.message?.includes('already used by worktree')
+                      || e1.message?.includes('already checked out') || e1.message?.includes('already used by worktree');
+                    if (alreadyUsed) {
+                      const existingWtPath = await findExistingWorktree(rootDir, branchName);
+                      if (existingWtPath && fs.existsSync(existingWtPath)) {
+                        // Bug fix: read dispatch under file lock so check-and-act is atomic
+                        let activelyUsed = false;
+                        mutateDispatch((dp) => {
+                          activelyUsed = (dp.active || []).some(d => {
+                            const dBranch = d.meta?.branch ? sanitizeBranch(d.meta.branch) : '';
+                            return dBranch === branchName && d.id !== id;
+                          });
+                          return dp;
+                        });
+                        if (activelyUsed) {
+                          log('warn', `Branch ${branchName} actively used by another agent at ${existingWtPath} — cannot create worktree`);
+                          throw e2;
+                        }
+                        try { shared.assertWorktreeOutsideProject(existingWtPath, rootDir); }
+                        catch (assertErr) {
+                          if (assertErr?.code === 'WORKTREE_NESTED_IN_PROJECT') { _failWorktreePreflight(assertErr); return null; }
+                          throw assertErr;
+                        }
+                        log('info', `Branch ${branchName} already checked out at ${existingWtPath} — reusing`);
+                        worktreePath = existingWtPath;
+                      } else if (existingWtPath && !fs.existsSync(existingWtPath)) {
+                        log('warn', `Branch ${branchName} tracked in missing dir ${existingWtPath} — pruning and recreating`);
+                        try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+                        await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
+                        log('info', `Recovered worktree for ${branchName} after stale entry prune`);
+                      } else {
+                        try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
+                        await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
                       }
-                      log('info', `Branch ${branchName} already checked out at ${existingWtPath} — reusing`);
-                      worktreePath = existingWtPath;
-                    } else if (existingWtPath && !fs.existsSync(existingWtPath)) {
-                      log('warn', `Branch ${branchName} tracked in missing dir ${existingWtPath} — pruning and recreating`);
-                      try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-                      await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
-                      log('info', `Recovered worktree for ${branchName} after stale entry prune`);
                     } else {
-                      try { await shared.shellSafeGit(['worktree', 'prune'], { ..._gitOpts, cwd: rootDir, timeout: 10000 }); } catch (e) { log('warn', 'git: ' + e.message); }
-                      await runWorktreeAdd(rootDir, worktreePath, [branchName], _worktreeGitOpts, worktreeCreateRetries);
+                      throw e2;
                     }
-                  } else {
-                    throw e2;
                   }
                 }
               }
@@ -4502,29 +4590,48 @@ async function discoverFromPrs(config, project) {
       && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.REVIEW_FEEDBACK)) {
       const reviewCauseKey = getPrAutomationCauseKey('review-feedback', pr);
       const key = getPrAutomationDispatchKey(`fix-${project?.name || 'default'}-${prDisplayId}`, reviewCauseKey);
-      if (isPrAutomationCauseHandledOrPending(project, pr, reviewCauseKey)) continue;
-      if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
-      const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
-      if (!agentId) continue;
-      const prBranch = ensurePrBranchForDispatch(project, pr, 'fix');
-      if (!prBranch) continue;
-
-      const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
-        pr_id: pr.id, pr_branch: prBranch,
-        review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
-      }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, {
-        dispatchKey: key, cooldownKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta,
-        // W-mpg58wv3 — closure-loop binding. Carries the originating minion review
-        // WI id (and any ADO thread ids it cited) onto the fix WI so the
-        // post-completion path in lifecycle.js can auto-dispatch a re-review
-        // against the same PR. Both fields fall through to null/[] when the
-        // upstream review didn't expose them.
-        addresses_review_wi: pr.minionsReview?.sourceItem || null,
-        addresses_threads: Array.isArray(pr.minionsReview?.threads) ? pr.minionsReview.threads.slice() : [],
-      });
-      if (item) {
-        newWork.push(item); fixDispatched = true;
-      }
+      // W-mphnm6a1000281b8: cause-local skip mirroring the human-feedback
+      // (#2632) and build-failure (#2632 audit) guards above. A previous bare
+      // `continue` here aborted the entire PR iteration when the
+      // review-feedback dispatch was throttled, on cooldown, or already
+      // dispatched — starving the build-fix and conflict-fix blocks below
+      // even though their own dedupe keys had not been hit. Live repro on
+      // opg-microsoft/minions PR #57: two STALE_HEAD-errored review-feedback
+      // dispatches stamped a 60-min effective cooldown, and the PR received
+      // zero build-fix dispatches for the rest of the cooldown window even
+      // though buildStatus stayed `failing` and the build-fix key was clean.
+      // Skip ONLY this cause; let iteration fall through to downstream
+      // blocks (re-review already ran above; build-fix + conflict-fix run
+      // below).
+      const skipReviewFeedback =
+        isPrAutomationCauseHandledOrPending(project, pr, reviewCauseKey)
+        || fixThrottled
+        || isAlreadyDispatched(key)
+        || isOnCooldown(key, cooldownMs);
+      if (!skipReviewFeedback) {
+        const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
+        if (agentId) {
+          const prBranch = ensurePrBranchForDispatch(project, pr, 'fix');
+          if (prBranch) {
+            const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
+              pr_id: pr.id, pr_branch: prBranch,
+              review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
+            }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, {
+              dispatchKey: key, cooldownKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta,
+              // W-mpg58wv3 — closure-loop binding. Carries the originating minion review
+              // WI id (and any ADO thread ids it cited) onto the fix WI so the
+              // post-completion path in lifecycle.js can auto-dispatch a re-review
+              // against the same PR. Both fields fall through to null/[] when the
+              // upstream review didn't expose them.
+              addresses_review_wi: pr.minionsReview?.sourceItem || null,
+              addresses_threads: Array.isArray(pr.minionsReview?.threads) ? pr.minionsReview.threads.slice() : [],
+            });
+            if (item) {
+              newWork.push(item); fixDispatched = true;
+            }
+          }
+        }
+      } // end if (!skipReviewFeedback) — cause-local guard for W-mphnm6a1000281b8
     }
 
     // PRs with build failures — route to author (has session context from implementing)
@@ -6872,6 +6979,7 @@ module.exports = {
   isWorktreeRetryableError, removeStaleIndexLock, syncReusedWorktree, assertCleanSharedWorktree, // exported for testing
   pruneStaleWorktreeForBranch, // exported for testing
   findExistingWorktree, // exported for testing
+  probeBranchOnRemote, // exported for testing (W-mphnm6a1000281b8)
   _maxTurnsForType, buildProjectContext, normalizeAc, _buildAgentSpawnFlags, _classifyAgentFailure, // exported for testing
   promoteCheckpointSteeringForClose, // exported for testing
   normalizePrBranch, resolvePrBranch, prCausePart, getPrCauseHead, getPrCauseBase, getPrAutomationCauseKey, getPrAutomationDispatchKey, // exported for testing

package/package.json

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