@yemi33/minions 0.1.2021 → 0.1.2023

package/dashboard/js/refresh.js

@@ -152,8 +152,19 @@ function _processStatusUpdate(data) {
   var _workItemsChanged = _changed('workItems', data.workItems);
   if (_prsChanged) renderPrs(data.pullRequests || []);
   if (_changed('archivedPrds', data.archivedPrds)) renderArchiveButtons(data.archivedPrds || []);
+  // renderEngineStatus is NOT gated by _changed('engine'): heartbeat
+  // staleness is wall-clock-relative (Date.now() - engine.heartbeat), so
+  // even when the snapshot bytes are byte-for-byte identical between polls
+  // (e.g. control.json mtime is intentionally excluded from the fast-state
+  // mtime tracker — see engine/queries.js#getStatusFastStateMtimePaths)
+  // the staleness verdict can flip both directions purely from time
+  // passing. Gating the call made the STALE banner stick after a CLI
+  // restart until some unrelated slice changed. The render is cheap and
+  // renderEngineAlert is idempotent (hides itself when state !== 'stale').
+  // The quick-stats block IS still gated to avoid pointless DOM writes
+  // when the underlying numbers haven't moved.
+  if (data.engine) renderEngineStatus(data.engine);
   if (_changed('engine', data.engine)) {
-    renderEngineStatus(data.engine);
     var qs = document.getElementById('engine-quick-stats');
     if (qs && data.engine) {
       var wt = data.engine.worktreeCount != null ? data.engine.worktreeCount : '-';

package/dashboard.js

@@ -97,17 +97,33 @@ function reloadConfig() {
 ensureConfiguredProjectStateFiles();
 
 // Pre-warm git-status cache for every configured project so the first
-// /api/status after dashboard boot already has branch/dirty data — without
-// blocking the event loop on the per-project git shell-outs. Fire-and-forget,
-// boot-only: re-warming on every reloadConfig() would spawn 4× git probes on
-// every 10s status-poll cache miss. Project add/remove handlers explicitly
-// invoke this when the project list actually changes.
+// /api/status after dashboard boot already has branch/dirty data instead of
+// the ~8s `gitState=pending` gap that hides the "on: <branch>" chips in the
+// projects bar (#2754, W-mpgr4bu8). Returns a Promise that settles once every
+// per-project probe finishes; the boot block awaits this before `server.listen`
+// so the first poll never sees pending. The module-level call below is
+// fire-and-forget so module-import paths (tests) still get opportunistic
+// warming without blocking. Project add handlers re-invoke this when the
+// project list changes; re-warming on every `reloadConfig()` would spawn 4×
+// git probes on every 10s status-poll cache miss.
 function warmProjectGitStatusCache() {
+  const probes = [];
   for (const p of PROJECTS) {
     if (p && p.localPath) {
-      try { queries.warmProjectGitStatus(p.localPath, p.mainBranch); } catch { /* swallow — warming is opportunistic */ }
+      try {
+        const probe = queries.warmProjectGitStatus(p.localPath, p.mainBranch);
+        if (probe && typeof probe.then === 'function') {
+          probes.push(probe.catch(e => {
+            console.warn(`[boot] warm git status failed for ${p.name}: ${e && e.message}`);
+            return null;
+          }));
+        }
+      } catch (e) {
+        console.warn(`[boot] warm git status threw for ${p.name}: ${e && e.message}`);
+      }
     }
   }
+  return Promise.all(probes);
 }
 warmProjectGitStatusCache();
 
@@ -10233,6 +10249,7 @@ module.exports = {
   _resetPreambleCache,
   _installCrashHandlers,
   _mergeSettingsConfigUpdate: mergeSettingsConfigUpdate,
+  _warmProjectGitStatusCache: warmProjectGitStatusCache,
   // /api/status event-loop isolation surface (W-mpehsyhv0017085a)
   refreshStatusAsync,
   handleStatus: _handleStatusRequest,
@@ -10251,7 +10268,25 @@ if (require.main === module) {
   // engine reads, port binding) is captured rather than dying silently.
   _installCrashHandlers();
 
-  server.listen(PORT, '127.0.0.1', () => {
+  // Pre-warm the per-project git-status cache before accepting requests so
+  // the first /api/status after restart already returns gitState='ok' with a
+  // real branch instead of the ~8s pending gap that hides the projects-bar
+  // "on: <branch>" chips (#2754, W-mpgr4bu8). Wrapped in an async IIFE so
+  // the await happens before server.listen(); per-project failures are
+  // swallowed inside warmProjectGitStatusCache() so one bad project cannot
+  // block boot.
+  (async () => {
+    const _warmStartedAt = Date.now();
+    try {
+      await warmProjectGitStatusCache();
+      const ms = Date.now() - _warmStartedAt;
+      const n = Array.isArray(PROJECTS) ? PROJECTS.length : 0;
+      console.log(`[boot] pre-warmed git status for ${n} project${n === 1 ? '' : 's'} in ${ms}ms`);
+    } catch (e) {
+      console.warn(`[boot] pre-warm git status failed: ${e && e.message}`);
+    }
+
+    server.listen(PORT, '127.0.0.1', () => {
     console.log(`\n  Minions Mission Control`);
     console.log(`  -----------------------------------`);
     console.log(`  http://localhost:${PORT}`);
@@ -10331,6 +10366,7 @@ if (require.main === module) {
     }, 30000).unref();
     console.log(`  Engine watchdog: active (checks every 30s)`);
   });
+  })();
 
   server.on('error', e => {
     if (e.code === 'EADDRINUSE') {

package/docs/auto-discovery.md

@@ -1,6 +1,6 @@
 # Auto-Discovery & Execution Pipeline
 
-> Last verified: 2026-05-17 against `engine.js` `tickInner()` (lines 5360-5993).
+> Last verified: 2026-05-22 against `engine.js` `tickInner()` (lines 6068-6425).
 
 How the minions engine finds work and dispatches agents automatically.
 

package/docs/pr-review-fix-loop.md

@@ -39,7 +39,7 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 ### A. Human comments (`humanFeedback.pendingFix`)
 
 - Gate: `pendingFix || coalescedFeedback` + not already dispatched/on cooldown
-- Agent comments filtered out via `/\bMinions\s*\(/i` regex on comment body
+- Agent comments filtered out via `_isNonActionableComment()` (`engine/github.js`, `engine/ado.js`) — composes preview/bot body checks and the structural Minions-author check from `engine/comment-classifier.js`. The structural check matches the `<!-- minions:agent=<id> kind=<kind> -->` HTML marker on the body's first line (`hasMinionsMarker`); on GitHub it must combine with `viewerDidAuthor === true` (anti-spoof), on ADO with a `config.engine.minionsAdoIdentities` author match. Marker presence alone never classifies a comment as agent-authored on either platform.
 - Coalesces multiple comments arriving during cooldown into single fix
 - Routes to author
 - Fix agents must treat human comments as claims to verify, not commands. They inspect or reproduce each claimed issue, make the smallest correct fix only when the claim is valid, and otherwise reply with evidence-backed rationale.
@@ -108,6 +108,7 @@ The engine does not cap review→fix cycles or build-fix attempts. Each trigger
 | `engine/lifecycle.js` | `syncPrsFromOutput()`, `updatePrAfterReview()`, `updatePrAfterFix()` |
 | `engine/github.js` | `pollPrStatus()`, `pollPrHumanComments()`, `fetchGhBuildErrorLog()` |
 | `engine/ado.js` | `pollPrStatus()`, `pollPrHumanComments()`, `fetchAdoBuildErrorLog()` |
+| `engine/comment-classifier.js` | Host-agnostic body-only predicates (`isPreviewStatusBody`, `hasMinionsMarker`, `hasVerdictPrefix`) shared by GH + ADO pollers (extracted in F2+F3+F4) |
 | `engine/dispatch.js` | `addToDispatch()` — dedup by work item ID and dispatchKey |
 | `engine/cooldown.js` | `isBranchActive()`, cooldown management |
 | `playbooks/review.md` | Reviewer playbook |

package/docs/self-improvement.md

@@ -174,10 +174,10 @@ Human comments on PR with "@minions fix the error handling here"
 
 ### How it works
 
-- **Trigger:** If you're the only human commenter, **any** comment triggers a fix. If multiple humans are commenting, `@minions` keyword is required to avoid noise
-- **Agent detection:** Comments matching `/\bMinions\s*\(/i` are skipped (agent signature pattern)
+- **Trigger:** Any human comment newer than the per-PR cutoff that survives `_isNonActionableComment()` (preview/CI/Minions-author filter) flips `pr.humanFeedback.pendingFix = true` and queues a fix. There is no "@minions keyword required" gate — `@minions` mentions are merely stripped from `feedbackContent` before it is handed to the fix agent.
+- **Agent detection:** Comments are filtered via `_isNonActionableComment()` in `engine/github.js` / `engine/ado.js`, which composes the body-only predicates from `engine/comment-classifier.js` (`isPreviewStatusBody`, `hasMinionsMarker`) with an identity gate (`viewerDidAuthor === true` on GitHub, `config.engine.minionsAdoIdentities` author match on ADO). Marker presence alone never classifies a comment as agent-authored on either platform.
 - **Dedup:** Only comments newer than `pr.humanFeedback.lastProcessedCommentDate` are processed
-- **Multiple comments:** All new `@minions` comments are concatenated into a single fix task
+- **Multiple comments:** All new actionable comments since the cutoff are concatenated chronologically into a single fix task (each body individually fenced in `<UNTRUSTED-INPUT>` per F5 / W-mpeklod3000we69c)
 - **After fix:** `pendingFix` is cleared; PR re-enters normal review cycle
 
 ## 5. Quality Metrics

package/docs/watches.md

@@ -49,7 +49,7 @@ When `stopAfter === 0`, these are **fire-once** — the engine flips the watch t
 > **Per-target override (W-mp7hg58e000b5212):** the global `WATCH_ABSOLUTE_CONDITIONS` set is the legacy fallback. Each target type now declares its own `absoluteConditions: [...]` array in its spec; `registerTargetType` normalizes that into a `Set` that takes precedence at evaluation time. The plugin contract (see below) uses this to keep absolute-vs-change semantics local to each target type. Plugins that omit `absoluteConditions` get an empty set (all change-based).
 
 ### Change-based conditions
-`status-change`, `any`, `new-comments`, `vote-change`, `stage-complete`, `ran`, `enabled`, `disabled`, `activity-change`, plus the predicate conditions added under P-w4e2f6a1 / P-w5b8d2c9 for the `pr`, `work-item`, `plan`, and `pipeline` target types (`head-commit-change`, `mergeable-flipped`, `behind-master`, `draft-flipped`, `stalled`, `dependency-met`, `stage-advanced`, `stuck-in-stage`). See `engine/shared.js:1891-1929` for the canonical enum.
+`status-change`, `any`, `new-comments`, `vote-change`, `stage-complete`, `ran`, `enabled`, `disabled`, `activity-change`, plus the predicate conditions added under P-w4e2f6a1 / P-w5b8d2c9 for the `pr`, `work-item`, `plan`, and `pipeline` target types (`head-commit-change`, `mergeable-flipped`, `behind-master`, `draft-flipped`, `stalled`, `dependency-met`, `stage-advanced`, `stuck-in-stage`). See `engine/shared.js:2422-2460` for the canonical enum.
 
 These compare the live entity against the watch's `_lastState` snapshot and run forever when `stopAfter === 0`. Baseline `_lastState` is captured on the first check so the very next change triggers the watch *(source: `engine/watches.js:434, 520`)*.
 
@@ -89,7 +89,7 @@ Canonical example: `watches.d/http.js` (W-mp7i22mu00191b07) — a generic HTTP p
 
 ### Built-in target types
 
-The eight built-ins are registered at module load *(source: `engine/watches.js:672-1311`)*. Constants live at `engine/shared.js:1881-1890` (`WATCH_TARGET_TYPE`).
+The eight built-ins are registered at module load *(source: `engine/watches.js:672-1313`)*. Constants live at `engine/shared.js:2412-2421` (`WATCH_TARGET_TYPE`).
 
 | `targetType`  | Target value                         | Conditions                                                                 | Notes |
 |---------------|--------------------------------------|----------------------------------------------------------------------------|-------|
@@ -174,7 +174,7 @@ I/O happens **outside the lock**: notifications via `writeToInbox`, follow-up ac
 | `archive-plan`         | Set PRD `status="archived"` + `archivedAt`                                                    |
 | `resume-plan`          | Set PRD `status=PLAN_STATUS.ACTIVE` and clear `planStale`                                     |
 
-Constants live in `WATCH_ACTION_TYPE` (`engine/shared.js:1960`); handlers in `engine/watch-actions.js`.
+Constants live in `WATCH_ACTION_TYPE` (`engine/shared.js:2491`); handlers in `engine/watch-actions.js`.
 
 ### Templating
 
@@ -245,7 +245,7 @@ Absolute conditions firing under `stopAfter === 0` flip `status` to `expired`; `
 
 ## See Also
 
-- `engine/shared.js:1875-1960` — `WATCH_STATUS`, `WATCH_TARGET_TYPE`, `WATCH_CONDITION`, `WATCH_ABSOLUTE_CONDITIONS`, `WATCH_ACTION_TYPE` constants
+- `engine/shared.js:2406-2500` — `WATCH_STATUS`, `WATCH_TARGET_TYPE`, `WATCH_CONDITION`, `WATCH_ABSOLUTE_CONDITIONS`, `WATCH_ACTION_TYPE` constants
 - `engine/watches.js` — registry, lifecycle, tick integration, `watches.d/` plugin loader
 - `engine/watch-actions.js` — action registry and built-in handlers (including `minions-api`)
 - `watches.d/http.js` — canonical user-extensible target type plugin

package/engine/ado-git-auth.js

@@ -47,6 +47,22 @@ const TOKEN_TTL_MS = 30 * 60 * 1000;     // 30 min — matches gh-token cadence
 const ACQUIRE_BACKOFF_MS = 10 * 60 * 1000; // 10 min — same backoff as gh-token
 const ACQUIRE_TIMEOUT_MS = 30000;        // 30s — generous for slow IWA/broker auth
 
+// #2762 — Suppress Windows credential helpers (GCM/WAM broker) and any
+// interactive credential prompt for the lifetime of each ADO git invocation.
+// Without these, when the bearer extraHeader doesn't cover a needed host
+// (e.g. Scalar/GVFS cache-server like *.gvfscache.dev.azure.com), git falls
+// through to `credential.helper=git-credential-manager`. On Windows with
+// `credential.msauthusebroker=true` in the user's global config, GCM invokes
+// the WAM broker which pops a focus-stealing "Account Manager" dialog mid-task.
+// Setting credential.helper to an empty string disables ALL helpers for this
+// command only (no global config mutation); credential.interactive=false
+// keeps git from falling back to TTY prompts. Together they convert an
+// otherwise-silent hang behind a UI dialog into an immediate, debuggable 401.
+const CREDENTIAL_DISABLE_ARGS = [
+  '-c', 'credential.helper=',
+  '-c', 'credential.interactive=false',
+];
+
 let _cached = null;       // { token, expiresAt }
 let _backoffUntil = 0;    // epoch ms — no acquire attempts before this
 
@@ -127,6 +143,14 @@ function _buildHeaderArgs(token, scopeUrls) {
   return args;
 }
 
+// #2762 — Always-on credential-helper suppression for ADO git ops, paired with
+// (optional) bearer-header injection. The credential disable flags come FIRST
+// so they're effective even when token acquisition failed and we have nothing
+// else to add — preventing the WAM popup is more important than authenticating.
+function _composeAdoArgs(headerArgs) {
+  return [...CREDENTIAL_DISABLE_ARGS, ...headerArgs];
+}
+
 function _acquireToken(opts = {}) {
   const exec = opts.acquireAdoTokenSync || adoToken.acquireAdoTokenSync;
   const result = exec({ timeout: opts.timeout || ACQUIRE_TIMEOUT_MS });
@@ -137,23 +161,28 @@ function getAdoGitExtraArgs(project, opts = {}) {
   if (!isAdoProject(project)) return [];
   const now = Date.now();
   if (_cached && _cached.expiresAt > now) {
-    return _buildHeaderArgs(_cached.token, _resolveScopeUrls(project));
+    return _composeAdoArgs(_buildHeaderArgs(_cached.token, _resolveScopeUrls(project)));
+  }
+  if (now < _backoffUntil) {
+    // #2762 — Still suppress the credential helper even when we have no token.
+    // Without these flags, git falls through to GCM/WAM and pops the account
+    // picker; with them, the fetch fails fast with a 401 in agent logs.
+    return [...CREDENTIAL_DISABLE_ARGS];
   }
-  if (now < _backoffUntil) return [];
   try {
     const token = _acquireToken(opts);
     if (!token) {
       _backoffUntil = now + ACQUIRE_BACKOFF_MS;
       log('warn', `ado-git-auth: acquireAdoTokenSync returned empty token; backing off ${ACQUIRE_BACKOFF_MS / 1000}s`);
-      return [];
+      return [...CREDENTIAL_DISABLE_ARGS];
     }
     _cached = { token, expiresAt: now + TOKEN_TTL_MS };
-    return _buildHeaderArgs(token, _resolveScopeUrls(project));
+    return _composeAdoArgs(_buildHeaderArgs(token, _resolveScopeUrls(project)));
   } catch (e) {
     _backoffUntil = now + ACQUIRE_BACKOFF_MS;
     const firstLine = String(e && e.message || e).split('\n')[0];
     log('warn', `ado-git-auth: token acquire failed (${firstLine}); backing off ${ACQUIRE_BACKOFF_MS / 1000}s`);
-    return [];
+    return [...CREDENTIAL_DISABLE_ARGS];
   }
 }
 
@@ -203,7 +232,14 @@ async function runAdoGit(project, gitArgs, opts = {}) {
     invalidateAdoTokenCache();
     _backoffUntil = 0; // give the retry a chance to actually hit the token source
     const refreshedExtra = getAdoGitExtraArgs(project, adoOpts);
-    if (!refreshedExtra.length) {
+    // #2762 — `refreshedExtra` now always includes the credential-disable
+    // flags even when token acquisition fails, so length alone no longer
+    // signals "got a usable token." Detect a real bearer header instead;
+    // without one, retrying just re-runs the same unauthenticated request.
+    const hasBearer = refreshedExtra.some(
+      (a) => typeof a === 'string' && a.includes('Authorization: Bearer '),
+    );
+    if (!hasBearer) {
       throw _redactErrorInPlace(err);
     }
     const retryExtra = baseExtra.concat(refreshedExtra);

package/engine/lifecycle.js

@@ -1973,15 +1973,18 @@ function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChang
   ).slice(0, 500);
   target._lastDispatchByCause = target._lastDispatchByCause
     && typeof target._lastDispatchByCause === 'object' ? target._lastDispatchByCause : {};
-  // W-mpg6wptq0011cc68: distinguish indeterminate noops (detection could not
-  // prove the branch advanced — fetch failed, worktree gone, missing baseline)
-  // from confirmed noops (remote head was verified to equal beforeHead). The
-  // same-head guard in engine.js MUST NOT permanently suppress on indeterminate
-  // records, otherwise a single failed detection locks out future fix
-  // dispatches on that head+comment until the SHA moves — and the SHA cannot
-  // move unless the suppressed fix runs. The `_noOpFixes[cause].count` +
-  // `prNoOpFixPauseAttempts` (default 3) safety valve still applies; only the
-  // same-head guard is relaxed.
+  // W-mpg6wptq0011cc68 / W-mpgq8vve0001b8e3: distinguish indeterminate noops
+  // (detection could not prove the branch advanced — fetch failed, worktree
+  // gone, missing baseline) from confirmed noops (remote head was verified
+  // to equal beforeHead). The flag is recorded on `_lastDispatchByCause`
+  // for diagnostics and dashboards; the same-head/same-comment guard in
+  // engine.js NO LONGER treats it as a bypass (it used to, but that produced
+  // tight retry loops on PRs like ado:office/iss/constellation#5227039 where
+  // the indeterminate flag forced a retry every poll while the evidence
+  // fingerprint kept drifting just enough to reset `_noOpFixes.count`).
+  // Recovery story without the bypass: if a fix actually landed but
+  // detection failed, the next ADO/GH poll refreshes `pr.headSha` and the
+  // guard's `===` check stops matching — re-dispatch resumes automatically.
   const indeterminate = !!branchChange && branchChange.changed === null;
   target._lastDispatchByCause[cause] = {
     outcome: 'noop',

package/engine/queries.js

@@ -1632,7 +1632,13 @@ function resetPrdInfoCache() {
 // Folding state + in-flight into one map keeps reads/writes atomic and removes
 // the second-Map sync hazard.
 const _projectGitStatusCache = new Map();
-const PROJECT_GIT_STATUS_TTL = 300000; // 5 minutes
+// 15 s TTL — keeps external `git checkout` visible on the projects bar within
+// ~one /api/status cycle. The probe is 4 cheap local `git` commands (<100 ms on
+// a warm repo) and is already backgrounded + single-flighted by
+// _scheduleProjectGitStatusRefresh, so a tighter TTL doesn't add load: at
+// /api/status's 4 s poll cadence we trigger at most one background refresh per
+// project every ~4 polls (#2760).
+const PROJECT_GIT_STATUS_TTL = 15000;
 // Default null comparator fields so callers can blindly spread the result into
 // the /api/status payload without per-state branching (W-mpg3whgp000d09ec).
 // `remoteDefaultBranch` / `ahead` / `behind` are populated only by the `ok`
@@ -1776,9 +1782,11 @@ function getProjectGitStatus(localPath, configuredMainBranch = null) {
   return cached ? cached.value : PROJECT_GIT_STATUS_PENDING;
 }
 
-// Force a refresh now and wait for completion. Called from engine boot to
-// pre-warm the cache for every configured project so the first /api/status
-// after restart already has data. Also used by tests to settle the async
+// Force a refresh now and wait for completion. Called from dashboard boot
+// (see `warmProjectGitStatusCache()` in dashboard.js) to pre-warm the cache
+// for every configured project before `server.listen()` accepts requests, so
+// the first /api/status after restart already has data instead of a ~8s
+// `gitState=pending` gap (#2754). Also used by tests to settle the async
 // probe deterministically.
 function warmProjectGitStatus(localPath, configuredMainBranch = null) {
   const norm = String(localPath || '').replace(/\\/g, '/');

package/engine.js

@@ -4281,14 +4281,28 @@ async function discoverFromPrs(config, project) {
       // + `buildFailureSignature` but no `build-fix-*` dispatch was ever
       // queued). Skip only the human-feedback dispatch path; leave
       // `fixDispatched=false` so downstream causes are still evaluated.
+      // W-mpgq8vve0001b8e3: the same-head/same-comment guard now suppresses
+      // BOTH confirmed AND indeterminate noops. The original W-mpg6wptq0011cc68
+      // bypass for `indeterminate` produced a tight retry loop on
+      // ado:office/iss/constellation#5227039 (4 dispatches on identical head
+      // `c182a517` and comment id `2` within a single day) because the
+      // indeterminate flag forced a retry every poll while the evidence
+      // fingerprint (`feedbackContent`) kept drifting just enough to reset
+      // `_noOpFixes.count` to 1, preventing the `prNoOpFixPauseAttempts` valve
+      // from ever tripping. Rationale for suppressing indeterminate too:
+      //   - `currentHeadSha` reads from `pr.headSha`, which is refreshed by
+      //     the ADO/GH poller every `prPollStatusEvery` ticks. If the agent
+      //     had genuinely pushed (and lifecycle-side fetch detection just
+      //     failed), the next poll cycle would advance `pr.headSha` and the
+      //     `===` check would no longer match → re-dispatch naturally
+      //     resumes.
+      //   - If `currentHeadSha` still equals `lastHumanDispatch.headSha` AND
+      //     the comment id is unchanged, there is no new evidence for the
+      //     agent to act on — retrying produces another indeterminate noop
+      //     and accomplishes nothing. New activity (new comment, head moves)
+      //     is the only thing that can unstick the loop, and both naturally
+      //     unstick the guard.
       const skipHumanFeedback = !!(lastHumanDispatch?.outcome === 'noop'
-        // W-mpg6wptq0011cc68: indeterminate noops (detection could not verify
-        // branch advance — fetch failed, worktree gone) must NOT permanently
-        // suppress re-dispatch. lifecycle.js:2043-2048 explicitly comments
-        // that a future tick with working detection must be free to re-fire.
-        // The `_noOpFixes` count + `prNoOpFixPauseAttempts` (default 3) safety
-        // valve still triggers pause if detection keeps failing.
-        && !lastHumanDispatch.indeterminate
         && lastHumanDispatch.headSha
         && currentHeadSha
         && lastHumanDispatch.headSha === currentHeadSha
@@ -4472,13 +4486,17 @@ async function discoverFromPrs(config, project) {
       // aborted the whole PR iteration and starved the conflict-fix block
       // below — symmetric to the human-feedback bug. Skip only the build-fix
       // dispatch path; downstream merge-conflict resolution must still run.
+      // W-mpgq8vve0001b8e3: symmetric to the human-feedback guard above —
+      // suppress BOTH confirmed AND indeterminate noops on an unchanged head.
+      // The original W-mpg6wptq0011cc68 bypass let indeterminate build-fix
+      // noops retry indefinitely; in practice that produces the same tight
+      // loop the human-feedback path hit (4 noop dispatches on identical
+      // head). Recovery story is the same: if a fix actually landed but
+      // fetch-side detection failed, the next ADO/GH poll cycle refreshes
+      // `pr.headSha` and the `===` check stops matching → re-dispatch
+      // resumes naturally. If the head genuinely hasn't moved, there is
+      // nothing for the agent to do.
       const skipBuildFix = !!(lastBuildDispatch?.outcome === 'noop'
-        // W-mpg6wptq0011cc68: symmetric protection — indeterminate noops here
-        // (detection couldn't verify branch advance) must NOT permanently
-        // suppress build-fix either. Same rationale as the human-feedback
-        // guard above; the per-cause `_noOpFixes` count + pause-after-N valve
-        // still applies.
-        && !lastBuildDispatch.indeterminate
         && lastBuildDispatch.headSha
         && currentHeadSha
         && lastBuildDispatch.headSha === currentHeadSha);

package/package.json

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