@yemi33/minions 0.1.1653 → 0.1.1655

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1655 (2026-05-01)
+
+### Features
+- ADO manual PR link metadata and branch race
+
+## 0.1.1654 (2026-05-01)
+
+### Fixes
+-  harden orchestration reliability
+
 ## 0.1.1653 (2026-05-01)
 
 ### Fixes

package/dashboard/js/settings.js

@@ -98,6 +98,10 @@ async function openSettings() {
         '<div style="margin-left:20px;padding-left:10px;border-left:2px solid var(--border);display:flex;flex-direction:column;gap:4px">' +
           settingsToggle('Auto-fix Builds', 'set-autoFixBuilds', e.autoFixBuilds !== false, 'Dispatch gate: auto-fix agent when build fails (downstream of ADO Polling)') +
           settingsToggle('Auto-fix Conflicts', 'set-autoFixConflicts', e.autoFixConflicts !== false, 'Dispatch gate: auto-fix agent when merge conflict detected (downstream of ADO Polling)') +
+          settingsToggle('Auto-review PRs', 'set-autoReviewPrs', e.autoReviewPrs !== false, 'Dispatch gate: review agent for newly opened agent PRs (throttle-aware)') +
+          settingsToggle('Auto-re-review PRs', 'set-autoReReviewPrs', e.autoReReviewPrs !== false, 'Dispatch gate: review agent after a fix push is awaiting re-review (throttle-aware)') +
+          settingsToggle('Auto-fix Review Feedback', 'set-autoFixReviewFeedback', e.autoFixReviewFeedback !== false, 'Dispatch gate: fix agent for minions changes-requested verdicts (throttle-aware)') +
+          settingsToggle('Auto-fix Human Comments', 'set-autoFixHumanComments', e.autoFixHumanComments !== false, 'Dispatch gate: fix agent for actionable human PR comments (throttle-aware)') +
         '</div>' +
       '</div>' +
       settingsToggle('GitHub Polling', 'set-ghPollEnabled', e.ghPollEnabled !== false, 'Keeps GitHub PR build results, votes, and comments fresh each tick (reconciliation always runs regardless)') +
@@ -547,6 +551,10 @@ async function saveSettings() {
       autoArchive: document.getElementById('set-autoArchive').checked,
       autoFixBuilds: document.getElementById('set-autoFixBuilds').checked,
       autoFixConflicts: document.getElementById('set-autoFixConflicts').checked,
+      autoReviewPrs: document.getElementById('set-autoReviewPrs').checked,
+      autoReReviewPrs: document.getElementById('set-autoReReviewPrs').checked,
+      autoFixReviewFeedback: document.getElementById('set-autoFixReviewFeedback').checked,
+      autoFixHumanComments: document.getElementById('set-autoFixHumanComments').checked,
       autoCompletePrs: document.getElementById('set-autoCompletePrs').checked,
       adoPollEnabled: document.getElementById('set-adoPollEnabled').checked,
       ghPollEnabled: document.getElementById('set-ghPollEnabled').checked,

package/dashboard.js

@@ -75,7 +75,42 @@ function getWorkItemIdFromPrLinkContext(context, workItemId) {
   return null;
 }
 
-function linkPullRequestForTracking({ url, title, project: projectName, autoObserve, context, workItemId }, config = CONFIG) {
+function decodeUrlSegment(segment) {
+  try { return decodeURIComponent(segment); } catch { return segment; }
+}
+
+function parseAdoPrMetadataTarget(url) {
+  const raw = String(url || '');
+  const devAzure = raw.match(/https?:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)\/pullrequest\/(\d+)/i);
+  if (devAzure) {
+    return {
+      adoOrg: decodeUrlSegment(devAzure[1]),
+      adoProj: decodeUrlSegment(devAzure[2]),
+      adoRepo: decodeUrlSegment(devAzure[3]),
+      prNum: devAzure[4],
+    };
+  }
+  const visualStudio = raw.match(/https?:\/\/([^/.]+)\.visualstudio\.com\/(?:DefaultCollection\/)?([^/]+)\/_git\/([^/]+)\/pullrequest\/(\d+)/i);
+  if (!visualStudio) return null;
+  return {
+    adoOrg: `${decodeUrlSegment(visualStudio[1])}.visualstudio.com`,
+    adoProj: decodeUrlSegment(visualStudio[2]),
+    adoRepo: decodeUrlSegment(visualStudio[3]),
+    prNum: visualStudio[4],
+  };
+}
+
+function normalizePrMetadata(metadata) {
+  if (!metadata || typeof metadata !== 'object') return null;
+  return {
+    title: typeof metadata.title === 'string' ? metadata.title.trim() : '',
+    description: typeof metadata.description === 'string' ? metadata.description : '',
+    branch: typeof metadata.branch === 'string' ? metadata.branch.trim().replace(/^refs\/heads\//i, '') : '',
+    author: typeof metadata.author === 'string' ? metadata.author.trim() : '',
+  };
+}
+
+function linkPullRequestForTracking({ url, title, project: projectName, autoObserve, context, workItemId }, config = CONFIG, options = {}) {
   if (!url) {
     const err = new Error('url required');
     err.statusCode = 400;
@@ -90,13 +125,14 @@ function linkPullRequestForTracking({ url, title, project: projectName, autoObse
   const prId = shared.getCanonicalPrId(targetProject, prNum, url);
   const linkedWorkItemId = getWorkItemIdFromPrLinkContext(context, workItemId);
   const contextText = typeof context === 'string' ? context : (context == null ? '' : JSON.stringify(context));
+  const metadata = normalizePrMetadata(options.metadata);
   const result = shared.upsertPullRequestRecord(prPath, {
     id: prId,
     prNumber: parseInt(prNum, 10) || null,
-    title: (title || 'PR #' + prNum + ' (polling...)').slice(0, 120),
-    description: '',
-    agent: 'human',
-    branch: '',
+    title: (metadata?.title || title || 'PR #' + prNum + ' (polling...)').slice(0, 120),
+    description: metadata?.description ? metadata.description.slice(0, 500) : '',
+    agent: metadata?.author || 'human',
+    branch: metadata?.branch || '',
     reviewStatus: 'pending',
     status: 'active',
     created: new Date().toISOString(),
@@ -5994,7 +6030,16 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       if (!url) return jsonReply(res, 400, { error: 'url required' });
 
       reloadConfig();
-      const { id: prId, prPath, targetProject, prNum, created, linked } = linkPullRequestForTracking(body, CONFIG);
+      const adoTarget = parseAdoPrMetadataTarget(url);
+      let initialPrData = null;
+      if (adoTarget) {
+        try {
+          initialPrData = await ado.fetchAdoPrMetadata(adoTarget.prNum, adoTarget.adoOrg, adoTarget.adoProj, adoTarget.adoRepo);
+        } catch (e) {
+          shared.log('warn', `ADO PR link metadata fetch failed for ${url}: ${e.message}`);
+        }
+      }
+      const { id: prId, prPath, prNum, created, linked } = linkPullRequestForTracking(body, CONFIG, { metadata: initialPrData });
       invalidateStatusCache();
       jsonReply(res, 200, { ok: true, id: prId, created, linked });
 
@@ -6003,16 +6048,14 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         try {
           let prData = null;
           const ghMatch = url.match(/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
-          const adoMatch = url.match(/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)\/pullrequest\/(\d+)/);
           if (ghMatch) {
             const slug = ghMatch[1];
             const result = await shared.execAsync(`gh api "repos/${slug}/pulls/${prNum}"`, { timeout: 15000, encoding: 'utf-8' });
             const d = JSON.parse(result);
             prData = { title: d.title, description: d.body, branch: d.head?.ref, author: d.user?.login };
-          } else if (adoMatch) {
-            const [, adoOrg, adoProj, adoRepo] = adoMatch;
+          } else if (adoTarget && !initialPrData) {
             try {
-              prData = await ado.fetchAdoPrMetadata(prNum, adoOrg, adoProj, adoRepo);
+              prData = await ado.fetchAdoPrMetadata(adoTarget.prNum, adoTarget.adoOrg, adoTarget.adoProj, adoTarget.adoRepo);
             } catch { /* ADO token may not be available */ }
           }
           if (!prData) return;
@@ -6134,6 +6177,12 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/live(?:\?.*)?$/, desc: 'Tail live output for a working agent', params: 'tail? (bytes, default 8192)', handler: handleAgentLive },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)\/output(?:\?.*)?$/, desc: 'Fetch final output.log for an agent', handler: handleAgentOutput },
     { method: 'GET', path: /^\/api\/agent\/([\w-]+)$/, desc: 'Get detailed agent info', handler: handleAgentDetail },
+    { method: 'GET', path: /^\/api\/dispatch\/([\w.-]+)\/completion-report$/, desc: 'Read structured completion report for a dispatch', handler: (req, res, match) => {
+      const id = match && match[1];
+      const payload = queries.getDispatchCompletionReport(id);
+      if (!payload) return jsonReply(res, 404, { error: 'completion report not found' }, req);
+      return jsonReply(res, 200, payload, req);
+    } },
     { method: 'GET', path: '/api/agent-output', desc: 'Read agent output log file', params: 'file', handler: async (req, res) => {
       const file = new URL(req.url, 'http://localhost').searchParams.get('file');
       if (!file || file.includes('..') || file.includes('\0') || !file.startsWith('agents/')) return jsonReply(res, 400, { error: 'invalid file' });

package/engine/ado.js

@@ -138,6 +138,48 @@ function clearBuildStatusStale(pr) {
   if (pr._buildStatusDetail) delete pr._buildStatusDetail;
 }
 
+function isPlaceholderPrTitle(title, prNum) {
+  const text = String(title || '').trim();
+  if (!text) return true;
+  if (/\bpolling\.\.\./i.test(text)) return true;
+  if (String(prNum || '') && (text === `PR #${prNum}` || text === `PR-${prNum}`)) return true;
+  if (/[{}"\[\]]/.test(text)) return true;
+  return /^[0-9a-f-]{8,}$/i.test(text);
+}
+
+function applyAdoPrMetadata(pr, prData, prNum) {
+  if (!pr || !prData) return false;
+  let updated = false;
+
+  const sourceBranch = stripRefsHeads(prData.sourceRefName);
+  if (sourceBranch && (pr.branch !== sourceBranch || pr._branchResolutionError || pr._pendingReason === shared.PR_PENDING_REASON.MISSING_BRANCH)) {
+    pr.branch = sourceBranch;
+    if (pr._branchResolutionError) delete pr._branchResolutionError;
+    if (pr._pendingReason === shared.PR_PENDING_REASON.MISSING_BRANCH) delete pr._pendingReason;
+    updated = true;
+  }
+
+  const title = String(prData.title || '').trim();
+  if (title && isPlaceholderPrTitle(pr.title, prNum) && pr.title !== title.slice(0, 120)) {
+    pr.title = title.slice(0, 120);
+    updated = true;
+  }
+
+  const description = typeof prData.description === 'string' ? prData.description : '';
+  if (description && (pr.description == null || pr.description === '')) {
+    pr.description = description.slice(0, 500);
+    updated = true;
+  }
+
+  const author = String(prData.createdBy?.displayName || '').trim();
+  if (author && pr.agent === 'human') {
+    pr.agent = author;
+    updated = true;
+  }
+
+  return updated;
+}
+
 // ── Build/Review Status Helpers ───────────────────────────────────────────────
 
 /** Classify an array of ADO build records into a single status string. */
@@ -454,13 +496,7 @@ async function pollPrStatus(config) {
 
     const prData = await adoFetch(`${repoBase}?api-version=7.1`, token);
 
-    const sourceBranch = stripRefsHeads(prData.sourceRefName);
-    if (sourceBranch && pr.branch !== sourceBranch) {
-      pr.branch = sourceBranch;
-      if (pr._branchResolutionError) delete pr._branchResolutionError;
-      if (pr._pendingReason === 'missing_pr_branch') delete pr._pendingReason;
-      updated = true;
-    }
+    if (applyAdoPrMetadata(pr, prData, prNum)) updated = true;
 
     let newStatus = pr.status;
     if (prData.status === 'completed') newStatus = PR_STATUS.MERGED;
@@ -1121,7 +1157,8 @@ async function checkLiveBuildAndConflict(pr, project) {
 async function fetchAdoPrMetadata(prNum, adoOrg, adoProj, adoRepo) {
   const token = await getAdoToken();
   if (!token) return null;
-  const url = `https://dev.azure.com/${adoOrg}/${adoProj}/_apis/git/repositories/${adoRepo}/pullrequests/${prNum}?api-version=7.1`;
+  const orgBase = getAdoOrgBase({ adoOrg });
+  const url = `${orgBase}/${encodeURIComponent(adoProj)}/_apis/git/repositories/${encodeURIComponent(adoRepo)}/pullrequests/${encodeURIComponent(String(prNum))}?api-version=7.1`;
   const pr = await adoFetch(url, token);
   if (!pr) return null;
   return {

package/engine/cleanup.js

@@ -724,8 +724,63 @@ function runCleanup(config, verbose = false) {
   // 14. Scrub stale temp agent keys from metrics.json
   try { scrubStaleMetrics(); } catch { /* best-effort cleanup */ }
 
-  if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed + cleaned.notesArchive > 0) {
-    log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.notesArchive} archived notes, ${cleaned.pidFiles} PID files`);
+  // 15. Evict old completion reports — keep reports durable beyond the capped
+  // dispatch history, but bound disk growth by age/count.
+  cleaned.completionReports = 0;
+  try {
+    const dispatch = getDispatch();
+    const protectedReportFiles = new Set();
+    for (const queue of ['pending', 'active', 'completed']) {
+      for (const entry of dispatch[queue] || []) {
+        if (!entry?.id) continue;
+        const reportPath = shared.dispatchCompletionReportPath(entry.id);
+        if (reportPath) protectedReportFiles.add(path.basename(reportPath));
+      }
+    }
+    const configuredRetentionDays = Number(config?.engine?.completionReportRetentionDays ?? ENGINE_DEFAULTS.completionReportRetentionDays);
+    const configuredMaxReports = Number(config?.engine?.completionReportMaxFiles ?? ENGINE_DEFAULTS.completionReportMaxFiles);
+    const retentionDays = Number.isFinite(configuredRetentionDays) ? configuredRetentionDays : ENGINE_DEFAULTS.completionReportRetentionDays;
+    const maxReports = Number.isFinite(configuredMaxReports) ? configuredMaxReports : ENGINE_DEFAULTS.completionReportMaxFiles;
+    const retentionMs = retentionDays > 0 ? retentionDays * 24 * 60 * 60 * 1000 : 0;
+    const cutoffMs = retentionMs > 0 ? Date.now() - retentionMs : 0;
+    const completionsDir = path.join(ENGINE_DIR, 'completions');
+    if (fs.existsSync(completionsDir)) {
+      const reports = fs.readdirSync(completionsDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+          const fp = path.join(completionsDir, f);
+          let mtimeMs = 0;
+          try { mtimeMs = fs.statSync(fp).mtimeMs; } catch {}
+          return { file: f, path: fp, mtimeMs, protected: protectedReportFiles.has(f) };
+        })
+        .filter(r => r.mtimeMs > 0)
+        .sort((a, b) => a.mtimeMs - b.mtimeMs);
+      const removeReport = (report) => {
+        try { fs.unlinkSync(report.path); cleaned.completionReports++; return true; } catch { return false; }
+      };
+      for (const report of reports) {
+        if (report.protected) continue;
+        if (cutoffMs > 0 && report.mtimeMs < cutoffMs) {
+          removeReport(report);
+        }
+      }
+      if (maxReports > 0) {
+        const remaining = reports.filter(r => fs.existsSync(r.path));
+        let overflow = remaining.length - maxReports;
+        for (const report of remaining) {
+          if (overflow <= 0) break;
+          if (report.protected) continue;
+          if (removeReport(report)) overflow--;
+        }
+      }
+      if (cleaned.completionReports > 0) {
+        log('info', `Cleanup: removed ${cleaned.completionReports} old completion report(s)`);
+      }
+    }
+  } catch (e) { log('warn', `cleanupCompletionReports: ${e.message}`); }
+
+  if (cleaned.ccSessions + cleaned.docSessions + cleaned.cooldowns + cleaned.pidFiles + cleaned.pendingContextsTrimmed + cleaned.notesArchive + cleaned.completionReports > 0) {
+    log('info', `Cleanup (resources): ${cleaned.ccSessions} cc-sessions, ${cleaned.docSessions} doc-sessions, ${cleaned.cooldowns} cooldowns, ${cleaned.pendingContextsTrimmed} pendingCtx trimmed, ${cleaned.notesArchive} archived notes, ${cleaned.pidFiles} PID files, ${cleaned.completionReports} completion reports`);
   }
 
   return cleaned;

package/engine/cooldown.js

@@ -117,12 +117,17 @@ function setCooldownWithContext(key, context) {
   saveCooldowns();
 }
 
-function getCoalescedContexts(key) {
+// Drain pending coalesced contexts for a key, clearing the entry's
+// pendingContexts and persisting the change. Returns [] for unknown / empty
+// keys without side effects (no save, no phantom entry creation).
+function drainCoalescedContexts(key) {
   const entry = dispatchCooldowns.get(key);
-  const contexts = entry?.pendingContexts || [];
-  if (contexts.length > 0 && entry) {
-    entry.pendingContexts = []; // Clear after retrieval
+  if (!entry || !Array.isArray(entry.pendingContexts) || entry.pendingContexts.length === 0) {
+    return [];
   }
+  const contexts = entry.pendingContexts;
+  entry.pendingContexts = [];
+  saveCooldowns();
   return contexts;
 }
 
@@ -181,7 +186,7 @@ module.exports = {
   isOnCooldown,
   setCooldown,
   setCooldownWithContext,
-  getCoalescedContexts,
+  drainCoalescedContexts,
   setCooldownFailure,
   clearCooldown,
   isAlreadyDispatched,

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-01T02:44:10.693Z"
+  "cachedAt": "2026-05-01T04:20:15.660Z"
 }

package/engine/dispatch.js

@@ -62,6 +62,10 @@ function mutateDispatch(mutator) {
 function addToDispatch(item) {
   item.id = item.id || `${item.agent}-${item.type}-${shared.uid()}`;
   item.created_at = ts();
+  item.meta = item.meta && typeof item.meta === 'object' ? item.meta : {};
+  if (!item.meta.completionReportPath) {
+    item.meta.completionReportPath = shared.dispatchCompletionReportPath(item.id);
+  }
   let added = false;
   mutateDispatch((dispatch) => {
     // Dedup: skip if same work item ID is already pending or active
@@ -262,6 +266,16 @@ function completeDispatch(id, result = DISPATCH_RESULT.SUCCESS, reason = '', res
     if (reason) item.reason = reason;
     if (resultSummary) item.resultSummary = resultSummary;
     if (failureClass && result === DISPATCH_RESULT.ERROR) item.failureClass = failureClass;
+    item.meta = item.meta && typeof item.meta === 'object' ? item.meta : {};
+    if (opts.completionReportPath && !item.meta.completionReportPath) {
+      item.meta.completionReportPath = opts.completionReportPath;
+    }
+    if (opts.structuredCompletion && typeof opts.structuredCompletion === 'object') {
+      item.structuredCompletion = opts.structuredCompletion;
+      if (opts.structuredCompletion._path && !item.meta.completionReportPath) {
+        item.meta.completionReportPath = opts.structuredCompletion._path;
+      }
+    }
     // Drop prompt (and sidecar file, if any) — completed entries don't need
     // replayable content and it would accumulate forever (#1167).
     try { deleteDispatchPromptSidecar(item); } catch { /* best-effort */ }

package/engine/lifecycle.js

@@ -706,8 +706,9 @@ function reconcilePrdStatuses(config) {
 
 // ─── PR Sync from Output ─────────────────────────────────────────────────────
 
-function syncPrsFromOutput(output, agentId, meta, config) {
-
+function syncPrsFromOutput(output, agentId, meta, config, opts = {}) {
+  const { structuredCompletion = null } = opts;
+  const outputText = String(output || '');
   const prEvidence = new Map();
   const trustedPrCreateToolIds = new Set();
   const prUrlPattern = /(https?:\/\/github\.com\/[^\s"'\\)\]]+\/[^\s"'\\)\]]+\/pull\/(\d+)(?:[^\s"'\\)\]]*)?|https?:\/\/(?:dev\.azure\.com|[^/\s"'\\)\]]+\.visualstudio\.com)[^\s"'\\)\]]*?pullrequest\/(\d+)(?:[^\s"'\\)\]]*)?)/gi;
@@ -735,6 +736,21 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     }
   }
 
+  function addStructuredPrEvidence(completion) {
+    const raw = completion?.pr ?? completion?.pull_request ?? completion?.pullRequest;
+    if (raw == null) return;
+    const values = Array.isArray(raw) ? raw : [raw];
+    for (const value of values) {
+      const text = typeof value === 'object' ? JSON.stringify(value) : String(value || '');
+      if (!text || /^(?:n\/a|na|none|null|no pr|-)\s*$/i.test(text.trim())) continue;
+      const before = prEvidence.size;
+      addPrUrlEvidence(text);
+      if (prEvidence.size > before) continue;
+      const idMatch = text.match(/\b(?:PR|pull\s*request)?\s*#?\s*(\d{1,10})\b/i);
+      if (idMatch && !prEvidence.has(idMatch[1])) prEvidence.set(idMatch[1], '');
+    }
+  }
+
   function isTrustedPrCreateToolUse(block) {
     const name = String(block?.name || '');
     if (/(?:create|open|submit)[_-]?(?:pull[_-]?request|pr)|(?:pull[_-]?request|pr)[_-]?(?:create|open|submit)/i.test(name)) {
@@ -749,7 +765,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
   }
 
   try {
-    const lines = output.split('\n');
+    const lines = outputText.split('\n');
     for (const line of lines) {
       try {
         if (!line.includes('"type":"assistant"') && !line.includes('"type":"result"') && !line.includes('"type":"user"')) continue;
@@ -779,13 +795,15 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     }
   } catch {}
 
+  addStructuredPrEvidence(structuredCompletion);
+
   // Accept inbox fallback ONLY when the agent's stdout is empty (rotated/lost).
   // The inbox note is the durable artifact for the "gh pr create ran in a sibling
   // dispatch whose stdout was rotated" case. When stdout has actual content (even
   // without PR evidence — e.g. the agent ran gh issue view but didn't create a PR),
   // we must NOT pull in PR URLs from leftover inbox files of prior dispatches —
   // those would falsely attribute unrelated PRs to this run.
-  if (!output || !String(output).trim()) {
+  if (!outputText.trim()) {
     const today = dateStamp();
     const inboxFiles = getInboxFiles().filter(f => f.includes(agentId) && f.includes(today));
     const currentItemId = meta?.item?.id ? String(meta.item.id) : '';
@@ -813,13 +831,15 @@ function syncPrsFromOutput(output, agentId, meta, config) {
 
   // Match each PR to its correct project by finding which repo URL appears near the PR number in output
   function resolveProjectForPr(prId) {
+    const evidenceUrl = prEvidence.get(prId) || '';
+    const evidenceText = `${outputText}\n${evidenceUrl}`;
     for (const p of projects) {
       if (!p.prUrlBase) continue;
       const urlFragment = p.prUrlBase.replace(/pullrequest\/$/, '');
-      if (output.includes(urlFragment + 'pullrequest/' + prId) || output.includes(urlFragment + prId)) return p;
+      if (evidenceText.includes(urlFragment + 'pullrequest/' + prId) || evidenceText.includes(urlFragment + prId)) return p;
     }
     for (const p of projects) {
-      if (p.repoName && output.includes(`_git/${p.repoName}/pullrequest/${prId}`)) return p;
+      if (p.repoName && evidenceText.includes(`_git/${p.repoName}/pullrequest/${prId}`)) return p;
     }
     return defaultProject;
   }
@@ -847,7 +867,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
     const fullId = shared.getCanonicalPrId(targetProject, prId, prUrl);
 
     let title = meta?.item?.title || '';
-    const titleMatch = output.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
+    const titleMatch = outputText.match(new RegExp(`${prId}[^\\n]*?[—–-]\\s*([^\\n]+)`, 'i'));
     if (titleMatch) title = titleMatch[1].trim();
     if (title.includes('session_id') || title.includes('is_error') || title.includes('uuid') || title.length > 120 || /[{}"\[\]]/.test(title) || /^[0-9a-f-]{8,}$/i.test(title)) {
       title = meta?.item?.title || '';
@@ -902,7 +922,7 @@ function syncPrsFromOutput(output, agentId, meta, config) {
         log('warn', `Duplicate PR detected: ${fullId} on branch ${entry.branch || entryBranch} — already tracked as ${duplicateOnBranch.id}. Skipping.`);
         // Best-effort close the duplicate on GitHub (non-blocking, fire-and-forget)
         try {
-          const ghSlug = output.match(/github\.com\/([^/]+\/[^/]+)/)?.[1];
+          const ghSlug = outputText.match(/github\.com\/([^/]+\/[^/]+)/)?.[1];
           if (ghSlug) {
             execAsync(`gh pr close ${prId} --repo ${ghSlug} --comment "Closing duplicate — ${duplicateOnBranch.id} already tracks this branch."`, { timeout: 15000 })
               .catch(() => {});
@@ -1750,11 +1770,16 @@ function parseStructuredCompletion(stdout, runtimeName) {
   return result;
 }
 
-function parseCompletionReportFile(dispatchItem) {
+function parseCompletionReportFile(dispatchItem, opts = {}) {
   const reportPath = dispatchItem?.meta?.completionReportPath || shared.dispatchCompletionReportPath(dispatchItem?.id);
-  if (!reportPath || !fs.existsSync(reportPath)) return null;
+  if (!reportPath || !fs.existsSync(reportPath)) {
+    if (opts.warnIfMissing && dispatchItem?.id) {
+      log('warn', `Completion report missing for ${dispatchItem.id}: ${reportPath || '(no path)'}`);
+    }
+    return null;
+  }
   const report = safeJson(reportPath);
-  if (!report || typeof report !== 'object' || Array.isArray(report)) {
+  if (!shared.isPlainObject(report)) {
     log('warn', `Ignoring malformed completion report for ${dispatchItem?.id || 'unknown'}: ${reportPath}`);
     return null;
   }
@@ -1768,6 +1793,29 @@ function parseCompletionReportFile(dispatchItem) {
   return report;
 }
 
+function persistCompletionReport(dispatchItem, completion, source = 'fallback') {
+  if (!dispatchItem?.id || !completion || typeof completion !== 'object') return completion;
+  const reportPath = dispatchItem?.meta?.completionReportPath || shared.dispatchCompletionReportPath(dispatchItem.id);
+  if (!reportPath) return completion;
+  const report = {
+    ...completion,
+    status: completion.status || completion.outcome || 'unknown',
+    _source: source,
+    _path: reportPath,
+    dispatchId: dispatchItem.id,
+    agent: dispatchItem.agent || null,
+    type: dispatchItem.type || null,
+    completedAt: ts(),
+  };
+  try {
+    safeWrite(reportPath, report);
+    log('info', `Persisted ${source} completion report for ${dispatchItem.id}: ${reportPath}`);
+  } catch (err) {
+    log('warn', `Persist fallback completion report for ${dispatchItem.id}: ${err.message}`);
+  }
+  return report;
+}
+
 function normalizeCompletionStatus(status) {
   return String(status || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
 }
@@ -2045,8 +2093,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   let { resultSummary, taskUsage, sessionId, model } = parseAgentOutput(stdout, runtimeName);
 
   // Prefer the sidecar completion report; keep fenced output as a compatibility fallback.
-  const reportCompletion = parseCompletionReportFile(dispatchItem);
-  const structuredCompletion = reportCompletion || parseStructuredCompletion(stdout, runtimeName);
+  const reportCompletion = parseCompletionReportFile(dispatchItem, { warnIfMissing: true });
+  const fallbackCompletion = reportCompletion ? null : parseStructuredCompletion(stdout, runtimeName);
+  const structuredCompletion = reportCompletion || persistCompletionReport(dispatchItem, fallbackCompletion, 'fenced-completion');
   if (structuredCompletion) {
     if (structuredCompletion.summary) resultSummary = String(structuredCompletion.summary);
     log('info', `Structured completion from ${agentId}: status=${structuredCompletion.status}, pr=${structuredCompletion.pr || 'N/A'}${structuredCompletion._source ? ` (${structuredCompletion._source})` : ''}`);
@@ -2073,7 +2122,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
   // Always attempt PR sync — even failed/timed-out agents may have created PRs before dying
   let prsCreatedCount = 0;
   try {
-    prsCreatedCount = syncPrsFromOutput(stdout, agentId, meta, config) || 0;
+    prsCreatedCount = syncPrsFromOutput(stdout, agentId, meta, config, { structuredCompletion }) || 0;
   } catch (err) { log('warn', `PR sync from output: ${err.message}`); }
 
   // Structured completion may report PR even when regex didn't find it
@@ -2559,6 +2608,7 @@ module.exports = {
   parseStructuredCompletion,
   detectNonTerminalResultSummary,
   parseCompletionReportFile,
+  persistCompletionReport,
   runPostCompletionHooks,
   syncPrdFromPrs,
   resolveWorkItemPath,

package/engine/queries.js

@@ -168,14 +168,121 @@ function getDispatch() {
 }
 function invalidateDispatchCache() { _dispatchCache = null; _dispatchCacheAt = 0; }
 
+function _relativeStatePath(filePath) {
+  if (!filePath) return '';
+  try { return path.relative(MINIONS_DIR, filePath).replace(/\\/g, '/'); } catch { return filePath; }
+}
+
+function _findDispatchEntry(dispatch, id) {
+  for (const listName of ['pending', 'active', 'completed']) {
+    const entry = (dispatch[listName] || []).find(d => d.id === id);
+    if (entry) return entry;
+  }
+  return null;
+}
+
+function _completionReportPathForEntry(entryOrId) {
+  const id = typeof entryOrId === 'string' ? entryOrId : entryOrId?.id;
+  return (typeof entryOrId === 'object' && entryOrId?.meta?.completionReportPath)
+    || shared.dispatchCompletionReportPath(id);
+}
+
+// In-memory cache for completion report summaries, keyed by dispatch id.
+// /api/state polls at ~1Hz and re-reads ~40 completion-report files per call;
+// this cache turns those into stat-only checks unless mtime changed.
+const _completionReportCache = new Map();
+
+function _getCachedCompletionSummary(id) {
+  if (!id) return null;
+  const reportPath = shared.dispatchCompletionReportPath(id);
+  let stat;
+  try { stat = fs.statSync(reportPath); }
+  catch { _completionReportCache.delete(id); return null; }
+  const cached = _completionReportCache.get(id);
+  if (cached && cached.mtime === stat.mtimeMs) return cached.summary;
+  const report = safeJson(reportPath);
+  if (!shared.isPlainObject(report)) {
+    _completionReportCache.delete(id);
+    return null;
+  }
+  const summary = {
+    available: true,
+    path: _relativeStatePath(reportPath),
+    status: report.status || report.outcome || '',
+    summary: String(report.summary || '').slice(0, 500),
+    verdict: report.verdict || report.review_verdict || report.reviewVerdict || '',
+    pr: report.pr || report.pull_request || report.pullRequest || '',
+    source: report._source || '',
+  };
+  if (Array.isArray(report.artifacts)) summary.artifacts = report.artifacts.slice(0, 20);
+  _completionReportCache.set(id, { mtime: stat.mtimeMs, summary });
+  return summary;
+}
+
+function _pruneCompletionReportCache(activeIds) {
+  if (_completionReportCache.size < 200) return;
+  for (const id of _completionReportCache.keys()) {
+    if (!activeIds.has(id)) _completionReportCache.delete(id);
+  }
+}
+
+function getDispatchCompletionReport(id) {
+  if (!id) return null;
+  const dispatch = getDispatch();
+  const entry = _findDispatchEntry(dispatch, id);
+  const reportPath = _completionReportPathForEntry(entry || id);
+  // TOCTOU-safe: skip existsSync gate; treat null/non-object safeJson result as not-found.
+  const report = safeJson(reportPath);
+  if (!shared.isPlainObject(report)) return null;
+  return {
+    id,
+    path: _relativeStatePath(reportPath),
+    report,
+    dispatch: entry ? {
+      id: entry.id,
+      agent: entry.agent || '',
+      type: entry.type || '',
+      task: entry.task || '',
+      result: entry.result || '',
+      completed_at: entry.completed_at || '',
+    } : null,
+  };
+}
+
+function _completionReportSummary(entry) {
+  if (!entry?.id) return null;
+  const cached = _getCachedCompletionSummary(entry.id);
+  if (cached) return cached;
+  // Cache miss / file absent — return a "not available" stub keyed off the canonical path.
+  const reportPath = _completionReportPathForEntry(entry);
+  return { available: false, path: _relativeStatePath(reportPath) };
+}
+
+function _withCompletionReportSummary(entry) {
+  if (!entry || typeof entry !== 'object') return entry;
+  return { ...entry, completionReport: _completionReportSummary(entry) };
+}
+
 function getDispatchQueue() {
   const d = getDispatch();
   const allCompleted = d.completed || [];
   // Lifetime total from metrics (dispatch.completed is capped at 100)
   const metrics = readJsonNoRestore(path.join(ENGINE_DIR, 'metrics.json')) || {};
-  d.completedTotal = Object.entries(metrics).filter(([k]) => !k.startsWith('_')).reduce((sum, [, m]) => sum + (m.tasksCompleted || 0) + (m.tasksErrored || 0), 0);
-  d.completed = allCompleted.slice(-20);
-  return d;
+  // Periodically prune cache entries for dispatches that have rotated out of the queue.
+  if (_completionReportCache.size >= 200) {
+    const activeIds = new Set();
+    for (const list of [d.pending, d.active, allCompleted]) {
+      for (const entry of list || []) { if (entry?.id) activeIds.add(entry.id); }
+    }
+    _pruneCompletionReportCache(activeIds);
+  }
+  return {
+    ...d,
+    pending: (d.pending || []).map(_withCompletionReportSummary),
+    active: (d.active || []).map(_withCompletionReportSummary),
+    completed: allCompleted.slice(-20).map(_withCompletionReportSummary),
+    completedTotal: Object.entries(metrics).filter(([k]) => !k.startsWith('_')).reduce((sum, [, m]) => sum + (m.tasksCompleted || 0) + (m.tasksErrored || 0), 0),
+  };
 }
 
 function getNotes() {
@@ -207,7 +314,7 @@ function getMetrics() {
     if (agentId.startsWith('_')) continue;
     metrics[agentId] = {
       ...DEFAULT_AGENT_METRICS,
-      ...(m && typeof m === 'object' && !Array.isArray(m) ? m : {}),
+      ...(shared.isPlainObject(m) ? m : {}),
     };
   }
 
@@ -352,6 +459,7 @@ function getAgentStatus(agentId) {
         started_at: latest.started_at || null,
         completed_at: latest.completed_at,
         resultSummary: latest.resultSummary || latest.reason || '',
+        completionReport: _completionReportSummary(latest),
       };
     }
   }
@@ -484,6 +592,7 @@ function getAgentDetail(id) {
         id: d.id, task: d.task || '', type: d.type || '',
         result: d.result || '', reason: d.reason || '',
         started_at: d.started_at || '', completed_at: d.completed_at || '',
+        completionReport: _completionReportSummary(d),
       }));
   } catch { /* optional */ }
 
@@ -1234,7 +1343,7 @@ module.exports = {
   invalidateKnowledgeBaseCache,
 
   // Core state
-  getConfig, getControl, getDispatch, getDispatchQueue, invalidateDispatchCache,
+  getConfig, getControl, getDispatch, getDispatchQueue, getDispatchCompletionReport, invalidateDispatchCache,
   getNotes, getNotesWithMeta, getEngineLog, getMetrics,
 
   // Inbox

package/engine/shared.js

@@ -720,6 +720,12 @@ const ENGINE_DEFAULTS = {
   autoArchive: false, // opt-in: auto-archive plans after verify completes (false = mark ready, user archives manually)
   autoFixConflicts: true, // auto-dispatch fix agents when a PR has merge conflicts
   autoFixBuilds: true, // auto-dispatch fix agents when a PR build fails
+  autoReviewPrs: true, // auto-dispatch review agents for newly opened agent PRs
+  autoReReviewPrs: true, // auto-dispatch review agents after a PR fix is pushed
+  autoFixReviewFeedback: true, // auto-dispatch fix agents for minions review changes-requested verdicts
+  autoFixHumanComments: true, // auto-dispatch fix agents for actionable human PR comments
+  completionReportRetentionDays: 90, // retain completion report sidecars beyond capped dispatch history
+  completionReportMaxFiles: 5000, // hard cap for completion report sidecars during cleanup
   meetingRoundTimeout: 900000, // 15min per meeting round before auto-advance
   evalLoop: true, // enable review→fix loop after implementation completes
   evalMaxIterations: 3, // legacy UI/config field; engine discovery no longer enforces review→fix cycle caps
@@ -1177,7 +1183,7 @@ const ESCALATION_POLICY = {
 };
 
 // Structured completion protocol — fields agents must produce in ```completion blocks
-const COMPLETION_FIELDS = ['status', 'summary', 'files_changed', 'tests', 'pr', 'pending', 'failure_class', 'retryable', 'needs_rerun', 'verdict'];
+const COMPLETION_FIELDS = ['status', 'summary', 'files_changed', 'tests', 'pr', 'pending', 'failure_class', 'retryable', 'needs_rerun', 'verdict', 'artifacts'];
 
 const DEFAULT_AGENT_METRICS = {
   tasksCompleted: 0, tasksErrored: 0,
@@ -1793,9 +1799,11 @@ function _jsonEqual(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
 }
 
-function _isPlainObject(value) {
+function isPlainObject(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+// Backwards-compat alias for legacy in-file callers.
+const _isPlainObject = isPlainObject;
 
 function applyPrFieldDelta(target, before, after) {
   if (!target || typeof target !== 'object' || !after || typeof after !== 'object') return target;
@@ -2322,6 +2330,7 @@ module.exports = {
   mutatePullRequests,
   uid,
   uniquePath,
+  isPlainObject,
   truncateTextBytes,
   tailTextBytes,
   appendTextTail,

package/engine.js

@@ -486,7 +486,7 @@ async function spawnAgent(dispatchItem, config) {
     '',
     `Before exiting, write a JSON completion report to: \`${completionReportPath}\``,
     '',
-    'Use this shape: {"status":"success|partial|failed","summary":"...","verdict":"approved|changes-requested|null","pr":"PR URL or id if relevant","failure_class":"...","retryable":true|false,"needs_rerun":true|false}.',
+    'Use this shape: {"status":"success|partial|failed","summary":"...","verdict":"approved|changes-requested|null","pr":"PR URL or id if relevant","failure_class":"...","retryable":true|false,"needs_rerun":true|false,"artifacts":[{"type":"note|plan|prd|pr|file","path":"relative/path/or/url","title":"short label"}]}.',
     'This report is the primary completion signal; fenced completion blocks are only a fallback.',
     '',
   ].join('\n') : '';
@@ -1336,13 +1336,19 @@ async function spawnAgent(dispatchItem, config) {
     const hardContractFail = completionContractFailure?.severity === 'hard'
       || completionContractFailure?.nonTerminal === true;
     const effectiveResult = hardContractFail ? DISPATCH_RESULT.ERROR : (((code === 0 && !agentReportedFailure) || autoRecovered) ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR);
+    const completionReportPath = structuredCompletion?._path || dispatchItem.meta?.completionReportPath || shared.dispatchCompletionReportPath(id);
+    const completionOpts = {
+      ...(completionReportPath ? { completionReportPath } : {}),
+      ...(structuredCompletion ? { structuredCompletion } : {}),
+    };
     const completeOpts = hardContractFail
-      ? { processWorkItemFailure: false }
+      ? { ...completionOpts, processWorkItemFailure: false }
       : (effectiveResult === DISPATCH_RESULT.ERROR ? {
+          ...completionOpts,
           ...(failureClass ? { failureClass } : {}),
           ...(typeof retryableDecision === 'boolean' ? { agentRetryable: retryableDecision } : {}),
           ...(structuredCompletion?.failure_class ? { failureClass: structuredCompletion.failure_class } : {}),
-        } : {});
+        } : completionOpts);
     // Extract last 5 non-empty stderr lines as error context when exit code is non-zero
     let errorReason = '';
     if (hardContractFail) {
@@ -1679,7 +1685,7 @@ function updateSnapshot(config) {
 // ─── Cooldowns (extracted to engine/cooldown.js) ─────────────────────────────
 
 const { COOLDOWN_PATH, dispatchCooldowns, loadCooldowns, saveCooldowns,
-  isOnCooldown, setCooldown, setCooldownWithContext, getCoalescedContexts,
+  isOnCooldown, setCooldown, setCooldownWithContext, drainCoalescedContexts,
   setCooldownFailure, clearCooldown, isAlreadyDispatched, isBranchActive } = require('./engine/cooldown');
 
 
@@ -2174,6 +2180,11 @@ async function discoverFromPrs(config, project) {
     ? (config.engine?.adoPollEnabled ?? ENGINE_DEFAULTS.adoPollEnabled)
     : (config.engine?.ghPollEnabled ?? ENGINE_DEFAULTS.ghPollEnabled);
   const evalLoopEnabled = config.engine?.evalLoop !== false;
+  const fixThrottled = isAdoProject ? isAdoThrottled() : isGhThrottled();
+  const autoReviewPrs = config.engine?.autoReviewPrs ?? ENGINE_DEFAULTS.autoReviewPrs;
+  const autoReReviewPrs = config.engine?.autoReReviewPrs ?? ENGINE_DEFAULTS.autoReReviewPrs;
+  const autoFixReviewFeedback = config.engine?.autoFixReviewFeedback ?? ENGINE_DEFAULTS.autoFixReviewFeedback;
+  const autoFixHumanComments = config.engine?.autoFixHumanComments ?? ENGINE_DEFAULTS.autoFixHumanComments;
 
   // Collect active PR dispatches to prevent simultaneous review+fix on same PR
   const dispatch = getDispatch();
@@ -2217,12 +2228,13 @@ async function discoverFromPrs(config, project) {
     const awaitingReReview = reviewStatus === 'waiting' && !!pr.minionsReview?.fixedAt;
 
     // PRs needing review: evalLoop gates the entire review+fix cycle; pollEnabled ensures reviewStatus is fresh
-    const reviewEnabled = evalLoopEnabled && pollEnabled;
+    const reviewEnabled = evalLoopEnabled && pollEnabled && autoReviewPrs;
+    const reReviewEnabled = evalLoopEnabled && pollEnabled && autoReReviewPrs;
     const alreadyReviewed = pr.lastReviewedAt && (!pr.lastPushedAt || pr.lastPushedAt <= pr.lastReviewedAt);
     const needsReview = reviewEnabled && reviewStatus === 'pending' && !alreadyReviewed;
     if (needsReview) {
       const key = `review-${project?.name || 'default'}-${prDisplayId}`;
-      if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
+      if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
 
       // Pre-dispatch live vote check — cached reviewStatus may be stale (poll lag ~6 min)
       try {
@@ -2263,21 +2275,29 @@ async function discoverFromPrs(config, project) {
     // awaiting a stale-vote re-review or has build-fix retries escalated.
     const humanFixKey = `human-fix-${project?.name || 'default'}-${prDisplayId}`;
     const hasCoalescedFeedback = (dispatchCooldowns.get(humanFixKey)?.pendingContexts || []).length > 0;
-    if ((pr.humanFeedback?.pendingFix || hasCoalescedFeedback) && !fixDispatched) {
+    if (autoFixHumanComments && (pr.humanFeedback?.pendingFix || hasCoalescedFeedback) && !fixDispatched) {
       const key = humanFixKey;
       let staleCoalesced = [];
       const alreadyDispatched = isAlreadyDispatched(key);
       const blockedByCooldown = isOnCooldown(key, cooldownMs);
+      const currentFeedback = pr.humanFeedback?.pendingFix ? pr.humanFeedback.feedbackContent : '';
+      const coalesceCurrentHumanFeedback = () => {
+        if (!currentFeedback) return;
+        setCooldownWithContext(key, { feedbackContent: currentFeedback, timestamp: ts() });
+        clearPendingHumanFeedbackFlag(projMeta, pr.id);
+      };
+      if (fixThrottled) {
+        coalesceCurrentHumanFeedback();
+        continue;
+      }
       if (blockedByCooldown && !alreadyDispatched) {
-        staleCoalesced = getCoalescedContexts(key);
+        staleCoalesced = drainCoalescedContexts(key);
         clearCooldown(key);
         log('info', `Cleared stale cooldown for ${key} — no matching dispatch history`);
       }
       if (alreadyDispatched || isOnCooldown(key, cooldownMs)) {
         // Coalesce: save feedback for next dispatch
-        if (pr.humanFeedback?.feedbackContent) {
-          setCooldownWithContext(key, { feedbackContent: pr.humanFeedback.feedbackContent, timestamp: ts() });
-        }
+        coalesceCurrentHumanFeedback();
         continue;
       }
       const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
@@ -2285,11 +2305,11 @@ async function discoverFromPrs(config, project) {
       const prBranch = ensurePrBranchForDispatch(project, pr, 'human-feedback fix');
       if (!prBranch) continue;
 
-      const coalesced = [...staleCoalesced, ...getCoalescedContexts(key)];
-      let reviewNote = pr.humanFeedback.feedbackContent || 'See PR thread comments';
+      const coalesced = [...staleCoalesced, ...drainCoalescedContexts(key)];
+      let reviewNote = currentFeedback || 'See PR thread comments';
       if (coalesced.length > 0) {
         const earlier = coalesced.map(c => c.feedbackContent).filter(Boolean).join('\n\n---\n\n');
-        if (earlier) reviewNote = earlier + '\n\n---\n\n' + reviewNote;
+        if (earlier) reviewNote = currentFeedback ? earlier + '\n\n---\n\n' + currentFeedback : earlier;
       }
       reviewNote = `New PR comments were observed. Read the full PR thread, decide whether the comments require code/documentation/test changes, make only necessary changes, and push if action is needed.\n\n${reviewNote}`;
 
@@ -2305,13 +2325,13 @@ async function discoverFromPrs(config, project) {
     // or when no minions review has completed yet (e.g. human-feedback-only fix path).
     const fixedAfterReview = !!(pr.minionsReview?.fixedAt &&
       (!pr.lastReviewedAt || pr.minionsReview.fixedAt > pr.lastReviewedAt));
-    const needsReReview = reviewEnabled && reviewStatus === 'waiting' &&
+    const needsReReview = reReviewEnabled && reviewStatus === 'waiting' &&
       fixedAfterReview && !fixDispatched;
     if (needsReReview) {
       const key = `rereview-${project?.name || 'default'}-${prDisplayId}`;
       // Skip isAlreadyDispatched — fixedAfterReview/lastReviewedAt already dedupe; the 1hr
       // completed-dispatch window would block legitimate re-reviews within the hour after a fix
-      if (isOnCooldown(key, cooldownMs)) continue;
+      if (fixThrottled || isOnCooldown(key, cooldownMs)) continue;
 
       // Pre-dispatch live vote check — cached 'waiting' may be stale if reviewer already acted
       try {
@@ -2346,9 +2366,9 @@ async function discoverFromPrs(config, project) {
 
     // PRs with changes requested → route back to author for fix
     // Gate on evalLoopEnabled — the review→fix cycle is the eval loop
-    if (evalLoopEnabled && reviewStatus === 'changes-requested' && !awaitingReReview && !fixDispatched) {
+    if (evalLoopEnabled && autoFixReviewFeedback && reviewStatus === 'changes-requested' && !awaitingReReview && !fixDispatched) {
       const key = `fix-${project?.name || 'default'}-${prDisplayId}`;
-      if (isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
+      if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
       const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
       if (!agentId) continue;
       const prBranch = ensurePrBranchForDispatch(project, pr, 'fix');
@@ -2371,7 +2391,6 @@ async function discoverFromPrs(config, project) {
       if (Date.now() - new Date(pr._buildFixPushedAt).getTime() < gracePeriodMs) continue;
     }
     const autoFixBuilds = config.engine?.autoFixBuilds ?? ENGINE_DEFAULTS.autoFixBuilds;
-    const fixThrottled = isAdoProject ? isAdoThrottled() : isGhThrottled();
     if (autoFixBuilds && pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing') {
       const key = `build-fix-${project?.name || 'default'}-${prDisplayId}`;
       if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
@@ -4082,7 +4101,7 @@ module.exports = {
   updateWorkItemStatus, handlePostMerge,
 
   // Cooldowns
-  loadCooldowns, setCooldownWithContext, getCoalescedContexts,
+  loadCooldowns, setCooldownWithContext, drainCoalescedContexts,
 
   // Budget
   getMonthlySpend,

package/package.json

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

package/playbooks/shared-rules.md

@@ -55,10 +55,10 @@ Treat a Minions assignment like the user typed the same task directly into a cap
 The engine provides a completion report path in the prompt and in `MINIONS_COMPLETION_REPORT`. Before exiting, write JSON there with the actual outcome:
 
 ```json
-{"status":"success","summary":"what changed and how it was validated","verdict":null,"pr":"PR id/url or N/A","failure_class":"N/A","retryable":false,"needs_rerun":false}
+{"status":"success","summary":"what changed and how it was validated","verdict":null,"pr":"PR id/url or N/A","failure_class":"N/A","retryable":false,"needs_rerun":false,"artifacts":[{"type":"note|plan|prd|pr|file","path":"relative/path/or/url","title":"short label"}]}
 ```
 
-Use `status: "failed"` plus an accurate `failure_class`, `retryable`, and `needs_rerun` when the task could not be completed. For PR reviews, set `verdict` to `approved` or `changes-requested`. Fenced `completion` blocks are still accepted as a fallback, but the JSON report is the primary signal.
+Use `status: "failed"` plus an accurate `failure_class`, `retryable`, and `needs_rerun` when the task could not be completed. For PR reviews, set `verdict` to `approved` or `changes-requested`. Include every durable artifact you created or updated in `artifacts` (PRs, notes, plans, PRDs, important files) so the dashboard can display them. Fenced `completion` blocks are still accepted as a fallback, but the JSON report is the primary signal.
 
 ## Long-Running Commands