@yemi33/minions 0.1.492 → 0.1.494

package/CHANGELOG.md

@@ -1,8 +1,10 @@
 # Changelog
 
-## 0.1.492 (2026-04-07)
+## 0.1.494 (2026-04-07)
 
 ### Fixes
+- GitHub PR poll backoff for inaccessible repos (closes #377) (#386)
+-  reconcile agent completions during engine downtime (closes #376) (#385)
 -  settings button shows modal immediately with loading state
 -  CC respects user scroll position — no auto-scroll when reading history
 -  steering feedback — toast notification, ensure polling resumes

package/engine/cli.js

@@ -221,17 +221,43 @@ const commands = {
           const hasError = output.includes('"is_error":true') || output.includes('"is_error": true');
           if (!hasResult && !hasError) continue;
 
-          const isSuccess = hasResult && !hasError;
-          const result = isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR;
-
-          e.log('info', `Orphan recovery: ${agentId} (${item.id}) completed while engine was down — result: ${result}`);
+          let isSuccess = hasResult && !hasError;
 
-          // Extract PRs from output
+          // Extract PRs from output first — if PRs were created, the agent succeeded
+          // regardless of intermediate error lines in the log
           let prsCreated = 0;
           try {
             prsCreated = lifecycle.syncPrsFromOutput(output, agentId, item.meta, config);
           } catch (err) { e.log('warn', `Orphan PR sync: ${err.message}`); }
 
+          // If PRs were created or a matching PR exists, treat as success
+          if (!isSuccess && prsCreated > 0) {
+            e.log('info', `Orphan recovery: ${agentId} (${item.id}) has ${prsCreated} PR(s) — overriding to success`);
+            isSuccess = true;
+          }
+
+          // Fallback: check pull-requests.json for a matching PR by work item ID
+          if (!isSuccess && item.meta?.item?.id) {
+            try {
+              const projName = item.meta.project?.name;
+              if (projName) {
+                const prPath = path.join(MINIONS_DIR, 'projects', projName, 'pull-requests.json');
+                const prs = safeJson(prPath) || [];
+                const matchingPr = prs.find(pr =>
+                  (pr.prdItems || []).includes(item.meta.item.id) &&
+                  pr.status !== 'abandoned' && pr.status !== 'closed'
+                );
+                if (matchingPr) {
+                  e.log('info', `Orphan recovery: ${agentId} (${item.id}) has matching PR ${matchingPr.id} — overriding to success`);
+                  isSuccess = true;
+                }
+              }
+            } catch (err) { e.log('warn', `Orphan PR lookup: ${err.message}`); }
+          }
+
+          const result = isSuccess ? DISPATCH_RESULT.SUCCESS : DISPATCH_RESULT.ERROR;
+          e.log('info', `Orphan recovery: ${agentId} (${item.id}) completed while engine was down — result: ${result}`);
+
           // Update work item status
           if (item.meta?.item?.id) {
             const status = isSuccess ? WI_STATUS.DONE : WI_STATUS.FAILED;

package/engine/github.js

@@ -30,6 +30,44 @@ function getRepoSlug(project) {
   return `${org}/${repo}`;
 }
 
+// ─── Per-Repo Poll Backoff ──────────────────────────────────────────────────
+// Tracks consecutive poll failures per repo slug to avoid spamming logs when
+// a repo is inaccessible. Backoff doubles each failure: 2min, 4min, 8min, 16min, max 30min.
+const _ghPollBackoff = new Map(); // slug → { failures, backoffUntil }
+const GH_POLL_BACKOFF_BASE_MS = 2 * 60 * 1000; // 2 minutes (one poll cycle)
+const GH_POLL_BACKOFF_MAX_MS = 30 * 60 * 1000;  // 30 minutes cap
+
+/** Check if a repo slug is currently in backoff. Returns true if should skip. */
+function isSlugInBackoff(slug) {
+  const entry = _ghPollBackoff.get(slug);
+  if (!entry) return false;
+  return Date.now() < entry.backoffUntil;
+}
+
+/** Record a poll failure for a repo slug, applying exponential backoff. */
+function recordSlugFailure(slug) {
+  const existing = _ghPollBackoff.get(slug);
+  const failures = (existing?.failures || 0) + 1;
+  const backoffMs = Math.min(GH_POLL_BACKOFF_BASE_MS * Math.pow(2, failures - 1), GH_POLL_BACKOFF_MAX_MS);
+  _ghPollBackoff.set(slug, { failures, backoffUntil: Date.now() + backoffMs });
+  if (failures === 1) {
+    log('warn', `GitHub poll: repo ${slug} failed — will retry in ${Math.round(backoffMs / 1000)}s`);
+  } else {
+    log('warn', `GitHub poll: repo ${slug} failed ${failures} times — backoff ${Math.round(backoffMs / 1000)}s`);
+  }
+}
+
+/** Reset backoff for a repo slug after a successful poll. */
+function resetSlugBackoff(slug) {
+  if (_ghPollBackoff.has(slug)) {
+    const entry = _ghPollBackoff.get(slug);
+    if (entry.failures > 0) {
+      log('info', `GitHub poll: repo ${slug} recovered after ${entry.failures} failure(s)`);
+    }
+    _ghPollBackoff.delete(slug);
+  }
+}
+
 /** Run a `gh api` call and parse JSON result. Returns null on failure. */
 function ghApi(endpoint, slug) {
   try {
@@ -42,6 +80,20 @@ function ghApi(endpoint, slug) {
   }
 }
 
+/**
+ * Run a `gh api` call with per-slug backoff tracking. Returns null on failure.
+ * On success, resets the slug's backoff. On failure, increments it.
+ */
+function ghApiWithBackoff(endpoint, slug) {
+  const result = ghApi(endpoint, slug);
+  if (result === null) {
+    recordSlugFailure(slug);
+  } else {
+    resetSlugBackoff(slug);
+  }
+  return result;
+}
+
 // ─── Shared PR Polling Loop ─────────────────────────────────────────────────
 
 async function forEachActiveGhPr(config, callback) {
@@ -52,10 +104,21 @@ async function forEachActiveGhPr(config, callback) {
     const slug = getRepoSlug(project);
     if (!slug) continue;
 
+    // Skip projects in backoff (inaccessible repo)
+    if (isSlugInBackoff(slug)) continue;
+
     const prs = getPrs(project);
     const activePrs = prs.filter(pr => pr.status === PR_STATUS.ACTIVE);
     if (activePrs.length === 0) continue;
 
+    // Probe repo accessibility before iterating PRs — avoids N warnings per inaccessible repo
+    const probe = ghApi('', slug);
+    if (probe === null) {
+      recordSlugFailure(slug);
+      continue;
+    }
+    resetSlugBackoff(slug);
+
     let projectUpdated = 0;
 
     for (const pr of activePrs) {
@@ -101,6 +164,7 @@ async function forEachActiveGhPr(config, callback) {
     const ghMatch = pr.url.match(/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)/);
     if (!ghMatch) continue;
     const slug = ghMatch[1];
+    if (isSlugInBackoff(slug)) continue;
     const prNum = ghMatch[2];
     try {
       const updated = await callback(null, pr, prNum, slug);
@@ -370,9 +434,16 @@ async function reconcilePrs(config) {
     const slug = getRepoSlug(project);
     if (!slug) continue;
 
+    // Skip projects in backoff (inaccessible repo)
+    if (isSlugInBackoff(slug)) continue;
+
     // Fetch open PRs
     const prsData = ghApi('/pulls?state=open&per_page=100', slug);
-    if (!prsData || !Array.isArray(prsData)) continue;
+    if (!prsData || !Array.isArray(prsData)) {
+      recordSlugFailure(slug);
+      continue;
+    }
+    resetSlugBackoff(slug);
 
     const ghPrs = prsData.filter(pr => {
       const branch = pr.head?.ref || '';
@@ -498,5 +569,10 @@ module.exports = {
   pollPrHumanComments,
   reconcilePrs,
   checkLiveReviewStatus,
+  // Exported for testing
+  isSlugInBackoff,
+  recordSlugFailure,
+  resetSlugBackoff,
+  _ghPollBackoff,
 };
 

package/engine.js

@@ -838,7 +838,10 @@ function reconcileItemsWithPrs(items, allPrs, { onlyIds } = {}) {
   const prLinks = shared.getPrLinks();
   let reconciled = 0;
   for (const wi of items) {
-    if (wi.status !== WI_STATUS.PENDING || wi._pr) continue;
+    // Reconcile pending items AND failed items that have a matching PR
+    // (failed items may have been incorrectly marked during engine downtime)
+    if (wi._pr && wi.status !== WI_STATUS.FAILED) continue;
+    if (wi.status !== WI_STATUS.PENDING && wi.status !== WI_STATUS.FAILED) continue;
     if (onlyIds && !onlyIds.has(wi.id)) continue;
 
     let exactPr = allPrs.find(pr => (pr.prdItems || []).includes(wi.id));
@@ -849,6 +852,10 @@ function reconcileItemsWithPrs(items, allPrs, { onlyIds } = {}) {
     if (exactPr) {
       wi.status = WI_STATUS.DONE;
       wi._pr = exactPr.id;
+      // Clear failure artifacts if reconciling a previously failed item
+      if (wi.failReason) delete wi.failReason;
+      if (wi.failedAt) delete wi.failedAt;
+      if (!wi.completedAt) wi.completedAt = new Date().toISOString();
       reconciled++;
     }
   }

package/package.json

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