@yemi33/minions 0.1.2040 → 0.1.2042

package/dashboard/js/refresh.js

@@ -14,7 +14,15 @@ const _pageCounters = {
   // triggers or the count changes; triggerCount removed because it advances
   // on the same event as last_triggered (F9/S4).
   watches:   function(d) { return (d.watches || []).length + '|' + (d.watches || []).reduce(function(m, w) { return Math.max(m, new Date(w.last_triggered || 0).getTime() || 0); }, 0); },
-  meetings:  function(d) { return (d.meetings || []).length + '|' + (d.meetings || []).reduce(function(s, m) { return s + (m.round || 0); }, 0); },
+  // meetings signature: full count + sum of all rounds. Uses meetingsTotal
+  // (top-level full count of meetings on disk) NOT meetings.length — the
+  // latter is the slim slice which drops terminal meetings >7d via
+  // statusMeetingsRetentionDays, so an archived meeting reaching round 3
+  // would silently fail to flip the dot. Round-sum stays on the slim slice
+  // (we don't track per-meeting round in meetingsTotal) — operators who
+  // care about archived-meeting round transitions can crank the retention
+  // window or set it to 0. (W-mphlrxx6000a8760)
+  meetings:  function(d) { return (d.meetingsTotal ?? (d.meetings || []).length) + '|' + (d.meetings || []).reduce(function(s, m) { return s + (m.round || 0); }, 0); },
   pipelines: function(d) { return (d.pipelines || []).length + '|' + (d.pipelines || []).reduce(function(s, p) { return s + (p.runs || []).length; }, 0); },
   schedule:  function(d) { return (d.schedules || []).length; },
   // tools signature: skills count + mcp servers count.

package/dashboard/js/settings.js

@@ -89,6 +89,7 @@ async function openSettings() {
       settingsField('Meeting Round Timeout', 'set-meetingRoundTimeout', e.meetingRoundTimeout || 900000, 'ms', 'Auto-advance meeting round after this') +
       settingsField('Operator login (used in branch names)', 'set-operatorLogin', e.operatorLogin || '', '', 'Override the human operator login used in user/<loginname>/<wi-id>-<slug> branches. Empty = auto-resolve via gh / git email / OS username (currently resolves to: ' + (e._resolvedOperatorLogin || 'unknown') + ')') +
       settingsField('Status WorkItems Retention', 'set-statusWorkItemsRetentionDays', e.statusWorkItemsRetentionDays ?? 7, 'days', 'Trim done/failed/cancelled work items older than N days from the /api/status workItems slice (active items are always shipped). Cuts SPA payload from ~3MB to <500KB. Set to 0 to disable trimming (full list shipped, restoring legacy behavior).') +
+      settingsField('Status Meetings Retention', 'set-statusMeetingsRetentionDays', e.statusMeetingsRetentionDays ?? 7, 'days', 'Trim completed/archived meetings older than N days from the /api/status meetings slice (active meetings are always shipped). Cuts SPA payload from ~4.3MB to <500KB. Detail modal still fetches full transcripts via /api/meetings/:id. Set to 0 to disable trimming (full list shipped, restoring legacy behavior).') +
     '</div>' +
     '<h3 style="font-size:13px;color:var(--blue);margin-bottom:8px">Automation</h3>' +
     '<div style="display:flex;flex-direction:column;gap:6px;margin-bottom:16px">' +
@@ -599,6 +600,7 @@ async function saveSettings() {
       meetingRoundTimeout: document.getElementById('set-meetingRoundTimeout').value,
       operatorLogin: (document.getElementById('set-operatorLogin')?.value ?? '').trim(),
       statusWorkItemsRetentionDays: document.getElementById('set-statusWorkItemsRetentionDays').value,
+      statusMeetingsRetentionDays: document.getElementById('set-statusMeetingsRetentionDays').value,
       autoApprovePlans: document.getElementById('set-autoApprovePlans').checked,
       evalLoop: document.getElementById('set-evalLoop').checked,
       autoDecompose: document.getElementById('set-autoDecompose').checked,

package/dashboard.js

@@ -23,6 +23,7 @@ const shared = require('./engine/shared');
 const queries = require('./engine/queries');
 const ado = require('./engine/ado');
 const gh = require('./engine/github');
+const ghToken = require('./engine/gh-token');
 const issues = require('./engine/issues');
 const watchesMod = require('./engine/watches');
 const meetingMod = require('./engine/meeting');
@@ -1710,7 +1711,14 @@ function _buildStatusFastState() {
     metrics: getMetrics(),
     workItems: _slimWorkItemsForStatus(getWorkItems()),
     watches: watchesMod.getWatches(),
-    meetings: _safeStatusSlice('meetings', () => meetingMod.getMeetings(), []),
+    meetings: _safeStatusSlice('meetings', () => _slimMeetingsForStatus(meetingMod.getMeetings()), []),
+    // Top-level full meeting count (NOT slim slice length). Surfaced so the
+    // sidebar activity-dot counter (dashboard/js/refresh.js _pageCounters.meetings)
+    // still fires when ANY meeting — including old/archived ones dropped from
+    // the slim slice by statusMeetingsRetentionDays — gains a new round.
+    // Without this, completing the third round of an archived meeting would
+    // silently fail to light the sidebar dot. (W-mphlrxx6000a8760)
+    meetingsTotal: _safeStatusSlice('meetingsTotal', () => _countMeetingsForStatus(), 0),
     // QA runs — surfaced for the sidebar activity-dot counter and any future
     // CC/aggregate view. Tab-level rendering keeps its own /api/qa/runs poll
     // (5 s while the QA page is mounted). qa-runs.json is in the mtime tracker
@@ -1844,6 +1852,101 @@ function _slimWorkItemsForStatus(items) {
   return surviving;
 }
 
+// ── /api/status meetings slimming (W-mphlrxx6000a8760) ──────────────────────
+// Mirrors the workItems trim above (PR #2816). Meetings are the second
+// largest /api/status slice after workItems — live measurement: 22 meetings
+// / 4.3MB (60% of the 7.2MB payload). The list renderer in
+// dashboard/js/render-meetings.js:renderMeetings only needs:
+//   - id, title, status, round, participants, agenda(short), createdAt,
+//     completedAt
+//   - per-participant booleans of findings/debate (used to pick the
+//     ✓/⏳/○ icon — `m.findings?.[p]` truthy check, line 48-50)
+// The detail modal calls `/api/meetings/:id` which serves the full record
+// (findings.content + debate.content + conclusion + transcript bodies), so
+// dropping those from the slice is safe.
+//
+// Active meetings (investigating/debating/concluding) are ALWAYS kept
+// regardless of age. Terminal meetings (completed/archived) only survive
+// if their completedAt/roundStartedAt/createdAt is within the window.
+// Set engine.statusMeetingsRetentionDays = 0 to disable trimming entirely
+// (returns the full list — but still slim-shaped — restoring legacy size).
+const _ACTIVE_MEETING_STATUSES_FOR_STATUS = new Set(['investigating', 'debating', 'concluding']);
+const _TERMINAL_MEETING_STATUSES_FOR_STATUS = new Set(['completed', 'archived']);
+function _resolveStatusMeetingsRetentionDays() {
+  const raw = CONFIG?.engine?.statusMeetingsRetentionDays;
+  if (raw === 0 || raw === '0') return 0;
+  const n = Number(raw);
+  if (Number.isFinite(n) && n >= 0) return n;
+  return shared.ENGINE_DEFAULTS.statusMeetingsRetentionDays;
+}
+function _slimMeetingForStatus(meeting) {
+  // Reduce findings/debate objects to {agentId: true} sentinels — the list
+  // renderer only checks `m.findings?.[p]` for truthiness when picking the
+  // participant-badge icon. Keeping just the keys preserves that contract
+  // while dropping the per-round agent transcript bodies (~95KB+ each).
+  const findingsKeys = meeting.findings && typeof meeting.findings === 'object'
+    ? Object.keys(meeting.findings) : [];
+  const debateKeys = meeting.debate && typeof meeting.debate === 'object'
+    ? Object.keys(meeting.debate) : [];
+  const findings = {};
+  for (const k of findingsKeys) findings[k] = true;
+  const debate = {};
+  for (const k of debateKeys) debate[k] = true;
+  const slim = {
+    id: meeting.id,
+    title: meeting.title,
+    status: meeting.status,
+    round: meeting.round,
+    participants: Array.isArray(meeting.participants) ? meeting.participants : [],
+    agenda: meeting.agenda,
+    createdAt: meeting.createdAt,
+    findings,
+    debate,
+  };
+  if (meeting.completedAt !== undefined) slim.completedAt = meeting.completedAt;
+  if (meeting.roundStartedAt !== undefined) slim.roundStartedAt = meeting.roundStartedAt;
+  if (meeting.createdBy !== undefined) slim.createdBy = meeting.createdBy;
+  return slim;
+}
+function _slimMeetingsForStatus(meetings) {
+  if (!Array.isArray(meetings)) return meetings;
+  const retentionDays = _resolveStatusMeetingsRetentionDays();
+  if (retentionDays <= 0) {
+    // Trimming disabled — keep full list but still flatten via slim shape
+    // so wire format is consistent and the heavy bodies never ship via
+    // /api/status regardless of operator config.
+    return meetings.map(_slimMeetingForStatus);
+  }
+  const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+  const surviving = [];
+  for (const meeting of meetings) {
+    if (!meeting) continue;
+    const status = meeting.status || 'investigating';
+    if (_TERMINAL_MEETING_STATUSES_FOR_STATUS.has(status)) {
+      const ts = meeting.completedAt || meeting.roundStartedAt || meeting.createdAt || '';
+      const tsMs = ts ? Date.parse(ts) : NaN;
+      // Drop only when we have a parseable timestamp and it's beyond the
+      // window. Meetings with missing/unparseable timestamps stay visible —
+      // we'd rather over-include than silently hide them.
+      if (Number.isFinite(tsMs) && tsMs < cutoffMs) {
+        continue;
+      }
+    } else if (!_ACTIVE_MEETING_STATUSES_FOR_STATUS.has(status)) {
+      // Unknown status — keep, so a future round name isn't silently
+      // hidden until the constant set is updated.
+    }
+    surviving.push(_slimMeetingForStatus(meeting));
+  }
+  return surviving;
+}
+// Count meetings on disk without rehydrating bodies — backs the sidebar
+// activity dot signature so new rounds in trimmed/archived meetings still
+// flip the counter (refresh.js _pageCounters.meetings reads meetingsTotal).
+function _countMeetingsForStatus() {
+  const meetings = meetingMod.getMeetings();
+  return Array.isArray(meetings) ? meetings.length : 0;
+}
+
 // Build the slow-state slice (rarely-changing data: ~60s TTL).
 function _buildStatusSlowState() {
   const prdInfo = getPrdInfo();
@@ -8538,6 +8641,20 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             _setEngineConfig('statusWorkItemsRetentionDays', val);
           }
         }
+        // W-mphlrxx6000a8760: /api/status meetings retention window. Same
+        // shape as statusWorkItemsRetentionDays — 0 must persist literally
+        // (disables trim), so handled outside the numericFields loop.
+        if (e.statusMeetingsRetentionDays !== undefined) {
+          const raw = e.statusMeetingsRetentionDays;
+          if (raw === '' || raw === null) {
+            _deleteEngineConfig('statusMeetingsRetentionDays');
+          } else {
+            let val = Number(raw);
+            if (!Number.isFinite(val) || val < 0) val = D.statusMeetingsRetentionDays;
+            if (val > 365) { _clamped.push(`statusMeetingsRetentionDays: ${val} → 365 (range: 0–365)`); val = 365; }
+            _setEngineConfig('statusMeetingsRetentionDays', val);
+          }
+        }
         // W-mpejf0fq000e84d6: operator login override. Empty string clears
         // the override (engine falls back to gh/git/os resolution); any other
         // value pins the login used in `user/<login>/<wi-id>-<slug>` branches.
@@ -9915,7 +10032,15 @@ What would you like to discuss or change? When you're happy, say "approve" and I
             // a regex match against untrusted PR-link input (the body of POST
             // /api/pull-requests/link); validate before exec. `prNum` is already
             // a number; coerce to string for argv.
-            const result = await shared.shellSafeGh(['api', `repos/${shared.validateGhSlug(slug)}/pulls/${String(prNum)}`], { timeout: 15000 });
+            //
+            // W-mphm0kt0000cebc3 (Bug A): route the GH PAT per slug. Without this,
+            // cross-account scopes (e.g. opg-microsoft/minions when active gh is
+            // yemi33) 404 silently and enrichment never lands — title stays
+            // "PR #N (polling...)" indefinitely. Mirrors engine/github.js:316.
+            const token = ghToken.resolveTokenForSlug(slug);
+            const ghOpts = { timeout: 15000 };
+            if (token) ghOpts.env = { ...process.env, GH_TOKEN: token };
+            const result = await shared.shellSafeGh(['api', `repos/${shared.validateGhSlug(slug)}/pulls/${String(prNum)}`], ghOpts);
             const d = JSON.parse(result);
             prData = { title: d.title, description: d.body, branch: d.head?.ref, author: d.user?.login };
           } else if (adoTarget && !initialPrData) {

package/engine/dispatch.js

@@ -111,14 +111,28 @@ function getBranchDispatchLockKey(entry) {
 }
 
 function findActivePrOrBranchLock(dispatch, item) {
-  if (item?.type !== WORK_TYPE.FIX) return null;
   const active = dispatch.active || [];
-  const prTargetKey = getPrDispatchTargetKey(item);
-  if (prTargetKey) {
-    const existing = active.find(d => getPrDispatchTargetKey(d) === prTargetKey);
-    if (existing) return { existing, reason: `active PR dispatch ${prTargetKey}` };
+
+  // PR-target dedup is FIX-only: a FIX shouldn't stack on top of another FIX
+  // for the same PR, but a REVIEW + FIX pair targeting the same PR is the
+  // normal review-then-fix flow and must not be dedup'd here.
+  if (item?.type === WORK_TYPE.FIX) {
+    const prTargetKey = getPrDispatchTargetKey(item);
+    if (prTargetKey) {
+      const existing = active.find(d => getPrDispatchTargetKey(d) === prTargetKey);
+      if (existing) return { existing, reason: `active PR dispatch ${prTargetKey}` };
+    }
   }
 
+  // Branch-lock applies to EVERY type, not just FIX (W-mphll3py0006234e —
+  // issue #2817). Any dispatch that carries meta.branch is, by definition,
+  // claiming ownership of that branch for the duration of its run — if two
+  // such dispatches overlap on the same branch they race the eventual
+  // `git push` and the spawn-time stale-HEAD guard fails whichever push
+  // lost the race. Mirrors the dispatch-loop's `lockedBranches` mutex
+  // (engine.js ~6577-6731) at queue-time so maintenance-class dispatches
+  // (setup / test / docs / implement / verify / decompose / review …) get
+  // the same coordination FIX already had.
   const branchLockKey = getBranchDispatchLockKey(item);
   if (!branchLockKey) return null;
   const existing = active.find(d => getBranchDispatchLockKey(d) === branchLockKey);

package/engine/github.js

@@ -669,6 +669,35 @@ async function pollPrStatus(config) {
       }
     }
 
+    // W-mphm0kt0000cebc3 (Bug B): backfill title/description/agent for
+    // project-local PRs that are still on the link-time placeholder. The
+    // central poller (above, ~lines 561-583) does this already; without
+    // parity here a manually-linked project-local PR whose initial
+    // enrichment IIFE failed (cross-account auth, transient blip) would
+    // stay stuck on "PR #N (polling...)" forever. `prData` is already in
+    // hand from line 622 — no extra API call needed.
+    const currentTitleForBackfill = pr.title || '';
+    if (!currentTitleForBackfill
+        || currentTitleForBackfill.includes('polling...')
+        || /[{}"\[\]]/.test(currentTitleForBackfill)
+        || /^[0-9a-f-]{8,}$/i.test(currentTitleForBackfill)) {
+      if (prData.title) {
+        const nextTitle = String(prData.title).slice(0, 120);
+        if (pr.title !== nextTitle) {
+          pr.title = nextTitle;
+          updated = true;
+        }
+      }
+    }
+    if (pr.description === undefined) {
+      pr.description = (prData.body || '').slice(0, 500);
+      updated = true;
+    }
+    if (pr.agent === 'human' && prData.user?.login) {
+      pr.agent = prData.user.login;
+      updated = true;
+    }
+
     // Map GitHub PR state to minions status
     let newStatus = pr.status;
     if (prData.merged) newStatus = PR_STATUS.MERGED;

package/engine/shared.js

@@ -2041,6 +2041,19 @@ const ENGINE_DEFAULTS = {
   // via GET /api/work-items/<id> when description/references/AC are needed.
   // 0 disables the trim (full list shipped, restoring legacy behavior).
   statusWorkItemsRetentionDays: 7,
+
+  // ── /api/status meetings retention (W-mphlrxx6000a8760) ─────────────────────
+  // Same shape as statusWorkItemsRetentionDays — mirrors the trim+slim pass
+  // for the meetings slice (live: 22 meetings / 4.3MB → ~5 meetings / <500KB
+  // typical). Active meetings (investigating/debating/concluding) are ALWAYS
+  // shipped regardless of age — only terminal meetings (completed/archived)
+  // past the window are dropped. The detail modal fetches the full record
+  // (findings, debate, conclusion, transcript bodies) on demand via
+  // GET /api/meetings/<id> when opened. A top-level meetingsTotal field is
+  // synthesized so the sidebar activity dot still fires when ANY meeting
+  // (including those dropped from the slim slice) gains a new round.
+  // 0 disables the trim (full list shipped, restoring legacy behavior).
+  statusMeetingsRetentionDays: 7,
 };
 
 // ─── Runtime Fleet Resolution (P-3b8e5f1d) ──────────────────────────────────

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;
                   }
                 }
               }
@@ -4063,6 +4151,18 @@ function ensurePrBranchForDispatch(project, pr, automationType) {
     }
     return branch;
   }
+  // W-mphm0kt0000cebc3 (Bug C): suppress the red "missing branch" badge during
+  // the link grace window. User reports the badge "is so loud as a warning -
+  // makes the user think something is wrong when it's just taking its time".
+  // A just-linked PR has `created` set within the last few seconds and has
+  // never been polled (no `headSha`); the enrichment IIFE + first poll cycle
+  // need 10-30s to land the real `branch`. During that window, return ''
+  // silently so dispatch is deferred without flipping any UI state. The next
+  // tick retries; if branch still missing past the grace window, fall through
+  // to the existing _branchResolutionError path (red badge as before).
+  if (isWithinLinkGraceWindow(pr)) {
+    return '';
+  }
   const reason = `Cannot dispatch ${automationType} for ${shared.getPrDisplayId(pr)}: missing pr_branch/source branch metadata. Link or refresh the PR so the source branch is known.`;
   if (updatePrBranchResolutionState(project, pr, { reason })) {
     log('warn', `PR ${pr.id}: ${reason}`);
@@ -4070,6 +4170,21 @@ function ensurePrBranchForDispatch(project, pr, automationType) {
   return '';
 }
 
+// W-mphm0kt0000cebc3 (Bug C): a PR is "freshly linked" if it was created in
+// the last 120s AND has never been successfully polled (no `headSha`). The
+// enrichment IIFE in dashboard.js's POST /api/pull-requests/link runs async
+// after returning the response, and the first GH/ADO poll completes within
+// 10-30s. The 120s window comfortably covers both without masking PRs whose
+// branch is genuinely missing.
+const PR_LINK_GRACE_WINDOW_MS = 120 * 1000;
+function isWithinLinkGraceWindow(pr) {
+  if (!pr || !pr.created) return false;
+  if (pr.headSha) return false; // poll has run successfully — past the grace window
+  const createdMs = Date.parse(pr.created);
+  if (!Number.isFinite(createdMs)) return false;
+  return (Date.now() - createdMs) < PR_LINK_GRACE_WINDOW_MS;
+}
+
 function prCausePart(value, fallback = 'unknown') {
   const raw = String(value || '').trim();
   return shared.safeSlugComponent(raw || fallback, 80);
@@ -4502,29 +4617,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,9 +7006,11 @@ 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
+  ensurePrBranchForDispatch, isWithinLinkGraceWindow, PR_LINK_GRACE_WINDOW_MS, // exported for testing (W-mphm0kt0000cebc3)
 
   // Playbooks
   renderPlaybook, validatePlaybookVars, PLAYBOOK_REQUIRED_VARS, buildWorkItemDispatchVars,

package/package.json

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