@link-assistant/hive-mind 1.63.0 → 1.64.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.64.0
+
+### Minor Changes
+
+- 2ffb808: Add experimental `--use-agent-commander` option to delegate supported tool execution to the agent-commander library, including Claude, Codex, OpenCode, Agent, Qwen, and Gemini.
+
 ## 1.63.0
 
 ### Minor Changes

package/README.hi.md

@@ -343,7 +343,7 @@ solve <issue-url> [options]
 
 | विकल्प                   | संक्षिप्त | विवरण                                                       | डिफ़ॉल्ट |
 | ------------------------ | --------- | ----------------------------------------------------------- | -------- |
-| `--tool`                 |           | AI टूल (claude, opencode, codex, agent, gemini, qwen)       | claude   |
+| `--tool`                 |           | AI टूल (claude, opencode, codex, agent, qwen, gemini)       | claude   |
 | `--verbose`              | `-v`      | विस्तृत लॉगिंग सक्षम करें                                   | false    |
 | `--attach-logs`          |           | PR में लॉग संलग्न करें (⚠️ संवेदनशील डेटा उजागर हो सकता है) | false    |
 | `--auto-init-repository` |           | खाली रेपो स्वतः-आरंभ करें (README.md बनाता है)              | false    |
@@ -370,7 +370,7 @@ hive <github-url> [options]
 
 | विकल्प                   | संक्षिप्त | विवरण                                                       | डिफ़ॉल्ट |
 | ------------------------ | --------- | ----------------------------------------------------------- | -------- |
-| `--tool`                 |           | AI टूल (claude, opencode, codex, agent, gemini, qwen)       | claude   |
+| `--tool`                 |           | AI टूल (claude, opencode, codex, agent, qwen, gemini)       | claude   |
 | `--concurrency`          | `-c`      | समानांतर वर्कर की संख्या                                    | 2        |
 | `--skip-issues-with-prs` | `-s`      | मौजूदा PR वाले इश्यू छोड़ें                                 | false    |
 | `--verbose`              | `-v`      | विस्तृत लॉगिंग सक्षम करें                                   | false    |
@@ -462,8 +462,8 @@ Aliases:
 /codex /solve --tool codex के बराबर है
 /opencode /solve --tool opencode के बराबर है
 /agent /solve --tool agent के बराबर है
-/gemini /solve --tool gemini के बराबर है
 /qwen /solve --tool qwen के बराबर है
+/gemini /solve --tool gemini के बराबर है
 
 Tool alias examples:
 /codex https://github.com/owner/repo/issues/123 --model gpt-5.5
@@ -471,6 +471,7 @@ Tool alias examples:
 /agent https://github.com/owner/repo/issues/123 --model nemotron-3-super-free
 /gemini https://github.com/owner/repo/issues/123 --model flash
 /qwen https://github.com/owner/repo/issues/123 --model qwen3-coder-plus
+/gemini https://github.com/owner/repo/issues/123 --model gemini-2.5-flash
 
 Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model nemotron-3-super-free

package/README.md

@@ -352,7 +352,7 @@ solve <issue-url> [options]
 
 | Option                   | Alias | Description                                            | Default |
 | ------------------------ | ----- | ------------------------------------------------------ | ------- |
-| `--tool`                 |       | AI tool (claude, opencode, codex, agent, gemini, qwen) | claude  |
+| `--tool`                 |       | AI tool (claude, opencode, codex, agent, qwen, gemini) | claude  |
 | `--verbose`              | `-v`  | Enable verbose logging                                 | false   |
 | `--attach-logs`          |       | Attach logs to PR (⚠️ may expose sensitive data)       | false   |
 | `--auto-init-repository` |       | Auto-initialize empty repos (creates README.md)        | false   |
@@ -379,7 +379,7 @@ hive <github-url> [options]
 
 | Option                   | Alias | Description                                            | Default |
 | ------------------------ | ----- | ------------------------------------------------------ | ------- |
-| `--tool`                 |       | AI tool (claude, opencode, codex, agent, gemini, qwen) | claude  |
+| `--tool`                 |       | AI tool (claude, opencode, codex, agent, qwen, gemini) | claude  |
 | `--concurrency`          | `-c`  | Number of parallel workers                             | 2       |
 | `--skip-issues-with-prs` | `-s`  | Skip issues with existing PRs                          | false   |
 | `--verbose`              | `-v`  | Enable verbose logging                                 | false   |
@@ -469,8 +469,8 @@ Aliases:
 /codex is equivalent to /solve --tool codex
 /opencode is equivalent to /solve --tool opencode
 /agent is equivalent to /solve --tool agent
-/gemini is equivalent to /solve --tool gemini
 /qwen is equivalent to /solve --tool qwen
+/gemini is equivalent to /solve --tool gemini
 
 Tool alias examples:
 /codex https://github.com/owner/repo/issues/123 --model gpt-5.5
@@ -478,6 +478,7 @@ Tool alias examples:
 /agent https://github.com/owner/repo/issues/123 --model nemotron-3-super-free
 /gemini https://github.com/owner/repo/issues/123 --model flash
 /qwen https://github.com/owner/repo/issues/123 --model qwen3-coder-plus
+/gemini https://github.com/owner/repo/issues/123 --model gemini-2.5-flash
 
 Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model nemotron-3-super-free
@@ -501,6 +502,7 @@ Current tool defaults in Hive Mind:
 | `agent`    | `nemotron-3-super-free`                                     | No extra thinking prompt is added for the default model                                  |
 | `gemini`   | `flash`                                                     | No extra thinking prompt is added for the default model                                  |
 | `qwen`     | `qwen3-coder-plus`                                          | No extra thinking prompt is added for the default model                                  |
+| `gemini`   | `gemini-2.5-flash`                                          | No extra thinking prompt is added for the default model                                  |
 
 See [docs/CONFIGURATION.md](./docs/CONFIGURATION.md) for the full per-tool defaults and reasoning mappings.
 

package/README.ru.md

@@ -343,7 +343,7 @@ solve <issue-url> [options]
 
 | Параметр                 | Сокр. | Описание                                                              | По умолчанию |
 | ------------------------ | ----- | --------------------------------------------------------------------- | ------------ |
-| `--tool`                 |       | Инструмент ИИ (claude, opencode, codex, agent, gemini, qwen)          | claude       |
+| `--tool`                 |       | Инструмент ИИ (claude, opencode, codex, agent, qwen, gemini)          | claude       |
 | `--verbose`              | `-v`  | Включить подробное логирование                                        | false        |
 | `--attach-logs`          |       | Прикрепить логи к PR (⚠️ может раскрыть конфиденциальные данные)      | false        |
 | `--auto-init-repository` |       | Автоматически инициализировать пустые репозитории (создаёт README.md) | false        |
@@ -370,7 +370,7 @@ hive <github-url> [options]
 
 | Параметр                 | Сокр. | Описание                                                          | По умолчанию |
 | ------------------------ | ----- | ----------------------------------------------------------------- | ------------ |
-| `--tool`                 |       | Инструмент ИИ (claude, opencode, codex, agent, gemini, qwen)      | claude       |
+| `--tool`                 |       | Инструмент ИИ (claude, opencode, codex, agent, qwen, gemini)      | claude       |
 | `--concurrency`          | `-c`  | Количество параллельных воркеров                                  | 2            |
 | `--skip-issues-with-prs` | `-s`  | Пропускать задачи с существующими PR                              | false        |
 | `--verbose`              | `-v`  | Включить подробное логирование                                    | false        |
@@ -463,8 +463,8 @@ Aliases:
 /codex эквивалентна /solve --tool codex
 /opencode эквивалентна /solve --tool opencode
 /agent эквивалентна /solve --tool agent
-/gemini эквивалентна /solve --tool gemini
 /qwen эквивалентна /solve --tool qwen
+/gemini эквивалентна /solve --tool gemini
 
 Tool alias examples:
 /codex https://github.com/owner/repo/issues/123 --model gpt-5.5
@@ -472,6 +472,7 @@ Tool alias examples:
 /agent https://github.com/owner/repo/issues/123 --model nemotron-3-super-free
 /gemini https://github.com/owner/repo/issues/123 --model flash
 /qwen https://github.com/owner/repo/issues/123 --model qwen3-coder-plus
+/gemini https://github.com/owner/repo/issues/123 --model gemini-2.5-flash
 
 Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model nemotron-3-super-free

package/README.zh.md

@@ -343,7 +343,7 @@ solve <issue-url> [options]
 
 | 选项                     | 简写 | 描述                                                    | 默认值 |
 | ------------------------ | ---- | ------------------------------------------------------- | ------ |
-| `--tool`                 |      | AI 工具（claude、opencode、codex、agent、gemini、qwen） | claude |
+| `--tool`                 |      | AI 工具（claude、opencode、codex、agent、qwen、gemini） | claude |
 | `--verbose`              | `-v` | 启用详细日志                                            | false  |
 | `--attach-logs`          |      | 将日志附加到 PR（⚠️ 可能暴露敏感数据）                  | false  |
 | `--auto-init-repository` |      | 自动初始化空仓库（创建 README.md）                      | false  |
@@ -370,7 +370,7 @@ hive <github-url> [options]
 
 | 选项                     | 简写 | 描述                                                    | 默认值 |
 | ------------------------ | ---- | ------------------------------------------------------- | ------ |
-| `--tool`                 |      | AI 工具（claude、opencode、codex、agent、gemini、qwen） | claude |
+| `--tool`                 |      | AI 工具（claude、opencode、codex、agent、qwen、gemini） | claude |
 | `--concurrency`          | `-c` | 并行工作进程数量                                        | 2      |
 | `--skip-issues-with-prs` | `-s` | 跳过已有 PR 的 Issue                                    | false  |
 | `--verbose`              | `-v` | 启用详细日志                                            | false  |
@@ -459,8 +459,8 @@ Aliases:
 /codex 等同于 /solve --tool codex
 /opencode 等同于 /solve --tool opencode
 /agent 等同于 /solve --tool agent
-/gemini 等同于 /solve --tool gemini
 /qwen 等同于 /solve --tool qwen
+/gemini 等同于 /solve --tool gemini
 
 Tool alias examples:
 /codex https://github.com/owner/repo/issues/123 --model gpt-5.5
@@ -468,6 +468,7 @@ Tool alias examples:
 /agent https://github.com/owner/repo/issues/123 --model nemotron-3-super-free
 /gemini https://github.com/owner/repo/issues/123 --model flash
 /qwen https://github.com/owner/repo/issues/123 --model qwen3-coder-plus
+/gemini https://github.com/owner/repo/issues/123 --model gemini-2.5-flash
 
 Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model nemotron-3-super-free

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.63.0",
+  "version": "1.64.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -72,7 +72,7 @@
     "@secretlint/secretlint-rule-preset-recommend": "^11.2.5",
     "@sentry/node": "^10.15.0",
     "@sentry/profiling-node": "^10.15.0",
-    "agent-commander": "^0.4.2",
+    "agent-commander": "^0.6.1",
     "dayjs": "^1.11.19",
     "decimal.js-light": "^2.5.1",
     "lino-arguments": "^0.3.0",

package/src/agent-commander.lib.mjs

@@ -0,0 +1,361 @@
+#!/usr/bin/env node
+/**
+ * Experimental agent-commander execution adapter.
+ *
+ * This module is only used when solve is called with --use-agent-commander.
+ * Default tool execution remains in claude.lib.mjs, codex.lib.mjs,
+ * opencode.lib.mjs, and agent.lib.mjs.
+ */
+
+import { resolveCodexReasoningEffort } from './codex.options.lib.mjs';
+import { mapModelForTool } from './models/index.mjs';
+import { buildCodexDisable1mContextConfigArgs, buildCodexSubSessionSizeConfigArgs, parseSubSessionSize } from './sub-session-size.lib.mjs';
+import { detectUsageLimit } from './usage-limit.lib.mjs';
+
+export const AGENT_COMMANDER_TOOLS = new Set(['claude', 'codex', 'opencode', 'agent', 'qwen', 'gemini']);
+
+const TOOL_EXECUTABLE_CONFIG = {
+  claude: { argvKey: 'claudePath', envKey: 'CLAUDE_PATH' },
+  codex: { argvKey: 'codexPath', envKey: 'CODEX_PATH' },
+  opencode: { argvKey: 'opencodePath', envKey: 'OPENCODE_PATH' },
+  agent: { argvKey: 'agentPath', envKey: 'AGENT_PATH' },
+  qwen: { argvKey: 'qwenPath', envKey: 'QWEN_PATH' },
+  gemini: { argvKey: 'geminiPath', envKey: 'GEMINI_PATH' },
+};
+
+const getConfiguredExecutable = (argv = {}, tool) => {
+  const config = TOOL_EXECUTABLE_CONFIG[tool];
+  if (!config) return null;
+  return argv[config.argvKey] || process.env[config.envKey] || null;
+};
+
+const appendExtraArgs = (options, args) => {
+  if (!Array.isArray(args) || args.length === 0) return;
+  options.extraArgs = [...(options.extraArgs || []), ...args];
+};
+
+const appendExtraEnv = (options, env) => {
+  const entries = Object.entries(env || {}).filter(([, value]) => value !== undefined && value !== null && value !== false);
+  if (entries.length === 0) return;
+  options.extraEnv = {
+    ...(options.extraEnv || {}),
+    ...Object.fromEntries(entries.map(([key, value]) => [key, String(value)])),
+  };
+};
+
+const buildClaudeToolOptions = (argv = {}) => {
+  const options = {};
+  options.verbose = !!argv.verbose;
+  if (argv.fallbackModel) options.fallbackModel = argv.fallbackModel;
+
+  const extraEnv = {};
+  if (argv.thinkingBudget !== undefined) extraEnv.MAX_THINKING_TOKENS = argv.thinkingBudget;
+  if (argv.disable1mContext) extraEnv.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+  if (argv.showThinkingContent) extraEnv.CLAUDE_CODE_SHOW_THINKING = '1';
+  if (argv.planModel) extraEnv.ANTHROPIC_DEFAULT_OPUS_MODEL = argv.planModel;
+  appendExtraEnv(options, extraEnv);
+
+  return options;
+};
+
+const buildCodexToolOptions = (argv = {}) => {
+  const options = {};
+  const { reasoningEffort } = resolveCodexReasoningEffort(argv);
+  appendExtraArgs(options, ['-c', `model_reasoning_effort=${reasoningEffort}`, '-c', 'model_reasoning_summary=auto']);
+
+  appendExtraArgs(options, buildCodexDisable1mContextConfigArgs(!!argv.disable1mContext));
+  try {
+    appendExtraArgs(options, buildCodexSubSessionSizeConfigArgs(parseSubSessionSize(argv.subSessionSize)));
+  } catch {
+    // The embedded Codex path logs parse warnings later. Keep agent-commander
+    // command construction permissive so validation can still run.
+  }
+
+  return options;
+};
+
+const defaultLog = async (message, options = {}) => {
+  if (options.verbose && !global.verboseMode) return;
+  if (options.level === 'error') {
+    console.error(message);
+  } else if (options.level === 'warning' || options.level === 'warn') {
+    console.warn(message);
+  } else {
+    console.log(message);
+  }
+};
+
+const getAgentCommander = async () => {
+  try {
+    return await import('agent-commander');
+  } catch (error) {
+    throw new Error(`agent-commander is not installed or cannot be loaded. Install it with: npm install agent-commander\nOriginal error: ${error.message}`);
+  }
+};
+
+export const isAgentCommanderAvailable = async () => {
+  try {
+    await getAgentCommander();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const getAgentCommanderToolName = (argv = {}) => argv.tool || 'claude';
+
+const resolveAgentCommanderModel = (tool, model) => (model ? mapModelForTool(tool, model) : model);
+
+export const buildAgentCommanderToolOptions = (argv = {}, tool = getAgentCommanderToolName(argv)) => {
+  const options = tool === 'claude' ? buildClaudeToolOptions(argv) : tool === 'codex' ? buildCodexToolOptions(argv) : {};
+
+  const executable = getConfiguredExecutable(argv, tool);
+  if (executable) {
+    options.executable = executable;
+  }
+
+  if (tool === 'gemini' && argv.verbose) options.debug = true;
+
+  return options;
+};
+
+export const buildAgentCommanderControllerOptions = ({ tool, tempDir, prompt, systemPrompt, argv = {} }) => ({
+  tool,
+  workingDirectory: tempDir,
+  prompt,
+  systemPrompt,
+  model: resolveAgentCommanderModel(tool, argv.model),
+  json: tool !== 'agent',
+  resume: argv.resume,
+  toolOptions: buildAgentCommanderToolOptions(argv, tool),
+});
+
+export const validateAgentCommanderConnection = async ({ tool, model, log = defaultLog, agentCommanderModule = null }) => {
+  try {
+    const module = agentCommanderModule || (await getAgentCommander());
+    const { agent, isToolSupported } = module;
+    const toolName = tool || 'claude';
+
+    if (!AGENT_COMMANDER_TOOLS.has(toolName) || !isToolSupported({ toolName })) {
+      await log(`[agent-commander] Tool '${toolName}' is not supported`, { level: 'error' });
+      return false;
+    }
+
+    const controller = agent({
+      tool: toolName,
+      workingDirectory: process.cwd(),
+      prompt: 'connection check',
+      model: resolveAgentCommanderModel(toolName, model),
+      json: toolName !== 'agent',
+      toolOptions: buildAgentCommanderToolOptions({ model }, toolName),
+    });
+    await controller.start({ dryRun: true, attached: false });
+    await log(`[agent-commander] ${toolName} command construction validated`, { verbose: true });
+    return true;
+  } catch (error) {
+    await log(`[agent-commander] Connection validation failed: ${error.message}`, { level: 'error' });
+    return false;
+  }
+};
+
+const getPromptModule = async tool => {
+  if (tool === 'claude') return await import('./claude.prompts.lib.mjs');
+  if (tool === 'codex') return await import('./codex.prompts.lib.mjs');
+  if (tool === 'opencode') return await import('./opencode.prompts.lib.mjs');
+  if (tool === 'agent') return await import('./agent.prompts.lib.mjs');
+  if (tool === 'qwen') return await import('./qwen.prompts.lib.mjs');
+  if (tool === 'gemini') return await import('./gemini.prompts.lib.mjs');
+  throw new Error(`Unsupported tool for agent-commander: ${tool}`);
+};
+
+export const getPlaywrightMcpAvailabilityCheck = async tool => {
+  if (tool === 'opencode') return (await import('./opencode.lib.mjs')).checkPlaywrightMcpAvailability;
+  if (tool === 'codex') return (await import('./codex.lib.mjs')).checkPlaywrightMcpAvailability;
+  if (tool === 'agent') return (await import('./agent.lib.mjs')).checkPlaywrightMcpAvailability;
+  if (tool === 'qwen') return (await import('./qwen.lib.mjs')).checkPlaywrightMcpAvailability;
+  if (tool === 'gemini') return (await import('./gemini.lib.mjs')).checkPlaywrightMcpAvailability;
+  return (await import('./claude.lib.mjs')).checkPlaywrightMcpAvailability;
+};
+
+export const resolvePlaywrightMcpForAgentCommander = async ({ argv, log = defaultLog, tool = getAgentCommanderToolName(argv) }) => {
+  if (argv.playwrightMcp === false) return;
+  if (!argv.promptPlaywrightMcp) {
+    await log('ℹ️  Playwright MCP explicitly disabled via --no-prompt-playwright-mcp', { verbose: true });
+    return;
+  }
+
+  const checkFn = await getPlaywrightMcpAvailabilityCheck(tool);
+  const available = await checkFn();
+  if (available) {
+    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;
+  }
+};
+
+const getParsedMessages = result => {
+  const parsed = result?.output?.parsed;
+  if (Array.isArray(parsed)) return parsed;
+  if (parsed && typeof parsed === 'object') return [parsed];
+  return [];
+};
+
+const extractResultSummary = (messages, plainOutput) => {
+  for (const message of [...messages].reverse()) {
+    if (typeof message?.result === 'string' && message.result.trim()) return message.result.trim();
+    if (typeof message?.summary === 'string' && message.summary.trim()) return message.summary.trim();
+    if (typeof message?.text === 'string' && message.text.trim()) return message.text.trim();
+    if (typeof message?.message === 'string' && message.message.trim()) return message.message.trim();
+    if (typeof message?.item?.content === 'string' && message.item.content.trim()) return message.item.content.trim();
+    if (Array.isArray(message?.item?.content)) {
+      const text = message.item.content
+        .map(part => part?.text || '')
+        .join('')
+        .trim();
+      if (text) return text;
+    }
+  }
+
+  return plainOutput?.trim() ? plainOutput.trim().slice(-4000) : null;
+};
+
+const hasErrorMessage = messages => messages.some(message => message?.is_error === true || message?.type === 'error' || message?.type === 'step_error' || message?.error);
+
+export const summarizeAgentCommanderResult = ({ result, tool }) => {
+  const plainOutput = result?.output?.plain || '';
+  if (result?.metadata && typeof result.metadata === 'object') {
+    const metadata = result.metadata;
+    return {
+      success: metadata.success === true,
+      sessionId: metadata.sessionId || result.sessionId || null,
+      limitReached: !!metadata.limitReached,
+      limitResetTime: metadata.limitResetTime || null,
+      limitTimezone: metadata.limitTimezone || null,
+      anthropicTotalCostUSD: metadata.anthropicTotalCostUSD ?? null,
+      publicPricingEstimate: metadata.publicPricingEstimate ?? metadata.pricingInfo?.totalCostUSD ?? null,
+      pricingInfo: metadata.pricingInfo || null,
+      resultSummary: metadata.resultSummary || null,
+      resultModelUsage: metadata.resultModelUsage || null,
+      streamTokenUsage: metadata.streamTokenUsage || result.usage || null,
+      subAgentCalls: metadata.subAgentCalls || null,
+      errorDuringExecution: metadata.errorDuringExecution === true || result?.exitCode !== 0,
+      result: plainOutput,
+    };
+  }
+
+  const messages = getParsedMessages(result);
+  const usageLimit = detectUsageLimit(plainOutput);
+  const usage = result?.usage || null;
+  const resultMessage = [...messages].reverse().find(message => message?.type === 'result') || null;
+  const totalCost = typeof resultMessage?.total_cost_usd === 'number' ? resultMessage.total_cost_usd : null;
+  const publicPricingEstimate = tool === 'agent' && typeof usage?.totalCost === 'number' ? usage.totalCost : null;
+
+  return {
+    success: result?.exitCode === 0 && !usageLimit.isUsageLimit && !hasErrorMessage(messages),
+    sessionId: result?.sessionId || resultMessage?.session_id || null,
+    limitReached: usageLimit.isUsageLimit,
+    limitResetTime: usageLimit.resetTime,
+    limitTimezone: usageLimit.timezone,
+    anthropicTotalCostUSD: tool === 'claude' ? totalCost : null,
+    publicPricingEstimate,
+    pricingInfo: publicPricingEstimate !== null ? { totalCostUSD: publicPricingEstimate, source: 'agent-commander' } : null,
+    resultSummary: extractResultSummary(messages, plainOutput),
+    resultModelUsage: null,
+    streamTokenUsage: usage,
+    subAgentCalls: null,
+    errorDuringExecution: result?.exitCode !== 0 || hasErrorMessage(messages),
+    result: plainOutput,
+  };
+};
+
+export const executeWithAgentCommander = async params => {
+  const { agentCommanderModule = null, promptModule = null, log = defaultLog, argv, tempDir, workspaceTmpDir, ...promptParams } = params;
+  const tool = getAgentCommanderToolName(argv);
+  const module = agentCommanderModule || (await getAgentCommander());
+
+  if (!AGENT_COMMANDER_TOOLS.has(tool) || !module.isToolSupported({ toolName: tool })) {
+    throw new Error(`agent-commander does not support tool '${tool}'`);
+  }
+
+  const prompts = promptModule || (await getPromptModule(tool));
+  const promptBuilderParams = { ...promptParams, tempDir, workspaceTmpDir, argv };
+  const prompt = prompts.buildUserPrompt(promptBuilderParams);
+  const systemPrompt = prompts.buildSystemPrompt(promptBuilderParams);
+  const controllerOptions = buildAgentCommanderControllerOptions({ tool, tempDir, prompt, systemPrompt, argv });
+
+  if (argv.verbose) {
+    await log('\n[agent-commander] Final prompt structure:', { verbose: true });
+    await log(`   Tool: ${tool}`, { verbose: true });
+    await log(`   User prompt characters: ${prompt.length}`, { verbose: true });
+    await log(`   System prompt characters: ${systemPrompt.length}`, { verbose: true });
+  }
+
+  const controller = module.agent(controllerOptions);
+  const dryRun = !!(argv.dryRun || argv.onlyPrepareCommand);
+  await log(`\n[agent-commander] Starting ${tool} execution${dryRun ? ' (dry-run)' : ''}...`);
+  await controller.start({
+    dryRun,
+    attached: true,
+    onOutput: chunk => {
+      if (chunk.type === 'stderr') process.stderr.write(chunk.data);
+      else process.stdout.write(chunk.data);
+    },
+  });
+
+  if (dryRun) {
+    return {
+      success: true,
+      sessionId: null,
+      limitReached: false,
+      limitResetTime: null,
+      limitTimezone: null,
+      anthropicTotalCostUSD: null,
+      publicPricingEstimate: null,
+      pricingInfo: null,
+      resultSummary: null,
+    };
+  }
+
+  const result = await controller.stop();
+  await log(`[agent-commander] ${tool} exited with code ${result.exitCode}`);
+  return summarizeAgentCommanderResult({ result, tool });
+};
+
+export const checkForUncommittedChanges = async (tempDir, owner, repo, branchName, $, log = defaultLog, autoCommit = false, autoRestartEnabled = true) => {
+  await log('\n🔍 Checking for uncommitted changes...');
+  const gitStatusResult = await $({ cwd: tempDir })`git status --porcelain 2>&1`;
+  const statusOutput = gitStatusResult.stdout?.toString().trim() || '';
+
+  if (!statusOutput) {
+    await log('✅ No uncommitted changes found');
+    return false;
+  }
+
+  await log('📝 Found uncommitted changes');
+  await log('Changes:');
+  for (const line of statusOutput.split('\n')) await log(`   ${line}`);
+
+  if (autoCommit) {
+    await log('💾 Auto-committing changes (--auto-commit-uncommitted-changes is enabled)...');
+    const addResult = await $({ cwd: tempDir })`git add -A`;
+    if (addResult.code === 0) {
+      const commitResult = await $({ cwd: tempDir })`git commit -m ${'Auto-commit: Changes made through agent-commander during problem-solving session'}`;
+      if (commitResult.code === 0) {
+        const pushResult = await $({ cwd: tempDir })`git push origin ${branchName} 2>&1`;
+        await log(pushResult.code === 0 ? '✅ Changes pushed successfully' : `⚠️ Warning: Could not push changes: ${pushResult.stderr?.toString().trim() || pushResult.stdout?.toString().trim()}`, { level: pushResult.code === 0 ? 'info' : 'warning' });
+      }
+    }
+    return false;
+  }
+
+  if (autoRestartEnabled) {
+    await log('\n⚠️  IMPORTANT: Uncommitted changes detected!');
+    await log('   The agent-commander controlled tool made changes that were not committed.');
+    await log('\n🔄 AUTO-RESTART: Restarting the tool to handle uncommitted changes...\n');
+    return true;
+  }
+
+  await log('\n⚠️  Uncommitted changes detected but auto-restart is disabled.');
+  return false;
+};

package/src/claude.prompts.lib.mjs

@@ -294,13 +294,13 @@ Plan sub-agent usage.
 
 Agent Commander usage (unified subagent delegation).
    - When you need to delegate tasks to subagents, use the agent-commander CLI tool (start-agent) instead of the native Task tool.
-   - Agent Commander provides a unified API for different agent types (claude, opencode, codex, agent, qwen) and supports various isolation modes.
+   - Agent Commander provides a unified API for different agent types (claude, opencode, codex, agent, qwen, gemini) and supports various isolation modes.
    - To delegate a task, use the Bash tool to run start-agent with appropriate parameters:
       \`\`\`bash
       start-agent --tool claude --working-directory "$(pwd)" --prompt "Your task description here"
       \`\`\`
    - Common start-agent parameters:
-      --tool <name>: Agent to use (claude, opencode, codex, agent, qwen)
+      --tool <name>: Agent to use (claude, opencode, codex, agent, qwen, gemini)
       --working-directory <path>: Execution directory (use current directory for context)
       --prompt <text>: The task to delegate
       --model <name>: Model to use (${[...new Set(Object.values(primaryModelNames).flat())].slice(0, 5).join(', ')}, etc.)

package/src/codex.prompts.lib.mjs

@@ -277,13 +277,13 @@ Planning workflow usage.
 
 Agent Commander usage (unified subagent delegation).
    - When you need to delegate tasks to subagents, use the agent-commander CLI tool (start-agent) instead of relying only on native Codex collaboration.
-   - Agent Commander provides a unified API for different agent types (claude, opencode, codex, agent, qwen) and supports various isolation modes.
+   - Agent Commander provides a unified API for different agent types (claude, opencode, codex, agent, qwen, gemini) and supports various isolation modes.
    - To delegate a task, use a command like:
       \`\`\`bash
       start-agent --tool codex --working-directory "$(pwd)" --prompt "Your task description here"
       \`\`\`
    - Common start-agent parameters:
-      --tool <name>: Agent to use (claude, opencode, codex, agent, qwen)
+      --tool <name>: Agent to use (claude, opencode, codex, agent, qwen, gemini)
       --working-directory <path>: Execution directory (use the current directory for context)
       --prompt <text>: The task to delegate
       --model <name>: Model to use

package/src/hive.config.lib.mjs

@@ -47,7 +47,7 @@ const HIVE_CUSTOM_SOLVE_OPTIONS = {
   tool: {
     type: 'string',
     description: 'AI tool to use for solving issues',
-    choices: ['claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen'],
+    choices: ['claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini'],
     default: 'claude',
   },
 };

package/src/models/index.mjs

@@ -129,19 +129,6 @@ export const codexModels = {
   'gpt-4o': 'gpt-4o',
 };
 
-// Gemini models (Google Gemini CLI)
-// Keep aliases aligned with the Gemini CLI model aliases documented in
-// docs/cli/cli-reference.md: auto, pro, flash, and flash-lite.
-export const geminiModels = {
-  auto: 'auto',
-  pro: 'gemini-2.5-pro',
-  flash: 'gemini-2.5-flash',
-  'flash-lite': 'gemini-2.5-flash-lite',
-  'gemini-2.5-pro': 'gemini-2.5-pro',
-  'gemini-2.5-flash': 'gemini-2.5-flash',
-  'gemini-2.5-flash-lite': 'gemini-2.5-flash-lite',
-};
-
 // Qwen Code models
 export const qwenModels = {
   qwen: 'qwen3-coder-plus',
@@ -154,14 +141,38 @@ export const qwenModels = {
   'qwen3.6-coder-plus': 'qwen3.6-coder-plus',
 };
 
+// Gemini models (Google Gemini CLI)
+// Keep aliases aligned with the Gemini CLI model aliases documented in
+// docs/cli/cli-reference.md: auto, pro, flash, and flash-lite.
+export const geminiModels = {
+  auto: 'auto',
+  gemini: 'gemini-2.5-flash',
+  flash: 'gemini-2.5-flash',
+  '2.5-flash': 'gemini-2.5-flash',
+  pro: 'gemini-2.5-pro',
+  '2.5-pro': 'gemini-2.5-pro',
+  lite: 'gemini-2.5-flash-lite',
+  '2.5-lite': 'gemini-2.5-flash-lite',
+  'flash-lite': 'gemini-2.5-flash-lite',
+  '3-flash': 'gemini-3-flash-preview',
+  '3-pro': 'gemini-3-pro-preview',
+  'gemini-flash': 'gemini-2.5-flash',
+  'gemini-pro': 'gemini-2.5-pro',
+  'gemini-2.5-flash': 'gemini-2.5-flash',
+  'gemini-2.5-pro': 'gemini-2.5-pro',
+  'gemini-2.5-flash-lite': 'gemini-2.5-flash-lite',
+  'gemini-3-flash-preview': 'gemini-3-flash-preview',
+  'gemini-3-pro-preview': 'gemini-3-pro-preview',
+};
+
 // Default model for each tool (Issue #1473: centralized to avoid scattered hardcoded defaults)
 export const defaultModels = {
   claude: 'sonnet',
   agent: 'nemotron-3-super-free', // Issue #1563: changed from qwen3.6-plus-free (free promotion ended) per agent PR #243
   opencode: 'grok-code-fast-1',
   codex: 'gpt-5.5',
-  gemini: 'flash',
   qwen: 'qwen3-coder-plus',
+  gemini: 'flash',
 };
 
 // Models that support 1M token context window via [1m] suffix (Issue #1221, Issue #1238, Issue #1329)
@@ -241,10 +252,6 @@ export const CODEX_MODELS = {
   'gpt-4o': 'gpt-4o',
 };
 
-export const GEMINI_MODELS = {
-  ...geminiModels,
-};
-
 export const QWEN_MODELS = {
   ...qwenModels,
   'qwen3-coder': 'qwen3-coder',
@@ -254,6 +261,15 @@ export const QWEN_MODELS = {
   'qwen3.6-coder-plus': 'qwen3.6-coder-plus',
 };
 
+export const GEMINI_MODELS = {
+  ...geminiModels,
+  'gemini-2.5-flash': 'gemini-2.5-flash',
+  'gemini-2.5-pro': 'gemini-2.5-pro',
+  'gemini-2.5-flash-lite': 'gemini-2.5-flash-lite',
+  'gemini-3-flash-preview': 'gemini-3-flash-preview',
+  'gemini-3-pro-preview': 'gemini-3-pro-preview',
+};
+
 export const AGENT_MODELS = {
   ...agentModels,
   'opencode/grok-code': 'opencode/grok-code',
@@ -275,7 +291,7 @@ export const AGENT_MODELS = {
 
 /**
  * Get the model map object for a given tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen, gemini)
  * @returns {Object} The model mapping for the tool
  */
 export const getModelMapForTool = tool => {
@@ -299,7 +315,7 @@ export const getModelMapForTool = tool => {
 
 /**
  * Get the default model for a given tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen, gemini)
  * @returns {string} The default model alias for the tool
  */
 export const getDefaultModelForTool = tool => {
@@ -352,7 +368,7 @@ export const resolveRuntimeDefaultModel = async (tool, options = {}) => {
 
 /**
  * Map model name to full model ID for a specific tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen, gemini)
  * @param {string} model - The model name or alias
  * @returns {string} The full model ID
  */
@@ -377,7 +393,7 @@ export const mapModelForTool = (tool, model) => {
 
 /**
  * Validate if a model is compatible with a tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen, gemini)
  * @param {string} model - The model name or alias
  * @returns {boolean} True if the model is compatible with the tool
  */
@@ -432,9 +448,9 @@ export const primaryModelNames = {
   claude: ['opus', 'sonnet', 'haiku', 'opusplan'],
   opencode: ['grok', 'gpt4o'],
   codex: ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.3-codex-spark'],
-  gemini: ['flash', 'pro', 'flash-lite', 'auto'],
   agent: ['nemotron-3-super-free', 'minimax-m2.5-free', 'big-pickle', 'gpt-5-nano', 'glm-5-free', 'deepseek-r1-free'],
   qwen: ['qwen3-coder-plus', 'qwen3-coder', 'qwen3-coder-flash'],
+  gemini: ['flash', 'pro', 'flash-lite', 'auto'],
 };
 
 /**
@@ -474,7 +490,7 @@ export const validateToolModelCompatibility = (tool, model) => {
 
 /**
  * Get the model map for a given tool (validation-extended version with full ID entries)
- * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini')
  * @returns {Object} The model mapping for the tool
  */
 const getValidationModelMapForTool = tool => {
@@ -497,7 +513,7 @@ const getValidationModelMapForTool = tool => {
 
 /**
  * Get the list of available model names for a tool (for display in help/error messages)
- * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini')
  * @returns {string[]} Array of available model short names
  */
 export const getAvailableModelNames = tool => {
@@ -636,7 +652,7 @@ export const supports1mContext = (model, tool = 'claude') => {
  * Validate a model name against the available models for a tool
  * Supports [1m] suffix for 1 million token context (Issue #1221)
  * @param {string} model - The model name to validate (e.g., "opus", "opus[1m]", "claude-opus-4-6[1m]")
- * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini')
  * @returns {{ valid: boolean, message?: string, suggestions?: string[], mappedModel?: string, has1mSuffix?: boolean }}
  */
 export const validateModelName = (model, tool = 'claude') => {
@@ -709,7 +725,7 @@ export const validateModelName = (model, tool = 'claude') => {
  * Validate model name and exit with error if invalid
  * This is the main entry point for model validation in solve.mjs, hive.mjs, etc.
  * @param {string} model - The model name to validate
- * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini')
  * @param {Function} exitFn - Function to call for exiting (default: process.exit)
  * @returns {Promise<boolean>} True if valid, exits process if invalid
  */
@@ -744,7 +760,7 @@ export const formatAvailableModelsForHelp = (tool = 'claude') => {
 
 /**
  * Map tool identifier to user-friendly display name.
- * @param {string|null} tool - The tool identifier (claude, codex, opencode, agent, gemini, qwen)
+ * @param {string|null} tool - The tool identifier (claude, codex, opencode, agent, qwen, gemini)
  * @returns {string} User-friendly display name
  */
 export const getToolDisplayName = tool => {
@@ -883,7 +899,7 @@ const doesRequestedMatchActual = (requestedModel, actualModelId, tool) => {
  *
  * @param {Object} options - Model info options
  * @param {string|null} options.requestedModel - The model requested via --model flag
- * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex, qwen)
+ * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex, qwen, gemini)
  * @param {Object|null} options.pricingInfo - Pricing info from tool result
  * @param {Object|null} options.modelInfo - Pre-fetched model metadata from models.dev
  * @param {Array<{modelId: string, modelInfo: Object|null}>|null} options.modelsUsed - Actual models used from CLI JSON output
@@ -994,7 +1010,7 @@ export const resolveDefaultFallbackModel = (tool, model) => {
  *
  * @param {Object} options
  * @param {string|null} options.requestedModel - The --model flag value
- * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex, qwen)
+ * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex, qwen, gemini)
  * @param {Object|null} options.pricingInfo - Pricing info from tool result
  * @param {Array<string>|null} options.actualModelIds - Actual model IDs from CLI JSON output
  * @returns {Promise<string>} Formatted markdown model info section

package/src/qwen.prompts.lib.mjs

@@ -13,7 +13,7 @@ import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
  * @returns {string} The formatted user prompt
  */
 export const buildUserPrompt = params => {
-  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv } = params;
+  const { issueUrl, issueNumber, prNumber, prUrl, branchName, tempDir, workspaceTmpDir, isContinueMode, forkedRepo, feedbackLines, forkActionsUrl, owner, repo, argv, tool = 'qwen' } = params;
 
   const promptLines = [];
 
@@ -50,7 +50,7 @@ export const buildUserPrompt = params => {
     promptLines.push('');
   }
 
-  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'qwen', argv });
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool, argv });
   if (thinkingPromptInstruction) {
     promptLines.push(thinkingPromptInstruction);
   }

package/src/solve.config.lib.mjs

@@ -327,7 +327,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   tool: {
     type: 'string',
     description: 'AI tool to use for solving issues',
-    choices: ['claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen'],
+    choices: ['claude', 'opencode', 'codex', 'agent', 'qwen', 'gemini'],
     default: 'claude',
   },
   plan: {
@@ -352,7 +352,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'enable-workspaces': {
     type: 'boolean',
-    description: 'Use separate workspace directory structure with repository/ and tmp/ folders. Works with all tools (claude, opencode, codex, agent, gemini, qwen). Experimental feature.',
+    description: 'Use separate workspace directory structure with repository/ and tmp/ folders. Works with all tools (claude, opencode, codex, agent, qwen, gemini). Experimental feature.',
     default: false,
   },
   'interactive-mode': {
@@ -428,7 +428,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'prompt-playwright-mcp': {
     type: 'boolean',
-    description: 'Enable Playwright MCP browser automation hints in system prompt (enabled by default, only takes effect if Playwright MCP is installed). Use --no-prompt-playwright-mcp to disable. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, --tool gemini, and --tool qwen.',
+    description: 'Enable Playwright MCP browser automation hints in system prompt (enabled by default, only takes effect if Playwright MCP is installed). Use --no-prompt-playwright-mcp to disable. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, --tool qwen, and --tool gemini.',
     default: true,
   },
   'prompt-check-sibling-pull-requests': {
@@ -448,7 +448,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'playwright-mcp': {
     type: 'boolean',
-    description: 'Enable Playwright MCP server connection for this session (enabled by default). Use --no-playwright-mcp to physically disable the Playwright MCP server without affecting the global MCP registration. When disabled, also disables --prompt-playwright-mcp and --playwright-mcp-auto-cleanup. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, and --tool qwen; for --tool gemini this controls prompt hints and cleanup only.',
+    description: 'Enable Playwright MCP server connection for this session (enabled by default). Use --no-playwright-mcp to physically disable the Playwright MCP server without affecting the global MCP registration. When disabled, also disables --prompt-playwright-mcp and --playwright-mcp-auto-cleanup. Supported for --tool claude, --tool codex, --tool opencode, --tool agent, --tool qwen, and --tool gemini.',
     default: true,
   },
   'playwright-mcp-auto-cleanup': {
@@ -468,9 +468,15 @@ export const SOLVE_OPTION_DEFINITIONS = {
   },
   'prompt-subagents-via-agent-commander': {
     type: 'boolean',
-    description: 'Guide AI to use agent-commander CLI (start-agent) instead of native tool-specific delegation for subagent work. Allows using any supported agent type (claude, opencode, codex, agent, qwen) with a unified API. Supported for --tool claude and --tool codex and requires agent-commander to be installed.',
+    description: 'Guide AI to use agent-commander CLI (start-agent) instead of native tool-specific delegation for subagent work. Allows using any supported agent type (claude, opencode, codex, agent, qwen, gemini) with a unified API. Supported for --tool claude and --tool codex and requires agent-commander to be installed.',
     default: false,
   },
+  'use-agent-commander': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Execute the selected AI tool through agent-commander instead of the embedded hive-mind tool adapter. Disabled by default.',
+    default: false,
+    hidden: true,
+  },
   'auto-init-repository': {
     type: 'boolean',
     description: 'Automatically initialize empty repositories by creating a simple README.md file. Only works when you have write access to the repository. This allows branch creation and pull request workflows to proceed on repositories that have no commits.',

package/src/solve.mjs

@@ -89,8 +89,13 @@ 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') {
@@ -667,103 +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');
+    }
 
-    toolResult = await executeAgent({
-      issueUrl,
-      issueNumber,
-      prNumber,
-      prUrl,
-      branchName,
-      tempDir,
-      workspaceTmpDir,
-      isContinueMode,
-      mergeStateStatus,
-      forkedRepo,
-      feedbackLines,
-      forkActionsUrl,
-      owner,
-      repo,
-      argv,
-      log,
-      setLogFile,
-      getLogFile,
-      formatAligned,
-      getResourceSnapshot,
-      agentPath,
-      $,
-    });
-  } else if (argv.tool === 'gemini') {
-    const geminiLib = await import('./gemini.lib.mjs');
-    const { executeGemini, checkPlaywrightMcpAvailability: checkGeminiPlaywrightMcp } = geminiLib;
-    const geminiPath = process.env.GEMINI_PATH || 'gemini';
-    await resolvePlaywrightMcp(checkGeminiPlaywrightMcp);
+    await log(`\n[agent-commander] Using agent-commander for ${argv.tool || 'claude'} execution`);
+    await agentCommanderLib.resolvePlaywrightMcpForAgentCommander({ argv, log, tool: argv.tool || 'claude' });
 
-    toolResult = await executeGemini({
+    toolResult = await agentCommanderLib.executeWithAgentCommander({
       issueUrl,
       issueNumber,
       prNumber,
@@ -784,16 +712,20 @@ try {
       getLogFile,
       formatAligned,
       getResourceSnapshot,
-      geminiPath,
       $,
     });
-  } 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,
@@ -814,7 +746,7 @@ try {
       getLogFile,
       formatAligned,
       getResourceSnapshot,
-      qwenPath,
+      [toolDispatch.pathKey]: process.env[toolDispatch.envVar] || toolDispatch.defaultBin,
       $,
     });
   } else {

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

@@ -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;

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);

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, gemini, 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-solve-command.lib.mjs

@@ -13,8 +13,8 @@ export const TOOL_SOLVE_COMMAND_ALIASES = Object.freeze({
   codex: 'codex',
   opencode: 'opencode',
   agent: 'agent',
-  gemini: 'gemini',
   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.helpers.lib.mjs

@@ -76,21 +76,21 @@ export async function getRunningCodexProcesses(verbose = false) {
 }
 
 /**
- * Count running gemini processes.
+ * Count running qwen 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);
+export async function getRunningQwenProcesses(verbose = false) {
+  return getRunningProcesses('qwen', verbose);
 }
 
 /**
- * Count running qwen processes.
+ * Count running gemini processes.
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{count: number, processes: string[]}>}
  */
-export async function getRunningQwenProcesses(verbose = false) {
-  return getRunningProcesses('qwen', verbose);
+export async function getRunningGeminiProcesses(verbose = false) {
+  return getRunningProcesses('gemini', verbose);
 }
 
 /**
@@ -163,10 +163,10 @@ export function formatWaitingReason(metric, currentValue, threshold) {
       return 'Claude process is already running';
     case 'codex_running':
       return 'Codex process is already running';
-    case 'gemini_running':
-      return 'Gemini 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

@@ -149,8 +149,8 @@ export class SolveQueue {
       claude: [],
       agent: [],
       codex: [],
-      gemini: [],
       qwen: [],
+      gemini: [],
     };
     this.processing = new Map();
     this.completed = [];
@@ -162,8 +162,8 @@ export class SolveQueue {
       claude: null,
       agent: null,
       codex: null,
-      gemini: null,
       qwen: null,
+      gemini: null,
     };
     // Legacy: keep for compatibility with existing code that uses lastStartTime
     this.lastStartTime = null;
@@ -566,12 +566,12 @@ export class SolveQueue {
     const claudeProcessCount = externalProcessing.byTool.claude || 0;
     const codexProcessCount = externalProcessing.byTool.codex || 0;
     const agentProcessCount = externalProcessing.byTool.agent || 0;
-    const geminiProcessCount = externalProcessing.byTool.gemini || 0;
     const qwenProcessCount = externalProcessing.byTool.qwen || 0;
+    const geminiProcessCount = externalProcessing.byTool.gemini || 0;
     const hasRunningClaude = claudeProcessCount > 0;
     const hasRunningCodex = codexProcessCount > 0;
-    const hasRunningGemini = geminiProcessCount > 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
@@ -583,8 +583,8 @@ export class SolveQueue {
     // See: https://github.com/link-assistant/hive-mind/issues/1159
     const claudeProcessingCount = this.getProcessingCountByTool('claude');
     const codexProcessingCount = this.getProcessingCountByTool('codex');
-    const geminiProcessingCount = this.getProcessingCountByTool('gemini');
     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) {
@@ -593,12 +593,12 @@ export class SolveQueue {
     if (hasRunningCodex) {
       this.recordThrottle('codex_running');
     }
-    if (hasRunningGemini) {
-      this.recordThrottle('gemini_running');
-    }
     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
@@ -646,12 +646,12 @@ export class SolveQueue {
     if (tool === 'codex' && hasRunningCodex && reasons.length > 0) {
       reasons.push(formatWaitingReason('codex_running', codexProcessCount, 0) + ` (${codexProcessCount} processes)`);
     }
-    if (tool === 'gemini' && hasRunningGemini && reasons.length > 0) {
-      reasons.push(formatWaitingReason('gemini_running', geminiProcessCount, 0) + ` (${geminiProcessCount} processes)`);
-    }
     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;
 
@@ -673,14 +673,14 @@ export class SolveQueue {
       claudeProcesses: claudeProcessCount,
       codexProcesses: codexProcessCount,
       agentProcesses: agentProcessCount,
-      geminiProcesses: geminiProcessCount,
       qwenProcesses: qwenProcessCount,
+      geminiProcesses: geminiProcessCount,
       isolatedProcesses: externalProcessing.isolatedTotal,
       totalProcessing,
       claudeProcessingCount,
       codexProcessingCount,
-      geminiProcessingCount,
       qwenProcessingCount,
+      geminiProcessingCount,
     };
   }
 
@@ -1442,8 +1442,8 @@ export default {
   getRunningClaudeProcesses,
   getRunningAgentProcesses,
   getRunningCodexProcesses,
-  getRunningGeminiProcesses,
   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);
 };