@link-assistant/hive-mind 1.12.0 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @link-assistant/hive-mind
 
+## 1.13.0
+
+### Minor Changes
+
+- 03adcb6: Add --auto-merge and --auto-restart-until-mergable options for autonomous PR management
+
+  New CLI options:
+  - `--auto-merge`: Automatically merge the pull request when CI passes and PR is mergeable. Implies --auto-restart-until-mergable.
+  - `--auto-restart-until-mergable`: Auto-restart the AI agent until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or uncommitted changes. Does NOT auto-merge.
+
+  Features:
+  - Non-bot comment detection with configurable bot patterns
+  - Automatic detection of CI/CD status and merge readiness
+  - Continuous monitoring loop with configurable check intervals
+  - Progress and status reporting throughout the process
+  - Graceful handling of API errors with exponential backoff
+  - Session data tracking for accurate pricing across iterations
+
 ## 1.12.0
 
 ### Minor Changes

package/package.json

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

package/src/hive.config.lib.mjs

@@ -239,6 +239,16 @@ export const createYargsConfig = yargsInstance => {
       alias: 'w',
       default: false,
     })
+    .option('auto-merge', {
+      type: 'boolean',
+      description: 'Automatically merge the pull request when the working session is finished and all CI/CD statuses pass and PR is mergeable. Implies --auto-restart-until-mergable.',
+      default: false,
+    })
+    .option('auto-restart-until-mergable', {
+      type: 'boolean',
+      description: 'Auto-restart until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or other issues. Does NOT auto-merge.',
+      default: false,
+    })
     .option('issue-order', {
       type: 'string',
       description: 'Order issues by publication date: "asc" (oldest first) or "desc" (newest first)',

package/src/hive.mjs

@@ -771,6 +771,8 @@ if (isDirectExecution) {
             if (argv.promptCaseStudies) args.push('--prompt-case-studies');
             if (argv.promptPlaywrightMcp !== undefined) args.push(argv.promptPlaywrightMcp ? '--prompt-playwright-mcp' : '--no-prompt-playwright-mcp');
             if (argv.executeToolWithBun) args.push('--execute-tool-with-bun');
+            if (argv.autoMerge) args.push('--auto-merge');
+            if (argv.autoRestartUntilMergable) args.push('--auto-restart-until-mergable');
             // Log the actual command being executed so users can investigate/reproduce
             await log(`   📋 Command: ${solveCommand} ${args.join(' ')}`);
 

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

@@ -0,0 +1,598 @@
+#!/usr/bin/env node
+
+/**
+ * Auto-merge and auto-restart-until-mergable module for solve.mjs
+ * Handles automatic merging of PRs and continuous restart until PR becomes mergeable
+ *
+ * Uses shared utilities from solve.restart-shared.lib.mjs for common functions.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1190
+ */
+
+// Check if use is already defined globally (when imported from solve.mjs)
+// If not, fetch it (when running standalone)
+if (typeof globalThis.use === 'undefined') {
+  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
+}
+const use = globalThis.use;
+
+// Use command-stream for consistent $ behavior across runtimes
+const { $ } = await use('command-stream');
+
+// Import shared library functions
+const lib = await import('./lib.mjs');
+const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;
+
+// Note: We don't use detectAndCountFeedback from solve.feedback.lib.mjs
+// because we have our own non-bot comment detection logic that's more
+// appropriate for auto-restart-until-mergable mode
+
+// Import Sentry integration
+const sentryLib = await import('./sentry.lib.mjs');
+const { reportError } = sentryLib;
+
+// Import GitHub merge functions
+const githubMergeLib = await import('./github-merge.lib.mjs');
+const { checkPRCIStatus, checkPRMergeable, mergePullRequest, waitForCI } = githubMergeLib;
+
+// Import GitHub functions for log attachment
+const githubLib = await import('./github.lib.mjs');
+const { sanitizeLogContent, attachLogToGitHub } = githubLib;
+
+// Import shared utilities from the restart-shared module
+const restartShared = await import('./solve.restart-shared.lib.mjs');
+const { checkPRMerged, checkPRClosed, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildAutoRestartInstructions, isApiError } = restartShared;
+
+/**
+ * Check for new comments from non-bot users since last commit
+ * @returns {Promise<{hasNewComments: boolean, comments: Array}>}
+ */
+const checkForNonBotComments = async (owner, repo, prNumber, issueNumber, lastCheckTime, verbose = false) => {
+  try {
+    // Get current GitHub user to identify which comments are from the bot/hive-mind
+    let currentUser = null;
+    try {
+      const userResult = await $`gh api user --jq .login`;
+      if (userResult.code === 0) {
+        currentUser = userResult.stdout.toString().trim();
+      }
+    } catch {
+      // If we can't get the current user, continue without filtering
+    }
+
+    // Common bot usernames and patterns to filter out
+    // Note: Patterns use word boundaries or end-of-string to avoid false positives
+    // (e.g., "claudeuser" should NOT match as a bot)
+    const botPatterns = [
+      /\[bot\]$/i, // Any username ending with [bot]
+      /^github-actions$/i, // GitHub Actions
+      /^dependabot$/i, // Dependabot
+      /^renovate$/i, // Renovate
+      /^codecov$/i, // Codecov
+      /^netlify$/i, // Netlify
+      /^vercel$/i, // Vercel
+      /^hive-?mind$/i, // Hive Mind (with or without hyphen)
+      /^claude$/i, // Claude (exact match only)
+      /^copilot$/i, // GitHub Copilot
+    ];
+
+    const isBot = login => {
+      if (!login) return false;
+      // Check if it's the current user (the bot running hive-mind)
+      if (currentUser && login === currentUser) return true;
+      // Check against known bot patterns
+      return botPatterns.some(pattern => pattern.test(login));
+    };
+
+    // Fetch PR conversation comments
+    const prCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate`;
+    let prComments = [];
+    if (prCommentsResult.code === 0 && prCommentsResult.stdout) {
+      prComments = JSON.parse(prCommentsResult.stdout.toString() || '[]');
+    }
+
+    // Fetch PR review comments (inline code comments)
+    const prReviewCommentsResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate`;
+    let prReviewComments = [];
+    if (prReviewCommentsResult.code === 0 && prReviewCommentsResult.stdout) {
+      prReviewComments = JSON.parse(prReviewCommentsResult.stdout.toString() || '[]');
+    }
+
+    // Fetch issue comments if we have an issue number
+    let issueComments = [];
+    if (issueNumber && issueNumber !== prNumber) {
+      const issueCommentsResult = await $`gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate`;
+      if (issueCommentsResult.code === 0 && issueCommentsResult.stdout) {
+        issueComments = JSON.parse(issueCommentsResult.stdout.toString() || '[]');
+      }
+    }
+
+    // Combine all comments
+    const allComments = [...prComments, ...prReviewComments, ...issueComments];
+
+    // Filter for new comments from non-bot users
+    const newNonBotComments = allComments.filter(comment => {
+      const commentTime = new Date(comment.created_at);
+      const isAfterLastCheck = commentTime > lastCheckTime;
+      const isFromNonBot = !isBot(comment.user?.login);
+
+      if (verbose && isAfterLastCheck && isFromNonBot) {
+        console.log(`[VERBOSE] New non-bot comment from ${comment.user?.login} at ${comment.created_at}`);
+      }
+
+      return isAfterLastCheck && isFromNonBot;
+    });
+
+    return {
+      hasNewComments: newNonBotComments.length > 0,
+      comments: newNonBotComments,
+    };
+  } catch (error) {
+    reportError(error, {
+      context: 'check_non_bot_comments',
+      owner,
+      repo,
+      prNumber,
+      operation: 'fetch_comments',
+    });
+    return { hasNewComments: false, comments: [] };
+  }
+};
+
+/**
+ * Get the reasons why PR is not mergeable
+ */
+const getMergeBlockers = async (owner, repo, prNumber, verbose = false) => {
+  const blockers = [];
+
+  // Check CI status
+  const ciStatus = await checkPRCIStatus(owner, repo, prNumber, verbose);
+  if (ciStatus.status === 'failure') {
+    blockers.push({
+      type: 'ci_failure',
+      message: 'CI/CD checks are failing',
+      details: ciStatus.checks.filter(c => c.conclusion === 'failure').map(c => c.name),
+    });
+  } else if (ciStatus.status === 'pending') {
+    blockers.push({
+      type: 'ci_pending',
+      message: 'CI/CD checks are still running',
+      details: ciStatus.checks.filter(c => c.status !== 'completed').map(c => c.name),
+    });
+  }
+
+  // Check mergeability
+  const mergeStatus = await checkPRMergeable(owner, repo, prNumber, verbose);
+  if (!mergeStatus.mergeable) {
+    blockers.push({
+      type: 'not_mergeable',
+      message: mergeStatus.reason || 'PR is not mergeable',
+      details: [],
+    });
+  }
+
+  return blockers;
+};
+
+/**
+ * Main function: Watch and restart until PR becomes mergeable
+ * This implements --auto-restart-until-mergable functionality
+ */
+export const watchUntilMergable = async params => {
+  const { issueUrl, owner, repo, issueNumber, prNumber, prBranch, branchName, tempDir, argv } = params;
+
+  const watchInterval = argv.watchInterval || 60; // seconds
+  const isAutoMerge = argv.autoMerge || false;
+
+  // Track latest session data across all iterations for accurate pricing
+  let latestSessionId = null;
+  let latestAnthropicCost = null;
+
+  // Track consecutive API errors for retry limit
+  const MAX_API_ERROR_RETRIES = 3;
+  let consecutiveApiErrors = 0;
+  let currentBackoffSeconds = watchInterval;
+
+  await log('');
+  await log(formatAligned('🔄', 'AUTO-RESTART-UNTIL-MERGABLE MODE ACTIVE', ''));
+  await log(formatAligned('', 'Monitoring PR:', `#${prNumber}`, 2));
+  await log(formatAligned('', 'Mode:', isAutoMerge ? 'Auto-merge (will merge when ready)' : 'Auto-restart-until-mergable (will NOT auto-merge)', 2));
+  await log(formatAligned('', 'Checking interval:', `${watchInterval} seconds`, 2));
+  await log(formatAligned('', 'Stop conditions:', 'PR merged, PR closed, or becomes mergeable', 2));
+  await log(formatAligned('', 'Restart triggers:', 'New non-bot comments, CI failures, merge conflicts', 2));
+  await log('');
+  await log('Press Ctrl+C to stop watching manually');
+  await log('');
+
+  let iteration = 0;
+  let lastCheckTime = new Date();
+
+  while (true) {
+    iteration++;
+    const currentTime = new Date();
+
+    // Check if PR is merged
+    const isMerged = await checkPRMerged(owner, repo, prNumber);
+    if (isMerged) {
+      await log('');
+      await log(formatAligned('🎉', 'PR MERGED!', 'Stopping auto-restart-until-mergable mode'));
+      await log(formatAligned('', 'Pull request:', `#${prNumber} has been merged`, 2));
+      await log('');
+      return { success: true, reason: 'merged', latestSessionId, latestAnthropicCost };
+    }
+
+    // Check if PR is closed (not merged)
+    const isClosed = await checkPRClosed(owner, repo, prNumber);
+    if (isClosed) {
+      await log('');
+      await log(formatAligned('🚫', 'PR CLOSED!', 'Stopping auto-restart-until-mergable mode'));
+      await log(formatAligned('', 'Pull request:', `#${prNumber} has been closed without merging`, 2));
+      await log('');
+      return { success: false, reason: 'closed', latestSessionId, latestAnthropicCost };
+    }
+
+    await log(formatAligned('🔍', `Check #${iteration}:`, currentTime.toLocaleTimeString()));
+
+    try {
+      // Get merge blockers
+      const blockers = await getMergeBlockers(owner, repo, prNumber, argv.verbose);
+
+      // Check for new comments from non-bot users
+      const { hasNewComments, comments } = await checkForNonBotComments(owner, repo, prNumber, issueNumber, lastCheckTime, argv.verbose);
+
+      // Check for uncommitted changes using shared utility
+      const hasUncommittedChanges = await checkForUncommittedChanges(tempDir, argv);
+
+      // If PR is mergeable, no blockers, no new comments, and no uncommitted changes
+      if (blockers.length === 0 && !hasNewComments && !hasUncommittedChanges) {
+        await log(formatAligned('✅', 'PR IS MERGEABLE!', ''));
+
+        if (isAutoMerge) {
+          // Attempt to merge the PR
+          await log(formatAligned('🔀', 'Auto-merging PR...', ''));
+          const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: argv.deleteBranchAfterMerge || false }, argv.verbose);
+
+          if (mergeResult.success) {
+            await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));
+            await log(formatAligned('', 'Pull request:', `#${prNumber} has been auto-merged`, 2));
+
+            // Post success comment
+            try {
+              const commentBody = `## 🎉 Auto-merged\n\nThis pull request has been automatically merged by hive-mind after all CI checks passed and the PR became mergeable.\n\n---\n*Auto-merged by hive-mind with --auto-merge flag*`;
+              await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+            } catch {
+              // Don't fail if comment posting fails
+            }
+
+            return { success: true, reason: 'auto-merged', latestSessionId, latestAnthropicCost };
+          } else {
+            await log(formatAligned('⚠️', 'Auto-merge failed:', mergeResult.error || 'Unknown error', 2));
+            await log(formatAligned('', 'Will continue monitoring...', '', 2));
+          }
+        } else {
+          // Just report that PR is mergeable and exit
+          await log(formatAligned('', 'PR is ready to be merged manually', '', 2));
+          await log(formatAligned('', 'Exiting auto-restart-until-mergable mode', '', 2));
+
+          // Post success comment
+          try {
+            const commentBody = `## ✅ Ready to merge\n\nThis pull request is now ready to be merged:\n- All CI checks have passed\n- No merge conflicts\n- No pending changes\n\n---\n*Monitored by hive-mind with --auto-restart-until-mergable flag*`;
+            await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+          } catch {
+            // Don't fail if comment posting fails
+          }
+
+          return { success: true, reason: 'mergeable', latestSessionId, latestAnthropicCost };
+        }
+      }
+
+      // Determine if we need to restart
+      let shouldRestart = false;
+      let restartReason = '';
+      let feedbackLines = [];
+
+      // Reason 1: New comments from non-bot users
+      if (hasNewComments) {
+        shouldRestart = true;
+        restartReason = `New comment(s) from non-bot user(s): ${comments.map(c => c.user?.login).join(', ')}`;
+        feedbackLines.push('📬 New comments detected from non-bot users:');
+        for (const comment of comments) {
+          feedbackLines.push(`  - ${comment.user?.login}: "${comment.body?.substring(0, 100)}${comment.body?.length > 100 ? '...' : ''}"`);
+        }
+        feedbackLines.push('');
+        feedbackLines.push('Please review and address the feedback from these comments.');
+      }
+
+      // Reason 2: CI failures
+      const ciBlocker = blockers.find(b => b.type === 'ci_failure');
+      if (ciBlocker) {
+        shouldRestart = true;
+        restartReason = restartReason ? `${restartReason}; CI failures` : 'CI failures detected';
+        feedbackLines.push('❌ CI/CD checks are failing:');
+        for (const check of ciBlocker.details) {
+          feedbackLines.push(`  - ${check}`);
+        }
+        feedbackLines.push('');
+        feedbackLines.push('Please fix the failing CI checks.');
+      }
+
+      // Reason 3: Merge conflicts or other merge issues
+      const mergeBlocker = blockers.find(b => b.type === 'not_mergeable');
+      if (mergeBlocker && mergeBlocker.message.includes('conflicts')) {
+        shouldRestart = true;
+        restartReason = restartReason ? `${restartReason}; Merge conflicts` : 'Merge conflicts detected';
+        feedbackLines.push('⚠️ Merge conflicts detected:');
+        feedbackLines.push(`  ${mergeBlocker.message}`);
+        feedbackLines.push('');
+        feedbackLines.push('Please resolve the merge conflicts.');
+      }
+
+      // Reason 4: Uncommitted changes
+      if (hasUncommittedChanges) {
+        shouldRestart = true;
+        restartReason = restartReason ? `${restartReason}; Uncommitted changes` : 'Uncommitted changes detected';
+
+        // Get uncommitted changes for display using shared utility
+        const changes = await getUncommittedChangesDetails(tempDir);
+        feedbackLines.push('📝 Uncommitted changes detected:');
+        for (const line of changes) {
+          feedbackLines.push(`  ${line}`);
+        }
+        feedbackLines.push('');
+        feedbackLines.push('IMPORTANT: You MUST handle these uncommitted changes by either:');
+        feedbackLines.push('1. COMMITTING them if they are part of the solution (git add + git commit + git push)');
+        feedbackLines.push('2. REVERTING them if they are not needed (git checkout -- <file> or git clean -fd)');
+      }
+
+      if (shouldRestart) {
+        // Add standard instructions for auto-restart-until-mergable mode using shared utility
+        feedbackLines.push(...buildAutoRestartInstructions());
+
+        await log(formatAligned('🔄', 'RESTART TRIGGERED:', restartReason));
+        await log('');
+
+        // Post a comment to PR about the restart
+        try {
+          const commentBody = `## 🔄 Auto-restart triggered\n\n**Reason:** ${restartReason}\n\nStarting new session to address the issues.\n\n---\n*Auto-restart-until-mergable mode is active. Will continue until PR becomes mergeable.*`;
+          await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+          await log(formatAligned('', '💬 Posted auto-restart notification to PR', '', 2));
+        } catch (commentError) {
+          reportError(commentError, {
+            context: 'post_auto_restart_comment',
+            owner,
+            repo,
+            prNumber,
+            operation: 'comment_on_pr',
+          });
+          await log(formatAligned('', '⚠️  Could not post comment to PR', '', 2));
+        }
+
+        // Get PR merge state status
+        const prStateResult = await $`gh api repos/${owner}/${repo}/pulls/${prNumber} --jq '.mergeStateStatus'`;
+        const mergeStateStatus = prStateResult.code === 0 ? prStateResult.stdout.toString().trim() : null;
+
+        // Execute the AI tool using shared utility
+        await log(formatAligned('🔄', 'Restarting:', `Running ${argv.tool.toUpperCase()} to address issues...`));
+
+        const toolResult = await executeToolIteration({
+          issueUrl,
+          owner,
+          repo,
+          issueNumber,
+          prNumber,
+          branchName: prBranch || branchName,
+          tempDir,
+          mergeStateStatus,
+          feedbackLines,
+          argv,
+        });
+
+        if (!toolResult.success) {
+          // Check if this is an API error using shared utility
+          if (isApiError(toolResult)) {
+            consecutiveApiErrors++;
+            await log(formatAligned('⚠️', `${argv.tool.toUpperCase()} execution failed`, `API error detected (${consecutiveApiErrors}/${MAX_API_ERROR_RETRIES})`, 2));
+
+            if (consecutiveApiErrors >= MAX_API_ERROR_RETRIES) {
+              await log('');
+              await log(formatAligned('❌', 'MAXIMUM API ERROR RETRIES REACHED', ''));
+              await log(formatAligned('', 'Error details:', toolResult.result || 'Unknown API error', 2));
+              await log(formatAligned('', 'Action:', 'Exiting to prevent infinite loop', 2));
+              return { success: false, reason: 'api_error', latestSessionId, latestAnthropicCost };
+            }
+
+            // Apply exponential backoff
+            currentBackoffSeconds = Math.min(currentBackoffSeconds * 2, 300);
+            await log(formatAligned('', 'Backing off:', `Will retry after ${currentBackoffSeconds} seconds`, 2));
+          } else {
+            consecutiveApiErrors = 0;
+            currentBackoffSeconds = watchInterval;
+            await log(formatAligned('⚠️', `${argv.tool.toUpperCase()} execution failed`, 'Will retry in next check', 2));
+          }
+        } else {
+          // Success - reset error counters
+          consecutiveApiErrors = 0;
+          currentBackoffSeconds = watchInterval;
+
+          // Capture latest session data
+          if (toolResult.sessionId) {
+            latestSessionId = toolResult.sessionId;
+            latestAnthropicCost = toolResult.anthropicTotalCostUSD;
+          }
+
+          // Attach log if enabled
+          const shouldAttachLogs = argv.attachLogs || argv['attach-logs'];
+          if (prNumber && shouldAttachLogs) {
+            await log('');
+            await log(formatAligned('📎', 'Uploading session log...', ''));
+            try {
+              const logFile = getLogFile();
+              if (logFile) {
+                const customTitle = `🔄 Auto-restart-until-mergable Log (iteration ${iteration})`;
+                await attachLogToGitHub({
+                  logFile,
+                  targetType: 'pr',
+                  targetNumber: prNumber,
+                  owner,
+                  repo,
+                  $,
+                  log,
+                  sanitizeLogContent,
+                  verbose: argv.verbose,
+                  customTitle,
+                  sessionId: latestSessionId,
+                  tempDir,
+                  anthropicTotalCostUSD: latestAnthropicCost,
+                  publicPricingEstimate: toolResult.publicPricingEstimate,
+                  pricingInfo: toolResult.pricingInfo,
+                });
+                await log(formatAligned('', '✅ Session log uploaded to PR', '', 2));
+              }
+            } catch (logUploadError) {
+              reportError(logUploadError, {
+                context: 'attach_auto_restart_log',
+                prNumber,
+                owner,
+                repo,
+                iteration,
+                operation: 'upload_session_log',
+              });
+              await log(formatAligned('', `⚠️  Log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
+            }
+          }
+
+          await log('');
+          await log(formatAligned('✅', `${argv.tool.toUpperCase()} execution completed:`, 'Checking if PR is now mergeable...'));
+        }
+
+        // Update last check time after restart
+        lastCheckTime = new Date();
+      } else if (blockers.length > 0) {
+        // There are blockers but none that warrant a restart (e.g., CI pending)
+        await log(formatAligned('⏳', 'Waiting for:', blockers.map(b => b.message).join(', '), 2));
+      } else {
+        await log(formatAligned('', 'No action needed', 'Continuing to monitor...', 2));
+      }
+
+      // Update last check time
+      lastCheckTime = currentTime;
+    } catch (error) {
+      reportError(error, {
+        context: 'watch_until_mergable',
+        prNumber,
+        owner,
+        repo,
+        operation: 'check_and_restart',
+      });
+      await log(formatAligned('⚠️', 'Check failed:', cleanErrorMessage(error), 2));
+      await log(formatAligned('', 'Will retry in:', `${watchInterval} seconds`, 2));
+    }
+
+    // Wait for next interval
+    const actualWaitSeconds = consecutiveApiErrors > 0 ? currentBackoffSeconds : watchInterval;
+    await log(formatAligned('⏱️', 'Next check in:', `${actualWaitSeconds} seconds...`, 2));
+    await log('');
+    await new Promise(resolve => setTimeout(resolve, actualWaitSeconds * 1000));
+  }
+};
+
+/**
+ * Attempt to auto-merge PR after session ends
+ * This implements the --auto-merge functionality for one-shot merge attempts
+ */
+export const attemptAutoMerge = async params => {
+  const { owner, repo, prNumber, argv } = params;
+
+  await log('');
+  await log(formatAligned('🔀', 'AUTO-MERGE:', 'Checking if PR can be merged...'));
+
+  // Wait for CI to complete (with timeout)
+  const ciWaitResult = await waitForCI(
+    owner,
+    repo,
+    prNumber,
+    {
+      timeout: argv.autoMergeCiTimeout || 30 * 60 * 1000, // 30 minutes default
+      pollInterval: argv.autoMergeCiPollInterval || 30 * 1000, // 30 seconds default
+      onStatusUpdate: async status => {
+        if (argv.verbose) {
+          await log(`   CI status: ${status.status}`, { verbose: true });
+        }
+      },
+    },
+    argv.verbose
+  );
+
+  if (!ciWaitResult.success) {
+    await log(formatAligned('⚠️', 'CI check failed or timed out:', ciWaitResult.error || ciWaitResult.status, 2));
+    return { success: false, reason: ciWaitResult.status, error: ciWaitResult.error };
+  }
+
+  await log(formatAligned('✅', 'CI checks passed:', 'Checking mergeability...', 2));
+
+  // Check if PR is mergeable
+  const mergeStatus = await checkPRMergeable(owner, repo, prNumber, argv.verbose);
+  if (!mergeStatus.mergeable) {
+    await log(formatAligned('⚠️', 'PR not mergeable:', mergeStatus.reason || 'Unknown reason', 2));
+    return { success: false, reason: 'not_mergeable', error: mergeStatus.reason };
+  }
+
+  await log(formatAligned('✅', 'PR is mergeable:', 'Attempting to merge...', 2));
+
+  // Attempt to merge
+  const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: argv.deleteBranchAfterMerge || false }, argv.verbose);
+
+  if (mergeResult.success) {
+    await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));
+
+    // Post success comment
+    try {
+      const commentBody = `## 🎉 Auto-merged\n\nThis pull request has been automatically merged by hive-mind after all CI checks passed and the PR became mergeable.\n\n---\n*Auto-merged by hive-mind with --auto-merge flag*`;
+      await $`gh pr comment ${prNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+    } catch {
+      // Don't fail if comment posting fails
+    }
+
+    return { success: true, reason: 'merged' };
+  } else {
+    await log(formatAligned('⚠️', 'Merge failed:', mergeResult.error || 'Unknown error', 2));
+    return { success: false, reason: 'merge_failed', error: mergeResult.error };
+  }
+};
+
+/**
+ * Start auto-restart-until-mergable mode
+ */
+export const startAutoRestartUntilMergable = async params => {
+  const { argv } = params;
+
+  // Determine the mode
+  const isAutoMerge = argv.autoMerge || false;
+  const isAutoRestartUntilMergable = argv.autoRestartUntilMergable || false;
+
+  if (!isAutoMerge && !isAutoRestartUntilMergable) {
+    return null; // Neither mode enabled
+  }
+
+  if (!params.prNumber) {
+    await log('');
+    await log(formatAligned('⚠️', 'Auto-restart-until-mergable:', 'Requires a pull request'));
+    await log(formatAligned('', 'Note:', 'This mode only works with existing PRs', 2));
+    return null;
+  }
+
+  // If --auto-merge implies --auto-restart-until-mergable
+  if (isAutoMerge) {
+    argv.autoRestartUntilMergable = true;
+  }
+
+  // Start the watch loop
+  return await watchUntilMergable(params);
+};
+
+export default {
+  watchUntilMergable,
+  attemptAutoMerge,
+  startAutoRestartUntilMergable,
+  checkForNonBotComments,
+};

package/src/solve.config.lib.mjs

@@ -200,6 +200,16 @@ export const createYargsConfig = yargsInstance => {
         description: 'Maximum number of auto-restart iterations when uncommitted changes are detected (default: 3)',
         default: 3,
       })
+      .option('auto-merge', {
+        type: 'boolean',
+        description: 'Automatically merge the pull request when the working session is finished and all CI/CD statuses pass and PR is mergeable. Implies --auto-restart-until-mergable.',
+        default: false,
+      })
+      .option('auto-restart-until-mergable', {
+        type: 'boolean',
+        description: 'Auto-restart until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or other issues. Does NOT auto-merge.',
+        default: false,
+      })
       .option('continue-only-on-feedback', {
         type: 'boolean',
         description: 'Only continue if feedback is detected (works only with pull request link or issue link with --auto-continue)',