@link-assistant/hive-mind 2.13.4 → 2.14.0

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

@@ -21,6 +21,8 @@ import { promisify } from 'node:util';
 import { exec as execCb } from 'node:child_process';
 
 import { limitReset, retryLimits } from './config.lib.mjs';
+import { matchGitNetworkCommand } from './git-retry.lib.mjs';
+import { collectErrorText, describeTransientError, formatTransientDiagnostics, isTransientNetworkError, GITHUB_SERVER_TRANSIENT_PATTERNS } from './transient-errors.lib.mjs';
 
 const exec = promisify(execCb);
 
@@ -34,24 +36,6 @@ const githubRateLimitLogging = {
   lastUsageByResource: null,
 };
 
-/**
- * Pull every plausible string out of a thrown error/result so pattern matches
- * survive whatever shape the upstream caller gave us (Error, exec result with
- * stdout/stderr, command-stream result, plain string, etc.).
- */
-const collectErrorText = error => {
-  if (!error) return '';
-  if (typeof error === 'string') return error;
-  const parts = [];
-  if (typeof error.message === 'string') parts.push(error.message);
-  if (typeof error.stderr === 'string') parts.push(error.stderr);
-  else if (error.stderr && typeof error.stderr.toString === 'function') parts.push(error.stderr.toString());
-  if (typeof error.stdout === 'string') parts.push(error.stdout);
-  else if (error.stdout && typeof error.stdout.toString === 'function') parts.push(error.stdout.toString());
-  if (error.cause) parts.push(collectErrorText(error.cause));
-  return parts.join('\n');
-};
-
 /**
  * Detect whether `error` represents a GitHub rate-limit response.
  * Recognises both primary (5,000/hr) and secondary (abuse-detection) forms.
@@ -288,22 +272,18 @@ 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.
+ * Transient-fault classification now lives in `src/transient-errors.lib.mjs`
+ * (issue #2168). Both this module and `src/lib.mjs` import from that leaf
+ * module so a pattern added once applies everywhere; previously each file kept
+ * its own copy of the list and `GraphQL: Something went wrong while executing
+ * your query` was missing from both.
  *
  * 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.
+ * Issue #2168: the same call failed with GitHub's GraphQL internal error,
+ * which is not an HTTP status at all and so was not covered by #1756.
  */
-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));
-};
 
 /**
  * Patterns that identify a *transient* failure of GitHub's compare/diff
@@ -318,13 +298,15 @@ const isTransientNetworkError = error => {
  * used to treat this as fatal and abort the whole session. These patterns let
  * callers recognise the transient case and degrade gracefully instead.
  *
- * Note: HTTP 500 is deliberately matched here (and NOT in
- * `TRANSIENT_NETWORK_PATTERNS`) because a bare 500 from arbitrary endpoints is
- * too broad to retry blindly; it is only safe to treat as transient for the
- * compare endpoint, alongside the explicit "not_available" / "heavy server
- * load" markers.
+ * Issue #2168: these markers are now the shared
+ * `GITHUB_SERVER_TRANSIENT_PATTERNS` list. HTTP 500 used to be matched only
+ * here, on the theory that a bare 500 is too broad to retry blindly. That
+ * carve-out is what let GitHub's GraphQL internal error abort `gh pr create`,
+ * so 5xx/GraphQL-internal responses are now retryable everywhere; writes that
+ * could double-apply are made idempotent at the call site instead (see
+ * `src/github-pr-idempotency.lib.mjs`).
  */
-const TRANSIENT_COMPARE_API_PATTERNS = ['this diff is temporarily unavailable', 'temporarily unavailable due to heavy server load', 'heavy server load', 'not_available', 'http 500', 'http 502', 'http 503', 'http 504'];
+const TRANSIENT_COMPARE_API_PATTERNS = GITHUB_SERVER_TRANSIENT_PATTERNS;
 
 /**
  * Detect whether `error` represents a transient failure of GitHub's
@@ -364,8 +346,10 @@ const isTransientCompareApiError = error => {
  */
 export const ghWithRateLimitRetry = async (fn, options = {}) => {
   const maxAttempts = options.maxAttempts ?? retryLimits.maxApiRetries;
-  const transientMaxAttempts = options.transientMaxAttempts ?? retryLimits.maxApiRetries;
-  const transientDelay = options.transientDelay ?? 1000;
+  // Issue #2168: the transient budget used to reuse `maxApiRetries` (3 attempts
+  // at 1s + 2s). GitHub's GraphQL internal errors routinely outlast that.
+  const transientMaxAttempts = options.transientMaxAttempts ?? retryLimits.maxGitHubTransientRetries;
+  const transientDelay = options.transientDelay ?? retryLimits.initialGitHubTransientDelayMs;
   const transientBackoff = options.transientBackoff ?? 2;
   const label = options.label || 'gh';
   const log = options.log || (msg => console.warn(msg));
@@ -403,18 +387,24 @@ export const ghWithRateLimitRetry = async (fn, options = {}) => {
         continue;
       }
 
-      if (isTransientNetworkError(error)) {
+      // Issue #2168: classify once, and log the classification on every path —
+      // including the "we are not retrying this" path — so the next unknown
+      // failure mode can be diagnosed from the session log without a rerun.
+      const description = describeTransientError(error);
+
+      if (description.transient) {
         transientAttempts++;
         if (transientAttempts >= transientMaxAttempts) {
-          await Promise.resolve(log(`❌ ${label}: transient network error persisted after ${transientAttempts} attempts; giving up.`));
+          await Promise.resolve(log(`❌ ${label}: transient network error persisted after ${transientAttempts} attempts; giving up. [${formatTransientDiagnostics(description)}]`));
           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 Promise.resolve(log(`⚠️ ${label}: transient network error (attempt ${transientAttempts}/${transientMaxAttempts}), retrying in ${Math.round(waitMs / 1000)}s... [${formatTransientDiagnostics(description)}]`));
         await sleepWithCountdown(waitMs, log);
         continue;
       }
 
+      await Promise.resolve(log(`ℹ️ ${label}: error is not retryable [${formatTransientDiagnostics(description)}]; propagating to caller.`));
       throw error;
     }
   }
@@ -480,7 +470,20 @@ export const wrapDollarWithGhRetry = (dollar, options = {}) => {
       if (i < values.length) preview += String(values[i] ?? '');
     }
     const isGh = /^\s*gh(?:\s|$)/.test(preview);
-    if (!isGh) return dollar(strings, ...values);
+    if (!isGh) {
+      // Issue #2168: "retry for any git/github operation". Network-facing git
+      // commands (`git push`/`fetch`/`pull`/`ls-remote`) get the same treatment
+      // here so every module already using the wrapped `$` is covered without
+      // touching its call sites. Everything else passes straight through.
+      const gitSubcommand = matchGitNetworkCommand(preview);
+      if (gitSubcommand) {
+        return (async () => {
+          const { gitCmdRetry } = await import('./lib.mjs');
+          return gitCmdRetry(() => dollar(strings, ...values), { label: `$git (${gitSubcommand})`, ...options });
+        })();
+      }
+      return dollar(strings, ...values);
+    }
     return ghWithRateLimitRetry(() => dollar(strings, ...values), {
       label: `$gh (${preview.trim().split(/\s+/).slice(0, 3).join(' ')})`,
       ...options,

package/src/hive.mjs

@@ -103,125 +103,10 @@ if (isRunningDirectly) {
     const commandName = process.argv[1] ? process.argv[1].split('/').pop() : '';
     const isLocalScript = commandName.endsWith('.mjs');
     const solveCommand = isLocalScript ? './solve.mjs' : 'solve';
-    /**
-     * Fallback function to fetch issues from organization/user repositories
-     * when search API hits rate limits
-     * @param {string} owner - Organization or user name
-     * @param {string} scope - 'organization' or 'user'
-     * @param {string} monitorTag - Label to filter by (optional)
-     * @param {boolean} allIssues - Whether to fetch all issues or only labeled ones
-     * @returns {Promise<Array>} Array of issues
-     */
-    async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIssues = false) {
-      try {
-        await log(`   🔄 Using repository-by-repository fallback for ${scope}: ${owner}`);
-        // Strategy 1: Try GraphQL approach first (faster but has limitations)
-        // Only try GraphQL for "all issues" mode, not for labeled issues
-        if (fetchAllIssues) {
-          const graphqlResult = await tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage);
-          if (graphqlResult.success) {
-            await log(`   ✅ GraphQL approach successful: ${graphqlResult.issues.length} issues from ${graphqlResult.repoCount} repositories`);
-            return graphqlResult.issues;
-          }
-        }
-        // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
-        await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
-
-        // Get list of ALL repositories using gh api with --paginate (includes isArchived for filtering)
-        let repoListCmd;
-        if (scope === 'organization') {
-          repoListCmd = `gh api orgs/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
-        } else {
-          repoListCmd = `gh api users/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
-        }
-        await log('   📋 Fetching repository list (using --paginate for unlimited pagination)...', { verbose: true });
-        await log(`   🔎 Command: ${repoListCmd}`, { verbose: true });
-        // Add delay for rate limiting
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        // #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()
-          .split('\n')
-          .filter(line => line.trim());
-        const allRepositories = repoLines.map(line => JSON.parse(line));
-        await log(`   📊 Found ${allRepositories.length} repositories`);
-        // Filter repositories to only include those owned by the target user/org
-        const ownedRepositories = allRepositories.filter(repo => {
-          const repoOwner = repo.owner?.login || repo.owner;
-          return repoOwner === owner;
-        });
-        const unownedCount = allRepositories.length - ownedRepositories.length;
-        if (unownedCount > 0) {
-          await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
-        }
-        // Filter out archived repositories from owned repositories
-        const repositories = ownedRepositories.filter(repo => !repo.isArchived);
-        const archivedCount = ownedRepositories.length - repositories.length;
-        if (archivedCount > 0) {
-          await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
-        }
-        await log(`   ✅ Processing ${repositories.length} non-archived repositories owned by ${owner}`);
-        let collectedIssues = [];
-        let processedRepos = 0;
-        // Process repositories in batches to avoid overwhelming the API
-        for (const repo of repositories) {
-          try {
-            const repoName = repo.name;
-            const ownerName = repo.owner?.login || owner;
-            await log(`   🔍 Fetching issues from ${ownerName}/${repoName}...`, { verbose: true });
-            // Build the appropriate issue list command
-            let issueCmd;
-            if (fetchAllIssues) {
-              issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open --json url,title,number,createdAt`;
-            } else {
-              issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open --label "${monitorTag}" --json url,title,number,createdAt`;
-            }
-            // Add delay between repository requests
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            const repoIssues = await fetchAllIssuesWithPagination(issueCmd);
-            // Add repository information to each issue
-            const issuesWithRepo = repoIssues.map(issue => ({
-              ...issue,
-              repository: {
-                name: repoName,
-                owner: { login: ownerName },
-              },
-            }));
-            collectedIssues.push(...issuesWithRepo);
-            processedRepos++;
-            if (issuesWithRepo.length > 0) {
-              await log(`   ✅ Found ${issuesWithRepo.length} issues in ${ownerName}/${repoName}`, { verbose: true });
-            }
-          } catch (repoError) {
-            reportError(repoError, {
-              context: 'fetchIssuesFromRepositories',
-              repo: repo.name,
-              operation: 'fetch_repo_issues',
-            });
-            await log(`   ⚠️  Failed to fetch issues from ${repo.name}: ${cleanErrorMessage(repoError)}`, {
-              verbose: true,
-            });
-            // Continue with other repositories
-          }
-        }
-        await log(`   ✅ Repository fallback complete: ${collectedIssues.length} issues from ${processedRepos}/${repositories.length} repositories`);
-        return collectedIssues;
-      } catch (error) {
-        reportError(error, {
-          context: 'fetchIssuesFromRepositories',
-          owner,
-          scope,
-          operation: 'repository_fallback',
-        });
-        await log(`   ❌ Repository fallback failed: ${cleanErrorMessage(error)}`, { level: 'error' });
-        return [];
-      }
-    }
+    // Repository-by-repository fallback lives in its own module so hive.mjs stays
+    // under the 1350-line early-warning threshold (issue #2175, warning from #1593).
+    const repositoryFallbackLib = await import('./hive.repository-fallback.lib.mjs');
+    const fetchIssuesFromRepositories = repositoryFallbackLib.createRepositoryIssueFetcher({ log, cleanErrorMessage, tryFetchIssuesWithGraphQL, execGhWithRetry, fetchAllIssuesWithPagination, reportError });
     // Configure command line arguments - GitHub URL as positional argument
     const rawArgs = normalizeCliArgs(hideBin(process.argv));
     // Use .parse() instead of .argv to ensure .strict() mode works correctly
@@ -1398,37 +1283,10 @@ if (isRunningDirectly) {
     delegateSignalHandling(true);
     process.on('SIGINT', () => gracefulShutdown('interrupt'));
     process.on('SIGTERM', () => gracefulShutdown('termination'));
-    // Check system resources (disk space and RAM) before starting monitoring (skip in dry-run mode)
-    if (argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) {
-      await log('⏩ Skipping system resource check (dry-run mode or skip-tool-connection-check enabled)', {
-        verbose: true,
-      });
-      await log('⏩ Skipping AI tool connection check (dry-run mode or skip-tool-connection-check enabled)', {
-        verbose: true,
-      });
-    } else {
-      // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
-      // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
-      // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
-      // directly, which skips the log-flushing safeExit path and printed no actionable reason.
-      const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
-      const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
-      if (!startupDiskGuard.ok) {
-        await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
-        await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
-        await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
-      }
-      const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
-      if (!systemCheck.success) {
-        await safeExit(1, 'System resource check failed');
-      }
-      // Validate the selected AI tool connection before starting monitoring with the same model that will be used
-      const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
-      if (!isToolConnected) {
-        await log(`❌ Cannot start monitoring without ${argv.tool || 'claude'} connection`, { level: 'error' });
-        await safeExit(1, 'Error occurred');
-      }
-    }
+    // Pre-flight checks live in hive.startup-checks.lib.mjs so hive.mjs stays under
+    // the 1350-line early-warning threshold (issue #2175, warning from #1593).
+    const startupChecksLib = await import('./hive.startup-checks.lib.mjs');
+    await startupChecksLib.runStartupChecks({ argv, log, safeExit, ensureDiskSpaceForWorker, checkSystem, validateToolConnection, validateClaudeConnection, EXIT_CODE_INSUFFICIENT_DISK_SPACE });
     // Wrap monitor function with Sentry error tracking
     const monitorWithSentry = !argv.sentry ? monitor : withSentry(monitor, 'hive.monitor', 'command');
     // Start monitoring

package/src/hive.repository-fallback.lib.mjs

@@ -0,0 +1,125 @@
+/**
+ * Repository-by-repository issue fetching fallback for the hive.
+ *
+ * Extracted from src/hive.mjs (issue #2175) so the entry point stays under the
+ * 1350-line early-warning threshold that protects concurrent merges (#1593).
+ * The logic is unchanged; it now takes its collaborators as parameters instead
+ * of closing over the dynamically imported bindings in hive.mjs, which also
+ * makes it unit-testable (see tests/hive-repository-fallback-2175.test.mjs).
+ *
+ * Used when GitHub's search API is rate-limited: rather than giving up, every
+ * repository owned by the org/user is listed and queried directly.
+ */
+
+/**
+ * Build the repository-fallback fetcher with its dependencies bound.
+ *
+ * @param {object} deps
+ * @param {Function} deps.log
+ * @param {Function} deps.cleanErrorMessage
+ * @param {Function} deps.tryFetchIssuesWithGraphQL
+ * @param {Function} deps.execGhWithRetry
+ * @param {Function} deps.fetchAllIssuesWithPagination
+ * @param {Function} deps.reportError
+ * @param {(ms: number) => Promise<void>} [deps.sleeper] delay between API calls
+ * @returns {(owner: string, scope: string, monitorTag?: string, fetchAllIssues?: boolean) => Promise<Array>}
+ */
+export function createRepositoryIssueFetcher({ log, cleanErrorMessage, tryFetchIssuesWithGraphQL, execGhWithRetry, fetchAllIssuesWithPagination, reportError, sleeper = ms => new Promise(resolve => setTimeout(resolve, ms)) }) {
+  /**
+   * Fallback function to fetch issues from organization/user repositories
+   * when search API hits rate limits
+   * @param {string} owner - Organization or user name
+   * @param {string} scope - 'organization' or 'user'
+   * @param {string} monitorTag - Label to filter by (optional)
+   * @param {boolean} fetchAllIssues - Whether to fetch all issues or only labeled ones
+   * @returns {Promise<Array>} Array of issues
+   */
+  return async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIssues = false) {
+    try {
+      await log(`   🔄 Using repository-by-repository fallback for ${scope}: ${owner}`);
+      // Strategy 1: Try GraphQL approach first (faster but has limitations)
+      // Only try GraphQL for "all issues" mode, not for labeled issues
+      if (fetchAllIssues) {
+        const graphqlResult = await tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage);
+        if (graphqlResult.success) {
+          await log(`   ✅ GraphQL approach successful: ${graphqlResult.issues.length} issues from ${graphqlResult.repoCount} repositories`);
+          return graphqlResult.issues;
+        }
+      }
+      // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
+      await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
+
+      // Get list of ALL repositories using gh api with --paginate (includes isArchived for filtering)
+      const scopePath = scope === 'organization' ? 'orgs' : 'users';
+      const repoListCmd = `gh api ${scopePath}/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
+      await log('   📋 Fetching repository list (using --paginate for unlimited pagination)...', { verbose: true });
+      await log(`   🔎 Command: ${repoListCmd}`, { verbose: true });
+      // Add delay for rate limiting
+      await sleeper(2000);
+      // #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()
+        .split('\n')
+        .filter(line => line.trim());
+      const allRepositories = repoLines.map(line => JSON.parse(line));
+      await log(`   📊 Found ${allRepositories.length} repositories`);
+      // Filter repositories to only include those owned by the target user/org
+      const ownedRepositories = allRepositories.filter(repo => {
+        const repoOwner = repo.owner?.login || repo.owner;
+        return repoOwner === owner;
+      });
+      const unownedCount = allRepositories.length - ownedRepositories.length;
+      if (unownedCount > 0) {
+        await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
+      }
+      // Filter out archived repositories from owned repositories
+      const repositories = ownedRepositories.filter(repo => !repo.isArchived);
+      const archivedCount = ownedRepositories.length - repositories.length;
+      if (archivedCount > 0) {
+        await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
+      }
+      await log(`   ✅ Processing ${repositories.length} non-archived repositories owned by ${owner}`);
+      const collectedIssues = [];
+      let processedRepos = 0;
+      // Process repositories in batches to avoid overwhelming the API
+      for (const repo of repositories) {
+        try {
+          const repoName = repo.name;
+          const ownerName = repo.owner?.login || owner;
+          await log(`   🔍 Fetching issues from ${ownerName}/${repoName}...`, { verbose: true });
+          // Build the appropriate issue list command
+          const labelFilter = fetchAllIssues ? '' : ` --label "${monitorTag}"`;
+          const issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open${labelFilter} --json url,title,number,createdAt`;
+          // Add delay between repository requests
+          await sleeper(1000);
+          const repoIssues = await fetchAllIssuesWithPagination(issueCmd);
+          // Add repository information to each issue
+          const issuesWithRepo = repoIssues.map(issue => ({
+            ...issue,
+            repository: { name: repoName, owner: { login: ownerName } },
+          }));
+          collectedIssues.push(...issuesWithRepo);
+          processedRepos++;
+          if (issuesWithRepo.length > 0) {
+            await log(`   ✅ Found ${issuesWithRepo.length} issues in ${ownerName}/${repoName}`, { verbose: true });
+          }
+        } catch (repoError) {
+          reportError(repoError, { context: 'fetchIssuesFromRepositories', repo: repo.name, operation: 'fetch_repo_issues' });
+          await log(`   ⚠️  Failed to fetch issues from ${repo.name}: ${cleanErrorMessage(repoError)}`, { verbose: true });
+          // Continue with other repositories
+        }
+      }
+      await log(`   ✅ Repository fallback complete: ${collectedIssues.length} issues from ${processedRepos}/${repositories.length} repositories`);
+      return collectedIssues;
+    } catch (error) {
+      reportError(error, { context: 'fetchIssuesFromRepositories', owner, scope, operation: 'repository_fallback' });
+      await log(`   ❌ Repository fallback failed: ${cleanErrorMessage(error)}`, { level: 'error' });
+      return [];
+    }
+  };
+}

package/src/hive.startup-checks.lib.mjs

@@ -0,0 +1,57 @@
+/**
+ * Pre-flight checks the hive runs before it starts monitoring.
+ *
+ * Extracted from src/hive.mjs (issue #2175) so the entry point stays under the
+ * 1350-line early-warning threshold that protects concurrent merges (#1593).
+ * Behaviour is unchanged; the collaborators that used to be closure bindings in
+ * hive.mjs are parameters, which also makes the sequence unit-testable
+ * (see tests/hive-startup-checks-2175.test.mjs).
+ */
+
+/**
+ * Run the startup checks, exiting through `safeExit` when one fails.
+ *
+ * @param {object} deps
+ * @param {object} deps.argv parsed CLI arguments
+ * @param {Function} deps.log
+ * @param {Function} deps.safeExit
+ * @param {Function} deps.ensureDiskSpaceForWorker
+ * @param {Function} deps.checkSystem
+ * @param {Function} deps.validateToolConnection
+ * @param {Function} deps.validateClaudeConnection
+ * @param {number} deps.EXIT_CODE_INSUFFICIENT_DISK_SPACE
+ * @returns {Promise<{skipped: boolean}>}
+ */
+export async function runStartupChecks({ argv, log, safeExit, ensureDiskSpaceForWorker, checkSystem, validateToolConnection, validateClaudeConnection, EXIT_CODE_INSUFFICIENT_DISK_SPACE }) {
+  if (argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) {
+    await log('⏩ Skipping system resource check (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
+    await log('⏩ Skipping AI tool connection check (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
+    return { skipped: true };
+  }
+
+  // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
+  // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
+  // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
+  // directly, which skips the log-flushing safeExit path and printed no actionable reason.
+  const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
+  const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
+  if (!startupDiskGuard.ok) {
+    await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
+    await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
+    await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
+  }
+
+  const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
+  if (!systemCheck.success) {
+    await safeExit(1, 'System resource check failed');
+  }
+
+  // Validate the selected AI tool connection before starting monitoring with the same model that will be used
+  const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
+  if (!isToolConnected) {
+    await log(`❌ Cannot start monitoring without ${argv.tool || 'claude'} connection`, { level: 'error' });
+    await safeExit(1, 'Error occurred');
+  }
+
+  return { skipped: false };
+}