@yemi33/minions 0.1.2177 → 0.1.2179

package/engine/queries.js

@@ -734,6 +734,118 @@ function getPrs(project) {
 let _prsCache = null;
 let _prsCacheAt = 0;
 
+// ── W-mqba5ulq000nd255 — cross-project PR de-dupe helpers ────────────────────
+//
+// When a dispatching agent in project A reports a PR URL that actually lives
+// on project B's repo, the engine historically wrote the PR into BOTH project
+// files. The A copy got stamped with `_invalidProjectScope` (a tracking
+// breadcrumb) but was never pruned. getPullRequests' legacy first-write-wins
+// dedupe then surfaced the wrong scope first, masking the real record. These
+// helpers collapse those duplicates at read time, with field-merge so we
+// never drop prdItems, sourcePlan, itemType, minionsReview, or
+// _automationFixCauses that lived on the loser.
+
+// Timestamps that signal "this record was touched recently". Highest of the
+// three breaks ties when neither record has a scope advantage.
+function _prFreshnessMs(pr) {
+  if (!pr) return 0;
+  const cands = [pr.lastPushedAt, pr.mergedAt, pr.lastPolledAt, pr.lastPolled, pr._attachedAt, pr.created];
+  let best = 0;
+  for (const c of cands) {
+    if (!c) continue;
+    const t = typeof c === 'number' ? c : Date.parse(c);
+    if (Number.isFinite(t) && t > best) best = t;
+  }
+  return best;
+}
+
+function _groupPrRecordsById(prs) {
+  const groups = new Map();
+  const order = [];
+  for (const pr of prs) {
+    if (!pr || !pr.id) continue;
+    if (!groups.has(pr.id)) {
+      const g = [];
+      groups.set(pr.id, g);
+      order.push(g);
+    }
+    groups.get(pr.id).push(pr);
+  }
+  return order;
+}
+
+// Choose the winning record from a group of cross-scope duplicates. Fields
+// the winner left empty are filled from the loser(s). Returns the winner +
+// the dropped sibling records so the caller can log the pruning decision.
+function _pickPrDedupeWinner(group, projects) {
+  if (group.length === 1) return { winner: group[0], dropped: [] };
+
+  // Map each project name -> its canonical scope, so we can detect when a
+  // record's _scope matches the PR url-derived scope (preference #2 below).
+  const projectScopeByName = new Map();
+  for (const p of projects || []) {
+    if (!p || !p.name) continue;
+    const sc = shared.getProjectPrScope(p);
+    if (sc) projectScopeByName.set(p.name, sc);
+  }
+
+  // Resolve the PR's "correct" scope from its URL (independent of _scope).
+  // Falls back to the canonical id when the URL is absent. Group members
+  // share the same id so any non-empty url is sufficient.
+  let urlScope = '';
+  for (const pr of group) {
+    const info = shared.getPrScopeInfo(pr, pr.url || '');
+    if (info && info.scope) { urlScope = info.scope; break; }
+  }
+
+  // Score each candidate. Higher is better. Composite key:
+  //  bit 2: no _invalidProjectScope stamp (best signal)
+  //  bit 1: _scope matches url-derived scope
+  //  bit 0: freshness rank (broken into a separate tiebreak after)
+  function scoreOf(pr) {
+    const scopeOk = !pr._invalidProjectScope ? 1 : 0;
+    const projectScope = projectScopeByName.get(pr._scope) || '';
+    const matchesUrl = urlScope && projectScope && projectScope === urlScope ? 1 : 0;
+    return (scopeOk << 1) | matchesUrl;
+  }
+
+  let winnerIdx = 0;
+  let winnerScore = scoreOf(group[0]);
+  let winnerFresh = _prFreshnessMs(group[0]);
+  for (let i = 1; i < group.length; i++) {
+    const s = scoreOf(group[i]);
+    const f = _prFreshnessMs(group[i]);
+    if (s > winnerScore || (s === winnerScore && f > winnerFresh)) {
+      winnerIdx = i;
+      winnerScore = s;
+      winnerFresh = f;
+    }
+  }
+
+  const winner = group[winnerIdx];
+  const dropped = group.filter((_, i) => i !== winnerIdx);
+
+  // Field-merge: fill empty winner fields from any loser. Winner wins on
+  // every field it has; losers only contribute where the winner is missing
+  // the field entirely (undefined, null, '', or empty array).
+  function isEmpty(v) {
+    if (v == null) return true;
+    if (typeof v === 'string') return v === '';
+    if (Array.isArray(v)) return v.length === 0;
+    return false;
+  }
+  const mergeKeys = ['prdItems', 'sourcePlan', 'itemType', 'minionsReview', '_automationFixCauses'];
+  for (const loser of dropped) {
+    for (const key of mergeKeys) {
+      if (isEmpty(winner[key]) && !isEmpty(loser[key])) {
+        winner[key] = loser[key];
+      }
+    }
+  }
+
+  return { winner, dropped };
+}
+
 function getPullRequests(config) {
   const now = Date.now();
   if (_prsCache && (now - _prsCacheAt) < 1000) return _prsCache;
@@ -741,14 +853,34 @@ function getPullRequests(config) {
   const projects = getProjects(config);
   const projectByName = new Map(projects.map(p => [p.name, p]));
   const allPrs = [];
-  const seenIds = new Set();
 
   // SQL is the canonical (and only) PR store after Phase 9.
   const store = require('./pull-requests-store');
   const sqlPrs = store.readAllPullRequests() || [];
 
-  for (const pr of sqlPrs) {
-    if (!pr?.id || seenIds.has(pr.id)) continue;
+  // W-mqba5ulq000nd255 — Read-side de-dupe across project scopes. When the
+  // same canonical pr.id appears under multiple scopes (e.g. an agent in
+  // project A reported a PR URL that actually lives on project B's repo,
+  // landing a stub stamped with _invalidProjectScope in A while the real
+  // record lives in B), collapse to one record using the preference order:
+  //   1. record where `_invalidProjectScope` is FALSY
+  //   2. record whose scope matches the PR url-derived scope
+  //   3. most-recently-updated (lastPushedAt / mergedAt / _attachedAt)
+  //   4. first-seen
+  // Then merge non-conflicting fields from the loser into the winner so we
+  // never lose prdItems, sourcePlan, itemType, minionsReview, or
+  // _automationFixCauses if only the loser carried them.
+  const groups = _groupPrRecordsById(sqlPrs);
+  for (const group of groups) {
+    const { winner, dropped } = _pickPrDedupeWinner(group, projects);
+    if (dropped.length > 0) {
+      try {
+        const droppedScopes = dropped.map(d => d._scope || 'unknown').join(', ');
+        shared.log('info', `[pull-requests] de-duped ${winner.id} across ${group.length} records, kept _project=${winner._scope || 'unknown'}, dropped [${droppedScopes}]`);
+      } catch { /* logging is best-effort */ }
+    }
+
+    const pr = winner;
     const scope = pr._scope;
     delete pr._scope;
     if (scope === 'central') {
@@ -769,7 +901,6 @@ function getPullRequests(config) {
     // _noOpFixes themselves.
     pr._pausedCauses = shared.getPrPausedCauses(pr);
     allPrs.push(pr);
-    seenIds.add(pr.id);
   }
   allPrs.sort((a, b) => {
     // W-mpej044m00076d63: sort by the full ISO `created` timestamp DESC so
@@ -1521,6 +1652,21 @@ function _getPrdInputHash(projects) {
   }
   // Static pr-links.json overrides (affect shared.getPrLinks(); missing project mtimes otherwise)
   try { mtimes.push(fs.statSync(path.join(MINIONS_DIR, 'engine', 'pr-links.json')).mtimeMs); } catch { mtimes.push(0); }
+  // W-mqacrzis0003df4a — Source-plan markdown mtimes. Without this, the
+  // per-PRD planStale fresh-computation at lines ~1568-1576 is never reached
+  // after the user revises plans/<x>.md until the engine tick (~10s) flips
+  // the persisted plan.planStale flag. The cached `_prdResultCache` hits the
+  // early-return and serves the prior (stale) `planStale: false` to readers
+  // long enough for a fast user to Approve and silently bypass diff-aware
+  // regen. Push the PLANS_DIR directory mtime first (catches add/delete on
+  // POSIX) then every .md file's mtime in sorted order for determinism.
+  try { mtimes.push(fs.statSync(PLANS_DIR).mtimeMs); } catch { mtimes.push(0); }
+  try {
+    const planFiles = fs.readdirSync(PLANS_DIR).filter(f => f.endsWith('.md')).sort();
+    for (const f of planFiles) {
+      try { mtimes.push(fs.statSync(path.join(PLANS_DIR, f)).mtimeMs); } catch { mtimes.push(0); }
+    }
+  } catch { /* plans/ may not exist in some test/init states */ }
   return { hash: mtimes.join(','), prdDirMtime, archiveDirMtime };
 }
 
@@ -1770,7 +1916,17 @@ function getPrdInfo(config) {
     items: items.map(i => ({
       id: i.id, name: i.name || i.title, priority: i.priority,
       complexity: i.estimated_complexity || i.size, status: i.status || 'missing',
-      description: i.description || '', projects: i.projects || [],
+      description: i.description || '',
+      // P-e8d49105 — projects[] feeds the per-item badge in
+      // dashboard/js/render-prd.js:250-252 + the plan-group rollup at :243.
+      // Honor a pre-populated projects[] (forward-compat for any future
+      // multi-repo single item); otherwise derive a single-element array
+      // from i.project so cross-repo PRDs (every item.project may differ)
+      // light up the dormant badge code without changing single-project
+      // behavior — i.project keeps being emitted unchanged below.
+      projects: (Array.isArray(i.projects) && i.projects.length > 0)
+        ? i.projects
+        : (i.project ? [i.project] : []),
       prs: prdToPr[i.id] || [], depends_on: i.depends_on || [],
       project: i.project || '', source: i._source || '', planSummary: i._planSummary || '', planProject: i._planProject || '', planStatus: i._planStatus || 'active', _archived: i._archived || false, sourcePlan: i._sourcePlan || '',
       branchStrategy: i._branchStrategy || 'parallel',
@@ -2572,6 +2728,10 @@ module.exports = {
 
   // Pull requests
   getPrs, getPullRequests,
+  // W-mqba5ulq000nd255 — exported for direct unit testing of the cross-project
+  // PR dedupe helpers.
+  _pickPrDedupeWinner,
+  _groupPrRecordsById,
 
   // Skills
   collectSkillFiles, getSkills, getSkillIndex, invalidateSkillsCache,

package/engine/runtimes/copilot.js

@@ -444,6 +444,7 @@ function buildArgs(opts = {}) {
     disableBuiltinMcps,
     suppressAgentsMd,
     reasoningSummaries,
+    disabledMcpServers,
   } = opts;
 
   const args = [
@@ -478,6 +479,16 @@ function buildArgs(opts = {}) {
   if (suppressAgentsMd === true) args.push('--no-custom-instructions');
   if (reasoningSummaries === true) args.push('--enable-reasoning-summaries');
 
+  // P-mcp-storm — Disable named user-scope MCP servers per spawn. Copilot loads
+  // ~/.copilot/mcp-config.json unconditionally (not gated by --add-dir/cwd), so
+  // this --disable-mcp-server <name> (repeatable) is the only lever to keep an
+  // operator's interactive MCP servers out of autonomous agent dispatches.
+  if (Array.isArray(disabledMcpServers)) {
+    for (const name of disabledMcpServers) {
+      if (name) args.push('--disable-mcp-server', String(name));
+    }
+  }
+
   // --stream takes a value: 'on' or 'off'. Caller passes that exact value.
   if (stream === 'on' || stream === 'off') {
     args.push('--stream', stream);
@@ -504,6 +515,14 @@ function buildSpawnFlags(opts = {}) {
   if (opts.disableBuiltinMcps === true) flags.push('--disable-builtin-mcps');
   if (opts.suppressAgentsMd === true) flags.push('--no-custom-instructions');
   if (opts.reasoningSummaries === true) flags.push('--enable-reasoning-summaries');
+  // P-mcp-storm — forward each disabled user MCP server so spawn-agent.js can
+  // re-emit it on the copilot CLI (parseSpawnArgs accumulates these into
+  // opts.disabledMcpServers, which buildArgs turns back into --disable-mcp-server).
+  if (Array.isArray(opts.disabledMcpServers)) {
+    for (const name of opts.disabledMcpServers) {
+      if (name) flags.push('--disable-mcp-server', String(name));
+    }
+  }
   return flags;
 }