@link-assistant/hive-mind 1.49.1 → 1.49.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @link-assistant/hive-mind
 
+## 1.49.2
+
+### Patch Changes
+
+- 026c95c: fix: non-consistent auto-restart logic on comments (#1567)
+  - Reduce CI check interval from 5 minutes to 2 minutes for faster response times
+  - Prevent concurrent sessions on the same PR/issue via active session URL checking
+  - Add cross-process deduplication for "Ready to merge" comments
+  - Add initial 2-minute cooldown before first mergeable check to ensure proper ordering
+
 ## 1.49.1
 
 ### Patch Changes

package/package.json

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

package/src/session-monitor.lib.mjs

@@ -243,6 +243,39 @@ export function startSessionMonitoring(bot, verbose = false, intervalMs = 30000)
   return timer;
 }
 
+/**
+ * Issue #1567: Check if there's an active session for a given URL.
+ * This prevents concurrent sessions on the same PR/issue, which causes
+ * iteration number jumps, duplicate "Ready to merge" comments, and other
+ * inconsistencies when two auto-restart-until-mergeable processes run
+ * simultaneously.
+ *
+ * @param {string} url - The GitHub URL to check (issue or PR URL)
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {{isActive: boolean, sessionName: string|null}} Whether an active session exists for this URL
+ */
+export function hasActiveSessionForUrl(url, verbose = false) {
+  if (!url) return { isActive: false, sessionName: null };
+
+  // Normalize the URL for comparison (remove trailing slashes, fragments, etc.)
+  const normalizeUrl = u => u.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
+  const normalizedUrl = normalizeUrl(url);
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (sessionInfo.url && normalizeUrl(sessionInfo.url) === normalizedUrl) {
+      if (verbose) {
+        console.log(`[VERBOSE] Found active session for URL ${url}: ${sessionName}`);
+      }
+      return { isActive: true, sessionName };
+    }
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] No active session found for URL ${url}`);
+  }
+  return { isActive: false, sessionName: null };
+}
+
 /**
  * Get statistics about session tracking
  * @param {boolean} verbose - Whether to log verbose output

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

@@ -510,9 +510,11 @@ export const watchUntilMergeable = async params => {
   const { issueUrl, owner, repo, issueNumber, prNumber, prBranch, branchName, tempDir, argv } = params;
 
   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;
+  // Issue #1503: Enforce minimum CI check interval to conserve GitHub API rate limits.
+  // Issue #1567: Reduced from 5 minutes (300s) to 2 minutes (120s) to decrease wait times
+  // between working session finish and "Ready to merge" / next action detection.
+  // This also applies uniformly whether CI/CD is configured or not.
+  const MIN_CI_CHECK_INTERVAL_SECONDS = 120;
   const watchInterval = Math.max(rawWatchInterval, MIN_CI_CHECK_INTERVAL_SECONDS);
   const isAutoMerge = argv.autoMerge || false;
   // Issue #1503: --wait-for-all-actions-in-repository-before-mergable (default: true)
@@ -549,11 +551,20 @@ export const watchUntilMergeable = async params => {
   let consecutiveNoRunsChecks = 0;
   let lastKnownHeadSha = null;
 
+  // Issue #1567: Initial cooldown before first check.
+  // Wait at least MIN_CI_CHECK_INTERVAL_SECONDS after working session finishes before
+  // starting to check. This ensures:
+  // 1. Solution Draft Log is fully posted before any "Ready to merge" can appear
+  // 2. CI/CD checks have time to register with GitHub (avoids false "no CI" detection)
+  // 3. Consistent behavior whether CI/CD is configured or not
+  const INITIAL_COOLDOWN_SECONDS = MIN_CI_CHECK_INTERVAL_SECONDS;
+
   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 (minimum: ${MIN_CI_CHECK_INTERVAL_SECONDS}s)`, 2));
+  await log(formatAligned('', 'Initial cooldown:', `${INITIAL_COOLDOWN_SECONDS} seconds`, 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));
@@ -561,6 +572,13 @@ export const watchUntilMergeable = async params => {
   await log('Press Ctrl+C to stop watching manually');
   await log('');
 
+  // Issue #1567: Wait for initial cooldown before first check.
+  // This gives CI/CD time to start and solution logs time to be posted.
+  await log(formatAligned('⏳', 'Initial cooldown:', `Waiting ${INITIAL_COOLDOWN_SECONDS}s before first check...`));
+  await new Promise(resolve => setTimeout(resolve, INITIAL_COOLDOWN_SECONDS * 1000));
+  await log(formatAligned('✅', 'Cooldown complete:', 'Starting monitoring loop'));
+  await log('');
+
   let iteration = 0;
   let lastCheckTime = new Date();
 
@@ -732,16 +750,28 @@ export const watchUntilMergeable = async params => {
           await log(formatAligned('', 'Exiting auto-restart-until-mergeable mode', '', 2));
 
           // Issue #1371: Post success comment only if not already posted in this session.
-          // Use in-memory flag instead of checking all PR comment history (issue #1323),
-          // since the historical check incorrectly suppressed notifications when a
-          // previous solve run had already posted a "Ready to merge" comment.
+          // Issue #1567: Also check PR comment history as a cross-process guard.
+          // Two layers of deduplication:
+          //   1. In-memory flag (readyToMergeCommentPosted) — prevents duplicates within this process
+          //   2. checkForExistingComment — prevents duplicates from concurrent processes
+          // The in-memory flag is reset when HEAD SHA changes (line 614), so a new commit
+          // will allow a fresh "Ready to merge" comment.
           try {
             if (!readyToMergeCommentPosted) {
-              // Issue #1345: Differentiate message when no CI is configured
-              const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? (workflowRunConclusions ? `- CI workflows completed without executing (${workflowRunConclusions})` : '- CI workflows exist but were not triggered for this commit') : '- All CI checks have passed';
-              const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n${ciLine}\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}`;
-              readyToMergeCommentPosted = true;
+              // Issue #1567: Cross-process deduplication — check if another process already
+              // posted a "Ready to merge" comment. This catches the case where two concurrent
+              // watchUntilMergeable processes both detect mergeability simultaneously.
+              const hasExistingReadyComment = await checkForExistingComment(owner, repo, prNumber, '## ✅ Ready to merge', argv.verbose);
+              if (hasExistingReadyComment) {
+                await log(formatAligned('', 'Skipping duplicate "Ready to merge" comment (already posted by another process)', '', 2));
+                readyToMergeCommentPosted = true;
+              } else {
+                // Issue #1345: Differentiate message when no CI is configured
+                const ciLine = noCiConfigured ? '- No CI/CD checks are configured for this repository' : noCiTriggered ? (workflowRunConclusions ? `- CI workflows completed without executing (${workflowRunConclusions})` : '- CI workflows exist but were not triggered for this commit') : '- All CI checks have passed';
+                const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n${ciLine}\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}`;
+                readyToMergeCommentPosted = true;
+              }
             } else {
               await log(formatAligned('', 'Skipping duplicate "Ready to merge" comment (already posted this session)', '', 2));
             }

package/src/telegram-bot.mjs

@@ -48,7 +48,7 @@ const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-s
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
-const { trackSession, startSessionMonitoring } = await import('./session-monitor.lib.mjs');
+const { trackSession, startSessionMonitoring, hasActiveSessionForUrl } = await import('./session-monitor.lib.mjs');
 
 const config = yargs(hideBin(process.argv))
   .usage('Usage: hive-telegram-bot [options]')
@@ -238,11 +238,8 @@ if (hiveEnabled && hiveOverrides.length > 0) {
           throw new Error(msg);
         });
       await testYargs.parse(testArgs);
-      // Issue #1482: Validate --base-branch/--target-branch in overrides early
-      const overrideBranchError = validateBranchInArgs(hiveOverrides);
-      if (overrideBranchError) {
-        throw new Error(overrideBranchError);
-      }
+      const overrideBranchError = validateBranchInArgs(hiveOverrides); // Issue #1482
+      if (overrideBranchError) throw new Error(overrideBranchError);
       console.log('✅ Hive overrides validated successfully');
     } finally {
       // Restore stderr
@@ -755,17 +752,9 @@ bot.command('limits', async ctx => {
   // Get all limits using shared cache (3min for API, 2min for system)
   const limits = await getAllCachedLimits(VERBOSE);
 
-  // Format the message with usage limits and queue status
-  // If Claude auth failed, pass the error to formatUsageMessage to show it in the Claude sections
-  // while still displaying all other limits sections (disk, GitHub, CPU, memory)
-  // See: https://github.com/link-assistant/hive-mind/issues/1343
+  // Format message with usage limits and queue status (issues #1343, #1267)
   const claudeError = limits.claude.success ? null : limits.claude.error;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
-  // Fetch queue status and pass it as an extra section to formatUsageMessage so that all
-  // sections are assembled before the code block is formed — no fragile string-searching needed.
-  // Shows each queue (claude, agent) with pending/processing counts.
-  // Processing counts are actual running system processes (via pgrep).
-  // See: https://github.com/link-assistant/hive-mind/issues/1267
   const queueStatus = await solveQueue.formatStatus();
   const message = '📊 *Usage Limits*\n\n' + formatUsageMessage(limits.claude.success ? limits.claude.usage : null, limits.disk.success ? limits.disk.diskSpace : null, limits.github.success ? limits.github.githubRateLimit : null, limits.cpu.success ? limits.cpu.cpuLoad : null, limits.memory.success ? limits.memory.memory : null, claudeError, [queueStatus]);
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
@@ -1007,22 +996,22 @@ async function handleSolveCommand(ctx) {
   if (solveOverrides.length > 0) infoBlock += `${userOptionsRaw ? '\n' : '\n\n'}🔒 Locked options: ${escapeMarkdown(solveOverrides.join(' '))}`;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
 
-  // Check for duplicate URL in queue
-  // See: https://github.com/link-assistant/hive-mind/issues/1080
+  // Check for duplicate URL in queue (issue #1080)
   const existingItem = solveQueue.findByUrl(normalizedUrl);
   if (existingItem) {
     const statusText = existingItem.status === 'starting' || existingItem.status === 'started' ? 'being processed' : 'already in the queue';
     await safeReply(ctx, `❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve_queue to check the queue status.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
-
+  // Issue #1567: Prevent concurrent sessions on the same PR/issue
+  const activeSession = hasActiveSessionForUrl(normalizedUrl, VERBOSE);
+  if (activeSession.isActive) {
+    await safeReply(ctx, `❌ A working session is already running for this URL.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nSession: \`${activeSession.sessionName}\`\n\n💡 Wait for the current session to complete, or use /solve\\_stop to cancel it.`, { reply_to_message_id: ctx.message.message_id });
+    return;
+  }
   const check = await solveQueue.canStartCommand({ tool: solveTool }); // Skip Claude limits for agent (#1159)
   const queueStats = solveQueue.getStats();
-
-  // Handle rejection: when a threshold strategy is 'reject', the command should fail immediately
-  // without being placed in the queue. This ensures users get clear feedback about why
-  // their command cannot be processed (e.g., disk full, server maintenance pending).
-  // See: https://github.com/link-assistant/hive-mind/issues/1267
+  // Handle rejection: threshold strategy is 'reject' — fail immediately (issue #1267)
   if (check.rejected) {
     await safeReply(ctx, `❌ Solve command rejected.\n\n${infoBlock}\n\n🚫 Reason: ${escapeMarkdown(check.rejectReason || 'Unknown')}`, { reply_to_message_id: ctx.message.message_id });
     return;
@@ -1288,13 +1277,11 @@ bot.on('message', async (ctx, next) => {
 bot.catch((error, ctx) => {
   console.error('Unhandled error while processing update', ctx.update.update_id);
   console.error('Error:', error);
-  // Log detailed error information
   console.error('Error details:', {
     name: error.name,
     message: error.message,
     stack: error.stack?.split('\n').slice(0, 10).join('\n'),
   });
-  // Log context information for debugging
   if (VERBOSE) {
     console.log('[VERBOSE] Error context:', {
       chatId: ctx.chat?.id,
@@ -1319,7 +1306,6 @@ bot.catch((error, ctx) => {
 
   // Try to notify the user about the error with more details
   if (ctx?.reply) {
-    // Detect if this is a Telegram API parsing error
     const isTelegramParsingError = error.message && (error.message.includes("can't parse entities") || error.message.includes("Can't parse entities") || error.message.includes("can't find end of") || (error.message.includes('Bad Request') && error.message.includes('400')));
 
     let errorMessage;
@@ -1342,7 +1328,6 @@ bot.catch((error, ctx) => {
       // Issue #1460: Show user a simple, non-confusing message — all details are in the logs
       errorMessage = `❌ Failed to send formatted message. Please try your command again.\n\nIf the issue persists, contact support with Update ID: ${ctx.update.update_id}`;
     } else {
-      // Build informative error message for other errors
       errorMessage = '❌ An error occurred while processing your request.\n\n';
       if (error.message) {
         // Filter out sensitive info and escape markdown
@@ -1358,8 +1343,7 @@ bot.catch((error, ctx) => {
       if (VERBOSE) errorMessage += `\n\n🔍 Debug info: Update ID: ${ctx.update.update_id}`;
     }
 
-    // Issue #1460: For parsing errors, always send as plain text (we already know Markdown is the problem)
-    // For other errors, try Markdown first, then fall back to plain text
+    // Issue #1460: For parsing errors send plain text; otherwise try Markdown first
     if (isTelegramParsingError) {
       ctx.reply(errorMessage).catch(fallbackError => {
         console.error('Failed to send plain text error message:', fallbackError);