@link-assistant/hive-mind 1.24.5 → 1.25.0

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @link-assistant/hive-mind
 
+## 1.25.0
+
+### Minor Changes
+
+- cbac3dd: feat: wait for post-merge CI to complete before merging next PR (Issue #1341)
+
+  This change ensures that the /merge command waits for GitHub Actions to complete after each merge before processing the next PR in the queue.
+
+  **Problem:**
+  - Merge queue was merging PRs too quickly (70 seconds apart)
+  - Workflow runs were being cancelled (superseded by new commits)
+  - Only one version published instead of multiple
+
+  **Solution:**
+  1. Check branch CI health before starting the queue
+  2. Wait for post-merge CI after each successful merge
+  3. Stop queue on CI failure (configurable)
+
+  **New configuration options:**
+  - `HIVE_MIND_MERGE_QUEUE_WAIT_FOR_POST_MERGE_CI` (default: true)
+  - `HIVE_MIND_MERGE_QUEUE_STOP_ON_CI_FAILURE` (default: true)
+  - `HIVE_MIND_MERGE_QUEUE_CHECK_BRANCH_HEALTH` (default: true)
+  - `HIVE_MIND_MERGE_QUEUE_POST_MERGE_CI_TIMEOUT_MS` (default: 60 minutes)
+  - `HIVE_MIND_MERGE_QUEUE_POST_MERGE_CI_POLL_INTERVAL_MS` (default: 30 seconds)
+
+  **New API functions:**
+  - `waitForCommitCI()` - Wait for workflow runs on a commit
+  - `checkBranchCIHealth()` - Check for failed CI on a branch
+  - `getMergeCommitSha()` - Get merge commit SHA for a PR
+
+## 1.24.6
+
+### Patch Changes
+
+- Make `--auto-resume-on-limit-reset` enabled by default to improve user experience when hitting API rate limits. Previously defaulted to `false`, now defaults to `true` for both `solve` and `hive` commands. Users can explicitly disable with `--no-auto-resume-on-limit-reset` if needed.
+
+  Fix false positive error detection for step_finish with reason stop
+
+  When an agent encounters a timeout error during execution but successfully recovers and completes (indicated by `step_finish` with `reason: "stop"`), the error detection was incorrectly flagging this as a failure due to fallback pattern matching.
+
+  The `agentCompletedSuccessfully` flag was only being set for `session.idle` and `"exiting loop"` log messages (Issue #1276), but not for the more common `step_finish` event with `reason: "stop"`. This meant the fallback pattern matching would still trigger and detect error patterns in the full output, even when the agent had clearly completed successfully.
+
+  Fix: Add `step_finish` with `reason: "stop"` as a success marker in both stdout and stderr processing loops in `src/agent.lib.mjs`.
+
 ## 1.24.5
 
 ### Patch Changes

package/README.md

@@ -268,12 +268,10 @@ See [docs/HELM.md](./docs/HELM.md) for detailed Helm configuration options.
        --attach-logs
        --verbose
        --no-tool-check
-       --auto-resume-on-limit-reset
      TELEGRAM_SOLVE_OVERRIDES:
        --attach-logs
        --verbose
        --no-tool-check
-       --auto-resume-on-limit-reset
      TELEGRAM_BOT_VERBOSE: true
    "
 
@@ -295,12 +293,10 @@ See [docs/HELM.md](./docs/HELM.md) for detailed Helm configuration options.
      --attach-logs
      --verbose
      --no-tool-check
-     --auto-resume-on-limit-reset
    )" --solve-overrides "(
      --attach-logs
      --verbose
      --no-tool-check
-     --auto-resume-on-limit-reset
    )" --verbose
 
    # Press CTRL + A + D for detach from screen

package/package.json

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

package/src/agent.lib.mjs

@@ -665,6 +665,13 @@ export const executeAgentCommand = async params => {
               if (data.type === 'session.idle' || (data.type === 'log' && data.message === 'exiting loop')) {
                 agentCompletedSuccessfully = true;
               }
+              // Issue #1296: Detect step_finish with reason "stop" as successful completion
+              // This is a clear marker of success - agent finished normally, not due to error or limit
+              // When this event appears, we should ignore any error events that appeared earlier in the stream
+              // (e.g., timeout errors that were recovered from via retry logic)
+              if (data.type === 'step_finish' && data.part?.reason === 'stop') {
+                agentCompletedSuccessfully = true;
+              }
             } catch {
               // Not JSON - log as plain text
               await log(line);
@@ -727,6 +734,11 @@ export const executeAgentCommand = async params => {
                 if (stderrData.type === 'session.idle' || (stderrData.type === 'log' && stderrData.message === 'exiting loop')) {
                   agentCompletedSuccessfully = true;
                 }
+                // Issue #1296: Detect step_finish with reason "stop" as successful completion (stderr)
+                // This is a clear marker of success - agent finished normally, not due to error or limit
+                if (stderrData.type === 'step_finish' && stderrData.part?.reason === 'stop') {
+                  agentCompletedSuccessfully = true;
+                }
               } catch {
                 // Not JSON - log as plain text
                 await log(stderrLine);

package/src/config.lib.mjs

@@ -443,6 +443,31 @@ export const mergeQueue = {
   // 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),
+  // Issue #1341: Wait for post-merge CI to complete before merging next PR
+  // When enabled, the merge queue will wait for all CI runs triggered by a merge
+  // to complete before processing the next PR. This ensures each merge gets its own
+  // release/publish cycle.
+  // Default: true - ensures post-merge CI (including release workflows) completes
+  waitForPostMergeCI: getenv('HIVE_MIND_MERGE_QUEUE_WAIT_FOR_POST_MERGE_CI', 'true').toLowerCase() === 'true',
+  // Issue #1341: Stop the queue if post-merge CI fails
+  // When enabled, the merge queue will stop processing if any post-merge CI run fails
+  // This prevents cascading failures and allows humans to investigate
+  // Default: true - stop on failure to prevent problems from multiplying
+  stopOnPostMergeCIFailure: getenv('HIVE_MIND_MERGE_QUEUE_STOP_ON_CI_FAILURE', 'true').toLowerCase() === 'true',
+  // Issue #1341: Check for existing CI failures before starting the queue
+  // When enabled, the merge queue will check if there are any failed CI runs on
+  // the default branch before starting to process PRs. If failures exist, it will
+  // report them and stop.
+  // Default: true - ensure a healthy branch before merging
+  checkBranchCIHealthBeforeStart: getenv('HIVE_MIND_MERGE_QUEUE_CHECK_BRANCH_HEALTH', 'true').toLowerCase() === 'true',
+  // Issue #1341: Timeout for waiting on post-merge CI (in milliseconds)
+  // This is per-merge, not total. If a single merge's CI doesn't complete within
+  // this time, the queue will fail with a timeout error.
+  // Default: 60 minutes (3600000ms) - typical CI/CD pipelines take 15-45 minutes
+  postMergeCITimeoutMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_POST_MERGE_CI_TIMEOUT_MS', 60 * 60 * 1000),
+  // Issue #1341: Polling interval for post-merge CI status (in milliseconds)
+  // Default: 30 seconds (30000ms) - balance between responsiveness and API rate limits
+  postMergeCIPollIntervalMs: parseIntWithDefault('HIVE_MIND_MERGE_QUEUE_POST_MERGE_CI_POLL_INTERVAL_MS', 30 * 1000),
 };
 
 // Helper function to validate configuration values

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

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/**
+ * GitHub Merge Queue CI Monitoring Library
+ *
+ * Provides utilities for monitoring CI/CD status on commits and branches.
+ * Split from github-merge.lib.mjs to maintain file size limits.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1341
+ */
+
+import { getWorkflowRunsForSha } from './github-merge.lib.mjs';
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+/**
+ * Wait for all workflow runs triggered by a specific commit to complete
+ * Issue #1341: Used to wait for post-merge CI before processing the next PR
+ *
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {string} sha - Commit SHA to monitor
+ * @param {Object} options - Wait options
+ * @param {number} options.timeout - Maximum wait time in ms (default: 60 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, status: string, runs: Array, failedRuns: Array, error: string|null}>}
+ */
+export async function waitForCommitCI(owner, repo, sha, options = {}, verbose = false) {
+  const { timeout = 60 * 60 * 1000, pollInterval = 30 * 1000, onStatusUpdate = null } = options;
+
+  const startTime = Date.now();
+  let noRunsIterations = 0;
+  const MAX_NO_RUNS_ITERATIONS = 10; // Wait up to ~5 minutes for runs to appear
+
+  if (verbose) {
+    console.log(`[VERBOSE] /merge: Waiting for CI runs on commit ${sha.substring(0, 7)} to complete...`);
+  }
+
+  while (Date.now() - startTime < timeout) {
+    let runs;
+    try {
+      runs = await getWorkflowRunsForSha(owner, repo, sha, verbose);
+    } catch (error) {
+      console.error(`[ERROR] /merge: Error checking commit CI: ${error.message}`);
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      continue;
+    }
+
+    // Handle case where no runs exist yet (CI hasn't started)
+    if (runs.length === 0) {
+      noRunsIterations++;
+      if (noRunsIterations >= MAX_NO_RUNS_ITERATIONS) {
+        // No CI runs after waiting - assume no CI is configured or it's optional
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: No CI runs found for commit ${sha.substring(0, 7)} after ${MAX_NO_RUNS_ITERATIONS} checks. Proceeding.`);
+        }
+        return { success: true, status: 'no_runs', runs: [], failedRuns: [], error: null };
+      }
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: No CI runs yet for commit ${sha.substring(0, 7)} (attempt ${noRunsIterations}/${MAX_NO_RUNS_ITERATIONS}). Waiting...`);
+      }
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      continue;
+    }
+
+    // Reset counter when runs appear
+    noRunsIterations = 0;
+
+    // Check run statuses
+    const completedRuns = runs.filter(r => r.status === 'completed');
+    const inProgressRuns = runs.filter(r => r.status === 'in_progress' || r.status === 'queued' || r.status === 'waiting' || r.status === 'requested' || r.status === 'pending');
+    const failedRuns = completedRuns.filter(r => r.conclusion === 'failure' || r.conclusion === 'timed_out' || r.conclusion === 'cancelled');
+    const successRuns = completedRuns.filter(r => r.conclusion === 'success' || r.conclusion === 'skipped' || r.conclusion === 'neutral');
+
+    // Report status
+    if (onStatusUpdate) {
+      try {
+        await onStatusUpdate({
+          sha,
+          totalRuns: runs.length,
+          completedRuns: completedRuns.length,
+          inProgressRuns: inProgressRuns.length,
+          failedRuns: failedRuns.length,
+          successRuns: successRuns.length,
+          runs,
+          elapsedMs: Date.now() - startTime,
+        });
+      } catch (callbackError) {
+        console.error(`[ERROR] /merge: Status update callback failed: ${callbackError.message}`);
+      }
+    }
+
+    // All runs completed
+    if (inProgressRuns.length === 0) {
+      // Check for failures
+      if (failedRuns.length > 0) {
+        if (verbose) {
+          console.log(`[VERBOSE] /merge: CI completed with ${failedRuns.length} failure(s) for commit ${sha.substring(0, 7)}`);
+          for (const run of failedRuns) {
+            console.log(`[VERBOSE] /merge:   - FAILED: ${run.name} (${run.conclusion}): ${run.html_url}`);
+          }
+        }
+        return {
+          success: false,
+          status: 'failure',
+          runs,
+          failedRuns,
+          error: `${failedRuns.length} CI run(s) failed: ${failedRuns.map(r => r.name).join(', ')}`,
+        };
+      }
+
+      // All passed
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: All ${completedRuns.length} CI runs passed for commit ${sha.substring(0, 7)}`);
+      }
+      return { success: true, status: 'success', runs, failedRuns: [], error: null };
+    }
+
+    // Still waiting
+    if (verbose) {
+      const elapsedSec = Math.round((Date.now() - startTime) / 1000);
+      console.log(`[VERBOSE] /merge: Waiting for ${inProgressRuns.length} CI run(s) to complete... (${elapsedSec}s elapsed)`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+
+  // Timeout reached
+  return {
+    success: false,
+    status: 'timeout',
+    runs: await getWorkflowRunsForSha(owner, repo, sha, verbose),
+    failedRuns: [],
+    error: `Timeout waiting for CI runs on commit ${sha.substring(0, 7)}`,
+  };
+}
+
+/**
+ * Check if the default branch has any recent failed CI runs
+ * Issue #1341: Used to detect pre-existing failures before starting the merge queue
+ *
+ * @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 {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{healthy: boolean, failedRuns: Array, error: string|null}>}
+ */
+export async function checkBranchCIHealth(owner, repo, branch = 'main', options = {}, verbose = false) {
+  const { lookbackCount = 5 } = options;
+
+  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}]'`);
+    const runs = JSON.parse(stdout.trim() || '[]');
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Checking ${runs.length} recent CI runs on ${owner}/${repo} branch ${branch}`);
+    }
+
+    if (runs.length === 0) {
+      // No recent runs - assume healthy
+      return { healthy: true, failedRuns: [], 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');
+
+    if (failedRuns.length > 0) {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: Found ${failedRuns.length} failed CI run(s) on ${branch}:`);
+        for (const run of failedRuns) {
+          console.log(`[VERBOSE] /merge:   - ${run.name}: ${run.conclusion} (${run.html_url})`);
+        }
+      }
+      return {
+        healthy: false,
+        failedRuns,
+        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)`);
+    }
+
+    return { healthy: true, failedRuns: [], 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 };
+  }
+}
+
+/**
+ * Get the merge commit SHA for a merged pull request
+ * Issue #1341: Used to track the commit that triggers post-merge CI
+ *
+ * @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<{sha: string|null, error: string|null}>}
+ */
+export async function getMergeCommitSha(owner, repo, prNumber, verbose = false) {
+  try {
+    const { stdout } = await exec(`gh pr view ${prNumber} --repo ${owner}/${repo} --json mergeCommit --jq '.mergeCommit.oid'`);
+    const sha = stdout.trim();
+
+    if (!sha || sha === 'null') {
+      if (verbose) {
+        console.log(`[VERBOSE] /merge: PR #${prNumber} has no merge commit (may not be merged yet)`);
+      }
+      return { sha: null, error: 'PR is not merged or merge commit not available' };
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: PR #${prNumber} merge commit: ${sha.substring(0, 7)}`);
+    }
+
+    return { sha, error: null };
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] /merge: Error getting merge commit for PR #${prNumber}: ${error.message}`);
+    }
+    return { sha: null, error: error.message };
+  }
+}
+
+export default {
+  waitForCommitCI,
+  checkBranchCIHealth,
+  getMergeCommitSha,
+};

package/src/github-merge.lib.mjs

@@ -1204,11 +1204,11 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
  * @param {string} repo - Repository name
  * @param {string} sha - Commit SHA
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<Array<{id: number, status: string, conclusion: string|null, name: string}>>}
+ * @returns {Promise<Array<{id: number, status: string, conclusion: string|null, name: string, html_url: string}>>}
  */
 export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
   try {
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=20" --jq '[.workflow_runs[] | {id: .id, status: .status, conclusion: .conclusion, name: .name}]'`);
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?head_sha=${sha}&per_page=20" --jq '[.workflow_runs[] | {id: .id, status: .status, conclusion: .conclusion, name: .name, html_url: .html_url}]'`);
     const runs = JSON.parse(stdout.trim() || '[]');
 
     if (verbose) {
@@ -1227,6 +1227,11 @@ export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
   }
 }
 
+// Issue #1341: Import and re-export post-merge CI functions from separate module
+// to keep this file under the 1500 line limit
+import { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge-ci.lib.mjs';
+export { waitForCommitCI, checkBranchCIHealth, getMergeCommitSha };
+
 export default {
   READY_LABEL,
   checkReadyLabelExists,
@@ -1256,4 +1261,8 @@ export default {
   rerunWorkflowRun,
   rerunFailedJobs,
   getWorkflowRunsForSha,
+  // Issue #1341: Post-merge CI waiting and branch health checking
+  waitForCommitCI,
+  checkBranchCIHealth,
+  getMergeCommitSha,
 };

package/src/hive.config.lib.mjs

@@ -36,7 +36,7 @@ const HIVE_CUSTOM_SOLVE_OPTIONS = {
   'auto-resume-on-limit-reset': {
     type: 'boolean',
     description: 'Automatically resume when AI tool limit resets (calculates reset time and waits). Passed to solve command.',
-    default: false,
+    default: true,
   },
   'auto-cleanup': {
     type: 'boolean',

package/src/solve.config.lib.mjs

@@ -132,7 +132,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   'auto-resume-on-limit-reset': {
     type: 'boolean',
     description: 'Automatically resume when AI tool limit resets (maintains session context with --resume flag)',
-    default: false,
+    default: true,
   },
   'auto-restart-on-limit-reset': {
     type: 'boolean',

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, waitForBranchCI, getDefaultBranch } from './github-merge.lib.mjs';
+import { getAllReadyPRs, checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI, ensureReadyLabel, waitForBranchCI, getDefaultBranch, waitForCommitCI, checkBranchCIHealth, getMergeCommitSha } from './github-merge.lib.mjs';
 import { mergeQueue as mergeQueueConfig } from './config.lib.mjs';
 import { getProgressBar } from './limits.lib.mjs';
 
@@ -79,6 +79,13 @@ export const MERGE_QUEUE_CONFIG = {
   WAIT_FOR_TARGET_BRANCH_CI: mergeQueueConfig.waitForTargetBranchCI,
   TARGET_BRANCH_CI_TIMEOUT_MS: mergeQueueConfig.targetBranchCITimeoutMs,
   TARGET_BRANCH_CI_POLL_INTERVAL_MS: mergeQueueConfig.targetBranchCIPollIntervalMs,
+
+  // Issue #1341: Wait for post-merge CI to complete before merging next PR
+  WAIT_FOR_POST_MERGE_CI: mergeQueueConfig.waitForPostMergeCI,
+  STOP_ON_POST_MERGE_CI_FAILURE: mergeQueueConfig.stopOnPostMergeCIFailure,
+  CHECK_BRANCH_CI_HEALTH_BEFORE_START: mergeQueueConfig.checkBranchCIHealthBeforeStart,
+  POST_MERGE_CI_TIMEOUT_MS: mergeQueueConfig.postMergeCITimeoutMs,
+  POST_MERGE_CI_POLL_INTERVAL_MS: mergeQueueConfig.postMergeCIPollIntervalMs,
 };
 
 /**
@@ -94,6 +101,8 @@ class MergeQueueItem {
     this.ciStatus = null;
     this.startedAt = null;
     this.completedAt = null;
+    // Issue #1341: Track merge commit SHA for post-merge CI waiting
+    this.mergeCommitSha = null;
   }
 
   /**
@@ -234,6 +243,29 @@ export class MergeQueueProcessor {
     this.isCancelled = false;
 
     try {
+      // Issue #1341: Check if the default branch has any failed CI runs before starting
+      // This prevents merging on top of a broken branch
+      if (MERGE_QUEUE_CONFIG.CHECK_BRANCH_CI_HEALTH_BEFORE_START) {
+        const healthCheckResult = await this.checkBranchCIHealthBeforeStart();
+        if (!healthCheckResult.healthy) {
+          this.status = MergeStatus.FAILED;
+          this.error = healthCheckResult.error;
+          this.completedAt = new Date();
+          // Store the failed runs for the error report
+          this.branchCIFailedRuns = healthCheckResult.failedRuns;
+
+          if (this.onError) {
+            await this.onError(new Error(healthCheckResult.error));
+          }
+
+          return {
+            success: false,
+            stats: this.stats,
+            error: healthCheckResult.error,
+          };
+        }
+      }
+
       // 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) {
@@ -255,10 +287,35 @@ export class MergeQueueProcessor {
           await this.onProgress(this.getProgressUpdate());
         }
 
-        // If merged, wait before processing next PR to allow CI to stabilize
+        // Issue #1341: If merged successfully, wait for post-merge CI to complete
+        // This ensures each PR's CI completes (including releases) before merging the next
         if (item.status === MergeItemStatus.MERGED && this.currentIndex < this.items.length - 1) {
-          this.log(`Waiting ${MERGE_QUEUE_CONFIG.POST_MERGE_WAIT_MS / 1000}s before next PR...`);
-          await this.sleep(MERGE_QUEUE_CONFIG.POST_MERGE_WAIT_MS);
+          if (MERGE_QUEUE_CONFIG.WAIT_FOR_POST_MERGE_CI && item.mergeCommitSha) {
+            const postMergeCIResult = await this.waitForPostMergeCI(item);
+
+            // Issue #1341: Stop the queue if post-merge CI failed
+            if (!postMergeCIResult.success && MERGE_QUEUE_CONFIG.STOP_ON_POST_MERGE_CI_FAILURE) {
+              this.status = MergeStatus.FAILED;
+              this.error = postMergeCIResult.error;
+              this.completedAt = new Date();
+              // Store the failed runs for the error report
+              this.postMergeCIFailedRuns = postMergeCIResult.failedRuns;
+
+              if (this.onError) {
+                await this.onError(new Error(postMergeCIResult.error));
+              }
+
+              return {
+                success: false,
+                stats: this.stats,
+                error: postMergeCIResult.error,
+              };
+            }
+          } else {
+            // Fallback: short wait before processing next PR
+            this.log(`Waiting ${MERGE_QUEUE_CONFIG.POST_MERGE_WAIT_MS / 1000}s before next PR...`);
+            await this.sleep(MERGE_QUEUE_CONFIG.POST_MERGE_WAIT_MS);
+          }
         }
       }
 
@@ -372,6 +429,17 @@ export class MergeQueueProcessor {
       item.completedAt = new Date();
       this.stats.merged++;
       this.log(`Successfully merged PR #${item.pr.number}`);
+
+      // Issue #1341: Get the merge commit SHA for post-merge CI tracking
+      // Need a small delay to allow GitHub to update the PR state
+      await this.sleep(5000);
+      const mergeCommitResult = await getMergeCommitSha(this.owner, this.repo, item.pr.number, this.verbose);
+      if (mergeCommitResult.sha) {
+        item.mergeCommitSha = mergeCommitResult.sha;
+        this.log(`PR #${item.pr.number} merge commit: ${mergeCommitResult.sha.substring(0, 7)}`);
+      } else {
+        this.log(`Could not get merge commit SHA for PR #${item.pr.number}: ${mergeCommitResult.error}`);
+      }
     } catch (error) {
       item.status = MergeItemStatus.FAILED;
       item.error = error.message;
@@ -442,6 +510,105 @@ export class MergeQueueProcessor {
     }
   }
 
+  /**
+   * Check if the default branch has any failed CI runs before starting the queue
+   * Issue #1341: Prevents merging on top of a broken branch
+   * @returns {Promise<{healthy: boolean, failedRuns: Array, error: string|null}>}
+   */
+  async checkBranchCIHealthBeforeStart() {
+    try {
+      const targetBranch = await getDefaultBranch(this.owner, this.repo, this.verbose);
+      this.log(`Checking CI health on ${targetBranch} branch before starting queue...`);
+
+      const healthResult = await checkBranchCIHealth(this.owner, this.repo, targetBranch, {}, this.verbose);
+
+      if (!healthResult.healthy) {
+        this.log(`Branch ${targetBranch} has ${healthResult.failedRuns.length} failed CI run(s)`);
+        return {
+          healthy: false,
+          failedRuns: healthResult.failedRuns,
+          error: `Cannot start merge queue: ${healthResult.error}. Please fix the CI failures first.`,
+        };
+      }
+
+      this.log(`Branch ${targetBranch} CI is healthy. Ready to proceed.`);
+      return {
+        healthy: true,
+        failedRuns: [],
+        error: null,
+      };
+    } catch (error) {
+      // On error, assume healthy to avoid blocking merges due to API issues
+      console.warn(`[WARN] /merge-queue: Error checking branch CI health: ${error.message}. Proceeding anyway.`);
+      return {
+        healthy: true,
+        failedRuns: [],
+        error: null,
+      };
+    }
+  }
+
+  /**
+   * Wait for post-merge CI to complete for a merged PR
+   * Issue #1341: Ensures each PR's CI completes (including releases) before merging the next
+   * @param {MergeQueueItem} item - The merged PR item
+   * @returns {Promise<{success: boolean, failedRuns: Array, error: string|null}>}
+   */
+  async waitForPostMergeCI(item) {
+    if (!item.mergeCommitSha) {
+      this.log(`No merge commit SHA available for PR #${item.pr.number}, skipping post-merge CI wait`);
+      return { success: true, failedRuns: [], error: null };
+    }
+
+    // Track that we're waiting for post-merge CI (for progress updates)
+    this.waitingForPostMergeCI = true;
+    this.postMergeCIStatus = null;
+    this.currentPostMergePR = item.pr.number;
+
+    try {
+      this.log(`Waiting for post-merge CI on commit ${item.mergeCommitSha.substring(0, 7)} (PR #${item.pr.number})...`);
+
+      const waitResult = await waitForCommitCI(
+        this.owner,
+        this.repo,
+        item.mergeCommitSha,
+        {
+          timeout: MERGE_QUEUE_CONFIG.POST_MERGE_CI_TIMEOUT_MS,
+          pollInterval: MERGE_QUEUE_CONFIG.POST_MERGE_CI_POLL_INTERVAL_MS,
+          onStatusUpdate: async status => {
+            this.postMergeCIStatus = status;
+
+            // Report progress while waiting
+            if (this.onProgress) {
+              await this.onProgress(this.getProgressUpdate());
+            }
+          },
+        },
+        this.verbose
+      );
+
+      if (waitResult.success) {
+        if (waitResult.status === 'no_runs') {
+          this.log(`No CI runs found for merge commit ${item.mergeCommitSha.substring(0, 7)}. Proceeding.`);
+        } else {
+          this.log(`Post-merge CI completed successfully for PR #${item.pr.number}`);
+        }
+        return { success: true, failedRuns: [], error: null };
+      } else {
+        this.log(`Post-merge CI failed for PR #${item.pr.number}: ${waitResult.error}`);
+        return {
+          success: false,
+          failedRuns: waitResult.failedRuns || [],
+          error: waitResult.error,
+        };
+      }
+    } finally {
+      this.waitingForPostMergeCI = false;
+      this.postMergeCIStatus = null;
+      this.currentPostMergePR = null;
+    }
+  }
+
   /**
    * Get current progress update
    */
@@ -525,8 +692,21 @@ export class MergeQueueProcessor {
       message += `⏱️ Checking for active CI runs on target branch\\.\\.\\.\n\n`;
     }
 
+    // Issue #1341: Show waiting status for post-merge CI
+    if (this.waitingForPostMergeCI && this.postMergeCIStatus) {
+      const elapsedSec = Math.round(this.postMergeCIStatus.elapsedMs / 1000);
+      const elapsedMin = Math.floor(elapsedSec / 60);
+      const elapsedSecRemainder = elapsedSec % 60;
+      const completed = this.postMergeCIStatus.completedRuns || 0;
+      const total = this.postMergeCIStatus.totalRuns || 0;
+      const inProgress = total - completed;
+      message += `⏱️ Waiting for post\\-merge CI \\(PR \\#${this.currentPostMergePR}\\): ${inProgress} in progress, ${completed}/${total} completed \\(${elapsedMin}m ${elapsedSecRemainder}s\\)\\.\\.\\.\n\n`;
+    } else if (this.waitingForPostMergeCI) {
+      message += `⏱️ Waiting for post\\-merge CI \\(PR \\#${this.currentPostMergePR}\\)\\.\\.\\.\n\n`;
+    }
+
     // Current item being processed
-    if (update.current && !this.waitingForTargetBranchCI) {
+    if (update.current && !this.waitingForTargetBranchCI && !this.waitingForPostMergeCI) {
       const statusEmoji = update.currentStatus === MergeItemStatus.WAITING_CI ? '⏱️' : '🔄';
       // Issue #1339: escape the current item description for MarkdownV2
       message += `${statusEmoji} ${this.escapeMarkdown(update.current)}\n\n`;
@@ -609,6 +789,36 @@ export class MergeQueueProcessor {
     message += `⏭️ Skipped: ${report.stats.skipped}  `;
     message += `📋 Total: ${report.stats.total}\n\n`;
 
+    // Issue #1341: Show branch CI health failure details if applicable
+    if (this.branchCIFailedRuns && this.branchCIFailedRuns.length > 0) {
+      message += `⚠️ *Branch CI Failures \\(blocked queue\\):*\n`;
+      for (const run of this.branchCIFailedRuns.slice(0, 3)) {
+        const runName = this.escapeMarkdown(run.name);
+        // Format the URL for MarkdownV2 - need to escape special characters
+        const runUrl = run.html_url ? `[View](${run.html_url.replace(/[)]/g, '\\)')})` : '';
+        message += `  ❌ ${runName} ${runUrl}\n`;
+      }
+      if (this.branchCIFailedRuns.length > 3) {
+        message += `  _\\.\\.\\.and ${this.branchCIFailedRuns.length - 3} more_\n`;
+      }
+      message += '\n';
+    }
+
+    // Issue #1341: Show post-merge CI failure details if applicable
+    if (this.postMergeCIFailedRuns && this.postMergeCIFailedRuns.length > 0) {
+      message += `⚠️ *Post\\-Merge CI Failures \\(stopped queue\\):*\n`;
+      for (const run of this.postMergeCIFailedRuns.slice(0, 3)) {
+        const runName = this.escapeMarkdown(run.name);
+        // Format the URL for MarkdownV2 - need to escape special characters
+        const runUrl = run.html_url ? `[View](${run.html_url.replace(/[)]/g, '\\)')})` : '';
+        message += `  ❌ ${runName} ${runUrl}\n`;
+      }
+      if (this.postMergeCIFailedRuns.length > 3) {
+        message += `  _\\.\\.\\.and ${this.postMergeCIFailedRuns.length - 3} more_\n`;
+      }
+      message += '\n';
+    }
+
     // Details
     if (report.items.length > 0) {
       message += `*Results:*\n`;