@link-assistant/hive-mind 1.31.0 → 1.31.2

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @link-assistant/hive-mind
 
+## 1.31.2
+
+### Patch Changes
+
+- efe3506: fix: /merge command no longer falsely fails when latest CI is in progress (Issue #1425)
+
+  The `checkBranchCIHealth` function previously queried only `status=completed` runs
+  to determine if the default branch CI was healthy. When a new commit had an in-progress
+  CI run, the function returned the previous (now superseded) commit's failure as the
+  "latest" CI status, causing the merge queue to be blocked with a false positive error.
+
+  The fix resolves the actual HEAD SHA of the branch first, then queries CI runs
+  specifically for that SHA (without a status filter). If the latest commit's runs are
+  in progress, the function returns `pending: true` (healthy) instead of reporting a
+  failure from an older commit. The merge queue then proceeds to the existing
+  `waitForTargetBranchCI` step which correctly waits for those runs to complete.
+
+## 1.31.1
+
+### Patch Changes
+
+- 5108367: fix: fix root causes of 20-32h process hang after session ends (Issue #1335)
+
+  Two separate bugs caused `solve` processes to run for 20–32 hours after work was complete:
+
+  **Bug A — Infinite loop for repos without CI:** When `--auto-restart-until-mergeable` is used
+  on a repository with no CI/CD workflows, the `watchUntilMergeable` loop was permanently stuck
+  on "CI/CD checks have not started yet" with no exit condition. The root cause was that the code
+  treated `no_checks` identically for both transient race conditions (CI hasn't started yet after
+  a push) and permanent states (repo has no CI at all). Fixed by checking whether the repository
+  actually has GitHub Actions workflows configured (`hasRepoWorkflows()`). If none exist, the
+  `no_checks` state is permanent and the monitor exits immediately, treating the PR as CI-passing.
+  If workflows exist, the state is a transient race condition and the loop keeps waiting.
+
+  **Bug B — No process exit after session ends:** After a successful run (PR became mergeable,
+  work session ended), `solve.mjs` never called `process.exit()`. Sentry's profiling integration
+  (`@sentry/profiling-node`) kept the Node.js event loop alive indefinitely. Fixed by calling
+  `safeExit(0)` at the end of the `finally` block in `solve.mjs`, which flushes Sentry events
+  (up to 2 seconds) and then calls `process.exit(0)`.
+
+  Also adds `--verbose` debug logging of active Node.js handles at exit to aid diagnosis of
+  future occurrences.
+
 ## 1.31.0
 
 ### Minor Changes

package/package.json

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

package/src/github-merge-ci.lib.mjs

@@ -141,62 +141,105 @@ export async function waitForCommitCI(owner, repo, sha, options = {}, verbose =
 /**
  * Check if the default branch has any recent failed CI runs
  * Issue #1341: Used to detect pre-existing failures before starting the merge queue
+ * Issue #1425: Fixed to resolve the actual HEAD SHA first, then check CI for that SHA,
+ *              so that in-progress runs on the latest commit are not mistaken for failures.
  *
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {string} branch - Branch name (usually 'main' or 'master')
- * @param {Object} options - Check options
- * @param {number} options.lookbackCount - Number of recent runs to check (default: 5)
+ * @param {Object} options - Check options (currently unused, kept for API compatibility)
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{healthy: boolean, failedRuns: Array, error: string|null}>}
+ * @returns {Promise<{healthy: boolean, pending: boolean, failedRuns: Array, pendingRuns: Array, error: string|null}>}
  */
-export async function checkBranchCIHealth(owner, repo, branch = 'main', options = {}, verbose = false) {
-  const { lookbackCount = 5 } = options;
-
+export async function checkBranchCIHealth(owner, repo, branch = 'main', options, verbose = false) {
   try {
-    // Get recent completed workflow runs on the branch
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?branch=${branch}&status=completed&per_page=${lookbackCount}" --jq '[.workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha, created_at: .created_at}]'`);
+    // Issue #1425: First, resolve the actual HEAD SHA of the branch.
+    // This avoids the bug where only completed runs are queried: if the latest commit has
+    // an in-progress CI run, querying ?status=completed would return the previous commit's
+    // runs and could incorrectly report a failure from an older (now superseded) commit.
+    let headSha;
+    try {
+      const { stdout: refOut } = await exec(`gh api "repos/${owner}/${repo}/git/ref/heads/${branch}" --jq '.object.sha'`);
+      headSha = refOut.trim();
+    } catch (refError) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Error resolving HEAD SHA for ${branch}: ${refError.message}`);
+      }
+      // On error, assume healthy to avoid blocking merges due to API issues
+      return { healthy: true, pending: false, failedRuns: [], pendingRuns: [], error: null };
+    }
+
+    if (!headSha) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Could not resolve HEAD SHA for ${branch}, assuming healthy`);
+      }
+      return { healthy: true, pending: false, failedRuns: [], pendingRuns: [], error: null };
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Checking CI for latest ${branch} commit ${headSha.substring(0, 7)}`);
+    }
+
+    // Issue #1425: Query CI runs specifically for the HEAD SHA (no status filter).
+    // This ensures we see in-progress runs for the latest commit, not just completed ones.
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${headSha}&per_page=20" --jq '[.workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, html_url: .html_url, head_sha: .head_sha, created_at: .created_at}]'`);
     const runs = JSON.parse(stdout.trim() || '[]');
 
     if (verbose) {
-      console.log(`[VERBOSE] /merge: Checking ${runs.length} recent CI runs on ${owner}/${repo} branch ${branch}`);
+      console.log(`[VERBOSE] /merge: Found ${runs.length} CI run(s) for HEAD commit ${headSha.substring(0, 7)} on ${owner}/${repo} branch ${branch}`);
     }
 
     if (runs.length === 0) {
-      // No recent runs - assume healthy
-      return { healthy: true, failedRuns: [], error: null };
+      // No runs for the latest commit - CI may not have started yet or is not configured.
+      // Assume healthy to avoid blocking merges.
+      return { healthy: true, pending: false, failedRuns: [], pendingRuns: [], error: null };
+    }
+
+    // Issue #1425: Check for in-progress runs on the latest commit.
+    // If the latest commit's CI is still running, we should NOT report failure —
+    // the previous commit's failure (which may appear in completed runs) is no longer relevant.
+    const pendingRuns = runs.filter(r => r.status === 'in_progress' || r.status === 'queued' || r.status === 'waiting' || r.status === 'requested' || r.status === 'pending');
+    if (pendingRuns.length > 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: ${pendingRuns.length} CI run(s) still in progress on ${branch} (latest commit ${headSha.substring(0, 7)})`);
+        for (const run of pendingRuns) {
+          console.log(`[VERBOSE] /merge:   - ${run.name}: ${run.status} (${run.html_url})`);
+        }
+      }
+      // Healthy but pending: caller should wait for CI rather than block the queue
+      return { healthy: true, pending: true, failedRuns: [], pendingRuns, error: null };
     }
 
-    // Check for failures in the most recent run(s)
-    const latestSha = runs[0].head_sha;
-    const latestRuns = runs.filter(r => r.head_sha === latestSha);
-    const failedRuns = latestRuns.filter(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
+    // All runs for the latest commit are completed — check for failures
+    const failedRuns = runs.filter(r => r.conclusion === 'failure' || r.conclusion === 'timed_out');
 
     if (failedRuns.length > 0) {
       if (verbose) {
-        console.log(`[VERBOSE] /merge: Found ${failedRuns.length} failed CI run(s) on ${branch}:`);
+        console.log(`[VERBOSE] /merge: Found ${failedRuns.length} failed CI run(s) on ${branch} (latest commit ${headSha.substring(0, 7)}):`);
         for (const run of failedRuns) {
           console.log(`[VERBOSE] /merge:   - ${run.name}: ${run.conclusion} (${run.html_url})`);
         }
       }
       return {
         healthy: false,
+        pending: false,
         failedRuns,
+        pendingRuns: [],
         error: `${failedRuns.length} CI run(s) failed on ${branch}: ${failedRuns.map(r => r.name).join(', ')}`,
       };
     }
 
     if (verbose) {
-      console.log(`[VERBOSE] /merge: Branch ${branch} CI is healthy (${latestRuns.length} runs checked)`);
+      console.log(`[VERBOSE] /merge: Branch ${branch} CI is healthy (${runs.length} run(s) passed for commit ${headSha.substring(0, 7)})`);
     }
 
-    return { healthy: true, failedRuns: [], error: null };
+    return { healthy: true, pending: false, failedRuns: [], pendingRuns: [], error: null };
   } catch (error) {
     if (verbose) {
       console.log(`[VERBOSE] /merge: Error checking branch CI health: ${error.message}`);
     }
     // On error, assume healthy to avoid blocking merges due to API issues
-    return { healthy: true, failedRuns: [], error: null };
+    return { healthy: true, pending: false, failedRuns: [], pendingRuns: [], error: null };
   }
 }
 

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

@@ -368,6 +368,12 @@ 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();
@@ -812,12 +818,62 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
         const pendingBlocker = blockers.find(b => b.type === 'ci_pending');
         const cancelledOnly = blockers.every(b => b.type === 'ci_cancelled' || b.type === 'ci_pending');
 
-        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));
+        // 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));
+          }
         } else {
-          await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 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 {
+            await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
+          }
         }
       } else {
         await log(formatAligned('', 'No action needed', 'Continuing to monitor...', 2));

package/src/solve.error-handlers.lib.mjs

@@ -152,6 +152,45 @@ export const createUnhandledRejectionHandler = options => {
   };
 };
 
+/**
+ * Handles the case where no PR is available when one is required
+ */
+export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned }) => {
+  await log('');
+  await log(formatAligned('❌', 'FATAL ERROR:', 'No pull request available'), { level: 'error' });
+  await log('');
+  await log('  🔍 What happened:');
+  if (isContinueMode) {
+    await log('     Continue mode is active but no PR number is available.');
+    await log('     This usually means PR creation failed or was skipped incorrectly.');
+  } else {
+    await log('     Auto-PR creation is enabled but no PR was created.');
+    await log('     PR creation may have failed without throwing an error.');
+  }
+  await log('');
+  await log('  💡 Why this is critical:');
+  await log('     The solve command requires a PR for:');
+  await log('     • Tracking work progress');
+  await log('     • Receiving and processing feedback');
+  await log('     • Managing code changes');
+  await log('     • Auto-merging when complete');
+  await log('');
+  await log('  🔧 How to fix:');
+  await log('');
+  await log('  Option 1: Create PR manually and use --continue');
+  await log(`     cd ${tempDir}`);
+  await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
+  await log('     # Then use the PR URL with solve.mjs');
+  await log('');
+  await log('  Option 2: Start fresh without continue mode');
+  await log(`     ./solve.mjs "${issueUrl}" --auto-pull-request-creation`);
+  await log('');
+  await log('  Option 3: Disable auto-PR creation (Claude will create it)');
+  await log(`     ./solve.mjs "${issueUrl}" --no-auto-pull-request-creation`);
+  await log('');
+  await safeExit(1, 'No PR available');
+};
+
 /**
  * Handles execution errors in the main catch block
  */

package/src/solve.mjs

@@ -69,7 +69,7 @@ const usageLimitLib = await import('./usage-limit.lib.mjs');
 const { formatResetTimeWithRelative } = usageLimitLib;
 
 const errorHandlers = await import('./solve.error-handlers.lib.mjs');
-const { createUncaughtExceptionHandler, createUnhandledRejectionHandler, handleMainExecutionError } = errorHandlers;
+const { createUncaughtExceptionHandler, createUnhandledRejectionHandler, handleMainExecutionError, handleNoPrAvailableError } = errorHandlers;
 
 const watchLib = await import('./solve.watch.lib.mjs');
 const { startWatchMode } = watchLib;
@@ -650,39 +650,7 @@ try {
   // CRITICAL: Validate that we have a PR number when required
   // This prevents continuing without a PR when one was supposed to be created
   if ((isContinueMode || argv.autoPullRequestCreation) && !prNumber) {
-    await log('');
-    await log(formatAligned('❌', 'FATAL ERROR:', 'No pull request available'), { level: 'error' });
-    await log('');
-    await log('  🔍 What happened:');
-    if (isContinueMode) {
-      await log('     Continue mode is active but no PR number is available.');
-      await log('     This usually means PR creation failed or was skipped incorrectly.');
-    } else {
-      await log('     Auto-PR creation is enabled but no PR was created.');
-      await log('     PR creation may have failed without throwing an error.');
-    }
-    await log('');
-    await log('  💡 Why this is critical:');
-    await log('     The solve command requires a PR for:');
-    await log('     • Tracking work progress');
-    await log('     • Receiving and processing feedback');
-    await log('     • Managing code changes');
-    await log('     • Auto-merging when complete');
-    await log('');
-    await log('  🔧 How to fix:');
-    await log('');
-    await log('  Option 1: Create PR manually and use --continue');
-    await log(`     cd ${tempDir}`);
-    await log(`     gh pr create --draft --title "Fix issue #${issueNumber}" --body "Fixes #${issueNumber}"`);
-    await log('     # Then use the PR URL with solve.mjs');
-    await log('');
-    await log('  Option 2: Start fresh without continue mode');
-    await log(`     ./solve.mjs "${issueUrl}" --auto-pull-request-creation`);
-    await log('');
-    await log('  Option 3: Disable auto-PR creation (Claude will create it)');
-    await log(`     ./solve.mjs "${issueUrl}" --no-auto-pull-request-creation`);
-    await log('');
-    await safeExit(1, 'No PR available');
+    await handleNoPrAvailableError({ isContinueMode, tempDir, issueNumber, issueUrl, log, formatAligned });
   }
 
   if (isContinueMode) {
@@ -1495,4 +1463,15 @@ try {
   // Issue #1346: Flush Sentry events before exit.
   // closeSentry() uses a hard Promise.race deadline so it cannot block indefinitely.
   await closeSentry();
+
+  // Issue #1335: Log active handles at exit to diagnose future process hang.
+  if (argv.verbose) {
+    const handles = process._getActiveHandles();
+    const requests = process._getActiveRequests();
+    if (handles.length > 0 || requests.length > 0) {
+      await log(`\n🔍 Active Node.js handles at exit (${handles.length} handles, ${requests.length} requests):`, { verbose: true });
+      for (const h of handles) await log(`   Handle: ${h.constructor?.name || typeof h}`, { verbose: true });
+      for (const r of requests) await log(`   Request: ${r.constructor?.name || typeof r}`, { verbose: true });
+    }
+  }
 }

package/src/telegram-merge-queue.lib.mjs

@@ -552,6 +552,19 @@ export class MergeQueueProcessor {
         };
       }
 
+      // Issue #1425: If the latest commit's CI is still in progress, wait for it to complete
+      // rather than proceeding immediately. The WAIT_FOR_TARGET_BRANCH_CI step (below) will
+      // also wait, but checking here ensures we don't skip the health check entirely.
+      if (healthResult.pending) {
+        this.log(`Branch ${targetBranch} has ${healthResult.pendingRuns.length} CI run(s) in progress on the latest commit. Will wait for them to complete.`);
+        // Return healthy so the queue proceeds to the waitForTargetBranchCI step which handles waiting
+        return {
+          healthy: true,
+          failedRuns: [],
+          error: null,
+        };
+      }
+
       this.log(`Branch ${targetBranch} CI is healthy. Ready to proceed.`);
       return {
         healthy: true,