@link-assistant/hive-mind 1.50.6 → 1.50.8

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @link-assistant/hive-mind
 
+## 1.50.8
+
+### Patch Changes
+
+- 5760755: fix: default to PR-branch-only CI check, add pagination and typo fix (#1573)
+  - Fix typo: `--wait-for-all-actions-in-repository-before-mergable` → `--wait-for-all-actions-in-repository-before-mergeable` (deprecated alias kept for backward compatibility)
+  - When repo-wide flag is enabled, block on ALL active runs regardless of branch (no branch filtering) to ensure safety when CI/CD pipelines interact
+  - Add `--paginate` to `getPRCommitShas()` to load all PR commits (not just first page)
+  - Add all-commits CI check: verify CI completes for every commit on the PR branch, not just HEAD
+  - Add `getPRCommitShas()` and `checkAllPRCommitsCI()` for per-commit CI verification
+
+## 1.50.7
+
+### Patch Changes
+
+- 84b9853: fix: make all long sleeps interruptible so CTRL+C responds immediately (#1574)
+  - Replace raw `setTimeout` sleeps with an interruptible sleep utility that listens for SIGINT
+  - Ensure CTRL+C during CI polling, auto-merge waits, and auto-continue delays terminates the process immediately
+  - Add `interruptible-sleep.lib.mjs` with full test coverage
+
 ## 1.50.6
 
 ### Patch Changes

package/package.json

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

package/src/github-merge-repo-actions.lib.mjs

@@ -69,9 +69,61 @@ export async function waitForAllRepoActions(owner, repo, options = {}, verbose =
   return { success: false, waitedForRuns: true, timedOut: true, remainingRuns: finalRuns.runs };
 }
 
+/**
+ * Get all commit SHAs for a pull request branch.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<string[]>} Array of commit SHAs
+ */
+export async function getPRCommitShas(owner, repo, prNumber, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/pulls/${prNumber}/commits" --paginate --jq '[.[].sha]'`);
+    const shas = JSON.parse(stdout.trim() || '[]');
+    if (verbose && shas.length > 1) {
+      console.log(`[VERBOSE] pr-commits: ${shas.length} commits on PR #${prNumber}`);
+    }
+    return shas;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check that workflow runs for ALL commits on the PR branch have completed.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} prNumber - Pull request number
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Function} getWorkflowRunsForSha - Function to get workflow runs for a SHA
+ * @returns {Promise<{allComplete: boolean, totalCommits: number, pendingCommits: string[], details: Object[]}>}
+ */
+export async function checkAllPRCommitsCI(owner, repo, prNumber, verbose, getWorkflowRunsForSha) {
+  const shas = await getPRCommitShas(owner, repo, prNumber, verbose);
+  if (shas.length === 0) return { allComplete: true, totalCommits: 0, pendingCommits: [], details: [] };
+
+  const details = [];
+  const pendingCommits = [];
+  for (const sha of shas) {
+    const runs = await getWorkflowRunsForSha(owner, repo, sha, false);
+    const inProgress = runs.filter(r => r.status !== 'completed');
+    const complete = inProgress.length === 0;
+    details.push({ sha: sha.substring(0, 7), total: runs.length, inProgress: inProgress.length, complete });
+    if (!complete) pendingCommits.push(sha.substring(0, 7));
+  }
+
+  if (verbose && pendingCommits.length > 0) {
+    console.log(`[VERBOSE] pr-commits: ${pendingCommits.length}/${shas.length} commits have in-progress CI: ${pendingCommits.join(', ')}`);
+  }
+
+  return { allComplete: pendingCommits.length === 0, totalCommits: shas.length, pendingCommits, details };
+}
+
 /**
  * Multi-mechanism CI consensus check. Requires Check Runs API, Workflow Runs API,
  * and optionally repo-wide active runs to ALL agree before concluding CI is complete.
+ * Issue #1573: Also checks all PR commits' CI (not just head SHA) by default.
  * @param {Object} params
  * @returns {Promise<{allAgree: boolean, mechanisms: Object, ciStatus: Object, workflowRuns: Array}>}
  */
@@ -82,6 +134,15 @@ export async function checkCIConsensus({ owner, repo, prNumber, sha, waitForAllR
   const workflowRuns = await getWorkflowRunsForSha(owner, repo, sha, verbose);
   const workflowsOK = workflowRuns.length === 0 || workflowRuns.every(r => r.status === 'completed');
 
+  let allCommitsOK = true;
+  let allCommitsInfo = null;
+  if (checkRunsOK && workflowsOK && prNumber) {
+    allCommitsInfo = await checkAllPRCommitsCI(owner, repo, prNumber, verbose, getWorkflowRunsForSha);
+    allCommitsOK = allCommitsInfo.allComplete;
+  }
+
+  // When enabled, block on ANY active CI/CD run in the repository regardless of branch.
+  // This ensures safety when CI/CD pipelines interact or depend on each other.
   let repoOK = true;
   let repoInfo = null;
   if (waitForAllRepoActionsFlag) {
@@ -89,15 +150,18 @@ export async function checkCIConsensus({ owner, repo, prNumber, sha, waitForAllR
     repoOK = !repoInfo.hasActiveRuns;
   }
 
-  const allAgree = checkRunsOK && workflowsOK && repoOK;
+  const allAgree = checkRunsOK && workflowsOK && allCommitsOK && repoOK;
   const mechanisms = {
     checkRunsAPI: { complete: checkRunsOK, status: ciStatus.status },
     workflowRunsAPI: { complete: workflowsOK, total: workflowRuns.length, inProgress: workflowRuns.filter(r => r.status !== 'completed').length },
+    allCommitsCI: allCommitsInfo ? { complete: allCommitsOK, totalCommits: allCommitsInfo.totalCommits, pendingCommits: allCommitsInfo.pendingCommits } : { skipped: true },
     repoActions: waitForAllRepoActionsFlag ? { complete: repoOK, count: repoInfo?.count ?? 0 } : { skipped: true },
   };
 
   if (verbose) {
-    console.log(`[VERBOSE] consensus: CheckRuns=${checkRunsOK}(${ciStatus.status}), WorkflowRuns=${workflowsOK}(${workflowRuns.length}), RepoActions=${waitForAllRepoActionsFlag ? repoOK : 'skip'} → ${allAgree ? 'AGREE' : 'DISAGREE'}`);
+    const repoLabel = waitForAllRepoActionsFlag ? `${repoOK}(${repoInfo?.count ?? 0} active)` : 'skip';
+    const commitsLabel = allCommitsInfo ? `${allCommitsOK}(${allCommitsInfo.totalCommits} commits${allCommitsInfo.pendingCommits.length > 0 ? `, ${allCommitsInfo.pendingCommits.length} pending` : ''})` : 'skip';
+    console.log(`[VERBOSE] consensus: CheckRuns=${checkRunsOK}(${ciStatus.status}), WorkflowRuns=${workflowsOK}(${workflowRuns.length}), AllCommits=${commitsLabel}, RepoActions=${repoLabel} → ${allAgree ? 'AGREE' : 'DISAGREE'}`);
   }
   return { allAgree, mechanisms, ciStatus, workflowRuns };
 }

package/src/github-merge.lib.mjs

@@ -1332,7 +1332,7 @@ export async function getCommitDate(owner, repo, sha, verbose = false) {
 export async function checkPreviousPRCommitsHadCI(owner, repo, prNumber, headSha, verbose = false) {
   try {
     // Get all commits in the PR
-    const { stdout: commitsJson } = await exec(`gh api "repos/${owner}/${repo}/pulls/${prNumber}/commits?per_page=100" --jq '[.[].sha]'`);
+    const { stdout: commitsJson } = await exec(`gh api "repos/${owner}/${repo}/pulls/${prNumber}/commits" --paginate --jq '[.[].sha]'`);
     const allShas = JSON.parse(commitsJson.trim() || '[]');
 
     // Exclude the current HEAD SHA
@@ -1455,8 +1455,8 @@ export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false,
 import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
 export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
 
-import { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus } from './github-merge-repo-actions.lib.mjs'; // Issue #1503
-export { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus };
+import { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas } from './github-merge-repo-actions.lib.mjs'; // Issue #1503
+export { getAllActiveRepoRuns, waitForAllRepoActions, checkCIConsensus, checkAllPRCommitsCI, getPRCommitShas };
 
 export default {
   READY_LABEL,

package/src/interruptible-sleep.lib.mjs

@@ -0,0 +1,42 @@
+/**
+ * Interruptible sleep utility for long-running wait loops.
+ *
+ * Replaces raw `await new Promise(r => setTimeout(r, ms))` with a sleep
+ * that resolves immediately on SIGINT, so the process exit handler chain
+ * is not blocked by a lingering timer.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1574
+ */
+
+/**
+ * Sleep for `ms` milliseconds, but resolve early if SIGINT is received.
+ *
+ * When SIGINT fires during the sleep, the timer is cleared and the promise
+ * resolves with `{ interrupted: true }`. The existing SIGINT handler (from
+ * exit-handler.lib.mjs) continues to run normally — this function does NOT
+ * consume or re-emit the signal, it only ensures its own timer doesn't
+ * block the event loop.
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {Promise<{interrupted: boolean}>}
+ */
+export function interruptibleSleep(ms) {
+  return new Promise(resolve => {
+    let timer;
+
+    const onInterrupt = () => {
+      clearTimeout(timer);
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: true });
+    };
+
+    timer = setTimeout(() => {
+      process.removeListener('SIGINT', onInterrupt);
+      resolve({ interrupted: false });
+    }, ms);
+
+    process.on('SIGINT', onInterrupt);
+  });
+}
+
+export default { interruptibleSleep };

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

@@ -49,6 +49,9 @@ const { extractLinkedIssueNumber } = githubLinking;
 // Import configuration
 import { autoContinue, limitReset } from './config.lib.mjs';
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 const { calculateWaitTime } = validation;
 
 /**
@@ -116,7 +119,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     }, countdownInterval);
 
     // Wait until reset time
-    await new Promise(resolve => setTimeout(resolve, waitMs));
+    await interruptibleSleep(waitMs);
     clearInterval(countdownTimer);
 
     const actionType = isRestart ? 'Restarting' : 'Resuming';

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

@@ -54,6 +54,9 @@ import { limitReset } from './config.lib.mjs';
 const autoMergeHelpers = await import('./solve.auto-merge-helpers.lib.mjs');
 const { checkForExistingComment, checkForNonBotComments, getMergeBlockers } = autoMergeHelpers;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Main function: Watch and restart until PR becomes mergeable
  * This implements --auto-restart-until-mergeable functionality
@@ -66,8 +69,9 @@ export const watchUntilMergeable = async params => {
   const MIN_CI_CHECK_INTERVAL_SECONDS = 120;
   const watchInterval = Math.max(rawWatchInterval, MIN_CI_CHECK_INTERVAL_SECONDS);
   const isAutoMerge = argv.autoMerge || false;
-  // Issue #1503: --wait-for-all-actions-in-repository-before-mergable (default: true)
-  const waitForAllRepoActionsFlag = argv.waitForAllActionsInRepositoryBeforeMergable ?? argv['wait-for-all-actions-in-repository-before-mergable'] ?? true;
+  // Issue #1503/#1573: --wait-for-all-actions-in-repository-before-mergeable
+  // When enabled (default: true), blocks merge if ANY CI/CD run in the repo is active — ensures safety when pipelines interact.
+  const waitForAllRepoActionsFlag = argv.waitForAllActionsInRepositoryBeforeMergeable ?? argv['wait-for-all-actions-in-repository-before-mergeable'] ?? argv.waitForAllActionsInRepositoryBeforeMergable ?? argv['wait-for-all-actions-in-repository-before-mergable'] ?? false;
 
   // Track latest session data across all iterations for accurate pricing
   let latestSessionId = null;
@@ -104,7 +108,7 @@ export const watchUntilMergeable = async params => {
   // Issue #1567: Wait for initial cooldown before first check.
   // This gives CI/CD time to start and solution logs time to be posted.
   await log(formatAligned('⏳', 'Initial cooldown:', `Waiting ${INITIAL_COOLDOWN_SECONDS}s before first check...`));
-  await new Promise(resolve => setTimeout(resolve, INITIAL_COOLDOWN_SECONDS * 1000));
+  await interruptibleSleep(INITIAL_COOLDOWN_SECONDS * 1000);
   await log(formatAligned('✅', 'Cooldown complete:', 'Starting monitoring loop'));
   await log('');
 
@@ -200,7 +204,7 @@ export const watchUntilMergeable = async params => {
         if (!noCiConfigured) {
           const DOUBLE_CHECK_DELAY_MS = 10000; // 10 seconds
           await log(formatAligned('🔍', 'Multi-mechanism CI consensus check:', `Waiting ${DOUBLE_CHECK_DELAY_MS / 1000}s then verifying...`, 2));
-          await new Promise(resolve => setTimeout(resolve, DOUBLE_CHECK_DELAY_MS));
+          await interruptibleSleep(DOUBLE_CHECK_DELAY_MS);
 
           // Run multi-mechanism consensus: Check Runs API + Workflow Runs API + Repo-wide actions
           const consensus = await checkCIConsensus({
@@ -216,17 +220,20 @@ export const watchUntilMergeable = async params => {
 
           if (!consensus.allAgree) {
             const m = consensus.mechanisms;
-            await log(formatAligned('🔄', 'CI mechanisms DISAGREE:', `CheckRuns=${m.checkRunsAPI.status}, WorkflowRuns=${m.workflowRunsAPI.inProgress} in-progress, RepoActions=${m.repoActions.skipped ? 'skipped' : m.repoActions.count + ' active'}`, 2));
+            const repoLabel = m.repoActions.skipped ? 'skipped' : `${m.repoActions.count} active`;
+            const commitsLabel = m.allCommitsCI.skipped ? 'skipped' : `${m.allCommitsCI.pendingCommits.length} pending of ${m.allCommitsCI.totalCommits}`;
+            await log(formatAligned('🔄', 'CI mechanisms DISAGREE:', `CheckRuns=${m.checkRunsAPI.status}, WorkflowRuns=${m.workflowRunsAPI.inProgress} in-progress, AllCommits=${commitsLabel}, RepoActions=${repoLabel}`, 2));
             await log(formatAligned('⏳', 'Continuing to monitor...', 'Mechanisms must agree before declaring mergeable', 2));
             consecutiveNoRunsChecks = 0;
             lastCheckTime = currentTime;
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
-          await log(formatAligned('✅', 'All CI mechanisms agree:', `CheckRuns=${consensus.mechanisms.checkRunsAPI.status}, WorkflowRuns=complete(${consensus.mechanisms.workflowRunsAPI.total}), RepoActions=${consensus.mechanisms.repoActions.skipped ? 'skipped' : 'clear'}`, 2));
+          const acLabel = consensus.mechanisms.allCommitsCI.skipped ? '' : `, AllCommits=complete(${consensus.mechanisms.allCommitsCI.totalCommits})`;
+          await log(formatAligned('✅', 'All CI mechanisms agree:', `CheckRuns=${consensus.mechanisms.checkRunsAPI.status}, WorkflowRuns=complete(${consensus.mechanisms.workflowRunsAPI.total})${acLabel}, RepoActions=${consensus.mechanisms.repoActions.skipped ? 'skipped' : 'clear'}`, 2));
         } else if (waitForAllRepoActionsFlag) {
           // Even with no CI configured, check repo-wide actions for absolute safety
           const repoRuns = await getAllActiveRepoRuns(owner, repo, argv.verbose);
@@ -236,7 +243,7 @@ export const watchUntilMergeable = async params => {
             const actualWaitSeconds = currentBackoffSeconds;
             await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
             await log('');
-            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            await interruptibleSleep(actualWaitSeconds * 1000);
             continue;
           }
         }
@@ -606,7 +613,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
             }
 
             // Wait until the limit resets
-            await new Promise(resolve => setTimeout(resolve, waitMs));
+            await interruptibleSleep(waitMs);
 
             await log(formatAligned('✅', 'Usage limit wait complete', 'Resuming session...'));
             await log('');
@@ -841,7 +848,7 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
     const actualWaitSeconds = currentBackoffSeconds;
     await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
     await log('');
-    await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+    await interruptibleSleep(actualWaitSeconds * 1000);
   }
 };
 

package/src/solve.config.lib.mjs

@@ -186,11 +186,16 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Auto-restart until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or other issues. Does NOT auto-merge.',
     default: true,
   },
-  'wait-for-all-actions-in-repository-before-mergable': {
+  'wait-for-all-actions-in-repository-before-mergeable': {
     type: 'boolean',
-    description: 'Wait for ALL active GitHub Actions workflow runs in the entire repository to complete before declaring PR mergeable. Provides absolute safety against interacting CI/CD pipelines. Enabled by default.',
+    description: 'Wait for ALL active GitHub Actions workflow runs in the entire repository to complete before declaring PR mergeable. When enabled, blocks merge if ANY CI/CD run in the repository is active, regardless of branch — this ensures safety when CI/CD pipelines interact or depend on each other. Enabled by default.',
     default: true,
   },
+  'wait-for-all-actions-in-repository-before-mergable': {
+    type: 'boolean',
+    description: 'Deprecated alias for --wait-for-all-actions-in-repository-before-mergeable (fixes typo).',
+    hidden: true,
+  },
   'auto-restart-on-non-updated-pull-request-description': {
     type: 'boolean',
     description: 'Automatically restart if PR title or description still contains auto-generated placeholder text after agent execution. Restarts with a hint about what was not updated.',

package/src/solve.watch.lib.mjs

@@ -37,6 +37,9 @@ const { detectAndCountFeedback } = feedbackLib;
 const restartShared = await import('./solve.restart-shared.lib.mjs');
 const { checkPRMerged, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildUncommittedChangesFeedback, isApiError } = restartShared;
 
+// Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
+const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
+
 /**
  * Monitor for feedback in a loop and trigger restart when detected
  */
@@ -446,7 +449,7 @@ export const watchForFeedback = async params => {
       const actualWaitMs = actualWaitSeconds * 1000;
       await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
       await log(''); // Blank line for readability
-      await new Promise(resolve => setTimeout(resolve, actualWaitMs));
+      await interruptibleSleep(actualWaitMs);
     } else if (isTemporaryWatch && !firstIterationInTemporaryMode) {
       // In auto-restart mode, check immediately without waiting
       await log(formatAligned('', 'Checking immediately for uncommitted changes...', '', 2));