@yemi33/minions 0.1.379 → 0.1.381

package/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 
-## 0.1.379 (2026-04-06)
+## 0.1.381 (2026-04-06)
+
+### Fixes
+-  clear failReason on all retry-to-pending paths
+-  clear failReason and noPr on no-PR retry reset
+-  PR duplicate race condition — convert safeWrite to mutateJsonFileLocked (#240)
 
 ### Other
 - [E2E] Fix review re-dispatch loop, dashboard write races, crash bugs, and failing tests (#232)

package/dashboard.js

@@ -3482,34 +3482,34 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       const projects = shared.getProjects(CONFIG);
       const targetProject = projectName ? projects.find(p => p.name?.toLowerCase() === projectName.toLowerCase()) : projects[0];
       const prPath = targetProject ? shared.projectPrPath(targetProject) : path.join(MINIONS_DIR, 'pull-requests.json');
-      const prs = JSON.parse(safeRead(prPath) || '[]');
 
       // Extract PR number from URL
       const prNumMatch = url.match(/\/pull\/(\d+)|pullrequest\/(\d+)/);
       const prNum = prNumMatch ? (prNumMatch[1] || prNumMatch[2]) : Date.now().toString().slice(-6);
       const prId = 'PR-' + prNum;
 
-      if (prs.some(p => p.id === prId || p.url === url)) return jsonReply(res, 400, { error: 'PR already tracked' });
-
-      // Save minimal entry — the existing pollPrStatus (ado.js/github.js) will
-      // fetch title, author, branch, build status, and review status on next poll cycle (~6 min).
-      // For auto-observe PRs, status='active' makes pollPrStatus process them.
-      // For context-only PRs, status='linked' skips polling but shows in agent context.
-      prs.push({
-        id: prId,
-        title: (title || 'PR #' + prNum + ' (polling...)').slice(0, 120),
-        agent: 'human',
-        branch: '',
-        reviewStatus: autoObserve ? 'pending' : 'none',
-        status: autoObserve ? 'active' : 'linked',
-        created: new Date().toISOString(),
-        url,
-        prdItems: [],
-        _manual: true,
-        _autoObserve: !!autoObserve,
-        _context: context || '',
-      });
-      safeWrite(prPath, prs);
+      // Atomic check-and-insert to prevent duplicates and races with polling loops
+      let duplicate = false;
+      mutateJsonFileLocked(prPath, (prs) => {
+        if (!Array.isArray(prs)) prs = [];
+        if (prs.some(p => p.id === prId || p.url === url)) { duplicate = true; return prs; }
+        prs.push({
+          id: prId,
+          title: (title || 'PR #' + prNum + ' (polling...)').slice(0, 120),
+          agent: 'human',
+          branch: '',
+          reviewStatus: autoObserve ? 'pending' : 'none',
+          status: autoObserve ? 'active' : 'linked',
+          created: new Date().toISOString(),
+          url,
+          prdItems: [],
+          _manual: true,
+          _autoObserve: !!autoObserve,
+          _context: context || '',
+        });
+        return prs;
+      }, { defaultValue: [] });
+      if (duplicate) return jsonReply(res, 400, { error: 'PR already tracked' });
       invalidateStatusCache();
       return jsonReply(res, 200, { ok: true, id: prId });
     }},

package/engine/ado.js

@@ -101,11 +101,12 @@ async function forEachActivePr(config, token, callback) {
 
     if (projectUpdated > 0) {
       mutateJsonFileLocked(shared.projectPrPath(project), (currentPrs) => {
-        // Merge updated PRs into the locked copy by ID
-        for (const updatedPr of prs) {
+        // Only merge back PRs that the callback actually modified — not the entire
+        // stale snapshot, which would overwrite concurrent writes from other code paths
+        for (const updatedPr of activePrs) {
           const idx = currentPrs.findIndex(p => p.id === updatedPr.id);
           if (idx >= 0) currentPrs[idx] = updatedPr;
-          else currentPrs.push(updatedPr);
+          // Don't push if not found — it was deleted by another writer, respect that
         }
         return currentPrs;
       }, { defaultValue: [] });

package/engine/github.js

@@ -72,10 +72,10 @@ async function forEachActiveGhPr(config, callback) {
 
     if (projectUpdated > 0) {
       mutateJsonFileLocked(projectPrPath(project), (currentPrs) => {
-        for (const updatedPr of prs) {
+        // Only merge back PRs that the callback actually modified
+        for (const updatedPr of activePrs) {
           const idx = currentPrs.findIndex(p => p.id === updatedPr.id);
           if (idx >= 0) currentPrs[idx] = updatedPr;
-          else currentPrs.push(updatedPr);
         }
         return currentPrs;
       }, { defaultValue: [] });
@@ -113,10 +113,10 @@ async function forEachActiveGhPr(config, callback) {
   }
   if (centralUpdated > 0) {
     mutateJsonFileLocked(centralPath, (currentPrs) => {
-      for (const updatedPr of centralPrs) {
+      // Only merge back central PRs that the callback actually modified
+      for (const updatedPr of activeCentral) {
         const idx = currentPrs.findIndex(p => p.id === updatedPr.id);
         if (idx >= 0) currentPrs[idx] = updatedPr;
-        else currentPrs.push(updatedPr);
       }
       return currentPrs;
     }, { defaultValue: [] });

package/engine/lifecycle.js

@@ -714,66 +714,63 @@ function syncPrsFromOutput(output, agentId, meta, config) {
 function updatePrAfterReview(agentId, pr, project) {
 
   if (!pr?.id) return;
-  const prs = getPrs(project);
-  const target = prs.find(p => p.id === pr.id);
-  if (!target) return;
 
   const config = getConfig();
   const reviewerName = config.agents[agentId]?.name || agentId;
-  // Record the reviewer — actual verdict comes from ADO/GitHub votes via pollPrStatus.
-  // Set to 'waiting' so pollPrStatus updates it with the real vote on next cycle.
   const dispatch = getDispatch();
   const completedEntry = (dispatch.completed || []).find(d => d.agent === agentId && d.type === 'review');
 
-  // Set reviewStatus to 'waiting' (single source of truth — synced from ADO/GitHub votes on next poll)
-  target.reviewStatus = 'waiting';
-  // Track when this PR was last reviewed — used by engine.js to prevent re-dispatch
-  // until new commits are pushed (lastPushedAt > lastReviewedAt)
-  target.lastReviewedAt = ts();
-  target.minionsReview = {
-    reviewer: reviewerName,
-    reviewedAt: ts(),
-    note: completedEntry?.task || ''
-  };
-  // Metrics update: don't track 'waiting' as a verdict — metrics are updated
-  // when pollPrStatus syncs the actual vote to minionsReview.status.
-  // The reviewer's reviewsDone counter is incremented in the main updateMetrics call.
-
-  // Track reviewer for metrics purposes
+  const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
+  let updatedTarget = null;
+  shared.mutateJsonFileLocked(prPath, (prs) => {
+    if (!Array.isArray(prs)) return prs;
+    const target = prs.find(p => p.id === pr.id);
+    if (!target) return prs;
+    target.reviewStatus = 'waiting';
+    target.lastReviewedAt = ts();
+    target.minionsReview = {
+      reviewer: reviewerName,
+      reviewedAt: ts(),
+      note: completedEntry?.task || ''
+    };
+    updatedTarget = { ...pr, ...target };
+    return prs;
+  }, { defaultValue: [] });
+
+  // Track reviewer for metrics purposes (separate file, separate lock)
   const authorAgentId = (pr.agent || '').toLowerCase();
   if (authorAgentId && config.agents?.[authorAgentId]) {
-    const metricsPath = path.join(ENGINE_DIR, 'metrics.json');
-    const metrics = safeJson(metricsPath) || {};
-    if (!metrics[authorAgentId]) metrics[authorAgentId] = { tasksCompleted:0, tasksErrored:0, prsCreated:0, prsApproved:0, prsRejected:0, reviewsDone:0, lastTask:null, lastCompleted:null };
-    if (!metrics[agentId]) metrics[agentId] = { tasksCompleted:0, tasksErrored:0, prsCreated:0, prsApproved:0, prsRejected:0, reviewsDone:0, lastTask:null, lastCompleted:null };
-    metrics[agentId].reviewsDone = (metrics[agentId].reviewsDone || 0) + 1;
-    shared.safeWrite(metricsPath, metrics);
+    shared.mutateJsonFileLocked(path.join(ENGINE_DIR, 'metrics.json'), (metrics) => {
+      if (!metrics[authorAgentId]) metrics[authorAgentId] = { tasksCompleted:0, tasksErrored:0, prsCreated:0, prsApproved:0, prsRejected:0, reviewsDone:0, lastTask:null, lastCompleted:null };
+      if (!metrics[agentId]) metrics[agentId] = { tasksCompleted:0, tasksErrored:0, prsCreated:0, prsApproved:0, prsRejected:0, reviewsDone:0, lastTask:null, lastCompleted:null };
+      metrics[agentId].reviewsDone = (metrics[agentId].reviewsDone || 0) + 1;
+      return metrics;
+    }, { defaultValue: {} });
   }
 
-  shared.safeWrite(project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json'), prs);
-  log('info', `Updated ${pr.id} → minions review: ${target.reviewStatus} by ${reviewerName}`);
-  createReviewFeedbackForAuthor(agentId, { ...pr, ...target }, config);
+  log('info', `Updated ${pr.id} → minions review: waiting by ${reviewerName}`);
+  if (updatedTarget) createReviewFeedbackForAuthor(agentId, updatedTarget, config);
 }
 
 function updatePrAfterFix(pr, project, source) {
 
   if (!pr?.id) return;
-  const prs = getPrs(project);
-  const target = prs.find(p => p.id === pr.id);
-  if (!target) return;
-
-  // Reset reviewStatus to 'waiting' for re-review (single source of truth)
-  target.reviewStatus = 'waiting';
-  if (source === 'pr-human-feedback') {
-    if (target.humanFeedback) 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`);
-  } else {
-    target.minionsReview = { ...target.minionsReview, note: 'Fixed, awaiting re-review', fixedAt: ts() };
-    log('info', `Updated ${pr.id} → reviewStatus: waiting (fix pushed)`);
-  }
-
-  shared.safeWrite(project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json'), prs);
+  const prPath = project ? shared.projectPrPath(project) : path.join(path.resolve(MINIONS_DIR, '..'), '.minions', 'pull-requests.json');
+  shared.mutateJsonFileLocked(prPath, (prs) => {
+    if (!Array.isArray(prs)) return prs;
+    const target = prs.find(p => p.id === pr.id);
+    if (!target) return prs;
+    target.reviewStatus = 'waiting';
+    if (source === 'pr-human-feedback') {
+      if (target.humanFeedback) 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`);
+    } else {
+      target.minionsReview = { ...target.minionsReview, note: 'Fixed, awaiting re-review', fixedAt: ts() };
+      log('info', `Updated ${pr.id} → reviewStatus: waiting (fix pushed)`);
+    }
+    return prs;
+  }, { defaultValue: [] });
 }
 
 // ─── Post-Merge / Post-Close Hooks ───────────────────────────────────────────
@@ -1196,7 +1193,7 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
             if (wi.status === WI_STATUS.DONE || wi.completedAt) {
               log('info', `Skip retry for ${meta.item.id} — already completed`);
             } else {
-              wi._retryCount = retries + 1; wi.status = WI_STATUS.PENDING; delete wi.dispatched_at; delete wi.dispatched_to;
+              wi._retryCount = retries + 1; wi.status = WI_STATUS.PENDING; delete wi.dispatched_at; delete wi.dispatched_to; delete wi.failReason;
               if (type === WORK_TYPE.DECOMPOSE) delete wi._decomposing;
               shared.safeWrite(wiPath, items);
             }
@@ -1317,6 +1314,8 @@ function runPostCompletionHooks(dispatchItem, agentId, code, stdout, config) {
             wi._retryCount = retries + 1;
             delete wi.dispatched_at;
             delete wi.dispatched_to;
+            delete wi.failReason;
+            delete wi.noPr;
             log('info', `Auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries} for ${meta.item.id} (no output, no PR)`);
           } else if (hasOutput) {
             // Agent ran successfully but chose not to create a PR — mark done

package/engine/timeout.js

@@ -254,6 +254,7 @@ function checkTimeouts(config) {
             delete item.dispatched_at;
             delete item.dispatched_to;
             delete item._pendingReason;
+            delete item.failReason;
           } else {
             log('warn', `Reconcile: work item ${item.id} failed after ${retries} retries — marking as failed`);
             item.status = WI_STATUS.FAILED;

package/package.json

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