@yemi33/minions 0.1.1692 → 0.1.1693

package/CHANGELOG.md

@@ -1,10 +1,13 @@
 # Changelog
 
-## 0.1.1692 (2026-05-04)
+## 0.1.1693 (2026-05-04)
+
+### Features
+- sync review verdict PR status (#2008)
+
+## 0.1.1691 (2026-05-04)
 
 ### Features
-- stop Azure auth for GitHub agents (#2005)
-- recover stalled runtime resumes (#2004)
 - preserve doc-chat response fragments (#2003)
 
 ## 0.1.1689 (2026-05-03)

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-04T01:58:58.614Z"
+  "cachedAt": "2026-05-04T03:30:25.499Z"
 }

package/engine/github.js

@@ -39,6 +39,19 @@ function getRepoSlug(project) {
   return `${org}/${repo}`;
 }
 
+function _hasMinionsReviewVerdict(body) {
+  return /(?:^|\n)\s*\*{0,2}VERDICT[:\s]+\*{0,2}(?:APPROVE|REQUEST[_\s-]?CHANGES)\*{0,2}\b/i.test(String(body || ''));
+}
+
+function _isAgentComment(c) {
+  const body = c.body || '';
+  if (_hasMinionsReviewVerdict(body)) return true;
+  if (/\bMinions\s*\(/i.test(body)) return true;
+  if (/\bby\s+Minions\b/i.test(body)) return true;
+  if (/\[minions\]/i.test(body)) return true;
+  return false;
+}
+
 // ─── Per-Repo Poll Backoff ──────────────────────────────────────────────────
 // Tracks consecutive poll failures per repo slug to avoid spamming logs when
 // a repo is inaccessible. Backoff doubles each failure: 2min, 4min, 8min, 16min, max 30min.
@@ -572,13 +585,6 @@ async function pollPrHumanComments(config) {
       if (/!\[.*\]\(https?:\/\/.*badge/i.test(body)) return true;
       return false;
     }
-    function _isAgentComment(c) {
-      const body = c.body || '';
-      if (/\bMinions\s*\(/i.test(body)) return true;
-      if (/\bby\s+Minions\b/i.test(body)) return true;
-      if (/\[minions\]/i.test(body)) return true;
-      return false;
-    }
     const actionableComments = allComments.filter(c => !_isIgnoredComment(c));
 
     const cutoffStr = pr.humanFeedback?.lastProcessedCommentDate || pr.created || '1970-01-01';
@@ -907,4 +913,6 @@ module.exports = {
   GH_MAX_BUFFER, // exported for testing
   GH_POLL_BACKOFF_BASE_MS, // exported for testing
   GH_POLL_BACKOFF_MAX_MS, // exported for testing
+  _hasMinionsReviewVerdict, // exported for testing
+  _isAgentComment, // exported for testing
 };

package/engine/lifecycle.js

@@ -1266,11 +1266,61 @@ function isReviewBailout(text) {
   return /bail(ing)?\s+out/i.test(text) || /already\s+posted/i.test(text);
 }
 
-async function updatePrAfterReview(agentId, pr, project, config, resultSummary, structuredCompletion = null) {
+function reviewPrRefFromCompletion(completion) {
+  if (!completion || typeof completion !== 'object') return null;
+  const value = String(completion.pr || completion.pull_request || completion.pullRequest || '').trim();
+  if (!value || /^N\/?A$/i.test(value)) return null;
+  return value;
+}
 
-  if (!pr?.id) return;
+function centralPrPath() {
+  return path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
+}
+
+function resolveReviewPrContext(pr, project, config, structuredCompletion = null) {
+  const refs = [pr, reviewPrRefFromCompletion(structuredCompletion)].filter(Boolean);
+  if (refs.length === 0) return null;
+
+  const projects = shared.getProjects(config);
+  const projectCandidates = [];
+  if (project) projectCandidates.push(project);
+  for (const p of projects) {
+    if (!projectCandidates.some(existing => existing?.name === p.name)) projectCandidates.push(p);
+  }
+
+  for (const candidateProject of projectCandidates) {
+    const prPath = shared.projectPrPath(candidateProject);
+    const prs = safeJson(prPath) || [];
+    for (const ref of refs) {
+      const target = shared.findPrRecord(prs, ref, candidateProject);
+      if (target) return { pr: { ...target }, project: candidateProject, prPath };
+    }
+  }
+
+  const centralPath = centralPrPath();
+  const centralPrs = safeJson(centralPath) || [];
+  for (const ref of refs) {
+    const target = shared.findPrRecord(centralPrs, ref, null);
+    if (target) return { pr: { ...target }, project: null, prPath: centralPath };
+  }
+
+  return pr?.id
+    ? { pr, project: project || null, prPath: project ? shared.projectPrPath(project) : centralPath }
+    : null;
+}
+
+async function updatePrAfterReview(agentId, pr, project, config, resultSummary, structuredCompletion = null) {
 
   if (!config) config = getConfig();
+  const reviewContext = resolveReviewPrContext(pr, project, config, structuredCompletion);
+  if (!reviewContext?.pr?.id) {
+    const reportedPr = reviewPrRefFromCompletion(structuredCompletion);
+    if (reportedPr) log('warn', `Review completion reported PR ${reportedPr}, but no tracked PR record was found`);
+    return;
+  }
+  const reviewPr = reviewContext.pr;
+  const reviewProject = reviewContext.project;
+  const prPath = reviewContext.prPath;
   const reviewerName = config.agents?.[agentId]?.name || agentId;
   const dispatch = getDispatch();
   const completedEntry = (dispatch.completed || []).find(d => d.agent === agentId && d.type === 'review');
@@ -1280,31 +1330,30 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
   // The poller will pick up the real status on the next cycle (~3 min).
   let postReviewStatus = null; // null = don't change
   try {
-    const projectObj = project || shared.getProjects(config)[0];
+    const projectObj = reviewProject || shared.getProjects(config)[0];
     if (projectObj) {
       const host = projectObj.repoHost || 'ado';
       const checkFn = host === 'github'
         ? require('./github').checkLiveReviewStatus
         : require('./ado').checkLiveReviewStatus;
-      const liveStatus = await checkFn(pr, projectObj);
+      const liveStatus = await checkFn(reviewPr, projectObj);
       if (liveStatus && liveStatus !== 'pending') postReviewStatus = liveStatus;
     }
-  } catch (e) { log('warn', `Post-review status check for ${pr.id}: ${e.message}`); }
+  } catch (e) { log('warn', `Post-review status check for ${reviewPr.id}: ${e.message}`); }
 
   // Fallback: if live check returned pending (e.g., GitHub self-approval blocked), use the agent's completion report.
   if (!postReviewStatus) {
     const verdict = reviewVerdictFromCompletion(structuredCompletion) || parseReviewVerdict(resultSummary);
     if (verdict) {
       postReviewStatus = verdict;
-      log('info', `Read review verdict from agent completion for ${pr.id}: ${verdict}`);
+      log('info', `Read review verdict from agent completion for ${reviewPr.id}: ${verdict}`);
     }
   }
 
-  const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
   let updatedTarget = null;
   shared.mutateJsonFileLocked(prPath, (prs) => {
     if (!Array.isArray(prs)) return prs;
-    const target = shared.findPrRecord(prs, pr, project);
+    const target = shared.findPrRecord(prs, reviewPr, reviewProject);
     if (!target) return prs;
     // Once approved, stays approved — only changes-requested can override
     if (postReviewStatus) {
@@ -1323,12 +1372,12 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
       // Drop it when reviewer requests changes again — that starts a new fix cycle.
       ...(target.minionsReview?.fixedAt && postReviewStatus !== 'changes-requested' ? { fixedAt: target.minionsReview.fixedAt } : {}),
     };
-    updatedTarget = { ...pr, ...target };
+    updatedTarget = { ...reviewPr, ...target };
     return prs;
   }, { defaultValue: [] });
 
   // Track reviewer for metrics purposes (separate file, separate lock)
-  const authorAgentId = (pr.agent || '').toLowerCase();
+  const authorAgentId = (reviewPr.agent || '').toLowerCase();
   if (authorAgentId && config.agents?.[authorAgentId]) {
     shared.mutateJsonFileLocked(path.join(ENGINE_DIR, 'metrics.json'), (metrics) => {
       if (!metrics[authorAgentId]) metrics[authorAgentId] = { ...DEFAULT_AGENT_METRICS };
@@ -1338,7 +1387,7 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
     }, { defaultValue: {} });
   }
 
-  log('info', `Updated ${pr.id} → minions review: ${postReviewStatus || 'waiting'} by ${reviewerName}`);
+  log('info', `Updated ${reviewPr.id} → minions review: ${postReviewStatus || 'waiting'} by ${reviewerName}`);
   if (updatedTarget) createReviewFeedbackForAuthor(agentId, updatedTarget, config);
 }
 

package/engine/shared.js

@@ -1310,14 +1310,27 @@ function projectPrPath(project) {
   return path.join(projectStateDir(project), 'pull-requests.json');
 }
 
+function comparablePath(filePath) {
+  const resolved = path.resolve(filePath);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch {
+    try {
+      return path.join(fs.realpathSync.native(path.dirname(resolved)), path.basename(resolved));
+    } catch {
+      return resolved;
+    }
+  }
+}
+
 function resolveProjectForPrPath(filePath, config = null) {
-  const resolvedPaths = new Set([path.resolve(filePath)]);
+  const resolvedPaths = new Set([comparablePath(filePath)]);
   if (filePath && !path.isAbsolute(filePath)) {
-    resolvedPaths.add(path.resolve(MINIONS_DIR, filePath));
+    resolvedPaths.add(comparablePath(path.resolve(MINIONS_DIR, filePath)));
   }
   const projects = getProjects(config);
   for (const project of projects) {
-    if (resolvedPaths.has(path.resolve(projectPrPath(project)))) return project;
+    if (resolvedPaths.has(comparablePath(projectPrPath(project)))) return project;
   }
   if (projects.length === 1) return projects[0];
   return null;

package/package.json

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