@yemi33/minions 0.1.1648 → 0.1.1650

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1650 (2026-05-01)
+
+### Features
+- reject premature task_complete for nonterminal summaries
+- ADO build poll repositoryId GUID handling
+
+### Fixes
+- yemi33/minions#1927
+- yemi33/minions#1925
+
 ## 0.1.1648 (2026-05-01)
 
 ### Other

package/dashboard/js/render-prs.js

@@ -16,6 +16,7 @@ function prRow(pr) {
   const reviewTitle = reviewEscalated ? 'Review/re-review and review-fix automation stopped after evalMaxIterations; build-fix and conflict-fix automation may still run.' : '';
   const buildClass = pr.buildFixEscalated ? 'build-escalated' : pr._buildStatusStale ? 'build-stale' : pr.buildStatus === 'passing' ? 'build-pass' : pr.buildStatus === 'failing' ? 'build-fail' : pr.buildStatus === 'running' ? 'building' : 'no-build';
   const buildLabel = pr.buildFixEscalated ? 'escalated (' + (pr.buildFixAttempts || '?') + ' fixes)' : (pr.buildStatus || 'none') + (pr._buildStatusStale ? ' (stale)' : '');
+  const buildTitle = pr._buildStatusDetail || '';
   const statusClass = pr.status === 'merged' ? 'merged' : pr.status === 'abandoned' ? 'rejected' : pr.status === 'active' ? 'active' : 'draft';
   const statusLabel = pr.status || 'active';
   const branchError = pr._branchResolutionError?.reason || '';
@@ -34,7 +35,7 @@ function prRow(pr) {
     '<td><span class="' + branchClass + '"' + (branchError ? ' title="' + escapeHtml(branchError) + '"' : '') + '>' + escapeHtml(branchLabel) + '</span>' + pendingReasonHtml + '</td>' +
     '<td><span class="pr-badge ' + reviewClass + '"' + (reviewTitle ? ' title="' + escapeHtml(reviewTitle) + '"' : '') + '>' + escapeHtml(reviewLabel) + '</span></td>' +
     '<td>' + (sq.reviewer && sq.status !== 'waiting' ? '<span class="pr-agent" title="' + escapeHtml(sq.note || '') + '">' + escapeHtml(sq.reviewer) + '</span>' : sq.reviewer && sq.status === 'waiting' ? '<span class="pr-agent" style="color:var(--muted)" title="Vote pending confirmation">' + escapeHtml(sq.reviewer) + '…</span>' : pr.reviewedBy && pr.reviewedBy.length ? '<span class="pr-agent">' + escapeHtml(pr.reviewedBy.join(', ')) + '</span>' : '<span style="color:var(--muted);font-size:11px">—</span>') + '</td>' +
-    '<td><span class="pr-badge ' + buildClass + '">' + escapeHtml(buildLabel) + '</span></td>' +
+    '<td><span class="pr-badge ' + buildClass + '"' + (buildTitle ? ' title="' + escapeHtml(buildTitle) + '"' : '') + '>' + escapeHtml(buildLabel) + '</span></td>' +
     '<td><span class="pr-badge ' + statusClass + '">' + escapeHtml(statusLabel) + '</span></td>' +
     '<td><span class="pr-date">' + escapeHtml((pr.created || '—').slice(0, 16).replace('T', ' ')) + '</span></td>' +
     '<td><button class="pr-pager-btn" style="font-size:9px;padding:1px 5px;color:var(--red);border-color:var(--red)" data-pr-id="' + escapeHtml(String(prId)) + '" onclick="event.stopPropagation();unlinkPr(this.dataset.prId)" title="Remove from tracking">x</button></td>' +

package/engine/ado-status.js

@@ -42,7 +42,7 @@ if (!prNumberArg) {
     '  --project <name>    Scope search to one project (optional)',
     '',
     'Output: JSON with fields: prNumber, title, branch, status, reviewStatus,',
-    '        buildStatus, buildErrorLog (if failing), mergeConflict, url, project, source',
+    '        buildStatus, buildStatusStale/detail (if stale), buildErrorLog (if failing), mergeConflict, url, project, source',
     '',
     'buildStatus values: passing | failing | running | none',
     'reviewStatus values: approved | changes-requested | waiting | pending',
@@ -73,6 +73,10 @@ function findInCache(projects) {
       source: 'cached',
     };
     if (pr.buildErrorLog) out.buildErrorLog = pr.buildErrorLog;
+    if (pr._buildStatusStale) {
+      out.buildStatusStale = true;
+      if (pr._buildStatusDetail) out.buildStatusDetail = pr._buildStatusDetail;
+    }
     if (pr._mergeConflict) out.mergeConflict = true;
     return out;
   }

package/engine/ado.js

@@ -26,17 +26,31 @@ const getAdoPrUrl = (project, prNumber) => {
   const repoPath = encodeURIComponent(project.repoName || project.repositoryId || '');
   return `https://dev.azure.com/${project.adoOrg}/${project.adoProject}/_git/${repoPath}/pullrequest/${prNumber}`;
 };
+const ADO_GUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 function isGitHubProject(project) {
   return String(project?.repoHost || '').toLowerCase() === 'github';
 }
 
-function getAdoRepositoryId(project) {
+function isAdoGuid(value) {
+  return ADO_GUID_RE.test(String(value || '').trim());
+}
+
+function getAdoRepositoryLookupKey(project) {
   const repositoryId = String(project?.repositoryId || '').trim();
   if (repositoryId) return repositoryId;
   return String(project?.repoName || '').trim();
 }
 
+function getAdoRepositoryId(project) {
+  return getAdoRepositoryLookupKey(project);
+}
+
+function getConfiguredAdoRepositoryGuid(project) {
+  const repositoryId = String(project?.repositoryId || '').trim();
+  return isAdoGuid(repositoryId) ? repositoryId : '';
+}
+
 function getAdoProjectLabel(project) {
   return project?.name || project?.repoName || `${project?.adoOrg || 'unknown-org'}/${project?.adoProject || 'unknown-project'}`;
 }
@@ -45,6 +59,85 @@ function logMissingAdoRepository(project, purpose) {
   log('error', `${purpose} disabled for project ${getAdoProjectLabel(project)}: missing project.repositoryId and project.repoName; configure one so Azure DevOps repository API calls can target the repo`);
 }
 
+function adoConfigPath() {
+  return path.join(shared.MINIONS_DIR, 'config.json');
+}
+
+function sameAdoProject(a, b) {
+  if (!a || !b) return false;
+  if (a.name && b.name && a.name === b.name) return true;
+  if (a.localPath && b.localPath && path.resolve(a.localPath) === path.resolve(b.localPath)) return true;
+  return String(a.adoOrg || '') === String(b.adoOrg || '')
+    && String(a.adoProject || '') === String(b.adoProject || '')
+    && String(a.repoName || '') === String(b.repoName || '')
+    && String(a.repoHost || 'ado').toLowerCase() === String(b.repoHost || 'ado').toLowerCase();
+}
+
+function persistAdoRepositoryGuid(project, guid, repoName) {
+  if (!isAdoGuid(guid)) return;
+  const previous = String(project?.repositoryId || '').trim();
+  project.repositoryId = guid;
+  if (!project.repoName && repoName) project.repoName = repoName;
+  if (previous === guid) return;
+
+  try {
+    let persisted = false;
+    mutateJsonFileLocked(adoConfigPath(), (config) => {
+      if (!config || typeof config !== 'object' || Array.isArray(config)) return config;
+      if (!Array.isArray(config.projects)) return config;
+      const target = config.projects.find(p => sameAdoProject(p, project));
+      if (!target) return config;
+      target.repositoryId = guid;
+      if (!target.repoName && repoName) target.repoName = repoName;
+      persisted = true;
+      return config;
+    }, { defaultValue: { projects: [] }, skipWriteIfUnchanged: true });
+    if (persisted) {
+      log('info', `Resolved ADO repository GUID for ${getAdoProjectLabel(project)}: ${previous || project.repoName || 'unknown'} → ${guid}`);
+    } else {
+      log('warn', `Resolved ADO repository GUID for ${getAdoProjectLabel(project)} but could not find the project in config.json to persist it`);
+    }
+  } catch (e) {
+    log('warn', `Resolved ADO repository GUID for ${getAdoProjectLabel(project)} but failed to persist it: ${e.message}`);
+  }
+}
+
+async function resolveAdoBuildRepositoryGuid(project, token, orgBase, purpose, opts = {}) {
+  const configured = getConfiguredAdoRepositoryGuid(project);
+  if (configured) return configured;
+
+  const lookupKey = getAdoRepositoryLookupKey(project);
+  if (!lookupKey) {
+    logMissingAdoRepository(project, purpose);
+    return null;
+  }
+
+  try {
+    const repoUrl = `${orgBase}/${project.adoProject}/_apis/git/repositories/${encodeURIComponent(lookupKey)}?api-version=7.1`;
+    const repoData = await adoFetch(repoUrl, token, opts);
+    const guid = String(repoData?.id || '').trim();
+    if (!isAdoGuid(guid)) {
+      log('error', `${purpose} disabled for project ${getAdoProjectLabel(project)}: ADO repository lookup for "${lookupKey}" did not return a repository GUID`);
+      return null;
+    }
+    persistAdoRepositoryGuid(project, guid, repoData?.name || project.repoName || '');
+    return guid;
+  } catch (e) {
+    log('warn', `${purpose} could not resolve repository GUID for project ${getAdoProjectLabel(project)} from "${lookupKey}": ${e.message}`);
+    return null;
+  }
+}
+
+function markBuildStatusStale(pr, detail) {
+  pr._buildStatusStale = true;
+  if (detail) pr._buildStatusDetail = detail;
+}
+
+function clearBuildStatusStale(pr) {
+  if (pr._buildStatusStale) delete pr._buildStatusStale;
+  if (pr._buildStatusDetail) delete pr._buildStatusDetail;
+}
+
 // ── Build/Review Status Helpers ───────────────────────────────────────────────
 
 /** Classify an array of ADO build records into a single status string. */
@@ -353,9 +446,6 @@ async function pollPrStatus(config) {
     const repoBase = `${orgBase}/${project.adoProject}/_apis/git/repositories/${encodedRepoId}/pullrequests/${prNum}`;
     let updated = false;
 
-    // Clear stale flag — we're attempting a fresh poll
-    if (pr._buildStatusStale) { delete pr._buildStatusStale; updated = true; }
-
     const prData = await adoFetch(`${repoBase}?api-version=7.1`, token);
 
     const sourceBranch = stripRefsHeads(prData.sourceRefName);
@@ -387,6 +477,8 @@ async function pollPrStatus(config) {
           delete pr.buildFailReason;
           delete pr.buildErrorLog;
           delete pr._buildFailNotified;
+          delete pr._buildStatusStale;
+          delete pr._buildStatusDetail;
           delete pr.buildFixAttempts;
           delete pr.buildFixEscalated;
         }
@@ -485,42 +577,59 @@ async function pollPrStatus(config) {
     // merge commit (same ref accumulates builds across all prior pushes to the PR).
     const prNumber = pr.prNumber;
     const mergeCommitId = prData.lastMergeCommit?.commitId;
-    let buildStatus = 'none';
-    let buildFailReason = '';
+    let buildStatus = pr.buildStatus || 'none';
+    let buildFailReason = pr.buildFailReason || '';
     let buildStatuses = []; // for error log fetching
+    let buildStatusResolved = true;
+    let buildStatusStaleDetail = '';
 
     if (prNumber && mergeCommitId) {
-      try {
-        const mergeRef = encodeURIComponent(`refs/pull/${prNumber}/merge`);
-        const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodedRepoId}&repositoryType=TfsGit&$top=25&api-version=7.1`;
-        const buildsData = await adoFetch(buildsUrl, token);
-        const allBuilds = buildsData?.value || [];
-        const prBuilds = allBuilds.filter(b => b.sourceVersion === mergeCommitId);
-
-        if (prBuilds.length > 0) {
-          buildStatus = classifyBuildStatus(prBuilds);
-          if (buildStatus === 'failing') {
-            const failed = prBuilds.find(b => b.result === 'failed');
-            buildFailReason = failed?.definition?.name || 'Build failed';
-            // Build fake status objects for error log fetching
-            buildStatuses = prBuilds.filter(b => b.result === 'failed').map(b => ({
-              state: 'failed', targetUrl: `${orgBase}/${project.adoProject}/_build/results?buildId=${b.id}`,
-              _buildId: String(b.id),
-            }));
+      const buildRepositoryGuid = await resolveAdoBuildRepositoryGuid(project, token, orgBase, 'ADO build polling');
+      if (!buildRepositoryGuid) {
+        buildStatusResolved = false;
+        buildStatusStaleDetail = 'ADO Builds API requires a repository GUID; repository GUID could not be resolved from project.repositoryId/project.repoName';
+      } else {
+        try {
+          const mergeRef = encodeURIComponent(`refs/pull/${prNumber}/merge`);
+          const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodeURIComponent(buildRepositoryGuid)}&repositoryType=TfsGit&$top=25&api-version=7.1`;
+          const buildsData = await adoFetch(buildsUrl, token);
+          const allBuilds = buildsData?.value || [];
+          const prBuilds = allBuilds.filter(b => b.sourceVersion === mergeCommitId);
+          buildStatus = 'none';
+          buildFailReason = '';
+
+          if (prBuilds.length > 0) {
+            buildStatus = classifyBuildStatus(prBuilds);
+            if (buildStatus === 'failing') {
+              const failed = prBuilds.find(b => b.result === 'failed');
+              buildFailReason = failed?.definition?.name || 'Build failed';
+              // Build fake status objects for error log fetching
+              buildStatuses = prBuilds.filter(b => b.result === 'failed').map(b => ({
+                state: 'failed', targetUrl: `${orgBase}/${project.adoProject}/_build/results?buildId=${b.id}`,
+                _buildId: String(b.id),
+              }));
+            }
+          } else if (allBuilds.length > 0 && pr.buildStatus) {
+            // Stale merge-commit fallback — ADO returned builds for this PR's merge ref
+            // but none target the current `mergeCommitId`. Most likely the target branch
+            // moved, ADO recomputed the merge commit, but no new source-side changes
+            // triggered a rebuild. Preserve the previous `pr.buildStatus` so the tracker
+            // reflects the last known truth instead of flipping to a spurious 'none'.
+            // Also log a warn so stale states are detectable in engine logs. Issue #1233.
+            const sampleSv = (allBuilds[0]?.sourceVersion || '').slice(0, 8);
+            log('warn', `PR ${pr.id} build: merge-commit mismatch — ${allBuilds.length} build(s) on merge ref, none target current merge commit ${String(mergeCommitId).slice(0, 8)} (sample sourceVersion ${sampleSv}); preserving previous buildStatus '${pr.buildStatus}'`);
+            buildStatus = pr.buildStatus;
+            if (pr.buildFailReason) buildFailReason = pr.buildFailReason;
           }
-        } else if (allBuilds.length > 0 && pr.buildStatus) {
-          // Stale merge-commit fallback — ADO returned builds for this PR's merge ref
-          // but none target the current `mergeCommitId`. Most likely the target branch
-          // moved, ADO recomputed the merge commit, but no new source-side changes
-          // triggered a rebuild. Preserve the previous `pr.buildStatus` so the tracker
-          // reflects the last known truth instead of flipping to a spurious 'none'.
-          // Also log a warn so stale states are detectable in engine logs. Issue #1233.
-          const sampleSv = (allBuilds[0]?.sourceVersion || '').slice(0, 8);
-          log('warn', `PR ${pr.id} build: merge-commit mismatch — ${allBuilds.length} build(s) on merge ref, none target current merge commit ${String(mergeCommitId).slice(0, 8)} (sample sourceVersion ${sampleSv}); preserving previous buildStatus '${pr.buildStatus}'`);
-          buildStatus = pr.buildStatus;
-          if (pr.buildFailReason) buildFailReason = pr.buildFailReason;
+        } catch (e) {
+          buildStatusResolved = false;
+          buildStatusStaleDetail = `ADO build query failed: ${e.message}`;
+          log('warn', `ADO build query for ${pr.id}: ${e.message}; preserving previous buildStatus '${pr.buildStatus || 'none'}'`);
         }
-      } catch (e) { log('warn', `ADO build query for ${pr.id}: ${e.message}`); }
+      }
+    } else {
+      buildStatus = 'none';
+      buildFailReason = '';
     }
 
     // Record actual poll time — makes lastBuildCheck reflect when the engine last
@@ -528,50 +637,64 @@ async function pollPrStatus(config) {
     pr.lastBuildCheck = ts();
     updated = true;
 
-    if (pr.buildStatus !== buildStatus) {
-      log('info', `PR ${pr.id} build: ${pr.buildStatus || 'none'} → ${buildStatus}${buildFailReason ? ' (' + buildFailReason + ')' : ''}`);
-      pr.buildStatus = buildStatus;
-      if (buildFailReason) pr.buildFailReason = buildFailReason;
-      else delete pr.buildFailReason;
-      // Build transitioned — clear grace period and auto-complete flag
-      delete pr._buildFixPushedAt;
-      if (buildStatus === 'failing') delete pr._autoCompleted;
-      if (buildStatus !== 'failing') {
-        delete pr._buildFailNotified;
-        // Preserve buildErrorLog + buildFixAttempts through transient 'none'/'running'
-        // transitions — only clear on confirmed 'passing' recovery. Issue #1232: 'none'
-        // can also occur when ADO recomputes the merge commit after a target-branch
-        // update but no new builds have been triggered yet (filter by sourceVersion
-        // returns []), which previously wiped the last known error log and caused
-        // fix agents to be dispatched blind.
-        if (buildStatus === 'passing') {
-          delete pr.buildErrorLog;
-          // Reset build fix retry counter on recovery — allows fresh auto-fix cycles if build breaks again
-          if (pr.buildFixAttempts) { delete pr.buildFixAttempts; delete pr.buildFixEscalated; }
-        }
+    if (buildStatusResolved) {
+      if (pr._buildStatusStale || pr._buildStatusDetail) {
+        clearBuildStatusStale(pr);
+        updated = true;
       }
+    } else {
+      markBuildStatusStale(pr, buildStatusStaleDetail);
       updated = true;
+    }
 
-      // Fetch actual compiler/build error logs when transitioning to failing
-      if (buildStatus === 'failing') {
-        const failedStatusObjs = buildStatuses.filter(s => s.state === 'failed' || s.state === 'error').slice(0, 10);
-        const logParts = [];
-        const seenBuildIds = new Set();
-        for (const failedStatusObj of failedStatusObjs) {
-          const errorLog = await fetchAdoBuildErrorLog(orgBase, project, failedStatusObj, token, pr, seenBuildIds);
-          if (errorLog) logParts.push(errorLog);
-        }
-        if (logParts.length > 0) {
-          pr.buildErrorLog = logParts.join('\n\n');
-          log('info', `PR ${pr.id}: fetched error logs from ${logParts.length} failing pipeline(s)`);
+    if (buildStatusResolved) {
+      if (pr.buildStatus !== buildStatus) {
+        log('info', `PR ${pr.id} build: ${pr.buildStatus || 'none'} → ${buildStatus}${buildFailReason ? ' (' + buildFailReason + ')' : ''}`);
+        pr.buildStatus = buildStatus;
+        if (buildFailReason) pr.buildFailReason = buildFailReason;
+        else delete pr.buildFailReason;
+        // Build transitioned — clear grace period and auto-complete flag
+        delete pr._buildFixPushedAt;
+        if (buildStatus === 'failing') delete pr._autoCompleted;
+        if (buildStatus !== 'failing') {
+          delete pr._buildFailNotified;
+          delete pr._buildStatusStale;
+          delete pr._buildStatusDetail;
+          // Preserve buildErrorLog + buildFixAttempts through transient 'none'/'running'
+          // transitions — only clear on confirmed 'passing' recovery. Issue #1232: 'none'
+          // can also occur when ADO recomputes the merge commit after a target-branch
+          // update but no new builds have been triggered yet (filter by sourceVersion
+          // returns []), which previously wiped the last known error log and caused
+          // fix agents to be dispatched blind.
+          if (buildStatus === 'passing') {
+            delete pr.buildErrorLog;
+            // Reset build fix retry counter on recovery — allows fresh auto-fix cycles if build breaks again
+            if (pr.buildFixAttempts) { delete pr.buildFixAttempts; delete pr.buildFixEscalated; }
+          }
         }
+        updated = true;
 
-        // Teams notification for build failure — non-blocking
-        try {
-          const teams = require('./teams');
-          const prFilePath = shared.projectPrPath(project);
-          teams.teamsNotifyPrEvent(pr, 'build-failed', project, prFilePath).catch(() => {});
-        } catch {}
+        // Fetch actual compiler/build error logs when transitioning to failing
+        if (buildStatus === 'failing') {
+          const failedStatusObjs = buildStatuses.filter(s => s.state === 'failed' || s.state === 'error').slice(0, 10);
+          const logParts = [];
+          const seenBuildIds = new Set();
+          for (const failedStatusObj of failedStatusObjs) {
+            const errorLog = await fetchAdoBuildErrorLog(orgBase, project, failedStatusObj, token, pr, seenBuildIds);
+            if (errorLog) logParts.push(errorLog);
+          }
+          if (logParts.length > 0) {
+            pr.buildErrorLog = logParts.join('\n\n');
+            log('info', `PR ${pr.id}: fetched error logs from ${logParts.length} failing pipeline(s)`);
+          }
+
+          // Teams notification for build failure — non-blocking
+          try {
+            const teams = require('./teams');
+            const prFilePath = shared.projectPrPath(project);
+            teams.teamsNotifyPrEvent(pr, 'build-failed', project, prFilePath).catch(() => {});
+          } catch {}
+        }
       }
     }
 
@@ -618,7 +741,7 @@ async function pollPrStatus(config) {
       // Auth errors → mark build status stale so dashboard shows uncertainty
       // and engine re-polls on next tick instead of waiting 6 ticks
       if (isAdoAuthError(err)) {
-        pr._buildStatusStale = true;
+        markBuildStatusStale(pr, `ADO auth error: ${err.message}`);
         _adoPollHadAuthFailure = true;
         log('warn', `PR ${pr.id}: build status marked stale (auth error: ${err.message})`);
         return true; // count as updated to persist the stale flag
@@ -923,6 +1046,8 @@ async function checkLiveReviewStatus(pr, project) {
  *   {
  *     buildStatus: 'failing' | 'passing' | 'running' | 'none' | null,
  *     mergeConflict: boolean,
+ *     buildStatusStale?: boolean,
+ *     buildStatusDetail?: string,
  *   }
  *
  * `buildStatus` is null when ADO has builds on the merge ref but none target the
@@ -937,12 +1062,12 @@ async function checkLiveBuildAndConflict(pr, project) {
     const orgBase = shared.getAdoOrgBase(project);
     const prNum = shared.getPrNumber(pr);
     if (!prNum) return null;
-    const adoRepositoryId = getAdoRepositoryId(project);
-    if (!adoRepositoryId) {
+    const adoRepositoryLookupKey = getAdoRepositoryLookupKey(project);
+    if (!adoRepositoryLookupKey) {
       logMissingAdoRepository(project, 'ADO live build/conflict check');
       return null;
     }
-    const encodedRepoId = encodeURIComponent(adoRepositoryId);
+    const encodedRepoId = encodeURIComponent(adoRepositoryLookupKey);
     const repoBase = `${orgBase}/${project.adoProject}/_apis/git/repositories/${encodedRepoId}`;
     const prUrl = `${repoBase}/pullrequests/${prNum}?api-version=7.1`;
     // 4s timeout — same budget as checkLiveReviewStatus. This is a pre-dispatch
@@ -959,23 +1084,35 @@ async function checkLiveBuildAndConflict(pr, project) {
     // pollPrStatus's narrowing logic so the live check and the cached poll
     // agree on what 'failing' / 'passing' / 'running' / 'none' mean.
     let buildStatus = null;
+    let buildStatusStale = false;
+    let buildStatusDetail = '';
     if (prData.status === 'active') {
       const mergeCommitId = prData.lastMergeCommit?.commitId;
       if (mergeCommitId) {
-        try {
-          const mergeRef = encodeURIComponent(`refs/pull/${prNum}/merge`);
-          const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodedRepoId}&repositoryType=TfsGit&$top=25&api-version=7.1`;
-          const buildsData = await adoFetch(buildsUrl, token, { timeout: 4000 });
-          const allBuilds = buildsData?.value || [];
-          const prBuilds = allBuilds.filter(b => b.sourceVersion === mergeCommitId);
-          if (prBuilds.length > 0) {
-            buildStatus = classifyBuildStatus(prBuilds);
-          } else if (allBuilds.length === 0) {
-            buildStatus = 'none';
+        const buildRepositoryGuid = await resolveAdoBuildRepositoryGuid(project, token, orgBase, 'ADO live build check', { timeout: 4000 });
+        if (!buildRepositoryGuid) {
+          buildStatusStale = true;
+          buildStatusDetail = 'ADO Builds API requires a repository GUID; repository GUID could not be resolved from project.repositoryId/project.repoName';
+        } else {
+          try {
+            const mergeRef = encodeURIComponent(`refs/pull/${prNum}/merge`);
+            const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodeURIComponent(buildRepositoryGuid)}&repositoryType=TfsGit&$top=25&api-version=7.1`;
+            const buildsData = await adoFetch(buildsUrl, token, { timeout: 4000 });
+            const allBuilds = buildsData?.value || [];
+            const prBuilds = allBuilds.filter(b => b.sourceVersion === mergeCommitId);
+            if (prBuilds.length > 0) {
+              buildStatus = classifyBuildStatus(prBuilds);
+            } else if (allBuilds.length === 0) {
+              buildStatus = 'none';
+            }
+            // else: merge-commit mismatch — leave buildStatus null so caller
+            // falls back to cached state (issue #1233).
+          } catch (e) {
+            buildStatusStale = true;
+            buildStatusDetail = `ADO live build query failed: ${e.message}`;
+            log('warn', `Live build check builds query for ${pr.id}: ${e.message}`);
           }
-          // else: merge-commit mismatch — leave buildStatus null so caller
-          // falls back to cached state (issue #1233).
-        } catch (e) { log('warn', `Live build check builds query for ${pr.id}: ${e.message}`); }
+        }
       } else {
         // No merge commit yet — likely conflict or fresh PR. Treat as 'none'
         // so a stale 'failing' cache can be cleared by the caller.
@@ -983,7 +1120,11 @@ async function checkLiveBuildAndConflict(pr, project) {
       }
     }
 
-    return { buildStatus, mergeConflict };
+    return {
+      buildStatus,
+      mergeConflict,
+      ...(buildStatusStale ? { buildStatusStale, buildStatusDetail } : {}),
+    };
   } catch (e) {
     log('warn', `Live build/conflict check for ${pr.id}: ${e.message}`);
     return null;
@@ -1007,7 +1148,8 @@ async function fetchAdoPrMetadata(prNum, adoOrg, adoProj, adoRepo) {
 /**
  * Fetch live PR and build status for a single PR number.
  * Used by engine/ado-status.js so agents can check CI without raw curl calls.
- * Returns { prNumber, title, branch, status, reviewStatus, buildStatus, buildErrorLog?,
+ * Returns { prNumber, title, branch, status, reviewStatus, buildStatus,
+ *           buildStatusStale?, buildStatusDetail?, buildErrorLog?,
  *           mergeConflict, url, project } or null on auth failure.
  */
 async function fetchSinglePrBuildStatus(project, prNumber) {
@@ -1015,29 +1157,45 @@ async function fetchSinglePrBuildStatus(project, prNumber) {
   if (!token) return null;
 
   const orgBase = getAdoOrgBase(project);
-  const adoRepositoryId = getAdoRepositoryId(project);
-  if (!adoRepositoryId) {
+  const adoRepositoryLookupKey = getAdoRepositoryLookupKey(project);
+  if (!adoRepositoryLookupKey) {
     logMissingAdoRepository(project, 'ADO single PR status fetch');
     return null;
   }
-  const encodedRepoId = encodeURIComponent(adoRepositoryId);
+  const encodedRepoId = encodeURIComponent(adoRepositoryLookupKey);
   const repoBase = `${orgBase}/${project.adoProject}/_apis/git/repositories/${encodedRepoId}`;
-  const mergeRef = encodeURIComponent(`refs/pull/${prNumber}/merge`);
-  const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodedRepoId}&repositoryType=TfsGit&$top=25&api-version=7.1`;
 
-  // Fetch PR metadata and builds in parallel
-  const [prData, buildsData] = await Promise.all([
+  // Fetch PR metadata and resolve the Builds API repository GUID in parallel.
+  const [prData, buildRepositoryGuid] = await Promise.all([
     adoFetch(`${repoBase}/pullrequests/${prNumber}?api-version=7.1`, token),
-    adoFetch(buildsUrl, token).catch(() => null),
+    resolveAdoBuildRepositoryGuid(project, token, orgBase, 'ADO single PR status fetch'),
   ]);
   if (!prData) return null;
 
+  let buildsData = null;
+  let buildStatusStale = false;
+  let buildStatusDetail = '';
+  if (buildRepositoryGuid) {
+    try {
+      const mergeRef = encodeURIComponent(`refs/pull/${prNumber}/merge`);
+      const buildsUrl = `${orgBase}/${project.adoProject}/_apis/build/builds?branchName=${mergeRef}&repositoryId=${encodeURIComponent(buildRepositoryGuid)}&repositoryType=TfsGit&$top=25&api-version=7.1`;
+      buildsData = await adoFetch(buildsUrl, token);
+    } catch (e) {
+      buildStatusStale = true;
+      buildStatusDetail = `ADO build query failed: ${e.message}`;
+      log('warn', `fetchSinglePrBuildStatus builds query for PR #${prNumber}: ${e.message}`);
+    }
+  } else {
+    buildStatusStale = true;
+    buildStatusDetail = 'ADO Builds API requires a repository GUID; repository GUID could not be resolved from project.repositoryId/project.repoName';
+  }
+
   const mergeCommitId = prData.lastMergeCommit?.commitId;
   const prBuilds = mergeCommitId
     ? (buildsData?.value || []).filter(b => b.sourceVersion === mergeCommitId)
     : [];
 
-  let buildStatus = classifyBuildStatus(prBuilds);
+  let buildStatus = buildStatusStale ? null : classifyBuildStatus(prBuilds);
   let buildErrorLog = null;
 
   if (buildStatus === 'failing') {
@@ -1067,6 +1225,7 @@ async function fetchSinglePrBuildStatus(project, prNumber) {
     status: prData.status || 'unknown',
     reviewStatus: votesToReviewStatus(votes),
     buildStatus,
+    ...(buildStatusStale ? { buildStatusStale, buildStatusDetail } : {}),
     ...(buildErrorLog ? { buildErrorLog } : {}),
     mergeConflict: prData.mergeStatus === 'conflicts',
     url: prUrl,

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-01T01:02:02.441Z"
+  "cachedAt": "2026-05-01T01:28:04.266Z"
 }

package/engine/lifecycle.js

@@ -787,9 +787,15 @@ function syncPrsFromOutput(output, agentId, meta, config) {
   if (!output || !String(output).trim()) {
     const today = dateStamp();
     const inboxFiles = getInboxFiles().filter(f => f.includes(agentId) && f.includes(today));
+    const currentItemId = meta?.item?.id ? String(meta.item.id) : '';
+    function isCurrentItemInboxNote(fileName, content) {
+      if (!currentItemId) return true;
+      return String(fileName || '').includes(currentItemId) || String(content || '').includes(currentItemId);
+    }
     for (const f of inboxFiles) {
       const content = safeRead(path.join(INBOX_DIR, f));
       if (!content) continue;
+      if (!isCurrentItemInboxNote(f, content)) continue;
       const prHeaderPattern = /(?:^|\n)\s*\*{0,2}(?:PR|Pull\s+Request|E2E\s+PR)\s+(?:created|opened|submitted)\*{0,2}\s*[:\-]\s*([^\n]+)/gi;
       while ((match = prHeaderPattern.exec(content)) !== null) {
         addPrUrlEvidence(match[1]);
@@ -1698,6 +1704,119 @@ function normalizeCompletionStatus(status) {
   return String(status || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
 }
 
+function isTerminalPendingValue(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return true;
+  return /^(?:none|n\/a|na|no|nothing|not-applicable|not applicable|-)$/.test(text)
+    || /^no\s+(?:pending|remaining|outstanding)\b/.test(text)
+    || /^(?:all\s+)?(?:pending|remaining|outstanding)\s+(?:work|items?|tasks?)?\s*(?:resolved|complete|completed|done|closed)$/.test(text);
+}
+
+function isTerminalPendingLine(line) {
+  const text = String(line || '').trim().toLowerCase();
+  return /\bno\s+pending\b/.test(text)
+    || /\bpending\s*[:=-]\s*(?:none|n\/a|na|no|nothing|not applicable|-)\b/.test(text)
+    || /\bpending\s+(?:work|items?|tasks?)?\s*(?:resolved|complete|completed|done|closed)\b/.test(text);
+}
+
+function detectNonTerminalResultSummary(resultSummary, structuredCompletion) {
+  const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  if (completionStatus) {
+    if (/^(?:partial|partially-complete|in-progress|pending|deferred|blocked|incomplete|to-be-continued)/.test(completionStatus)) {
+      return {
+        phrase: `status:${structuredCompletion.status}`,
+        reason: `Nonterminal completion summary: structured status is '${structuredCompletion.status}'`,
+      };
+    }
+    if (/^(?:fail|failed|failure|error)/.test(completionStatus)) {
+      return {
+        phrase: `status:${structuredCompletion.status}`,
+        reason: `Nonterminal completion summary: structured status is '${structuredCompletion.status}', not a successful terminal state`,
+      };
+    }
+  }
+
+  if (structuredCompletion?.pending && !isTerminalPendingValue(structuredCompletion.pending)) {
+    return {
+      phrase: 'pending',
+      reason: `Nonterminal completion summary: pending work remains (${String(structuredCompletion.pending).slice(0, 160)})`,
+    };
+  }
+
+  const text = String(resultSummary || '').replace(/\r/g, '').trim();
+  if (!text) return null;
+
+  const patterns = [
+    { phrase: 'still running', re: /\b(?:still|currently|continues?\s+to\s+be)\s+(?:running|ongoing|in\s+progress)\b/i },
+    { phrase: 'will check later', re: /\b(?:i(?:'|’)ll|i\s+will|we(?:'|’)ll|we\s+will|will)\s+(?:check|verify|review|follow\s+up|revisit)\s+(?:again\s+)?(?:later|soon|in\b|after\b|when\b)/i },
+    { phrase: 'wake up', re: /\bwake(?:\s|-)?up\b|\bwake\b.*\b(?:check|verify|review)\b/i },
+    { phrase: 'not yet complete', re: /\b(?:not\s+yet|isn(?:'|’)t|not|incomplete|not\s+fully|not\s+completely)\s+(?:complete|completed|done|finished|validated|verified)\b/i },
+    { phrase: 'partial', re: /\bpartial(?:ly)?\b/i },
+    { phrase: 'to be continued', re: /\bto\s+be\s+continued\b|\btbc\b/i },
+    { phrase: 'in progress', re: /\bin\s+progress\b|\bongoing\b|\bincomplete\b/i },
+  ];
+  for (const { phrase, re } of patterns) {
+    if (re.test(text)) {
+      return { phrase, reason: `Nonterminal completion summary: matched '${phrase}'` };
+    }
+  }
+
+  const pendingLines = text.split('\n').filter(line => /\bpending\b/i.test(line));
+  for (const line of pendingLines) {
+    if (!isTerminalPendingLine(line)) {
+      return { phrase: 'pending', reason: `Nonterminal completion summary: matched 'pending'` };
+    }
+  }
+
+  return null;
+}
+
+function deferNonTerminalCompletion(meta, detection) {
+  const itemId = meta?.item?.id;
+  const reason = detection?.reason || 'Nonterminal completion summary';
+  if (!itemId) return reason;
+  const wiPath = resolveWorkItemPath(meta);
+  if (!wiPath) return reason;
+
+  let finalStatus = WI_STATUS.PENDING;
+  try {
+    mutateJsonFileLocked(wiPath, data => {
+      if (!Array.isArray(data)) return data;
+      const w = data.find(i => i.id === itemId);
+      if (!w) return data;
+      const retries = w._retryCount || 0;
+      if (retries < ENGINE_DEFAULTS.maxRetries) {
+        w.status = WI_STATUS.PENDING;
+        w._retryCount = retries + 1;
+        w._lastRetryAt = ts();
+        w._lastRetryReason = reason;
+        w._pendingReason = 'nonterminal_completion';
+        delete w.completedAt;
+        delete w.dispatched_at;
+        delete w.dispatched_to;
+        delete w.failedAt;
+        finalStatus = WI_STATUS.PENDING;
+        log('warn', `Work item ${itemId} reported nonterminal success — retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}: ${reason}`);
+      } else {
+        w.status = WI_STATUS.FAILED;
+        w.failReason = `${reason} after ${ENGINE_DEFAULTS.maxRetries} attempts`;
+        w.failedAt = ts();
+        delete w.completedAt;
+        delete w.dispatched_at;
+        delete w.dispatched_to;
+        delete w._pendingReason;
+        finalStatus = WI_STATUS.FAILED;
+        log('warn', `Work item ${itemId} failed — repeated nonterminal completion summaries after ${ENGINE_DEFAULTS.maxRetries} attempts`);
+      }
+      return data;
+    }, { defaultValue: [], skipWriteIfUnchanged: true });
+    syncPrdItemStatus(itemId, finalStatus, meta.item?.sourcePlan);
+  } catch (err) {
+    log('warn', `nonterminal completion gate: ${err.message}`);
+  }
+  return reason;
+}
+
 function writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, exitCode) {
   if (!dispatchItem?.id || !outcome) {
     log('warn', 'Cannot write non-clean agent report without dispatch id and outcome');
@@ -1834,6 +1953,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // (P-2a6d9c4f, P-9c4f2d6a) populate dispatchItem.meta.runtimeName at spawn time.
   const runtimeName = dispatchItem.meta?.runtimeName || dispatchItem.runtimeName || 'claude';
   const { resultSummary, taskUsage, sessionId, model } = parseAgentOutput(stdout, runtimeName);
+  const completionGateSummary = resultSummary || (typeof stdout === 'string' && !stdout.includes('"type":') ? stdout : '');
 
   // Try structured completion protocol first (```completion block from agent output)
   const structuredCompletion = parseStructuredCompletion(stdout, runtimeName);
@@ -1872,9 +1992,11 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   const effectiveSuccess = isSuccess || autoRecovered;
 
   const completionStatus = normalizeCompletionStatus(structuredCompletion?.status);
+  let nonCleanReportWritten = false;
   if (completionStatus.startsWith('partial') || autoRecovered || (completionStatus.startsWith('fail') && isSuccess)) {
     const outcome = completionStatus.startsWith('fail') ? 'failure' : 'partial';
-    writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, resultSummary, code);
+    writeNonCleanAgentReport(dispatchItem, agentId, outcome, structuredCompletion, completionGateSummary, code);
+    nonCleanReportWritten = true;
   }
 
   // Handle decomposition results — create sub-items from decompose agent output
@@ -1981,6 +2103,18 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   }
 
   let completionContractFailure = null;
+  if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
+    const nonTerminalCompletion = detectNonTerminalResultSummary(completionGateSummary, structuredCompletion);
+    if (nonTerminalCompletion) {
+      skipDoneStatus = true;
+      const reason = deferNonTerminalCompletion(meta, nonTerminalCompletion);
+      completionContractFailure = { reason, itemId: meta.item.id, nonTerminal: true };
+      if (!nonCleanReportWritten) {
+        writeNonCleanAgentReport(dispatchItem, agentId, 'partial', structuredCompletion, completionGateSummary, code);
+      }
+    }
+  }
+
   if (effectiveSuccess && meta?.item?.id && !skipDoneStatus) {
     completionContractFailure = await enforcePrAttachmentContract(type, meta, agentId, config, resultSummary);
     if (completionContractFailure) skipDoneStatus = true;
@@ -2316,6 +2450,7 @@ module.exports = {
   parseReviewVerdict,
   isReviewBailout,
   parseStructuredCompletion,
+  detectNonTerminalResultSummary,
   runPostCompletionHooks,
   syncPrdFromPrs,
   resolveWorkItemPath,

package/engine/timeout.js

@@ -147,7 +147,7 @@ function checkTimeouts(config) {
   const engineRestartGraceUntil = engine().engineRestartGraceUntil;
   const engineRestartGraceExempt = engine().engineRestartGraceExempt;
   const { completeDispatch } = dispatch();
-  const { runPostCompletionHooks } = require('./lifecycle');
+  const { runPostCompletionHooks, parseAgentOutput, parseStructuredCompletion, detectNonTerminalResultSummary } = require('./lifecycle');
 
   const timeout = config.engine?.agentTimeout || ENGINE_DEFAULTS.agentTimeout;
   const defaultStaleOrphanTimeout = config.engine?.heartbeatTimeout || ENGINE_DEFAULTS.heartbeatTimeout;
@@ -257,12 +257,25 @@ function checkTimeouts(config) {
           safeWrite(outputLogPath, `# Output for dispatch ${item.id}\n# Exit code: ${processExitCode}\n# Completed: ${ts()}\n# Detected via output scan\n\n## Result\n${text || '(no text)'}\n`);
         } catch (e) { log('warn', 'parse output result: ' + e.message); }
 
-        completeDispatch(item.id, isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR,
-          isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`);
+        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
+        let completionDetection = null;
+        let outputResultSummary = '';
+        try {
+          const runtimeName = item.meta?.runtimeName || item.runtimeName || 'claude';
+          outputResultSummary = parseAgentOutput(fullLogForHooks, runtimeName).resultSummary || '';
+          const gateSummary = outputResultSummary || (!fullLogForHooks.includes('"type":') ? fullLogForHooks : '');
+          completionDetection = isSuccess
+            ? detectNonTerminalResultSummary(gateSummary, parseStructuredCompletion(fullLogForHooks, runtimeName))
+            : null;
+        } catch (e) { log('warn', 'completion summary gate: ' + e.message); }
+
+        completeDispatch(item.id, completionDetection ? DISPATCH_RESULT.ERROR : (isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR),
+          completionDetection ? completionDetection.reason : (isSuccess ? 'Completed (detected from output)' : `Exited with code ${processExitCode} (detected from output)`),
+          outputResultSummary,
+          completionDetection ? { processWorkItemFailure: false } : {});
 
         // Run post-completion hooks via shared helper (async — fire and forget in timeout context).
         // Pass the actual exit code so autoRecovery (PR-created-but-failed) still works correctly.
-        const fullLogForHooks = safeRead(liveLogPath) || liveLogTail;
         runPostCompletionHooks(item, item.agent, processExitCode, fullLogForHooks, config).catch(e => log('warn', 'post-completion hooks: ' + e.message));
 
         if (hasProcess) {

package/engine.js

@@ -2383,6 +2383,16 @@ async function discoverFromPrs(config, project) {
       try {
         const checkBcFn = project.repoHost === 'github' ? ghCheckLiveBuildAndConflict : adoCheckLiveBuildAndConflict;
         const live = await checkBcFn(pr, project);
+        if (live?.buildStatusStale) {
+          try {
+            mutatePullRequests(projectPrPath(project), prs => {
+              const target = shared.findPrRecord(prs, pr, project);
+              if (!target) return;
+              target._buildStatusStale = true;
+              if (live.buildStatusDetail) target._buildStatusDetail = live.buildStatusDetail;
+            });
+          } catch {}
+        }
         if (live && live.buildStatus && live.buildStatus !== 'failing') {
           log('info', `Pre-dispatch build check: ${pr.id} build is ${live.buildStatus} (cached was failing) — skipping build-fix`);
           // Persist the fresh status so subsequent ticks don't re-check on every pass
@@ -2391,6 +2401,8 @@ async function discoverFromPrs(config, project) {
               const target = shared.findPrRecord(prs, pr, project);
               if (!target) return;
               target.buildStatus = live.buildStatus;
+              delete target._buildStatusStale;
+              delete target._buildStatusDetail;
               if (live.buildStatus === 'passing') {
                 delete target.buildErrorLog;
                 delete target.buildFailReason;

package/package.json

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