@link-assistant/hive-mind 1.38.1 → 1.38.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @link-assistant/hive-mind
 
+## 1.38.3
+
+### Patch Changes
+
+- deb31bf: fix: add multi-mechanism CI consensus, repo-wide action monitoring, and 5-min minimum CI check interval to prevent false positive "Ready to merge"
+
+## 1.38.2
+
+### Patch Changes
+
+- 290139f: fix: correct cost and token/context budget calculations (#1501)
+  - Deduplicate JSONL session entries by message ID to fix inflated token counts caused by upstream anthropics/claude-code#6805
+  - Show peak context window usage (max single-request fill) instead of cumulative sum which produced nonsensical percentages like 7516%
+  - Add "Total tokens processed" as a separate cumulative metric for session throughput visibility
+  - Add verbose logging for JSONL deduplication stats and peak context values
+
 ## 1.38.1
 
 ### Patch Changes

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -14,6 +14,8 @@ export const createEmptySubSessionUsage = () => ({
   cacheReadTokens: 0,
   outputTokens: 0,
   messageCount: 0,
+  peakContextUsage: 0,
+  peakOutputUsage: 0,
 });
 
 /**
@@ -136,173 +138,161 @@ export const displayCostComparison = async (publicCost, anthropicCost, log) => {
 /**
  * Display token budget statistics (context window usage and ratios)
  * @param {Object} usage - Usage data for a model
+ * @param {Object} tokenUsage - Full token usage data (with subSessions)
  * @param {Function} log - Logging function
  */
-export const displayBudgetStats = async (usage, log) => {
+export const displayBudgetStats = async (usage, tokenUsage, log) => {
   const modelInfo = usage.modelInfo;
   if (!modelInfo?.limit) {
     await log('\n      ⚠️  Budget stats not available (no model limits found)');
     return;
   }
 
-  await log('\n      📊 Token Budget Statistics:');
+  await log('\n      📊 Context and tokens usage:');
 
-  // Context window usage
-  if (modelInfo.limit.context) {
-    const contextLimit = modelInfo.limit.context;
-    // Input tokens include regular input + cache creation + cache read
-    const totalInputUsed = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
-    const contextUsageRatio = totalInputUsed / contextLimit;
-    const contextUsagePercent = (contextUsageRatio * 100).toFixed(2);
+  const contextLimit = modelInfo.limit.context;
+  const outputLimit = modelInfo.limit.output;
+  const subSessions = tokenUsage?.subSessions || [];
+  const hasMultipleSubSessions = subSessions.length > 1;
 
-    await log('        Context window:');
-    await log(`          Used: ${formatNumber(totalInputUsed)} tokens`);
-    await log(`          Limit: ${formatNumber(contextLimit)} tokens`);
-    await log(`          Ratio: ${contextUsageRatio.toFixed(4)} (${contextUsagePercent}%)`);
-  }
-
-  // Output tokens usage
-  if (modelInfo.limit.output) {
-    const outputLimit = modelInfo.limit.output;
-    const outputUsageRatio = usage.outputTokens / outputLimit;
-    const outputUsagePercent = (outputUsageRatio * 100).toFixed(2);
-
-    await log('        Output tokens:');
-    await log(`          Used: ${formatNumber(usage.outputTokens)} tokens`);
-    await log(`          Limit: ${formatNumber(outputLimit)} tokens`);
-    await log(`          Ratio: ${outputUsageRatio.toFixed(4)} (${outputUsagePercent}%)`);
-  }
-
-  // Total session tokens (input + cache_creation + output)
-  const totalSessionTokens = usage.inputTokens + usage.cacheCreationTokens + usage.outputTokens;
-  await log(`        Total session tokens: ${formatNumber(totalSessionTokens)}`);
-};
-
-/**
- * Display sub-session breakdown when compactification events occurred (Issue #1491)
- * @param {Object} tokenUsage - Token usage data with subSessions and compactifications
- * @param {Object} modelInfo - Model info with context/output limits
- * @param {Function} log - Logging function
- */
-export const displaySubSessionStats = async (tokenUsage, modelInfo, log) => {
-  if (!tokenUsage.subSessions || !tokenUsage.compactifications) return;
-
-  const contextLimit = modelInfo?.limit?.context;
-  await log(`\n      🔄 Compactification events: ${tokenUsage.compactifications.length}`);
-
-  for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-    const sub = tokenUsage.subSessions[i];
-    const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-    const label = i === 0 ? 'Initial session' : `After compactification #${i}`;
-
-    await log(`        Sub-session ${i + 1} (${label}):`);
-    await log(`          Messages: ${sub.messageCount}`);
-    await log(`          Context used: ${formatNumber(totalInput)} tokens`);
+  if (hasMultipleSubSessions) {
+    await log('        Sub sessions (between compact events):');
+    for (let i = 0; i < subSessions.length; i++) {
+      const sub = subSessions[i];
+      const subPeak = sub.peakContextUsage || 0;
+      let line = `          ${i + 1}. `;
+      if (contextLimit && subPeak > 0) {
+        const pct = ((subPeak / contextLimit) * 100).toFixed(0);
+        line += `${formatNumber(subPeak)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`;
+      } else {
+        const subTotal = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
+        line += `${formatNumber(subTotal)} input tokens`;
+      }
+      if (outputLimit) {
+        const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
+        line += `; ${formatNumber(sub.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`;
+      } else {
+        line += `; ${formatNumber(sub.outputTokens)} output tokens`;
+      }
+      await log(line);
+    }
+  } else {
+    // Single sub-session: simplified format
+    const peakContext = usage.peakContextUsage || 0;
     if (contextLimit) {
-      const pct = ((totalInput / contextLimit) * 100).toFixed(2);
-      await log(`          Context usage: ${pct}% of ${formatNumber(contextLimit)}`);
+      if (peakContext > 0) {
+        const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+        await log(`        Max context window: ${formatNumber(peakContext)} / ${formatNumber(contextLimit)} input tokens (${pct}%)`);
+      }
+    }
+    if (outputLimit) {
+      const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+      await log(`        Max output tokens: ${formatNumber(usage.outputTokens)} / ${formatNumber(outputLimit)} output tokens (${outPct}%)`);
     }
-    await log(`          Output: ${formatNumber(sub.outputTokens)} tokens`);
   }
 
-  // Show compactification details
-  for (let i = 0; i < tokenUsage.compactifications.length; i++) {
-    const comp = tokenUsage.compactifications[i];
-    let detail = `        Compactification #${i + 1}: trigger=${comp.trigger}`;
-    if (comp.preTokens) detail += `, pre-compaction tokens=${formatNumber(comp.preTokens)}`;
-    await log(detail);
-  }
+  // Cumulative totals
+  const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
+  const cachedTokens = usage.cacheReadTokens;
+  let totalLine = `        Total input tokens: ${formatNumber(totalInputNonCached)}`;
+  if (cachedTokens > 0) totalLine += ` + ${formatNumber(cachedTokens)} cached`;
+  await log(totalLine);
+  await log(`        Total output tokens: ${formatNumber(usage.outputTokens)}`);
 };
 
 /**
- * Display stream vs JSONL token comparison (Issue #1491)
- * Shows independent calculation from stream events vs JSONL session file
- * @param {Object} streamTokenUsage - Token usage accumulated from stream JSON events
- * @param {Object} jsonlTokenUsage - Token usage calculated from JSONL session file
- * @param {Function} log - Logging function
+ * Format a token count with K/M suffix for compact display
+ * @param {number} tokens - Token count
+ * @returns {string} Formatted string like "850K" or "1.5M"
  */
-export const displayTokenComparison = async (streamTokenUsage, jsonlTokenUsage, log) => {
-  if (!streamTokenUsage || !jsonlTokenUsage) return;
-
-  const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-  const jsonlTotal = jsonlTokenUsage.inputTokens + jsonlTokenUsage.cacheCreationTokens + jsonlTokenUsage.outputTokens;
-
-  await log('\n      🔍 Token calculation comparison:');
-  await log(`        Stream JSON events: ${formatNumber(streamTotal)} tokens (${streamTokenUsage.eventCount} events)`);
-  await log(`        JSONL session file: ${formatNumber(jsonlTotal)} tokens`);
-
-  if (streamTotal !== jsonlTotal) {
-    const diff = jsonlTotal - streamTotal;
-    const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-    await log(`        Difference: ${formatNumber(Math.abs(diff))} tokens (${diff > 0 ? '+' : ''}${pct}%)`);
-  } else {
-    await log('        Match: calculations are consistent');
-  }
+const formatTokensCompact = tokens => {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(tokens % 1000000 === 0 ? 0 : 1)}M`;
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(tokens % 1000 === 0 ? 0 : 1)}K`;
+  return tokens.toLocaleString();
 };
 
 /**
- * Build budget stats string for GitHub PR comments (Issue #1491)
- * Similar to buildCostInfoString but for token budget statistics
+ * Build budget stats string for GitHub PR comments (Issue #1491, #1501)
+ * Format requested by user: sub-sessions between compactification events,
+ * per-model breakdown, cumulative totals with cached tokens shown separately.
  * @param {Object} tokenUsage - Token usage data from calculateSessionTokens
- * @param {Object|null} streamTokenUsage - Token usage from stream JSON events
+ * @param {Object|null} streamTokenUsage - Token usage from stream JSON events (used for comparison, not displayed)
  * @returns {string} Formatted markdown string for PR comment
  */
-export const buildBudgetStatsString = (tokenUsage, streamTokenUsage) => {
+export const buildBudgetStatsString = tokenUsage => {
   if (!tokenUsage) return '';
 
-  let stats = '\n\n### 📊 **Token budget statistics:**';
+  let stats = '\n\n### 📊 **Context and tokens usage:**';
 
   // Per-model breakdown
   if (tokenUsage.modelUsage) {
     const modelIds = Object.keys(tokenUsage.modelUsage);
+    const isMultiModel = modelIds.length > 1;
+
     for (const modelId of modelIds) {
       const usage = tokenUsage.modelUsage[modelId];
       const modelName = usage.modelName || modelId;
       const contextLimit = usage.modelInfo?.limit?.context;
       const outputLimit = usage.modelInfo?.limit?.output;
-      const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
 
-      if (modelIds.length > 1) stats += `\n- **${modelName}**:`;
+      if (isMultiModel) stats += `\n\n**${modelName}:**`;
 
-      if (contextLimit) {
-        const contextPct = ((totalInput / contextLimit) * 100).toFixed(2);
-        stats += `\n- Context window: ${totalInput.toLocaleString()} / ${contextLimit.toLocaleString()} tokens (${contextPct}%)`;
-      } else {
-        stats += `\n- Context tokens used: ${totalInput.toLocaleString()}`;
-      }
+      // Sub-session display (Issue #1501: show per sub-session stats)
+      const subSessions = tokenUsage.subSessions || [];
+      const hasMultipleSubSessions = subSessions.length > 1;
 
-      if (outputLimit) {
-        const outputPct = ((usage.outputTokens / outputLimit) * 100).toFixed(2);
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()} / ${outputLimit.toLocaleString()} tokens (${outputPct}%)`;
+      if (hasMultipleSubSessions) {
+        // Multiple sub-sessions: show numbered list
+        stats += '\n\nSub sessions (between compact events):';
+        for (let i = 0; i < subSessions.length; i++) {
+          const sub = subSessions[i];
+          const subPeakContext = sub.peakContextUsage || 0;
+          const subTotalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
+          let line = `\n${i + 1}. `;
+          if (contextLimit && subPeakContext > 0) {
+            const pct = ((subPeakContext / contextLimit) * 100).toFixed(0);
+            line += `${formatTokensCompact(subPeakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
+          } else {
+            line += `${formatTokensCompact(subTotalInput)} input tokens`;
+          }
+          if (outputLimit) {
+            const outPct = ((sub.outputTokens / outputLimit) * 100).toFixed(0);
+            line += `; ${formatTokensCompact(sub.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+          } else {
+            line += `; ${formatTokensCompact(sub.outputTokens)} output tokens`;
+          }
+          stats += line;
+        }
       } else {
-        stats += `\n- Output tokens: ${usage.outputTokens.toLocaleString()}`;
+        // Single sub-session (or no sub-sessions): simplified format
+        const peakContext = usage.peakContextUsage || 0;
+        if (contextLimit) {
+          if (peakContext > 0) {
+            const pct = ((peakContext / contextLimit) * 100).toFixed(0);
+            stats += `\n- Max context window: ${formatTokensCompact(peakContext)} / ${formatTokensCompact(contextLimit)} input tokens (${pct}%)`;
+          } else {
+            const totalInput = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+            const pct = ((totalInput / contextLimit) * 100).toFixed(0);
+            stats += `\n- Context window: ${formatTokensCompact(totalInput)} / ${formatTokensCompact(contextLimit)} tokens (${pct}%)`;
+          }
+        }
+        if (outputLimit) {
+          const outPct = ((usage.outputTokens / outputLimit) * 100).toFixed(0);
+          stats += `\n- Max output tokens: ${formatTokensCompact(usage.outputTokens)} / ${formatTokensCompact(outputLimit)} output tokens (${outPct}%)`;
+        }
       }
-    }
-  }
 
-  // Sub-session breakdown if compactification occurred
-  if (tokenUsage.subSessions && tokenUsage.compactifications) {
-    stats += `\n- Compactifications: ${tokenUsage.compactifications.length}`;
-    for (let i = 0; i < tokenUsage.subSessions.length; i++) {
-      const sub = tokenUsage.subSessions[i];
-      const totalInput = sub.inputTokens + sub.cacheCreationTokens + sub.cacheReadTokens;
-      const label = i === 0 ? 'initial' : `after compactification #${i}`;
-      stats += `\n  - Sub-session ${i + 1} (${label}): ${totalInput.toLocaleString()} context, ${sub.outputTokens.toLocaleString()} output, ${sub.messageCount} messages`;
+      // Cumulative totals: input tokens + cached shown separately
+      const totalInputNonCached = usage.inputTokens + usage.cacheCreationTokens;
+      const cachedTokens = usage.cacheReadTokens;
+      stats += `\n\nTotal input tokens: ${formatTokensCompact(totalInputNonCached)}`;
+      if (cachedTokens > 0) stats += ` + ${formatTokensCompact(cachedTokens)} cached`;
+      stats += `\nTotal output tokens: ${formatTokensCompact(usage.outputTokens)} output`;
     }
   }
 
-  // Stream vs JSONL comparison
-  if (streamTokenUsage) {
-    const streamTotal = streamTokenUsage.inputTokens + streamTokenUsage.cacheCreationTokens + streamTokenUsage.outputTokens;
-    const jsonlTotal = tokenUsage.inputTokens + tokenUsage.cacheCreationTokens + tokenUsage.outputTokens;
-    stats += `\n- Own calculation (stream): ${streamTotal.toLocaleString()} tokens (${streamTokenUsage.eventCount} events)`;
-    stats += `\n- JSONL calculation: ${jsonlTotal.toLocaleString()} tokens`;
-    if (streamTotal !== jsonlTotal) {
-      const diff = jsonlTotal - streamTotal;
-      const pct = streamTotal > 0 ? ((diff / streamTotal) * 100).toFixed(2) : 'N/A';
-      stats += ` (diff: ${diff > 0 ? '+' : ''}${pct}%)`;
-    }
-  }
+  // Stream vs JSONL comparison — kept for internal diagnostics only in verbose/debug mode
+  // Not shown to users per feedback (Issue #1501 PR comment)
 
   return stats;
 };

package/src/claude.lib.mjs

@@ -12,7 +12,7 @@ import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToToke
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
-import { displayBudgetStats, displaySubSessionStats, displayTokenComparison, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
+import { displayBudgetStats, createEmptySubSessionUsage, accumulateModelUsage, displayModelUsage, displayCostComparison } from './claude.budget-stats.lib.mjs';
 import { buildClaudeResumeCommand } from './claude.command-builder.lib.mjs';
 import { handleClaudeRuntimeSwitch } from './claude.runtime-switch.lib.mjs'; // see issue #1141
 import { CLAUDE_MODELS as availableModels } from './models/index.mjs'; // Issue #1221
@@ -497,6 +497,15 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
   }
   // Initialize per-model usage tracking
   const modelUsage = {};
+  // Issue #1501: Deduplicate JSONL entries by message ID (upstream: anthropics/claude-code#6805)
+  // Claude Code's stream-json mode splits single API responses with multiple content blocks
+  // into separate JSONL entries, each with the same message ID and identical usage stats.
+  const seenMessageIds = new Set();
+  let duplicateCount = 0;
+  // Issue #1501: Track peak context usage per request (not cumulative)
+  // The context window limit is per-request, so we track the max single-request fill.
+  const peakContextByModel = {};
+  let globalPeakContext = 0;
   // Issue #1491: Track sub-sessions between compactification events
   const subSessions = [];
   let currentSubSession = createEmptySubSessionUsage();
@@ -524,14 +533,39 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
           continue;
         }
         if (entry.message && entry.message.usage && entry.message.model) {
+          // Issue #1501: Skip duplicate JSONL entries (same message ID = same API response)
+          const msgId = entry.message.id;
+          if (msgId) {
+            if (seenMessageIds.has(msgId)) {
+              duplicateCount++;
+              continue; // Skip — already counted this message's usage
+            }
+            seenMessageIds.add(msgId);
+          }
           accumulateModelUsage(modelUsage, entry);
-          // Issue #1491: Also track per-sub-session usage
+          // Issue #1501: Track peak context usage per single API request
           const usage = entry.message.usage;
+          const requestContext = (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+          const model = entry.message.model;
+          if (requestContext > (peakContextByModel[model] || 0)) {
+            peakContextByModel[model] = requestContext;
+          }
+          if (requestContext > globalPeakContext) {
+            globalPeakContext = requestContext;
+          }
+          // Issue #1491: Also track per-sub-session usage
           if (usage.input_tokens) currentSubSession.inputTokens += usage.input_tokens;
           if (usage.cache_creation_input_tokens) currentSubSession.cacheCreationTokens += usage.cache_creation_input_tokens;
           if (usage.cache_read_input_tokens) currentSubSession.cacheReadTokens += usage.cache_read_input_tokens;
           if (usage.output_tokens) currentSubSession.outputTokens += usage.output_tokens;
           currentSubSession.messageCount++;
+          // Issue #1501: Track peak context and output per sub-session
+          if (requestContext > currentSubSession.peakContextUsage) {
+            currentSubSession.peakContextUsage = requestContext;
+          }
+          if ((usage.output_tokens || 0) > currentSubSession.peakOutputUsage) {
+            currentSubSession.peakOutputUsage = usage.output_tokens || 0;
+          }
         }
       } catch {
         // Skip lines that aren't valid JSON
@@ -561,6 +595,8 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
     // Calculate cost for each model and store all characteristics
     for (const [modelId, usage] of Object.entries(modelUsage)) {
       const modelInfo = modelInfoMap[modelId];
+      // Issue #1501: Attach peak context usage per model
+      usage.peakContextUsage = peakContextByModel[modelId] || 0;
       // Calculate cost using pricing API
       if (modelInfo) {
         const costData = calculateModelCost(usage, modelInfo, true);
@@ -604,8 +640,11 @@ export const calculateSessionTokens = async (sessionId, tempDir) => {
       outputTokens: totalOutputTokens,
       totalTokens,
       totalCostUSD: hasCostData ? totalCostUSD : null,
-      // Issue #1491: Sub-session and compactification data
-      subSessions: subSessions.length > 1 ? subSessions : null, // Only include if compactification occurred
+      // Issue #1501: Peak context usage (max single-request fill) and dedup stats
+      peakContextUsage: globalPeakContext,
+      duplicateEntriesSkipped: duplicateCount,
+      // Issue #1491/#1501: Sub-session and compactification data (always include for display)
+      subSessions,
       compactifications: compactifications.length > 0 ? compactifications : null,
     };
   } catch (readError) {
@@ -1248,6 +1287,13 @@ export const executeClaudeCommand = async params => {
         try {
           const tokenUsage = await calculateSessionTokens(sessionId, tempDir);
           if (tokenUsage) {
+            // Issue #1501: Log deduplication stats in verbose mode
+            if (tokenUsage.duplicateEntriesSkipped > 0) {
+              await log(`\n⚠️  JSONL deduplication: skipped ${tokenUsage.duplicateEntriesSkipped} duplicate entries (upstream: anthropics/claude-code#6805)`, { verbose: true });
+            }
+            if (tokenUsage.peakContextUsage > 0) {
+              await log(`📊 Peak single-request context: ${formatNumber(tokenUsage.peakContextUsage)} tokens`, { verbose: true });
+            }
             await log('\n💰 Token Usage Summary:');
             // Display per-model breakdown
             if (tokenUsage.modelUsage) {
@@ -1258,18 +1304,9 @@ export const executeClaudeCommand = async params => {
                 await displayModelUsage(usage, log);
                 // Display budget stats if flag is enabled
                 if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
-                  await displayBudgetStats(usage, log);
+                  await displayBudgetStats(usage, tokenUsage, log);
                 }
               }
-              // Issue #1491: Display sub-session breakdown if compactification occurred
-              if (argv.tokensBudgetStats && tokenUsage.subSessions) {
-                const primaryModelInfo = Object.values(tokenUsage.modelUsage).find(u => u.modelInfo?.limit)?.modelInfo;
-                await displaySubSessionStats(tokenUsage, primaryModelInfo, log);
-              }
-              // Issue #1491: Display stream vs JSONL token comparison
-              if (argv.tokensBudgetStats && streamTokenUsage.eventCount > 0) {
-                await displayTokenComparison(streamTokenUsage, tokenUsage, log);
-              }
               // Show totals if multiple models were used
               if (modelIds.length > 1) {
                 await log('\n   📈 Total across all models:');

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * GitHub Repository-Wide Actions Monitoring
+ *
+ * Issue #1503: Functions to check and wait for ALL active GitHub Actions
+ * workflow runs across the entire repository. This is the "absolute safety
+ * mechanism" modeled after the /merge command's waitForBranchCI pattern.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1503
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+const exec = promisify(execCallback);
+
+/**
+ * Get ALL active workflow runs across the entire repository (no branch filter).
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{runs: Array, hasActiveRuns: boolean, count: number}>}
+ */
+export async function getAllActiveRepoRuns(owner, repo, verbose = false) {
+  try {
+    const activeFilter = '.workflow_runs[] | select(.status=="in_progress" or .status=="queued" or .status=="waiting" or .status=="requested" or .status=="pending")';
+    const fields = '{id: .id, name: .name, status: .status, head_branch: .head_branch, head_sha: (.head_sha[:7])}';
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/runs?per_page=100" --jq '[${activeFilter}] | map(${fields})'`);
+    const runs = JSON.parse(stdout.trim() || '[]');
+    if (verbose && runs.length > 0) {
+      console.log(`[VERBOSE] repo-actions: ${runs.length} active run(s) in ${owner}/${repo}`);
+      for (const r of runs) console.log(`[VERBOSE] repo-actions:   ${r.name} (${r.status}) on ${r.head_branch}`);
+    }
+    return { runs, hasActiveRuns: runs.length > 0, count: runs.length };
+  } catch {
+    return { runs: [], hasActiveRuns: false, count: 0 };
+  }
+}
+
+/**
+ * Wait for ALL active workflow runs in the repository to complete.
+ * Blocks until every in-progress/queued run across ALL branches finishes.
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {Object} options - Wait options (timeout, pollInterval, onStatusUpdate)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{success: boolean, waitedForRuns: boolean, timedOut: boolean, remainingRuns: Array}>}
+ */
+export async function waitForAllRepoActions(owner, repo, options = {}, verbose = false) {
+  const { timeout = 45 * 60 * 1000, pollInterval = 5 * 60 * 1000, onStatusUpdate = null } = options;
+  const startTime = Date.now();
+  let peakRunCount = 0;
+
+  while (Date.now() - startTime < timeout) {
+    const active = await getAllActiveRepoRuns(owner, repo, verbose);
+    if (onStatusUpdate) {
+      try {
+        await onStatusUpdate({ ...active, elapsedMs: Date.now() - startTime });
+      } catch {
+        // Ignore callback errors — continue monitoring
+      }
+    }
+    if (!active.hasActiveRuns) {
+      return { success: true, waitedForRuns: peakRunCount > 0, timedOut: false, remainingRuns: [] };
+    }
+    peakRunCount = Math.max(peakRunCount, active.count);
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+  const finalRuns = await getAllActiveRepoRuns(owner, repo, verbose);
+  return { success: false, waitedForRuns: true, timedOut: true, remainingRuns: finalRuns.runs };
+}
+
+/**
+ * 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.
+ * @param {Object} params
+ * @returns {Promise<{allAgree: boolean, mechanisms: Object, ciStatus: Object, workflowRuns: Array}>}
+ */
+export async function checkCIConsensus({ owner, repo, prNumber, sha, waitForAllRepoActionsFlag, verbose, getDetailedCIStatus, getWorkflowRunsForSha }) {
+  const ciStatus = await getDetailedCIStatus(owner, repo, prNumber, verbose);
+  const checkRunsOK = ciStatus.status === 'success' || ciStatus.status === 'no_checks';
+
+  const workflowRuns = await getWorkflowRunsForSha(owner, repo, sha, verbose);
+  const workflowsOK = workflowRuns.length === 0 || workflowRuns.every(r => r.status === 'completed');
+
+  let repoOK = true;
+  let repoInfo = null;
+  if (waitForAllRepoActionsFlag) {
+    repoInfo = await getAllActiveRepoRuns(owner, repo, verbose);
+    repoOK = !repoInfo.hasActiveRuns;
+  }
+
+  const allAgree = checkRunsOK && workflowsOK && repoOK;
+  const mechanisms = {
+    checkRunsAPI: { complete: checkRunsOK, status: ciStatus.status },
+    workflowRunsAPI: { complete: workflowsOK, total: workflowRuns.length, inProgress: workflowRuns.filter(r => r.status !== 'completed').length },
+    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'}`);
+  }
+  return { allAgree, mechanisms, ciStatus, workflowRuns };
+}

package/src/github-merge.lib.mjs

@@ -1385,31 +1385,30 @@ export async function checkPreviousPRCommitsHadCI(owner, repo, prNumber, headSha
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{hasPRTriggers: boolean, hasWorkflowFiles: boolean, workflows: Array<{name: string, triggers: string[]}>}>}
  */
-export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false) {
+export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false, ref = null) {
   try {
-    // List workflow files in .github/workflows/
-    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows" --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
+    // Issue #1503: Support querying workflow files from a specific branch (ref)
+    const refParam = ref ? `?ref=${encodeURIComponent(ref)}` : '';
+    // List workflow files in .github/workflows/ (uses ref if provided, otherwise default branch)
+    const { stdout: listJson } = await exec(`gh api "repos/${owner}/${repo}/contents/.github/workflows${refParam}" --jq '[.[] | select(.name | test("\\\\.(yml|yaml)$")) | {name: .name, download_url: .download_url, path: .path}]' 2>/dev/null`);
     const files = JSON.parse(listJson.trim() || '[]');
 
     if (files.length === 0) {
-      if (verbose) {
-        console.log(`[VERBOSE] /merge: No workflow files found in ${owner}/${repo}/.github/workflows/ — no CI/CD will execute`);
-      }
-      // Issue #1480: hasWorkflowFiles=false is a strong signal that no CI/CD is configured at the file level
+      if (verbose) console.log(`[VERBOSE] /merge: No workflow files in ${owner}/${repo}/.github/workflows/`);
       return { hasPRTriggers: false, hasWorkflowFiles: false, workflows: [] };
     }
 
     const prTriggerPatterns = [/\bon:\s*\n\s+pull_request/m, /\bon:\s*\[.*pull_request.*\]/m, /\bon:\s*pull_request\b/m, /\bpull_request_target\b/m];
-
-    // Also check for push triggers (push to PR branches triggers CI)
     const pushTriggerPatterns = [/\bon:\s*\n\s+push/m, /\bon:\s*\[.*push.*\]/m, /\bon:\s*push\b/m];
+    // Issue #1503: Non-PR triggers for diagnostics (won't produce check-runs on PRs)
+    const nonPROnlyTriggerPatterns = [/\bworkflow_dispatch\b/m, /\bschedule\b/m, /\brepository_dispatch\b/m, /\bworkflow_call\b/m];
 
     const results = [];
 
     for (const file of files) {
       try {
-        // Fetch file content (use raw content from the API)
-        const { stdout: contentJson } = await exec(`gh api "repos/${owner}/${repo}/contents/${file.path}" --jq '.content'`);
+        // Issue #1503: Fetch file content using same ref parameter for branch-specific workflows
+        const { stdout: contentJson } = await exec(`gh api "repos/${owner}/${repo}/contents/${file.path}${refParam}" --jq '.content'`);
         const content = Buffer.from(contentJson.trim().replace(/"/g, ''), 'base64').toString('utf-8');
 
         const triggers = [];
@@ -1419,13 +1418,15 @@ export async function checkWorkflowsHavePRTriggers(owner, repo, verbose = false)
         if (pushTriggerPatterns.some(p => p.test(content))) {
           triggers.push('push');
         }
+        // Issue #1503: Track non-PR triggers for diagnostics
+        const nonPRTriggers = nonPROnlyTriggerPatterns.filter(p => p.test(content)).map(p => p.source.replace(/\\b/g, ''));
 
         if (triggers.length > 0) {
           results.push({ name: file.name, triggers });
         }
 
         if (verbose) {
-          console.log(`[VERBOSE] /merge: Workflow ${file.name}: triggers=[${triggers.join(', ')}]`);
+          console.log(`[VERBOSE] /merge: Workflow ${file.name}: pr_triggers=[${triggers.join(', ')}], non_pr_triggers=[${nonPRTriggers.join(', ')}]`);
         }
       } catch (fileError) {
         if (verbose) {
@@ -1454,6 +1455,9 @@ 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 };
+
 export default {
   READY_LABEL,
   checkReadyLabelExists,
@@ -1482,15 +1486,15 @@ export default {
   rerunWorkflowRun,
   rerunFailedJobs,
   getWorkflowRunsForSha,
-  // Issue #1341: Post-merge CI waiting; Issue #1363: Detect active workflows
   waitForCommitCI,
   checkBranchCIHealth,
   getMergeCommitSha,
   getActiveRepoWorkflows,
-  // Issue #1480: Commit date, workflow PR triggers, and previous commit CI history for race condition detection
   getCommitDate,
   checkPreviousPRCommitsHadCI,
   checkWorkflowsHavePRTriggers,
-  // Issue #1413: Use issue timeline to find genuinely linked PRs (avoids false positives from text search)
   getLinkedPRsFromTimeline,
+  getAllActiveRepoRuns,
+  waitForAllRepoActions,
+  checkCIConsensus, // Issue #1503
 };

package/src/github.lib.mjs

@@ -368,7 +368,7 @@ export async function attachLogToGitHub(options) {
     resultModelUsage = null, // Issue #1454
     budgetStatsData = null, // Issue #1491: budget stats for comment
   } = options;
-  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage, budgetStatsData.streamTokenUsage) : '';
+  const budgetStats = budgetStatsData ? buildBudgetStatsString(budgetStatsData.tokenUsage) : '';
   const targetName = targetType === 'pr' ? 'Pull Request' : 'Issue';
   const ghCommand = targetType === 'pr' ? 'pr' : 'issue';
   try {

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

@@ -33,7 +33,7 @@ const { reportError } = sentryLib;
 
 // Import GitHub merge functions
 const githubMergeLib = await import('./github-merge.lib.mjs');
-const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows, getCommitDate, checkWorkflowsHavePRTriggers } = githubMergeLib;
+const { checkPRMergeable, checkMergePermissions, mergePullRequest, waitForCI, checkForBillingLimitError, getRepoVisibility, BILLING_LIMIT_ERROR_PATTERN, getDetailedCIStatus, rerunWorkflowRun, getWorkflowRunsForSha, getActiveRepoWorkflows, getCommitDate, checkWorkflowsHavePRTriggers, checkPreviousPRCommitsHadCI, getAllActiveRepoRuns, checkCIConsensus } = githubMergeLib;
 
 // Import GitHub functions for log attachment
 const githubLib = await import('./github.lib.mjs');
@@ -187,7 +187,7 @@ const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCh
  * - billing_limit: Billing/spending limit reached → stop (private) or wait (public)
  * - no_checks: No CI checks yet (race condition) → wait
  */
-const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCount = 1) => {
+const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCount = 1, prBranchRef = null) => {
   const blockers = [];
 
   // Use detailed CI status to distinguish between all possible states
@@ -239,7 +239,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
             // Treat the same as "CI not triggered" to avoid infinite waiting.
             const conclusions = [...new Set(workflowRuns.map(r => r.conclusion))].join(', ');
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} has ${workflowRuns.length} workflow run(s) for SHA ${ciStatus.sha.substring(0, 7)}, but all completed without executing (conclusions: ${conclusions}) — check-runs will never appear`);
+              await log(`[VERBOSE] /merge: PR #${prNumber} has ${workflowRuns.length} workflow run(s) for SHA ${ciStatus.sha.substring(0, 7)}, but all completed without executing (conclusions: ${conclusions}) — check-runs will never appear`);
             }
             await log(formatAligned('ℹ️', 'CI workflows completed without executing:', `${conclusions} (${workflowRuns.map(r => r.name).join(', ')})`, 2));
             return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true, workflowRunConclusions: conclusions };
@@ -247,7 +247,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
 
           // Some workflow runs are still in progress or produced results — genuine race condition
           if (verbose) {
-            console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI check-runs yet, but ${workflowRuns.length} workflow run(s) were triggered for SHA ${ciStatus.sha.substring(0, 7)} - genuine race condition (waiting for check-runs to appear)`);
+            await log(`[VERBOSE] /merge: PR #${prNumber} has no CI check-runs yet, but ${workflowRuns.length} workflow run(s) were triggered for SHA ${ciStatus.sha.substring(0, 7)} - genuine race condition (waiting for check-runs to appear)`);
           }
           blockers.push({
             type: 'ci_pending',
@@ -269,13 +269,13 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
           const commitInfo = await getCommitDate(owner, repo, ciStatus.sha, verbose);
 
           // Issue #1480: Parse workflow files for PR triggers (used in both grace period and post-grace checks)
-          const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose);
+          const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose, prBranchRef);
 
           // Issue #1480: If .github/workflows folder doesn't exist or has no workflow files,
           // that's a definitive signal — no CI/CD will execute, skip grace period entirely
           if (!prTriggers.hasWorkflowFiles) {
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} repo has no workflow files in .github/workflows/ — CI definitively not configured at file level`);
+              await log(`[VERBOSE] /merge: PR #${prNumber} repo has no workflow files in .github/workflows/ — CI definitively not configured at file level`);
             }
             return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
           }
@@ -295,15 +295,32 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
             // changed files, conditional workflows that don't match, etc.
             const MAX_NO_RUNS_CHECKS = 5;
             if (checkCount >= MAX_NO_RUNS_CHECKS) {
-              // We've waited long enough — CI was genuinely not triggered
+              // Issue #1503 (enhanced): Before concluding CI was not triggered, check if
+              // previous commits in this PR had CI runs. If they did, CI should be expected
+              // for the current commit too — extend waiting with a higher threshold.
+              const MAX_NO_RUNS_CHECKS_WITH_CI_HISTORY = 10;
+              if (checkCount < MAX_NO_RUNS_CHECKS_WITH_CI_HISTORY) {
+                const previousCI = await checkPreviousPRCommitsHadCI(owner, repo, prNumber, ciStatus.sha, verbose);
+                if (previousCI.hadPreviousCI) {
+                  // Previous commits had CI — this commit should too, keep waiting
+                  await log(formatAligned('⚠️', 'CI history signal:', `${previousCI.previousCommitsWithCI} previous commit(s) had CI runs — extending wait (check ${checkCount}/${MAX_NO_RUNS_CHECKS_WITH_CI_HISTORY})`, 2));
+                  blockers.push({
+                    type: 'ci_pending',
+                    message: `CI/CD workflow runs have not appeared yet — previous commits had CI runs, extending wait (check ${checkCount}/${MAX_NO_RUNS_CHECKS_WITH_CI_HISTORY})`,
+                    details: prTriggers.workflows.map(w => w.name),
+                  });
+                  return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: false };
+                }
+              }
+              // We've waited long enough (and no CI history signal) — CI was genuinely not triggered
               if (verbose) {
-                console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs after ${checkCount} consecutive checks — concluding CI was not triggered despite PR triggers existing`);
+                await log(formatAligned('ℹ️', 'CI not triggered:', `No workflow runs after ${checkCount} consecutive checks — concluding CI was not triggered`, 2));
               }
               return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
             }
 
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} has no workflow runs for SHA ${ciStatus.sha.substring(0, 7)}, but workflows have PR/push triggers (${prTriggers.workflows.map(w => w.name).join(', ')}) — waiting for workflow runs to appear (check ${checkCount}/${MAX_NO_RUNS_CHECKS}, commit age: ${commitInfo.ageSeconds ?? 'unknown'}s)`);
+              await log(formatAligned('⏳', 'Waiting for CI:', `No workflow runs for SHA ${ciStatus.sha.substring(0, 7)}, but workflows have PR/push triggers (${prTriggers.workflows.map(w => w.name).join(', ')}) — check ${checkCount}/${MAX_NO_RUNS_CHECKS}, commit age: ${commitInfo.ageSeconds ?? 'unknown'}s`, 2));
             }
             blockers.push({
               type: 'ci_pending',
@@ -313,7 +330,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
           } else if (commitInfo.ageSeconds !== null && commitInfo.ageSeconds < WORKFLOW_RUN_GRACE_PERIOD_SECONDS) {
             // No PR triggers found in workflow files, but commit is still recent — be safe and wait
             if (verbose) {
-              console.log(`[VERBOSE] /merge: No PR/push triggers found in workflow files, but commit is only ${commitInfo.ageSeconds}s old — waiting to be safe`);
+              await log(`[VERBOSE] /merge: No PR/push triggers found in workflow files, but commit is only ${commitInfo.ageSeconds}s old — waiting to be safe`);
             }
             blockers.push({
               type: 'ci_pending',
@@ -325,7 +342,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
             // Issue #1442: Fork PRs needing maintainer approval, paths-ignore filtering,
             // workflow conditions not matching, etc. all result in zero workflow runs.
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} (commit age: ${commitInfo.ageSeconds ?? 'unknown'}s, no PR/push triggers in workflow files) — CI was not triggered`);
+              await log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and no workflow runs for SHA ${ciStatus.sha.substring(0, 7)} (commit age: ${commitInfo.ageSeconds ?? 'unknown'}s, no PR/push triggers in workflow files) — CI was not triggered`);
             }
             return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: true };
           }
@@ -336,7 +353,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
         // Do NOT add a ci_pending blocker. The mergeability check below will also
         // confirm this is mergeable, so blockers will be empty → PR IS MERGEABLE path.
         if (verbose) {
-          console.log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and repo has no active workflows - no CI/CD configured`);
+          await log(`[VERBOSE] /merge: PR #${prNumber} has no CI checks and repo has no active workflows - no CI/CD configured`);
         }
         // Return early with no CI blocker, mergeability already confirmed
         return { blockers, ciStatus, noCiConfigured: true };
@@ -362,7 +379,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
       if (incompleteRuns.length > 0) {
         // Some workflow runs are still in progress — more check-runs may appear
         if (verbose) {
-          console.log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} checks passed), but ${incompleteRuns.length} workflow run(s) still in progress — waiting for completion`);
+          await log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} checks passed), but ${incompleteRuns.length} workflow run(s) still in progress — waiting for completion`);
         }
         blockers.push({
           type: 'ci_pending',
@@ -376,7 +393,7 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
       // (e.g., CodeFactor, Codecov). Check if the repo has workflows that should produce runs.
       const repoWorkflows = await getActiveRepoWorkflows(owner, repo, verbose);
       if (repoWorkflows.hasWorkflows) {
-        const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose);
+        const prTriggers = await checkWorkflowsHavePRTriggers(owner, repo, verbose, prBranchRef);
         if (prTriggers.hasPRTriggers) {
           // Repo has workflows with PR triggers but no runs yet — CI hasn't started
           // This is the exact scenario from Case 2 of Issue #1480
@@ -385,12 +402,12 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
           const MAX_NO_RUNS_CHECKS = 5;
           if (checkCount >= MAX_NO_RUNS_CHECKS) {
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} CI 'success' with ${ciStatus.passedChecks.length} external checks, no workflow runs after ${checkCount} checks — trusting external checks`);
+              await log(`[VERBOSE] /merge: PR #${prNumber} CI 'success' with ${ciStatus.passedChecks.length} external checks, no workflow runs after ${checkCount} checks — trusting external checks`);
             }
             // Fall through — trust the success status from external checks
           } else {
             if (verbose) {
-              console.log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} external checks), but repo has PR-triggered workflows with 0 workflow runs — likely race condition (check ${checkCount}/${MAX_NO_RUNS_CHECKS})`);
+              await log(`[VERBOSE] /merge: PR #${prNumber} CI status is 'success' (${ciStatus.passedChecks.length} external checks), but repo has PR-triggered workflows with 0 workflow runs — likely race condition (check ${checkCount}/${MAX_NO_RUNS_CHECKS})`);
             }
             // Wait for GitHub Actions to register workflow runs
             blockers.push({
@@ -492,8 +509,14 @@ const getMergeBlockers = async (owner, repo, prNumber, verbose = false, checkCou
 export const watchUntilMergeable = async params => {
   const { issueUrl, owner, repo, issueNumber, prNumber, prBranch, branchName, tempDir, argv } = params;
 
-  const watchInterval = argv.watchInterval || 60; // seconds
+  const rawWatchInterval = argv.watchInterval || 60; // seconds
+  // Issue #1503: Enforce minimum 5-minute (300s) CI check interval to conserve GitHub API rate limits.
+  // This prevents excessive API calls during long-running CI pipelines.
+  const MIN_CI_CHECK_INTERVAL_SECONDS = 300;
+  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;
 
   // Track latest session data across all iterations for accurate pricing
   let latestSessionId = null;
@@ -513,11 +536,25 @@ export const watchUntilMergeable = async params => {
 
   let currentBackoffSeconds = watchInterval;
 
+  // Issue #1503: Track consecutive "no workflow runs" checks per-SHA separately from iteration count.
+  // The `checkCount` parameter in getMergeBlockers is a safety valve that triggers after
+  // MAX_NO_RUNS_CHECKS (5) consecutive checks with zero workflow runs, concluding CI was
+  // genuinely not triggered (paths-ignore, fork PRs, etc.). Previously, `iteration` (total
+  // loop count) was passed as `checkCount`, which meant after 5 iterations (regardless of
+  // CI state), any new push would immediately trigger the safety valve because checkCount
+  // was already >= 5. This caused false positive "Ready to merge" when a new commit was
+  // pushed and CI hadn't registered yet.
+  //
+  // Fix: Track the HEAD SHA and reset the counter when it changes (new push detected).
+  let consecutiveNoRunsChecks = 0;
+  let lastKnownHeadSha = null;
+
   await log('');
   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-mergeable (will NOT auto-merge)', 2));
-  await log(formatAligned('', 'Checking interval:', `${watchInterval} seconds`, 2));
+  await log(formatAligned('', 'Checking interval:', `${watchInterval} seconds (minimum: ${MIN_CI_CHECK_INTERVAL_SECONDS}s)`, 2));
+  await log(formatAligned('', 'Wait for all repo actions:', waitForAllRepoActionsFlag ? 'Yes (absolute safety)' : 'No', 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));
   await log('');
@@ -554,8 +591,47 @@ export const watchUntilMergeable = async params => {
     await log(formatAligned('🔍', `Check #${iteration}:`, currentTime.toLocaleTimeString()));
 
     try {
+      // Issue #1503: Get the current HEAD SHA to detect new pushes and reset the
+      // consecutive no-runs counter. This prevents false positives where the counter
+      // from a previous commit's checks carries over to a new commit.
+      let currentHeadSha = null;
+      try {
+        const shaResult = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json headRefOid --jq .headRefOid`;
+        if (shaResult.code === 0) {
+          currentHeadSha = shaResult.stdout.toString().trim();
+        }
+      } catch {
+        // If SHA check fails, proceed with current counter (safe: doesn't reset)
+      }
+      if (currentHeadSha && currentHeadSha !== lastKnownHeadSha) {
+        if (lastKnownHeadSha !== null) {
+          await log(formatAligned('🔄', 'New commit detected:', `${lastKnownHeadSha.substring(0, 7)} → ${currentHeadSha.substring(0, 7)} (resetting CI check counter)`, 2));
+        }
+        lastKnownHeadSha = currentHeadSha;
+        consecutiveNoRunsChecks = 0;
+        // Issue #1503: Also reset the readyToMergeCommentPosted flag when SHA changes,
+        // so a new "Ready to merge" comment can be posted for the new commit's CI results.
+        readyToMergeCommentPosted = false;
+      }
+
+      // Issue #1503: Increment counter; getMergeBlockers will use it as a safety valve.
+      // If getMergeBlockers sees no workflow runs on this check, the counter stays incremented.
+      // If it sees workflow runs or checks, the counter is irrelevant (different code paths).
+      consecutiveNoRunsChecks++;
+
       // Get merge blockers
-      const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions } = await getMergeBlockers(owner, repo, prNumber, argv.verbose, iteration);
+      const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions, ciStatus } = await getMergeBlockers(owner, repo, prNumber, argv.verbose, consecutiveNoRunsChecks, prBranch);
+
+      // Issue #1503: Reset consecutive counter when CI checks or workflow runs were found.
+      // This ensures the safety valve only fires after truly consecutive "no runs" checks,
+      // not after interleaved pending/success/failure states that happened to reach the count.
+      if (ciStatus && ciStatus.status !== 'no_checks') {
+        // CI checks exist (pending, success, failure, etc.) — the "no runs" counter is irrelevant
+        consecutiveNoRunsChecks = 0;
+      } else if (noCiConfigured || noCiTriggered) {
+        // CI was definitively determined: either not configured or not triggered.
+        // Keep the counter as-is (it reached the safety valve or wasn't needed).
+      }
 
       // Check for new comments from non-bot users
       const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
@@ -576,6 +652,54 @@ export const watchUntilMergeable = async params => {
 
       // If PR is mergeable, no blockers, no new comments, and no uncommitted changes
       if (blockers.length === 0 && !hasNewComments && !hasUncommittedChanges) {
+        // Issue #1503 (enhanced): Multi-mechanism consensus + repo-wide action check.
+        // Before declaring PR mergeable, run multiple independent CI detection mechanisms
+        // and require all to agree. This catches race conditions where CI starts between
+        // checks or where interacting CI/CD pipelines affect mergeability.
+        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));
+
+          // Run multi-mechanism consensus: Check Runs API + Workflow Runs API + Repo-wide actions
+          const consensus = await checkCIConsensus({
+            owner,
+            repo,
+            prNumber,
+            sha: currentHeadSha || ciStatus?.sha,
+            waitForAllRepoActionsFlag,
+            verbose: argv.verbose,
+            getDetailedCIStatus,
+            getWorkflowRunsForSha,
+          });
+
+          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));
+            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));
+            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));
+        } else if (waitForAllRepoActionsFlag) {
+          // Even with no CI configured, check repo-wide actions for absolute safety
+          const repoRuns = await getAllActiveRepoRuns(owner, repo, argv.verbose);
+          if (repoRuns.hasActiveRuns) {
+            await log(formatAligned('⏳', 'Waiting for repo-wide actions:', `${repoRuns.count} active run(s) in repository`, 2));
+            lastCheckTime = currentTime;
+            const actualWaitSeconds = currentBackoffSeconds;
+            await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
+            await log('');
+            await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+            continue;
+          }
+        }
+
         await log(formatAligned('✅', 'PR IS MERGEABLE!', ''));
 
         if (isAutoMerge) {

package/src/solve.config.lib.mjs

@@ -186,6 +186,11 @@ 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': {
+    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.',
+    default: 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.',