@link-assistant/hive-mind 1.59.4 → 1.59.6

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

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub API rate-limit detection and retry utilities.
+ *
+ * Issue #1726: Hosted runners hit GitHub's 5,000/hr core API quota and bubble
+ * the failure up as a generic 403/HTTP error. The wrappers in lib.mjs only
+ * recognise transient TCP/TLS faults; rate-limit responses fell through and
+ * crashed callers (or worse, were silently swallowed in the merge subsystem
+ * making it look like "no workflows / no checks" — see
+ * src/github-merge.lib.mjs:getActiveRepoWorkflows in the original log).
+ *
+ * The retry policy required by the issue:
+ *   wait = (resetTimestamp - now) + bufferMs (10 min) + random(jitterMs) (0-5 min)
+ *
+ * `bufferMs` and `jitterMs` already exist in src/config.lib.mjs#limitReset
+ * (added in #1236 for Claude limit waits) so we re-use them rather than
+ * duplicate constants.
+ */
+import { promisify } from 'node:util';
+import { exec as execCb } from 'node:child_process';
+
+import { limitReset, retryLimits } from './config.lib.mjs';
+
+const exec = promisify(execCb);
+
+const RATE_LIMIT_PATTERNS = ['api rate limit exceeded', 'rate limit exceeded', 'you have exceeded a secondary rate limit', 'secondary rate limit', 'abuse detection', 'was submitted too quickly'];
+
+/**
+ * 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.
+ *
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export const isRateLimitError = error => {
+  const text = collectErrorText(error).toLowerCase();
+  if (!text) return false;
+  return RATE_LIMIT_PATTERNS.some(pattern => text.includes(pattern));
+};
+
+/**
+ * Extract a `Date` for when the rate-limit window resets, in priority order:
+ *   1. `X-RateLimit-Reset` header value (Unix epoch seconds) embedded in the
+ *      error text — `gh` prints headers when --include is used and graphql
+ *      surfaces them in the error body.
+ *   2. `Retry-After` header (seconds from now).
+ *   3. None — caller falls back to a polled `gh api rate_limit` lookup.
+ *
+ * @param {unknown} error
+ * @returns {Date|null}
+ */
+export const parseRateLimitReset = error => {
+  const text = collectErrorText(error);
+  if (!text) return null;
+
+  const resetMatch = text.match(/x-ratelimit-reset:\s*(\d+)/i);
+  if (resetMatch) {
+    const epochSeconds = Number(resetMatch[1]);
+    if (Number.isFinite(epochSeconds) && epochSeconds > 0) {
+      return new Date(epochSeconds * 1000);
+    }
+  }
+
+  const retryAfterMatch = text.match(/retry-after:\s*(\d+)/i);
+  if (retryAfterMatch) {
+    const seconds = Number(retryAfterMatch[1]);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return new Date(Date.now() + seconds * 1000);
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Ask `gh api rate_limit` directly when the error didn't carry a reset header.
+ * Returns the most-restrictive (soonest) reset time across the resources we
+ * touch (core, search, graphql) so we don't resume into a still-throttled
+ * bucket.
+ *
+ * @returns {Promise<Date|null>}
+ */
+export const fetchNextRateLimitReset = async () => {
+  try {
+    // eslint-disable-next-line gh-rate-limit/no-direct-gh-exec -- this IS the rate-limit helper; calling itself recursively would loop.
+    const { stdout } = await exec('gh api rate_limit');
+    const data = JSON.parse(stdout);
+    const resources = data?.resources || {};
+    const candidates = [];
+    for (const key of ['core', 'graphql', 'search']) {
+      const r = resources[key];
+      if (r && Number.isFinite(r.reset) && r.remaining === 0) {
+        candidates.push(r.reset);
+      }
+    }
+    if (candidates.length === 0) return null;
+    const soonestEpoch = Math.min(...candidates);
+    return new Date(soonestEpoch * 1000);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Compute the absolute wait deadline that satisfies issue #1726:
+ *   reset + bufferMs (default 10 min) + random(0..jitterMs) (default 0-5 min)
+ *
+ * @param {Date|null} reset
+ * @returns {{ waitMs: number, deadline: Date, reset: Date|null, bufferMs: number, jitterMs: number }}
+ */
+export const computeRateLimitWait = (reset, now = Date.now()) => {
+  const bufferMs = limitReset.bufferMs;
+  const jitterMs = Math.floor(Math.random() * (limitReset.jitterMs + 1));
+  const resetTime = reset instanceof Date ? reset.getTime() : null;
+  const baselineWait = resetTime && resetTime > now ? resetTime - now : 0;
+  const waitMs = baselineWait + bufferMs + jitterMs;
+  return {
+    waitMs,
+    deadline: new Date(now + waitMs),
+    reset: reset || null,
+    bufferMs,
+    jitterMs,
+  };
+};
+
+/**
+ * Sleep with optional periodic countdown notifications.
+ *
+ * @param {number} ms
+ * @param {(msg: string) => Promise<void>|void} [log]
+ */
+const sleepWithCountdown = async (ms, log) => {
+  if (ms <= 0) return;
+  if (!log || ms <= 60_000) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+    return;
+  }
+  let remaining = ms;
+  const timer = setInterval(() => {
+    remaining -= 60_000;
+    if (remaining > 0) {
+      const minutes = Math.round(remaining / 60_000);
+      Promise.resolve(log(`⏳ Rate-limit wait: ${minutes} min remaining...`)).catch(() => {});
+    }
+  }, 60_000);
+  try {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  } finally {
+    clearInterval(timer);
+  }
+};
+
+/**
+ * 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.
+ *
+ * @template T
+ * @param {() => Promise<T>} fn
+ * @param {object} [options]
+ * @param {number} [options.maxAttempts] - hard cap on rate-limit retries (default `retryLimits.maxApiRetries`).
+ * @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 label = options.label || 'gh';
+  const log = options.log || (msg => console.warn(msg));
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    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;
+      }
+
+      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);
+    }
+  }
+  // Unreachable — loop either returns or throws.
+  throw lastError;
+};
+
+/**
+ * Convenience wrapper around child_process.exec that retries on rate-limit
+ * errors. Use it for callers that build a `gh` command string and want the
+ * existing exec-based ergonomics.
+ *
+ * @param {string} command
+ * @param {object} [options] - forwarded to ghWithRateLimitRetry, plus `execOptions`.
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+export const execGhWithRetry = async (command, options = {}) => {
+  const { execOptions, ...retryOptions } = options;
+  return ghWithRateLimitRetry(() => exec(command, execOptions), {
+    label: retryOptions.label || `gh exec (${command.split(/\s+/).slice(0, 3).join(' ')})`,
+    ...retryOptions,
+  });
+};
+
+/**
+ * Wrap a command-stream `$` tagged-template so every `$gh ...` it issues is
+ * retried on rate-limit errors. Returns a callable that delegates to the
+ * underlying `$` for non-`gh` commands and through `ghWithRateLimitRetry` for
+ * `gh ...` commands.
+ *
+ * Usage at the top of a file:
+ *   const { $: rawDollar } = await use('command-stream');
+ *   const $ = wrapDollarWithGhRetry(rawDollar);
+ *
+ * @template T
+ * @param {(strings: TemplateStringsArray, ...values: unknown[]) => Promise<T>} dollar
+ * @param {object} [options] - forwarded to ghWithRateLimitRetry per call.
+ * @returns {(strings: TemplateStringsArray, ...values: unknown[]) => Promise<T>}
+ */
+export const wrapDollarWithGhRetry = (dollar, options = {}) => {
+  const wrapped = (strings, ...values) => {
+    // Reconstruct the literal command for inspection (sufficient — leading
+    // `gh ` is what we care about).
+    let preview = '';
+    for (let i = 0; i < strings.length; i++) {
+      preview += strings[i];
+      if (i < values.length) preview += String(values[i] ?? '');
+    }
+    const isGh = /^\s*gh(?:\s|$)/.test(preview);
+    if (!isGh) return dollar(strings, ...values);
+    return ghWithRateLimitRetry(() => dollar(strings, ...values), {
+      label: `$gh (${preview.trim().split(/\s+/).slice(0, 3).join(' ')})`,
+      ...options,
+    });
+  };
+  // Preserve a reference to the underlying $ for consumers that need it.
+  wrapped.raw = dollar;
+  return wrapped;
+};
+
+export default {
+  isRateLimitError,
+  parseRateLimitReset,
+  fetchNextRateLimitReset,
+  computeRateLimitWait,
+  ghWithRateLimitRetry,
+  execGhWithRetry,
+  wrapDollarWithGhRetry,
+};

package/src/github.batch.lib.mjs

@@ -11,6 +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
 /**
  * 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"

package/src/hive.mjs

@@ -1,6 +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
 const earlyArgs = process.argv.slice(2);
 if (earlyArgs.includes('--version')) {
   const { getVersion } = await import('./version.lib.mjs');
@@ -28,7 +29,6 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
     // Reuse createYargsConfig from shared module to avoid duplication
     const { createYargsConfig } = await import('./hive.config.lib.mjs');
     const helpYargs = createYargsConfig(yargs(rawArgs)).version(false);
-    // Show help and exit
     helpYargs.showHelp();
     process.exit(0);
   } catch (error) {
@@ -1497,4 +1497,4 @@ if (isRunningDirectly) {
     console.error('\nPlease report this issue at: https://github.com/link-assistant/hive-mind/issues');
     process.exit(1);
   }
-} // End of main execution block
+}

package/src/hive.recheck.lib.mjs

@@ -5,6 +5,7 @@ import { log, cleanErrorMessage } from './lib.mjs';
 import { batchCheckPullRequestsForIssues, batchCheckArchivedRepositories } from './github.lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 /**
  * Recheck conditions for an issue right before processing
  * This ensures the issue should still be processed even if conditions changed since queuing

package/src/lib.mjs

@@ -478,12 +478,16 @@ export const isTransientNetworkError = error => {
 /**
  * Retry a GitHub CLI / API operation with exponential backoff on transient network errors.
  * Unlike the generic `retry()`, this function:
- * - Only retries on transient network errors (TCP reset, TLS timeout, etc.)
- * - Immediately rethrows non-transient errors (404, 403, auth failures)
+ * - Retries on transient network errors (TCP reset, TLS timeout, etc.)
+ * - Retries on GitHub API rate-limit errors, sleeping until reset + buffer + jitter
+ *   (issue #1726 — see src/github-rate-limit.lib.mjs)
+ * - Immediately rethrows non-transient errors (404, 403 non-rate-limit, auth failures)
  * - Logs stderr to the log file when a command fails (fixing terminal/log parity)
  *
  * Issue #1536: Most gh commands had no retry logic, causing solve to abort on
  * intermittent network issues.
+ * Issue #1726: Rate limit errors silently surfaced as command failure with no retry,
+ *              causing the merge subsystem to swallow them as "no workflows found".
  *
  * @param {Function} fn - Async function to execute (should call gh CLI or GitHub API)
  * @param {Object} [options] - Options
@@ -496,11 +500,20 @@ export const isTransientNetworkError = error => {
  */
 export const ghRetry = async (fn, options = {}) => {
   const { maxAttempts = 3, delay = 1000, backoff = 2, label = 'gh command' } = options;
+  const { isRateLimitError, parseRateLimitReset, fetchNextRateLimitReset, computeRateLimitWait } = await import('./github-rate-limit.lib.mjs');
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       return await fn();
     } catch (error) {
+      if (isRateLimitError(error) && attempt < maxAttempts) {
+        const reset = parseRateLimitReset(error) || (await fetchNextRateLimitReset());
+        const { waitMs, deadline, bufferMs, jitterMs } = computeRateLimitWait(reset);
+        const resetSummary = reset ? `reset at ${reset.toISOString()}` : 'reset time unknown';
+        await log(`⏳ ${label}: GitHub API rate limit hit (attempt ${attempt}/${maxAttempts}). Waiting ${Math.round(waitMs / 60000)} min (${resetSummary}; buffer ${Math.round(bufferMs / 60000)} min + jitter ${Math.round(jitterMs / 1000)}s) until ${deadline.toISOString()}.`, { level: 'warn' });
+        await sleep(waitMs);
+        continue;
+      }
       if (isTransientNetworkError(error) && attempt < maxAttempts) {
         const waitTime = delay * Math.pow(backoff, attempt - 1);
         await log(`⚠️ ${label}: Network error (attempt ${attempt}/${maxAttempts}), retrying in ${waitTime / 1000}s...`, { level: 'warn' });
@@ -527,6 +540,7 @@ export const ghRetry = async (fn, options = {}) => {
  */
 export const ghCmdRetry = async (cmdFn, options = {}) => {
   const { maxAttempts = 3, delay = 1000, backoff = 2, label = 'gh command' } = options;
+  const { isRateLimitError, parseRateLimitReset, fetchNextRateLimitReset, computeRateLimitWait } = await import('./github-rate-limit.lib.mjs');
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     const result = await cmdFn();
@@ -541,9 +555,21 @@ export const ghCmdRetry = async (cmdFn, options = {}) => {
       return result;
     }
 
-    // Check if this is a transient network error worth retrying
     const combinedOutput = (result.stdout?.toString() || '') + ' ' + (result.stderr?.toString() || '');
-    if (isTransientNetworkError({ message: combinedOutput }) && attempt < maxAttempts) {
+    const errorLike = { message: combinedOutput, stdout: result.stdout, stderr: result.stderr };
+
+    // Issue #1726: rate-limit errors deserve a long, deterministic wait.
+    if (isRateLimitError(errorLike) && attempt < maxAttempts) {
+      const reset = parseRateLimitReset(errorLike) || (await fetchNextRateLimitReset());
+      const { waitMs, deadline, bufferMs, jitterMs } = computeRateLimitWait(reset);
+      const resetSummary = reset ? `reset at ${reset.toISOString()}` : 'reset time unknown';
+      await log(`⏳ ${label}: GitHub API rate limit hit (attempt ${attempt}/${maxAttempts}). Waiting ${Math.round(waitMs / 60000)} min (${resetSummary}; buffer ${Math.round(bufferMs / 60000)} min + jitter ${Math.round(jitterMs / 1000)}s) until ${deadline.toISOString()}.`, { level: 'warn' });
+      await sleep(waitMs);
+      continue;
+    }
+
+    // Check if this is a transient network error worth retrying
+    if (isTransientNetworkError(errorLike) && attempt < maxAttempts) {
       const waitTime = delay * Math.pow(backoff, attempt - 1);
       await log(`⚠️ ${label}: Network error (attempt ${attempt}/${maxAttempts}), retrying in ${waitTime / 1000}s...`, { level: 'warn' });
       await sleep(waitTime);

package/src/limits.lib.mjs

@@ -12,6 +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
 // Initialize dayjs plugins
 dayjs.extend(utc);
 

package/src/protect-branch.mjs

@@ -18,8 +18,9 @@
 const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Parse command line arguments
 const args = process.argv.slice(2);
 

package/src/queue-config.lib.mjs

@@ -88,7 +88,7 @@ function normalizeMetricName(name) {
  *   (cpu (65% enqueue))
  *   (claude-5-hour (65% dequeue-one-at-a-time))
  *   (claude-weekly (97% dequeue-one-at-a-time))
- *   (github-api (75% enqueue))
+ *   (github-api (50% enqueue))
  * )
  * ```
  *
@@ -253,7 +253,11 @@ export const QUEUE_CONFIG = {
     claudeWeekly: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time'),
     codex5Hour: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time'),
     codexWeekly: getThresholdConfig('codexWeekly', 'HIVE_MIND_CODEX_WEEKLY_THRESHOLD', 'HIVE_MIND_CODEX_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time'),
-    githubApi: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue'),
+    // Issue #1726: lowered default from 0.75 to 0.50 to start backing off earlier
+    // and leave a wider safety margin before the hard 5,000/hr ceiling. Hosted
+    // runners hit the ceiling repeatedly with the 75% setting (see
+    // docs/case-studies/issue-1726).
+    githubApi: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.5, 'enqueue'),
   },
 
   // Legacy flat threshold values for backward compatibility
@@ -265,7 +269,7 @@ export const QUEUE_CONFIG = {
   CLAUDE_WEEKLY_THRESHOLD: getThresholdConfig('claudeWeekly', 'HIVE_MIND_CLAUDE_WEEKLY_THRESHOLD', 'HIVE_MIND_CLAUDE_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time').value,
   CODEX_5_HOUR_SESSION_THRESHOLD: getThresholdConfig('codex5Hour', 'HIVE_MIND_CODEX_5_HOUR_SESSION_THRESHOLD', 'HIVE_MIND_CODEX_5_HOUR_SESSION_STRATEGY', 0.65, 'dequeue-one-at-a-time').value,
   CODEX_WEEKLY_THRESHOLD: getThresholdConfig('codexWeekly', 'HIVE_MIND_CODEX_WEEKLY_THRESHOLD', 'HIVE_MIND_CODEX_WEEKLY_STRATEGY', 0.97, 'dequeue-one-at-a-time').value,
-  GITHUB_API_THRESHOLD: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.75, 'enqueue').value,
+  GITHUB_API_THRESHOLD: getThresholdConfig('githubApi', 'HIVE_MIND_GITHUB_API_THRESHOLD', 'HIVE_MIND_GITHUB_API_STRATEGY', 0.5, 'enqueue').value,
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process

package/src/review.mjs

@@ -35,8 +35,9 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
 const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 const yargs = (await use('yargs@latest')).default;
 const os = (await use('os')).default;
 const path = (await use('path')).default;

package/src/reviewers-hive.mjs

@@ -4,8 +4,9 @@
 const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 const yargs = (await use('yargs@latest')).default;
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;

package/src/solve.accept-invite.lib.mjs

@@ -16,8 +16,14 @@
 
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
+import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
 
-const exec = promisify(execCallback);
+const execRaw = promisify(execCallback);
+// Issue #1726: rate-limit safe gh wrapper.
+const exec = (cmd, opts) =>
+  ghWithRateLimitRetry(() => execRaw(cmd, opts), {
+    label: `gh exec (${cmd.split(/\s+/).slice(0, 3).join(' ')})`,
+  });
 
 // Import retry utility (issue #1536)
 const lib = await import('./lib.mjs');

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

@@ -13,8 +13,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
 const { log, cleanErrorMessage } = lib;

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

@@ -18,8 +18,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
 const { log } = lib;

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

@@ -21,8 +21,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
 const { log, formatAligned } = lib;

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

@@ -17,8 +17,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
 const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;

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

@@ -5,6 +5,7 @@
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
 
+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

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

@@ -9,6 +9,7 @@
 // Import Sentry integration
 import { reportError } from './sentry.lib.mjs';
 
+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 handleBranchCheckoutError({ branchName, prNumber, errorOutput, issueUrl, owner, repo, tempDir, argv, formatAligned, log, $ }) {
   // Check if this is a PR from a fork
   let isForkPR = false;

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

@@ -5,6 +5,7 @@
 // Import exit handler
 import { safeExit } from './exit-handler.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 Sentry integration
 import { reportError } from './sentry.lib.mjs';
 

package/src/solve.execution.lib.mjs

@@ -12,8 +12,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 const os = (await use('os')).default;
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;

package/src/solve.feedback.lib.mjs

@@ -6,6 +6,7 @@
 // Import Sentry integration
 import { reportError } from './sentry.lib.mjs';
 
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 export const detectAndCountFeedback = async params => {
   const { prNumber, branchName, owner, repo, issueNumber, isContinueMode, argv, mergeStateStatus, prState, workStartTime, log, formatAligned, cleanErrorMessage, $ } = params;
 

package/src/solve.mjs

@@ -7,7 +7,9 @@ await handleSolveEarlyExit(earlyArgs);
 
 const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
 globalThis.use = use;
-const { $ } = await use('command-stream');
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 const config = await import('./solve.config.lib.mjs');
 const { initializeConfig, parseArguments } = config;
 // Import Sentry integration

package/src/solve.preparation.lib.mjs

@@ -3,6 +3,7 @@
  * Handles timestamp collection, feedback detection, and pre-execution checks
  */
 
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 // Import feedback detection functionality
 const feedback = await import('./solve.feedback.lib.mjs');
 const { detectAndCountFeedback } = feedback;

package/src/solve.progress-monitoring.lib.mjs

@@ -28,6 +28,7 @@
 // comment is excluded from --auto-attach-solution-summary's AI-comment check.
 import { LIVE_PROGRESS_SECTION_START_MARKER, LIVE_PROGRESS_SECTION_END_MARKER, postTrackedCommentFromFile, trackToolCommentId } from './tool-comments.lib.mjs';
 
+import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
 /**
  * Configuration constants for progress monitoring
  */

package/src/solve.repository.lib.mjs

@@ -11,9 +11,9 @@ if (typeof globalThis.use === 'undefined') {
 }
 const use = globalThis.use;
 
-// Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+// Use command-stream for consistent $ behavior; wrap with rate-limit retry (#1726)
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry((await use('command-stream')).$);
 const os = (await use('os')).default;
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;

package/src/solve.restart-shared.lib.mjs

@@ -20,8 +20,9 @@ if (typeof globalThis.use === 'undefined') {
 const use = globalThis.use;
 
 // Use command-stream for consistent $ behavior across runtimes
-const { $ } = await use('command-stream');
-
+const { $: __rawDollar$ } = await use('command-stream');
+const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import path and fs for cleanup operations
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;