@link-assistant/hive-mind 1.23.7 → 1.23.9

package/CHANGELOG.md

@@ -1,12 +1,26 @@
 # @link-assistant/hive-mind
 
+## 1.23.9
+
+### Patch Changes
+
+- 4456760: Fix merge queue to wait for target branch CI before merging (Issue #1307). The merge queue now checks for active CI runs on the target branch (main) before processing the first PR in the queue. This prevents cancelled workflows, incomplete releases, and failed post-merge checks when multiple PRs are merged in quick succession.
+
+## 1.23.8
+
+### Patch Changes
+
+- Fix spelling: rename --auto-restart-until-mergable to --auto-restart-until-mergeable throughout the codebase. This includes CLI options, function names, variable names, documentation, and code comments to use the correct English spelling.
+
+  Increase limit reset buffer from 5 to 10 minutes and add random jitter (0-5 min) to avoid thundering herd problem when multiple instances wait for the same limit reset. Format reset time in PR comments with relative time and UTC timezone for better user understanding.
+
 ## 1.23.7
 
 ### Patch Changes
 
-- d951635: Fix --auto-restart-until-mergable false positive on empty CI checks
+- d951635: Fix --auto-restart-until-mergeable false positive on empty CI checks
 
-  The `--auto-restart-until-mergable` mode was incorrectly posting "Ready to merge" when CI checks hadn't started yet. This was caused by JavaScript's vacuous truth: `[].every(fn)` returns `true`, so an empty checks array would pass all validation.
+  The `--auto-restart-until-mergeable` mode was incorrectly posting "Ready to merge" when CI checks hadn't started yet. This was caused by JavaScript's vacuous truth: `[].every(fn)` returns `true`, so an empty checks array would pass all validation.
 
   Fix: Return `pending` status when no CI checks exist yet, instead of `success`.
 
@@ -137,7 +151,7 @@
 ### Patch Changes
 
 - fdd8eaa: Fix auto-merge failure in fork mode with permission pre-check (Issue #1226)
-  - Add fork-mode guard in `startAutoRestartUntilMergable()` to detect when `--auto-merge` cannot work
+  - Add fork-mode guard in `startAutoRestartUntilMergeable()` to detect when `--auto-merge` cannot work
   - Add `checkMergePermissions()` function to verify write/push/admin/maintain access before merge attempts
   - Add permission pre-check in `attemptAutoMerge()` to fail fast when user lacks write access
   - Post "Ready to merge" comment to PR when auto-merge cannot be performed due to permissions
@@ -385,7 +399,7 @@
 
 - 5723a93: fix: prevent early exit when --auto-merge flag is used
 
-  The `verifyResults()` function was calling `safeExit(0)` before the auto-merge logic could run. This caused the `--auto-merge` flag to be silently ignored. Now the exit condition properly checks for `argv.autoMerge` and `argv.autoRestartUntilMergable` flags.
+  The `verifyResults()` function was calling `safeExit(0)` before the auto-merge logic could run. This caused the `--auto-merge` flag to be silently ignored. Now the exit condition properly checks for `argv.autoMerge|autoRestartUntilMergeable` and `argv.autoMerge|autoRestartUntilMergeable` flags.
 
 ## 1.15.1
 
@@ -468,11 +482,11 @@
 
 ### Minor Changes
 
-- 03adcb6: Add --auto-merge and --auto-restart-until-mergable options for autonomous PR management
+- 03adcb6: Add --auto-merge and --auto-restart-until-mergeable options for autonomous PR management
 
   New CLI options:
-  - `--auto-merge`: Automatically merge the pull request when CI passes and PR is mergeable. Implies --auto-restart-until-mergable.
-  - `--auto-restart-until-mergable`: Auto-restart the AI agent until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or uncommitted changes. Does NOT auto-merge.
+  - `--auto-merge`: Automatically merge the pull request when CI passes and PR is mergeable. Implies --auto-restart-until-mergeable.
+  - `--auto-restart-until-mergeable`: Auto-restart the AI agent until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or uncommitted changes. Does NOT auto-merge.
 
   Features:
   - Non-bot comment detection with configurable bot patterns

package/package.json

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

package/src/config.lib.mjs

@@ -61,10 +61,19 @@ export const autoContinue = {
 
 // Auto-resume on limit reset configurations
 // See: https://github.com/link-assistant/hive-mind/issues/1152
+// See: https://github.com/link-assistant/hive-mind/issues/1236
 export const limitReset = {
   // Buffer time to wait after limit reset (in milliseconds)
-  // Default: 5 minutes - accounts for server time differences
-  bufferMs: parseIntWithDefault('HIVE_MIND_LIMIT_RESET_BUFFER_MS', 5 * 60 * 1000),
+  // Default: 10 minutes - accounts for server time differences and API propagation delays
+  // Increased from 5 to 10 minutes to reduce risk of hitting limits again immediately
+  // See: https://github.com/link-assistant/hive-mind/issues/1236
+  bufferMs: parseIntWithDefault('HIVE_MIND_LIMIT_RESET_BUFFER_MS', 10 * 60 * 1000),
+  // Random jitter added to buffer to avoid thundering herd problem (in milliseconds)
+  // When multiple instances wait for the same limit reset, jitter distributes their
+  // resume times to reduce simultaneous API load
+  // Default: 5 minutes (0 to 5 minutes random) - total wait after reset: 10-15 minutes
+  // See: https://github.com/link-assistant/hive-mind/issues/1236
+  jitterMs: parseIntWithDefault('HIVE_MIND_LIMIT_RESET_JITTER_MS', 5 * 60 * 1000),
 };
 
 // GitHub API limits
@@ -400,6 +409,7 @@ export const version = {
 // Merge queue configurations
 // See: https://github.com/link-assistant/hive-mind/issues/1143
 // See: https://github.com/link-assistant/hive-mind/issues/1269
+// See: https://github.com/link-assistant/hive-mind/issues/1307
 export const mergeQueue = {
   // Maximum PRs to process in one merge session
   // Default: 10 PRs per session
@@ -417,6 +427,18 @@ export const mergeQueue = {
   // Issue #1269: gh pr merge requires explicit method when running non-interactively
   // Default: 'merge' - creates a merge commit
   mergeMethod: getenv('HIVE_MIND_MERGE_QUEUE_MERGE_METHOD', 'merge'),
+  // Issue #1307: Wait for main branch CI to complete before processing merge queue
+  // When enabled, the merge queue will wait for any active CI runs on the target branch
+  // (usually main) to complete before merging the first PR.
+  // Default: true - ensures all post-merge CI workflows complete before next merge
+  waitForTargetBranchCI: getenv('HIVE_MIND_MERGE_QUEUE_WAIT_FOR_TARGET_CI', 'true').toLowerCase() === 'true',
+  // Issue #1307: Timeout for waiting on target branch CI (in milliseconds)
+  // If active runs don't complete within this time, proceed with merge anyway
+  // Default: 45 minutes (2700000ms)
+  targetBranchCITimeoutMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_TARGET_CI_TIMEOUT_MS', 45 * 60 * 1000),
+  // Issue #1307: Polling interval for checking target branch CI status (in milliseconds)
+  // Default: 30 seconds (30000ms) - more frequent than PR CI polling since we're blocking
+  targetBranchCIPollIntervalMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_TARGET_CI_POLL_INTERVAL_MS', 30 * 1000),
 };
 
 // Helper function to validate configuration values

package/src/github-merge.lib.mjs

@@ -636,6 +636,160 @@ export function parseRepositoryUrl(url) {
   };
 }
 
+/**
+ * Get active workflow runs on a specific branch
+ * Issue #1307: Used to check if there are any in-progress or queued runs on the target branch
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} branch - Branch name (default: main)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{runs: Array<Object>, hasActiveRuns: boolean, count: number}>}
+ */
+export async function getActiveBranchRuns(owner, repo, branch = 'main', verbose = false) {
+  try {
+    // Query for in_progress and queued runs on the specified branch
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?branch=${branch}&per_page=10" --jq '[.workflow_runs[] | select(.status=="in_progress" or .status=="queued")] | map({id: .id, name: .name, status: .status, created_at: .created_at, html_url: .html_url})'`);
+
+    const runs = JSON.parse(stdout.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Found ${runs.length} active runs on ${owner}/${repo} branch ${branch}`);
+      for (const run of runs) {
+        console.log(`[VERBOSE] /merge:   - Run #${run.id}: ${run.name} (${run.status})`);
+      }
+    }
+
+    return {
+      runs,
+      hasActiveRuns: runs.length > 0,
+      count: runs.length,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error checking active runs on ${branch}: ${error.message}`);
+    }
+    return {
+      runs: [],
+      hasActiveRuns: false,
+      count: 0,
+    };
+  }
+}
+
+/**
+ * Wait for all active workflow runs on a branch to complete
+ * Issue #1307: Ensures all CI runs on target branch are complete before merging
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} branch - Branch name (default: main)
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 45 minutes)
+ * @param {number} options.pollInterval - Polling interval in ms (default: 30 seconds)
+ * @param {Function} options.onStatusUpdate - Callback for status updates
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, waitedForRuns: boolean, completedRuns: number, error: string|null}>}
+ */
+export async function waitForBranchCI(owner, repo, branch = 'main', options = {}, verbose = false) {
+  const { timeout = 45 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null } = options;
+
+  const startTime = Date.now();
+  let totalWaitedRuns = 0;
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Checking for active CI runs on ${owner}/${repo} branch ${branch}...`);
+  }
+
+  while (Date.now() - startTime < timeout) {
+    let activeRuns;
+    try {
+      activeRuns = await getActiveBranchRuns(owner, repo, branch, verbose);
+    } catch (error) {
+      // Log and continue on errors
+      console.error(`[ERROR] /merge: Error checking branch CI: ${error.message}`);
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      continue;
+    }
+
+    if (onStatusUpdate) {
+      try {
+        await onStatusUpdate({
+          hasActiveRuns: activeRuns.hasActiveRuns,
+          count: activeRuns.count,
+          runs: activeRuns.runs,
+          elapsedMs: Date.now() - startTime,
+        });
+      } catch (callbackError) {
+        // Log callback errors but continue
+        console.error(`[ERROR] /merge: Status update callback failed: ${callbackError.message}`);
+      }
+    }
+
+    if (!activeRuns.hasActiveRuns) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No active CI runs on ${branch} branch. Ready to proceed.`);
+      }
+      return {
+        success: true,
+        waitedForRuns: totalWaitedRuns > 0,
+        completedRuns: totalWaitedRuns,
+        error: null,
+      };
+    }
+
+    totalWaitedRuns = Math.max(totalWaitedRuns, activeRuns.count);
+
+    if (verbose) {
+      const elapsedSec = Math.round((Date.now() - startTime) / 1000);
+      console.log(`[VERBOSE] /merge: Waiting for ${activeRuns.count} active runs on ${branch}... (${elapsedSec}s elapsed)`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+
+  // Timeout reached
+  const finalCheck = await getActiveBranchRuns(owner, repo, branch, verbose);
+  if (finalCheck.hasActiveRuns) {
+    return {
+      success: false,
+      waitedForRuns: true,
+      completedRuns: totalWaitedRuns - finalCheck.count,
+      error: `Timeout waiting for ${finalCheck.count} CI runs on ${branch} branch`,
+    };
+  }
+
+  return {
+    success: true,
+    waitedForRuns: totalWaitedRuns > 0,
+    completedRuns: totalWaitedRuns,
+    error: null,
+  };
+}
+
+/**
+ * Get the default branch for a repository
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<string>} Default branch name (e.g., 'main' or 'master')
+ */
+export async function getDefaultBranch(owner, repo, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh api repos/${owner}/${repo} --jq '.default_branch'`);
+    const branch = stdout.trim();
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Default branch for ${owner}/${repo}: ${branch}`);
+    }
+
+    return branch || 'main';
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error getting default branch, falling back to 'main': ${error.message}`);
+    }
+    return 'main';
+  }
+}
+
 export default {
   READY_LABEL,
   checkReadyLabelExists,
@@ -651,4 +805,8 @@ export default {
   mergePullRequest,
   waitForCI,
   parseRepositoryUrl,
+  // Issue #1307: New exports for target branch CI waiting
+  getActiveBranchRuns,
+  waitForBranchCI,
+  getDefaultBranch,
 };

package/src/github.lib.mjs

@@ -1,24 +1,15 @@
 #!/usr/bin/env node
-// GitHub-related utility functions
-// Check if use is already defined (when imported from solve.mjs)
-// If not, fetch it (when running standalone)
-if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
-}
-// Use command-stream for consistent $ behavior
-const { $ } = await use('command-stream');
-// Import log and maskToken from general lib
+// GitHub-related utility functions. Check if use is already defined (when imported from solve.mjs), if not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+const { $ } = await use('command-stream'); // Use command-stream for consistent $ behavior
 import { log, maskToken, cleanErrorMessage } from './lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
-// Import batch operations from separate module
 import { batchCheckPullRequestsForIssues as batchCheckPRs, batchCheckArchivedRepositories as batchCheckArchived } from './github.batch.lib.mjs';
-// Import token sanitization from dedicated module (Issue #1037 fix)
 import { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeLogContent } from './token-sanitization.lib.mjs';
-// Re-export token sanitization functions for backward compatibility
-export { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeLogContent };
-// Import log upload function from separate module
+export { isSafeToken, isHexInSafeContext, getGitHubTokensFromFiles, getGitHubTokensFromCommand, sanitizeLogContent }; // Re-export for backward compatibility
 import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
+import { formatResetTimeWithRelative } from './usage-limit.lib.mjs'; // See: https://github.com/link-assistant/hive-mind/issues/1236
 
 /**
  * Build cost estimation string for log comments
@@ -488,7 +479,11 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 - **Limit Type**: Usage limit exceeded`;
 
       if (limitResetTime) {
-        logComment += `\n- **Reset Time**: ${limitResetTime}`;
+        // Format reset time with relative time and UTC for better user understanding
+        // Shows "in 14m (Feb 6, 3:00 PM UTC)" instead of just "4:00 PM"
+        // See: https://github.com/link-assistant/hive-mind/issues/1236
+        const formattedResetTime = formatResetTimeWithRelative(limitResetTime, global.limitTimezone || null) || limitResetTime;
+        logComment += `\n- **Reset Time**: ${formattedResetTime}`;
       }
 
       if (sessionId) {
@@ -681,7 +676,11 @@ The automated solution draft was interrupted because the ${toolName} usage limit
 - **Limit Type**: Usage limit exceeded`;
 
             if (limitResetTime) {
-              logUploadComment += `\n- **Reset Time**: ${limitResetTime}`;
+              // Format reset time with relative time and UTC for better user understanding
+              // Shows "in 14m (Feb 6, 3:00 PM UTC)" instead of just "4:00 PM"
+              // See: https://github.com/link-assistant/hive-mind/issues/1236
+              const formattedUploadResetTime = formatResetTimeWithRelative(limitResetTime, global.limitTimezone || null) || limitResetTime;
+              logUploadComment += `\n- **Reset Time**: ${formattedUploadResetTime}`;
             }
 
             if (sessionId) {

package/src/option-suggestions.lib.mjs

@@ -205,7 +205,7 @@ const KNOWN_OPTION_NAMES = [
   'auto-continue-only-on-new-comments',
   'auto-restart-on-limit-reset',
   'auto-restart-on-non-updated-pull-request-description',
-  'auto-restart-until-mergable',
+  'auto-restart-until-mergeable',
   'auto-merge',
   'auto-gitkeep-file',
   'playwright-mcp-auto-cleanup',

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

@@ -81,18 +81,27 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     const baseWaitMs = calculateWaitTime(resetTime);
 
     // Add buffer time after limit reset to account for server time differences
-    // Default: 5 minutes (configurable via HIVE_MIND_LIMIT_RESET_BUFFER_MS)
+    // Default: 10 minutes (configurable via HIVE_MIND_LIMIT_RESET_BUFFER_MS)
     // See: https://github.com/link-assistant/hive-mind/issues/1152
+    // See: https://github.com/link-assistant/hive-mind/issues/1236
     const bufferMs = limitReset.bufferMs;
-    const waitMs = baseWaitMs + bufferMs;
+
+    // Add random jitter to avoid thundering herd problem when multiple instances
+    // wait for the same limit reset time and all resume simultaneously
+    // Default: random 0-5 minutes (configurable via HIVE_MIND_LIMIT_RESET_JITTER_MS)
+    // See: https://github.com/link-assistant/hive-mind/issues/1236
+    const jitterMs = Math.floor(Math.random() * limitReset.jitterMs);
+    const totalBufferMs = bufferMs + jitterMs;
+    const waitMs = baseWaitMs + totalBufferMs;
     const bufferMinutes = Math.round(bufferMs / 60000);
+    const jitterSeconds = Math.round(jitterMs / 1000);
 
     // Format reset time with relative time and UTC for better user understanding
     // See: https://github.com/link-assistant/hive-mind/issues/1152
     const formattedResetTime = formatResetTimeWithRelative(resetTime, timezone);
 
-    await log(`\n⏰ Waiting until ${formattedResetTime} + ${bufferMinutes} min buffer for limit to reset...`);
-    await log(`   Wait time: ${formatWaitTime(waitMs)} (includes ${bufferMinutes} min buffer for server time differences)`);
+    await log(`\n⏰ Waiting until ${formattedResetTime} + ${bufferMinutes} min buffer + ${jitterSeconds}s jitter for limit to reset...`);
+    await log(`   Wait time: ${formatWaitTime(waitMs)} (includes ${bufferMinutes} min buffer + ${jitterSeconds}s random jitter)`);
     await log(`   Current time: ${new Date().toLocaleTimeString()}`);
 
     // Show countdown every 30 minutes for long waits, every minute for short waits
@@ -111,7 +120,7 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     clearInterval(countdownTimer);
 
     const actionType = isRestart ? 'Restarting' : 'Resuming';
-    await log(`\n✅ Limit reset time reached (+ ${bufferMinutes} min buffer)! ${actionType} session...`);
+    await log(`\n✅ Limit reset time reached (+ ${bufferMinutes} min buffer + ${jitterSeconds}s jitter)! ${actionType} session...`);
     await log(`   Current time: ${new Date().toLocaleTimeString()}`);
 
     // Recursively call the solve script

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Auto-merge and auto-restart-until-mergable module for solve.mjs
+ * Auto-merge and auto-restart-until-mergeable module for solve.mjs
  * Handles automatic merging of PRs and continuous restart until PR becomes mergeable
  *
  * Uses shared utilities from solve.restart-shared.lib.mjs for common functions.
@@ -25,7 +25,7 @@ const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;
 
 // Note: We don't use detectAndCountFeedback from solve.feedback.lib.mjs
 // because we have our own non-bot comment detection logic that's more
-// appropriate for auto-restart-until-mergable mode
+// appropriate for auto-restart-until-mergeable mode
 
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
@@ -176,9 +176,9 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
 
 /**
  * Main function: Watch and restart until PR becomes mergeable
- * This implements --auto-restart-until-mergable functionality
+ * This implements --auto-restart-until-mergeable functionality
  */
-export const watchUntilMergable = async params => {
+export const watchUntilMergeable = async params => {
   const { issueUrl, owner, repo, issueNumber, prNumber, prBranch, branchName, tempDir, argv } = params;
 
   const watchInterval = argv.watchInterval || 60; // seconds
@@ -194,9 +194,9 @@ export const watchUntilMergable = async params => {
   let currentBackoffSeconds = watchInterval;
 
   await log('');
-  await log(formatAligned('🔄', 'AUTO-RESTART-UNTIL-MERGABLE MODE ACTIVE', ''));
+  await log(formatAligned('🔄', 'AUTO-RESTART-UNTIL-MERGEABLE MODE ACTIVE', ''));
   await log(formatAligned('', 'Monitoring PR:', `#${prNumber}`, 2));
-  await log(formatAligned('', 'Mode:', isAutoMerge ? 'Auto-merge (will merge when ready)' : 'Auto-restart-until-mergable (will NOT auto-merge)', 2));
+  await log(formatAligned('', 'Mode:', isAutoMerge ? 'Auto-merge (will merge when ready)' : 'Auto-restart-until-mergeable (will NOT auto-merge)', 2));
   await log(formatAligned('', 'Checking interval:', `${watchInterval} seconds`, 2));
   await log(formatAligned('', 'Stop conditions:', 'PR merged, PR closed, or becomes mergeable', 2));
   await log(formatAligned('', 'Restart triggers:', 'New non-bot comments, CI failures, merge conflicts', 2));
@@ -215,7 +215,7 @@ export const watchUntilMergable = async params => {
     const isMerged = await checkPRMerged(owner, repo, prNumber);
     if (isMerged) {
       await log('');
-      await log(formatAligned('🎉', 'PR MERGED!', 'Stopping auto-restart-until-mergable mode'));
+      await log(formatAligned('🎉', 'PR MERGED!', 'Stopping auto-restart-until-mergeable mode'));
       await log(formatAligned('', 'Pull request:', `#${prNumber} has been merged`, 2));
       await log('');
       return { success: true, reason: 'merged', latestSessionId, latestAnthropicCost };
@@ -225,7 +225,7 @@ export const watchUntilMergable = async params => {
     const isClosed = await checkPRClosed(owner, repo, prNumber);
     if (isClosed) {
       await log('');
-      await log(formatAligned('🚫', 'PR CLOSED!', 'Stopping auto-restart-until-mergable mode'));
+      await log(formatAligned('🚫', 'PR CLOSED!', 'Stopping auto-restart-until-mergeable mode'));
       await log(formatAligned('', 'Pull request:', `#${prNumber} has been closed without merging`, 2));
       await log('');
       return { success: false, reason: 'closed', latestSessionId, latestAnthropicCost };
@@ -272,11 +272,11 @@ export const watchUntilMergable = async params => {
         } else {
           // Just report that PR is mergeable and exit
           await log(formatAligned('', 'PR is ready to be merged manually', '', 2));
-          await log(formatAligned('', 'Exiting auto-restart-until-mergable mode', '', 2));
+          await log(formatAligned('', 'Exiting auto-restart-until-mergeable mode', '', 2));
 
           // Post success comment
           try {
-            const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n- All CI checks have passed\n- No merge conflicts\n- No pending changes\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergable flag*`;
+            const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n- All CI checks have passed\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}`;
           } catch {
             // Don't fail if comment posting fails
@@ -345,7 +345,7 @@ export const watchUntilMergable = async params => {
       }
 
       if (shouldRestart) {
-        // Add standard instructions for auto-restart-until-mergable mode using shared utility
+        // Add standard instructions for auto-restart-until-mergeable mode using shared utility
         feedbackLines.push(...buildAutoRestartInstructions());
 
         await log(formatAligned('🔄', 'RESTART TRIGGERED:', restartReason));
@@ -353,7 +353,7 @@ export const watchUntilMergable = async params => {
 
         // Post a comment to PR about the restart
         try {
-          const commentBody = `## 🔄 Auto-restart triggered\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergable mode is active. Will continue until PR becomes mergeable.*`;
+          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.*`;
           await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
           await log(formatAligned('', '💬 Posted auto-restart notification to PR', '', 2));
         } catch (commentError) {
@@ -428,7 +428,7 @@ export const watchUntilMergable = async params => {
             try {
               const logFile = getLogFile();
               if (logFile) {
-                const customTitle = `🔄 Auto-restart-until-mergable Log (iteration ${iteration})`;
+                const customTitle = `🔄 Auto-restart-until-mergeable Log (iteration ${iteration})`;
                 await attachLogToGitHub({
                   logFile,
                   targetType: 'pr',
@@ -478,7 +478,7 @@ export const watchUntilMergable = async params => {
       lastCheckTime = currentTime;
     } catch (error) {
       reportError(error, {
-        context: 'watch_until_mergable',
+        context: 'watch_until_mergeable',
         prNumber,
         owner,
         repo,
@@ -568,22 +568,22 @@ export const attemptAutoMerge = async params => {
 };
 
 /**
- * Start auto-restart-until-mergable mode
+ * Start auto-restart-until-mergeable mode
  */
-export const startAutoRestartUntilMergable = async params => {
+export const startAutoRestartUntilMergeable = async params => {
   const { argv, owner, repo, prNumber } = params;
 
   // Determine the mode
   const isAutoMerge = argv.autoMerge || false;
-  const isAutoRestartUntilMergable = argv.autoRestartUntilMergable || false;
+  const isAutoRestartUntilMergeable = argv.autoRestartUntilMergeable || false;
 
-  if (!isAutoMerge && !isAutoRestartUntilMergable) {
+  if (!isAutoMerge && !isAutoRestartUntilMergeable) {
     return null; // Neither mode enabled
   }
 
   if (!prNumber) {
     await log('');
-    await log(formatAligned('⚠️', 'Auto-restart-until-mergable:', 'Requires a pull request'));
+    await log(formatAligned('⚠️', 'Auto-restart-until-mergeable:', 'Requires a pull request'));
     await log(formatAligned('', 'Note:', 'This mode only works with existing PRs', 2));
     return null;
   }
@@ -632,18 +632,18 @@ export const startAutoRestartUntilMergable = async params => {
     }
   }
 
-  // If --auto-merge implies --auto-restart-until-mergable
+  // If --auto-merge implies --auto-restart-until-mergeable
   if (isAutoMerge) {
-    argv.autoRestartUntilMergable = true;
+    argv.autoRestartUntilMergeable = true;
   }
 
   // Start the watch loop
-  return await watchUntilMergable(params);
+  return await watchUntilMergeable(params);
 };
 
 export default {
-  watchUntilMergable,
+  watchUntilMergeable,
   attemptAutoMerge,
-  startAutoRestartUntilMergable,
+  startAutoRestartUntilMergeable,
   checkForNonBotComments,
 };

package/src/solve.config.lib.mjs

@@ -173,10 +173,10 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'auto-merge': {
     type: 'boolean',
-    description: 'Automatically merge the pull request when the working session is finished and all CI/CD statuses pass and PR is mergeable. Implies --auto-restart-until-mergable.',
+    description: 'Automatically merge the pull request when the working session is finished and all CI/CD statuses pass and PR is mergeable. Implies --auto-restart-until-mergeable.',
     default: false,
   },
-  'auto-restart-until-mergable': {
+  'auto-restart-until-mergeable': {
     type: 'boolean',
     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: false,

package/src/solve.mjs

@@ -74,7 +74,7 @@ const { createUncaughtExceptionHandler, createUnhandledRejectionHandler, handleM
 const watchLib = await import('./solve.watch.lib.mjs');
 const { startWatchMode } = watchLib;
 const autoMergeLib = await import('./solve.auto-merge.lib.mjs');
-const { startAutoRestartUntilMergable } = autoMergeLib;
+const { startAutoRestartUntilMergeable } = autoMergeLib;
 const exitHandler = await import('./exit-handler.lib.mjs');
 const { initializeExitHandler, installGlobalExitHandlers, safeExit } = exitHandler;
 const getResourceSnapshot = memoryCheck.getResourceSnapshot;
@@ -1080,7 +1080,10 @@ try {
             // See: https://github.com/link-assistant/hive-mind/issues/1152
             const continueModeName = limitContinueMode === 'restart' ? 'auto-restart' : 'auto-resume';
             const continueDescription = limitContinueMode === 'restart' ? 'The session will automatically restart (fresh start) when the limit resets.' : 'The session will automatically resume (with context preserved) when the limit resets.';
-            const waitingComment = `⏳ **Usage Limit Reached - Waiting to ${limitContinueMode === 'restart' ? 'Restart' : 'Continue'}**\n\nThe AI tool has reached its usage limit. ${continueModeName} is enabled.\n\n**Reset time:** ${global.limitResetTime}\n**Wait time:** ${formatWaitTime(waitMs)} (days:hours:minutes:seconds)\n\n${continueDescription}\n\nSession ID: \`${sessionId}\``;
+            // Format reset time with relative time and UTC for better user understanding
+            // See: https://github.com/link-assistant/hive-mind/issues/1236
+            const waitingResetTimeFormatted = formatResetTimeWithRelative(global.limitResetTime, global.limitTimezone || null) || global.limitResetTime;
+            const waitingComment = `⏳ **Usage Limit Reached - Waiting to ${limitContinueMode === 'restart' ? 'Restart' : 'Continue'}**\n\nThe AI tool has reached its usage limit. ${continueModeName} is enabled.\n\n**Reset time:** ${waitingResetTimeFormatted}\n**Wait time:** ${formatWaitTime(waitMs)} (days:hours:minutes:seconds)\n\n${continueDescription}\n\nSession ID: \`${sessionId}\``;
 
             const commentResult = await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${waitingComment}`;
             if (commentResult.code === 0) {
@@ -1403,11 +1406,11 @@ try {
     }
   }
 
-  // Start auto-restart-until-mergable mode if enabled
+  // Start auto-restart-until-mergeable mode if enabled
   // This runs after the normal watch mode completes (if any)
-  // --auto-merge implies --auto-restart-until-mergable
-  if (argv.autoMerge || argv.autoRestartUntilMergable) {
-    const autoMergeResult = await startAutoRestartUntilMergable({
+  // --auto-merge implies --auto-restart-until-mergeable
+  if (argv.autoMerge || argv.autoRestartUntilMergeable) {
+    const autoMergeResult = await startAutoRestartUntilMergeable({
       issueUrl,
       owner,
       repo,
@@ -1425,7 +1428,7 @@ try {
       anthropicTotalCostUSD = autoMergeResult.latestAnthropicCost;
       if (argv.verbose) {
         await log('');
-        await log('📊 Updated session data from auto-restart-until-mergable mode:', { verbose: true });
+        await log('📊 Updated session data from auto-restart-until-mergeable mode:', { verbose: true });
         await log(`   Session ID: ${sessionId}`, { verbose: true });
         if (anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined) {
           await log(`   Anthropic cost: $${anthropicTotalCostUSD.toFixed(6)}`, { verbose: true });

package/src/solve.restart-shared.lib.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 /**
- * Shared utilities for watch mode and auto-restart-until-mergable mode
+ * Shared utilities for watch mode and auto-restart-until-mergeable mode
  *
  * This module contains common functions used by both:
  * - solve.watch.lib.mjs (--watch mode and temporary auto-restart)
- * - solve.auto-merge.lib.mjs (--auto-merge and --auto-restart-until-mergable)
+ * - solve.auto-merge.lib.mjs (--auto-merge and --auto-restart-until-mergeable)
  *
  * Functions extracted to reduce duplication and ensure consistent behavior.
  *
@@ -167,7 +167,7 @@ export const getUncommittedChangesDetails = async tempDir => {
 
 /**
  * Execute the AI tool (Claude, OpenCode, Codex, Agent) for a restart iteration
- * This is the shared tool execution logic used by both watch mode and auto-restart-until-mergable mode
+ * This is the shared tool execution logic used by both watch mode and auto-restart-until-mergeable mode
  * @param {Object} params - Execution parameters
  * @returns {Promise<Object>} - Tool execution result
  */

package/src/solve.results.lib.mjs

@@ -688,12 +688,12 @@ Fixes ${issueRef}
         await log('\n✨ Please review the pull request for the proposed solution draft.');
         // Don't exit if watch mode is enabled OR if auto-restart is needed for uncommitted changes
         // Also don't exit if auto-restart-on-non-updated-pull-request-description detected placeholders
-        // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergable is enabled
+        // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergeable is enabled
         const shouldAutoRestartForPlaceholder = argv.autoRestartOnNonUpdatedPullRequestDescription && (prTitleHasPlaceholder || prBodyHasPlaceholder);
         if (shouldAutoRestartForPlaceholder) {
           await log('\n🔄 Placeholder detected in PR title/description - auto-restart will be triggered');
         }
-        const shouldWaitForAutoMerge = argv.autoMerge || argv.autoRestartUntilMergable;
+        const shouldWaitForAutoMerge = argv.autoMerge || argv.autoRestartUntilMergeable;
         if (shouldWaitForAutoMerge) {
           await log('\n🔄 Auto-merge mode enabled - will attempt to merge after verification');
         }
@@ -764,8 +764,8 @@ Fixes ${issueRef}
       }
       await log('\n✨ A clarifying comment has been added to the issue.');
       // Don't exit if watch mode is enabled OR if auto-restart is needed for uncommitted changes
-      // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergable is enabled
-      const shouldWaitForAutoMergeComment = argv.autoMerge || argv.autoRestartUntilMergable;
+      // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergeable is enabled
+      const shouldWaitForAutoMergeComment = argv.autoMerge || argv.autoRestartUntilMergeable;
       if (!argv.watch && !shouldRestart && !shouldWaitForAutoMergeComment) {
         await safeExit(0, 'Process completed successfully');
       }
@@ -785,8 +785,8 @@ Fixes ${issueRef}
     const reviewLogPath = path.resolve(getLogFile());
     await log(`   ${reviewLogPath}`);
     // Don't exit if watch mode is enabled - it needs to continue monitoring
-    // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergable is enabled
-    const shouldWaitForAutoMergeNoAction = argv.autoMerge || argv.autoRestartUntilMergable;
+    // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergeable is enabled
+    const shouldWaitForAutoMergeNoAction = argv.autoMerge || argv.autoRestartUntilMergeable;
     if (!argv.watch && !shouldWaitForAutoMergeNoAction) {
       await safeExit(0, 'Process completed successfully');
     }
@@ -804,8 +804,8 @@ Fixes ${issueRef}
     const checkLogPath = path.resolve(getLogFile());
     await log(`   ${checkLogPath}`);
     // Don't exit if watch mode is enabled - it needs to continue monitoring
-    // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergable is enabled
-    const shouldWaitForAutoMergeError = argv.autoMerge || argv.autoRestartUntilMergable;
+    // Issue #1219: Also don't exit if auto-merge or auto-restart-until-mergeable is enabled
+    const shouldWaitForAutoMergeError = argv.autoMerge || argv.autoRestartUntilMergeable;
     if (!argv.watch && !shouldWaitForAutoMergeError) {
       await safeExit(0, 'Process completed successfully');
     }

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

@@ -16,7 +16,7 @@
  * @see https://github.com/link-assistant/hive-mind/issues/1143
  */
 
-import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel } from './github-merge.lib.mjs';
+import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch } from './github-merge.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
 
@@ -74,6 +74,11 @@ export const MERGE_QUEUE_CONFIG = {
   // Merge method: 'merge', 'squash', or 'rebase' (Issue #1269)
   // gh pr merge requires explicit method when running non-interactively
   MERGE_METHOD: mergeQueueConfig.mergeMethod,
+
+  // Issue #1307: Wait for target branch CI before first merge
+  WAIT_FOR_TARGET_BRANCH_CI: mergeQueueConfig.waitForTargetBranchCI,
+  TARGET_BRANCH_CI_TIMEOUT_MS: mergeQueueConfig.targetBranchCITimeoutMs,
+  TARGET_BRANCH_CI_POLL_INTERVAL_MS: mergeQueueConfig.targetBranchCIPollIntervalMs,
 };
 
 /**
@@ -229,6 +234,12 @@ export class MergeQueueProcessor {
     this.isCancelled = false;
 
     try {
+      // Issue #1307: Wait for any active CI runs on the target branch before processing
+      // This prevents merging while post-merge CI from previous merges is still running
+      if (MERGE_QUEUE_CONFIG.WAIT_FOR_TARGET_BRANCH_CI) {
+        await this.waitForTargetBranchCI();
+      }
+
       // Process each PR sequentially
       for (this.currentIndex = 0; this.currentIndex < this.items.length; this.currentIndex++) {
         if (this.isCancelled) {
@@ -383,6 +394,54 @@ export class MergeQueueProcessor {
     this.log('Cancellation requested');
   }
 
+  /**
+   * Wait for any active CI runs on the target branch to complete
+   * Issue #1307: Prevents merging while post-merge CI from previous merges is still running
+   * @returns {Promise<void>}
+   */
+  async waitForTargetBranchCI() {
+    // Track if we're waiting for CI (for progress updates)
+    this.waitingForTargetBranchCI = true;
+    this.targetBranchCIStatus = null;
+
+    try {
+      // Get the default branch (usually 'main' or 'master')
+      const targetBranch = await getDefaultBranch(this.owner, this.repo, this.verbose);
+      this.log(`Checking for active CI runs on ${targetBranch} branch before processing queue...`);
+
+      const waitResult = await waitForBranchCI(
+        this.owner,
+        this.repo,
+        targetBranch,
+        {
+          timeout: MERGE_QUEUE_CONFIG.TARGET_BRANCH_CI_TIMEOUT_MS,
+          pollInterval: MERGE_QUEUE_CONFIG.TARGET_BRANCH_CI_POLL_INTERVAL_MS,
+          onStatusUpdate: async status => {
+            this.targetBranchCIStatus = status;
+
+            // Report progress while waiting
+            if (this.onProgress) {
+              await this.onProgress(this.getProgressUpdate());
+            }
+          },
+        },
+        this.verbose
+      );
+
+      if (!waitResult.success) {
+        // Log warning but don't fail - proceed with merge anyway
+        console.warn(`[WARN] /merge-queue: ${waitResult.error}. Proceeding with merge anyway.`);
+      } else if (waitResult.waitedForRuns) {
+        this.log(`Waited for ${waitResult.completedRuns} CI runs to complete on ${targetBranch} branch`);
+      } else {
+        this.log(`No active CI runs on ${targetBranch} branch. Ready to proceed.`);
+      }
+    } finally {
+      this.waitingForTargetBranchCI = false;
+      this.targetBranchCIStatus = null;
+    }
+  }
+
   /**
    * Get current progress update
    */
@@ -456,8 +515,18 @@ export class MergeQueueProcessor {
     message += `⏭️ Skipped: ${update.stats.skipped}  `;
     message += `⏳ Pending: ${update.stats.total - update.progress.processed}\n\n`;
 
+    // Issue #1307: Show waiting status for target branch CI
+    if (this.waitingForTargetBranchCI && this.targetBranchCIStatus) {
+      const elapsedSec = Math.round(this.targetBranchCIStatus.elapsedMs / 1000);
+      const elapsedMin = Math.floor(elapsedSec / 60);
+      const elapsedSecRemainder = elapsedSec % 60;
+      message += `⏱️ Waiting for ${this.targetBranchCIStatus.count} CI run\\(s\\) on target branch to complete \\(${elapsedMin}m ${elapsedSecRemainder}s\\)\\.\\.\\.\\n\\n`;
+    } else if (this.waitingForTargetBranchCI) {
+      message += `⏱️ Checking for active CI runs on target branch\\.\\.\\.\n\n`;
+    }
+
     // Current item being processed
-    if (update.current) {
+    if (update.current && !this.waitingForTargetBranchCI) {
       const statusEmoji = update.currentStatus === MergeItemStatus.WAITING_CI ? '⏱️' : '🔄';
       message += `${statusEmoji} ${update.current}\n\n`;
     }