@yemi33/minions 0.1.2365 → 0.1.2366

package/dashboard.js

@@ -14125,14 +14125,50 @@ What would you like to discuss or change? When you're happy, say "approve" and I
 
     { method: 'POST', path: '/api/pull-requests/delete', desc: 'Remove a PR from tracking (sets userDeleted tombstone so pollers do not re-add it)', params: 'id, project?', handler: async (req, res) => {
       const body = await readBody(req);
-      const { id } = body;
+      const { id, project: requestedProjectName } = body;
       if (!id) return jsonReply(res, 400, { error: 'id required' });
       reloadConfig();
       // Search all project PR files and central file
-      const prPaths = [
-        ...shared.getProjects(CONFIG).map(p => shared.projectPrPath(p)),
-        path.join(MINIONS_DIR, 'pull-requests.json'),
-      ];
+      const projects = shared.getProjects(CONFIG);
+      const projectByName = new Map(projects.map(project => [project.name, project]));
+      const store = require('./engine/pull-requests-store');
+      const storedPrs = store.readAllPullRequests() || [];
+      const prScopes = new Map([
+        ...projects.map(project => [project.name, { prPath: shared.projectPrPath(project), project }]),
+        ['central', { prPath: path.join(MINIONS_DIR, 'pull-requests.json'), project: null }],
+      ]);
+      const canonicalRequest = shared.parseCanonicalPrId(id);
+      const requestedIdentities = new Set();
+      if (canonicalRequest) {
+        const compatibleProject = canonicalRequest.scope.startsWith('ado:')
+          ? projects.find(project => shared.isAdoPrScopeCompatible(canonicalRequest.scope, project))
+          : null;
+        requestedIdentities.add(shared.getPrIdentityKey(id, compatibleProject || null));
+      } else {
+        for (const pr of storedPrs) {
+          if (pr?.id !== id) continue;
+          if (requestedProjectName && pr._scope !== requestedProjectName) continue;
+          const ownerProject = pr._scope && pr._scope !== 'central'
+            ? projectByName.get(pr._scope) || null
+            : null;
+          const identity = shared.getPrIdentityKey(pr, ownerProject);
+          if (identity) requestedIdentities.add(identity);
+        }
+      }
+      if (requestedIdentities.size > 1) {
+        return jsonReply(res, 409, { error: 'Legacy PR id is ambiguous; specify project' });
+      }
+      if (requestedIdentities.size === 0) {
+        return jsonReply(res, 404, { error: 'PR not found' });
+      }
+      for (const pr of storedPrs) {
+        const scope = pr?._scope || 'central';
+        const ownerProject = scope !== 'central' ? projectByName.get(scope) || null : null;
+        if (!requestedIdentities.has(shared.getPrIdentityKey(pr, ownerProject))) continue;
+        if (!prScopes.has(scope)) {
+          prScopes.set(scope, { prPath: store._filePathForScope(scope), project: ownerProject });
+        }
+      }
       let found = false;
       // Issue #803: tombstone EVERY scope that has a copy of this PR id, not
       // just the first one found. When enrollPrFromCanonicalId (issue #802)
@@ -14141,14 +14177,16 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       // the other scope's copy fully untouched — queries.js#getPullRequests
       // then de-dupes by picking that untouched duplicate as the "winner"
       // and silently resurrects the "deleted" PR on the next read.
-      for (const prPath of prPaths) {
+      for (const { prPath, project } of prScopes.values()) {
         // Issue #384: use a tombstone (userDeleted:true) instead of splice so
         // the next poller cycle cannot re-add the PR. The entry stays in the
         // file but is filtered from API responses and skipped by pollers.
         shared.mutatePullRequests(prPath, (prs) => {
           if (!Array.isArray(prs)) return prs;
-          const pr = prs.find(p => p.id === id);
-          if (pr) {
+          const matches = prs.filter(pr =>
+            requestedIdentities.has(shared.getPrIdentityKey(pr, project))
+          );
+          for (const pr of matches) {
             pr.userDeleted = true;
             pr.userDeletedAt = shared.ts();
             found = true;

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

@@ -7519,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';
@@ -7814,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.
@@ -7839,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) {
@@ -7867,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.
  *
@@ -7884,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,
@@ -7918,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.
@@ -7933,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
@@ -7948,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;
@@ -9363,6 +9404,7 @@ module.exports = {
   isPrCompatibleWithProject,
   isAdoPrScopeCompatible,
   getCanonicalPrId,
+  getPrIdentityKey,
   findPrRecord,
   isPlaceholderPrTitle,
   snapshotPrRecord,

package/package.json

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