@link-assistant/hive-mind 1.25.5 → 1.25.6

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @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

package/package.json

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

package/src/solve.auto-merge.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
@@ -338,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('');
@@ -620,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) {
@@ -656,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;
@@ -768,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,
 };