@yemi33/minions 0.1.1729 → 0.1.1730

package/CHANGELOG.md

@@ -1,10 +1,13 @@
 # Changelog
 
-## 0.1.1729 (2026-05-05)
+## 0.1.1730 (2026-05-05)
+
+### Features
+- detect no-op PR fixes (#2077)
+
+## 0.1.1728 (2026-05-05)
 
 ### Features
-- suppress comment-only fix loops (#2076)
--  Allow explicit doc chat dispatch requests (#2072)
 - redact repository URLs in filed issues (#2069)
 
 ## 0.1.1727 (2026-05-05)

package/engine/copilot-models.json

@@ -1,5 +1,5 @@
 {
   "runtime": "copilot",
   "models": null,
-  "cachedAt": "2026-05-05T09:47:21.371Z"
+  "cachedAt": "2026-05-05T09:50:02.177Z"
 }

package/engine/lifecycle.js

@@ -1466,16 +1466,153 @@ function fixCompletionChangedBranch(structuredCompletion) {
   return true;
 }
 
-function updatePrAfterFix(pr, project, source, opts = {}, dispatchId = '') {
+function normalizePrFixBranchName(branch) {
+  return String(branch || '').trim().replace(/^refs\/heads\//, '');
+}
+
+function getPrFixBaselineHead(pr) {
+  return String(pr?.headSha || pr?._adoSourceCommit || pr?._adoHeadCommit || '').trim();
+}
+
+function findPrFixWorktree(meta, project, config) {
+  const branch = normalizePrFixBranchName(meta?.branch || meta?.pr?.branch);
+  const rootDir = project?.localPath ? path.resolve(project.localPath) : null;
+  if (!branch || !rootDir) return null;
+  const worktreeRoot = path.resolve(rootDir, config?.engine?.worktreeRoot || ENGINE_DEFAULTS.worktreeRoot);
+  try {
+    if (!fs.existsSync(worktreeRoot)) return null;
+    for (const dir of fs.readdirSync(worktreeRoot)) {
+      const wtPath = path.join(worktreeRoot, dir);
+      if (!fs.statSync(wtPath).isDirectory()) continue;
+      if (worktreeMatchesBranch(dir.toLowerCase(), branch, getWorktreeBranch(wtPath))) return wtPath;
+    }
+  } catch (err) {
+    log('warn', `PR fix no-op worktree lookup for ${meta?.pr?.id || branch}: ${err.message}`);
+  }
+  return null;
+}
+
+async function gitRevParse(cwd, ref) {
+  try {
+    const out = await runFileCapture('git', ['rev-parse', '--verify', `${ref}^{commit}`], { cwd, timeout: 10000 });
+    return String(out || '').trim();
+  } catch {
+    return '';
+  }
+}
+
+async function detectPrFixBranchChange(meta, config) {
+  const branch = normalizePrFixBranchName(meta?.branch || meta?.pr?.branch);
+  const project = resolvePrFallbackProject(meta, config) || meta?.project || null;
+  const rootDir = project?.localPath ? path.resolve(project.localPath) : null;
+  const beforeHead = getPrFixBaselineHead(meta?.pr);
+  if (!meta?.pr?.id || !branch || !rootDir || !beforeHead) {
+    return { changed: null, reason: 'missing PR branch baseline' };
+  }
+
+  const worktreePath = findPrFixWorktree(meta, project, config);
+  if (worktreePath) {
+    try {
+      const dirty = await runFileCapture('git', ['status', '--porcelain'], { cwd: worktreePath, timeout: 10000 });
+      if (String(dirty || '').trim()) {
+        return { changed: true, beforeHead, afterHead: beforeHead, evidence: 'worktree-diff' };
+      }
+    } catch (err) {
+      log('warn', `PR fix no-op dirty check for ${meta.pr.id}: ${err.message}`);
+    }
+  }
+
+  let fetched = false;
+  try {
+    await runFileCapture('git', ['fetch', 'origin', branch], { cwd: rootDir, timeout: 30000 });
+    fetched = true;
+  } catch (err) {
+    log('warn', `PR fix no-op fetch for ${meta.pr.id} (${branch}) failed: ${err.message}`);
+  }
 
+  const remoteHead = await gitRevParse(rootDir, `refs/remotes/origin/${branch}`);
+  if (remoteHead && remoteHead !== beforeHead) {
+    return { changed: true, beforeHead, afterHead: remoteHead, evidence: 'remote-head' };
+  }
+
+  if (worktreePath) {
+    const localHead = await gitRevParse(worktreePath, 'HEAD');
+    if (localHead && localHead !== beforeHead) {
+      return { changed: true, beforeHead, afterHead: localHead, evidence: 'local-head' };
+    }
+  }
+
+  if (fetched && remoteHead && remoteHead === beforeHead) {
+    return { changed: false, beforeHead, afterHead: remoteHead, evidence: 'remote-head' };
+  }
+
+  return { changed: null, beforeHead, afterHead: remoteHead || '', reason: 'unable to prove branch head after fix' };
+}
+
+function recordPrNoOpFixAttempt(target, cause, source, dispatchItem, branchChange, config) {
+  const evidenceFingerprint = shared.prFixEvidenceFingerprint(target, cause);
+  const prior = shared.getPrNoOpFixRecord(target, cause);
+  const sameEvidence = prior?.evidenceFingerprint === evidenceFingerprint;
+  const count = sameEvidence ? (Number(prior.count) || 0) + 1 : 1;
+  const pauseAfter = Number(config?.engine?.prNoOpFixPauseAttempts) || ENGINE_DEFAULTS.prNoOpFixPauseAttempts;
+  const paused = count >= pauseAfter;
+  const now = ts();
+  target._noOpFixes = target._noOpFixes && typeof target._noOpFixes === 'object' ? target._noOpFixes : {};
+  target._noOpFixes[cause] = {
+    count,
+    paused,
+    evidenceFingerprint,
+    firstAt: sameEvidence ? (prior.firstAt || now) : now,
+    lastAt: now,
+    dispatchId: dispatchItem?.id || null,
+    dispatchKey: dispatchItem?.meta?.dispatchKey || null,
+    source: source || null,
+    beforeHead: branchChange?.beforeHead || '',
+    afterHead: branchChange?.afterHead || '',
+    reason: branchChange?.reason || 'fix completed without changing the PR branch',
+  };
+  target._lastNoOpFix = {
+    cause,
+    at: now,
+    paused,
+    dispatchId: dispatchItem?.id || null,
+    beforeHead: branchChange?.beforeHead || '',
+    afterHead: branchChange?.afterHead || '',
+  };
+
+  if (cause === shared.PR_FIX_CAUSE.HUMAN_FEEDBACK && target.humanFeedback) {
+    target.humanFeedback.pendingFix = !paused;
+    if (paused) target.humanFeedback.noOpPaused = true;
+    else delete target.humanFeedback.noOpPaused;
+  }
+  if (cause === shared.PR_FIX_CAUSE.BUILD_FAILURE) delete target._buildFixPushedAt;
+  if (cause === shared.PR_FIX_CAUSE.MERGE_CONFLICT) delete target._conflictFixedAt;
+  return target._noOpFixes[cause];
+}
+
+function clearPrNoOpFixAttempt(target, cause) {
+  if (!target?._noOpFixes || !target._noOpFixes[cause]) return;
+  delete target._noOpFixes[cause];
+  if (Object.keys(target._noOpFixes).length === 0) delete target._noOpFixes;
+  if (target._lastNoOpFix?.cause === cause) delete target._lastNoOpFix;
+  if (target.humanFeedback) delete target.humanFeedback.noOpPaused;
+}
+
+function updatePrAfterFix(pr, project, source, options = {}, legacyDispatchId = '') {
   if (!pr?.id) return;
-  const options = opts && typeof opts === 'object' && !Array.isArray(opts)
-    ? opts
-    : { automationCauseKey: opts, dispatchId };
-  const branchChanged = options.branchChanged !== false;
-  const automationCauseKey = options.automationCauseKey || '';
-  const fixDispatchId = options.dispatchId || dispatchId || '';
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    options = { automationCauseKey: options, dispatchId: legacyDispatchId };
+  }
+  const explicitlyChangedBranch = options.branchChanged !== false;
   const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
+  const automationCauseKey = options.automationCauseKey || options.dispatchItem?.meta?.automationCauseKey || '';
+  const fixDispatchId = options.dispatchItem?.id || options.dispatchId || legacyDispatchId || '';
+  const cause = shared.getPrFixAutomationCause({
+    dispatchKey: options.dispatchItem?.meta?.dispatchKey,
+    source,
+    task: options.dispatchItem?.task,
+  });
+  let result = null;
   shared.mutateJsonFileLocked(prPath, (prs) => {
     if (!Array.isArray(prs)) return prs;
     const target = shared.findPrRecord(prs, pr, project);
@@ -1485,10 +1622,17 @@ function updatePrAfterFix(pr, project, source, opts = {}, dispatchId = '') {
       delete next.fixedAt;
       target.minionsReview = next;
     };
+    if (explicitlyChangedBranch && options.branchChange?.changed === false) {
+      const record = recordPrNoOpFixAttempt(target, cause, source, options.dispatchItem, options.branchChange, options.config);
+      result = { noOp: true, cause, paused: !!record.paused, count: record.count };
+      log('warn', `Updated ${pr.id} → recorded no-op ${cause} fix attempt ${record.count}${record.paused ? ' (paused)' : ''}; PR branch was unchanged`);
+      return prs;
+    }
+    clearPrNoOpFixAttempt(target, cause);
     if (source === 'pr-human-feedback') {
       const clearPendingFix = shouldClearHumanFeedbackPendingFix(target, pr, automationCauseKey);
       if (target.humanFeedback && clearPendingFix) target.humanFeedback.pendingFix = false;
-      if (branchChanged) {
+      if (explicitlyChangedBranch) {
         // Never downgrade from approved — fix was dispatched but PR is already approved
         if (target.reviewStatus !== 'approved') target.reviewStatus = 'waiting';
         target.minionsReview = { ...target.minionsReview, note: 'Fixed human feedback, awaiting re-review', fixedAt: ts() };
@@ -1507,7 +1651,7 @@ function updatePrAfterFix(pr, project, source, opts = {}, dispatchId = '') {
       }
     } else {
       if (target.reviewStatus !== 'approved') target.reviewStatus = 'waiting';
-      if (branchChanged) {
+      if (explicitlyChangedBranch) {
         target.minionsReview = { ...target.minionsReview, note: 'Fixed, awaiting re-review', fixedAt: ts() };
         log('info', `Updated ${pr.id} → reviewStatus: waiting (fix pushed)`);
       } else {
@@ -1523,8 +1667,10 @@ function updatePrAfterFix(pr, project, source, opts = {}, dispatchId = '') {
         handledAt: ts(),
       });
     }
+    result = { noOp: false, cause };
     return prs;
   }, { defaultValue: [] });
+  return result;
 }
 
 // ─── Post-Merge Rebase ──────────────────────────────────────────────────────
@@ -2754,6 +2900,16 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
 
   // Archive is manual — user archives plans from the dashboard when ready
 
+  let prFixBranchChange = null;
+  if (type === WORK_TYPE.FIX && effectiveSuccess && meta?.pr?.id) {
+    try {
+      prFixBranchChange = await detectPrFixBranchChange(meta, config);
+    } catch (err) {
+      log('warn', `PR fix no-op detection for ${meta.pr.id}: ${err.message}`);
+      prFixBranchChange = { changed: null, reason: err.message };
+    }
+  }
+
   // Scheduled task back-reference: update schedule-runs.json and write linked inbox note
   if (meta?.item?._scheduleId) {
     try {
@@ -2839,7 +2995,9 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
     updatePrAfterFix(meta?.pr, meta?.project, meta?.source, {
       branchChanged: fixCompletionChangedBranch(structuredCompletion),
       automationCauseKey: meta?.automationCauseKey,
-      dispatchId: dispatchItem?.id,
+      dispatchItem,
+      branchChange: prFixBranchChange,
+      config,
     });
     // (#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.

package/engine/shared.js

@@ -834,6 +834,7 @@ const ENGINE_DEFAULTS = {
   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
+  prNoOpFixPauseAttempts: 2, // pause one PR automation cause after repeated no-op fixes for unchanged evidence
   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
@@ -2492,6 +2493,62 @@ const _WIN_RESERVED_NAMES = new Set([
   'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9',
 ]);
 
+const PR_FIX_CAUSE = {
+  HUMAN_FEEDBACK: 'human-feedback',
+  REVIEW_FEEDBACK: 'review-feedback',
+  BUILD_FAILURE: 'build-failure',
+  MERGE_CONFLICT: 'merge-conflict',
+  UNKNOWN: 'pr-fix',
+};
+
+function getPrFixAutomationCause({ dispatchKey = '', source = '', task = '' } = {}) {
+  const key = String(dispatchKey || '').toLowerCase();
+  const src = String(source || '').toLowerCase();
+  const title = String(task || '').toLowerCase();
+  if (src === 'pr-human-feedback' || key.startsWith('human-fix-') || title.includes('human feedback')) return PR_FIX_CAUSE.HUMAN_FEEDBACK;
+  if (key.startsWith('build-fix-') || title.includes('build failure')) return PR_FIX_CAUSE.BUILD_FAILURE;
+  if (key.startsWith('conflict-fix-') || title.includes('merge conflict')) return PR_FIX_CAUSE.MERGE_CONFLICT;
+  if (key.startsWith('fix-') || src === 'pr') return PR_FIX_CAUSE.REVIEW_FEEDBACK;
+  return PR_FIX_CAUSE.UNKNOWN;
+}
+
+function prFixEvidenceFingerprint(pr, cause = PR_FIX_CAUSE.UNKNOWN) {
+  const review = pr?.minionsReview || {};
+  const feedback = pr?.humanFeedback || {};
+  const evidence = { cause };
+  if (cause === PR_FIX_CAUSE.HUMAN_FEEDBACK) {
+    evidence.lastProcessedCommentDate = feedback.lastProcessedCommentDate || '';
+    evidence.feedbackContent = feedback.feedbackContent || '';
+  } else if (cause === PR_FIX_CAUSE.BUILD_FAILURE) {
+    evidence.buildStatus = pr?.buildStatus || '';
+    evidence.buildFailReason = pr?.buildFailReason || '';
+    evidence.buildErrorLog = pr?.buildErrorLog || '';
+    evidence.buildStatusDetail = pr?._buildStatusDetail || '';
+  } else if (cause === PR_FIX_CAUSE.MERGE_CONFLICT) {
+    evidence.mergeConflict = !!pr?._mergeConflict;
+    evidence.mergeStatus = pr?.mergeStatus || '';
+    evidence.mergeConflictDetail = pr?._mergeConflictDetail || '';
+  } else {
+    evidence.reviewStatus = pr?.reviewStatus || '';
+    evidence.lastReviewedAt = pr?.lastReviewedAt || '';
+    evidence.reviewedAt = review.reviewedAt || '';
+    evidence.reviewNote = review.note || pr?.reviewNote || '';
+  }
+  return crypto.createHash('sha1').update(JSON.stringify(evidence)).digest('hex').slice(0, 16);
+}
+
+function getPrNoOpFixRecord(pr, cause) {
+  if (!pr || !cause || !pr._noOpFixes || typeof pr._noOpFixes !== 'object') return null;
+  const record = pr._noOpFixes[cause];
+  return record && typeof record === 'object' ? record : null;
+}
+
+function isPrNoOpFixCausePaused(pr, cause) {
+  const record = getPrNoOpFixRecord(pr, cause);
+  if (!record?.paused) return false;
+  return record.evidenceFingerprint === prFixEvidenceFingerprint(pr, cause);
+}
+
 /**
  * Recursively purge Windows reserved-name pseudo-files (NUL, CON, PRN, AUX, etc.)
  * using the \\?\ extended path prefix that bypasses reserved-name interpretation.
@@ -2787,6 +2844,11 @@ module.exports = {
   validateProjectName,
   validateProjectPath,
   validatePid,
+  PR_FIX_CAUSE,
+  getPrFixAutomationCause,
+  prFixEvidenceFingerprint,
+  getPrNoOpFixRecord,
+  isPrNoOpFixCausePaused,
   parseSkillFrontmatter,
   sleepMs,
   killGracefully,

package/engine.js

@@ -2214,6 +2214,12 @@ function clearPendingHumanFeedbackFlag(projectMeta, prId) {
   } catch (e) { log('warn', 'clear pending human feedback flag: ' + e.message); }
 }
 
+function isPrNoOpFixCauseSuppressed(pr, cause) {
+  if (!shared.isPrNoOpFixCausePaused(pr, cause)) return false;
+  log('warn', `PR ${pr.id}: suppressing ${cause} automation after repeated no-op fix attempts; waiting for human resume or new evidence`);
+  return true;
+}
+
 const PR_PENDING_MISSING_BRANCH = shared.PR_PENDING_REASON.MISSING_BRANCH;
 
 function normalizePrBranch(value) {
@@ -2539,7 +2545,8 @@ async function discoverFromPrs(config, project) {
     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) {
+    if (pollEnabled && autoFixHumanComments && (pr.humanFeedback?.pendingFix || hasCoalescedFeedback) && !fixDispatched
+      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.HUMAN_FEEDBACK)) {
       const key = humanFixKey;
       if (isPrAutomationCauseHandledOrPending(project, pr, humanCauseKey)) continue;
       let staleCoalesced = [];
@@ -2636,7 +2643,8 @@ 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) {
+    if (evalLoopEnabled && pollEnabled && autoFixReviewFeedback && reviewStatus === 'changes-requested' && !awaitingReReview && !fixDispatched
+      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.REVIEW_FEEDBACK)) {
       const reviewCauseKey = getPrAutomationCauseKey('review-feedback', pr);
       const key = getPrAutomationDispatchKey(`fix-${project?.name || 'default'}-${prDisplayId}`, reviewCauseKey);
       if (isPrAutomationCauseHandledOrPending(project, pr, reviewCauseKey)) continue;
@@ -2663,7 +2671,8 @@ async function discoverFromPrs(config, project) {
       if (Date.now() - new Date(pr._buildFixPushedAt).getTime() < gracePeriodMs) continue;
     }
     const autoFixBuilds = config.engine?.autoFixBuilds ?? ENGINE_DEFAULTS.autoFixBuilds;
-    if (pollEnabled && autoFixBuilds && pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing') {
+    if (pollEnabled && autoFixBuilds && pr.status === PR_STATUS.ACTIVE && pr.buildStatus === 'failing'
+      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.BUILD_FAILURE)) {
       const buildCauseKey = getPrAutomationCauseKey('build', pr);
       const key = getPrAutomationDispatchKey(`build-fix-${project?.name || 'default'}-${prDisplayId}`, buildCauseKey);
       if (isPrAutomationCauseHandledOrPending(project, pr, buildCauseKey)) continue;
@@ -2757,7 +2766,8 @@ 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) {
+    if (pollEnabled && autoFixConflicts && pr.status === PR_STATUS.ACTIVE && pr._mergeConflict && !fixDispatched
+      && !isPrNoOpFixCauseSuppressed(pr, shared.PR_FIX_CAUSE.MERGE_CONFLICT)) {
       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

package/package.json

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