@link-assistant/hive-mind 1.25.4 → 1.25.6

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @link-assistant/hive-mind
 
+## 1.25.6
+
+### Patch Changes
+
+- 5200c2a: Fix auto-restart spamming PR with comments when usage limit is reached (#1356)
+
+  When the AI tool's usage limit is reached during --auto-restart-until-mergeable mode, the loop now:
+  1. Detects the `limitReached` flag from the tool result
+  2. Silently waits for the limit reset time plus a 10-minute buffer (no GitHub comment posted)
+  3. Resumes the session using `--resume <sessionId>` with a "Continue" prompt, preserving context
+
+  For non-limit tool failures, the loop now stops immediately instead of retrying, preventing infinite loops on unrecoverable errors.
+
+## 1.25.5
+
+### Patch Changes
+
+- e0d68a4: fix: prevent false positive 'Ready to merge' for repos with CI but no required branch protection (Issue #1363)
+
+  Previously, the auto-merge logic would incorrectly declare a PR "Ready to merge — no CI/CD configured" when a repository had GitHub Actions workflows but no required status checks in branch protection rules. This happened because:
+  - `mergeStateStatus=CLEAN` (no required checks to block merging)
+  - `check_runs=[]` (CI hadn't started yet — race condition, GitHub takes ~10-30s to register checks)
+
+  The fix adds a workflow detection step (`getActiveRepoWorkflows`) that queries the GitHub Actions API to check if the repository has any active workflows. When workflows exist but no checks have started, the system now correctly identifies this as a race condition (CI hasn't started yet) rather than "no CI configured", and waits for the checks to appear before proceeding.
+
+  Full case study analysis in `docs/case-studies/issue-1363/`.
+
 ## 1.25.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.25.4",
+  "version": "1.25.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/github-merge.lib.mjs

@@ -1227,6 +1227,48 @@ export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
   }
 }
 
+/**
+ * Get the count of active (enabled) GitHub Actions workflows in a repository
+ * Issue #1363: Used to distinguish between "no CI configured" and "CI hasn't started yet"
+ *
+ * When a repo has NO workflows, no_checks means no CI configured.
+ * When a repo HAS workflows, no_checks means CI checks haven't started yet (race condition).
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, hasWorkflows: boolean, workflows: Array<{id: number, name: string, state: string}>}>}
+ */
+export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/workflows" --jq '[.workflows[] | select(.state == "active")] | map({id: .id, name: .name, state: .state})'`);
+    const workflows = JSON.parse(stdout.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${workflows.length} active workflows in ${owner}/${repo}`);
+      for (const wf of workflows) {
+        console.log(`[VERBOSE] /merge:   - ${wf.name} (${wf.id}): ${wf.state}`);
+      }
+    }
+
+    return {
+      count: workflows.length,
+      hasWorkflows: workflows.length > 0,
+      workflows,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error fetching workflows for ${owner}/${repo}: ${error.message}`);
+    }
+    // On error, assume no workflows (safer: avoids false positives in the no-CI case)
+    return {
+      count: 0,
+      hasWorkflows: false,
+      workflows: [],
+    };
+  }
+}
+
 // Issue #1341: Import and re-export post-merge CI functions from separate module
 // to keep this file under the 1500 line limit
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
@@ -1265,4 +1307,6 @@ export default {
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
+  // Issue #1363: Detect active workflows to distinguish "no CI" from race condition
+  getActiveRepoWorkflows,
 };

package/src/solve.auto-merge.lib.mjs

@@ -33,7 +33,7 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha } = githubMergeLib;
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -41,7 +41,14 @@ const { sanitizeLogContent, attachLogToGitHub } = githubLib;
 
 // Import shared utilities from the restart-shared module
 const restartShared = await import('./solve.restart-shared.lib.mjs');
-const { checkPRMerged, checkPRClosed, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildAutoRestartInstructions, isApiError } = restartShared;
+const { checkPRMerged, checkPRClosed, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildAutoRestartInstructions, isUsageLimitReached } = restartShared;
+
+// Import validation functions for time parsing (used for usage limit wait)
+const validation = await import('./solve.validation.lib.mjs');
+const { calculateWaitTime } = validation;
+
+// Import configuration (used for limit reset buffer and jitter)
+import { limitReset } from './config.lib.mjs';
 
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
@@ -197,14 +204,38 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
     // Otherwise (e.g. mergeStateStatus === 'BLOCKED'), treat as pending race condition.
     const earlyMergeStatus = await checkPRMergeable(owner, repo, prNumber, verbose);
     if (earlyMergeStatus.mergeable) {
-      // PR is already mergeable with no CI checks - the repo has no CI/CD configured.
-      // Do NOT add a ci_pending blocker. The mergeability check below will also
-      // confirm this is mergeable, so blockers will be empty → PR IS MERGEABLE path.
-      if (verbose) {
-        console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and is already MERGEABLE - no CI/CD configured`);
+      // Issue #1363: Before concluding "no CI configured", verify the repo actually
+      // has no active GitHub Actions workflows. If workflows exist but no checks have
+      // started yet, this is a race condition (GitHub takes ~10-30s to register checks
+      // after a push), NOT a "no CI configured" situation.
+      //
+      // This fixes a false positive where a repo with CI workflows but WITHOUT branch
+      // protection (required status checks) would be declared "no CI configured" because:
+      // - mergeStateStatus=CLEAN (no required checks to block it)
+      // - check_runs=[] (CI hasn't started yet — race condition)
+      const repoWorkflows = await getActiveRepoWorkflows(owner, repo, verbose);
+      if (repoWorkflows.hasWorkflows) {
+        // Repo HAS workflows — this is a race condition, not "no CI configured"
+        // Wait for CI checks to appear
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks yet, but repo has ${repoWorkflows.count} active workflow(s) - treating as race condition (CI hasn't started)`);
+        }
+        blockers.push({
+          type: 'ci_pending',
+          message: `CI/CD checks have not started yet (${repoWorkflows.count} workflow(s) configured, waiting for checks to appear)`,
+          details: repoWorkflows.workflows.map(wf => wf.name),
+        });
+      } else {
+        // Repo has NO workflows — this is truly "no CI configured"
+        // PR is already mergeable with no CI checks configured.
+        // Do NOT add a ci_pending blocker. The mergeability check below will also
+        // confirm this is mergeable, so blockers will be empty → PR IS MERGEABLE path.
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and repo has no active workflows - no CI/CD configured`);
+        }
+        // Return early with no CI blocker, mergeability already confirmed
+        return { blockers, ciStatus, noCiConfigured: true };
       }
-      // Return early with no CI blocker, mergeability already confirmed
-      return { blockers, ciStatus, noCiConfigured: true };
     } else {
       // PR is not yet mergeable despite no checks - treat as pending race condition
       blockers.push({
@@ -314,9 +345,6 @@ export const watchUntilMergeable = async params => {
   // `restartCount` counts actual AI tool executions (when we actually restart the AI)
   let restartCount = 0;
 
-  // Track consecutive API errors for retry limit
-  const MAX_API_ERROR_RETRIES = 3;
-  let consecutiveApiErrors = 0;
   let currentBackoffSeconds = watchInterval;
 
   await log('');
@@ -596,8 +624,9 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
         await log('');
 
         // Post a comment to PR about the restart
+        // Issue #1356: Include restart count for tracking and add deduplication
         try {
-          const commentBody = `## 🔄 Auto-restart triggered\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergeable mode is active. Will continue until PR becomes mergeable.*`;
+          const commentBody = `## 🔄 Auto-restart triggered (attempt ${restartCount})\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergeable mode is active. Will continue until PR becomes mergeable.*`;
           await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
           await log(formatAligned('', '💬 Posted auto-restart notification to PR', '', 2));
         } catch (commentError) {
@@ -632,33 +661,90 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
         });
 
         if (!toolResult.success) {
-          // Check if this is an API error using shared utility
-          if (isApiError(toolResult)) {
-            consecutiveApiErrors++;
-            await log(formatAligned('⚠️', `${argv.tool.toUpperCase()} execution failed`, `API error detected (${consecutiveApiErrors}/${MAX_API_ERROR_RETRIES})`, 2));
-
-            if (consecutiveApiErrors >= MAX_API_ERROR_RETRIES) {
-              await log('');
-              await log(formatAligned('❌', 'MAXIMUM API ERROR RETRIES REACHED', ''));
-              await log(formatAligned('', 'Error details:', toolResult.result || 'Unknown API error', 2));
-              await log(formatAligned('', 'Action:', 'Exiting to prevent infinite loop', 2));
-              return { success: false, reason: 'api_error', latestSessionId, latestAnthropicCost };
+          // Issue #1356: Check for usage limit errors FIRST (most specific)
+          // When usage limit is reached, silently wait for limitResetTime + buffer + jitter,
+          // then resume the session using --resume <sessionId> with a "Continue" prompt.
+          // No GitHub comment is posted — only log output.
+          if (isUsageLimitReached(toolResult)) {
+            const resumeSessionId = toolResult.sessionId;
+            const resetTime = toolResult.limitResetTime;
+            const baseWaitMs = resetTime ? calculateWaitTime(resetTime) : 0;
+            const bufferMs = limitReset.bufferMs;
+            const jitterMs = Math.floor(Math.random() * limitReset.jitterMs);
+            const waitMs = baseWaitMs + bufferMs + jitterMs;
+            const bufferMinutes = Math.round(bufferMs / 60000);
+            const jitterSeconds = Math.round(jitterMs / 1000);
+            const waitMinutes = Math.round(waitMs / 60000);
+
+            await log('');
+            await log(formatAligned('⏳', 'USAGE LIMIT REACHED', ''));
+            await log(formatAligned('', 'Reset time:', resetTime || 'Unknown', 2));
+            await log(formatAligned('', 'Waiting:', `${waitMinutes} min (reset + ${bufferMinutes} min buffer + ${jitterSeconds}s jitter)`, 2));
+            await log(formatAligned('', 'Action:', 'Silently waiting then resuming — no GitHub comment posted', 2));
+            if (resumeSessionId) {
+              await log(formatAligned('', 'Session ID:', resumeSessionId, 2));
             }
+            await log('');
 
-            // Apply exponential backoff
-            currentBackoffSeconds = Math.min(currentBackoffSeconds * 2, 300);
-            await log(formatAligned('', 'Backing off:', `Will retry after ${currentBackoffSeconds} seconds`, 2));
-          } else {
-            consecutiveApiErrors = 0;
-            currentBackoffSeconds = watchInterval;
-            await log(formatAligned('⚠️', `${argv.tool.toUpperCase()} execution failed`, 'Will retry in next check', 2));
+            // Wait silently until the limit resets (no GitHub comment)
+            await new Promise(resolve => setTimeout(resolve, waitMs));
+
+            await log(formatAligned('✅', 'Usage limit wait complete', 'Resuming session...'));
+            await log('');
+
+            // Resume the session: execute with --resume <sessionId> and a "Continue" prompt
+            // This preserves context and the system message from the original session
+            if (resumeSessionId) {
+              const resumeArgv = { ...argv, resume: resumeSessionId };
+              const resumeResult = await executeToolIteration({
+                issueUrl,
+                owner,
+                repo,
+                issueNumber,
+                prNumber,
+                branchName: prBranch || branchName,
+                tempDir,
+                mergeStateStatus,
+                feedbackLines: ['Continue'],
+                argv: resumeArgv,
+              });
+
+              if (resumeResult.success) {
+                // Resume succeeded - capture session data
+                currentBackoffSeconds = watchInterval;
+                if (resumeResult.sessionId) {
+                  latestSessionId = resumeResult.sessionId;
+                  latestAnthropicCost = resumeResult.anthropicTotalCostUSD;
+                }
+                await log(formatAligned('✅', `${argv.tool.toUpperCase()} resume completed:`, 'Checking if PR is now mergeable...'));
+              } else if (isUsageLimitReached(resumeResult)) {
+                // Hit the limit again immediately after resume — store for next outer iteration
+                await log(formatAligned('⚠️', 'Usage limit hit again after resume', 'Will retry in next check cycle', 2));
+              } else {
+                // Resume failed for a non-limit reason — stop the loop
+                await log('');
+                await log(formatAligned('❌', `${argv.tool.toUpperCase()} RESUME FAILED`, ''));
+                await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed after limit reset', 2));
+                return { success: false, reason: 'tool_failure_after_resume', latestSessionId, latestAnthropicCost };
+              }
+            } else {
+              // No session ID available — cannot resume, restart fresh in next iteration
+              await log(formatAligned('⚠️', 'No session ID for resume', 'Will restart fresh in next check cycle', 2));
+            }
+
+            lastCheckTime = new Date();
+            continue;
           }
+
+          // Any other failure (not usage limit): stop the auto-restart loop
+          // Per reviewer feedback: non-limit failures should fail and stop attempts
+          await log('');
+          await log(formatAligned('❌', `${argv.tool.toUpperCase()} EXECUTION FAILED`, ''));
+          await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed', 2));
+          return { success: false, reason: 'tool_failure', latestSessionId, latestAnthropicCost };
         } else {
-          // Success - reset error counters
-          consecutiveApiErrors = 0;
+          // Success - capture latest session data
           currentBackoffSeconds = watchInterval;
-
-          // Capture latest session data
           if (toolResult.sessionId) {
             latestSessionId = toolResult.sessionId;
             latestAnthropicCost = toolResult.anthropicTotalCostUSD;
@@ -744,7 +830,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
     }
 
     // Wait for next interval
-    const actualWaitSeconds = consecutiveApiErrors > 0 ? currentBackoffSeconds : watchInterval;
+    const actualWaitSeconds = currentBackoffSeconds;
     await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
     await log('');
     await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));

package/src/solve.restart-shared.lib.mjs

@@ -359,6 +359,18 @@ export const isApiError = toolResult => {
   return errorPatterns.some(pattern => toolResult.result.includes(pattern));
 };
 
+/**
+ * Issue #1356: Check if a tool result indicates a usage limit was reached
+ * This is separate from isApiError because usage limits return different fields
+ * (limitReached, limitResetTime) and require different handling (exit loop, not retry).
+ * @param {Object} toolResult - Tool execution result
+ * @returns {boolean}
+ */
+export const isUsageLimitReached = toolResult => {
+  if (!toolResult) return false;
+  return toolResult.limitReached === true;
+};
+
 export default {
   checkPRMerged,
   checkPRClosed,
@@ -369,4 +381,5 @@ export default {
   buildAutoRestartInstructions,
   buildUncommittedChangesFeedback,
   isApiError,
+  isUsageLimitReached,
 };