@yemi33/minions 0.1.1722 → 0.1.1724

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.1724 (2026-05-05)
+
+### Features
+- add per-cause PR automation dedupe (#2075)
+
+## 0.1.1723 (2026-05-05)
+
+### Other
+- Extend command center session TTL
+
 ## 0.1.1722 (2026-05-05)
 
 ### Other

package/engine/ado.js

@@ -708,6 +708,7 @@ async function pollPrStatus(config) {
           delete pr.buildStatus;
           delete pr.buildFailReason;
           delete pr.buildErrorLog;
+          delete pr.buildFailureSignature;
           delete pr._buildFailNotified;
           delete pr._buildStatusStale;
           delete pr._buildStatusDetail;
@@ -738,6 +739,11 @@ async function pollPrStatus(config) {
       pr._adoSourceCommit = sourceCommit;
       updated = true;
     }
+    const targetCommit = prData.lastMergeTargetCommit?.commitId || '';
+    if (targetCommit && pr._adoTargetCommit !== targetCommit) {
+      pr._adoTargetCommit = targetCommit;
+      updated = true;
+    }
 
     const reviewers = prData.reviewers || [];
     const votes = reviewers.map(r => r.vote).filter(v => v !== undefined);
@@ -811,6 +817,7 @@ async function pollPrStatus(config) {
     const mergeCommitId = prData.lastMergeCommit?.commitId;
     let buildStatus = pr.buildStatus || 'none';
     let buildFailReason = pr.buildFailReason || '';
+    let buildFailureSignature = pr.buildFailureSignature || '';
     let buildStatusResolved = true;
     let buildStatusStaleDetail = '';
 
@@ -834,6 +841,11 @@ async function pollPrStatus(config) {
             if (buildStatus === 'failing') {
               const failed = prBuilds.find(b => b.result === 'failed');
               buildFailReason = failed?.definition?.name || 'Build failed';
+              buildFailureSignature = shared.safeSlugComponent([
+                failed?.definition?.name,
+                failed?.result,
+                failed?.status,
+              ].filter(Boolean).join('\n') || buildFailReason, 80);
             }
           } else if (allBuilds.length > 0 && pr.buildStatus) {
             // Stale merge-commit fallback — ADO returned builds for this PR's merge ref
@@ -879,6 +891,8 @@ async function pollPrStatus(config) {
         pr.buildStatus = buildStatus;
         if (buildFailReason) pr.buildFailReason = buildFailReason;
         else delete pr.buildFailReason;
+        if (buildFailureSignature) pr.buildFailureSignature = buildFailureSignature;
+        else delete pr.buildFailureSignature;
         // Build transitioned — clear grace period and auto-complete flag
         delete pr._buildFixPushedAt;
         if (buildStatus === 'failing') delete pr._autoCompleted;
@@ -894,6 +908,7 @@ async function pollPrStatus(config) {
           // fix agents to be dispatched blind.
           if (buildStatus === 'passing') {
             delete pr.buildErrorLog;
+            delete pr.buildFailureSignature;
             // 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; }
           }
@@ -909,6 +924,16 @@ async function pollPrStatus(config) {
           } catch {}
         }
       }
+      if (buildStatus === 'failing') {
+        if (buildFailReason && pr.buildFailReason !== buildFailReason) {
+          pr.buildFailReason = buildFailReason;
+          updated = true;
+        }
+        if (buildFailureSignature && pr.buildFailureSignature !== buildFailureSignature) {
+          pr.buildFailureSignature = buildFailureSignature;
+          updated = true;
+        }
+      }
     }
 
     // Auto-complete: set auto-complete on PR when builds green + review approved
@@ -1041,6 +1066,8 @@ async function pollPrHumanComments(config) {
 
     pr.humanFeedback = {
       lastProcessedCommentDate: latestDate,
+      lastProcessedCommentId: String(newHumanComments[newHumanComments.length - 1].commentId),
+      lastProcessedCommentKey: `${newHumanComments[newHumanComments.length - 1].threadId}:${newHumanComments[newHumanComments.length - 1].commentId}`,
       pendingFix: true,
       feedbackContent
     };

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-05T07:20:48.344Z"
+  "cachedAt": "2026-05-05T09:09:53.466Z"
 }

package/engine/github.js

@@ -372,6 +372,10 @@ async function pollPrStatus(config) {
       pr.lastPushedAt = ts();
       updated = true;
     }
+    if (prData.base?.sha && pr.baseSha !== prData.base.sha) {
+      pr.baseSha = prData.base.sha;
+      updated = true;
+    }
 
     if (pr.status !== newStatus) {
       log('info', `PR ${pr.id} status: ${pr.status} → ${newStatus}`);
@@ -389,6 +393,7 @@ async function pollPrStatus(config) {
           delete pr.buildStatus;
           delete pr.buildFailReason;
           delete pr.buildErrorLog;
+          delete pr.buildFailureSignature;
           delete pr._buildFailNotified;
           delete pr.buildFixAttempts;
           delete pr.buildFixEscalated;
@@ -471,6 +476,7 @@ async function pollPrStatus(config) {
         const runs = checksData.check_runs;
         let buildStatus = 'none';
         let buildFailReason = '';
+        let buildFailureSignature = '';
 
         if (runs.length > 0) {
           const hasFailed = runs.some(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
@@ -481,6 +487,13 @@ async function pollPrStatus(config) {
             buildStatus = 'failing';
             const failed = runs.find(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
             buildFailReason = failed?.name || 'Check failed';
+            buildFailureSignature = shared.safeSlugComponent([
+              failed?.name,
+              failed?.conclusion,
+              failed?.output?.title,
+              failed?.output?.summary,
+              failed?.output?.text,
+            ].filter(Boolean).join('\n') || buildFailReason, 80);
           } else if (allDone && allPassed) {
             buildStatus = 'passing';
           } else {
@@ -493,6 +506,8 @@ async function pollPrStatus(config) {
           pr.buildStatus = buildStatus;
           if (buildFailReason) pr.buildFailReason = buildFailReason;
           else delete pr.buildFailReason;
+          if (buildFailureSignature) pr.buildFailureSignature = buildFailureSignature;
+          else delete pr.buildFailureSignature;
           // Build transitioned — clear grace period and auto-complete flag
           delete pr._buildFixPushedAt;
           if (buildStatus === 'failing') delete pr._autoCompleted; // allow re-merge after fix
@@ -504,6 +519,7 @@ async function pollPrStatus(config) {
             // while a queued build was still running.
             if (buildStatus === 'passing') {
               delete pr.buildErrorLog;
+              delete pr.buildFailureSignature;
               // 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; }
             }
@@ -519,6 +535,16 @@ async function pollPrStatus(config) {
             } catch {}
           }
         }
+        if (buildStatus === 'failing') {
+          if (buildFailReason && pr.buildFailReason !== buildFailReason) {
+            pr.buildFailReason = buildFailReason;
+            updated = true;
+          }
+          if (buildFailureSignature && pr.buildFailureSignature !== buildFailureSignature) {
+            pr.buildFailureSignature = buildFailureSignature;
+            updated = true;
+          }
+        }
       }
     }
 
@@ -636,6 +662,8 @@ async function pollPrHumanComments(config) {
 
     pr.humanFeedback = {
       lastProcessedCommentDate: latestDate,
+      lastProcessedCommentId: String(newComments[newComments.length - 1].commentId),
+      lastProcessedCommentKey: String(newComments[newComments.length - 1].commentId),
       pendingFix: true,
       feedbackContent
     };

package/engine/lifecycle.js

@@ -1431,7 +1431,26 @@ async function updatePrAfterReview(agentId, pr, project, config, resultSummary,
   }
 }
 
-function updatePrAfterFix(pr, project, source) {
+function getHumanFeedbackAutomationCauseKey(pr) {
+  const feedback = pr?.humanFeedback;
+  if (!feedback || typeof feedback !== 'object') return '';
+  const commentRef = feedback.lastProcessedCommentKey
+    || feedback.lastProcessedCommentId
+    || feedback.commentId
+    || feedback.lastProcessedCommentDate
+    || feedback.feedbackContent
+    || '';
+  return commentRef ? `human-comment:${shared.safeSlugComponent(commentRef, 80)}` : '';
+}
+
+function shouldClearHumanFeedbackPendingFix(target, completedPr, automationCauseKey) {
+  if (!target?.humanFeedback?.pendingFix) return true;
+  const currentCauseKey = getHumanFeedbackAutomationCauseKey(target);
+  const completedCauseKey = automationCauseKey || getHumanFeedbackAutomationCauseKey(completedPr);
+  return !currentCauseKey || !completedCauseKey || currentCauseKey === completedCauseKey;
+}
+
+function updatePrAfterFix(pr, project, source, automationCauseKey = '', dispatchId = '') {
 
   if (!pr?.id) return;
   const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
@@ -1442,13 +1461,26 @@ function updatePrAfterFix(pr, project, source) {
     // Never downgrade from approved — fix was dispatched but PR is already approved
     if (target.reviewStatus !== 'approved') target.reviewStatus = 'waiting';
     if (source === 'pr-human-feedback') {
-      if (target.humanFeedback) target.humanFeedback.pendingFix = false;
+      const clearPendingFix = shouldClearHumanFeedbackPendingFix(target, pr, automationCauseKey);
+      if (target.humanFeedback && clearPendingFix) target.humanFeedback.pendingFix = false;
       target.minionsReview = { ...target.minionsReview, note: 'Fixed human feedback, awaiting re-review', fixedAt: ts() };
-      log('info', `Updated ${pr.id} → cleared humanFeedback.pendingFix, reset to waiting for re-review`);
+      if (clearPendingFix) {
+        log('info', `Updated ${pr.id} → cleared humanFeedback.pendingFix, reset to waiting for re-review`);
+      } else {
+        log('info', `Updated ${pr.id} → preserved newer humanFeedback.pendingFix, reset to waiting for re-review`);
+      }
     } else {
       target.minionsReview = { ...target.minionsReview, note: 'Fixed, awaiting re-review', fixedAt: ts() };
       log('info', `Updated ${pr.id} → reviewStatus: waiting (fix pushed)`);
     }
+    if (automationCauseKey) {
+      shared.markPrAutomationCause(target, automationCauseKey, {
+        source,
+        dispatchId: dispatchId || null,
+        status: 'handled',
+        handledAt: ts(),
+      });
+    }
     return prs;
   }, { defaultValue: [] });
 }
@@ -2762,7 +2794,7 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     log('warn', `Skipping PR review metadata update for ${meta?.pr?.id || meta?.pr?.url || '(unknown PR)'} because review dispatch ${dispatchItem.id} did not complete cleanly`);
   }
   if (type === WORK_TYPE.FIX && effectiveSuccess) {
-    updatePrAfterFix(meta?.pr, meta?.project, meta?.source);
+    updatePrAfterFix(meta?.pr, meta?.project, meta?.source, meta?.automationCauseKey, dispatchItem?.id);
     // (#984) Sync PRD status for PR-linked features: fix work items have a different ID
     // than the original PRD feature, so syncPrdItemStatus(fixWiId, ...) finds nothing.
     // Use the PR's prdItems to propagate done status when the original work item is done.

package/engine/shared.js

@@ -836,7 +836,7 @@ const ENGINE_DEFAULTS = {
   maxDispatchPromptBytes: 1024 * 1024, // 1 MB — dispatch items with prompts larger than this sidecar to engine/contexts/ to prevent dispatch.json OOM (#1167)
   maxStateFileBytes: 100 * 1024 * 1024, // 100 MB — fail startup with a clear error when dispatch.json / cooldowns.json exceed this, rather than silently OOMing on JSON.parse (#1167)
   ccMaxTurns: 50, // max tool-use turns for CC/doc-chat before CLI stops
-  ccSessionTtlMs: 2 * 60 * 60 * 1000, // 2h — expire stale resumed CC sessions to cap context growth
+  ccSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — keep chats resumable after breaks, still bounded by turn cap
   docSessionTtlMs: 7 * 24 * 60 * 60 * 1000, // 7d — longer-lived doc sessions, still bounded
   maxLlmRawBytes: 256 * 1024, // keep only a bounded stdout tail from direct Claude calls
   maxLlmStderrBytes: 64 * 1024, // keep only a bounded stderr tail from direct Claude calls
@@ -2532,6 +2532,40 @@ function safeSlugComponent(text, maxLen = 80) {
   return `${base}-${hash}`.slice(0, maxLen);
 }
 
+const PR_AUTOMATION_CAUSE_LIMIT = 50;
+
+function getPrAutomationCauses(pr) {
+  const causes = pr?._automationFixCauses;
+  return causes && typeof causes === 'object' && !Array.isArray(causes) ? causes : {};
+}
+
+function hasPrAutomationCause(pr, causeKey) {
+  return !!(causeKey && getPrAutomationCauses(pr)[causeKey]);
+}
+
+function markPrAutomationCause(pr, causeKey, details = {}) {
+  if (!pr || !causeKey) return false;
+  const now = ts();
+  const causes = { ...getPrAutomationCauses(pr) };
+  causes[causeKey] = {
+    ...(causes[causeKey] || {}),
+    ...details,
+    status: details.status || causes[causeKey]?.status || 'handled',
+    updatedAt: now,
+  };
+  if (!causes[causeKey].firstSeenAt) causes[causeKey].firstSeenAt = now;
+
+  const entries = Object.entries(causes);
+  if (entries.length > PR_AUTOMATION_CAUSE_LIMIT) {
+    entries
+      .sort((a, b) => String(b[1]?.updatedAt || b[1]?.firstSeenAt || '').localeCompare(String(a[1]?.updatedAt || a[1]?.firstSeenAt || '')))
+      .slice(PR_AUTOMATION_CAUSE_LIMIT)
+      .forEach(([key]) => delete causes[key]);
+  }
+  pr._automationFixCauses = causes;
+  return true;
+}
+
 function formatTranscriptEntry(t) {
   return '### ' + (t.agent || 'agent') + ' (' + (t.type || '') + ', Round ' + (t.round || '?') + ')\n\n' + (t.content || '');
 }
@@ -2716,6 +2750,9 @@ module.exports = {
   redactSecrets,
   slugify,
   safeSlugComponent,
+  getPrAutomationCauses,
+  hasPrAutomationCause,
+  markPrAutomationCause,
   formatTranscriptEntry,
   getPinnedItems,
   _logBuffer, // exported for testing

package/engine.js

@@ -2308,6 +2308,93 @@ function ensurePrBranchForDispatch(project, pr, automationType) {
   return '';
 }
 
+function prCausePart(value, fallback = 'unknown') {
+  const raw = String(value || '').trim();
+  return shared.safeSlugComponent(raw || fallback, 80);
+}
+
+function getPrCauseHead(pr) {
+  return pr?.headSha
+    || pr?.headSHA
+    || pr?.head?.sha
+    || pr?._adoSourceCommit
+    || pr?._adoHeadCommit
+    || pr?.lastMergeSourceCommit?.commitId
+    || pr?.lastMergeCommit?.commitId
+    || '';
+}
+
+function getPrCauseBase(pr) {
+  return pr?.baseSha
+    || pr?.base?.sha
+    || pr?._adoTargetCommit
+    || pr?.lastMergeTargetCommit?.commitId
+    || pr?.targetSha
+    || pr?.targetRefSha
+    || pr?.baseRefName
+    || pr?.targetRefName
+    || '';
+}
+
+function getPrAutomationCauseKey(kind, pr) {
+  if (kind === 'review-feedback') {
+    const reviewRef = pr?.minionsReview?.dispatchId
+      || pr?.minionsReview?.reviewedAt
+      || pr?.lastReviewedAt
+      || getPrCauseHead(pr)
+      || pr?.reviewNote
+      || pr?.minionsReview?.note
+      || 'review';
+    return `review-feedback:${prCausePart(reviewRef)}`;
+  }
+  if (kind === 'human-comment') {
+    const commentRef = pr?.humanFeedback?.lastProcessedCommentKey
+      || pr?.humanFeedback?.lastProcessedCommentId
+      || pr?.humanFeedback?.commentId
+      || pr?.humanFeedback?.lastProcessedCommentDate
+      || pr?.humanFeedback?.feedbackContent
+      || 'comment';
+    return `human-comment:${prCausePart(commentRef)}`;
+  }
+  if (kind === 'build') {
+    const checkName = pr?.buildFailReason || pr?._buildStatusDetail || 'check';
+    const signature = pr?.buildFailureSignature
+      || pr?.buildErrorLog
+      || pr?._buildStatusDetail
+      || pr?.buildStatusDetail
+      || pr?.buildFailReason
+      || 'failure';
+    return `build:${prCausePart(checkName)}:${prCausePart(getPrCauseHead(pr), 'unknown-head')}:${prCausePart(signature)}`;
+  }
+  if (kind === 'merge-conflict') {
+    return `merge-conflict:${prCausePart(getPrCauseBase(pr), 'unknown-base')}:${prCausePart(getPrCauseHead(pr), 'unknown-head')}`;
+  }
+  return `${kind}:${prCausePart(getPrCauseHead(pr) || pr?.id || 'pr')}`;
+}
+
+function getPrAutomationDispatchKey(baseKey, causeKey) {
+  return `${baseKey}-${shared.safeSlugComponent(causeKey, 96)}`;
+}
+
+function isPrAutomationCausePending(project, pr, causeKey) {
+  if (!causeKey) return false;
+  const prCanonicalId = shared.getCanonicalPrId(project, pr, pr?.url || '');
+  const dispatch = getDispatch();
+  return [...(dispatch.pending || []), ...(dispatch.active || [])].some(d => {
+    if (d.meta?.automationCauseKey !== causeKey) return false;
+    if (!prCanonicalId) return true;
+    const dispatchProject = d.meta?.project?.name
+      ? (getProjects(getConfig()).find(p => p.name === d.meta.project.name) || d.meta.project)
+      : (d.meta?.project || null);
+    const dispatchPrId = shared.getCanonicalPrId(dispatchProject, d.meta?.pr, d.meta?.pr?.url || '');
+    return !dispatchPrId || dispatchPrId === prCanonicalId;
+  });
+}
+
+function isPrAutomationCauseHandledOrPending(project, pr, causeKey) {
+  return shared.hasPrAutomationCause(pr, causeKey) || isPrAutomationCausePending(project, pr, causeKey);
+}
+
 
 // Tracks per-process which silent-discovery warnings have already been logged
 // so we don't spam the log every tick. Cleared on process exit (no need to
@@ -2448,10 +2535,13 @@ async function discoverFromPrs(config, project) {
 
     // Fresh reviewer comments are actionable fixes, even while the PR is otherwise
     // awaiting a stale-vote re-review or has build-fix retries escalated.
-    const humanFixKey = `human-fix-${project?.name || 'default'}-${prDisplayId}`;
+    const humanFixBaseKey = `human-fix-${project?.name || 'default'}-${prDisplayId}`;
+    const humanCauseKey = getPrAutomationCauseKey('human-comment', pr);
+    const humanFixKey = getPrAutomationDispatchKey(humanFixBaseKey, humanCauseKey);
     const hasCoalescedFeedback = (dispatchCooldowns.get(humanFixKey)?.pendingContexts || []).length > 0;
     if (pollEnabled && autoFixHumanComments && (pr.humanFeedback?.pendingFix || hasCoalescedFeedback) && !fixDispatched) {
       const key = humanFixKey;
+      if (isPrAutomationCauseHandledOrPending(project, pr, humanCauseKey)) continue;
       let staleCoalesced = [];
       const alreadyDispatched = isAlreadyDispatched(key);
       const blockedByCooldown = isOnCooldown(key, cooldownMs);
@@ -2492,7 +2582,7 @@ async function discoverFromPrs(config, project) {
         pr_id: pr.id, pr_number: prNumber, pr_title: pr.title || '', pr_branch: prBranch,
         reviewer: 'Human Reviewer',
         review_note: reviewNote,
-      }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, source: 'pr-human-feedback', pr, branch: prBranch, project: projMeta });
+      }, `Fix ${pr.id}: ${pr.title || ''} — human feedback`, { dispatchKey: key, automationCauseKey: humanCauseKey, source: 'pr-human-feedback', pr, branch: prBranch, project: projMeta });
       if (item) { newWork.push(item); fixDispatched = true; }
     }
 
@@ -2547,7 +2637,9 @@ async function discoverFromPrs(config, project) {
     // PRs with changes requested → route back to author for fix.
     // Gate on evalLoopEnabled and provider polling — the review→fix cycle depends on fresh vote state.
     if (evalLoopEnabled && pollEnabled && autoFixReviewFeedback && reviewStatus === 'changes-requested' && !awaitingReReview && !fixDispatched) {
-      const key = `fix-${project?.name || 'default'}-${prDisplayId}`;
+      const reviewCauseKey = getPrAutomationCauseKey('review-feedback', pr);
+      const key = getPrAutomationDispatchKey(`fix-${project?.name || 'default'}-${prDisplayId}`, reviewCauseKey);
+      if (isPrAutomationCauseHandledOrPending(project, pr, reviewCauseKey)) continue;
       if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
       const agentId = resolveAgent('fix', config, { authorAgent: pr.agent });
       if (!agentId) continue;
@@ -2557,7 +2649,7 @@ async function discoverFromPrs(config, project) {
       const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
         pr_id: pr.id, pr_branch: prBranch,
         review_note: pr.minionsReview?.note || pr.reviewNote || 'See PR thread comments',
-      }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, { dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
+      }, `Fix ${pr.id}: ${pr.title || ''} — review feedback`, { dispatchKey: key, automationCauseKey: reviewCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
       if (item) {
         newWork.push(item); setCooldown(key); fixDispatched = true;
       }
@@ -2572,7 +2664,9 @@ async function discoverFromPrs(config, project) {
     }
     const autoFixBuilds = config.engine?.autoFixBuilds ?? ENGINE_DEFAULTS.autoFixBuilds;
     if (pollEnabled && autoFixBuilds && pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing') {
-      const key = `build-fix-${project?.name || 'default'}-${prDisplayId}`;
+      const buildCauseKey = getPrAutomationCauseKey('build', pr);
+      const key = getPrAutomationDispatchKey(`build-fix-${project?.name || 'default'}-${prDisplayId}`, buildCauseKey);
+      if (isPrAutomationCauseHandledOrPending(project, pr, buildCauseKey)) continue;
       if (fixThrottled || isAlreadyDispatched(key) || isOnCooldown(key, cooldownMs)) continue;
 
       // Pre-dispatch live build check — cached buildStatus may be stale: ADO can
@@ -2633,7 +2727,7 @@ async function discoverFromPrs(config, project) {
       const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
         pr_id: pr.id, pr_branch: prBranch,
         review_note: reviewNote,
-      }, `Fix build failure on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
+      }, `Fix build failure on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, automationCauseKey: buildCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
       if (item) {
         newWork.push(item); setCooldown(key); fixDispatched = true;
         try {
@@ -2664,13 +2758,14 @@ async function discoverFromPrs(config, project) {
     // PRs with merge conflicts — dispatch fix to resolve (gated by provider polling + autoFixConflicts)
     const autoFixConflicts = config.engine?.autoFixConflicts ?? ENGINE_DEFAULTS.autoFixConflicts;
     if (pollEnabled && autoFixConflicts && pr.status === PR_STATUS.ACTIVE && pr._mergeConflict && !fixDispatched) {
-      const key = `conflict-fix-${project?.name || 'default'}-${prDisplayId}`;
+      const conflictCauseKey = getPrAutomationCauseKey('merge-conflict', pr);
+      const key = getPrAutomationDispatchKey(`conflict-fix-${project?.name || 'default'}-${prDisplayId}`, conflictCauseKey);
       // Suppress re-dispatch for 10 min after last attempt — ADO/GitHub recomputes
       // mergeStatus asynchronously (1–5 min lag), so the flag may stay set even after
       // a successful push. _conflictFixedAt is cleared when the poller confirms clean status.
       const conflictFixedAt = pr._conflictFixedAt;
       const withinLag = conflictFixedAt && Date.now() - new Date(conflictFixedAt).getTime() < 10 * 60 * 1000;
-      if (!withinLag && !fixThrottled && !isAlreadyDispatched(key) && !isOnCooldown(key, cooldownMs)) {
+      if (!withinLag && !fixThrottled && !isPrAutomationCauseHandledOrPending(project, pr, conflictCauseKey) && !isAlreadyDispatched(key) && !isOnCooldown(key, cooldownMs)) {
         // Pre-dispatch live conflict check — cached `_mergeConflict` may be
         // stale: ADO/GitHub recompute mergeStatus asynchronously (1–5 min lag),
         // so a successful upstream merge can leave the flag set even after the
@@ -2702,7 +2797,7 @@ async function discoverFromPrs(config, project) {
             const item = buildPrDispatch(agentId, config, project, pr, 'fix', {
               pr_id: pr.id, pr_branch: prBranch,
               review_note: `This PR has merge conflicts with the target branch. Inspect the live PR and repository history, choose the safest merge/rebase/update strategy, resolve all conflicts, validate the result, and push the branch.`,
-            }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, source: 'pr', pr, branch: prBranch, project: projMeta });
+            }, `Fix merge conflicts on ${pr.id}: ${pr.title || ''}`, { dispatchKey: key, automationCauseKey: conflictCauseKey, source: 'pr', pr, branch: prBranch, project: projMeta });
             if (item) {
               newWork.push(item);
               setCooldown(key);

package/package.json

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