@yemi33/minions 0.1.2364 → 0.1.2366

package/engine/lifecycle.js

@@ -6695,6 +6695,7 @@ function pruneScopeMismatchDuplicatePrs(config) {
   config = config || getConfig();
   const projects = shared.getProjects(config) || [];
   if (projects.length === 0) return { pruned: 0, relocated: 0, scanned: 0 };
+  const projectByName = new Map(projects.filter(project => project?.name).map(project => [project.name, project]));
 
   // Map project name -> canonical scope(s) so we can find which project IS
   // the correctly-scoped owner for a given mismatch record. Includes
@@ -6717,14 +6718,19 @@ function pruneScopeMismatchDuplicatePrs(config) {
     }
   }
 
-  // Index all PRs by canonical id across all projects (post-_scope decoration).
+  // Index all PRs by repository-scoped identity across all projects.
   const store = require('./pull-requests-store');
   const allPrs = store.readAllPullRequests() || [];
   const byId = new Map();
   for (const pr of allPrs) {
     if (!pr || !pr.id) continue;
-    if (!byId.has(pr.id)) byId.set(pr.id, []);
-    byId.get(pr.id).push(pr);
+    const ownerProject = pr._scope && pr._scope !== 'central'
+      ? projectByName.get(pr._scope) || null
+      : null;
+    const identity = shared.getPrIdentityKey(pr, ownerProject);
+    if (!identity) continue;
+    if (!byId.has(identity)) byId.set(identity, []);
+    byId.get(identity).push(pr);
   }
 
   // Build per-project delete sets keyed by id, so we batch one mutation per
@@ -6741,6 +6747,9 @@ function pruneScopeMismatchDuplicatePrs(config) {
   for (const records of byId.values()) {
     for (const rec of records) {
       scanned++;
+      // A tombstone is the durable record of explicit user intent. Never prune
+      // it in favor of an active sibling, or the sibling becomes visible again.
+      if (rec.userDeleted === true) continue;
       if (!rec._invalidProjectScope || rec._invalidProjectScope.reason !== 'pr_scope_mismatch') continue;
       const correctScope = rec._invalidProjectScope.prScope;
       if (!correctScope) continue;
@@ -6831,8 +6840,8 @@ function pruneScopeMismatchDuplicatePrs(config) {
   return { pruned, relocated, scanned };
 }
 
-// Repair helper: collapse prNumber duplicates across all project-scoped and
-// the central pull-requests file.  Called once per reconcile cycle alongside
+// Repair helper: collapse duplicate repository-scoped PR identities across all
+// project-scoped and central tracker data. Called once per reconcile cycle alongside
 // pruneScopeMismatchDuplicatePrs so accumulated duplicates are cleaned up
 // without requiring a one-off migration.
 function collapseAllDuplicatePrRecords(config) {

package/engine/queries.js

@@ -1001,25 +1001,34 @@ function getPullRequests(config) {
   // only tombstones one scope's copy would still have its untouched
   // cross-scope duplicate survive grouping below and get picked as the
   // dedupe "winner", silently resurrecting a PR the user just deleted.
-  const tombstonedIds = new Set();
+  const identityOf = (pr) => {
+    const ownerProject = pr?._scope && pr._scope !== 'central'
+      ? projectByName.get(pr._scope) || null
+      : null;
+    return shared.getPrIdentityKey(pr, ownerProject);
+  };
+  const tombstonedIdentities = new Set();
   for (const pr of sqlPrs) {
-    if (pr && pr.id && pr.userDeleted === true) tombstonedIds.add(pr.id);
+    const identity = identityOf(pr);
+    if (identity && pr.userDeleted === true) tombstonedIdentities.add(identity);
   }
 
   const groups = [];
-  const groupsById = new Map();
+  const groupsByIdentity = new Map();
   for (const pr of sqlPrs) {
     if (!pr || !pr.id) continue;
+    const identity = identityOf(pr);
+    if (!identity) continue;
     // Issue #384/#803: skip tombstoned records (user explicitly deleted), and
-    // skip ANY record sharing an id that has a tombstoned copy elsewhere.
+    // skip ANY alias of an identity that has a tombstoned copy elsewhere.
     if (pr.userDeleted === true) continue;
-    if (tombstonedIds.has(pr.id)) continue;
-    if (!groupsById.has(pr.id)) {
+    if (tombstonedIdentities.has(identity)) continue;
+    if (!groupsByIdentity.has(identity)) {
       const g = [];
-      groupsById.set(pr.id, g);
+      groupsByIdentity.set(identity, g);
       groups.push(g);
     }
-    groupsById.get(pr.id).push(pr);
+    groupsByIdentity.get(identity).push(pr);
   }
   for (const group of groups) {
     const { winner, dropped } = _pickPrDedupeWinner(group, projects);

package/engine/shared.js

@@ -6327,16 +6327,18 @@ function resolveAgentTempBaseDir(project, engine, minionsDir) {
 
 // Seed the agent COPILOT_HOME's mcp-config (copy of `~/.copilot/mcp-config.json`
 // MINUS `engine.copilotAgentDisabledMcpServers`) and return the home path. This
-// is the single source of truth for "what MCP servers may a minions-spawned
-// copilot load." It is applied to EVERY copilot spawn path — agent dispatches
-// (engine), internal `llm.callLLM` calls (engine), and CC / doc-chat / the CC
-// worker pool (dashboard) — by setting `process.env.COPILOT_HOME` at the boot of
-// both processes, so every copilot CHILD inherits the filtered config. copilot
-// SPAWNS every server in its config and authenticates it (`--disable-mcp-server`
-// only hides tools), so any auth-requiring server pops a Microsoft window per
-// spawn — filtering the config is the only effective control. Idempotent: writes
-// only when the content changes (safe under concurrent callers). The operator's
-// real `~/.copilot` (interactive copilot) is never touched. Fail-open.
+// is the source of truth for "what MCP servers may an agent-dispatch copilot
+// load." It is applied to the engine-process copilot spawn paths ONLY — agent
+// dispatches (`_applyAgentCopilotHome`) and the engine process's own internal
+// `llm.callLLM` calls — by setting `process.env.COPILOT_HOME` at engine boot
+// and re-stamping it per dispatch, so those copilot CHILDREN inherit the
+// filtered config. copilot SPAWNS every server in its config and
+// authenticates it (`--disable-mcp-server` only hides tools), so any
+// auth-requiring server pops a Microsoft window per spawn — filtering the
+// config is the only effective control. Idempotent: writes only when the
+// content changes (safe under concurrent callers). The operator's real
+// `~/.copilot` (interactive copilot, and now also Command Center / doc-chat /
+// the CC worker pool, per W-mre75l6x00024f49) is never touched. Fail-open.
 function ensureAgentCopilotHome(minionsDir, engine) {
   const home = resolveAgentCopilotHome(minionsDir);
   try {
@@ -7517,6 +7519,19 @@ function getCanonicalPrId(project, prRef, url = '') {
   return scope ? `${scope}#${prNumber}` : `PR-${prNumber}`;
 }
 
+function getPrIdentityKey(prRef, project = null) {
+  if (!prRef) return '';
+  const url = typeof prRef === 'object' ? String(prRef.url || '') : '';
+  const rawId = typeof prRef === 'object' ? prRef.id : prRef;
+  const identity = getCanonicalPrId(project, prRef, url) || String(rawId || '');
+  const parsed = parseCanonicalPrId(identity);
+  if (parsed && project && isAdoPrScopeCompatible(parsed.scope, project)) {
+    const projectScope = getProjectPrScope(project);
+    if (projectScope?.startsWith('ado:')) return `${projectScope}#${parsed.prNumber}`;
+  }
+  return identity;
+}
+
 function findPrRecord(prs, prRef, project = null) {
   if (!Array.isArray(prs) || !prRef) return null;
   const isObjectRef = typeof prRef === 'object';
@@ -7812,14 +7827,19 @@ function _mergeDuplicatePrInto(winner, loser) {
     }
   }
   winner.prdItems = normalizePrLinkItems([...(winner.prdItems || []), ...(loser.prdItems || [])]);
+  if (winner.userDeleted === true || loser.userDeleted === true) {
+    winner.userDeleted = true;
+    if (winner.userDeletedAt == null && loser.userDeletedAt != null) {
+      winner.userDeletedAt = loser.userDeletedAt;
+    }
+  }
 }
 
 /**
- * P-e9f0a2b4 — One-time repair helper: collapse duplicate PR records that share
- * the same `prNumber` within a single `pull-requests.json` file.
+ * P-e9f0a2b4 — Repair helper: collapse duplicate records for the same
+ * repository-scoped PR identity within a single tracker scope.
  *
- * Call this at engine start for every project's PR file (and the central file).
- * Idempotent — no-op when no duplicates exist.
+ * Called from the reconciliation sweep for every tracker scope. Idempotent.
  *
  * Selection rule (matching the task spec):
  *   1. Prefer `merged` status over any other status.
@@ -7837,19 +7857,20 @@ function collapseDuplicatePrRecords(prPath, { project = null } = {}) {
   let collapsed = 0;
   mutatePullRequests(prPath, (prs) => {
     normalizePrRecords(prs, project);
-    // Group by prNumber.
-    const byNumber = new Map();
+    // PR numbers are only unique within a repository. Grouping by number alone
+    // merges unrelated GitHub/ADO repositories and can discard a tombstone.
+    const byIdentity = new Map();
     for (const pr of prs) {
       if (!pr) continue;
-      const num = getPrNumber(pr);
-      if (num == null) continue;
-      if (!byNumber.has(num)) byNumber.set(num, []);
-      byNumber.get(num).push(pr);
+      const identity = getPrIdentityKey(pr, project);
+      if (!identity) continue;
+      if (!byIdentity.has(identity)) byIdentity.set(identity, []);
+      byIdentity.get(identity).push(pr);
     }
     // Identify loser records to remove (by object reference, not id, because
     // normalization may have changed multiple records to the same canonical id).
     const toRemove = new Set();
-    for (const [, group] of byNumber) {
+    for (const [, group] of byIdentity) {
       if (group.length <= 1) continue;
       const best = _pickBestPrRecord(group);
       for (const dup of group) {
@@ -7865,6 +7886,35 @@ function collapseDuplicatePrRecords(prPath, { project = null } = {}) {
   return { collapsed };
 }
 
+function _clearPrTombstonesForIdentity(identity) {
+  if (!identity) return 0;
+  const projectsByName = new Map(getProjects().map(project => [project.name, project]));
+  const scopes = new Map();
+  const store = require('./pull-requests-store');
+  for (const pr of store.readAllPullRequests() || []) {
+    if (pr?.userDeleted !== true) continue;
+    const project = pr._scope && pr._scope !== 'central'
+      ? projectsByName.get(pr._scope) || null
+      : null;
+    if (getPrIdentityKey(pr, project) !== identity) continue;
+    const prPath = store._filePathForScope(pr._scope || 'central');
+    scopes.set(path.resolve(prPath), { prPath, project });
+  }
+  let cleared = 0;
+  for (const { prPath, project } of scopes.values()) {
+    mutatePullRequests(prPath, (prs) => {
+      for (const pr of prs) {
+        if (pr?.userDeleted !== true || getPrIdentityKey(pr, project) !== identity) continue;
+        delete pr.userDeleted;
+        delete pr.userDeletedAt;
+        cleared++;
+      }
+      return prs;
+    });
+  }
+  return cleared;
+}
+
 /**
  * Canonical PR-producing work contract helper.
  *
@@ -7882,17 +7932,15 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     ...(Array.isArray(itemIds) ? itemIds : [itemId]),
   ]);
   const prNumber = getPrNumber(entry.prNumber ?? entry.id ?? entry.url);
-  // Issue #802: when the caller already resolved a scope-qualified canonical
-  // id (e.g. `ado:office/office/office#5370216`, as enrollPrFromCanonicalId
-  // does before calling here), it must win over recomputing from a bare
-  // entry.prNumber + project. Recomputing silently downgrades to a legacy
-  // `PR-<n>` stub whenever project is null/unresolvable (getCanonicalPrId
-  // can't derive a scope), discarding the good id even though it was passed
-  // in. Prefer entry.id whenever it already parses as canonical.
-  const hasCanonicalEntryId = typeof entry.id === 'string' && parseCanonicalPrId(entry.id) != null;
-  const canonicalId = hasCanonicalEntryId
-    ? getCanonicalPrId(project, entry.id, entry.url || '')
-    : getCanonicalPrId(project, entry.prNumber ?? entry.id ?? entry.url ?? prNumber, entry.url || '');
+  // getPrIdentityKey(entry, project) passes the whole entry object through to
+  // getCanonicalPrId, which (for object refs) reads `entry.id` directly rather
+  // than the `entry.prNumber ?? entry.id ?? ...` coalesce used for bare refs.
+  // That already preserves an already-resolved scope-qualified `entry.id`
+  // (e.g. `ado:office/office/office#5370216`, as enrollPrFromCanonicalId
+  // produces) instead of silently downgrading to a legacy `PR-<n>` stub when
+  // `project` is null/unresolvable — see issue #802 and
+  // test/unit/pr-number-dedup.test.js's "(#802)" case.
+  const canonicalId = getPrIdentityKey(entry, project);
   if (!canonicalId) throw new Error('PR id required');
   const normalizedEntry = {
     ...entry,
@@ -7916,12 +7964,19 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
   let created = false;
   let linked = false;
   let skipped = false;
-  let resurrected = false;
+  let resurrected = allowResurrect && _clearPrTombstonesForIdentity(canonicalId) > 0;
   let record = null;
 
   mutatePullRequests(prPath, (prs) => {
     normalizePrRecords(prs, project);
-    let target = findPrRecord(prs, normalizedEntry, project);
+    const identityMatches = prs.filter(pr => getPrIdentityKey(pr, project) === canonicalId);
+    let target = identityMatches.length > 0 ? _pickBestPrRecord(identityMatches) : null;
+    if (target && identityMatches.length > 1) {
+      const duplicates = new Set(identityMatches.filter(pr => pr !== target));
+      for (const duplicate of duplicates) _mergeDuplicatePrInto(target, duplicate);
+      prs = prs.filter(pr => !duplicates.has(pr));
+    }
+    const tombstonedMatches = target?.userDeleted === true ? [target] : [];
     // Issue #384: tombstoned records (userDeleted:true) must not be re-activated
     // by any poller path. Return skipped so reconcilePrs / shared-branch-reconcile
     // cannot resurrect a PR the user explicitly removed.
@@ -7931,13 +7986,15 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     // via POST /api/pull-requests/link is explicit intent to bring the PR back.
     // Callers that want that behavior opt in with `allowResurrect: true`, which
     // clears the tombstone here and lets the normal field-merge logic below run.
-    if (target && target.userDeleted === true) {
+    if (tombstonedMatches.length > 0) {
       if (!allowResurrect) {
         skipped = true;
         return prs;
       }
-      delete target.userDeleted;
-      delete target.userDeletedAt;
+      for (const match of tombstonedMatches) {
+        delete match.userDeleted;
+        delete match.userDeletedAt;
+      }
       resurrected = true;
     }
     // W-mrduef3q000m2172 — defense-in-depth: `prs` here is scoped to a single
@@ -7946,37 +8003,23 @@ function upsertPullRequestRecord(prPath, entry, { project = null, itemId = null,
     // record actually lives in a DIFFERENT scope's file), the above check
     // never sees it and would otherwise fall through to insert-as-new,
     // silently clearing the tombstone. Check globally before inserting.
-    if (!target) {
+    if (!target && !allowResurrect) {
       try {
         const store = require('./pull-requests-store');
-        const globalMatch = (store.readAllPullRequests() || [])
-          .find(pr => pr && pr.id === canonicalId && pr.userDeleted === true);
+        const projectsByName = new Map(getProjects().map(candidate => [candidate.name, candidate]));
+        const globalMatch = (store.readAllPullRequests() || []).find(pr => {
+          if (!pr || pr.userDeleted !== true) return false;
+          const ownerProject = pr._scope && pr._scope !== 'central'
+            ? projectsByName.get(pr._scope) || null
+            : null;
+          return getPrIdentityKey(pr, ownerProject) === canonicalId;
+        });
         if (globalMatch) {
           skipped = true;
           return prs;
         }
       } catch { /* best-effort global tombstone check — fall through on failure */ }
     }
-    // P-e9f0a2b4 — When findPrRecord returns null but multiple records share the
-    // same prNumber (e.g. cross-scope contamination or a project-config change
-    // that shifted canonical IDs), collapse the duplicates before inserting.
-    // Without this check, every subsequent upsert would append yet another record
-    // because numberMatches.length > 1 forces findPrRecord to return null.
-    if (!target && prNumber != null) {
-      const numberMatches = prs.filter(pr => pr && !pr.userDeleted && getPrNumber(pr) === prNumber);
-      if (numberMatches.length > 1) {
-        const best = _pickBestPrRecord(numberMatches);
-        const toRemoveIds = new Set(numberMatches.filter(p => p !== best).map(p => p.id));
-        for (const dup of numberMatches) {
-          if (dup === best) continue;
-          _mergeDuplicatePrInto(best, dup);
-        }
-        for (let i = prs.length - 1; i >= 0; i--) {
-          if (prs[i] && toRemoveIds.has(prs[i].id)) prs.splice(i, 1);
-        }
-        target = best; // update the surviving record instead of inserting new
-      }
-    }
     if (!target && typeof beforeInsert === 'function' && beforeInsert(prs, normalizedEntry) === false) {
       skipped = true;
       return prs;
@@ -9361,6 +9404,7 @@ module.exports = {
   isPrCompatibleWithProject,
   isAdoPrScopeCompatible,
   getCanonicalPrId,
+  getPrIdentityKey,
   findPrRecord,
   isPlaceholderPrTitle,
   snapshotPrRecord,

package/engine.js

@@ -11811,8 +11811,11 @@ if (require.main === module) {
   // `llm.callLLM` calls (consolidation, classification, meetings, …) — inherits
   // this process's COPILOT_HOME, so point it at the seeded, MCP-filtered home.
   // Without this, those `direct:true` copilot calls load the operator's full
-  // `~/.copilot` stack and pop a Microsoft auth window per call. The dashboard
-  // sets the same at its own boot for CC / doc-chat / the CC worker pool.
+  // `~/.copilot` stack and pop a Microsoft auth window per call. This isolation
+  // is engine-process-only: the dashboard process deliberately does NOT set
+  // COPILOT_HOME at its own boot, so Command Center / doc-chat / the CC worker
+  // pool inherit the operator's real `~/.copilot` home instead (reverted in
+  // W-mre75l6x00024f49; see dashboard.js boot for rationale).
   // See shared.ensureAgentCopilotHome. Fail-open.
   try { process.env.COPILOT_HOME = shared.ensureAgentCopilotHome(MINIONS_DIR, getConfig()?.engine); } catch {}
   const { handleCommand } = require('./engine/cli');

package/package.json

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