@yemi33/minions 0.1.2040 → 0.1.2041

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.2040",
+  "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"