@link-assistant/hive-mind 2.13.4 → 2.14.0

package/src/solve.mode.lib.mjs

@@ -0,0 +1,191 @@
+/**
+ * Resolve which mode solve.mjs is running in and collect the pull request /
+ * issue facts that mode implies.
+ *
+ * Three entry shapes converge here:
+ *   - `--auto-continue` on an issue URL, which may find an existing pull
+ *     request (or just a branch left behind by an earlier run);
+ *   - a pull request URL, whose head branch and linked issue are read from the
+ *     API;
+ *   - a plain issue URL, which is the traditional mode.
+ *
+ * Fork detection is shared by the first two: a pull request whose head
+ * repository owner differs from the upstream owner puts solve in fork mode,
+ * unless the upstream is private and the user has write access (issue #1716),
+ * in which case working directly on the upstream is both possible and safer.
+ *
+ * Extracted from solve.mjs (issue #2175) so that file stays under the
+ * 1350-line early-warning threshold of the CI file-headroom check (long files
+ * cause concurrent PR merge conflicts — issue #1593). Behaviour is unchanged,
+ * including the `global.createdPR` assignments the error handlers read.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2175
+ */
+
+/**
+ * @param {object} deps every collaborator solve.mjs already has in scope
+ * @returns {Promise<{issueNumber: number|undefined, prNumber: number|undefined, prBranch: string|undefined, mergeStateStatus: string|undefined, prState: string|undefined, forkOwner: string|null, forkRepoName: string|null, isContinueMode: boolean}>}
+ */
+export async function resolveSolveMode({ argv, owner, repo, urlNumber, issueUrl, isIssueUrl, isPrUrl, skipForkForPrivateUpstream, shouldAttachLogs, log, safeExit, githubLib, processAutoContinueForIssue, handleMaintainerForkAccess, extractLinkedIssueNumber, reportError, cleanErrorMessage }) {
+  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 {
+        // Issue #2175: routed through githubLib.ghPrView (the same helper the
+        // pull-request-URL branch below uses) instead of a direct `$` call to
+        // `gh`, so the request goes through the rate-limit-safe wrapper.
+        const prCheckResult = await githubLib.ghPrView({ prNumber, owner, repo, jsonFields: 'headRepositoryOwner,headRepository,mergeStateStatus,state' });
+        if (prCheckResult.code === 0 && prCheckResult.data) {
+          const prCheckData = prCheckResult.data;
+          // 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}`);
+  }
+  return { issueNumber, prNumber, prBranch, mergeStateStatus, prState, forkOwner, forkRepoName, isContinueMode };
+}

package/src/task.config.lib.mjs

@@ -63,6 +63,11 @@ export const createYargsConfig = yargsInstance =>
       choices: ['screen', 'none', 'docker'],
       default: 'docker',
     })
+    .option('use-router', {
+      type: 'boolean',
+      description: '[EXPERIMENTAL] Route model traffic through the hive-mind-router sidecar instead of mounting AI credentials into the task container (issue #2164)',
+      default: false,
+    })
     .option('screen-name', {
       type: 'string',
       description: 'Screen session name when --isolation screen is used',

package/src/task.mjs

@@ -42,6 +42,7 @@ if (earlyArgs.length === 0 || earlyArgs.includes('--help') || earlyArgs.includes
   console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent, qwen, gemini) [default: claude]');
   console.log('  --model, -m        Model to use');
   console.log('  --isolation        agent-commander isolation mode [default: docker]');
+  console.log('  --use-router       [EXPERIMENTAL] Route model traffic through the hive-mind-router sidecar (issue #2164)');
   console.log('  --dry-run          Print split output without creating GitHub issues');
   console.log('  --verbose, -v      Enable verbose logging');
   console.log('  --output-format    Output format (text or json) [default: text]');

package/src/telegram-bot.mjs

@@ -255,6 +255,7 @@ const { createHeartbeat, resumeSessionsOnLaunch, createShutdownHandler } = await
 const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
 const { startFormalAiMaintenance } = await import('./formal-ai-maintenance.lib.mjs');
+const { startRouterMaintenance } = await import('./router-maintenance.lib.mjs');
 // Initialize Sentry for error tracking
 await initializeSentry({
   debug: VERBOSE,
@@ -1198,6 +1199,7 @@ if (VERBOSE) {
 const launchAbortController = new AbortController();
 let sessionMonitoringTimer = null;
 let formalAiMaintenance = null;
+let routerMaintenance = null;
 let launchAnnouncementShown = false;
 
 function startSessionMonitoringOnce() {
@@ -1220,6 +1222,20 @@ function startFormalAiMaintenanceOnce() {
   });
 }
 
+// Issue #2164 (R5): the router sidecar must only run while at least one task
+// uses it. A task that finishes releases its own lease, but a killed task or a
+// host reboot leaves one behind — this tick reconciles those against Docker and
+// stops an idle router. The audit data volume is never removed.
+function startRouterMaintenanceOnce() {
+  if (routerMaintenance) return;
+  routerMaintenance = startRouterMaintenance({
+    verbose: VERBOSE,
+    log: async message => {
+      console.log(message);
+    },
+  });
+}
+
 // Issue #1927 (requirements #3/#4): a periodic timestamped heartbeat so the "last
 // time the bot was alive" is always discoverable from the log. The heartbeat
 // logic lives in bot-lifecycle.lib.mjs so it can be unit tested.
@@ -1240,6 +1256,7 @@ async function onBotLaunched() {
 
   startSessionMonitoringOnce();
   startFormalAiMaintenanceOnce();
+  startRouterMaintenanceOnce();
   heartbeat.start();
   if (VERBOSE) {
     console.log('[VERBOSE] Bot launched successfully');
@@ -1334,6 +1351,7 @@ const handleShutdownSignal = createShutdownHandler({
     launchAbortController.abort();
     if (sessionMonitoringTimer) clearInterval(sessionMonitoringTimer);
     formalAiMaintenance?.stop();
+    routerMaintenance?.stop();
     heartbeat.stop();
     stopSolveQueue();
   },

package/src/telegram-solve-queue.lib.mjs

@@ -9,7 +9,7 @@
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1041
  */
-import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
+import { getLimitCache } from './limits.lib.mjs';
 export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
 import { collectExecutingItems, formatDuration, formatQueueToolSection, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems, groupQueueItemsByTool, reportDequeueDecision } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
@@ -20,6 +20,8 @@ import { canonicalizeGitHubUrl as canonicalizeQueueUrl } from './github-url-pars
 import { t } from './i18n.lib.mjs';
 import { safeEditMessageText } from './telegram-safe-reply.lib.mjs';
 import { lt } from './limits-i18n.lib.mjs';
+// Issue #2175: throttling decisions live in their own module to keep this file under the 1350-line warning threshold.
+import { checkApiLimits as checkApiLimitsImpl, checkSystemResources as checkSystemResourcesImpl, getLocale } from './telegram-solve-queue.throttling.lib.mjs';
 export const QueueItemStatus = {
   QUEUED: 'queued',
   WAITING: 'waiting',
@@ -28,13 +30,6 @@ export const QueueItemStatus = {
   FAILED: 'failed',
   CANCELLED: 'cancelled',
 };
-function getLocale(options = {}) {
-  if (typeof options === 'string') return options;
-  return options?.locale || null;
-}
-function appendWaitingForCurrentCommand(reason, locale) {
-  return `${reason} (${lt('queue_waiting_current_command', {}, { locale })})`;
-}
 function appendRemainingDuration(reason, ms, locale) {
   return `${reason} (${lt('remaining', { duration: formatDuration(ms, { locale }) }, { locale })})`;
 }
@@ -652,282 +647,34 @@ export class SolveQueue {
     };
   }
   /**
-   * Check system resources (RAM, CPU, disk) using cached values
-   *
-   * Uses 5-minute load average for CPU instead of instantaneous usage.
-   * This provides a more stable metric that isn't affected by brief spikes
-   * during claude process startup.
-   *
-   * Resource threshold modes are now configurable via HIVE_MIND_QUEUE_CONFIG:
-   * - 'reject': Immediately reject the command, no queueing
-   * - 'enqueue': Block all commands unconditionally until metric drops
-   * - 'dequeue-one-at-a-time': Allow one command when above threshold
+   * Check system resources (RAM, CPU, disk) using cached values.
    *
-   * Default strategies:
-   * - RAM: enqueue
-   * - CPU: enqueue
-   * - DISK: enqueue (waits until disk drops below the threshold)
+   * Issue #2175: the implementation lives in
+   * telegram-solve-queue.throttling.lib.mjs so this file stays under the
+   * 1350-line early-warning threshold (issue #1593).
    *
-   * See: https://github.com/link-assistant/hive-mind/issues/1155
-   * See: https://github.com/link-assistant/hive-mind/issues/1253
-   * See: https://github.com/link-assistant/hive-mind/issues/1981
-   *
-   * @param {number} totalProcessing - Total processing count (queue + external claude processes)
+   * @param {number} totalProcessing - Total processing count (queue + external tool processes)
+   * @param {object} [options]
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
   async checkSystemResources(totalProcessing = 0, options = {}) {
-    const locale = getLocale(options);
-    const reasons = [];
-    let oneAtATime = false;
-    let rejected = false;
-    let rejectReason = null;
-    // Check RAM (using cached value)
-    const memResult = await getCachedMemoryInfo(this.verbose);
-    if (memResult.success) {
-      const usedRatio = memResult.memory.usedPercentage / 100;
-      if (usedRatio >= QUEUE_CONFIG.thresholds.ram.value) {
-        const reason = formatWaitingReason('ram', memResult.memory.usedPercentage, QUEUE_CONFIG.thresholds.ram.value, { locale });
-        const strategy = QUEUE_CONFIG.thresholds.ram.strategy;
-        this.recordThrottle(`ram_${strategy}`);
-        if (strategy === 'reject') {
-          rejected = true;
-          rejectReason = reason;
-        } else if (strategy === 'dequeue-one-at-a-time') {
-          oneAtATime = true;
-          if (totalProcessing > 0) {
-            reasons.push(appendWaitingForCurrentCommand(reason, locale));
-          }
-        } else {
-          // 'enqueue' - block unconditionally
-          reasons.push(reason);
-        }
-      }
-    }
-    // Check CPU using 5-minute load average (more stable than 1-minute)
-    const cpuResult = await getCachedCpuInfo(this.verbose);
-    if (cpuResult.success) {
-      // Use loadAvg5 (5-minute average) instead of usagePercentage (1-minute based)
-      // This provides a more stable metric that isn't affected by transient spikes
-      const loadAvg5 = cpuResult.cpuLoad.loadAvg5;
-      const cpuCount = cpuResult.cpuLoad.cpuCount;
-      // Calculate usage ratio: loadAvg5 / cpuCount
-      // Load average of 1.0 per CPU = 100% utilization
-      const usageRatio = loadAvg5 / cpuCount;
-      const usagePercent = Math.min(100, Math.round(usageRatio * 100));
-      if (this.verbose) {
-        this.log(`CPU 5m load avg: ${loadAvg5.toFixed(2)}, cpus: ${cpuCount}, usage: ${usagePercent}%`);
-      }
-      if (usageRatio >= QUEUE_CONFIG.thresholds.cpu.value) {
-        const reason = formatWaitingReason('cpu', usagePercent, QUEUE_CONFIG.thresholds.cpu.value, { locale });
-        const strategy = QUEUE_CONFIG.thresholds.cpu.strategy;
-        this.recordThrottle(`cpu_${strategy}`);
-        if (strategy === 'reject') {
-          rejected = true;
-          rejectReason = reason;
-        } else if (strategy === 'dequeue-one-at-a-time') {
-          oneAtATime = true;
-          if (totalProcessing > 0) {
-            reasons.push(appendWaitingForCurrentCommand(reason, locale));
-          }
-        } else {
-          // 'enqueue' - block unconditionally
-          reasons.push(reason);
-        }
-      }
-    }
-    // Check disk space (using cached value)
-    // Default strategy changed to 'reject' because queue is lost on restart anyway
-    // See: https://github.com/link-assistant/hive-mind/issues/1253
-    const diskResult = await getCachedDiskInfo(this.verbose);
-    if (diskResult.success) {
-      // Calculate usage from free percentage
-      const usedPercent = 100 - diskResult.diskSpace.freePercentage;
-      const usedRatio = usedPercent / 100;
-      if (usedRatio >= QUEUE_CONFIG.thresholds.disk.value) {
-        const reason = formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.thresholds.disk.value, { locale });
-        const strategy = QUEUE_CONFIG.thresholds.disk.strategy;
-        this.recordThrottle(`disk_${strategy}`);
-        if (strategy === 'reject') {
-          rejected = true;
-          rejectReason = reason;
-        } else if (strategy === 'dequeue-one-at-a-time') {
-          oneAtATime = true;
-          if (totalProcessing > 0) {
-            reasons.push(appendWaitingForCurrentCommand(reason, locale));
-          }
-        } else {
-          // 'enqueue' - block unconditionally
-          reasons.push(reason);
-        }
-      }
-    }
-    return { ok: reasons.length === 0 && !rejected, reasons, oneAtATime, rejected, rejectReason };
+    return checkSystemResourcesImpl(this, totalProcessing, options);
   }
   /**
-   * Check API limits (Claude, GitHub) using cached values
+   * Check API limits (Claude, Codex, GitHub) using cached values.
    *
-   * Logic per issue #1133:
-   * - CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD use one-at-a-time mode:
-   *   when above threshold, allow exactly one command, block if claudeProcessing > 0
-   * - GitHub threshold blocks unconditionally when exceeded (ultimate restriction)
+   * Issue #2175: the implementation lives in
+   * telegram-solve-queue.throttling.lib.mjs so this file stays under the
+   * 1350-line early-warning threshold (issue #1593).
    *
-   * Logic per issue #1159:
-   * - When tool is 'agent', 'gemini', or 'qwen', skip Claude-specific limits entirely since these tools use
-   *   different rate limiting backends. Only system resources and GitHub limits apply.
-   * - For Claude limits, only count Claude-specific processing items, not agent/codex/gemini/qwen items.
-   *   This allows non-Claude tasks to run in parallel even when Claude limits are reached.
-   *
-   * Logic per issue #1253:
-   * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
-   * - Configuration via HIVE_MIND_QUEUE_CONFIG or individual env vars
-   *
-   * @param {boolean} hasRunningToolProcess - Whether matching tool processes are running (from pgrep)
-   * @param {number} toolProcessingCount - Count of matching tool items being processed in queue
-   * @param {string} tool - The tool being used ('claude', 'agent', 'codex', 'gemini', 'qwen', etc.)
+   * @param {boolean} hasRunningToolProcess
+   * @param {number} toolProcessingCount
+   * @param {string} tool
+   * @param {object} [options]
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
   async checkApiLimits(hasRunningToolProcess = false, toolProcessingCount = 0, tool = 'claude', options = {}) {
-    const locale = getLocale(options);
-    const reasons = [];
-    let oneAtATime = false;
-    let rejected = false;
-    let rejectReason = null;
-    // Apply Claude-specific limits only when tool is 'claude'
-    // Other tools (like 'agent', 'gemini', and 'qwen') use different rate limiting backends and are not
-    // affected by Claude API limits (5-hour session, weekly limits)
-    // See: https://github.com/link-assistant/hive-mind/issues/1159
-    const applyClaudeLimits = tool === 'claude';
-    const applyCodexLimits = tool === 'codex';
-    const totalToolProcessing = toolProcessingCount + (hasRunningToolProcess ? 1 : 0);
-    // Check Claude limits (using cached value)
-    // Only applied when tool is 'claude'
-    if (applyClaudeLimits) {
-      const claudeResult = await getCachedClaudeLimits(this.verbose);
-      if (claudeResult.success) {
-        const sessionPercent = claudeResult.usage.currentSession.percentage;
-        const weeklyPercent = claudeResult.usage.allModels.percentage;
-        // Session limit (5-hour)
-        // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_CLAUDE_5_HOUR_SESSION_STRATEGY
-        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159, #1253
-        if (sessionPercent !== null) {
-          const sessionRatio = sessionPercent / 100;
-          if (sessionRatio >= QUEUE_CONFIG.thresholds.claude5Hour.value) {
-            const reason = formatWaitingReason('claude_5_hour_session', sessionPercent, QUEUE_CONFIG.thresholds.claude5Hour.value, { locale });
-            const strategy = QUEUE_CONFIG.thresholds.claude5Hour.strategy;
-            this.recordThrottle(sessionRatio >= 1.0 ? 'claude_5_hour_session_100' : `claude_5_hour_session_${strategy}`);
-            if (strategy === 'reject') {
-              rejected = true;
-              rejectReason = reason;
-            } else if (strategy === 'dequeue-one-at-a-time') {
-              oneAtATime = true;
-              if (totalToolProcessing > 0) {
-                reasons.push(appendWaitingForCurrentCommand(reason, locale));
-              }
-            } else {
-              // 'enqueue' - block unconditionally
-              reasons.push(reason);
-            }
-          }
-        }
-        // Weekly limit
-        // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_CLAUDE_WEEKLY_STRATEGY
-        // See: https://github.com/link-assistant/hive-mind/issues/1133, #1159, #1253
-        if (weeklyPercent !== null) {
-          const weeklyRatio = weeklyPercent / 100;
-          if (weeklyRatio >= QUEUE_CONFIG.thresholds.claudeWeekly.value) {
-            const reason = formatWaitingReason('claude_weekly', weeklyPercent, QUEUE_CONFIG.thresholds.claudeWeekly.value, { locale });
-            const strategy = QUEUE_CONFIG.thresholds.claudeWeekly.strategy;
-            this.recordThrottle(weeklyRatio >= 1.0 ? 'claude_weekly_100' : `claude_weekly_${strategy}`);
-            if (strategy === 'reject') {
-              rejected = true;
-              rejectReason = reason;
-            } else if (strategy === 'dequeue-one-at-a-time') {
-              oneAtATime = true;
-              if (totalToolProcessing > 0) {
-                reasons.push(appendWaitingForCurrentCommand(reason, locale));
-              }
-            } else {
-              // 'enqueue' - block unconditionally
-              reasons.push(reason);
-            }
-          }
-        }
-      }
-    } else if (applyCodexLimits) {
-      const codexResult = await getCachedCodexLimits(this.verbose);
-      if (codexResult.success) {
-        const sessionPercent = codexResult.usage.currentSession.percentage;
-        const weeklyPercent = codexResult.usage.allModels.percentage;
-        if (sessionPercent !== null) {
-          const sessionRatio = sessionPercent / 100;
-          if (sessionRatio >= QUEUE_CONFIG.thresholds.codex5Hour.value) {
-            const reason = formatWaitingReason('codex_5_hour_session', sessionPercent, QUEUE_CONFIG.thresholds.codex5Hour.value, { locale });
-            const strategy = QUEUE_CONFIG.thresholds.codex5Hour.strategy;
-            this.recordThrottle(sessionRatio >= 1.0 ? 'codex_5_hour_session_100' : `codex_5_hour_session_${strategy}`);
-            if (strategy === 'reject') {
-              rejected = true;
-              rejectReason = reason;
-            } else if (strategy === 'dequeue-one-at-a-time') {
-              oneAtATime = true;
-              if (totalToolProcessing > 0) {
-                reasons.push(appendWaitingForCurrentCommand(reason, locale));
-              }
-            } else {
-              reasons.push(reason);
-            }
-          }
-        }
-        if (weeklyPercent !== null) {
-          const weeklyRatio = weeklyPercent / 100;
-          if (weeklyRatio >= QUEUE_CONFIG.thresholds.codexWeekly.value) {
-            const reason = formatWaitingReason('codex_weekly', weeklyPercent, QUEUE_CONFIG.thresholds.codexWeekly.value, { locale });
-            const strategy = QUEUE_CONFIG.thresholds.codexWeekly.strategy;
-            this.recordThrottle(weeklyRatio >= 1.0 ? 'codex_weekly_100' : `codex_weekly_${strategy}`);
-            if (strategy === 'reject') {
-              rejected = true;
-              rejectReason = reason;
-            } else if (strategy === 'dequeue-one-at-a-time') {
-              oneAtATime = true;
-              if (totalToolProcessing > 0) {
-                reasons.push(appendWaitingForCurrentCommand(reason, locale));
-              }
-            } else {
-              reasons.push(reason);
-            }
-          }
-        }
-      }
-    } else if (this.verbose) {
-      this.log(`Claude limits not applied for --tool ${tool}`);
-    }
-    // Check GitHub limits when the active tool already has a running process.
-    // This keeps the queue behavior aligned with the existing one-at-a-time throttling model.
-    // Configurable strategy via HIVE_MIND_QUEUE_CONFIG or HIVE_MIND_GITHUB_API_STRATEGY
-    if (hasRunningToolProcess) {
-      const githubResult = await getCachedGitHubLimits(this.verbose);
-      if (githubResult.success) {
-        const usedPercent = githubResult.githubRateLimit.usedPercentage;
-        const usedRatio = usedPercent / 100;
-        if (usedRatio >= QUEUE_CONFIG.thresholds.githubApi.value) {
-          const reason = formatWaitingReason('github', usedPercent, QUEUE_CONFIG.thresholds.githubApi.value, { locale });
-          const strategy = QUEUE_CONFIG.thresholds.githubApi.strategy;
-          this.recordThrottle(usedRatio >= 1.0 ? 'github_100' : `github_${strategy}`);
-          if (strategy === 'reject') {
-            rejected = true;
-            rejectReason = reason;
-          } else if (strategy === 'dequeue-one-at-a-time') {
-            oneAtATime = true;
-            if (totalToolProcessing > 0) {
-              reasons.push(appendWaitingForCurrentCommand(reason, locale));
-            }
-          } else {
-            // 'enqueue' - block unconditionally
-            reasons.push(reason);
-          }
-        }
-      }
-    }
-    return { ok: reasons.length === 0 && !rejected, reasons, oneAtATime, rejected, rejectReason };
+    return checkApiLimitsImpl(this, hasRunningToolProcess, toolProcessingCount, tool, options);
   }
   /**
    * Record a throttle event for statistics