@yemi33/minions 0.1.1003 → 0.1.1005

package/engine/lifecycle.js

@@ -111,8 +111,8 @@ function checkPlanCompletion(meta, config) {
       const prs = safeJson(prPath) || [];
       const prLinks = getPrLinks();
       for (const pr of prs) {
-        const linkedItemId = prLinks[pr.id];
-        if (linkedItemId && doneItems.find(w => w.id === linkedItemId)) {
+        const linkedItemIds = prLinks[pr.id] || [];
+        if (linkedItemIds.some(itemId => doneItems.find(w => w.id === itemId))) {
           prsCreated.push(pr);
         }
       }
@@ -199,8 +199,8 @@ function checkPlanCompletion(meta, config) {
       const prLinks = getPrLinks();
       const prs = (safeJson(shared.projectPrPath(p)) || [])
         .filter(pr => {
-          const linkedId = prLinks[pr.id];
-          return pr.status === PR_STATUS.ACTIVE && linkedId && doneItems.find(w => w.id === linkedId);
+          const linkedIds = prLinks[pr.id] || [];
+          return pr.status === PR_STATUS.ACTIVE && linkedIds.some(itemId => doneItems.find(w => w.id === itemId));
         });
       if (prs.length > 0) {
         projectPrs[p.name] = { project: p, prs, mainBranch: shared.resolveMainBranch(p.localPath, p.mainBranch) };
@@ -413,8 +413,8 @@ function cleanupPlanWorktrees(planFile, plan, projects, config) {
         const prs = safeJson(shared.projectPrPath(p)) || [];
         const prLinks = getPrLinks();
         for (const pr of prs) {
-          const linkedId = prLinks[pr.id];
-          if (linkedId && planItems.find(w => w.id === linkedId) && pr.branch) {
+          const linkedIds = prLinks[pr.id] || [];
+          if (linkedIds.some(itemId => planItems.find(w => w.id === itemId)) && pr.branch) {
             branchSlugs.add(shared.sanitizeBranch(pr.branch).toLowerCase());
           }
         }
@@ -781,10 +781,11 @@ function syncPrsFromOutput(output, agentId, meta, config) {
   const newPrsByPath = new Map(); // prPath -> [{ prId, newEntry }]
 
   for (const prId of prMatches) {
-    const fullId = `PR-${prId}`;
     const targetProject = useCentral ? null : resolveProjectForPr(prId);
     const targetName = targetProject ? targetProject.name : '_central';
     const prPath = targetProject ? shared.projectPrPath(targetProject) : centralPrPath;
+    const prUrl = extractPrUrl(prId);
+    const fullId = shared.getCanonicalPrId(targetProject, prId, prUrl);
 
     let title = meta?.item?.title || '';
     const titleMatch = output.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
@@ -793,7 +794,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
       title = meta?.item?.title || '';
     }
 
-    if (!newPrsByPath.has(prPath)) newPrsByPath.set(prPath, { name: targetName, entries: [] });
+    if (!newPrsByPath.has(prPath)) newPrsByPath.set(prPath, { name: targetName, project: targetProject, entries: [] });
     newPrsByPath.get(prPath).entries.push({
       prId, fullId,
       entry: {
@@ -805,7 +806,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
         reviewStatus: 'pending',
         status: PR_STATUS.ACTIVE,
         created: ts(),
-        url: extractPrUrl(prId),
+        url: prUrl,
         prdItems: meta?.item?.id ? [meta.item.id] : [],
         sourcePlan: meta?.item?.sourcePlan || '',
         itemType: meta?.item?.itemType || ''
@@ -813,7 +814,8 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     });
   }
 
-  for (const [prPath, { name, entries }] of newPrsByPath) {
+  for (const [prPath, { name, project: targetProject, entries }] of newPrsByPath) {
+    const linksToPersist = [];
     mutateJsonFileLocked(prPath, (data) => {
       const prs = Array.isArray(data) ? data : [];
       // Normalize legacy YYYY-MM-DD created dates to ISO
@@ -821,13 +823,18 @@ function syncPrsFromOutput(output, agentId, meta, config) {
         if (p.created && p.created.length === 10) p.created = p.created + 'T00:00:00.000Z';
       }
       for (const { prId, fullId, entry } of entries) {
-        if (prs.some(p => p.id === fullId || String(p.id) === String(prId))) continue;
+        if (prs.some(p => p.id === fullId || (p.url && p.url === entry.url))) continue;
         prs.push(entry);
-        if (meta?.item?.id) addPrLink(fullId, meta.item.id);
+        if (meta?.item?.id) {
+          linksToPersist.push({ prId: fullId, itemId: meta.item.id, project: targetProject, prNumber: entry.prNumber, url: entry.url });
+        }
         added++;
       }
       return prs;
     });
+    for (const { prId, itemId, project, prNumber, url } of linksToPersist) {
+      addPrLink(prId, itemId, { project, prNumber, url });
+    }
     log('info', `Synced PR(s) from ${agentName}'s output to ${name === '_central' ? 'central' : name}/pull-requests.json`);
   }
   return added;
@@ -894,7 +901,7 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary)
   let updatedTarget = null;
   shared.mutateJsonFileLocked(prPath, (prs) => {
     if (!Array.isArray(prs)) return prs;
-    const target = prs.find(p => p.id === pr.id);
+    const target = shared.findPrRecord(prs, pr, project);
     if (!target) return prs;
     // Once approved, stays approved — only changes-requested can override
     if (postReviewStatus) {
@@ -938,7 +945,7 @@ function updatePrAfterFix(pr, project, source) {
   const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
   shared.mutateJsonFileLocked(prPath, (prs) => {
     if (!Array.isArray(prs)) return prs;
-    const target = prs.find(p => p.id === pr.id);
+    const target = shared.findPrRecord(prs, pr, project);
     if (!target) return prs;
     // Never downgrade from approved — fix was dispatched but PR is already approved
     if (target.reviewStatus !== 'approved') target.reviewStatus = 'waiting';
@@ -1083,7 +1090,7 @@ async function processPendingRebases(config) {
 
 async function handlePostMerge(pr, project, config, newStatus) {
 
-  const prNum = (pr.id || '').replace('PR-', '');
+  const prNum = shared.getPrNumber(pr);
 
   if (pr.branch && project) {
     const root = path.resolve(project.localPath);
@@ -1109,13 +1116,14 @@ async function handlePostMerge(pr, project, config, newStatus) {
   if (newStatus !== PR_STATUS.MERGED) return;
 
   // Resolve linked work item from pr-links or PR branch name
-  let mergedItemId = getPrLinks()[pr.id];
-  if (!mergedItemId && pr.branch) {
+  const mergedItemIds = [...(getPrLinks()[pr.id] || [])];
+  if (mergedItemIds.length === 0 && pr.branch) {
     const branchMatch = pr.branch.match(/(P-[a-z0-9]{6,})/i) || pr.branch.match(/(W-[a-z0-9]{6,})/i) || pr.branch.match(/(PL-[a-z0-9]{6,})/i);
-    if (branchMatch) mergedItemId = branchMatch[1];
+    if (branchMatch) mergedItemIds.push(branchMatch[1]);
   }
 
-  if (mergedItemId) {
+  if (mergedItemIds.length > 0) {
+    const mergedItemSet = new Set(mergedItemIds);
     // Mark PRD feature as implemented
     const prdDir = path.join(MINIONS_DIR, 'prd');
     try {
@@ -1124,49 +1132,62 @@ async function handlePostMerge(pr, project, config, newStatus) {
       for (const pf of planFiles) {
         const plan = safeJson(path.join(prdDir, pf));
         if (!plan?.missing_features) continue;
-        const feature = plan.missing_features.find(f => f.id === mergedItemId);
-        if (feature && feature.status !== WI_STATUS.DONE) {
-          feature.status = WI_STATUS.DONE;
+        let changed = false;
+        for (const feature of plan.missing_features) {
+          if (mergedItemSet.has(feature.id) && feature.status !== WI_STATUS.DONE) {
+            feature.status = WI_STATUS.DONE;
+            changed = true;
+            updated++;
+          }
+        }
+        if (changed) {
           shared.safeWrite(path.join(prdDir, pf), plan);
-          updated++;
         }
       }
-      if (updated > 0) log('info', `Post-merge: marked ${mergedItemId} as done for ${pr.id}`);
+      if (updated > 0) log('info', `Post-merge: marked ${mergedItemIds.join(', ')} as done for ${pr.id}`);
     } catch (err) { log('warn', `Post-merge PRD update: ${err.message}`); }
 
     // Mark work item as done
     const wiPaths = [path.join(MINIONS_DIR, 'work-items.json')];
     for (const p of shared.getProjects(config)) wiPaths.push(shared.projectWorkItemsPath(p));
+    const remainingMergedIds = new Set(mergedItemIds);
     for (const wiPath of wiPaths) {
       try {
-        let found = false;
         mutateWorkItems(wiPath, items => {
-          const item = items.find(i => i.id === mergedItemId);
-          if (item && item.status !== WI_STATUS.DONE) {
-            log('info', `Post-merge: marking work item ${mergedItemId} as done (was ${item.status}) for ${pr.id}`);
-            item.status = WI_STATUS.DONE;
-            item.completedAt = ts();
-            item._mergedVia = pr.id;
-            found = true;
+          for (const item of items) {
+            if (!remainingMergedIds.has(item.id)) continue;
+            if (item.status !== WI_STATUS.DONE) {
+              log('info', `Post-merge: marking work item ${item.id} as done (was ${item.status}) for ${pr.id}`);
+              item.status = WI_STATUS.DONE;
+              item.completedAt = ts();
+              item._mergedVia = pr.id;
+            }
+            remainingMergedIds.delete(item.id);
           }
         });
-        if (found) break;
+        if (remainingMergedIds.size === 0) break;
       } catch (err) { log('warn', `Post-merge work item update: ${err.message}`); }
     }
 
     // Rebase dependent PRs onto main now that this dependency is merged
     try {
-      const dependentPrs = findDependentActivePrs(mergedItemId, config);
-      for (const { pr: depPr, project: depProject } of dependentPrs) {
-        if (isBranchActive(depPr.branch)) {
-          queuePendingRebase(depPr, depProject, mergedItemId);
-          log('info', `Post-merge rebase deferred: ${depPr.branch} locked by active agent`);
-          continue;
-        }
-        const result = await rebaseBranchOntoMain(depPr, depProject, config);
-        if (!result.success) {
-          shared.writeToInbox('engine', `rebase-fail-${depPr.id}`,
-            `# Rebase Failed: ${depPr.id}\n\nBranch \`${depPr.branch}\` could not be rebased onto main after dependency ${mergedItemId} merged.\n\nError: ${result.error}\n\nManual rebase may be needed.`);
+      const rebasedPrs = new Set();
+      for (const mergedItemId of mergedItemIds) {
+        const dependentPrs = findDependentActivePrs(mergedItemId, config);
+        for (const { pr: depPr, project: depProject } of dependentPrs) {
+          const rebaseKey = `${depProject.name}:${depPr.id}`;
+          if (rebasedPrs.has(rebaseKey)) continue;
+          rebasedPrs.add(rebaseKey);
+          if (isBranchActive(depPr.branch)) {
+            queuePendingRebase(depPr, depProject, mergedItemId);
+            log('info', `Post-merge rebase deferred: ${depPr.branch} locked by active agent`);
+            continue;
+          }
+          const result = await rebaseBranchOntoMain(depPr, depProject, config);
+          if (!result.success) {
+            shared.writeToInbox('engine', `rebase-fail-${depPr.id}`,
+              `# Rebase Failed: ${depPr.id}\n\nBranch \`${depPr.branch}\` could not be rebased onto main after dependency ${mergedItemId} merged.\n\nError: ${result.error}\n\nManual rebase may be needed.`);
+          }
         }
       }
     } catch (err) { log('warn', `Post-merge rebase phase error: ${err.message}`); }
@@ -1315,7 +1336,8 @@ function createReviewFeedbackForAuthor(reviewerAgentId, pr, config) {
   const reviewFiles = inboxFiles.filter(f => f.includes(reviewerAgentId) && f.includes(today));
   if (reviewFiles.length === 0) return;
   const reviewContent = reviewFiles.map(f => safeRead(path.join(INBOX_DIR, f))).filter(Boolean).join('\n\n');
-  const feedbackFile = `feedback-${authorAgentId}-from-${reviewerAgentId}-${pr.id}-${today}.md`;
+  const prSlug = shared.safeSlugComponent(pr.id, 60);
+  const feedbackFile = `feedback-${authorAgentId}-from-${reviewerAgentId}-${prSlug}-${today}.md`;
   const feedbackPath = shared.uniquePath(path.join(INBOX_DIR, feedbackFile));
   const content = `# Review Feedback for ${config.agents[authorAgentId]?.name || authorAgentId}\n\n` +
     `**PR:** ${pr.id} — ${pr.title || ''}\n` +
@@ -1780,7 +1802,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Detect implement tasks that completed without creating a PR
   if (effectiveSuccess && (type === WORK_TYPE.IMPLEMENT || type === WORK_TYPE.IMPLEMENT_LARGE || type === WORK_TYPE.FIX) && prsCreatedCount === 0 && meta?.item?.id && !meta?.item?.skipPr && meta?.project?.localPath) {
     // Check if a PR already exists linked to this work item (from a previous attempt)
-    let existingPrFound = Object.values(getPrLinks()).includes(meta.item.id);
+    let existingPrFound = Object.values(getPrLinks()).some(linkedIds => (linkedIds || []).includes(meta.item.id));
     // Also check pull-requests.json for PRs with matching prdItems or branch
     if (!existingPrFound) {
       const allProjects = shared.getProjects(config);
@@ -1800,22 +1822,49 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
       if (projectObj) {
         try {
           let found = null;
-          if (projectObj.repoHost === 'github') {
+          const host = projectObj.repoHost || 'ado';
+          if (host === 'github') {
             const ghSlug = projectObj.prUrlBase?.match(/github\.com\/([^/]+\/[^/]+)\/pull/)?.[1];
             if (ghSlug) {
-              const raw = await execAsync(`gh pr list --head "${meta.branch}" --repo ${ghSlug} --json number,url,state --limit 1`, { timeout: 15000, windowsHide: true });
-              const hits = JSON.parse(raw || '[]');
-              if (hits.length > 0 && hits[0].state === 'OPEN') found = { prNumber: hits[0].number, url: hits[0].url };
+              // Retry up to 3 times — newly created PRs can take a few seconds to appear in the API
+              for (let attempt = 0; attempt < 3 && !found; attempt++) {
+                if (attempt > 0) await new Promise(r => setTimeout(r, 3000));
+                let raw = '';
+                try {
+                  raw = await execAsync(`gh pr list --head "${meta.branch}" --repo ${ghSlug} --json number,url,state --limit 1`, { timeout: 15000, windowsHide: true });
+                  const parsed = JSON.parse(raw || '[]');
+                  const hits = Array.isArray(parsed) ? parsed : [];
+                  if (hits.length > 0 && hits[0].state === 'OPEN') {
+                    found = { prNumber: hits[0].number, url: hits[0].url };
+                  } else if (attempt === 2) {
+                    log('warn', `Auto-link fallback: no open PR found on branch ${meta.branch} after 3 attempts (raw: ${(raw || '').slice(0, 200)})`);
+                  }
+                } catch (err) {
+                  if (attempt === 2) {
+                    const rawSuffix = raw ? ` (raw: ${raw.slice(0, 200)})` : '';
+                    log('warn', `Auto-link fallback: gh pr list lookup failed on branch ${meta.branch} after 3 attempts: ${err.message}${rawSuffix}`);
+                  }
+                }
+              }
             }
-          } else {
+          } else if (host === 'ado') {
             found = await require('./ado').findOpenPrOnBranch(projectObj, meta.branch);
+          } else {
+            log('debug', `Skipping branch PR lookup for unsupported repo host "${host}" on ${projectObj.name}`);
           }
           if (found) {
-            const fullId = `PR-${found.prNumber}`;
+            const fullId = shared.getCanonicalPrId(projectObj, found.prNumber, found.url);
             const prPath = shared.projectPrPath(projectObj);
             mutateJsonFileLocked(prPath, prs => {
               if (!Array.isArray(prs)) prs = [];
-              if (prs.some(p => p.id === fullId)) return prs;
+              const existingPr = prs.find(p => p.id === fullId);
+              if (existingPr) {
+                if (meta.item?.id) {
+                  if (!Array.isArray(existingPr.prdItems)) existingPr.prdItems = [];
+                  if (!existingPr.prdItems.includes(meta.item.id)) existingPr.prdItems.push(meta.item.id);
+                }
+                return prs;
+              }
               prs.push({
                 id: fullId, prNumber: found.prNumber, title: meta.item?.title || '',
                 agent: agentId, branch: meta.branch, reviewStatus: 'pending',
@@ -1825,7 +1874,6 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
               });
               return prs;
             });
-            if (meta.item?.id) addPrLink(fullId, meta.item.id);
             log('info', `Auto-linked existing PR ${fullId} on branch ${meta.branch} for ${meta.item?.id}`);
             existingPrFound = true;
           }
@@ -2069,4 +2117,3 @@ module.exports = {
   processPendingRebases,
   findDependentActivePrs,
 };
-

package/engine/pipeline.js

@@ -703,7 +703,7 @@ function isStageComplete(stage, stageState, run, config) {
       for (const project of projects) {
         const prs = safeJson(shared.projectPrPath(project)) || [];
         for (const prId of prIds) {
-          const pr = prs.find(p => p.id === prId);
+          const pr = shared.findPrRecord(prs, prId, project);
           if (pr && pr.status !== PR_STATUS.MERGED && pr.status !== PR_STATUS.ABANDONED) return false;
         }
       }

package/engine/queries.js

@@ -419,7 +419,11 @@ function getAgentDetail(id) {
 // ── Pull Requests ───────────────────────────────────────────────────────────
 
 function getPrs(project) {
-  if (project) return safeJson(projectPrPath(project)) || [];
+  if (project) {
+    const prs = safeJson(projectPrPath(project)) || [];
+    shared.normalizePrRecords(prs, project);
+    return prs;
+  }
   const config = getConfig();
   const all = [];
   for (const p of getProjects(config)) all.push(...getPrs(p));
@@ -433,9 +437,13 @@ function getPullRequests(config) {
   for (const project of projects) {
     const prs = safeJson(projectPrPath(project));
     if (!prs) continue;
+    shared.normalizePrRecords(prs, project);
     const base = project.prUrlBase || '';
     for (const pr of prs) {
-      if (!pr.url && base && pr.id) pr.url = base + String(pr.id).replace('PR-', '');
+      if (!pr.url && base) {
+        const prNumber = shared.getPrNumber(pr);
+        if (prNumber != null) pr.url = base + prNumber;
+      }
       pr._project = project.name || 'Project';
       allPrs.push(pr);
     }
@@ -444,6 +452,7 @@ function getPullRequests(config) {
   const centralPath = path.join(MINIONS_DIR, 'pull-requests.json');
   const centralPrs = safeJson(centralPath);
   if (centralPrs) {
+    shared.normalizePrRecords(centralPrs, null);
     for (const pr of centralPrs) {
       if (!allPrs.some(p => p.id === pr.id)) {
         pr._project = 'central';
@@ -737,9 +746,16 @@ function getWorkItems(config) {
   const allPrs = getPullRequests(config);
   for (const item of allItems) {
     if (item._pr && !item._prUrl) {
-      const prId = String(item._pr).replace('PR-', '');
-      const pr = allPrs.find(p => String(p.id).includes(prId));
-      if (pr) item._prUrl = pr.url;
+      const project = projects.find(p => p.name === item.project || p.name === item._source) || null;
+      const canonicalPrId = shared.getCanonicalPrId(project, item._pr);
+      const displayPrId = shared.getPrDisplayId(item._pr);
+      const exactPr = allPrs.find(p => p.id === canonicalPrId);
+      const displayMatches = exactPr ? [] : allPrs.filter(p => shared.getPrDisplayId(p) === displayPrId);
+      const pr = exactPr || (displayMatches.length === 1 ? displayMatches[0] : null);
+      if (pr) {
+        item._pr = pr.id;
+        item._prUrl = pr.url;
+      }
     }
     if (!item._pr) {
       // Derive from PR.prdItems (single source of truth)
@@ -949,21 +965,28 @@ function getPrdInfo(config) {
   for (const pr of allPrs) prById[pr.id] = pr;
 
   const prdToPr = {};
-  const prLinks = shared.getPrLinks(); // { "PR-xxxx": "P-xxxx" }
-  for (const [prId, itemId] of Object.entries(prLinks)) {
+  const prLinks = shared.getPrLinks(); // { "PR-xxxx": ["P-xxxx", "P-yyyy"] }
+  for (const [prId, itemIds] of Object.entries(prLinks)) {
     const pr = prById[prId];
     const project = projects.find(p => p.name === pr?._project) || projects[0] || null;
-    const url = pr?.url || (project?.prUrlBase ? project.prUrlBase + prId.replace('PR-', '') : '');
-    if (!prdToPr[itemId]) prdToPr[itemId] = [];
-    prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status: pr?.status || 'active', _project: pr?._project || '' });
+    const prNumber = shared.getPrNumber(pr || prId);
+    const url = pr?.url || (project?.prUrlBase && prNumber != null ? project.prUrlBase + prNumber : '');
+    for (const itemId of (itemIds || [])) {
+      if (!prdToPr[itemId]) prdToPr[itemId] = [];
+      prdToPr[itemId].push({ id: prId, url, title: pr?.title || '', status: pr?.status || 'active', _project: pr?._project || '' });
+    }
   }
   // Fallback: work item _pr field for anything still missing
   for (const wi of Object.values(wiById)) {
     if (!wi._pr || prdToPr[wi.id]?.length) continue;
-    const pr = prById[wi._pr];
-    const project = projects.find(p => p.name === wi.project || p.name === wi._source);
-    const url = pr?.url || (project?.prUrlBase ? project.prUrlBase + wi._pr.replace('PR-', '') : '');
-    prdToPr[wi.id] = [{ id: wi._pr, url, title: pr?.title || '', status: pr?.status || 'active', _project: project?.name || '' }];
+    const project = projects.find(p => p.name === wi.project || p.name === wi._source) || null;
+    const canonicalPrId = shared.getCanonicalPrId(project, wi._pr);
+    const exactPr = prById[canonicalPrId] || null;
+    const displayMatches = exactPr ? [] : Object.values(prById).filter(candidate => shared.getPrDisplayId(candidate) === shared.getPrDisplayId(wi._pr));
+    const pr = exactPr || (displayMatches.length === 1 ? displayMatches[0] : null);
+    const prNumber = shared.getPrNumber(pr || wi._pr);
+    const url = pr?.url || (project?.prUrlBase && prNumber != null ? project.prUrlBase + prNumber : '');
+    prdToPr[wi.id] = [{ id: pr?.id || canonicalPrId || wi._pr, url, title: pr?.title || '', status: pr?.status || 'active', _project: project?.name || '' }];
   }
   // Aggregate sub-task PRs to decomposed parent (sub-tasks aren't PRD items but their PRs should show)
   for (const pr of allPrs) {
@@ -976,7 +999,8 @@ function getPrdInfo(config) {
       if (!prdToPr[parentId]) prdToPr[parentId] = [];
       if (!prdToPr[parentId].some(p => p.id === pr.id)) {
         const project = projects.find(p => p.name === pr._project) || projects[0] || null;
-        const url = pr.url || (project?.prUrlBase ? project.prUrlBase + pr.id.replace('PR-', '') : '');
+        const prNumber = shared.getPrNumber(pr);
+        const url = pr.url || (project?.prUrlBase && prNumber != null ? project.prUrlBase + prNumber : '');
         prdToPr[parentId].push({ id: pr.id, url, title: pr.title || '', status: pr.status || 'active', _project: pr._project || '' });
       }
     }
@@ -1091,4 +1115,3 @@ module.exports = {
   // Work items & PRD
   getWorkItems, getPrdInfo,
 };
-