[P4.1] Gemini adapter — build + parse + capabilities + tests + docs

[frankbria]

Phase 4 — Provider onboarding. Gemini is closest to Claude's shape.

Scope

• lib/agents/gemini.sh:
  • Build: -p/--prompt, -o json|stream-json, pre-assign --session-id <uuid>,
    -r/--resume, --approval-mode <default|auto_edit|yolo|plan>, -m <model>.
  • Parse: Gemini json/stream-json -> internal struct.
  • Capabilities: structured=yes, session=preassign (race-free, like claude),
    token usage / api-limit = verify against output.
• Tests via [P2.2]; docs/providers/GEMINI.md; README row.

Acceptance

• ralph --provider gemini drives the loop against a mock; preassigned-session path
  exercised. Full suite green.

Depends on: [P3.1].

[github-actions]

Triage: Feature / Enhancement

Category: Feature request (enhancement) — applied the enhancement label.

This issue is a well-specified implementation task in the multi-provider agent abstraction epic (already tagged multi-provider). It adds lib/agents/gemini.sh — command-build + output-normalize + a capabilities record — following the adapter contract, with tests, docs/providers/GEMINI.md, and a README row. It has clear scope and acceptance criteria.

Not a bug, and not a duplicate — each Phase-4 adapter issue targets a distinct provider CLI:

• [P3.1] Codex adapter (pilot) — build + parse + capabilities + tests + docs #317 [P3.1] Codex (pilot)
• [P4.1] Gemini adapter — build + parse + capabilities + tests + docs #318 [P4.1] Gemini ← this issue
• [P4.2] OpenCode adapter — build + parse + capabilities + tests + docs #319 [P4.2] OpenCode
• [P4.3] Droid adapter — build + parse + capabilities + tests + docs #320 [P4.3] Droid
• [P4.4] Kilocode adapter — build + parse + capabilities + tests + docs #321 [P4.4] Kilocode
• [P4.5] Copilot adapter (text-only, degraded) — build + parse + capabilities + tests + docs #322 [P4.5] Copilot

Recommended next steps

This work is dependency-gated and not yet ready to start:

• Depends on [P3.1] [P3.1] Codex adapter (pilot) — build + parse + capabilities + tests + docs #317 (the pilot Codex adapter that proves the seam end-to-end), which in turn depends on the Phase 0–2 foundation ([P0.1] Document provider capability matrix + adapter ADR #310–[P2.2] Generic adapter test harness (mock CLIs) #316).
• The implementation will reuse the [P2.2] [P2.2] Generic adapter test harness (mock CLIs) #316 generic adapter test harness for its unit tests.

Suggested ordering: land #310→#311→#312→#313→#314→#315→#316→#317 first, then this Gemini adapter becomes a near-mechanical application of the established pattern (Gemini's preassigned-session shape is the closest to Claude's, so it's a good first follow-on after the pilot).

Generated by Issue Triage Assistant for issue #318 · opus48 386.1K · ◷

[coderabbitai]

Coding Plan

Summary

• Establish minimal provider abstraction by extracting Claude code into lib/agents/claude.sh and adding case-statement routing (following the existing SANDBOX_PROVIDER pattern)
• Create lib/agents/gemini.sh implementing the same interface with Gemini-specific command building and session management (pre-assigned UUID for race-free operation)
• Extend parse_json_response() in lib/response_analyzer.sh to normalize Gemini JSON to the existing canonical schema, keeping all downstream consumers unchanged
• Use executable-on-PATH mock pattern for Gemini CLI testing, with comprehensive BATS tests covering unit, integration, and the preassigned-session path specified in acceptance criteria

Design Choices

Design Choice 1: Provider infrastructure dependency mismatch

Options Considered:

1. Block this ticket until a separate provider infrastructure ticket is completed
2. Include minimal provider abstraction infrastructure as part of this ticket
3. Build Gemini adapter without abstraction (hardcode parallel to Claude)

Chosen Option: 2

Rationale: Option 2: Include minimal provider abstraction as Phase 1 of this ticket, following the existing SANDBOX_PROVIDER routing pattern, to enable --provider gemini while keeping changes focused and maintainable.

Design Choice 2: Gemini CLI flag compatibility

Options Considered:

1. Assume all listed flags exist and implement directly
2. Build adapter with verified flags only, stub others

Chosen Option: 1

Rationale: Option 1: Implement all specified flags as the ticket explicitly lists them as requirements; the mock-based testing approach will validate the command structure without requiring live CLI access.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Provider Abstraction Infrastructure

Create the foundational provider routing layer by extracting Claude-specific code into an adapter and establishing the interface contract that Gemini will implement. This follows the existing SANDBOX_PROVIDER case-statement routing pattern.

Task 1: Create Provider Directory and Interface Contract

Establish the adapter directory structure and define the interface that all provider adapters must implement.

• Create lib/agents/ directory to house provider adapters
• Define the adapter interface contract as a documented set of required bash functions:
  • build_<provider>_command() → populates global AGENT_CMD_ARGS array
  • extract_<provider>_session_id() → returns session ID from output file
  • extract_<provider>_token_usage() → returns input+output token sum
  • get_<provider>_capabilities() → returns capability flags (structured, session_mode, etc.)
• Add AGENT_PROVIDER variable to ralph_loop.sh (default: claude)

Task 2: Add --provider Flag to CLI

Enable provider selection via command-line flag.

• Add --provider <name> flag parsing in ralph_loop.sh argument handling section
• Validate provider value against supported list (claude, gemini)
• Set AGENT_PROVIDER variable from flag value
• Add corresponding .ralphrc support for AGENT_PROVIDER environment variable

Task 3: Extract Claude Adapter

Move Claude-specific command building and session handling into a dedicated adapter file.

• Create lib/agents/claude.sh containing:
  • build_claude_command() — moved from ralph_loop.sh (lines ~1535-1638)
  • extract_claude_session_id() — wrapper around existing jq extraction logic
  • extract_claude_token_usage() — wrapper around existing extract_token_usage()
  • get_claude_capabilities() — returns structured=yes session_mode=server_assigned
• Update ralph_loop.sh to source lib/agents/claude.sh
• Rename execute_claude_code() to execute_agent_code() with provider routing

Task 4: Implement Provider Router

Create the dispatch mechanism that routes to the appropriate adapter based on AGENT_PROVIDER.

• Add build_agent_command() router function in ralph_loop.sh:

  case "$AGENT_PROVIDER" in
    claude) build_claude_command "$@" ;;
    gemini) build_gemini_command "$@" ;;
    *) error and exit ;;
  esac
  

• Add similar routers for extract_session_id(), extract_token_usage()
• Update save_claude_session() → save_agent_session() with provider dispatch
• Update init_claude_session() → init_agent_session() with provider dispatch

🤖 Prompt for AI agents

Implement the provider abstraction infrastructure layer in Ralph by extracting
Claude-specific code into an adapter and establishing a routing mechanism,
following the existing `SANDBOX_PROVIDER` case-statement pattern.

- Create the `lib/agents/` directory to house provider adapters
- Define the adapter interface contract as a documented set of required bash
functions for each provider:
  - `build_<provider>_command()` — populates global `AGENT_CMD_ARGS` array
  - `extract_<provider>_session_id()` — returns session ID from output file
  - `extract_<provider>_token_usage()` — returns input+output token sum
- `get_<provider>_capabilities()` — returns capability flags (e.g.,
`structured`, `session_mode`)
- Add `AGENT_PROVIDER` variable to `ralph_loop.sh` with a default value of
`claude`
- Add `--provider <name>` flag parsing in the argument handling section of
`ralph_loop.sh`; validate the value against the supported list (`claude`,
`gemini`) and set `AGENT_PROVIDER` accordingly; also add `.ralphrc` support for
the `AGENT_PROVIDER` environment variable
- Create `lib/agents/claude.sh` by moving Claude-specific logic from
`ralph_loop.sh` (around lines 1535–1638):
  - `build_claude_command()` — moved command builder
  - `extract_claude_session_id()` — wraps existing jq extraction logic
  - `extract_claude_token_usage()` — wraps existing `extract_token_usage()`
- `get_claude_capabilities()` — returns `structured=yes
session_mode=server_assigned`
- Update `ralph_loop.sh` to source `lib/agents/claude.sh` and rename
`execute_claude_code()` to `execute_agent_code()` with provider routing
- Add `build_agent_command()` router function in `ralph_loop.sh` using a case
statement dispatching to `build_claude_command` or `build_gemini_command` (or
erroring on unknown providers)
- Add equivalent routers for `extract_session_id()` and `extract_token_usage()`
- Rename `save_claude_session()` → `save_agent_session()` and
`init_claude_session()` → `init_agent_session()`, each with provider dispatch
via case statements

Phase 2: Gemini Adapter Implementation

Build the Gemini-specific adapter implementing the defined interface, and extend response parsing to handle Gemini's JSON output format.

Task 1: Create Gemini Command Builder

Implement command construction for Gemini CLI invocation.

• Create lib/agents/gemini.sh with build_gemini_command() function
• Support flag mappings as specified in ticket:
  • -p/--prompt for prompt content
  • -o/--output-format json|stream-json for structured output
  • --session-id <uuid> for pre-assigned session (race-free like Claude)
  • -r/--resume for session resumption
  • --approval-mode <default|auto_edit|yolo|plan> for tool approval
  • -m/--model for model selection
• Populate global AGENT_CMD_ARGS array matching Claude adapter pattern
• Pre-generate UUID for session-id using uuidgen or /proc/sys/kernel/random/uuid

Task 2: Implement Gemini Session Management

Add session handling functions specific to Gemini's session model.

• Implement extract_gemini_session_id() to parse session ID from Gemini JSON output
• Implement init_gemini_session() for pre-assigned session ID generation
• Store sessions in .ralph/.gemini_session_id (separate from Claude to avoid conflicts)
• Support --resume <uuid> for session continuity following Gemini CLI semantics

Task 3: Implement Gemini Token Extraction

Add token usage extraction for API limit tracking.

• Implement extract_gemini_token_usage() to parse token counts from Gemini output
• Handle Gemini's usageMetadata field structure (differs from Claude's usage object)
• Return combined input+output token sum for rate limiting compatibility

Task 4: Define Gemini Capabilities

Implement capability reporting for the Gemini provider.

• Implement get_gemini_capabilities() returning:
  • structured=yes (supports JSON output)
  • session_mode=preassign (race-free pre-assigned session IDs)
  • streaming=yes (supports stream-json)
• These capabilities inform ralph_loop.sh behavior decisions

Task 5: Extend Response Analyzer for Gemini JSON

Add Gemini JSON format handling to the normalization layer.

• Update parse_json_response() in lib/response_analyzer.sh to detect and handle Gemini format
• Add Format 4 branch for Gemini structure:
  • Extract text from candidates[].content.parts[].text path
  • Extract session ID from Gemini's session field
  • Map usageMetadata to normalized token fields
  • Handle finishReason for completion/error detection
• Normalize to existing canonical .json_parse_result schema so downstream consumers work unchanged

🤖 Prompt for AI agents

Implement the Gemini-specific adapter in `lib/agents/gemini.sh` and extend
`lib/response_analyzer.sh` to normalize Gemini JSON output to the existing
canonical schema.

**`lib/agents/gemini.sh`:**
- Create the file with `build_gemini_command()` that populates the global
`AGENT_CMD_ARGS` array, supporting the following flags:
  - `-p/--prompt` for prompt content
  - `-o/--output-format json|stream-json` for structured output
  - `--session-id <uuid>` for pre-assigned session IDs
  - `-r/--resume` for session resumption
  - `--approval-mode <default|auto_edit|yolo|plan>` for tool approval
  - `-m/--model` for model selection
- Pre-generate the UUID for `--session-id` using `uuidgen` or
`/proc/sys/kernel/random/uuid` before CLI invocation (race-free pattern)
- Implement `extract_gemini_session_id()` to parse session ID from Gemini JSON
output
- Implement `init_gemini_session()` for pre-assigned session ID generation;
store session in `.ralph/.gemini_session_id` (separate from Claude's session
file)
- Support `--resume <uuid>` for session continuity
- Implement `extract_gemini_token_usage()` to parse token counts from Gemini's
`usageMetadata` field structure and return the combined input+output token sum
- Implement `get_gemini_capabilities()` returning: `structured=yes`,
`session_mode=preassign`, `streaming=yes`

**`lib/response_analyzer.sh`:**
- Update `parse_json_response()` to detect and handle Gemini's JSON format as a
new Format 4 branch
- Extract text from `candidates[].content.parts[].text`
- Extract session ID from Gemini's session field
- Map `usageMetadata` to normalized token fields
- Handle `finishReason` for completion/error detection
- Normalize output to the existing canonical `.json_parse_result` schema so all
downstream consumers remain unchanged

Phase 3: Testing and Documentation

Implement comprehensive tests using the established BATS/mock pattern and create provider documentation following existing patterns.

Task 1: Create Mock Gemini CLI

Build a test double for the Gemini CLI following the executable-on-PATH mock pattern.

• Create tests/helpers/mock_gemini.bash with mock CLI generator function
• Support configurable responses via $TEST_DIR/mock_gemini_responses/
• Log invocation args to $TEST_DIR/gemini_args for assertion verification
• Return scripted JSON responses matching Gemini output format
• Support both json and stream-json output modes

Task 2: Create Gemini Adapter Unit Tests

Add unit tests for all Gemini adapter functions.

• Create tests/unit/test_agents_gemini.bats following existing lib test patterns
• Test build_gemini_command() produces correct flag combinations
• Test extract_gemini_session_id() handles various JSON shapes
• Test extract_gemini_token_usage() correctly sums tokens
• Test get_gemini_capabilities() returns expected values
• Test pre-assigned session ID generation

Task 3: Create Provider Router Integration Tests

Test the provider routing mechanism end-to-end.

• Create tests/integration/test_provider_routing.bats
• Test --provider gemini flag is parsed correctly
• Test AGENT_PROVIDER=gemini environment variable works
• Test router dispatches to correct adapter functions
• Test invalid provider names produce appropriate errors

Task 4: Create Response Analyzer Gemini Tests

Test Gemini JSON parsing integration.

• Add Gemini JSON fixtures to tests/helpers/fixtures.bash:
  • create_sample_gemini_output_success
  • create_sample_gemini_output_error
  • create_sample_gemini_stream_json
• Add tests in tests/unit/test_response_analyzer.bats for Gemini format detection and parsing
• Verify normalization produces correct canonical schema

Task 5: Create Preassigned Session Path Tests

Verify the race-free session management specified in acceptance criteria.

• Test that session ID is generated before Gemini CLI invocation
• Test that --session-id <uuid> is included in command args
• Test that session ID is correctly persisted after successful response
• Test session resumption with --resume flag

Task 6: Create Provider Documentation

Document the Gemini provider following existing sandbox documentation patterns.

• Create docs/providers/GEMINI.md with:
  • One-line summary with --provider gemini invocation
  • Setup section (Gemini CLI installation requirements)
  • Usage section with bash examples
  • Equivalent .ralphrc settings
  • Session management explanation
  • Supported flags and capabilities matrix
• Follow structure established by docs/DOCKER_SANDBOX.md and docs/E2B_SANDBOX.md

Task 7: Update README with Provider Section

Add Gemini to the README's provider documentation.

• Add feature bullet in feature list: "Multi-Provider Support - Run with Claude (default) or Gemini via --provider gemini"
• Add ## Provider Support section with subsections for Claude and Gemini
• Include setup, usage, and .ralphrc configuration for each
• Link to detailed docs/providers/GEMINI.md

Task 8: Update CLAUDE.md with Provider Architecture

Document the provider abstraction in the project's Claude guidance file.

• Add Library Components entry for lib/agents/claude.sh and lib/agents/gemini.sh
• Document AGENT_PROVIDER variable and --provider flag
• Add provider routing explanation in Key Commands section
• Update any references to Claude-specific code that was extracted

🤖 Prompt for AI agents

Implement comprehensive BATS tests for the Gemini adapter and provider routing,
and create all required documentation following existing project patterns.

**Testing:**
- Create `tests/helpers/mock_gemini.bash` as a mock CLI generator following the
executable-on-PATH pattern:
  - Support configurable responses via `$TEST_DIR/mock_gemini_responses/`
  - Log invocation args to `$TEST_DIR/gemini_args` for assertion verification
- Return scripted JSON responses matching Gemini output format for both `json`
and `stream-json` modes
- Create `tests/unit/test_agents_gemini.bats` following existing lib test
patterns, testing:
  - `build_gemini_command()` for correct flag combinations
  - `extract_gemini_session_id()` across various JSON shapes
  - `extract_gemini_token_usage()` correctly sums tokens
  - `get_gemini_capabilities()` returns expected values
  - Pre-assigned session ID generation
- Create `tests/integration/test_provider_routing.bats` testing:
  - `--provider gemini` flag parsing
  - `AGENT_PROVIDER=gemini` environment variable support
  - Correct adapter dispatch by the router
  - Appropriate errors for invalid provider names
- Add Gemini JSON fixtures (`create_sample_gemini_output_success`,
`create_sample_gemini_output_error`, `create_sample_gemini_stream_json`) to
`tests/helpers/fixtures.bash`
- Add Gemini format detection and parsing tests to
`tests/unit/test_response_analyzer.bats`, verifying normalization to the
canonical schema
- Add preassigned session path tests verifying: session ID generated before CLI
invocation, `--session-id <uuid>` in command args, correct persistence after
successful response, and `--resume` flag behavior

**Documentation:**
- Create `docs/providers/GEMINI.md` following the structure of
`docs/DOCKER_SANDBOX.md` and `docs/E2B_SANDBOX.md`, including: one-line summary,
setup (Gemini CLI installation), usage examples, `.ralphrc` settings, session
management explanation, and a supported flags/capabilities matrix
- Update `README.md`: add a **Multi-Provider Support** feature bullet and a new
`## Provider Support` section with Claude and Gemini subsections (setup, usage,
`.ralphrc` config), linking to `docs/providers/GEMINI.md`
- Update `CLAUDE.md`: add Library Components entries for `lib/agents/claude.sh`
and `lib/agents/gemini.sh`, document `AGENT_PROVIDER` and `--provider`, add
provider routing explanation in Key Commands, and update any references to
extracted Claude-specific code

Research

Ralph is a bash-based autonomous loop tool currently hardwired to Anthropic's Claude Code CLI. There is no existing provider abstraction—CLAUDE_CODE_CMD and CLAUDE_CMD_ARGS are used directly throughout ralph_loop.sh. Response parsing lives in lib/response_analyzer.sh with parse_json_response() handling three Claude-specific JSON shapes. The codebase has a sandbox provider pattern (SANDBOX_PROVIDER with docker/e2b routing via case statements) that can serve as a model for agent provider routing. Tests use BATS with executable-on-PATH mock patterns. Documentation follows a pattern of dedicated markdown files in docs/ plus README sections.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement the provider abstraction infrastructure layer in Ralph by extracting
Claude-specific code into an adapter and establishing a routing mechanism,
following the existing `SANDBOX_PROVIDER` case-statement pattern.

- Create the `lib/agents/` directory to house provider adapters
- Define the adapter interface contract as a documented set of required bash
functions for each provider:
  - `build_<provider>_command()` — populates global `AGENT_CMD_ARGS` array
  - `extract_<provider>_session_id()` — returns session ID from output file
  - `extract_<provider>_token_usage()` — returns input+output token sum
- `get_<provider>_capabilities()` — returns capability flags (e.g.,
`structured`, `session_mode`)
- Add `AGENT_PROVIDER` variable to `ralph_loop.sh` with a default value of
`claude`
- Add `--provider <name>` flag parsing in the argument handling section of
`ralph_loop.sh`; validate the value against the supported list (`claude`,
`gemini`) and set `AGENT_PROVIDER` accordingly; also add `.ralphrc` support for
the `AGENT_PROVIDER` environment variable
- Create `lib/agents/claude.sh` by moving Claude-specific logic from
`ralph_loop.sh` (around lines 1535–1638):
  - `build_claude_command()` — moved command builder
  - `extract_claude_session_id()` — wraps existing jq extraction logic
  - `extract_claude_token_usage()` — wraps existing `extract_token_usage()`
- `get_claude_capabilities()` — returns `structured=yes
session_mode=server_assigned`
- Update `ralph_loop.sh` to source `lib/agents/claude.sh` and rename
`execute_claude_code()` to `execute_agent_code()` with provider routing
- Add `build_agent_command()` router function in `ralph_loop.sh` using a case
statement dispatching to `build_claude_command` or `build_gemini_command` (or
erroring on unknown providers)
- Add equivalent routers for `extract_session_id()` and `extract_token_usage()`
- Rename `save_claude_session()` → `save_agent_session()` and
`init_claude_session()` → `init_agent_session()`, each with provider dispatch
via case statements
===============================================================================

Task: 2

Implement the Gemini-specific adapter in `lib/agents/gemini.sh` and extend
`lib/response_analyzer.sh` to normalize Gemini JSON output to the existing
canonical schema.

**`lib/agents/gemini.sh`:**
- Create the file with `build_gemini_command()` that populates the global
`AGENT_CMD_ARGS` array, supporting the following flags:
  - `-p/--prompt` for prompt content
  - `-o/--output-format json|stream-json` for structured output
  - `--session-id <uuid>` for pre-assigned session IDs
  - `-r/--resume` for session resumption
  - `--approval-mode <default|auto_edit|yolo|plan>` for tool approval
  - `-m/--model` for model selection
- Pre-generate the UUID for `--session-id` using `uuidgen` or
`/proc/sys/kernel/random/uuid` before CLI invocation (race-free pattern)
- Implement `extract_gemini_session_id()` to parse session ID from Gemini JSON
output
- Implement `init_gemini_session()` for pre-assigned session ID generation;
store session in `.ralph/.gemini_session_id` (separate from Claude's session
file)
- Support `--resume <uuid>` for session continuity
- Implement `extract_gemini_token_usage()` to parse token counts from Gemini's
`usageMetadata` field structure and return the combined input+output token sum
- Implement `get_gemini_capabilities()` returning: `structured=yes`,
`session_mode=preassign`, `streaming=yes`

**`lib/response_analyzer.sh`:**
- Update `parse_json_response()` to detect and handle Gemini's JSON format as a
new Format 4 branch
- Extract text from `candidates[].content.parts[].text`
- Extract session ID from Gemini's session field
- Map `usageMetadata` to normalized token fields
- Handle `finishReason` for completion/error detection
- Normalize output to the existing canonical `.json_parse_result` schema so all
downstream consumers remain unchanged
===============================================================================

Task: 3

Implement comprehensive BATS tests for the Gemini adapter and provider routing,
and create all required documentation following existing project patterns.

**Testing:**
- Create `tests/helpers/mock_gemini.bash` as a mock CLI generator following the
executable-on-PATH pattern:
  - Support configurable responses via `$TEST_DIR/mock_gemini_responses/`
  - Log invocation args to `$TEST_DIR/gemini_args` for assertion verification
- Return scripted JSON responses matching Gemini output format for both `json`
and `stream-json` modes
- Create `tests/unit/test_agents_gemini.bats` following existing lib test
patterns, testing:
  - `build_gemini_command()` for correct flag combinations
  - `extract_gemini_session_id()` across various JSON shapes
  - `extract_gemini_token_usage()` correctly sums tokens
  - `get_gemini_capabilities()` returns expected values
  - Pre-assigned session ID generation
- Create `tests/integration/test_provider_routing.bats` testing:
  - `--provider gemini` flag parsing
  - `AGENT_PROVIDER=gemini` environment variable support
  - Correct adapter dispatch by the router
  - Appropriate errors for invalid provider names
- Add Gemini JSON fixtures (`create_sample_gemini_output_success`,
`create_sample_gemini_output_error`, `create_sample_gemini_stream_json`) to
`tests/helpers/fixtures.bash`
- Add Gemini format detection and parsing tests to
`tests/unit/test_response_analyzer.bats`, verifying normalization to the
canonical schema
- Add preassigned session path tests verifying: session ID generated before CLI
invocation, `--session-id <uuid>` in command args, correct persistence after
successful response, and `--resume` flag behavior

**Documentation:**
- Create `docs/providers/GEMINI.md` following the structure of
`docs/DOCKER_SANDBOX.md` and `docs/E2B_SANDBOX.md`, including: one-line summary,
setup (Gemini CLI installation), usage examples, `.ralphrc` settings, session
management explanation, and a supported flags/capabilities matrix
- Update `README.md`: add a **Multi-Provider Support** feature bullet and a new
`## Provider Support` section with Claude and Gemini subsections (setup, usage,
`.ralphrc` config), linking to `docs/providers/GEMINI.md`
- Update `CLAUDE.md`: add Library Components entries for `lib/agents/claude.sh`
and `lib/agents/gemini.sh`, document `AGENT_PROVIDER` and `--provider`, add
provider routing explanation in Key Commands, and update any references to
extracted Claude-specific code

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!