@link-assistant/hive-mind 1.62.1 → 1.64.0

package/src/solve.mjs

@@ -89,10 +89,18 @@ setupStdioLogInterceptor(); // Issue #1549: capture ALL terminal output in log f
 
 // Early logs go to cwd; custom log dir takes effect after argv is parsed
 // Conditionally import tool-specific functions after argv is parsed
+// If --use-agent-commander is enabled, use agent-commander's checkForUncommittedChanges
 let checkForUncommittedChanges;
-if (argv.tool === 'opencode') {
+let agentCommanderLib = null;
+if (argv.useAgentCommander) {
+  agentCommanderLib = await import('./agent-commander.lib.mjs');
+  checkForUncommittedChanges = agentCommanderLib.checkForUncommittedChanges;
+} else if (argv.tool === 'opencode') {
   const opencodeLib = await import('./opencode.lib.mjs');
   checkForUncommittedChanges = opencodeLib.checkForUncommittedChanges;
+} else if (argv.tool === 'gemini') {
+  const geminiLib = await import('./gemini.lib.mjs');
+  checkForUncommittedChanges = geminiLib.checkForUncommittedChanges;
 } else if (argv.tool === 'codex') {
   const codexLib = await import('./codex.lib.mjs');
   checkForUncommittedChanges = codexLib.checkForUncommittedChanges;
@@ -664,73 +672,26 @@ try {
 
   // Execute tool command with all prompts and settings
   let toolResult;
-  if (argv.tool === 'opencode') {
-    const opencodeLib = await import('./opencode.lib.mjs');
-    const { executeOpenCode, checkPlaywrightMcpAvailability: checkOpenCodePlaywrightMcp } = opencodeLib;
-    const opencodePath = process.env.OPENCODE_PATH || 'opencode';
-    await resolvePlaywrightMcp(checkOpenCodePlaywrightMcp);
 
-    toolResult = await executeOpenCode({
-      issueUrl,
-      issueNumber,
-      prNumber,
-      prUrl,
-      branchName,
-      tempDir,
-      workspaceTmpDir,
-      isContinueMode,
-      mergeStateStatus,
-      forkedRepo,
-      feedbackLines,
-      forkActionsUrl,
-      owner,
-      repo,
-      argv,
-      log,
-      setLogFile,
-      getLogFile,
-      formatAligned,
-      getResourceSnapshot,
-      opencodePath,
-      $,
-    });
-  } else if (argv.tool === 'codex') {
-    const codexLib = await import('./codex.lib.mjs');
-    const { executeCodex, checkPlaywrightMcpAvailability } = codexLib;
-    const codexPath = process.env.CODEX_PATH || 'codex';
-    await resolvePlaywrightMcp(checkPlaywrightMcpAvailability);
+  // If --use-agent-commander is enabled, use agent-commander for all tools
+  if (argv.useAgentCommander) {
+    // Ensure agent-commander is available
+    if (!agentCommanderLib) {
+      agentCommanderLib = await import('./agent-commander.lib.mjs');
+    }
 
-    toolResult = await executeCodex({
-      issueUrl,
-      issueNumber,
-      prNumber,
-      prUrl,
-      branchName,
-      tempDir,
-      workspaceTmpDir,
-      isContinueMode,
-      mergeStateStatus,
-      forkedRepo,
-      feedbackLines,
-      forkActionsUrl,
-      owner,
-      repo,
-      argv,
-      log,
-      setLogFile,
-      getLogFile,
-      formatAligned,
-      getResourceSnapshot,
-      codexPath,
-      $,
-    });
-  } else if (argv.tool === 'agent') {
-    const agentLib = await import('./agent.lib.mjs');
-    const { executeAgent, checkPlaywrightMcpAvailability: checkAgentPlaywrightMcp } = agentLib;
-    const agentPath = process.env.AGENT_PATH || 'agent';
-    await resolvePlaywrightMcp(checkAgentPlaywrightMcp);
+    const isAvailable = await agentCommanderLib.isAgentCommanderAvailable();
+    if (!isAvailable) {
+      await log('\n[agent-commander] agent-commander is not installed.', { level: 'error' });
+      await log('   Install it with: npm install agent-commander', { level: 'error' });
+      await log('   Or remove the --use-agent-commander flag to use embedded tool logic.', { level: 'error' });
+      await safeExit(1, 'agent-commander not available');
+    }
+
+    await log(`\n[agent-commander] Using agent-commander for ${argv.tool || 'claude'} execution`);
+    await agentCommanderLib.resolvePlaywrightMcpForAgentCommander({ argv, log, tool: argv.tool || 'claude' });
 
-    toolResult = await executeAgent({
+    toolResult = await agentCommanderLib.executeWithAgentCommander({
       issueUrl,
       issueNumber,
       prNumber,
@@ -751,16 +712,20 @@ try {
       getLogFile,
       formatAligned,
       getResourceSnapshot,
-      agentPath,
       $,
     });
-  } else if (argv.tool === 'qwen') {
-    const qwenLib = await import('./qwen.lib.mjs');
-    const { executeQwen, checkPlaywrightMcpAvailability: checkQwenPlaywrightMcp } = qwenLib;
-    const qwenPath = process.env.QWEN_PATH || 'qwen';
-    await resolvePlaywrightMcp(checkQwenPlaywrightMcp);
-
-    toolResult = await executeQwen({
+  } else if (['opencode', 'codex', 'agent', 'gemini', 'qwen'].includes(argv.tool)) {
+    const toolDispatch = {
+      opencode: { lib: './opencode.lib.mjs', execFn: 'executeOpenCode', envVar: 'OPENCODE_PATH', defaultBin: 'opencode', pathKey: 'opencodePath' },
+      codex: { lib: './codex.lib.mjs', execFn: 'executeCodex', envVar: 'CODEX_PATH', defaultBin: 'codex', pathKey: 'codexPath' },
+      agent: { lib: './agent.lib.mjs', execFn: 'executeAgent', envVar: 'AGENT_PATH', defaultBin: 'agent', pathKey: 'agentPath' },
+      gemini: { lib: './gemini.lib.mjs', execFn: 'executeGemini', envVar: 'GEMINI_PATH', defaultBin: 'gemini', pathKey: 'geminiPath' },
+      qwen: { lib: './qwen.lib.mjs', execFn: 'executeQwen', envVar: 'QWEN_PATH', defaultBin: 'qwen', pathKey: 'qwenPath' },
+    }[argv.tool];
+    const toolLib = await import(toolDispatch.lib);
+    await resolvePlaywrightMcp(toolLib.checkPlaywrightMcpAvailability);
+
+    toolResult = await toolLib[toolDispatch.execFn]({
       issueUrl,
       issueNumber,
       prNumber,
@@ -781,7 +746,7 @@ try {
       getLogFile,
       formatAligned,
       getResourceSnapshot,
-      qwenPath,
+      [toolDispatch.pathKey]: process.env[toolDispatch.envVar] || toolDispatch.defaultBin,
       $,
     });
   } else {

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

@@ -167,7 +167,7 @@ export const getUncommittedChangesDetails = async tempDir => {
 };
 
 /**
- * Execute the AI tool (Claude, OpenCode, Codex, Agent, Qwen) for a restart iteration
+ * Execute the AI tool (Claude, OpenCode, Codex, Agent, Gemini, Qwen) for a restart iteration
  * This is the shared tool execution logic used by both watch mode and auto-restart-until-mergeable mode
  * @param {Object} params - Execution parameters
  * @returns {Promise<Object>} - Tool execution result
@@ -183,7 +183,34 @@ export const executeToolIteration = async params => {
   await cascadePlaywrightMcpDisable(argv, log);
 
   let toolResult;
-  if (argv.tool === 'opencode') {
+  if (argv.useAgentCommander) {
+    const agentCommanderLib = await import('./agent-commander.lib.mjs');
+    await agentCommanderLib.resolvePlaywrightMcpForAgentCommander({ argv, log, tool: argv.tool || 'claude' });
+
+    toolResult = await agentCommanderLib.executeWithAgentCommander({
+      issueUrl,
+      issueNumber,
+      prNumber,
+      prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
+      branchName,
+      tempDir,
+      workspaceTmpDir: params.workspaceTmpDir,
+      isContinueMode: true,
+      mergeStateStatus,
+      forkedRepo: argv.fork,
+      feedbackLines,
+      forkActionsUrl: null,
+      owner,
+      repo,
+      argv,
+      log,
+      formatAligned,
+      getResourceSnapshot,
+      setLogFile: () => {},
+      getLogFile: () => '',
+      $,
+    });
+  } else if (argv.tool === 'opencode') {
     // Use OpenCode
     const opencodeExecLib = await import('./opencode.lib.mjs');
     const { executeOpenCode, checkPlaywrightMcpAvailability } = opencodeExecLib;
@@ -208,6 +235,7 @@ export const executeToolIteration = async params => {
       prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
       branchName,
       tempDir,
+      workspaceTmpDir,
       isContinueMode: true,
       mergeStateStatus,
       forkedRepo: argv.fork,
@@ -246,6 +274,7 @@ export const executeToolIteration = async params => {
       prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
       branchName,
       tempDir,
+      workspaceTmpDir,
       isContinueMode: true,
       mergeStateStatus,
       forkedRepo: argv.fork,
@@ -287,6 +316,7 @@ export const executeToolIteration = async params => {
       prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
       branchName,
       tempDir,
+      workspaceTmpDir,
       isContinueMode: true,
       mergeStateStatus,
       forkedRepo: argv.fork,
@@ -301,6 +331,48 @@ export const executeToolIteration = async params => {
       agentPath,
       $,
     });
+  } else if (argv.tool === 'gemini') {
+    // Use Gemini
+    const geminiExecLib = await import('./gemini.lib.mjs');
+    const { executeGemini, checkPlaywrightMcpAvailability } = geminiExecLib;
+    const geminiPath = argv.geminiPath || 'gemini';
+
+    if (argv.promptPlaywrightMcp) {
+      const playwrightMcpAvailable = await checkPlaywrightMcpAvailability();
+      if (playwrightMcpAvailable) {
+        await log('🎭 Playwright MCP detected - enabling browser automation hints', { verbose: true });
+      } else {
+        await log('ℹ️  Playwright MCP not detected - browser automation hints will be disabled', { verbose: true });
+        argv.promptPlaywrightMcp = false;
+      }
+    } else {
+      await log('ℹ️  Playwright MCP explicitly disabled via --no-prompt-playwright-mcp', { verbose: true });
+    }
+
+    toolResult = await executeGemini({
+      issueUrl,
+      issueNumber,
+      prNumber,
+      prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
+      branchName,
+      tempDir,
+      workspaceTmpDir,
+      isContinueMode: true,
+      mergeStateStatus,
+      forkedRepo: argv.fork,
+      feedbackLines,
+      forkActionsUrl: null,
+      owner,
+      repo,
+      argv,
+      log,
+      setLogFile: () => {},
+      getLogFile: () => '',
+      formatAligned,
+      getResourceSnapshot,
+      geminiPath,
+      $,
+    });
   } else if (argv.tool === 'qwen') {
     // Use Qwen Code
     const qwenExecLib = await import('./qwen.lib.mjs');
@@ -371,6 +443,7 @@ export const executeToolIteration = async params => {
       prUrl: `https://github.com/${owner}/${repo}/pull/${prNumber}`,
       branchName,
       tempDir,
+      workspaceTmpDir,
       isContinueMode: true,
       mergeStateStatus,
       forkedRepo: argv.fork,

package/src/solve.results.lib.mjs

@@ -46,7 +46,7 @@ export const { buildClaudeResumeCommand, buildClaudeInitialCommand } = claudeCom
  * @param {Object} options
  * @param {string} options.issueUrl - The issue URL passed to solve.mjs
  * @param {string} options.sessionId - The session ID to resume
- * @param {string|null} [options.tool] - Tool name (codex, opencode, agent)
+ * @param {string|null} [options.tool] - Tool name (codex, opencode, agent, gemini)
  * @param {string|null} [options.model] - Model name to preserve
  * @param {string|null} [options.fallbackModel] - Explicit fallback model to preserve
  * @param {string|null} [options.tempDir] - Working directory to preserve

package/src/solve.validation.lib.mjs

@@ -295,7 +295,18 @@ export const performSystemChecks = async (minDiskSpace = 2048, skipToolConnectio
   // Skip tool connection validation if in dry-run mode or explicitly requested
   if (!skipToolConnection) {
     let isToolConnected = false;
-    if (argv.tool === 'opencode') {
+    if (argv.useAgentCommander) {
+      const agentCommanderLib = await import('./agent-commander.lib.mjs');
+      isToolConnected = await agentCommanderLib.validateAgentCommanderConnection({
+        tool: argv.tool || 'claude',
+        model,
+        log,
+      });
+      if (!isToolConnected) {
+        await log('❌ Cannot proceed without agent-commander tool connection', { level: 'error' });
+        return false;
+      }
+    } else if (argv.tool === 'opencode') {
       // Validate OpenCode connection
       const opencodeLib = await import('./opencode.lib.mjs');
       isToolConnected = await opencodeLib.validateOpenCodeConnection(model);
@@ -303,6 +314,14 @@ export const performSystemChecks = async (minDiskSpace = 2048, skipToolConnectio
         await log('❌ Cannot proceed without OpenCode connection', { level: 'error' });
         return false;
       }
+    } else if (argv.tool === 'gemini') {
+      // Validate Gemini connection
+      const geminiLib = await import('./gemini.lib.mjs');
+      isToolConnected = await geminiLib.validateGeminiConnection(model);
+      if (!isToolConnected) {
+        await log('❌ Cannot proceed without Gemini CLI connection', { level: 'error' });
+        return false;
+      }
     } else if (argv.tool === 'codex') {
       // Validate Codex connection
       const codexLib = await import('./codex.lib.mjs');

package/src/task.config.lib.mjs

@@ -1,7 +1,7 @@
 import { buildModelOptionDescription, defaultModels } from './models/index.mjs';
 import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 
-export const TASK_TOOL_CHOICES = ['claude', 'codex', 'opencode', 'agent'];
+export const TASK_TOOL_CHOICES = ['claude', 'codex', 'opencode', 'agent', 'gemini', 'qwen'];
 
 export function getDefaultTaskModel(tool) {
   return defaultModels[tool] || defaultModels.claude;

package/src/task.mjs

@@ -33,7 +33,7 @@ if (earlyArgs.length === 0 || earlyArgs.includes('--help') || earlyArgs.includes
   console.log('  --only-decompose   Only run decomposition mode');
   console.log('  --split            Split a GitHub issue into smaller issues');
   console.log('  --split-count      Number of issues to split into [default: 2]');
-  console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent, qwen) [default: claude]');
+  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: screen]');
   console.log('  --dry-run          Print split output without creating GitHub issues');

package/src/telegram-bot.mjs

@@ -342,7 +342,7 @@ function isForwardedOrReply(ctx) {
 /**
  * Validates the model name in the args array and returns an error message if invalid
  * @param {string[]} args - Array of command arguments
- * @param {string} tool - The tool to validate against ('claude' or 'opencode')
+ * @param {string} tool - The tool to validate against ('claude', 'opencode', 'codex', 'agent', or 'gemini')
  * @returns {string|null} Error message if invalid, null if valid or no model specified
  */
 function validateModelInArgs(args, tool = 'claude') {
@@ -525,7 +525,7 @@ bot.command('help', async ctx => {
   message += '📝 *Available Commands:*\n\n';
 
   if (solveEnabled) {
-    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */qwen*) - Solve a GitHub issue\n';
+    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - Solve a GitHub issue\n';
     message += 'Usage: `/solve <github-url> [options]`\n';
     message += 'Example: `/solve https://github.com/owner/repo/issues/123 --model sonnet`\n';
     message += 'Tool aliases imply `--tool <tool>`: `/codex <github-url>` equals `/solve <github-url> --tool codex`\n';
@@ -535,7 +535,7 @@ bot.command('help', async ctx => {
     }
     message += '\n';
   } else {
-    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */qwen*) - ❌ Disabled\n\n';
+    message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - ❌ Disabled\n\n';
   }
 
   if (taskEnabled) {
@@ -576,7 +576,7 @@ bot.command('help', async ctx => {
   message += '🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards.\n';
   if (ISOLATION_BACKEND) message += `🔒 *Isolation Mode:* \`${ISOLATION_BACKEND}\` (experimental)\n`;
   message += '\n';
-  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /gemini, /qwen, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';

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

@@ -14,6 +14,7 @@ export const TOOL_SOLVE_COMMAND_ALIASES = Object.freeze({
   opencode: 'opencode',
   agent: 'agent',
   qwen: 'qwen',
+  gemini: 'gemini',
 });
 
 export const SOLVE_COMMAND_NAMES = Object.freeze(['solve', 'do', 'continue', ...Object.keys(TOOL_SOLVE_COMMAND_ALIASES)]);

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

@@ -6,7 +6,7 @@
  *
  * Features:
  * - Shows pending, processing, completed, and failed queue items
- * - Per-tool queue breakdown (claude, opencode, etc.)
+ * - Per-tool queue breakdown (claude, opencode, codex, agent, gemini, etc.)
  * - Lists currently processing and waiting items
  * - Running Claude process count
  *

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

@@ -7,7 +7,7 @@ const execAsync = promisify(exec);
 
 /**
  * Count running processes by name.
- * @param {string} processName - Process name to search for (e.g., 'claude', 'agent')
+ * @param {string} processName - Process name to search for (e.g., 'claude', 'agent', 'codex', 'gemini')
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{count: number, processes: string[]}>}
  */
@@ -84,6 +84,15 @@ export async function getRunningQwenProcesses(verbose = false) {
   return getRunningProcesses('qwen', verbose);
 }
 
+/**
+ * Count running gemini processes.
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningGeminiProcesses(verbose = false) {
+  return getRunningProcesses('gemini', verbose);
+}
+
 /**
  * Format a threshold as percentage for display.
  * @param {number} ratio - Ratio (0.0 - 1.0)
@@ -156,6 +165,8 @@ export function formatWaitingReason(metric, currentValue, threshold) {
       return 'Codex process is already running';
     case 'qwen_running':
       return 'Qwen Code process is already running';
+    case 'gemini_running':
+      return 'Gemini CLI process is already running';
     default:
       return `${metric} threshold exceeded`;
   }

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

@@ -16,8 +16,8 @@
  */
 
 import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
-export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
-import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
@@ -128,7 +128,7 @@ class SolveQueueItem {
  * Solve Queue - Producer/Consumer queue for /solve commands
  *
  * Uses separate queues for each tool type to ensure:
- * - Claude tasks never block agent tasks (and vice versa)
+ * - Claude tasks never block agent, codex, gemini, or qwen tasks (and vice versa)
  * - Each tool queue maintains FIFO order
  * - Each tool has independent rate limiting
  *
@@ -143,13 +143,14 @@ export class SolveQueue {
     this.getRunningIsolatedSessionsFn = options.getRunningIsolatedSessions || getRunningIsolatedSessions;
     this.autoStart = options.autoStart !== false;
 
-    // Separate queues per tool type - claude tasks never block agent tasks
+    // Separate queues per tool type - claude tasks never block other tool tasks
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     this.queues = {
       claude: [],
       agent: [],
       codex: [],
       qwen: [],
+      gemini: [],
     };
     this.processing = new Map();
     this.completed = [];
@@ -162,6 +163,7 @@ export class SolveQueue {
       agent: null,
       codex: null,
       qwen: null,
+      gemini: null,
     };
     // Legacy: keep for compatibility with existing code that uses lastStartTime
     this.lastStartTime = null;
@@ -184,7 +186,7 @@ export class SolveQueue {
 
   /**
    * Get the queue array for a specific tool, creating it if needed
-   * @param {string} tool - Tool type ('claude', 'agent', etc.)
+   * @param {string} tool - Tool type ('claude', 'agent', 'codex', 'gemini', etc.)
    * @returns {Array} The queue array for this tool
    */
   getToolQueue(tool) {
@@ -333,7 +335,7 @@ export class SolveQueue {
   /**
    * Count processing items by tool type
    * Used for tool-specific limit checking - e.g., Claude limits only count Claude processing items
-   * @param {string} tool - Tool type to count ('claude', 'agent', etc.)
+   * @param {string} tool - Tool type to count ('claude', 'agent', 'codex', 'gemini', etc.)
    * @returns {number} Count of processing items with the specified tool
    * @see https://github.com/link-assistant/hive-mind/issues/1159
    */
@@ -378,6 +380,7 @@ export class SolveQueue {
 
       if (check.canStart) {
         const item = toolQueue[0];
+        if (!item) continue;
         // Also check one-at-a-time mode for this specific tool
         // For tool-specific one-at-a-time, only count that tool's processing items
         const toolProcessingCount = this.getProcessingCountByTool(tool);
@@ -397,7 +400,7 @@ export class SolveQueue {
    * Reject all items in a tool queue and notify users.
    * Called when a 'reject' strategy threshold is exceeded for queued items.
    *
-   * @param {string} tool - Tool type (e.g., 'claude', 'agent')
+   * @param {string} tool - Tool type (e.g., 'claude', 'agent', 'codex', 'gemini')
    * @param {SolveQueueItem[]} toolQueue - The tool's queue array
    * @param {string} rejectReason - Reason for rejection
    * @see https://github.com/link-assistant/hive-mind/issues/1555
@@ -523,8 +526,8 @@ export class SolveQueue {
    *
    * Logic per issue #1159:
    * - Different tools have different limits. Claude limits only apply to 'claude' tool.
-   * - Processing count for Claude limits only includes Claude items, not agent items.
-   * - This allows agent tasks to run in parallel when Claude limits are reached.
+   * - Processing count for Claude limits only includes Claude items, not agent/codex/gemini/qwen items.
+   * - This allows non-Claude tasks to run in parallel when Claude limits are reached.
    *
    * Logic per issue #1253:
    * - All thresholds now support configurable strategies (reject, enqueue, dequeue-one-at-a-time)
@@ -533,7 +536,7 @@ export class SolveQueue {
    * - 'dequeue-one-at-a-time' allows one command while blocking subsequent
    *
    * @param {Object} options - Options for the check
-   * @param {string} options.tool - The tool being used ('claude', 'agent', etc.)
+   * @param {string} options.tool - The tool being used ('claude', 'agent', 'codex', 'gemini', 'qwen', etc.)
    * @returns {Promise<{canStart: boolean, rejected?: boolean, rejectReason?: string, reason?: string, reasons?: string[], oneAtATime?: boolean}>}
    */
   async canStartCommand(options = {}) {
@@ -564,9 +567,11 @@ export class SolveQueue {
     const codexProcessCount = externalProcessing.byTool.codex || 0;
     const agentProcessCount = externalProcessing.byTool.agent || 0;
     const qwenProcessCount = externalProcessing.byTool.qwen || 0;
+    const geminiProcessCount = externalProcessing.byTool.gemini || 0;
     const hasRunningClaude = claudeProcessCount > 0;
     const hasRunningCodex = codexProcessCount > 0;
     const hasRunningQwen = qwenProcessCount > 0;
+    const hasRunningGemini = geminiProcessCount > 0;
 
     // Calculate total processing count for system resources (all tools)
     // System resources (RAM, CPU, disk) apply to all tools
@@ -574,11 +579,12 @@ export class SolveQueue {
 
     // Calculate Claude-specific processing count for Claude API limits
     // Only counts Claude items in queue + external claude processes
-    // Agent items don't count against Claude's one-at-a-time limit
+    // Non-Claude items don't count against Claude's one-at-a-time limit
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     const claudeProcessingCount = this.getProcessingCountByTool('claude');
     const codexProcessingCount = this.getProcessingCountByTool('codex');
     const qwenProcessingCount = this.getProcessingCountByTool('qwen');
+    const geminiProcessingCount = this.getProcessingCountByTool('gemini');
 
     // Track claude_running as a metric (but don't add to reasons yet)
     if (hasRunningClaude) {
@@ -590,6 +596,9 @@ export class SolveQueue {
     if (hasRunningQwen) {
       this.recordThrottle('qwen_running');
     }
+    if (hasRunningGemini) {
+      this.recordThrottle('gemini_running');
+    }
 
     // Check system resources with strategy support
     // System resources apply to ALL tools, not just Claude
@@ -609,11 +618,11 @@ export class SolveQueue {
 
     // Check API limits with strategy support (pass hasRunningClaude, claudeProcessingCount, and tool)
     // Claude limits use claudeProcessingCount (only Claude items), not totalProcessing
-    // This allows agent tasks to proceed when Claude limits are reached
+    // This allows non-Claude tasks to proceed when Claude limits are reached
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     // See: https://github.com/link-assistant/hive-mind/issues/1253 (strategies)
-    const hasRunningToolProcess = tool === 'codex' ? hasRunningCodex : tool === 'qwen' ? hasRunningQwen : hasRunningClaude;
-    const toolProcessingCount = tool === 'codex' ? codexProcessingCount : tool === 'qwen' ? qwenProcessingCount : claudeProcessingCount;
+    const hasRunningToolProcess = (externalProcessing.byTool[tool] || 0) > 0;
+    const toolProcessingCount = this.getProcessingCountByTool(tool);
     const limitCheck = await this.checkApiLimits(hasRunningToolProcess, toolProcessingCount, tool);
     if (limitCheck.rejected) {
       rejected = true;
@@ -640,6 +649,9 @@ export class SolveQueue {
     if (tool === 'qwen' && hasRunningQwen && reasons.length > 0) {
       reasons.push(formatWaitingReason('qwen_running', qwenProcessCount, 0) + ` (${qwenProcessCount} processes)`);
     }
+    if (tool === 'gemini' && hasRunningGemini && reasons.length > 0) {
+      reasons.push(formatWaitingReason('gemini_running', geminiProcessCount, 0) + ` (${geminiProcessCount} processes)`);
+    }
 
     const canStart = reasons.length === 0 && !rejected;
 
@@ -662,11 +674,13 @@ export class SolveQueue {
       codexProcesses: codexProcessCount,
       agentProcesses: agentProcessCount,
       qwenProcesses: qwenProcessCount,
+      geminiProcesses: geminiProcessCount,
       isolatedProcesses: externalProcessing.isolatedTotal,
       totalProcessing,
       claudeProcessingCount,
       codexProcessingCount,
       qwenProcessingCount,
+      geminiProcessingCount,
     };
   }
 
@@ -800,10 +814,10 @@ export class SolveQueue {
    * - GitHub threshold blocks unconditionally when exceeded (ultimate restriction)
    *
    * Logic per issue #1159:
-   * - When tool is 'agent', skip Claude-specific limits entirely since agent uses different
-   *   rate limits (Grok Code or similar). Only system resources and GitHub limits apply.
-   * - For Claude limits, only count Claude-specific processing items, not agent items.
-   *   This allows agent tasks to run in parallel even when Claude limits are reached.
+   * - 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)
@@ -811,7 +825,7 @@ export class SolveQueue {
    *
    * @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', etc.)
+   * @param {string} tool - The tool being used ('claude', 'agent', 'codex', 'gemini', 'qwen', etc.)
    * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean, rejected: boolean, rejectReason: string|null}>}
    */
   async checkApiLimits(hasRunningToolProcess = false, toolProcessingCount = 0, tool = 'claude') {
@@ -821,7 +835,7 @@ export class SolveQueue {
     let rejectReason = null;
 
     // Apply Claude-specific limits only when tool is 'claude'
-    // Other tools (like 'agent') use different rate limiting backends and are not
+    // 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';
@@ -1427,6 +1441,9 @@ export default {
   getRunningProcesses,
   getRunningClaudeProcesses,
   getRunningAgentProcesses,
+  getRunningCodexProcesses,
+  getRunningQwenProcesses,
+  getRunningGeminiProcesses,
   getRunningIsolatedSessions,
   createQueueExecuteCallback,
   formatDuration,

package/src/tool-connection-validation.lib.mjs

@@ -11,6 +11,9 @@ export const validateToolConnection = async ({ tool = 'claude', model, verbose =
   if (tool === 'qwen') {
     return (await import('./qwen.lib.mjs')).validateQwenConnection(model);
   }
+  if (tool === 'gemini') {
+    return (await import('./gemini.lib.mjs')).validateGeminiConnection(model);
+  }
   const validateClaude = validateClaudeConnection || (await import('./claude.lib.mjs')).validateClaudeConnection;
   return validateClaude(model);
 };