@link-assistant/hive-mind 1.35.6 → 1.35.8

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @link-assistant/hive-mind
 
+## 1.35.8
+
+### Patch Changes
+
+- ca57154: fix: add retry with exponential backoff for PR verification after creation (Issue #1468)
+  - Add retry logic with exponential backoff (up to 5 attempts: 2s, 4s, 6s, 8s, 10s) to PR verification step in solve.auto-pr.lib.mjs to handle GitHub API eventual consistency
+  - Add case study with timeline reconstruction and root cause analysis
+  - Add 11 unit tests covering retry behavior, backoff timing, and edge cases
+
+## 1.35.7
+
+### Patch Changes
+
+- fca8460: fix: prevent infinite CI waiting loop when workflows complete with action_required (Issue #1466)
+  - Detect when all workflow runs completed with non-executing conclusions (action_required, cancelled, stale, skipped) and treat as "CI not triggered" instead of waiting indefinitely for check-runs that will never appear
+  - Add verbose log interceptor (setupVerboseLogInterceptor) to capture [VERBOSE] console.log output in log files, fixing the discrepancy between terminal and log file output
+  - Add case study with root cause analysis and timeline reconstruction from 5 production log files
+  - Add 14 unit tests covering action_required handling, non-executing conclusions, race conditions, and edge cases
+
 ## 1.35.6
 
 ### Patch Changes

package/package.json

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

package/src/hive.mjs

@@ -95,7 +95,7 @@ if (isDirectExecution) {
     const fs = (await withTimeout(use('fs'), 30000, 'loading fs')).promises;
     // Import shared library functions
     const lib = await import('./lib.mjs');
-    const { log, setLogFile, getAbsoluteLogPath, formatTimestamp, cleanErrorMessage, cleanupTempDirectories } = lib;
+    const { log, setLogFile, getAbsoluteLogPath, formatTimestamp, cleanErrorMessage, cleanupTempDirectories, setupVerboseLogInterceptor } = lib;
     const yargsConfigLib = await import('./hive.config.lib.mjs');
     const { createYargsConfig } = yargsConfigLib;
     const claudeLib = await import('./claude.lib.mjs');
@@ -311,6 +311,9 @@ if (isDirectExecution) {
     // Set global verbose mode
     global.verboseMode = argv.verbose;
 
+    // Issue #1466: Intercept console.log to capture [VERBOSE] output in log files
+    setupVerboseLogInterceptor();
+
     // Use the universal GitHub URL parser
     if (githubUrl) {
       const parsedUrl = parseGitHubUrl(githubUrl);

package/src/lib.mjs

@@ -114,6 +114,43 @@ export const log = async (message, options = {}) => {
   }
 };
 
+/**
+ * Issue #1466: Intercept console.log to capture [VERBOSE] output in the log file.
+ *
+ * Functions in github-merge.lib.mjs and github-merge-ci.lib.mjs use console.log()
+ * directly for verbose output (e.g., `console.log('[VERBOSE] /merge: ...')`).
+ * This means verbose diagnostic data only appears in the terminal, not in log files,
+ * making debugging harder.
+ *
+ * This interceptor wraps console.log so that any message containing '[VERBOSE]'
+ * is also appended to the log file. It preserves the original console.log behavior.
+ *
+ * Call this once after setLogFile() to enable the interceptor.
+ */
+let verboseInterceptorInstalled = false;
+export const setupVerboseLogInterceptor = () => {
+  if (verboseInterceptorInstalled) return;
+  verboseInterceptorInstalled = true;
+
+  const originalConsoleLog = console.log.bind(console);
+  console.log = (...args) => {
+    // Always call original console.log first
+    originalConsoleLog(...args);
+
+    // If a log file is set and the message looks like a [VERBOSE] log, append to file
+    if (logFile && args.length > 0) {
+      const firstArg = String(args[0]);
+      if (firstArg.includes('[VERBOSE]')) {
+        const message = args.map(a => String(a)).join(' ');
+        const logMessage = `[${new Date().toISOString()}] [VERBOSE] ${message}`;
+        fs.appendFile(logFile, logMessage + '\n').catch(() => {
+          // Silent fail to avoid infinite loops
+        });
+      }
+    }
+  };
+};
+
 /**
  * Mask sensitive tokens in text
  * @param {string} token - Token to mask
@@ -469,6 +506,7 @@ export default {
   formatAligned,
   displayFormattedError,
   cleanupTempDirectories,
+  setupVerboseLogInterceptor,
 };
 
 /**

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

@@ -224,7 +224,28 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
         //   - 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
+          // Issue #1466: Check if ALL workflow runs are completed without producing check-runs.
+          // This happens when workflows require manual approval (first-time fork contributors,
+          // deployment approvals) — they complete with conclusion=action_required but never
+          // create check-runs. Waiting for check-runs in this case is an infinite loop.
+          //
+          // Also covers other non-executing conclusions: cancelled, stale workflows that
+          // completed without producing check-runs won't produce them in the future either.
+          const allRunsCompleted = workflowRuns.every(r => r.status === 'completed');
+          const allRunsNonExecuting = allRunsCompleted && workflowRuns.every(r => r.conclusion === 'action_required' || r.conclusion === 'cancelled' || r.conclusion === 'stale' || r.conclusion === 'skipped');
+
+          if (allRunsNonExecuting) {
+            // All workflow runs completed without executing jobs — check-runs will never appear.
+            // Treat the same as "CI not triggered" to avoid infinite waiting.
+            const conclusions = [...new Set(workflowRuns.map(r => r.conclusion))].join(', ');
+            if (verbose) {
+              console.log(`[VERBOSE] /merge: PR #${prNumber} has ${workflowRuns.length} workflow run(s) for SHA ${ciStatus.sha.substring(0, 7)}, but all completed without executing (conclusions: ${conclusions}) — check-runs will never appear`);
+            }
+            await log(formatAligned('ℹ️', 'CI workflows completed without executing:', `${conclusions} (${workflowRuns.map(r => r.name).join(', ')})`, 2));
+            return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true, workflowRunConclusions: conclusions };
+          }
+
+          // Some workflow runs are still in progress or produced results — 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)`);
           }
@@ -414,7 +435,7 @@ export const watchUntilMergeable = async params => {
 
     try {
       // Get merge blockers
-      const { blockers, noCiConfigured, noCiTriggered } = await getMergeBlockers(owner, repo, prNumber, argv.verbose);
+      const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions } = 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);
@@ -422,10 +443,15 @@ 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,
+      // Issue #1442/#1466: 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 (workflowRunConclusions) {
+          // Issue #1466: Workflow runs exist but completed without executing (action_required, cancelled, etc.)
+          await log(formatAligned('ℹ️', 'CI not executed:', `Workflow runs completed with: ${workflowRunConclusions} (likely needs maintainer approval)`, 2));
+        } else {
+          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
@@ -444,7 +470,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' : noCiTriggered ? '- CI workflows exist but were not triggered for this commit' : '- All CI checks have passed';
+              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? (workflowRunConclusions ? `- CI workflows completed without executing (${workflowRunConclusions})` : '- 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 {
@@ -468,7 +494,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' : noCiTriggered ? '- CI workflows exist but were not triggered for this commit' : '- All CI checks have passed';
+              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? (workflowRunConclusions ? `- CI workflows completed without executing (${workflowRunConclusions})` : '- 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;

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

@@ -1203,33 +1203,59 @@ ${prBody}`,
 
               // CRITICAL: Verify the PR was actually created by querying GitHub API
               // This is essential because gh pr create can return a URL but PR creation might have failed
+              // Issue #1468: Use retry with exponential backoff because GitHub's API is eventually
+              // consistent — a newly created PR may not be visible via gh pr view for several seconds.
+              // This matches the existing retry pattern used for the compare API (lines 571-624).
               await log(formatAligned('🔍', 'Verifying:', 'PR creation...'), { verbose: true });
-              const verifyResult = await $({
-                silent: true,
-              })`gh pr view ${localPrNumber} --repo ${owner}/${repo} --json number,url,state 2>&1`;
-
-              if (verifyResult.code === 0) {
-                try {
-                  const prData = JSON.parse(verifyResult.stdout.toString().trim());
-                  if (prData.number && prData.url) {
-                    await log(formatAligned('✅', 'Verification:', 'PR exists on GitHub'), { verbose: true });
-                    // Update prUrl and localPrNumber from verified data
-                    prUrl = prData.url;
-                    localPrNumber = String(prData.number);
-                  } else {
-                    throw new Error('PR data incomplete');
+
+              let prVerified = false;
+              let verifyAttempts = 0;
+              const maxVerifyAttempts = 5;
+              let lastVerifyResult = null;
+
+              while (!prVerified && verifyAttempts < maxVerifyAttempts) {
+                verifyAttempts++;
+                const waitTime = Math.min(2000 * verifyAttempts, 10000); // 2s, 4s, 6s, 8s, 10s
+
+                if (verifyAttempts > 1) {
+                  await log(`   Retry ${verifyAttempts}/${maxVerifyAttempts}: Waiting ${waitTime}ms for GitHub to propagate PR...`);
+                }
+
+                await new Promise(resolve => setTimeout(resolve, waitTime));
+
+                lastVerifyResult = await $({
+                  silent: true,
+                })`gh pr view ${localPrNumber} --repo ${owner}/${repo} --json number,url,state 2>&1`;
+
+                if (lastVerifyResult.code === 0) {
+                  try {
+                    const prData = JSON.parse(lastVerifyResult.stdout.toString().trim());
+                    if (prData.number && prData.url) {
+                      await log(formatAligned('✅', 'Verification:', `PR exists on GitHub (attempt ${verifyAttempts}/${maxVerifyAttempts})`), { verbose: true });
+                      // Update prUrl and localPrNumber from verified data
+                      prUrl = prData.url;
+                      localPrNumber = String(prData.number);
+                      prVerified = true;
+                    }
+                  } catch {
+                    // Parse failed, will retry
+                    if (argv.verbose) {
+                      await log(`   Verify attempt ${verifyAttempts}: Could not parse PR data, retrying...`, { verbose: true });
+                    }
                   }
-                } catch {
-                  await log('❌ PR verification failed: Could not parse PR data', { level: 'error' });
-                  throw new Error('PR creation verification failed - invalid response');
+                } else if (argv.verbose) {
+                  const attemptStderr = lastVerifyResult.stderr ? lastVerifyResult.stderr.toString().trim() : '';
+                  await log(`   Verify attempt ${verifyAttempts}: PR not found yet${attemptStderr ? ` (${attemptStderr})` : ''}`, { verbose: true });
                 }
-              } else {
-                // PR does not exist - gh pr create must have failed silently
+              }
+
+              if (!prVerified) {
+                // PR does not exist after all retries - gh pr create must have failed silently
                 // Issue #1462: Include gh pr create stderr for root cause diagnosis
-                const verifyStderr = verifyResult.stderr ? verifyResult.stderr.toString().trim() : '';
+                const verifyStderr = lastVerifyResult && lastVerifyResult.stderr ? lastVerifyResult.stderr.toString().trim() : '';
                 const stderrInfo = prCreateStderr ? ` (gh pr create stderr: ${prCreateStderr.trim()})` : '';
                 const verifyInfo = verifyStderr ? ` (gh pr view stderr: ${verifyStderr})` : '';
-                throw new Error(`PR verification failed - gh pr create returned URL "${prUrl}" but PR #${localPrNumber} does not exist on GitHub${stderrInfo}${verifyInfo}`);
+                throw new Error(`PR verification failed - gh pr create returned URL "${prUrl}" but PR #${localPrNumber} does not exist on GitHub after ${maxVerifyAttempts} verification attempts${stderrInfo}${verifyInfo}`);
               }
               // Store PR info globally for error handlers
               global.createdPR = { number: localPrNumber, url: prUrl };

package/src/solve.mjs

@@ -48,7 +48,7 @@ const fs = (await use('fs')).promises;
 const crypto = (await use('crypto')).default;
 const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
-const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, getVersionInfo } = lib;
+const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, getVersionInfo, setupVerboseLogInterceptor } = lib;
 const githubLib = await import('./github.lib.mjs');
 const { sanitizeLogContent, attachLogToGitHub, getToolDisplayName } = githubLib;
 const validation = await import('./solve.validation.lib.mjs');
@@ -111,6 +111,9 @@ try {
 }
 global.verboseMode = argv.verbose;
 
+// Issue #1466: Intercept console.log to capture [VERBOSE] output in log files
+setupVerboseLogInterceptor();
+
 // Early logs go to cwd; custom log dir takes effect after argv is parsed
 
 // Conditionally import tool-specific functions after argv is parsed