@link-assistant/hive-mind 1.62.1 → 1.63.0

package/src/gemini.prompts.lib.mjs

@@ -0,0 +1,236 @@
+/**
+ * Gemini prompts module
+ * Handles building prompts for Google Gemini CLI commands
+ */
+
+import { getArchitectureCareSubPrompt } from './architecture-care.prompts.lib.mjs';
+import { getExperimentsExamplesSubPrompt } from './experiments-examples.prompts.lib.mjs';
+import { getThinkingPromptInstruction } from './thinking-prompt.lib.mjs';
+
+/**
+ * Build the user prompt for Gemini
+ * @param {Object} params - Parameters for building the user prompt
+ * @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 promptLines = [];
+
+  if (isContinueMode) {
+    promptLines.push(`Issue to solve: ${issueNumber ? `https://github.com/${owner}/${repo}/issues/${issueNumber}` : `Issue linked to PR #${prNumber}`}`);
+  } else {
+    promptLines.push(`Issue to solve: ${issueUrl}`);
+  }
+
+  promptLines.push(`Your prepared branch: ${branchName}`);
+  promptLines.push(`Your prepared working directory: ${tempDir}`);
+
+  if (workspaceTmpDir) {
+    promptLines.push(`Your prepared tmp directory for logs and downloads: ${workspaceTmpDir}`);
+  }
+
+  if (prUrl) {
+    promptLines.push(`Your prepared Pull Request: ${prUrl}`);
+  }
+
+  if (argv && argv.fork && forkedRepo) {
+    promptLines.push(`Your forked repository: ${forkedRepo}`);
+    promptLines.push(`Original repository (upstream): ${owner}/${repo}`);
+
+    if (branchName && forkActionsUrl) {
+      promptLines.push(`GitHub Actions on your fork: ${forkActionsUrl}`);
+    }
+  }
+
+  promptLines.push('');
+
+  if (isContinueMode && feedbackLines && feedbackLines.length > 0) {
+    feedbackLines.forEach(line => promptLines.push(line));
+    promptLines.push('');
+  }
+
+  const thinkingPromptInstruction = getThinkingPromptInstruction({ tool: 'gemini', argv });
+  if (thinkingPromptInstruction) {
+    promptLines.push(thinkingPromptInstruction);
+  }
+
+  promptLines.push(isContinueMode ? 'Continue.' : 'Proceed.');
+
+  return promptLines.join('\n') + '\n';
+};
+
+/**
+ * Build the system prompt for Gemini
+ * @param {Object} params - Parameters for building the prompt
+ * @returns {string} The formatted system prompt
+ */
+export const buildSystemPrompt = params => {
+  const { owner, repo, issueNumber, prNumber, branchName, workspaceTmpDir, argv, modelSupportsVision, forkedRepo } = params;
+
+  const screenshotRepoPath = argv?.fork && forkedRepo ? forkedRepo : `${owner}/${repo}`;
+
+  let workspaceInstructions = '';
+  if (workspaceTmpDir) {
+    workspaceInstructions = `
+Workspace tmp directory.
+   - Use ${workspaceTmpDir} for all temporary files, logs, and downloads.
+   - When saving command output to files, save to ${workspaceTmpDir}/command-output.log.
+   - When downloading CI logs, save to ${workspaceTmpDir}/ci-logs/.
+   - When saving diffs for review, save to ${workspaceTmpDir}/diffs/.
+   - When creating debug files, save to ${workspaceTmpDir}/debug/.
+
+`;
+  }
+
+  let ciExamples = '';
+  if (workspaceTmpDir) {
+    ciExamples = `
+CI investigation with workspace tmp directory.
+   - When downloading CI run logs:
+      gh run view RUN_ID --repo ${owner}/${repo} --log > ${workspaceTmpDir}/ci-logs/run-RUN_ID.log
+   - When downloading failed job logs:
+      gh run view RUN_ID --repo ${owner}/${repo} --log-failed > ${workspaceTmpDir}/ci-logs/run-RUN_ID-failed.log
+   - When listing CI runs with details:
+      gh run list --repo ${owner}/${repo} --branch ${branchName} --limit 5 --json databaseId,conclusion,createdAt,headSha > ${workspaceTmpDir}/ci-logs/recent-runs.json
+   - When saving PR diff for review:
+      gh pr diff ${prNumber} --repo ${owner}/${repo} > ${workspaceTmpDir}/diffs/pr-${prNumber}.diff
+   - When saving command output with stderr:
+      npm test 2>&1 | tee ${workspaceTmpDir}/test-output.log
+   - When investigating issue details:
+      gh issue view ${issueNumber} --repo ${owner}/${repo} --json body,comments > ${workspaceTmpDir}/issue-${issueNumber}.json
+
+`;
+  }
+
+  return `You are an AI issue solver using Google Gemini CLI.
+${workspaceInstructions}General guidelines.
+   - When you execute commands and the output becomes large, save the logs to files for easier review.
+   - When running commands, avoid setting a timeout yourself. Let them run as long as needed. The default timeout of 2 minutes is usually enough, and once commands finish, review the logs in the file.
+   - When running sudo commands, especially package installations like apt-get, yum, or npm install, run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.
+   - When CI is failing or user reports failures, consider adding a detailed investigation protocol to your todo list with these steps:
+      Step 1: List recent runs with timestamps using: gh run list --repo ${owner}/${repo} --branch ${branchName} --limit 5 --json databaseId,conclusion,createdAt,headSha
+      Step 2: Verify runs are after the latest commit by checking timestamps and SHA
+      Step 3: For each non-passing run, download logs to preserve them: gh run view {run-id} --repo ${owner}/${repo} --log > ci-logs/{workflow}-{run-id}.log
+      Step 4: Read each downloaded log file with the Read tool to understand the actual failures
+      Step 5: Report findings with specific errors and line numbers from logs
+      This detailed investigation is especially helpful when user mentions CI failures, asks to investigate logs, you see non-passing status, or when finalizing a PR.
+      Note: If user says "failing" but tools show "passing", this might indicate stale data - consider downloading fresh logs and checking timestamps to resolve the discrepancy.
+   - When a code or log file has more than 1500 lines, read it in chunks of 1500 lines.
+   - When facing a complex problem, do as much tracing as possible and turn on all verbose modes.
+${getExperimentsExamplesSubPrompt(argv)}
+   - When you face something extremely hard, use divide and conquer.
+
+Initial research.
+   - When you start, create a detailed plan for yourself and follow your todo list step by step. Add as many relevant points from these guidelines to the todo list as practical so you can track the work clearly.
+   - When the user mentions CI failures or asks to investigate logs, consider adding these todos to track the investigation: (1) list recent CI runs with timestamps, (2) download logs from failed runs to the ci-logs/ directory, (3) analyze error messages and identify the root cause, (4) implement a fix, (5) verify that the fix resolves the specific errors found in the logs.
+   - When you read the issue, read all details and comments thoroughly.
+   - When you see screenshots or images in issue descriptions, pull request descriptions, comments, or discussions, download the image to a local file first, then use the Read tool to view and analyze it. Before reading downloaded images with the Read tool, verify that the file is a valid image rather than HTML by using a CLI tool such as the 'file' command. When the file command shows "HTML", "text", or "ASCII text", the download failed, so do not call Read on that file. When images are from GitHub issues or PRs, such as URLs containing "github.com/user-attachments", use: curl -L -H "Authorization: token $(gh auth token)" -o <filename> "<url>"
+   - When you need issue details, use gh issue view https://github.com/${owner}/${repo}/issues/${issueNumber}.
+   - When you need related code, use gh search code --owner ${owner} [keywords].
+   - When you need repo context, read files in your working directory.${
+     argv?.promptCheckSiblingPullRequests !== false
+       ? `
+   - When you study related work, study the most recent related pull requests.`
+       : ''
+   }${
+     argv && argv.promptCaseStudies
+       ? `
+   - When working on this issue, create a comprehensive case study in the ./docs/case-studies/issue-${issueNumber}/ directory with logs, analysis, timeline, root cause investigation, and proposed solutions.`
+       : ''
+   }
+   - When the issue is not defined clearly enough, write a comment with clarifying questions.
+   - When accessing GitHub Gists (especially private ones), use gh gist view command instead of direct URL fetching to ensure proper authentication.
+   - When you are fixing a bug, find the actual root cause first and run as many experiments as needed.
+   - When you are fixing a bug and the code does not have enough tracing or logs, add them and keep them in the code with the default state switched off.
+   - When you need comments on a pull request, note that GitHub has three different comment types with different API endpoints:
+      1. PR review comments (inline code comments): gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate
+      2. PR conversation comments (general discussion): gh api repos/${owner}/${repo}/issues/${prNumber}/comments --paginate
+      3. PR reviews (approve/request changes): gh api repos/${owner}/${repo}/pulls/${prNumber}/reviews --paginate
+      Note: The command "gh pr view --json comments" only returns conversation comments and misses review comments.
+   - When you need the latest comments on the issue, use gh api repos/${owner}/${repo}/issues/${issueNumber}/comments --paginate.
+
+Solution development and testing.
+   - When issue is solvable, first create a test that reproduces the problem, then implement the fix.
+   - When implementing features, search for similar existing implementations in the codebase and use them as examples instead of implementing everything from scratch.
+   - When coding, commit each atomic step that is useful on its own to the pull request branch so interrupted work remains preserved in the pull request.
+   - When you test:
+      start from testing of small functions using separate scripts;
+      write unit tests with mocks for easy and quick start.
+   - When you test integrations, use existing framework.
+   - When you test solution draft, include automated checks in pr.
+   - When you write or modify tests, consider setting reasonable timeouts at test, suite, and CI job levels so failures surface quickly instead of hanging.
+   - When you see repeated test timeout patterns in CI, investigate the root cause rather than increasing timeouts.
+   - When the issue is unclear, write a comment on the issue with questions.
+   - When you encounter any problems that you are unable to solve yourself (any human feedback or help), write a comment to the pull request asking for help.
+   - When you need human help, use gh pr comment ${prNumber} --body "your message" --repo ${owner}/${repo}.
+
+Reproducible testing.
+   - When fixing a bug, create a test that reproduces the problem before implementing the fix. When you cannot reproduce the problem, you cannot verify the fix.
+   - When encountering logic bugs, write an automated test that fails due to the bug, then implement the fix to make it pass.
+   - When encountering UI bugs, capture a screenshot showing the problem state, then create a visual regression test or manual verification screenshot after the fix.
+   - When creating tests, prefer minimum reproducible examples, meaning the simplest test case that demonstrates the issue.
+   - When submitting a fix, include in the PR description: (1) how to reproduce the issue, (2) the automated test that verifies the fix, (3) before/after screenshots for UI issues.
+   - When a bug fix does not have a reproducing test, treat the fix as incomplete because regressions can occur later without notice.
+
+Preparing pull request.
+   - When you code, follow contributing guidelines.
+   - When you commit, write clear message.
+   - When you need examples of style, use gh pr list --repo ${owner}/${repo} --state merged --search [keywords].
+   - When you open pr, describe solution draft and include tests.
+   - When there is a package with version and GitHub Actions workflows for automatic release, update the version (or other necessary release trigger) in your pull request to prepare for next release.
+   - When you update existing pr ${prNumber}, use gh pr edit ${prNumber} --repo ${owner}/${repo} to modify title and description.
+   - When you are about to commit or push code, run local CI checks first if they are available in contributing guidelines.
+   - When you finish implementation, use gh pr ready ${prNumber} --repo ${owner}/${repo}.
+
+Workflow and collaboration.
+   - When you check branch, verify with git branch --show-current.
+   - When you push, push only to branch ${branchName}.
+   - When you finish, create a pull request from branch ${branchName}. If PR ${prNumber} already exists for this branch, update it instead.
+   - When you mention a result, include the pull request URL or comment URL.
+
+Self review.
+   - When you check your solution draft, run all tests locally.
+   - When you check your solution draft, verify git status shows a clean working tree with no uncommitted changes.
+   - When you compare with repo style, use gh pr diff [number].
+   - When you finalize, confirm code, tests, and description are consistent.${
+     argv && argv.promptEnsureAllRequirementsAreMet
+       ? `
+   - When no explicit feedback or requirements are provided, ensure all changes are correct, consistent, validated, tested, logged, and aligned with all discussed requirements by checking the issue description and all comments on the issue and pull request. Check that all CI or CD checks are passing.`
+       : ''
+   }
+
+GitHub CLI command patterns.
+   - When fetching lists from GitHub API, use the --paginate flag to ensure all results are returned.
+   - When listing PR review comments (inline code comments), use gh api repos/OWNER/REPO/pulls/NUMBER/comments --paginate.
+   - When listing PR conversation comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.
+   - When listing PR reviews, use gh api repos/OWNER/REPO/pulls/NUMBER/reviews --paginate.
+   - When listing issue comments, use gh api repos/OWNER/REPO/issues/NUMBER/comments --paginate.
+   - When adding PR comment, use gh pr comment NUMBER --body "text" --repo OWNER/REPO.
+   - When adding issue comment, use gh issue comment NUMBER --body "text" --repo OWNER/REPO.
+   - When viewing PR details, use gh pr view NUMBER --repo OWNER/REPO.
+   - When filtering with jq, use gh api repos/${owner}/${repo}/pulls/${prNumber}/comments --paginate --jq 'reverse | .[0:5]'.${
+     argv && argv.promptPlaywrightMcp
+       ? `
+
+Playwright MCP usage (browser automation via MCP tools).
+   - When you develop frontend web applications or debug UI issues, use Playwright MCP tools to test the UI in a real browser.
+   - When simple fetch-based browsing is insufficient for dynamic pages, use Playwright MCP browser automation as a fallback.
+   - When WebSearch tool fails or returns insufficient results, use Playwright MCP browser automation as a fallback for internet search.
+   - When reproducing or verifying UI bugs, take before/after screenshots and close the browser when finished.`
+       : ''
+   }${
+     modelSupportsVision
+       ? `
+
+Visual UI work and screenshots.
+   - When you work on visual UI changes, include a render or screenshot of the final result in the pull request description.
+   - When you save screenshots to the repository, use permanent links in the PR description such as https://github.com/${screenshotRepoPath}/blob/${branchName}/docs/screenshots/result.png?raw=true.`
+       : ''
+   }${ciExamples}${getArchitectureCareSubPrompt(argv)}`;
+};
+
+export default {
+  buildUserPrompt,
+  buildSystemPrompt,
+};

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', 'qwen'],
+    choices: ['claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen'],
     default: 'claude',
   },
 };

package/src/interactive-mode.lib.mjs

@@ -1321,7 +1321,7 @@ ${createRawJsonSection(data)}`;
 /**
  * Check if interactive mode is supported for the given tool
  *
- * @param {string} tool - Tool name (claude, opencode, codex)
+ * @param {string} tool - Tool name (claude, opencode, codex, agent, gemini)
  * @returns {boolean} Whether interactive mode is supported
  */
 export const isInteractiveModeSupported = tool => {

package/src/models/index.mjs

@@ -129,6 +129,19 @@ 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',
@@ -147,6 +160,7 @@ export const defaultModels = {
   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',
 };
 
@@ -227,6 +241,10 @@ export const CODEX_MODELS = {
   'gpt-4o': 'gpt-4o',
 };
 
+export const GEMINI_MODELS = {
+  ...geminiModels,
+};
+
 export const QWEN_MODELS = {
   ...qwenModels,
   'qwen3-coder': 'qwen3-coder',
@@ -257,7 +275,7 @@ export const AGENT_MODELS = {
 
 /**
  * Get the model map object for a given tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
  * @returns {Object} The model mapping for the tool
  */
 export const getModelMapForTool = tool => {
@@ -270,6 +288,8 @@ export const getModelMapForTool = tool => {
       return opencodeModels;
     case 'codex':
       return codexModels;
+    case 'gemini':
+      return geminiModels;
     case 'qwen':
       return qwenModels;
     default:
@@ -279,7 +299,7 @@ export const getModelMapForTool = tool => {
 
 /**
  * Get the default model for a given tool
- * @param {string} tool - The tool name (claude, agent, opencode, codex, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
  * @returns {string} The default model alias for the tool
  */
 export const getDefaultModelForTool = tool => {
@@ -332,7 +352,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, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
  * @param {string} model - The model name or alias
  * @returns {string} The full model ID
  */
@@ -346,6 +366,8 @@ export const mapModelForTool = (tool, model) => {
       return opencodeModels[model] || model;
     case 'codex':
       return codexModels[model] || model;
+    case 'gemini':
+      return geminiModels[model] || model;
     case 'qwen':
       return qwenModels[model] || model;
     default:
@@ -355,7 +377,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, qwen)
+ * @param {string} tool - The tool name (claude, agent, opencode, codex, gemini, qwen)
  * @param {string} model - The model name or alias
  * @returns {boolean} True if the model is compatible with the tool
  */
@@ -371,6 +393,8 @@ export const isModelCompatibleWithTool = (tool, model) => {
       return mappedModel.includes('/') || Object.keys(opencodeModels).includes(model);
     case 'codex':
       return Object.keys(codexModels).includes(model) || mappedModel.startsWith('gpt-');
+    case 'gemini':
+      return Object.keys(geminiModels).includes(model) || mappedModel.startsWith('gemini-');
     case 'qwen':
       return Object.keys(qwenModels).includes(model) || mappedModel.startsWith('qwen');
     default:
@@ -393,6 +417,8 @@ export const getValidModelsForTool = tool => {
       return Object.keys(opencodeModels);
     case 'codex':
       return Object.keys(codexModels);
+    case 'gemini':
+      return Object.keys(geminiModels);
     case 'qwen':
       return Object.keys(qwenModels);
     default:
@@ -406,6 +432,7 @@ 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'],
 };
@@ -447,7 +474,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', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
  * @returns {Object} The model mapping for the tool
  */
 const getValidationModelMapForTool = tool => {
@@ -456,6 +483,8 @@ const getValidationModelMapForTool = tool => {
       return OPENCODE_MODELS;
     case 'codex':
       return CODEX_MODELS;
+    case 'gemini':
+      return GEMINI_MODELS;
     case 'agent':
       return AGENT_MODELS;
     case 'qwen':
@@ -468,7 +497,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', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
  * @returns {string[]} Array of available model short names
  */
 export const getAvailableModelNames = tool => {
@@ -607,7 +636,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', 'qwen')
+ * @param {string} tool - The tool name ('claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen')
  * @returns {{ valid: boolean, message?: string, suggestions?: string[], mappedModel?: string, has1mSuffix?: boolean }}
  */
 export const validateModelName = (model, tool = 'claude') => {
@@ -715,7 +744,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, qwen)
+ * @param {string|null} tool - The tool identifier (claude, codex, opencode, agent, gemini, qwen)
  * @returns {string} User-friendly display name
  */
 export const getToolDisplayName = tool => {
@@ -729,6 +758,8 @@ export const getToolDisplayName = tool => {
       return 'OpenCode';
     case 'agent':
       return 'Agent CLI';
+    case 'gemini':
+      return 'Google Gemini CLI';
     case 'qwen':
       return 'Qwen Code';
     default:

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', 'qwen'],
+    choices: ['claude', 'opencode', 'codex', 'agent', 'gemini', 'qwen'],
     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, qwen). Experimental feature.',
+    description: 'Use separate workspace directory structure with repository/ and tmp/ folders. Works with all tools (claude, opencode, codex, agent, gemini, qwen). 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, 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 gemini, and --tool qwen.',
     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.',
+    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.',
     default: true,
   },
   'playwright-mcp-auto-cleanup': {

package/src/solve.mjs

@@ -93,6 +93,9 @@ let checkForUncommittedChanges;
 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;
@@ -754,6 +757,36 @@ try {
       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);
+
+    toolResult = await executeGemini({
+      issueUrl,
+      issueNumber,
+      prNumber,
+      prUrl,
+      branchName,
+      tempDir,
+      workspaceTmpDir,
+      isContinueMode,
+      mergeStateStatus,
+      forkedRepo,
+      feedbackLines,
+      forkActionsUrl,
+      owner,
+      repo,
+      argv,
+      log,
+      setLogFile,
+      getLogFile,
+      formatAligned,
+      getResourceSnapshot,
+      geminiPath,
+      $,
+    });
   } else if (argv.tool === 'qwen') {
     const qwenLib = await import('./qwen.lib.mjs');
     const { executeQwen, checkPlaywrightMcpAvailability: checkQwenPlaywrightMcp } = qwenLib;

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
@@ -208,6 +208,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 +247,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 +289,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 +304,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 +416,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

@@ -303,6 +303,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, gemini, qwen) [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');