@link-assistant/hive-mind 1.65.0 → 1.65.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.65.2
+
+### Patch Changes
+
+- 0214c9e: Retry transient 5xx/network errors across all `gh` exec sites. Previously a single 504 from the GitHub GraphQL endpoint could abort `solve` during `gh pr create`. The retry helper now handles HTTP 502/503/504, socket hang up, ECONNRESET, ETIMEDOUT, and TLS handshake timeouts in addition to rate-limit errors, with a separate retry budget and exponential backoff. All direct `execAsync('gh ...')` sites are routed through `execGhWithRetry`.
+
+## 1.65.1
+
+### Patch Changes
+
+- d5cd096: Add a solve flag to disable separate error-report issue creation while preserving original issue failure comments, and improve pre-PR branch divergence diagnostics.
+
 ## 1.65.0
 
 ### Minor Changes

package/package.json

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

package/src/github-error-reporter.lib.mjs

@@ -271,7 +271,7 @@ export const handleErrorWithIssueCreation = async options => {
 
   // --disable-report-issue takes highest precedence
   if (disableReport) {
-    await log('ℹ️  Issue reporting disabled via --disable-report-issue.');
+    await log('ℹ️  Error issue creation is disabled by CLI configuration.');
     return null;
   }
 

package/src/github-rate-limit.lib.mjs

@@ -169,46 +169,98 @@ const sleepWithCountdown = async (ms, log) => {
   }
 };
 
+/**
+ * Patterns matched against an error's combined message/stderr/stdout to decide
+ * whether the failure is a transient network/edge fault that deserves a retry.
+ * Mirrors `isTransientNetworkError` in `src/lib.mjs` (issue #1536); duplicated
+ * here to avoid a circular import — `lib.mjs` already imports from this file.
+ *
+ * Issue #1756: `gh pr create` failed with `HTTP 504: 504 Gateway Timeout
+ * (https://api.github.com/graphql)`. `execGhWithRetry`/`ghWithRateLimitRetry`
+ * only handled rate-limit errors before — a single 504 was fatal.
+ */
+const TRANSIENT_NETWORK_PATTERNS = ['i/o timeout', 'dial tcp', 'connection refused', 'connection reset', 'econnreset', 'etimedout', 'enotfound', 'ehostunreach', 'enetunreach', 'network is unreachable', 'temporary failure', 'http 502', 'http 503', 'http 504', 'bad gateway', 'service unavailable', 'gateway timeout', 'tls handshake timeout', 'ssl_error', 'socket hang up', 'unexpected eof'];
+
+const isTransientNetworkError = error => {
+  const text = collectErrorText(error).toLowerCase();
+  if (!text) return false;
+  return TRANSIENT_NETWORK_PATTERNS.some(pattern => text.includes(pattern));
+};
+
 /**
  * Wrap `fn` so that GitHub rate-limit errors are converted into a sleep until
- * (resetTime + bufferMs + jitterMs) followed by a retry. Non-rate-limit errors
- * are rethrown immediately so we don't mask programming bugs or 404s.
+ * (resetTime + bufferMs + jitterMs) followed by a retry. Transient network
+ * errors (504/502/503, socket hang up, TLS timeouts) get exponential backoff
+ * and a separate retry budget. Other errors are rethrown immediately so we
+ * don't mask programming bugs or 404s.
+ *
+ * Issue #1726 — rate-limit retry. Issue #1756 — transient network retry.
  *
  * @template T
  * @param {() => Promise<T>} fn
  * @param {object} [options]
  * @param {number} [options.maxAttempts] - hard cap on rate-limit retries (default `retryLimits.maxApiRetries`).
+ * @param {number} [options.transientMaxAttempts] - hard cap on transient network retries (default `retryLimits.maxApiRetries`).
+ * @param {number} [options.transientDelay] - initial transient retry delay in ms (default 1000).
+ * @param {number} [options.transientBackoff] - backoff multiplier for transient retries (default 2).
  * @param {string} [options.label] - prefix for log messages.
  * @param {(msg: string) => Promise<void>|void} [options.log] - logger. Defaults to console.warn.
  * @returns {Promise<T>}
  */
 export const ghWithRateLimitRetry = async (fn, options = {}) => {
   const maxAttempts = options.maxAttempts ?? retryLimits.maxApiRetries;
+  const transientMaxAttempts = options.transientMaxAttempts ?? retryLimits.maxApiRetries;
+  const transientDelay = options.transientDelay ?? 1000;
+  const transientBackoff = options.transientBackoff ?? 2;
   const label = options.label || 'gh';
   const log = options.log || (msg => console.warn(msg));
 
+  // Two independent retry budgets — a long string of rate-limit responses
+  // shouldn't burn the transient-error retries, and vice versa.
+  let rateLimitAttempts = 0;
+  let transientAttempts = 0;
   let lastError;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+  // Hard cap so a permanently broken endpoint can't loop forever — sum of
+  // both budgets plus a safety margin.
+  const hardCap = maxAttempts + transientMaxAttempts + 1;
+
+  for (let i = 0; i < hardCap; i++) {
     try {
       return await fn();
     } catch (error) {
       lastError = error;
-      if (!isRateLimitError(error)) throw error;
 
-      if (attempt === maxAttempts) {
-        await Promise.resolve(log(`❌ ${label}: rate limit still active after ${attempt} attempts; giving up.`));
-        throw error;
+      if (isRateLimitError(error)) {
+        rateLimitAttempts++;
+        if (rateLimitAttempts >= maxAttempts) {
+          await Promise.resolve(log(`❌ ${label}: rate limit still active after ${rateLimitAttempts} attempts; giving up.`));
+          throw error;
+        }
+        const reset = parseRateLimitReset(error) || (await fetchNextRateLimitReset());
+        const { waitMs, deadline, bufferMs, jitterMs } = computeRateLimitWait(reset);
+        const waitMinutes = Math.round(waitMs / 60_000);
+        const resetSummary = reset ? `reset at ${reset.toISOString()}` : 'reset time unknown (using buffer + jitter only)';
+        await Promise.resolve(log(`⏳ ${label}: GitHub API rate limit hit (attempt ${rateLimitAttempts}/${maxAttempts}). Waiting ${waitMinutes} min (${resetSummary}; buffer ${Math.round(bufferMs / 60_000)} min + jitter ${Math.round(jitterMs / 1000)}s) until ${deadline.toISOString()}.`));
+        await sleepWithCountdown(waitMs, log);
+        continue;
       }
 
-      const reset = parseRateLimitReset(error) || (await fetchNextRateLimitReset());
-      const { waitMs, deadline, bufferMs, jitterMs } = computeRateLimitWait(reset);
-      const waitMinutes = Math.round(waitMs / 60_000);
-      const resetSummary = reset ? `reset at ${reset.toISOString()}` : 'reset time unknown (using buffer + jitter only)';
-      await Promise.resolve(log(`⏳ ${label}: GitHub API rate limit hit (attempt ${attempt}/${maxAttempts}). Waiting ${waitMinutes} min (${resetSummary}; buffer ${Math.round(bufferMs / 60_000)} min + jitter ${Math.round(jitterMs / 1000)}s) until ${deadline.toISOString()}.`));
-      await sleepWithCountdown(waitMs, log);
+      if (isTransientNetworkError(error)) {
+        transientAttempts++;
+        if (transientAttempts >= transientMaxAttempts) {
+          await Promise.resolve(log(`❌ ${label}: transient network error persisted after ${transientAttempts} attempts; giving up.`));
+          throw error;
+        }
+        const waitMs = transientDelay * Math.pow(transientBackoff, transientAttempts - 1);
+        await Promise.resolve(log(`⚠️ ${label}: transient network error (attempt ${transientAttempts}/${transientMaxAttempts}), retrying in ${Math.round(waitMs / 1000)}s...`));
+        await sleepWithCountdown(waitMs, log);
+        continue;
+      }
+
+      throw error;
     }
   }
-  // Unreachable — loop either returns or throws.
+  // Unreachable — loop either returns or throws via the budgets above.
   throw lastError;
 };
 
@@ -265,8 +317,11 @@ export const wrapDollarWithGhRetry = (dollar, options = {}) => {
   return wrapped;
 };
 
+export { isTransientNetworkError };
+
 export default {
   isRateLimitError,
+  isTransientNetworkError,
   parseRateLimitReset,
   fetchNextRateLimitReset,
   computeRateLimitWait,

package/src/github.batch.lib.mjs

@@ -11,7 +11,7 @@ if (typeof globalThis.use === 'undefined') {
 import { log, cleanErrorMessage } from './lib.mjs';
 import { githubLimits, timeouts } from './config.lib.mjs';
 
-import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
 /**
  * Check if a PR body/title indicates it fixes/closes/resolves a specific issue number
  * GitHub auto-closes issues when PR body contains keywords like "fixes #123", "closes #123", "resolves #123"
@@ -124,14 +124,14 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
           await new Promise(resolve => setTimeout(resolve, timeouts.githubRepoDelay));
         }
 
-        // Execute GraphQL query
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        const { stdout } = await execAsync(`gh api graphql -f query='${query}'`, {
-          encoding: 'utf8',
-          maxBuffer: githubLimits.bufferMaxSize,
-          env: process.env,
+        // Execute GraphQL query (#1756: route through execGhWithRetry for transient 5xx + rate-limit)
+        const { stdout } = await execGhWithRetry(`gh api graphql -f query='${query}'`, {
+          execOptions: {
+            encoding: 'utf8',
+            maxBuffer: githubLimits.bufferMaxSize,
+            env: process.env,
+          },
+          label: 'gh api graphql (batch PR check)',
         });
 
         const data = JSON.parse(stdout);
@@ -191,12 +191,13 @@ export async function batchCheckPullRequestsForIssues(owner, repo, issueNumbers)
 
         for (const issueNum of batch) {
           try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
             const cmd = `gh api repos/${owner}/${repo}/issues/${issueNum}/timeline --paginate --jq '[.[] | select(.event == "cross-referenced" and .source.issue.pull_request != null and .source.issue.state == "open")] | length'`;
 
-            const { stdout } = await execAsync(cmd, { encoding: 'utf8', env: process.env });
+            // #1756: route REST fallback through execGhWithRetry for transient 5xx + rate-limit
+            const { stdout } = await execGhWithRetry(cmd, {
+              execOptions: { encoding: 'utf8', env: process.env },
+              label: `gh api timeline (issue #${issueNum})`,
+            });
             const openPrCount = parseInt(stdout.trim()) || 0;
 
             results[issueNum] = {
@@ -271,14 +272,14 @@ export async function batchCheckArchivedRepositories(repositories) {
           await new Promise(resolve => setTimeout(resolve, timeouts.githubRepoDelay));
         }
 
-        // Execute GraphQL query
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        const { stdout } = await execAsync(`gh api graphql -f query='${query}'`, {
-          encoding: 'utf8',
-          maxBuffer: githubLimits.bufferMaxSize,
-          env: process.env,
+        // Execute GraphQL query (#1756: route through execGhWithRetry for transient 5xx + rate-limit)
+        const { stdout } = await execGhWithRetry(`gh api graphql -f query='${query}'`, {
+          execOptions: {
+            encoding: 'utf8',
+            maxBuffer: githubLimits.bufferMaxSize,
+            env: process.env,
+          },
+          label: 'gh api graphql (batch archived check)',
         });
 
         const data = JSON.parse(stdout);
@@ -301,12 +302,13 @@ export async function batchCheckArchivedRepositories(repositories) {
 
         for (const repo of batch) {
           try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
             const cmd = `gh api repos/${repo.owner}/${repo.name} --jq .archived`;
 
-            const { stdout } = await execAsync(cmd, { encoding: 'utf8', env: process.env });
+            // #1756: route REST fallback through execGhWithRetry for transient 5xx + rate-limit
+            const { stdout } = await execGhWithRetry(cmd, {
+              execOptions: { encoding: 'utf8', env: process.env },
+              label: `gh api repos (${repo.owner}/${repo.name})`,
+            });
             const isArchived = stdout.trim() === 'true';
 
             const repoKey = `${repo.owner}/${repo.name}`;

package/src/github.graphql.lib.mjs

@@ -3,6 +3,8 @@
  * This module provides functions to fetch issues using GitHub's GraphQL API
  */
 
+import { execGhWithRetry } from './github-rate-limit.lib.mjs'; // #1756: route gh exec through transient + rate-limit retry wrapper
+
 /**
  * Fetch issues from a single repository with pagination support for >100 issues
  * @param {string} owner - Repository owner
@@ -13,9 +15,6 @@
  * @returns {Promise<Array>} Array of issues
  */
 async function fetchRepositoryIssuesWithPagination(owner, repoName, log, cleanErrorMessage, issueLimit = 100) {
-  const { exec } = await import('child_process');
-  const { promisify } = await import('util');
-  const execAsync = promisify(exec);
   const allIssues = [];
   let hasNextPage = true;
   let cursor = null;
@@ -59,7 +58,10 @@ async function fetchRepositoryIssuesWithPagination(owner, repoName, log, cleanEr
       // Add delay for rate limiting
       await new Promise(resolve => setTimeout(resolve, 1000));
 
-      const { stdout } = await execAsync(graphqlCmd, { encoding: 'utf8', env: process.env });
+      const { stdout } = await execGhWithRetry(graphqlCmd, {
+        execOptions: { encoding: 'utf8', env: process.env },
+        label: `gh api graphql (issues page ${pageNum} of ${owner}/${repoName})`,
+      });
       const data = JSON.parse(stdout);
       const issuesData = data.data.repository.issues;
 
@@ -95,10 +97,6 @@ async function fetchRepositoryIssuesWithPagination(owner, repoName, log, cleanEr
  * @returns {Promise<{success: boolean, issues: Array, repoCount: number}>}
  */
 export async function tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage, repoLimit = 100, issueLimit = 100) {
-  const { exec } = await import('child_process');
-  const { promisify } = await import('util');
-  const execAsync = promisify(exec);
-
   try {
     await log('   🧪 Attempting GraphQL approach with pagination support...', { verbose: true });
 
@@ -174,7 +172,10 @@ export async function tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMes
       // Add delay for rate limiting
       await new Promise(resolve => setTimeout(resolve, 2000));
 
-      const { stdout } = await execAsync(graphqlCmd, { encoding: 'utf8', env: process.env });
+      const { stdout } = await execGhWithRetry(graphqlCmd, {
+        execOptions: { encoding: 'utf8', env: process.env },
+        label: `gh api graphql (repos page ${repoPageNum} of ${owner})`,
+      });
       const data = JSON.parse(stdout);
       const repos = isOrg ? data.data.organization.repositories : data.data.user.repositories;
 

package/src/github.lib.mjs

@@ -16,6 +16,8 @@ export { getToolDisplayName }; // Re-export for use by other modules
 import { buildBudgetStatsString } from './claude.budget-stats.lib.mjs';
 import { buildCostInfoString } from './github-cost-info.lib.mjs';
 export { buildCostInfoString };
+// #1756: route gh exec calls through transient + rate-limit retry wrapper
+import { execGhWithRetry } from './github-rate-limit.lib.mjs';
 // Issue #1625: Named marker constants (single source of truth) + in-memory
 // tracking for tool-posted comments. See tool-comments.lib.mjs for design.
 import { SOLUTION_DRAFT_LOG_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, postTrackedComment, postTrackedCommentFromFile } from './tool-comments.lib.mjs';
@@ -858,9 +860,6 @@ export function isRateLimitError(error) {
  * @returns {Promise<Array>} Array of issues
  */
 export async function fetchAllIssuesWithPagination(baseCommand) {
-  const { exec } = await import('child_process');
-  const { promisify } = await import('util');
-  const execAsync = promisify(exec);
   // Import log and cleanErrorMessage from lib.mjs
   const { log, cleanErrorMessage } = await import('./lib.mjs');
   try {
@@ -876,7 +875,11 @@ export async function fetchAllIssuesWithPagination(baseCommand) {
     const maxPageSize = isSearchCommand ? 100 : 1000;
     const improvedCommand = `${commandWithoutLimit} --limit ${maxPageSize}`;
     await log(`   🔎 Executing: ${improvedCommand}`, { verbose: true });
-    const { stdout } = await execAsync(improvedCommand, { encoding: 'utf8', env: process.env });
+    // #1756: use execGhWithRetry so transient 5xx (e.g., 504) auto-retry
+    const { stdout } = await execGhWithRetry(improvedCommand, {
+      execOptions: { encoding: 'utf8', env: process.env },
+      label: 'gh search/list issues (paginated)',
+    });
     const endTime = Date.now();
     const issues = JSON.parse(stdout || '[]');
     await log(`   ✅ Fetched ${issues.length} issues in ${Math.round((endTime - startTime) / 1000)}s`);
@@ -913,7 +916,11 @@ export async function fetchAllIssuesWithPagination(baseCommand) {
       await log('   🔄 Falling back to default behavior...', { verbose: true });
       const fallbackCommand = baseCommand.includes('--limit') ? baseCommand : `${baseCommand} --limit 100`;
       await new Promise(resolve => setTimeout(resolve, timeouts.githubRepoDelay)); // Shorter delay for fallback
-      const { stdout } = await execAsync(fallbackCommand, { encoding: 'utf8', env: process.env });
+      // #1756: use execGhWithRetry on fallback too
+      const { stdout } = await execGhWithRetry(fallbackCommand, {
+        execOptions: { encoding: 'utf8', env: process.env },
+        label: 'gh search/list issues (fallback)',
+      });
       const issues = JSON.parse(stdout || '[]');
       await log(`   ⚠️  Fallback: fetched ${issues.length} issues (limited to 100)`, { level: 'warning' });
       return issues;

package/src/hive.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Import Sentry instrumentation first (must be before other imports)
 import './instrument.mjs';
-import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
 const earlyArgs = process.argv.slice(2);
 if (earlyArgs.includes('--version')) {
   const { getVersion } = await import('./version.lib.mjs');
@@ -112,9 +112,6 @@ if (isRunningDirectly) {
      * @returns {Promise<Array>} Array of issues
      */
     async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIssues = false) {
-      const { exec } = await import('child_process');
-      const { promisify } = await import('util');
-      const execAsync = promisify(exec);
       try {
         await log(`   🔄 Using repository-by-repository fallback for ${scope}: ${owner}`);
         // Strategy 1: Try GraphQL approach first (faster but has limitations)
@@ -141,7 +138,11 @@ if (isRunningDirectly) {
 
         // Add delay for rate limiting
         await new Promise(resolve => setTimeout(resolve, 2000));
-        const { stdout: repoOutput } = await execAsync(repoListCmd, { encoding: 'utf8', env: process.env });
+        // #1756: route through execGhWithRetry for transient 5xx + rate-limit
+        const { stdout: repoOutput } = await execGhWithRetry(repoListCmd, {
+          execOptions: { encoding: 'utf8', env: process.env },
+          label: `gh api ${scope} repos (paginated)`,
+        });
         // Parse the output line by line, as gh api with --jq outputs one JSON object per line
         const repoLines = repoOutput
           .trim()

package/src/limits.lib.mjs

@@ -12,7 +12,7 @@ import { promisify } from 'node:util';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 
-import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
 // Initialize dayjs plugins
 dayjs.extend(utc);
 
@@ -316,7 +316,8 @@ function getDisplayCpuCoresUsed(loadAvg5, cpuCount) {
  */
 export async function getGitHubRateLimits(verbose = false) {
   try {
-    const { stdout } = await execAsync('gh api rate_limit 2>/dev/null');
+    // #1756: route through execGhWithRetry for transient 5xx; skip rate-limit retry budget (this is the endpoint we'd consult to know about rate limits).
+    const { stdout } = await execGhWithRetry('gh api rate_limit 2>/dev/null', { label: 'gh api rate_limit', maxAttempts: 1 });
     const data = JSON.parse(stdout);
 
     if (verbose) {

package/src/reviewers-hive.mjs

@@ -5,7 +5,7 @@ const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text(
 
 // Use command-stream for consistent $ behavior across runtimes
 const { $: __rawDollar$ } = await use('command-stream');
-const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const { wrapDollarWithGhRetry, execGhWithRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
 const { getLinoYargsFactory, hideBin, parseCliArgumentsWithLino } = await import('./cli-arguments.lib.mjs');
 const path = (await use('path')).default;
@@ -378,20 +378,19 @@ async function reviewer(reviewerId) {
 // Function to check if a PR already has approvals
 async function hasApprovals(prUrl) {
   try {
-    const { exec } = await import('child_process');
-    const { promisify } = await import('util');
-    const execAsync = promisify(exec);
-
     // Extract owner, repo, and PR number from URL
     const urlMatch = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
     if (!urlMatch) return false;
 
     const [, prOwner, prRepo, prNumber] = urlMatch;
 
-    // Check for reviews using GitHub API
+    // Check for reviews using GitHub API (#1756: retry on transient 5xx + rate-limit)
     const cmd = `gh api repos/${prOwner}/${prRepo}/pulls/${prNumber}/reviews --paginate --jq '[.[] | select(.state == "APPROVED")] | length'`;
 
-    const { stdout } = await execAsync(cmd, { encoding: 'utf8', env: process.env });
+    const { stdout } = await execGhWithRetry(cmd, {
+      execOptions: { encoding: 'utf8', env: process.env },
+      label: `gh api reviews (PR #${prNumber})`,
+    });
     const approvalCount = parseInt(stdout.trim()) || 0;
 
     if (approvalCount > 0) {
@@ -432,25 +431,24 @@ async function fetchPullRequests() {
 
       await log(`   🔎 Command: ${searchCmd}`, { verbose: true });
 
-      // Use async exec to avoid escaping issues
-      const { exec } = await import('child_process');
-      const { promisify } = await import('util');
-      const execAsync = promisify(exec);
-      const { stdout } = await execAsync(searchCmd, { encoding: 'utf8', env: process.env });
+      // #1756: route through execGhWithRetry to retry transient 5xx + rate-limit
+      const { stdout } = await execGhWithRetry(searchCmd, {
+        execOptions: { encoding: 'utf8', env: process.env },
+        label: 'gh search prs (all PRs)',
+      });
       prs = JSON.parse(stdout || '[]');
     } else {
-      // Use label filter
-      const { exec } = await import('child_process');
-      const { promisify } = await import('util');
-      const execAsync = promisify(exec);
-
       // For repositories, use gh pr list which works better
       if (scope === 'repository') {
         const listCmd = `gh pr list --repo ${owner}/${repo} --state open --label "${argv.reviewLabel}" --limit 100 --json url,title,number,isDraft`;
         await log(`   🔎 Command: ${listCmd}`, { verbose: true });
 
         try {
-          const { stdout } = await execAsync(listCmd, { encoding: 'utf8', env: process.env });
+          // #1756: retry on transient 5xx + rate-limit
+          const { stdout } = await execGhWithRetry(listCmd, {
+            execOptions: { encoding: 'utf8', env: process.env },
+            label: 'gh pr list (label filter)',
+          });
           prs = JSON.parse(stdout || '[]');
         } catch (listError) {
           await log(`   ⚠️  List failed: ${listError.message.split('\n')[0]}`, { verbose: true });
@@ -481,7 +479,11 @@ async function fetchPullRequests() {
         await log(`   🔎 Command: ${searchCmd}`, { verbose: true });
 
         try {
-          const { stdout } = await execAsync(searchCmd, { encoding: 'utf8', env: process.env });
+          // #1756: retry on transient 5xx + rate-limit
+          const { stdout } = await execGhWithRetry(searchCmd, {
+            execOptions: { encoding: 'utf8', env: process.env },
+            label: 'gh search prs (label filter)',
+          });
           prs = JSON.parse(stdout || '[]');
         } catch (searchError) {
           await log(`   ⚠️  Search failed: ${searchError.message.split('\n')[0]}`, { verbose: true });

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

@@ -4,8 +4,10 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
+import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
+
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. Issue #1756: execGhWithRetry retries on transient 5xx (504) too.
 
-import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNumber, owner, repo, defaultBranch, forkedRepo, isContinueMode, prNumber, log, formatAligned, $, reportError, path, fs }) {
   // Skip auto-PR creation if:
   // 1. Auto-PR creation is disabled AND we're not in continue mode with no PR
@@ -33,6 +35,16 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
   const issueUrl = argv['issue-url'] || argv._[0];
 
   try {
+    await synchronizeExistingIssueBranchBeforeAutoPrCreation({
+      tempDir,
+      branchName,
+      isContinueMode,
+      prNumber,
+      log,
+      formatAligned,
+      $,
+    });
+
     // Determine which file to create based on CLI flags
     let useClaudeFile = argv.claudeFile !== false;
     const useAutoGitkeepFile = argv.autoGitkeepFile !== false;
@@ -527,6 +539,7 @@ Proceed.
           await log('');
           throw new Error('Permission denied - need fork or collaborator access');
         } else if (errorOutput.includes('non-fast-forward') || errorOutput.includes('rejected') || errorOutput.includes('! [rejected]')) {
+          const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
           // Push rejected due to conflicts or diverged history
           await log('');
           await log(formatAligned('❌', 'PUSH REJECTED:', 'Branch has diverged from remote'), { level: 'error' });
@@ -534,6 +547,9 @@ Proceed.
           await log('  🔍 What happened:');
           await log('     The remote branch has changes that conflict with your local changes.');
           await log('     This typically means someone else has pushed to this branch.');
+          for (const line of buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence })) {
+            await log(line);
+          }
           await log('');
           await log('  💡 Why we cannot fix this automatically:');
           await log('     • We never use force push to preserve history');
@@ -887,16 +903,16 @@ Proceed.
           await log(`   Current user: ${currentUser}`, { verbose: true });
 
           // Check if user has push access (is a collaborator or owner)
-          // IMPORTANT: We need to completely suppress the JSON error output
-          // Using async exec to have full control over stderr
+          // IMPORTANT: We need to completely suppress the JSON error output.
+          // Issue #1756: route through execGhWithRetry so transient 5xx
+          // (504) and rate-limit responses are retried instead of being
+          // mistaken for "user is not a collaborator".
           try {
-            const { exec } = await import('child_process');
-            const { promisify } = await import('util');
-            const execAsync = promisify(exec);
             // This will throw if user doesn't have access, but won't print anything
-            await execAsync(`gh api repos/${owner}/${repo}/collaborators/${currentUser} 2>/dev/null`, {
-              encoding: 'utf8',
-              env: process.env,
+            await execGhWithRetry(`gh api repos/${owner}/${repo}/collaborators/${currentUser} 2>/dev/null`, {
+              execOptions: { encoding: 'utf8', env: process.env },
+              label: `gh api collaborators (${owner}/${repo}/${currentUser})`,
+              log: msg => log(msg, { level: 'warn' }),
             });
             canAssign = true;
             await log('   User has collaborator access', { verbose: true });
@@ -1077,13 +1093,11 @@ ${prBody}`,
           );
         }
 
-        // Use async exec for gh pr create to avoid command-stream output issues
-        // Similar to how create-test-repo.mjs handles it
+        // Issue #1756: route `gh pr create` through execGhWithRetry so a
+        // single transient 5xx (e.g. `HTTP 504: 504 Gateway Timeout
+        // (https://api.github.com/graphql)`) or rate-limit response retries
+        // instead of aborting the whole solve session.
         try {
-          const { exec } = await import('child_process');
-          const { promisify } = await import('util');
-          const execAsync = promisify(exec);
-
           // Write PR body to temp file to avoid shell escaping issues
           const prBodyFile = `/tmp/pr-body-${Date.now()}.md`;
           await fs.writeFile(prBodyFile, prBody);
@@ -1119,9 +1133,16 @@ ${prBody}`,
           let prCreateStderr = '';
           let assigneeFailed = false;
 
+          const prCreateExecOptions = { encoding: 'utf8', cwd: tempDir, env: process.env };
+          const prCreateRetryLogger = msg => log(msg, { level: 'warn' });
+
           // Try to create PR with assignee first (if specified)
           try {
-            const result = await execAsync(command, { encoding: 'utf8', cwd: tempDir, env: process.env });
+            const result = await execGhWithRetry(command, {
+              execOptions: prCreateExecOptions,
+              label: 'gh pr create',
+              log: prCreateRetryLogger,
+            });
             output = result.stdout;
             prCreateStderr = result.stderr || '';
           } catch (firstError) {
@@ -1149,7 +1170,11 @@ ${prBody}`,
               }
 
               // Retry without assignee - if this fails, let the error propagate to outer catch
-              const retryResult = await execAsync(command, { encoding: 'utf8', cwd: tempDir, env: process.env });
+              const retryResult = await execGhWithRetry(command, {
+                execOptions: prCreateExecOptions,
+                label: 'gh pr create (no assignee)',
+                log: prCreateRetryLogger,
+              });
               output = retryResult.stdout;
               prCreateStderr = retryResult.stderr || '';
             } else {

package/src/solve.branch-divergence.lib.mjs

@@ -0,0 +1,93 @@
+const toCount = value => {
+  const parsed = Number.parseInt(String(value || '').trim(), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const outputOf = result => {
+  const stdout = result?.stdout ? result.stdout.toString().trim() : '';
+  const stderr = result?.stderr ? result.stderr.toString().trim() : '';
+  return stdout || stderr;
+};
+
+export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null }) {
+  const lines = [];
+
+  if (isContinueMode && !prNumber) {
+    lines.push('     This run reused an existing issue branch because auto-continue found a matching branch with no PR.');
+    lines.push('     It is not a fresh branch created by this run, even though auto-PR creation is running now.');
+  } else {
+    lines.push('     The remote branch changed after the local branch state used for this push.');
+  }
+
+  if (divergence?.remoteExists && divergence.ahead !== null && divergence.behind !== null) {
+    lines.push(`     Current branch state for ${branchName}: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}.`);
+  } else if (divergence?.fetchError) {
+    lines.push(`     Could not inspect origin/${branchName}: ${divergence.fetchError}`);
+  }
+
+  return lines;
+}
+
+export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName }) {
+  const fetchResult = await $({ cwd: tempDir, silent: true })`git fetch origin refs/heads/${branchName}:refs/remotes/origin/${branchName} 2>&1`;
+  if (fetchResult.code !== 0) {
+    return {
+      remoteExists: false,
+      ahead: null,
+      behind: null,
+      fetchError: outputOf(fetchResult) || 'remote branch not found',
+    };
+  }
+
+  const aheadResult = await $({ cwd: tempDir, silent: true })`git rev-list --count origin/${branchName}..HEAD 2>&1`;
+  const behindResult = await $({ cwd: tempDir, silent: true })`git rev-list --count HEAD..origin/${branchName} 2>&1`;
+
+  return {
+    remoteExists: aheadResult.code === 0 && behindResult.code === 0,
+    ahead: aheadResult.code === 0 ? toCount(aheadResult.stdout) : null,
+    behind: behindResult.code === 0 ? toCount(behindResult.stdout) : null,
+    fetchError: aheadResult.code === 0 && behindResult.code === 0 ? null : outputOf(aheadResult) || outputOf(behindResult) || 'could not compare local and remote branch',
+  };
+}
+
+export async function synchronizeExistingIssueBranchBeforeAutoPrCreation({ tempDir, branchName, isContinueMode, prNumber, log, formatAligned, $ }) {
+  if (!(isContinueMode && !prNumber)) {
+    return null;
+  }
+
+  await log(formatAligned('🔎', 'Existing branch sync:', branchName));
+  const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  if (!divergence.remoteExists) {
+    await log(`   ⚠️ Could not inspect origin/${branchName}: ${divergence.fetchError || 'unknown error'}`, { level: 'warning' });
+    return divergence;
+  }
+
+  await log(`   Branch state before PR bootstrap commit: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}`);
+
+  if (divergence.behind > 0 && divergence.ahead === 0) {
+    await log(`   Fast-forwarding ${branchName} to origin/${branchName} before creating the PR bootstrap commit...`);
+    const mergeResult = await $({ cwd: tempDir })`git merge --ff-only origin/${branchName} 2>&1`;
+    if (mergeResult.code !== 0) {
+      await log(`   ⚠️ Fast-forward failed: ${outputOf(mergeResult) || 'unknown error'}`, {
+        level: 'warning',
+      });
+      throw new Error('Existing issue branch could not be fast-forwarded before PR creation');
+    }
+    await log(`   ✅ Branch fast-forwarded to origin/${branchName}`);
+    return await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  }
+
+  if (divergence.behind > 0 && divergence.ahead > 0) {
+    for (const line of buildPushRejectionExplanation({
+      branchName,
+      isContinueMode,
+      prNumber,
+      divergence,
+    })) {
+      await log(line);
+    }
+    throw new Error('Existing issue branch has diverged before PR creation; manual resolution required');
+  }
+
+  return divergence;
+}

package/src/solve.config.lib.mjs

@@ -512,6 +512,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Disable error issue creation entirely (no prompt, no automatic creation). Overrides --auto-report-issue if both are specified.',
     default: false,
   },
+  'disable-issue-auto-creation-on-error': {
+    type: 'boolean',
+    description: 'Disable creating a new GitHub error-report issue when solve fails, including the interactive prompt. This does not disable posting failure logs or comments to the original issue or pull request.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI working session summary (from the result field) as a comment to the PR/issue after every working session. The summary is extracted from the AI tool JSON output and posted under a "Working session summary" header. Applies to the top-level run, auto-restart-until-mergeable iterations, and watch-mode iterations.',
@@ -718,6 +723,12 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     if (argv.toolCheck === false) {
       argv.toolConnectionCheck = false;
     }
+    // Issue #1752: new flag is the explicit user-facing switch for disabling
+    // creation of separate solver-error issues. Keep the existing internal
+    // disableReportIssue path as the single behavior flag.
+    if (argv.disableIssueAutoCreationOnError) {
+      argv.disableReportIssue = true;
+    }
   }
 
   // --finalize normalization

package/src/solve.error-handlers.lib.mjs

@@ -12,11 +12,14 @@ import { reportError } from './sentry.lib.mjs';
 // Import GitHub error reporter
 import { handleErrorWithIssueCreation } from './github-error-reporter.lib.mjs';
 
+export const isErrorIssueAutoCreationDisabled = argv => !!(argv?.disableReportIssue || argv?.disableIssueAutoCreationOnError);
+
 /**
  * Handles log attachment and PR closing on failure
  */
 export const handleFailure = async options => {
   const { error, errorType, shouldAttachLogs, argv, global, owner, repo, log, getLogFile, attachLogToGitHub, cleanErrorMessage, sanitizeLogContent, $ } = options;
+  const disableIssueCreation = isErrorIssueAutoCreationDisabled(argv);
 
   // Offer to create GitHub issue for the error
   try {
@@ -30,9 +33,9 @@ export const handleFailure = async options => {
         prNumber: global.createdPR?.number,
         errorType,
       },
-      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation,
+      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation || disableIssueCreation,
       autoReport: argv.autoReportIssue,
-      disableReport: argv.disableReportIssue,
+      disableReport: disableIssueCreation,
     });
   } catch (issueError) {
     reportError(issueError, {
@@ -49,7 +52,7 @@ export const handleFailure = async options => {
     const hasIssue = global.issueNumber;
     const targetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const targetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const targetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const targetLabel = hasPR ? 'Pull Request' : `original issue #${targetNumber}`;
 
     if (targetType && targetNumber) {
       await log(`\n📄 Attempting to attach failure logs to ${targetLabel}...`);
@@ -70,7 +73,7 @@ export const handleFailure = async options => {
           tool: argv.tool || 'claude',
         });
         if (logUploadSuccess) {
-          await log(`📎 Failure log attached to ${targetLabel}`);
+          await log(`📎 Failure log posted to ${targetLabel}`);
           if (!hasPR && hasIssue) global.prePullRequestFailureNotificationPosted = true;
         }
       } catch (attachError) {
@@ -81,7 +84,7 @@ export const handleFailure = async options => {
           errorType,
           operation: `attach_log_to_${targetType}`,
         });
-        await log(`⚠️  Could not attach failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
+        await log(`⚠️  Could not post failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
       }
     }
   }

package/src/solve.mjs

@@ -162,6 +162,12 @@ const { isIssueUrl, isPrUrl, normalizedUrl, owner, repo, number: urlNumber } = u
 issueUrl = normalizedUrl || issueUrl;
 global.owner = owner;
 global.repo = repo;
+// Issue #1752: failures before PR creation can happen during checks that run
+// before the normal issue-mode setup below. Record the source issue as soon as
+// the URL is validated so the pre-exit notifier can still comment on it.
+if (isIssueUrl) {
+  global.issueNumber = urlNumber;
+}
 cleanupContext.owner = owner;
 cleanupContext.repo = repo;
 // Setup unhandled error handlers to ensure log path is always shown
@@ -331,6 +337,7 @@ if (autoContinueResult.isContinueMode) {
   } else {
     // We have a branch but no PR - we'll use the existing branch and create a PR later
     await log(`🔄 Using existing branch: ${prBranch} (no PR yet - will create one)`);
+    await log('   This branch was created by an earlier run; this run is reusing it rather than creating a fresh branch.');
     if (argv.verbose) {
       await log('   Branch will be checked out and PR will be created during auto-PR creation phase', {
         verbose: true,
@@ -1021,7 +1028,7 @@ try {
     const hasIssue = global.issueNumber;
     const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const logTargetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const logTargetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const logTargetLabel = hasPR ? 'Pull Request' : `original issue #${logTargetNumber}`;
 
     if (shouldAttachLogs && logTargetType && logTargetNumber) {
       await log(`\n📄 Attaching failure logs to ${logTargetLabel}...`);
@@ -1054,7 +1061,7 @@ try {
         });
 
         if (logUploadSuccess) {
-          await log(`  📎 Failure logs attached to ${logTargetLabel}`);
+          await log(`  📎 Failure logs posted to ${logTargetLabel}`);
         } else {
           // Issue #1212: Always show log upload failures (not just verbose)
           await log('  ⚠️  Failed to upload failure logs');