@link-assistant/hive-mind 2.13.4 → 2.13.5

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

@@ -0,0 +1,176 @@
+/**
+ * Post-push GitHub synchronization for auto-PR creation.
+ *
+ * Extracted from src/solve.auto-pr.lib.mjs (issue #2175) so that file stays
+ * under the 1350-line early-warning threshold that protects concurrent merges
+ * (#1593). Behaviour is unchanged; the collaborators that were closure bindings
+ * are now parameters.
+ *
+ * A push is accepted by git receive long before GitHub's compare/PR API can see
+ * the new commits, so `gh pr create` run immediately after a push fails with
+ * "No commits between branches". Both helpers here close that gap: the first
+ * polls the compare API until it reports commits ahead, the second confirms the
+ * branch itself is visible and re-pushes it (never forced) when it is not.
+ */
+
+/**
+ * Poll GitHub's compare API until it reports commits ahead of the base branch.
+ *
+ * @param {object} deps
+ * @returns {Promise<{compareReady: boolean, targetBranchForCompare: string}>}
+ */
+export async function waitForCompareApiReady({ argv, defaultBranch, branchName, forkedRepo, owner, repo, issueNumber, log, formatAligned, $, isTransientCompareApiError, handleCompareApiNotReady }) {
+  // CRITICAL: Wait for GitHub to process the push before creating PR
+  // This prevents "No commits between branches" error
+  await log('   Waiting for GitHub to sync...');
+
+  // Use exponential backoff to wait for GitHub's compare API to see the commits
+  // This is essential because GitHub has multiple backend systems:
+  // - Git receive: Accepts push immediately
+  // - Branch API: Returns quickly from cache
+  // - Compare/PR API: May take longer to index commits
+  let compareReady = false;
+  let compareAttempts = 0;
+  const maxCompareAttempts = 5;
+  const targetBranchForCompare = argv.baseBranch || defaultBranch;
+  let compareResult; // Declare outside loop so it's accessible for error checking
+
+  while (!compareReady && compareAttempts < maxCompareAttempts) {
+    compareAttempts++;
+    const waitTime = Math.min(2000 * compareAttempts, 10000); // 2s, 4s, 6s, 8s, 10s
+
+    if (compareAttempts > 1) {
+      await log(`   Retry ${compareAttempts}/${maxCompareAttempts}: Waiting ${waitTime}ms for GitHub to index commits...`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, waitTime));
+
+    // Check if GitHub's compare API can see commits between base and head
+    // This is the SAME API that gh pr create uses internally, so if this works,
+    // PR creation should work too
+    // For fork mode, we need to use forkUser:branchName format for the head
+    let headRef;
+    if (argv.fork && forkedRepo) {
+      const forkUser = forkedRepo.split('/')[0];
+      headRef = `${forkUser}:${branchName}`;
+    } else {
+      headRef = branchName;
+    }
+    compareResult = await $({
+      silent: true,
+    })`gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${headRef} --paginate --jq '.ahead_by' 2>&1`;
+
+    if (compareResult.code === 0) {
+      const aheadBy = parseInt(compareResult.stdout.toString().trim(), 10);
+      if (argv.verbose) {
+        await log(`   Compare API check: ${aheadBy} commit(s) ahead of ${targetBranchForCompare}`);
+      }
+
+      if (aheadBy > 0) {
+        compareReady = true;
+        await log(`   GitHub compare API ready: ${aheadBy} commit(s) found`);
+      } else {
+        await log(`   ⚠️ GitHub compare API shows 0 commits ahead (attempt ${compareAttempts}/${maxCompareAttempts})`, { level: 'warning' });
+      }
+    } else {
+      // Issue #1829: surface compare-API failures in normal output (not
+      // only verbose) so the degraded-mode decision below is explainable
+      // from the logs. Build the text as a STRING — the command-stream
+      // result exposes stdout/stderr as Buffers, and the transient
+      // detectors call String.prototype.toLowerCase().
+      const errorText = `${compareResult.stdout?.toString?.() ?? ''}${compareResult.stderr?.toString?.() ?? ''}`.trim();
+      const firstLine =
+        errorText
+          .split('\n')
+          .map(s => s.trim())
+          .filter(Boolean)[0] || 'unknown';
+      const transientNote = isTransientCompareApiError(errorText) ? ' (transient server error)' : '';
+      await log(`   ⚠️ GitHub compare API error${transientNote} (attempt ${compareAttempts}/${maxCompareAttempts}): ${firstLine}`, { level: 'warning' });
+      if (argv.verbose && errorText) {
+        await log(`   Compare API full output: ${errorText}`, { verbose: true });
+      }
+    }
+  }
+
+  if (!compareReady) {
+    compareReady = await handleCompareApiNotReady({
+      argv,
+      forkedRepo,
+      owner,
+      repo,
+      issueNumber,
+      branchName,
+      targetBranchForCompare,
+      maxCompareAttempts,
+      compareResult,
+      log,
+      formatAligned,
+      $,
+    });
+  }
+
+  return { compareReady, targetBranchForCompare };
+}
+
+/**
+ * Confirm the pushed branch is visible on GitHub, re-pushing it (never forced)
+ * when it is not.
+ *
+ * @param {object} deps
+ * @returns {Promise<void>}
+ */
+export async function verifyBranchOnGitHub({ argv, tempDir, branchName, forkedRepo, owner, repo, log, $ }) {
+  // Verify the push actually worked by checking GitHub API
+  // When using fork mode, check the fork repository; otherwise check the original repository
+  const repoToCheck = argv.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
+  const branchCheckResult = await $({
+    silent: true,
+  })`gh api repos/${repoToCheck}/branches/${branchName} --jq .name 2>&1`;
+  if (branchCheckResult.code === 0 && branchCheckResult.stdout.toString().trim() === branchName) {
+    await log(`   Branch verified on GitHub: ${branchName}`);
+
+    // Get the commit SHA from GitHub
+    const shaCheckResult = await $({
+      silent: true,
+    })`gh api repos/${repoToCheck}/branches/${branchName} --jq .commit.sha 2>&1`;
+    if (shaCheckResult.code === 0) {
+      const remoteSha = shaCheckResult.stdout.toString().trim();
+      await log(`   Remote commit SHA: ${remoteSha.substring(0, 7)}...`);
+    }
+  } else {
+    await log('   Warning: Branch not found on GitHub!');
+    await log('   This will cause PR creation to fail.');
+
+    if (argv.verbose) {
+      await log(`   Branch check result: ${branchCheckResult.stdout || branchCheckResult.stderr || 'empty'}`);
+
+      // Show all branches on GitHub
+      const allBranchesResult = await $({
+        silent: true,
+      })`gh api repos/${repoToCheck}/branches --paginate --jq '.[].name' 2>&1`;
+      if (allBranchesResult.code === 0) {
+        await log(`   All GitHub branches: ${allBranchesResult.stdout.toString().split('\n').slice(0, 5).join(', ')}...`);
+      }
+    }
+
+    // Try one more push with explicit ref (without force)
+    await log('   Attempting explicit push...');
+    const explicitPushCmd = `git push origin HEAD:refs/heads/${branchName}`;
+    if (argv.verbose) {
+      await log(`   Command: ${explicitPushCmd}`);
+    }
+    const explicitPushResult = await $`cd ${tempDir} && ${explicitPushCmd} 2>&1`;
+    if (explicitPushResult.code === 0) {
+      await log('   Explicit push completed');
+      if (argv.verbose && explicitPushResult.stdout) {
+        await log(`   Output: ${explicitPushResult.stdout.toString().trim()}`);
+      }
+      // Wait a bit more for GitHub to process
+      await new Promise(resolve => setTimeout(resolve, 3000));
+    } else {
+      await log('   ERROR: Cannot push to GitHub!');
+      await log(`   Error: ${explicitPushResult.stderr || explicitPushResult.stdout || 'Unknown'}`);
+      await log('   Force push is not allowed to preserve history');
+    }
+  }
+}

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

@@ -8,11 +8,13 @@ import { classifyIssueLinkStatus, buildNonDefaultBranchExplanation } from './git
 import { handleRejectedPushForAutoPr, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 import { emitForkAwareDiagnostic } from './solve.auto-pr-fork-diagnostic.lib.mjs';
 import { handleCompareApiNotReady } from './solve.auto-pr-compare-readiness.lib.mjs'; // Issue #1829: decides whether a failed compare-API readiness poll is fatal (fork mismatch / 0 commits) or a transient diff-render failure to degrade past.
+import { waitForCompareApiReady, verifyBranchOnGitHub } from './solve.auto-pr-push-sync.lib.mjs'; // Issue #2175: extracted to keep this file under the 1350-line warning threshold.
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry, isTransientCompareApiError } 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. Issue #1829: isTransientCompareApiError lets the compare-API readiness gate degrade gracefully on transient diff-render failures.
 import { quietProbe } from './quiet-probe.lib.mjs'; // issue #2130: keep read-only probe payloads out of the attached log
 import { stagePlaceholderFileOrExplain, explainNothingStagedAndThrow } from './solve.auto-pr-placeholder.lib.mjs'; // Issue #1825: handles the seed placeholder when the target repo gitignores it.
 import { sanitizeForPublication, writeSanitizedPublicationFile } from './token-sanitization.lib.mjs';
+import { isPullRequestAlreadyExistsError, findExistingPullRequestUrl } from './github-pr-idempotency.lib.mjs'; // Issue #2168: a retried `gh pr create` must not fail because the first (5xx'd) attempt already created the PR.
 
 export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNumber, owner, repo, defaultBranch, forkedRepo, isContinueMode, prNumber, log, formatAligned, $, reportError, path, fs }) {
   // Skip auto-PR creation if:
@@ -547,148 +549,11 @@ Proceed.
           await log(`   Push output: ${pushResult.stdout.toString().trim()}`, { verbose: true });
         }
 
-        // CRITICAL: Wait for GitHub to process the push before creating PR
-        // This prevents "No commits between branches" error
-        await log('   Waiting for GitHub to sync...');
-
-        // Use exponential backoff to wait for GitHub's compare API to see the commits
-        // This is essential because GitHub has multiple backend systems:
-        // - Git receive: Accepts push immediately
-        // - Branch API: Returns quickly from cache
-        // - Compare/PR API: May take longer to index commits
-        let compareReady = false;
-        let compareAttempts = 0;
-        const maxCompareAttempts = 5;
-        const targetBranchForCompare = argv.baseBranch || defaultBranch;
-        let compareResult; // Declare outside loop so it's accessible for error checking
-
-        while (!compareReady && compareAttempts < maxCompareAttempts) {
-          compareAttempts++;
-          const waitTime = Math.min(2000 * compareAttempts, 10000); // 2s, 4s, 6s, 8s, 10s
-
-          if (compareAttempts > 1) {
-            await log(`   Retry ${compareAttempts}/${maxCompareAttempts}: Waiting ${waitTime}ms for GitHub to index commits...`);
-          }
-
-          await new Promise(resolve => setTimeout(resolve, waitTime));
-
-          // Check if GitHub's compare API can see commits between base and head
-          // This is the SAME API that gh pr create uses internally, so if this works,
-          // PR creation should work too
-          // For fork mode, we need to use forkUser:branchName format for the head
-          let headRef;
-          if (argv.fork && forkedRepo) {
-            const forkUser = forkedRepo.split('/')[0];
-            headRef = `${forkUser}:${branchName}`;
-          } else {
-            headRef = branchName;
-          }
-          compareResult = await $({
-            silent: true,
-          })`gh api repos/${owner}/${repo}/compare/${targetBranchForCompare}...${headRef} --paginate --jq '.ahead_by' 2>&1`;
-
-          if (compareResult.code === 0) {
-            const aheadBy = parseInt(compareResult.stdout.toString().trim(), 10);
-            if (argv.verbose) {
-              await log(`   Compare API check: ${aheadBy} commit(s) ahead of ${targetBranchForCompare}`);
-            }
-
-            if (aheadBy > 0) {
-              compareReady = true;
-              await log(`   GitHub compare API ready: ${aheadBy} commit(s) found`);
-            } else {
-              await log(`   ⚠️ GitHub compare API shows 0 commits ahead (attempt ${compareAttempts}/${maxCompareAttempts})`, { level: 'warning' });
-            }
-          } else {
-            // Issue #1829: surface compare-API failures in normal output (not
-            // only verbose) so the degraded-mode decision below is explainable
-            // from the logs. Build the text as a STRING — the command-stream
-            // result exposes stdout/stderr as Buffers, and the transient
-            // detectors call String.prototype.toLowerCase().
-            const errorText = `${compareResult.stdout?.toString?.() ?? ''}${compareResult.stderr?.toString?.() ?? ''}`.trim();
-            const firstLine =
-              errorText
-                .split('\n')
-                .map(s => s.trim())
-                .filter(Boolean)[0] || 'unknown';
-            const transientNote = isTransientCompareApiError(errorText) ? ' (transient server error)' : '';
-            await log(`   ⚠️ GitHub compare API error${transientNote} (attempt ${compareAttempts}/${maxCompareAttempts}): ${firstLine}`, { level: 'warning' });
-            if (argv.verbose && errorText) {
-              await log(`   Compare API full output: ${errorText}`, { verbose: true });
-            }
-          }
-        }
-
-        if (!compareReady) {
-          compareReady = await handleCompareApiNotReady({
-            argv,
-            forkedRepo,
-            owner,
-            repo,
-            issueNumber,
-            branchName,
-            targetBranchForCompare,
-            maxCompareAttempts,
-            compareResult,
-            log,
-            formatAligned,
-            $,
-          });
-        }
-
-        // Verify the push actually worked by checking GitHub API
-        // When using fork mode, check the fork repository; otherwise check the original repository
-        const repoToCheck = argv.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
-        const branchCheckResult = await $({
-          silent: true,
-        })`gh api repos/${repoToCheck}/branches/${branchName} --jq .name 2>&1`;
-        if (branchCheckResult.code === 0 && branchCheckResult.stdout.toString().trim() === branchName) {
-          await log(`   Branch verified on GitHub: ${branchName}`);
-
-          // Get the commit SHA from GitHub
-          const shaCheckResult = await $({
-            silent: true,
-          })`gh api repos/${repoToCheck}/branches/${branchName} --jq .commit.sha 2>&1`;
-          if (shaCheckResult.code === 0) {
-            const remoteSha = shaCheckResult.stdout.toString().trim();
-            await log(`   Remote commit SHA: ${remoteSha.substring(0, 7)}...`);
-          }
-        } else {
-          await log('   Warning: Branch not found on GitHub!');
-          await log('   This will cause PR creation to fail.');
-
-          if (argv.verbose) {
-            await log(`   Branch check result: ${branchCheckResult.stdout || branchCheckResult.stderr || 'empty'}`);
-
-            // Show all branches on GitHub
-            const allBranchesResult = await $({
-              silent: true,
-            })`gh api repos/${repoToCheck}/branches --paginate --jq '.[].name' 2>&1`;
-            if (allBranchesResult.code === 0) {
-              await log(`   All GitHub branches: ${allBranchesResult.stdout.toString().split('\n').slice(0, 5).join(', ')}...`);
-            }
-          }
-
-          // Try one more push with explicit ref (without force)
-          await log('   Attempting explicit push...');
-          const explicitPushCmd = `git push origin HEAD:refs/heads/${branchName}`;
-          if (argv.verbose) {
-            await log(`   Command: ${explicitPushCmd}`);
-          }
-          const explicitPushResult = await $`cd ${tempDir} && ${explicitPushCmd} 2>&1`;
-          if (explicitPushResult.code === 0) {
-            await log('   Explicit push completed');
-            if (argv.verbose && explicitPushResult.stdout) {
-              await log(`   Output: ${explicitPushResult.stdout.toString().trim()}`);
-            }
-            // Wait a bit more for GitHub to process
-            await new Promise(resolve => setTimeout(resolve, 3000));
-          } else {
-            await log('   ERROR: Cannot push to GitHub!');
-            await log(`   Error: ${explicitPushResult.stderr || explicitPushResult.stdout || 'Unknown'}`);
-            await log('   Force push is not allowed to preserve history');
-          }
-        }
+        // Issue #2175: the post-push GitHub synchronization (compare-API readiness
+        // poll + branch visibility check) lives in solve.auto-pr-push-sync.lib.mjs
+        // to keep this file under the 1350-line warning threshold.
+        await waitForCompareApiReady({ argv, defaultBranch, branchName, forkedRepo, owner, repo, issueNumber, log, formatAligned, $, isTransientCompareApiError, handleCompareApiNotReady });
+        await verifyBranchOnGitHub({ argv, tempDir, branchName, forkedRepo, owner, repo, log, $ });
 
         // Get issue title for PR title
         await log(formatAligned('📋', 'Getting issue:', 'Title from GitHub...'), { verbose: true });
@@ -950,16 +815,41 @@ ${prBody}`,
 
           const prCreateExecOptions = { encoding: 'utf8', cwd: tempDir, env: process.env };
           const prCreateRetryLogger = msg => log(msg, { level: 'warn' });
+          const prHeadRef = argv.fork && forkedRepo ? `${forkedRepo.split('/')[0]}:${branchName}` : branchName;
+
+          // Issue #2168: `execGhWithRetry` now retries GitHub 5xx / GraphQL
+          // internal errors. A mutation that GitHub committed but failed to
+          // acknowledge would make the retry report "a pull request already
+          // exists" — which is success, not failure. Resolve the existing PR
+          // instead of aborting the session.
+          const runPrCreate = async (cmd, label) => {
+            try {
+              const result = await execGhWithRetry(cmd, {
+                execOptions: prCreateExecOptions,
+                label,
+                log: prCreateRetryLogger,
+              });
+              return { stdout: result.stdout, stderr: result.stderr || '' };
+            } catch (error) {
+              if (!isPullRequestAlreadyExistsError(error)) throw error;
+              await log(`   ${label}: GitHub reports a pull request already exists for ${prHeadRef} — treating the retried creation as already applied.`, { level: 'warn' });
+              const existingUrl = await findExistingPullRequestUrl({
+                owner,
+                repo,
+                headRef: prHeadRef,
+                execGh: (lookupCommand, lookupOptions) => execGhWithRetry(lookupCommand, { execOptions: prCreateExecOptions, log: prCreateRetryLogger, ...lookupOptions }),
+                log: msg => log(msg),
+              });
+              if (!existingUrl) throw error;
+              return { stdout: existingUrl, stderr: '' };
+            }
+          };
 
           // Try to create PR with assignee first (if specified)
           try {
-            const result = await execGhWithRetry(command, {
-              execOptions: prCreateExecOptions,
-              label: 'gh pr create',
-              log: prCreateRetryLogger,
-            });
+            const result = await runPrCreate(command, 'gh pr create');
             output = result.stdout;
-            prCreateStderr = result.stderr || '';
+            prCreateStderr = result.stderr;
           } catch (firstError) {
             // Check if the error is specifically about assignee validation
             const errorMsg = firstError.message || '';
@@ -985,13 +875,9 @@ ${prBody}`,
               }
 
               // Retry without assignee - if this fails, let the error propagate to outer catch
-              const retryResult = await execGhWithRetry(command, {
-                execOptions: prCreateExecOptions,
-                label: 'gh pr create (no assignee)',
-                log: prCreateRetryLogger,
-              });
+              const retryResult = await runPrCreate(command, 'gh pr create (no assignee)');
               output = retryResult.stdout;
-              prCreateStderr = retryResult.stderr || '';
+              prCreateStderr = retryResult.stderr;
             } else {
               // Not an assignee error, re-throw the original error
               throw firstError;

package/src/solve.mjs

@@ -291,164 +291,14 @@ if (argv.autoCleanup === undefined) {
 }
 // Issue #1716: When the upstream repository is private and the user has direct write access, fork-based workflows should be skipped — even if the existing PR was originally created from a fork. Forks of private repositories often become inaccessible (renamed, deleted, parent re-private'd) and there's no reason to use them when we can push branches and PRs to the upstream repo.
 const skipForkForPrivateUpstream = !isRepoPublic && !argv.fork && hasWriteAccess;
-// Determine mode and get issue details
-let issueNumber;
-let prNumber;
-let prBranch;
-let mergeStateStatus;
-let prState;
-let forkOwner = null;
-let forkRepoName = null;
-let isContinueMode = false;
-// Auto-continue logic: check for existing PRs if --auto-continue is enabled
-const autoContinueResult = await processAutoContinueForIssue(argv, isIssueUrl, urlNumber, owner, repo);
-if (autoContinueResult.isContinueMode) {
-  isContinueMode = true;
-  prNumber = autoContinueResult.prNumber;
-  prBranch = autoContinueResult.prBranch;
-  issueNumber = autoContinueResult.issueNumber;
-  // Only check PR details if we have a PR number
-  if (prNumber) {
-    // Store PR info globally for error handlers
-    global.createdPR = { number: prNumber };
-    // Check if PR is from a fork and get fork owner, merge status, and PR state
-    if (argv.verbose) {
-      await log('   Checking if PR is from a fork...', { verbose: true });
-    }
-    try {
-      const prCheckResult = await $`gh pr view ${prNumber} --repo ${owner}/${repo} --json headRepositoryOwner,headRepository,mergeStateStatus,state`;
-      if (prCheckResult.code === 0) {
-        const prCheckData = JSON.parse(prCheckResult.stdout.toString());
-        // Extract merge status and PR state
-        mergeStateStatus = prCheckData.mergeStateStatus;
-        prState = prCheckData.state;
-        if (argv.verbose) {
-          await log(`   PR state: ${prState || 'UNKNOWN'}`, { verbose: true });
-          await log(`   Merge status: ${mergeStateStatus || 'UNKNOWN'}`, { verbose: true });
-        }
-        if (prCheckData.headRepositoryOwner && prCheckData.headRepositoryOwner.login !== owner) {
-          const detectedForkOwner = prCheckData.headRepositoryOwner.login;
-          const detectedForkRepoName = prCheckData.headRepository && prCheckData.headRepository.name ? prCheckData.headRepository.name : null;
-          // Issue #1716: Skip fork mode for private upstream repos with write access.
-          if (skipForkForPrivateUpstream) {
-            await log(`🔒 Detected fork PR from ${detectedForkOwner}/${detectedForkRepoName || repo}, but upstream ${owner}/${repo} is private and you have write access.`);
-            await log('   Working directly on the private upstream repository (Issue #1716).');
-          } else {
-            forkOwner = detectedForkOwner;
-            // Get actual fork repository name (may be prefixed) and store for use in setupRepository
-            forkRepoName = detectedForkRepoName;
-            await log(`🍴 Detected fork PR from ${forkOwner}/${forkRepoName || repo}`);
-            if (argv.verbose) {
-              await log(`   Fork owner: ${forkOwner}`, { verbose: true });
-              await log('   Will clone fork repository for continue mode', { verbose: true });
-            }
-          }
-          // Check if maintainer can push to the fork when --allow-to-push-to-contributors-pull-requests-as-maintainer is enabled
-          if (forkOwner && argv.allowToPushToContributorsPullRequestsAsMaintainer && argv.autoFork) {
-            await handleMaintainerForkAccess({ owner, repo, prNumber });
-          }
-        }
-      }
-    } catch (forkCheckError) {
-      if (argv.verbose) {
-        await log(`   Warning: Could not check fork status: ${forkCheckError.message}`, { verbose: true });
-      }
-    }
-  } 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,
-      });
-    }
-  }
-} else if (isIssueUrl) {
-  issueNumber = autoContinueResult.issueNumber || urlNumber;
-}
-if (isPrUrl) {
-  isContinueMode = true;
-  prNumber = urlNumber;
-  // Store PR info globally for error handlers
-  global.createdPR = { number: prNumber, url: issueUrl };
-  await log(`🔄 Continue mode: Working with PR #${prNumber}`);
-  if (argv.verbose) {
-    await log('   Continue mode activated: PR URL provided directly', { verbose: true });
-    await log(`   PR Number set to: ${prNumber}`, { verbose: true });
-    await log('   Will fetch PR details and linked issue', { verbose: true });
-  }
-  // Get PR details to find the linked issue and branch
-  try {
-    const prResult = await githubLib.ghPrView({
-      prNumber,
-      owner,
-      repo,
-      jsonFields: 'headRefName,body,number,mergeStateStatus,state,headRepositoryOwner,headRepository',
-    });
-    if (prResult.code !== 0 || !prResult.data) {
-      await log('Error: Failed to get PR details', { level: 'error' });
-      if (prResult.output.includes('Could not resolve to a PullRequest')) {
-        await githubLib.handlePRNotFoundError({ prNumber, owner, repo, argv, shouldAttachLogs });
-      } else {
-        await log(`Error: ${prResult.stderr || 'Unknown error'}`, { level: 'error' });
-      }
-      await safeExit(1, 'Failed to get PR details');
-    }
-    const prData = prResult.data;
-    prBranch = prData.headRefName;
-    mergeStateStatus = prData.mergeStateStatus;
-    prState = prData.state;
-    // Check if this is a fork PR
-    if (prData.headRepositoryOwner && prData.headRepositoryOwner.login !== owner) {
-      const detectedForkOwner = prData.headRepositoryOwner.login;
-      const detectedForkRepoName = prData.headRepository && prData.headRepository.name ? prData.headRepository.name : null;
-      // Issue #1716: Skip fork mode for private upstream repos with write access.
-      if (skipForkForPrivateUpstream) {
-        await log(`🔒 Detected fork PR from ${detectedForkOwner}/${detectedForkRepoName || repo}, but upstream ${owner}/${repo} is private and you have write access.`);
-        await log('   Working directly on the private upstream repository (Issue #1716).');
-      } else {
-        forkOwner = detectedForkOwner;
-        // Get actual fork repository name and store for use in setupRepository
-        forkRepoName = detectedForkRepoName;
-        await log(`🍴 Detected fork PR from ${forkOwner}/${forkRepoName || repo}`);
-        if (argv.verbose) {
-          await log(`   Fork owner: ${forkOwner}`, { verbose: true });
-          await log('   Will clone fork repository for continue mode', { verbose: true });
-        }
-      }
-      // Check if maintainer can push to the fork when --allow-to-push-to-contributors-pull-requests-as-maintainer is enabled
-      if (forkOwner && argv.allowToPushToContributorsPullRequestsAsMaintainer && argv.autoFork) {
-        await handleMaintainerForkAccess({ owner, repo, prNumber });
-      }
-    }
-    await log(`📝 PR branch: ${prBranch}`);
-    const prBody = prData.body || '';
-    const extractedIssueNumber = extractLinkedIssueNumber(prBody);
-    if (extractedIssueNumber) {
-      issueNumber = extractedIssueNumber;
-      await log(`🔗 Found linked issue #${issueNumber}`);
-    } else {
-      // If no linked issue found, we can still continue but warn
-      await log('⚠️  Warning: No linked issue found in PR body', { level: 'warning' });
-      await log('   The PR should contain "Fixes #123" or similar to link an issue', { level: 'warning' });
-      // Set issueNumber to PR number as fallback
-      issueNumber = prNumber;
-    }
-  } catch (error) {
-    reportError(error, {
-      context: 'pr_processing',
-      prNumber,
-      operation: 'process_pull_request',
-    });
-    await log(`Error: Failed to process PR: ${cleanErrorMessage(error)}`, { level: 'error' });
-    await safeExit(1, 'Failed to process PR');
-  }
-} else {
-  // Traditional issue mode
-  issueNumber = urlNumber;
-  await log(`📝 Issue mode: Working with issue #${issueNumber}`);
-}
+// Determine mode and get issue details.
+// Issue #2175: the mode/fork/linked-issue resolution lives in solve.mode.lib.mjs
+// so this file stays under the 1350-line early-warning threshold (issue #1593).
+const solveMode = await import('./solve.mode.lib.mjs');
+const resolvedMode = await solveMode.resolveSolveMode({ argv, owner, repo, urlNumber, issueUrl, isIssueUrl, isPrUrl, skipForkForPrivateUpstream, shouldAttachLogs, log, safeExit, githubLib, processAutoContinueForIssue, handleMaintainerForkAccess, extractLinkedIssueNumber, reportError, cleanErrorMessage });
+const { issueNumber, prBranch, mergeStateStatus, prState, forkOwner, forkRepoName, isContinueMode } = resolvedMode;
+// `prNumber` is reassigned below when auto-PR creation opens the pull request.
+let prNumber = resolvedMode.prNumber;
 // Issues #1212, #1462: Store issueNumber globally for error handlers (attach failure logs to issue when no PR exists)
 global.issueNumber = issueNumber;
 // Issues #1595 and #1596: detect the issue type so analysis and logging prompts use bug vs feature/task wording.