@link-assistant/hive-mind 1.34.3 → 1.34.5

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @link-assistant/hive-mind
 
+## 1.34.5
+
+### Patch Changes
+
+- ab070db: Use workflow runs API to detect when CI is not triggered, preventing infinite loop (Issue #1442)
+
+  When `--auto-restart-until-mergeable` monitors a PR in a repo that has active GitHub Actions workflows but CI checks never start (e.g., fork PRs needing maintainer approval, `paths-ignore` filtering all changed files, workflow trigger conditions not matching), the monitoring loop now exits immediately instead of waiting indefinitely.
+
+  Instead of using a timeout-based approach, the fix uses the GitHub Actions workflow runs API (`repos/{owner}/{repo}/actions/runs?head_sha={sha}`) to definitively determine if any workflow runs were triggered for the PR's commit. If zero workflow runs exist, CI was not triggered and there is nothing to wait for — the system exits immediately with a diagnostic PR comment.
+
+## 1.34.4
+
+### Patch Changes
+
+- c3806b5: Fix missing log upload on tool failure and make HTTP 529 overload error retryable (Issue #1439)
+
+  Two fixes:
+  1. When `--attach-logs` is enabled and the tool execution fails during an auto-restart session, the failure log was not being uploaded to GitHub. Now the log is attached before stopping on both tool execution failure paths.
+  2. HTTP 529 (Anthropic "Overloaded") errors were not recognized as transient/retryable by the outer retry loop. The code only matched `API Error: 500` + `Overloaded`, but 529 uses `API Error: 529` + `overloaded_error`. Now both 500 and 529 overload errors trigger the retry logic with exponential backoff.
+
 ## 1.34.3
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -129,8 +129,8 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
         return null;
       };
       const jsonError = checkForJsonError(stdout) || checkForJsonError(stderr);
-      // Check for API overload error pattern
-      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (jsonError && jsonError.type === 'api_error' && jsonError.message === 'Overloaded');
+      // Check for API overload error pattern (Issue #1439: also detect 529 overloaded_error)
+      const isOverloadError = (stdout.includes('API Error: 500') && stdout.includes('Overloaded')) || (stdout.includes('API Error: 529') && stdout.includes('Overloaded')) || (stderr.includes('API Error: 500') && stderr.includes('Overloaded')) || (stderr.includes('API Error: 529') && stderr.includes('Overloaded')) || (jsonError && (jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded');
       // Handle overload errors with retry
       if (isOverloadError) {
         if (retryCount < maxRetries) {
@@ -168,7 +168,7 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
       }
       // Check for error patterns in successful response
       if (jsonError) {
-        if (jsonError.type === 'api_error' && jsonError.message === 'Overloaded') {
+        if ((jsonError.type === 'api_error' || jsonError.type === 'overloaded_error') && jsonError.message === 'Overloaded') {
           if (retryCount < maxRetries) {
             const delay = baseDelay * Math.pow(2, retryCount);
             await log(`⚠️ API overload error in response. Retrying in ${delay / 1000} seconds...`, {
@@ -193,7 +193,7 @@ export const validateClaudeConnection = async (model = 'haiku-3') => {
       return true;
     } catch (error) {
       const errorStr = error.message || error.toString();
-      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded'))) {
+      if ((errorStr.includes('API Error: 500') && errorStr.includes('Overloaded')) || (errorStr.includes('API Error: 529') && errorStr.includes('Overloaded')) || (errorStr.includes('api_error') && errorStr.includes('Overloaded')) || (errorStr.includes('overloaded_error') && errorStr.includes('Overloaded'))) {
         if (retryCount < maxRetries) {
           const delay = baseDelay * Math.pow(2, retryCount);
           await log(`⚠️ API overload error during validation. Retrying in ${delay / 1000} seconds...`, {
@@ -1067,11 +1067,11 @@ export const executeClaudeCommand = async params => {
                 const content = Array.isArray(data.message.content) ? data.message.content : [data.message.content];
                 for (const item of content) {
                   if (item.type === 'text' && item.text) {
-                    // Check for the specific 500 overload error pattern
-                    if (item.text.includes('API Error: 500') && item.text.includes('api_error') && item.text.includes('Overloaded')) {
+                    // Check for the specific 500/529 overload error pattern (Issue #1439: 529 is also an overload)
+                    if ((item.text.includes('API Error: 500') || item.text.includes('API Error: 529')) && (item.text.includes('api_error') || item.text.includes('overloaded_error')) && item.text.includes('Overloaded')) {
                       isOverloadError = true;
                       lastMessage = item.text;
-                      await log('⚠️ Detected API overload error', { verbose: true });
+                      await log(`⚠️ Detected API overload error${item.text.includes('529') ? ' (529)' : ' (500)'}`, { verbose: true });
                     }
                     if (item.text.includes('API Error: 500') && item.text.includes('Internal server error') && !item.text.includes('Overloaded')) {
                       isInternalServerError = true;
@@ -1194,7 +1194,7 @@ export const executeClaudeCommand = async params => {
 
       // Issues #1331, #1353: Unified handler for transient API errors (Overloaded, 503, Internal Server Error,
       // Request timed out). All use exponential backoff with session preservation via --resume.
-      const isTransientError = isOverloadError || isInternalServerError || is503Error || isRequestTimeout || (lastMessage.includes('API Error: 500') && (lastMessage.includes('Overloaded') || lastMessage.includes('Internal server error'))) || (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')) || lastMessage.includes('API Error: 503') || (lastMessage.includes('503') && (lastMessage.includes('upstream connect error') || lastMessage.includes('remote connection failure'))) || lastMessage === 'Request timed out' || lastMessage.includes('Request timed out');
+      const isTransientError = isOverloadError || isInternalServerError || is503Error || isRequestTimeout || (lastMessage.includes('API Error: 500') && (lastMessage.includes('Overloaded') || lastMessage.includes('Internal server error'))) || (lastMessage.includes('API Error: 529') && (lastMessage.includes('overloaded_error') || lastMessage.includes('Overloaded'))) || (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')) || (lastMessage.includes('overloaded_error') && lastMessage.includes('Overloaded')) || lastMessage.includes('API Error: 503') || (lastMessage.includes('503') && (lastMessage.includes('upstream connect error') || lastMessage.includes('remote connection failure'))) || lastMessage === 'Request timed out' || lastMessage.includes('Request timed out');
       if ((commandFailed || isTransientError) && isTransientError) {
         // Issue #1353: Timeouts use longer backoff (5min–1hr) vs general transient (2min–30min)
         const maxRetries = isRequestTimeout ? retryLimits.maxRequestTimeoutRetries : retryLimits.maxTransientErrorRetries;
@@ -1222,7 +1222,7 @@ export const executeClaudeCommand = async params => {
         }
         if (retryCount < maxRetries) {
           const delay = Math.min(initialDelay * Math.pow(retryLimits.retryBackoffMultiplier, retryCount), maxDelay);
-          const errorLabel = isRequestTimeout ? 'Request timeout' : isOverloadError || (lastMessage.includes('API Error: 500') && lastMessage.includes('Overloaded')) ? 'API overload (500)' : isInternalServerError || lastMessage.includes('Internal server error') ? 'Internal server error (500)' : '503 network error';
+          const errorLabel = isRequestTimeout ? 'Request timeout' : isOverloadError || (lastMessage.includes('API Error: 500') && lastMessage.includes('Overloaded')) || (lastMessage.includes('API Error: 529') && lastMessage.includes('Overloaded')) ? `API overload (${lastMessage.includes('529') ? '529' : '500'})` : isInternalServerError || lastMessage.includes('Internal server error') ? 'Internal server error (500)' : '503 network error';
           const notRetryableHint = apiMarkedNotRetryable ? ' (API says not retryable — will stop early if no progress)' : '';
           await log(`\n⚠️ ${errorLabel} detected. Retry ${retryCount + 1}/${maxRetries} in ${Math.round(delay / 60000)} min (session preserved)${notRetryableHint}...`, { level: 'warning' });
           await log(`   Error: ${lastMessage.substring(0, 200)}`, { verbose: true });
@@ -1393,7 +1393,7 @@ export const executeClaudeCommand = async params => {
       // Issue #1353: Also handle "Request timed out" in exception block
       // (Overloaded, 503, Internal Server Error, Request timed out) - all with session preservation
       const isTimeoutException = errorStr === 'Request timed out' || errorStr.includes('Request timed out');
-      const isTransientException = isTimeoutException || (errorStr.includes('API Error: 500') && (errorStr.includes('Overloaded') || errorStr.includes('Internal server error'))) || (errorStr.includes('api_error') && errorStr.includes('Overloaded')) || errorStr.includes('API Error: 503') || (errorStr.includes('503') && (errorStr.includes('upstream connect error') || errorStr.includes('remote connection failure')));
+      const isTransientException = isTimeoutException || (errorStr.includes('API Error: 500') && (errorStr.includes('Overloaded') || errorStr.includes('Internal server error'))) || (errorStr.includes('API Error: 529') && (errorStr.includes('overloaded_error') || errorStr.includes('Overloaded'))) || (errorStr.includes('api_error') && errorStr.includes('Overloaded')) || (errorStr.includes('overloaded_error') && errorStr.includes('Overloaded')) || errorStr.includes('API Error: 503') || (errorStr.includes('503') && (errorStr.includes('upstream connect error') || errorStr.includes('remote connection failure')));
       if (isTransientException) {
         // Issue #1353: Use timeout-specific backoff for request timeouts
         const maxRetries = isTimeoutException ? retryLimits.maxRequestTimeoutRetries : retryLimits.maxTransientErrorRetries;
@@ -1401,7 +1401,7 @@ export const executeClaudeCommand = async params => {
         const maxDelay = isTimeoutException ? retryLimits.maxRequestTimeoutDelayMs : retryLimits.maxTransientErrorDelayMs;
         if (retryCount < maxRetries) {
           const delay = Math.min(initialDelay * Math.pow(retryLimits.retryBackoffMultiplier, retryCount), maxDelay);
-          const errorLabel = isTimeoutException ? 'Request timeout' : errorStr.includes('Overloaded') ? 'API overload (500)' : errorStr.includes('Internal server error') ? 'Internal server error (500)' : '503 network error';
+          const errorLabel = isTimeoutException ? 'Request timeout' : errorStr.includes('Overloaded') ? `API overload (${errorStr.includes('529') ? '529' : '500'})` : errorStr.includes('Internal server error') ? 'Internal server error (500)' : '503 network error';
           await log(`\n⚠️ ${errorLabel} in exception. Retry ${retryCount + 1}/${maxRetries} in ${Math.round(delay / 60000)} min (session preserved)...`, { level: 'warning' });
           if (sessionId && !argv.resume) argv.resume = sessionId;
           await waitWithCountdown(delay, log);

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

@@ -197,6 +197,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
     // No CI checks exist yet - this could be:
     // 1. A race condition after push (checks haven't started yet) - wait
     // 2. A repository with no CI/CD configured at all - should be mergeable immediately
+    // 3. CI workflows exist but were not triggered for this commit (fork PR, paths-ignore, etc.)
     //
     // Issue #1345: Distinguish by checking the PR's mergeability status.
     // If GitHub says the PR is MERGEABLE (mergeStateStatus === 'CLEAN'),
@@ -215,16 +216,33 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
       // - 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)`);
+        // Repo HAS workflows — but were they triggered for this commit?
+        // Issue #1442: Use the GitHub Actions workflow runs API to definitively check
+        // if any workflow runs were triggered for this PR's HEAD SHA. This avoids
+        // the need for timeout-based detection:
+        //   - workflow_runs.length > 0 → genuine race condition (CI started, check-runs not yet registered)
+        //   - workflow_runs.length === 0 → CI was NOT triggered (fork PR, paths-ignore, etc.)
+        const workflowRuns = await getWorkflowRunsForSha(owner, repo, ciStatus.sha, verbose);
+        if (workflowRuns.length > 0) {
+          // Workflow runs exist but check-runs haven't appeared yet — genuine race condition
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI check-runs yet, but ${workflowRuns.length} workflow run(s) were triggered for SHA ${ciStatus.sha.substring(0, 7)} - genuine race condition (waiting for check-runs to appear)`);
+          }
+          blockers.push({
+            type: 'ci_pending',
+            message: `CI/CD checks have not started yet (${workflowRuns.length} workflow run(s) triggered, waiting for check-runs to appear)`,
+            details: workflowRuns.map(r => r.name),
+          });
+        } else {
+          // No workflow runs for this SHA — CI was definitively NOT triggered
+          // Issue #1442: This is the root cause of the infinite loop. Fork PRs needing
+          // maintainer approval, paths-ignore filtering, workflow conditions not matching,
+          // etc. all result in zero workflow runs. No need for timeout — exit immediately.
+          if (verbose) {
+            console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} — CI was not triggered (fork PR, paths-ignore, workflow conditions, etc.)`);
+          }
+          return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
         }
-        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.
@@ -323,7 +341,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
     });
   }
 
-  return { blockers, ciStatus, noCiConfigured: false };
+  return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: false };
 };
 
 /**
@@ -368,12 +386,6 @@ export const watchUntilMergeable = async params => {
   let iteration = 0;
   let lastCheckTime = new Date();
 
-  // Issue #1335: Cache whether the repo has CI workflows to avoid repeated API calls.
-  // When 'no_checks' is seen, we check if the repo actually has workflows configured.
-  // - If no workflows exist → 'no_checks' is permanent; treat PR as CI-passing and exit.
-  // - If workflows exist → 'no_checks' is a transient race condition; keep waiting.
-  let repoHasWorkflows = null; // null = not yet checked; true/false = cached result
-
   while (true) {
     iteration++;
     const currentTime = new Date();
@@ -402,7 +414,7 @@ export const watchUntilMergeable = async params => {
 
     try {
       // Get merge blockers
-      const { blockers, noCiConfigured } = await getMergeBlockers(owner, repo, prNumber, argv.verbose);
+      const { blockers, noCiConfigured, noCiTriggered } = await getMergeBlockers(owner, repo, prNumber, argv.verbose);
 
       // Check for new comments from non-bot users
       const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
@@ -410,6 +422,12 @@ export const watchUntilMergeable = async params => {
       // Check for uncommitted changes using shared utility
       const hasUncommittedChanges = await checkForUncommittedChanges(tempDir, argv);
 
+      // Issue #1442: If CI workflows exist but were not triggered for this commit,
+      // log why before proceeding to the mergeable path.
+      if (noCiTriggered) {
+        await log(formatAligned('ℹ️', 'CI not triggered:', 'Workflows exist but no workflow runs for this commit (fork PR, paths-ignore, workflow conditions)', 2));
+      }
+
       // If PR is mergeable, no blockers, no new comments, and no uncommitted changes
       if (blockers.length === 0 && !hasNewComments && !hasUncommittedChanges) {
         await log(formatAligned('✅', 'PR IS MERGEABLE!', ''));
@@ -426,7 +444,7 @@ export const watchUntilMergeable = async params => {
             // Post success comment
             try {
               // Issue #1345: Differentiate message when no CI is configured
-              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : '- All CI checks have passed';
+              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? '- CI workflows exist but were not triggered for this commit' : '- All CI checks have passed';
               const commentBody = `## 🎉 Auto-merged\n\nThis pull request has been automatically merged by hive-mind.\n${ciLine}\n\n---\n*Auto-merged by hive-mind with --auto-merge flag*`;
               await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
             } catch {
@@ -450,7 +468,7 @@ export const watchUntilMergeable = async params => {
           try {
             if (!readyToMergeCommentPosted) {
               // Issue #1345: Differentiate message when no CI is configured
-              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : '- All CI checks have passed';
+              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? '- CI workflows exist but were not triggered for this commit' : '- All CI checks have passed';
               const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n${ciLine}\n- No merge conflicts\n- No pending changes\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
               await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
               readyToMergeCommentPosted = true;
@@ -739,6 +757,40 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
                 await log('');
                 await log(formatAligned('❌', `${argv.tool.toUpperCase()} RESUME FAILED`, ''));
                 await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed after limit reset', 2));
+                // Issue #1439: Attach failure log before stopping, so user can see what happened
+                const shouldAttachLogsOnResumeFail = argv.attachLogs || argv['attach-logs'];
+                if (prNumber && shouldAttachLogsOnResumeFail) {
+                  try {
+                    const logFile = getLogFile();
+                    if (logFile) {
+                      await attachLogToGitHub({
+                        logFile,
+                        targetType: 'pr',
+                        targetNumber: prNumber,
+                        owner,
+                        repo,
+                        $,
+                        log,
+                        sanitizeLogContent,
+                        verbose: argv.verbose,
+                        errorMessage: `${argv.tool.toUpperCase()} execution failed after limit reset`,
+                        sessionId: latestSessionId,
+                        tempDir,
+                        requestedModel: argv.model,
+                        tool: argv.tool || 'claude',
+                      });
+                    }
+                  } catch (logUploadError) {
+                    reportError(logUploadError, {
+                      context: 'attach_auto_restart_failure_log',
+                      prNumber,
+                      owner,
+                      repo,
+                      operation: 'upload_failure_log',
+                    });
+                    await log(formatAligned('', `⚠️  Failure log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
+                  }
+                }
                 return { success: false, reason: 'tool_failure_after_resume', latestSessionId, latestAnthropicCost };
               }
             } else {
@@ -755,6 +807,40 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
           await log('');
           await log(formatAligned('❌', `${argv.tool.toUpperCase()} EXECUTION FAILED`, ''));
           await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed', 2));
+          // Issue #1439: Attach failure log before stopping, so user can see what happened
+          const shouldAttachLogsOnFail = argv.attachLogs || argv['attach-logs'];
+          if (prNumber && shouldAttachLogsOnFail) {
+            try {
+              const logFile = getLogFile();
+              if (logFile) {
+                await attachLogToGitHub({
+                  logFile,
+                  targetType: 'pr',
+                  targetNumber: prNumber,
+                  owner,
+                  repo,
+                  $,
+                  log,
+                  sanitizeLogContent,
+                  verbose: argv.verbose,
+                  errorMessage: `${argv.tool.toUpperCase()} execution failed`,
+                  sessionId: latestSessionId,
+                  tempDir,
+                  requestedModel: argv.model,
+                  tool: argv.tool || 'claude',
+                });
+              }
+            } catch (logUploadError) {
+              reportError(logUploadError, {
+                context: 'attach_auto_restart_failure_log',
+                prNumber,
+                owner,
+                repo,
+                operation: 'upload_failure_log',
+              });
+              await log(formatAligned('', `⚠️  Failure log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
+            }
+          }
           return { success: false, reason: 'tool_failure', latestSessionId, latestAnthropicCost };
         } else {
           // Success - capture latest session data
@@ -820,63 +906,14 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
         // Issue #1314: Distinguish between different waiting reasons
         const pendingBlocker = blockers.find(b => b.type === 'ci_pending');
         const cancelledOnly = blockers.every(b => b.type === 'ci_cancelled' || b.type === 'ci_pending');
+        const cancelledBlocker = blockers.find(b => b.type === 'ci_cancelled');
 
-        // Issue #1335: Detect permanent 'no_checks' state (repo has no CI workflows).
-        // The 'ci_pending' blocker with message 'have not started yet' means GitHub returned
-        // zero check-runs and zero commit statuses for this PR's HEAD SHA. This is ambiguous:
-        //   (a) Transient race condition — CI workflows exist but haven't queued yet after push.
-        //   (b) Permanent state — the repository has no CI/CD workflows configured at all.
-        // We resolve the ambiguity by checking if the repo actually has workflow files via the
-        // GitHub API. If it has none, the 'no_checks' state is permanent and the PR should be
-        // treated as CI-passing (no CI = nothing to wait for).
-        const isNoCIChecks = pendingBlocker && pendingBlocker.message.includes('have not started yet');
-        if (isNoCIChecks) {
-          // Lazy-check whether the repo has workflows (cache result to avoid repeated API calls)
-          if (repoHasWorkflows === null) {
-            const workflowCheck = await getActiveRepoWorkflows(owner, repo, argv.verbose);
-            repoHasWorkflows = workflowCheck.hasWorkflows;
-            if (argv.verbose) {
-              await log(formatAligned('', 'Repo workflow check:', repoHasWorkflows ? `${workflowCheck.count} workflow(s) found — CI check is a transient race condition` : 'No workflows configured — no CI expected', 2));
-            }
-          }
-
-          if (!repoHasWorkflows) {
-            // Root cause confirmed: repo has no CI. The 'no_checks' state is permanent.
-            // Treat the PR as CI-passing and exit the monitoring loop immediately.
-            await log('');
-            await log(formatAligned('ℹ️', 'NO CI WORKFLOWS CONFIGURED', 'Repository has no GitHub Actions workflows'));
-            await log(formatAligned('', 'Conclusion:', 'No CI expected — treating PR as CI-passing', 2));
-            await log(formatAligned('', 'Action:', 'Exiting monitoring loop', 2));
-            await log('');
-
-            // Post a comment explaining the situation
-            try {
-              const commentBody = `## ℹ️ No CI Workflows Detected
-
-No CI/CD checks are configured for this pull request. The repository has no GitHub Actions workflow files in \`.github/workflows/\`.
-
-The auto-restart-until-mergeable monitor is stopping since there is no CI to wait for. The PR may be ready to merge if there are no other issues.
-
----
-*Monitored by hive-mind with --auto-restart-until-mergeable flag*`;
-              await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
-            } catch {
-              // Don't fail if comment posting fails
-            }
-
-            return { success: true, reason: 'no_ci_checks', latestSessionId, latestAnthropicCost };
-          } else {
-            // Repo has workflows but CI hasn't started yet — transient race condition, keep waiting
-            await log(formatAligned('⏳', 'Waiting for CI:', 'No checks yet (CI workflows exist, waiting for them to start)', 2));
-          }
+        if (cancelledOnly && cancelledBlocker) {
+          await log(formatAligned('🔄', 'Waiting for re-triggered CI:', cancelledBlocker.details.join(', '), 2));
+        } else if (pendingBlocker) {
+          await log(formatAligned('⏳', 'Waiting for CI:', pendingBlocker.details.length > 0 ? pendingBlocker.details.join(', ') : pendingBlocker.message, 2));
         } else {
-          if (cancelledOnly && cancelledBlocker) {
-            await log(formatAligned('🔄', 'Waiting for re-triggered CI:', cancelledBlocker.details.join(', '), 2));
-          } else if (pendingBlocker) {
-            await log(formatAligned('⏳', 'Waiting for CI:', pendingBlocker.details.length > 0 ? pendingBlocker.details.join(', ') : pendingBlocker.message, 2));
-          } else {
-            await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
-          }
+          await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
         }
       } else {
         await log(formatAligned('', 'No action needed', 'Continuing to monitor...', 2));