From befd365b46ef5ce48b908168beeb4419300d97a2 Mon Sep 17 00:00:00 2001
From: Charles Ouimet <charles.ouimet@gmail.com>
Date: Thu, 14 May 2026 13:06:09 -0400
Subject: [PATCH] [issues/529] Add Gemini Code Assist as built-in AI assistant
 destination
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds Google Gemini Code Assist (`google.geminicodeassist`) as a fourth built-in AI assistant destination alongside Claude Code, Cursor AI, and GitHub Copilot Chat. The integration mirrors the Claude Code pattern exactly: a typed destination kind, focus command wiring, availability detection via extension + command probing, cold-start re-focus loop with configurable timing, and a dedicated bind command. Seven integration tests cover bind, availability, picker ordering, and cold-start validation. README messaging was also updated across the board to consistently include Gemini in named-tool lists, surface terminal AI tools alongside extensions, and replace "AI model" with "AI tool" throughout.

- **Gemini Code Assist destination** — new `'gemini-code-assist'` kind in `DESTINATION_KINDS` and `AI_ASSISTANT_KINDS`; `GeminiCodeAssistBindOptions` in the `BindOptions` union; five new message codes (display name, error, info-not-available, user-instructions, status-bar jump success); EN strings wired in `messages.en.ts`
- **Detection utility** — `isGeminiCodeAssistAvailable.ts` checks command `cloudcode.gemini.chatView.focus` first, falls back to extension presence `google.geminicodeassist`; 100% coverage unit test suite
- **Cold-start re-focus loop** — `aiAssistantFocusCommands.ts` includes `GEMINI_CODE_ASSIST_FOCUS_COMMANDS` with the same `getColdRefocus()` factory the Claude Code destination uses; `destinationBuilders.ts` entry keyed by `'google.geminicodeassist'` with lazy validation lambda; shared defaults `DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS` (2500) and `DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS` (300) in `settingDefaults.ts`; configurable via `rangelink.destinations.gemini.coldStartDelayMs` and `coldRefocusIntervalMs`
- **Availability & routing** — `DestinationAvailabilityService.ts` info-map entry; `PasteDestinationManager.ts` error-code and send-path switch cases; `Destination.ts` display-name entry
- **Picker ordering** — `'gemini-code-assist'` inserted between `'claude-code'` and `'cursor-ai'` in `DESTINATION_PICKER_SEQUENCE` and group map
- **Command wiring** — `CMD_BIND_TO_GEMINI_CODE_ASSIST` in `commandIds.ts`; registered in `wireSubscriptions.ts`; `package.json` contributes `"Bind to Gemini Code Assist"` command
- **Integration tests** — 7 Gemini tests (gemini-code-assist-001 through 007) covering bind, availability, picker ordering, and cold-start config validation; `waitForExtensionActive()` helper for Gemini's ~4-6s activation delay; `resetRangelinkSettings()` now clears all 3 VS Code config scopes (Global, Workspace, WorkspaceFolder) to prevent config leakage between tests
- **README improvements** — Added Gemini Code Assist to all named-tool lists (lines 24, 31); added "or runs in a terminal" to AI-agnostic messaging (line 27); changed "Choice of AI model" to "Choice of AI tool" with product names instead of model names (line 41); added separate "Terminal AI tllet in "Perfect For" section (line 48-49); normalized "Claude Code" naming throughout
- **Documentation** — CHANGELOG: Added entry for Gemini Code Assist Integration under `[Unreleased]`; README updated (see above)

- [x] All 1912 unit tests pass (109 suites)
- [x] New unit tests for `isGeminiCodeAssistAvailable.ts` (100% coverage)
- [x] 7 new integration tests for Gemini Code Assist in `builtInAiAssistants.test.ts`
- [x] QA YAML updated with new test cases (bind-to-destination-029 through bind-to-destination-038)
- [ ] Manual testing: bind to Gemini Code Assist and verify auto-send behavior with the extension installed

Closes https://github.com/couimet/rangelink/issues/529
---
 .../.vscode-test.with-extensions.mjs          |   6 +-
 .../rangelink-vscode-extension/CHANGELOG.md   |  10 +-
 packages/rangelink-vscode-extension/README.md |  44 ++-
 .../rangelink-vscode-extension/package.json   |  20 ++
 .../qa/qa-test-cases-v1.1.0.yaml              | 106 ++++++
 .../setup-integration-test-settings.js        |   5 +
 .../scripts/test-release-run.sh               |   2 +-
 .../__integration-tests__/helpers/index.ts    |   1 +
 .../helpers/settingsHelpers.ts                |   2 +
 .../__integration-tests__/helpers/testEnv.ts  |  28 ++
 .../suite/bindToDestination.test.ts           |  32 +-
 .../suite/builtInAiAssistants.test.ts         | 328 +++++++++++++++++-
 .../suite/clipboardPreservation.test.ts       |  56 +++
 .../suite/commandRegistration.test.ts         |   1 +
 .../suite/customAiAssistants.test.ts          |   9 +-
 .../constants/packageJsonContracts.test.ts    |  30 +-
 .../destinations/DestinationRegistry.test.ts  |   3 +-
 .../PasteDestinationManager.test.ts           | 107 ++++++
 .../destinations/destinationBuilders.test.ts  |  46 ++-
 .../buildDestinationQuickPickItems.test.ts    |  91 +++++
 .../src/__tests__/extension.test.ts           | 115 +++---
 .../createMockBindableQuickPickItem.ts        |   3 +-
 .../helpers/createMockDestinationRegistry.ts  |  13 +-
 .../createMockFocusCapabilityFactory.ts       |   2 +-
 ...ckGeminiCodeAssistComposableDestination.ts |  26 ++
 .../createMockGeminiCodeAssistDestination.ts  |  22 ++
 .../src/__tests__/helpers/index.ts            |   3 +
 .../spyOnIsGeminiCodeAssistAvailable.ts       |   9 +
 .../services/ClipboardRouter.test.ts          |   2 +-
 .../src/__tests__/wireSubscriptions.test.ts   |   4 +-
 .../src/constants/commandIds.ts               |   1 +
 .../src/constants/settingDefaults.ts          |  22 +-
 .../src/constants/settingKeys.ts              |   4 +
 .../DestinationAvailabilityService.ts         |   2 +
 .../src/destinations/DestinationRegistry.ts   |   1 +
 .../destinations/PasteDestinationManager.ts   |   3 +
 .../destinations/aiAssistantFocusCommands.ts  |   4 +
 .../AIAssistantFocusCapability.ts             |   2 +-
 .../src/destinations/capabilities/index.ts    |   4 +-
 .../src/destinations/destinationBuilders.ts   |  48 ++-
 .../src/destinations/index.ts                 |   1 +
 .../utils/buildDestinationQuickPickItems.ts   |   9 +-
 .../src/i18n/messages.en.ts                   |   8 +
 .../src/services/ClipboardRouter.ts           |   6 +-
 .../src/types/BindOptions.ts                  |   9 +
 .../src/types/DestinationKind.ts              |   2 +
 .../src/types/MessageCode.ts                  |   5 +
 .../isClaudeCodeAvailable.test.ts             |  38 +-
 .../aiAssistants/isCursorIDEDetected.test.ts  |  10 +
 .../isGeminiCodeAssistAvailable.test.ts       | 146 ++++++++
 .../isGitHubCopilotChatAvailable.test.ts      |  74 ++--
 .../utils/aiAssistants/builtInAiAssistants.ts |   3 +
 .../src/utils/aiAssistants/index.ts           |   2 +
 .../aiAssistants/isClaudeCodeAvailable.ts     |   6 +-
 .../isGeminiCodeAssistAvailable.ts            |  27 ++
 .../isGitHubCopilotChatAvailable.ts           |  19 +-
 .../src/wireSubscriptions.ts                  |  11 +-
 .../dummy-ai-extension/extension.js           |   8 +
 .../dummy-ai-extension/package.json           |   4 +
 59 files changed, 1410 insertions(+), 195 deletions(-)
 create mode 100644 packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistComposableDestination.ts
 create mode 100644 packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistDestination.ts
 create mode 100644 packages/rangelink-vscode-extension/src/__tests__/helpers/spyOnIsGeminiCodeAssistAvailable.ts
 create mode 100644 packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGeminiCodeAssistAvailable.test.ts
 create mode 100644 packages/rangelink-vscode-extension/src/utils/aiAssistants/builtInAiAssistants.ts
 create mode 100644 packages/rangelink-vscode-extension/src/utils/aiAssistants/isGeminiCodeAssistAvailable.ts

diff --git a/packages/rangelink-vscode-extension/.vscode-test.with-extensions.mjs b/packages/rangelink-vscode-extension/.vscode-test.with-extensions.mjs
index 177c2f2a8..915ae956a 100644
--- a/packages/rangelink-vscode-extension/.vscode-test.with-extensions.mjs
+++ b/packages/rangelink-vscode-extension/.vscode-test.with-extensions.mjs
@@ -3,9 +3,9 @@ import { defineConfig } from '@vscode/test-cli';
 import { ASSISTED_TIMEOUT_MS, BASE_CONFIG, userDataDir } from './.vscode-test.base.mjs';
 
 // Marketplace extensions installed before tests run. With these present,
-// isClaudeCodeAvailable() returns true, enabling tests that verify real
-// focus + paste behavior.
-const MARKETPLACE_EXTENSIONS = ['anthropic.claude-code'];
+// isGeminiCodeAssistAvailable() and isClaudeCodeAvailable() return true,
+// enabling tests that verify real focus + paste behavior.
+const MARKETPLACE_EXTENSIONS = ['google.geminicodeassist', 'anthropic.claude-code'];
 
 export default defineConfig([
   {
diff --git a/packages/rangelink-vscode-extension/CHANGELOG.md b/packages/rangelink-vscode-extension/CHANGELOG.md
index 91d3f7537..9cd01e5c8 100644
--- a/packages/rangelink-vscode-extension/CHANGELOG.md
+++ b/packages/rangelink-vscode-extension/CHANGELOG.md
@@ -35,12 +35,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - When more open files exist beyond the inline list, extras collapse into "More files..." which opens a secondary picker
   - Secondary picker organizes all open files into "Active Files" section + per-"Tab Group N" sections
   - Escaping the secondary picker returns to the destination picker
+- **Gemini Code Assist Integration** - Paste destination for Google's Gemini Code Assist (#529) <sup>Unreleased</sup>
+  - Automatically inserts links and selected text directly into Gemini Code Assist
+  - Requires [Gemini Code Assist](https://marketplace.visualstudio.com/items?itemName=Google.geminicodeassist) extension (`Google.geminicodeassist`)
+  - Configurable cold-start timing: `rangelink.destinations.gemini.coldStartDelayMs` (default: `2500`) and `rangelink.destinations.gemini.coldRefocusIntervalMs` (default: `300`) — tune for your machine's speed; increase the delay on slower hardware if the initial paste after binding silently fails to reach the Gemini panel
 - **Custom AI Assistants** - Connect RangeLink to any AI tool with a VS Code extension (#500) <sup>Unreleased</sup>
   - New setting `rangelink.customAiAssistants`: three-tier command schema — `insertCommands` (direct text delivery), `focusAndPasteCommands` (focus + auto-paste), `focusCommands` (focus + manual paste toast)
   - Custom assistants appear in the destination picker (R-D) alongside built-in destinations
   - Lazy tier resolution: RangeLink checks which commands are registered on first use and caches the winning tier — no per-operation overhead
   - Override built-in assistants (Cursor, Claude Code, Copilot) via config with automatic fallback to hardcoded commands
   - `${content}` template interpolation for insert commands with non-standard argument formats
+- **Claude Code Cold-Start Timing** - Configurable cold-start settings for the Claude Code Extension destination <sup>Unreleased</sup>
+  - `rangelink.destinations.claudeCode.coldStartDelayMs` (default: `2500`) and `rangelink.destinations.claudeCode.coldRefocusIntervalMs` (default: `300`) — tune for your machine's speed; increase the delay on slower hardware if the initial paste after binding silently fails to reach the Claude Code panel
 - **Release Notifier** - Once-per-upgrade notification so new versions don't go unnoticed (#525)
   - On upgrade, shows "RangeLink updated to vX.Y.Z. See what changed!" with "What's New" and "Skip for this version" buttons
   - "What's New" opens the GitHub releases page; "Skip for this version" silences without opening the browser
@@ -116,9 +122,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Forgiving filename navigation** - Links with bare filenames (no directory path) now navigate when exactly one matching file exists in the workspace (#342)
   - Covers links generated by AI tools that omit directory prefixes (e.g., `RangeLinkNavigationHandler.ts#L10`)
   - When the filename is ambiguous (multiple matches) or not found, the existing "Cannot find file" warning is shown
-- **Claude Code cold-start re-focus loop** - Adds configurable `coldStartDelayMs` and `coldRefocusIntervalMs` settings under `rangelink.destinations.claudeCode.*` to ensure the chat panel is ready before the first paste dispatch after binding.
-
-<!-- TODO: #366 unhide when bookmarks graduate from beta — re-add these entries to the sections above
+  <!-- TODO: #366 unhide when bookmarks graduate from beta — re-add these entries to the sections above
 - R-M menu: add "List Bookmarks / Manage Bookmarks" bullet
 - Editor Content context menu: add "RangeLink: Save Selection as Bookmark" row
 - **Bookmarks System** - Save code locations for quick access later
diff --git a/packages/rangelink-vscode-extension/README.md b/packages/rangelink-vscode-extension/README.md
index fe0aae092..9f524563c 100644
--- a/packages/rangelink-vscode-extension/README.md
+++ b/packages/rangelink-vscode-extension/README.md
@@ -21,14 +21,14 @@ Every AI coding assistant has its own way to share code — different shortcuts,
 
 **RangeLink unifies it:**
 
-- **One keybinding** — `Cmd+R Cmd+L` works with Claude, Copilot, Cursor, terminal tools, text editors. Learn once, use everywhere.
+- **One keybinding** — `Cmd+R Cmd+L` works with Claude Code, Gemini Code Assist, Copilot, Cursor, terminal tools, text editors. Learn once, use everywhere.
 - **Better precision** — Character-level ranges, not just lines. Share exactly what matters.
 - **Universal format** — GitHub-style links work in PRs, Slack, docs. Not proprietary.
-- **AI-agnostic** — Your workflow doesn't change when you switch AI assistants. Bring your own AI tool — if it has a VS Code extension with a focus command, RangeLink can paste into it.
+- **AI-agnostic** — Your workflow doesn't change when you switch AI tools. Bring your own — if it has a VS Code extension with a focus command, or runs in a terminal, RangeLink can paste into it.
 
 ### For AI-Assisted Development
 
-**Using Claude Code, Cursor, Copilot, or any other AI tool?** RangeLink eliminates the context-sharing friction:
+**Using Claude Code, Gemini Code Assist, Cursor, Copilot, or any other AI tool — in an extension or terminal?** RangeLink eliminates the context-sharing friction:
 
 1. **Select code** → Generate link (`Cmd+R Cmd+L`)
 2. **Destination handles delivery** → Link appears where your AI can see it
@@ -38,14 +38,15 @@ Every AI coding assistant has its own way to share code — different shortcuts,
 **Compete with built-in AI features** by making external AI assistants feel integrated. You get:
 
 - ⚡ **Zero-friction AI context** — Destinations auto-send links. No clipboard juggling.
-- 🎯 **Choice of AI model** — Claude, GPT, Gemini, anything. Not locked into one vendor.
+- 🎯 **Choice of AI tool** — Claude Code, Gemini Code Assist, Copilot, Cursor, terminal CLI tools, anything. Not locked into one vendor or one interface.
 - 📐 **Full control over context** — Character-level precision (`#L42C10`), not just line-level.
 - 🔗 **Cross-file context** — Generate links from multiple files, paste all in one prompt.
 - 🌐 **Universal compatibility** — Works across editors (VSCode, Cursor) and in any text-based tool.
 
 ### Perfect For
 
-- 🤖 **AI assistants** — Claude Code Extension, Cursor AI, terminal claude-code, Copilot, plus any custom AI tool via settings <sup>Unreleased</sup> — with _exact_ context + clickable navigation
+- 🤖 **AI assistants** — Claude Code (extension or terminal), Gemini Code Assist, Cursor AI, Copilot, plus any custom AI tool via settings <sup>Unreleased</sup> — with _exact_ context + clickable navigation
+- 💻 **Terminal AI tools** — Claude Code CLI, gemini-cli, or any terminal-based AI workflow — links paste at your cursor and the terminal auto-focuses
 - 💬 **Code reviews** — "The bug is in `api/routes.ts#L215C8-L223C45`" (click to view)
 - 👥 **Team collaboration** — Universal format everyone can use and navigate
 
@@ -146,6 +147,7 @@ When you close the bound file, RangeLink auto-unbinds with a notification. If th
 **Built-in AI assistants:**
 
 - **[Claude Code Extension](https://marketplace.visualstudio.com/items?itemName=anthropic.claude-code)** — Anthropic's official extension (works in VSCode and Cursor)
+- **[Gemini Code Assist](https://marketplace.visualstudio.com/items?itemName=Google.geminicodeassist)** — Google's AI coding assistant
 - **Cursor AI** — Built into Cursor IDE
 - **[GitHub Copilot Chat](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot-chat)** — GitHub's AI coding assistant
 
@@ -157,7 +159,7 @@ When you close the bound file, RangeLink auto-unbinds with a notification. If th
 2. Select code → `Cmd+R Cmd+L` → Link auto-pastes into chat
 3. Review and send
 
-**One destination at a time:** Bind to Claude Code, Cursor AI, a custom AI tool, terminal, OR text editor. **Quick switching:** Run a different "Bind to..." command or use the R-D picker to replace your current binding with confirmation—no need to unbind first.
+**One destination at a time:** Bind to Claude Code, Gemini Code Assist, Cursor AI, a custom AI tool, terminal, OR text editor. **Quick switching:** Run a different "Bind to..." command or use the R-D picker to replace your current binding with confirmation—no need to unbind first.
 
 ---
 
@@ -283,6 +285,7 @@ Access via `Cmd+Shift+P` (Mac) or `Ctrl+Shift+P` (Windows/Linux), then type "Ran
 | Send Current File Path (Absolute) <sup>Unreleased</sup> | `Cmd+R Cmd+Shift+F` | `Ctrl+R Ctrl+Shift+F` | Send active editor's absolute path to bound destination      |
 | Bind to Destination <sup>Unreleased</sup>               | `Cmd+R Cmd+D`       | `Ctrl+R Ctrl+D`       | Open destination picker to select and bind a target          |
 | Bind to Claude Code                                     | —                   | —                     | Auto-send links to Claude Code chat                          |
+| Bind to Gemini Code Assist <sup>Unreleased</sup>        | —                   | —                     | Auto-send links to Gemini Code Assist chat                   |
 | Bind to Cursor AI                                       | —                   | —                     | Auto-send links to Cursor AI chat                            |
 | Bind to GitHub Copilot Chat                             | —                   | —                     | Auto-send links to Copilot Chat                              |
 | Bind to Terminal                                        | —                   | —                     | Auto-send links to integrated terminal for AI workflows      |
@@ -368,7 +371,7 @@ Customize settings in VSCode (Preferences > Settings > search "rangelink").
 | ------------------------------ | ------- | ---------------------------------------------------- |
 | `rangelink.customAiAssistants` | `[]`    | Array of custom AI assistant definitions (see below) |
 
-Define custom AI assistants to extend RangeLink beyond the three built-in AI tools. Each entry has two required fields and three optional command arrays:
+Define custom AI assistants to extend RangeLink beyond the four built-in AI tools. Each entry has two required fields and three optional command arrays:
 
 | Field                   | Type                   | Required | Description                                                                                                                                                                                          |
 | ----------------------- | ---------------------- | -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -411,7 +414,7 @@ At least one of the three command arrays must be present. RangeLink tries them i
 
 When `sparkAi.insertText` is registered (extension supports it), RangeLink uses direct insertion — no clipboard involved. If the command isn't available (older extension version), RangeLink falls back to the focus + manual paste flow automatically.
 
-**Overriding built-in assistants:** <sup>Unreleased</sup> You can customize the built-in AI assistants (Cursor, Claude Code, Copilot) by adding an entry with the same `extensionId`. RangeLink merges your custom tiers with the built-in's hardcoded commands as a safety-net fallback. If your custom commands aren't registered (typo, extension not updated), the built-in behavior takes over automatically.
+**Overriding built-in assistants:** <sup>Unreleased</sup> You can customize the built-in AI assistants (Claude Code, Gemini Code Assist, Cursor, Copilot) by adding an entry with the same `extensionId`. RangeLink merges your custom tiers with the built-in's hardcoded commands as a safety-net fallback. If your custom commands aren't registered (typo, extension not updated), the built-in behavior takes over automatically.
 
 ```json
 {
@@ -444,6 +447,24 @@ Here `insertCommands` is tried first (Tier 1). If `myPlugin.sendToCopilot` isn't
 
 Run **Developer: Reload Window** (or restart VS Code) after changing this setting.
 
+### Destination Settings — Claude Code <sup>Unreleased</sup>
+
+| Setting                                                   | Default | Description                                                                                       |
+| --------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------- |
+| `rangelink.destinations.claudeCode.coldStartDelayMs`      | `1500`  | Total duration (ms) RangeLink waits for the Claude Code panel to become ready on first use        |
+| `rangelink.destinations.claudeCode.coldRefocusIntervalMs` | `300`   | Interval (ms) at which RangeLink re-sends the Claude Code focus signal during the cold-start wait |
+
+On first use after binding, the Claude Code chat panel needs time to initialize. During the cold-start period, RangeLink periodically re-focuses the panel so it receives keyboard focus once ready. After the first successful paste, subsequent operations use a faster warm-start path. Increase `coldStartDelayMs` on slower machines; decrease `coldRefocusIntervalMs` for more aggressive re-focusing. `coldStartDelayMs` must be greater than `coldRefocusIntervalMs` — if violated, defaults are used.
+
+### Destination Settings — Gemini Code Assist <sup>Unreleased</sup>
+
+| Setting                                               | Default | Description                                                                                  |
+| ----------------------------------------------------- | ------- | -------------------------------------------------------------------------------------------- |
+| `rangelink.destinations.gemini.coldStartDelayMs`      | `2500`  | Total duration (ms) RangeLink waits for the Gemini panel to become ready on first use        |
+| `rangelink.destinations.gemini.coldRefocusIntervalMs` | `300`   | Interval (ms) at which RangeLink re-sends the Gemini focus signal during the cold-start wait |
+
+On first use after binding, Gemini Code Assist's webview panel needs time to initialize. During the cold-start period, RangeLink periodically re-focuses the panel so it receives keyboard focus once ready. After the first successful paste, subsequent operations use a faster warm-start path. Increase `coldStartDelayMs` on slower machines; decrease `coldRefocusIntervalMs` for more aggressive re-focusing. `coldStartDelayMs` must be greater than `coldRefocusIntervalMs` — if violated, defaults are used.
+
 ### Clipboard Settings <sup>Unreleased</sup>
 
 | Setting                        | Default    | Description                                            |
@@ -491,13 +512,6 @@ Set the navigation settings to `false` for a quieter workflow. Navigation itself
 
 When you have more terminals than this threshold, the destination picker shows a "More terminals..." option instead of listing all terminals individually.
 
-### Claude Code Settings <sup>Unreleased</sup>
-
-| Setting                                                   | Default | Description                                                                          |
-| --------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------ |
-| `rangelink.destinations.claudeCode.coldStartDelayMs`      | `1500`  | Total duration (ms) of the cold-start re-focus window for Claude Code                |
-| `rangelink.destinations.claudeCode.coldRefocusIntervalMs` | `300`   | Interval (ms) between successive focus-command re-sends during the cold-start window |
-
 ### Delimiter Settings
 
 | Setting                       | Default | Description                         |
diff --git a/packages/rangelink-vscode-extension/package.json b/packages/rangelink-vscode-extension/package.json
index 85e5dbf73..ebe39bf56 100644
--- a/packages/rangelink-vscode-extension/package.json
+++ b/packages/rangelink-vscode-extension/package.json
@@ -161,6 +161,12 @@
         "category": "RangeLink",
         "icon": "$(link)"
       },
+      {
+        "command": "rangelink.bindToGeminiCodeAssist",
+        "title": "Bind to Gemini Code Assist",
+        "category": "RangeLink",
+        "icon": "$(link)"
+      },
       {
         "command": "rangelink.bindToGitHubCopilotChat",
         "title": "Bind to GitHub Copilot Chat",
@@ -548,6 +554,20 @@
           "description": "Interval (ms) between successive focus-command re-sends during the Claude Code cold-start window.",
           "title": "Claude Code Cold Re-focus Interval"
         },
+        "rangelink.destinations.gemini.coldStartDelayMs": {
+          "type": "number",
+          "default": 2500,
+          "minimum": 500,
+          "maximum": 15000,
+          "description": "Total duration (ms) RangeLink waits for the Gemini panel to become ready on first use, sending periodic refocus signals. Increase on slower machines if automatic paste does not work. Must be greater than coldRefocusIntervalMs."
+        },
+        "rangelink.destinations.gemini.coldRefocusIntervalMs": {
+          "type": "number",
+          "default": 300,
+          "minimum": 100,
+          "maximum": 5000,
+          "description": "Interval (ms) at which RangeLink re-sends the Gemini focus signal during the cold-start period. Must be less than coldStartDelayMs."
+        },
         "rangelink.features.bookmarks.enabled": {
           "type": "boolean",
           "default": false,
diff --git a/packages/rangelink-vscode-extension/qa/qa-test-cases-v1.1.0.yaml b/packages/rangelink-vscode-extension/qa/qa-test-cases-v1.1.0.yaml
index 2a8b71ba9..83956f5e7 100644
--- a/packages/rangelink-vscode-extension/qa/qa-test-cases-v1.1.0.yaml
+++ b/packages/rangelink-vscode-extension/qa/qa-test-cases-v1.1.0.yaml
@@ -3241,6 +3241,112 @@ test_cases:
     expected_result: 'Content arrives in GitHub Copilot Chat input. Logs show no cold-start refocus signals. Paste command succeeds with minimal delay.'
     automated: false
 
+  - id: gemini-code-assist-001
+    labels:
+      - requires-extensions
+    feature: 'Built-in AI Assistants'
+    scenario: 'Gemini Code Assist appears in destination picker when extension is active'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'No destination currently bound'
+    steps:
+      - 'Open destination picker via R-D or Command Palette → "Bind to Destination"'
+      - 'Confirm "Gemini Code Assist" item appears in the AI Assistants group'
+      - 'Confirm it appears after "Claude Code Chat" and before "Cursor AI Assistant" in the picker'
+    expected_result: '"Gemini Code Assist" is listed in the AI Assistants group of the destination picker'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-001"'
+    automated: true
+
+  - id: gemini-code-assist-002
+    labels:
+      - clipboard
+      - requires-extensions
+    feature: 'Built-in AI Assistants'
+    scenario: 'Binding to Gemini Code Assist and sending a link delivers content to chat'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'A file is open in the editor with a selection'
+    steps:
+      - 'Run Command Palette → "RangeLink: Bind to Gemini Code Assist" (or select from R-D picker)'
+      - 'Confirm "✓ RangeLink bound to Gemini Code Assist" status bar message appears'
+      - 'Select a range of code and press Cmd+R Cmd+L (Mac) / Ctrl+R Ctrl+L (Win/Linux)'
+      - 'Confirm Gemini Code Assist chat panel opens and receives the link + selected text'
+    expected_result: 'Gemini Code Assist chat opens and contains the RangeLink and selected code snippet'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-002"'
+    automated: assisted
+
+  - id: gemini-code-assist-003
+    labels:
+      - clipboard
+      - requires-extensions
+    feature: 'Built-in AI Assistants'
+    scenario: 'Cold panel paste verification — content arrives in Gemini Code Assist chat input after a single R-L since bind'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'RangeLink is bound to Gemini Code Assist'
+      - 'No send has been performed since binding (cold start)'
+    steps:
+      - 'Select a range of code and press Cmd+R Cmd+L (Mac) / Ctrl+R Ctrl+L (Win/Linux)'
+      - 'Confirm the Gemini Code Assist chat panel receives the link and selected code'
+      - 'Confirm logs show paste command succeeded'
+    expected_result: 'Content arrives in Gemini Code Assist chat input. Logs show paste command succeeded.'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-003"'
+    automated: assisted
+
+  - id: gemini-code-assist-004
+    labels:
+      - clipboard
+      - requires-extensions
+    feature: 'Built-in AI Assistants'
+    scenario: 'Warm panel paste verification — content arrives in Gemini Code Assist chat input on second R-L without cold-start refocus signals'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'RangeLink is bound to Gemini Code Assist'
+      - 'At least one send has been performed since binding (warm path)'
+    steps:
+      - 'Select a different range of code and press Cmd+R Cmd+L (Mac) / Ctrl+R Ctrl+L (Win/Linux)'
+      - 'Confirm the Gemini Code Assist chat panel receives the link and selected code'
+      - 'Confirm logs show NO cold-start refocus signals in the warm send'
+    expected_result: 'Content arrives in Gemini Code Assist chat input. Logs show no cold-start refocus signals.'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-004"'
+    automated: assisted
+
+  - id: gemini-code-assist-005
+    labels:
+      - requires-extensions
+      - cold-start
+    feature: 'Built-in AI Assistants'
+    scenario: 'Cold-start default settings produce a valid ColdRefocusConfig where totalMs > intervalMs'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'VS Code is running with the standard test:release:with-extensions configuration'
+    steps:
+      - 'Read the rangelink.destinations.gemini.coldStartDelayMs and coldRefocusIntervalMs defaults from VS Code configuration'
+      - 'Confirm coldStartDelayMs > coldRefocusIntervalMs'
+    expected_result: 'Default settings produce a valid ColdRefocusConfig. coldStartDelayMs is greater than coldRefocusIntervalMs.'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-005"'
+    automated: true
+
+  - id: gemini-code-assist-006
+    labels:
+      - requires-extensions
+      - cold-start
+      - validation
+    feature: 'Built-in AI Assistants'
+    scenario: 'Cold-start validation rejects invalid config (totalMs <= intervalMs) and falls back to defaults with a warning'
+    preconditions:
+      - 'Google Gemini Code Assist extension (google.geminicodeassist) is installed and active'
+      - 'VS Code is running with the standard test:release:with-extensions configuration'
+    steps:
+      - 'Set rangelink.destinations.gemini.coldStartDelayMs to 100 and coldRefocusIntervalMs to 400 (invalid: delay <= interval)'
+      - 'Bind to Gemini Code Assist to trigger getColdRefocus validation'
+      - 'Confirm a warning log is emitted about invalid cold-start config'
+      - 'Confirm the fallback defaults from coldStartDelayMs / coldRefocusIntervalMs are used instead of the invalid values'
+      - 'Restore original configuration values'
+    expected_result: 'Invalid config is rejected. Warning is logged. Defaults from coldStartDelayMs / coldRefocusIntervalMs are used as fallback.'
+    command_to_run: 'pnpm test:release:with-extensions --grep "gemini-code-assist-006"'
+    automated: true
+
   # ---------------------------------------------------------------------------
   # Section — Release Notifier
   # ---------------------------------------------------------------------------
diff --git a/packages/rangelink-vscode-extension/scripts/setup-integration-test-settings.js b/packages/rangelink-vscode-extension/scripts/setup-integration-test-settings.js
index cce6e02b8..cedd55612 100644
--- a/packages/rangelink-vscode-extension/scripts/setup-integration-test-settings.js
+++ b/packages/rangelink-vscode-extension/scripts/setup-integration-test-settings.js
@@ -53,6 +53,11 @@ const settings = {
       focusAndPasteCommands: ['nonexistent.paste'],
       focusCommands: ['dummyAi.focusPanel'],
     },
+    {
+      extensionId: 'rangelink.dummy-ai-extension-focus-fail',
+      extensionName: 'Dummy AI (Focus-Fail)',
+      focusAndPasteCommands: ['dummyAi.focusFail'],
+    },
     {
       extensionId: 'github.copilot-chat',
       extensionName: 'Copilot Override',
diff --git a/packages/rangelink-vscode-extension/scripts/test-release-run.sh b/packages/rangelink-vscode-extension/scripts/test-release-run.sh
index 4182a2d5d..771510fb2 100755
--- a/packages/rangelink-vscode-extension/scripts/test-release-run.sh
+++ b/packages/rangelink-vscode-extension/scripts/test-release-run.sh
@@ -7,7 +7,7 @@
 #   ./scripts/test-release-run.sh --automated                # CI-safe (skips [assisted])
 #   ./scripts/test-release-run.sh --grep "pattern"           # filtered by Mocha grep
 #   ./scripts/test-release-run.sh --grep "\[assisted\]"      # only [assisted] tests
-#   ./scripts/test-release-run.sh --with-extensions          # installs Claude Code marketplace extension
+#   ./scripts/test-release-run.sh --with-extensions          # installs real marketplace extensions (Gemini, Claude Code)
 #   ./scripts/test-release-run.sh --label "clipboard"         # only tests with matching label in QA YAML
 #   ./scripts/test-release-run.sh --label "clipboard" --assisted  # label + assisted-only filter
 #   ./scripts/test-release-run.sh --label "clipboard" --no-assisted # label + exclude assisted tests
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/index.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/index.ts
index a32500349..79a61833f 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/index.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/index.ts
@@ -61,4 +61,5 @@ export {
   settle,
   SETTLE_MS,
   TERMINAL_READY_MS,
+  waitForExtensionActive,
 } from './testEnv';
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/settingsHelpers.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/settingsHelpers.ts
index fb53171be..2002be06f 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/settingsHelpers.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/settingsHelpers.ts
@@ -66,6 +66,8 @@ export const resetRangelinkSettings = async (log: (msg: string) => void): Promis
 
   for (const key of keys) {
     await config.update(key, undefined, vscode.ConfigurationTarget.Global);
+    await config.update(key, undefined, vscode.ConfigurationTarget.Workspace);
+    await config.update(key, undefined, vscode.ConfigurationTarget.WorkspaceFolder);
   }
   log(`resetRangelinkSettings: cleared ${keys.length} rangelink settings to defaults`);
 };
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/testEnv.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/testEnv.ts
index 8e1fa53ce..db33240f4 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/testEnv.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/helpers/testEnv.ts
@@ -30,6 +30,34 @@ export const getExtensionVersion = (): string => {
 export const settle = (ms: number = SETTLE_MS): Promise<void> =>
   new Promise<void>((resolve) => setTimeout(resolve, ms));
 
+export const waitForExtensionActive = async (
+  extensionId: string,
+  log: (msg: string) => void,
+  timeoutMs: number = 30000,
+): Promise<void> => {
+  const start = Date.now();
+  let lastState = '';
+  while (Date.now() - start < timeoutMs) {
+    const ext = vscode.extensions.getExtension(extensionId);
+    if (ext && ext.isActive) {
+      log(`[waitForExtensionActive] ${extensionId} → active after ${Date.now() - start}ms`);
+      return;
+    }
+    const currentState = ext ? `found, isActive=${ext.isActive}` : 'not found';
+    if (currentState !== lastState) {
+      log(
+        `[waitForExtensionActive] ${extensionId} → ${currentState} (${Date.now() - start}ms elapsed)`,
+      );
+      lastState = currentState;
+    }
+    await new Promise<void>((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  const ext = vscode.extensions.getExtension(extensionId);
+  throw new Error(
+    `Extension ${extensionId} did not activate within ${timeoutMs}ms (found=${ext !== undefined}, isActive=${ext?.isActive ?? 'N/A'})`,
+  );
+};
+
 /**
  * Open a QuickPick or InputBox via command, dismiss it with closeQuickOpen, and return after
  * the promise settles. The caller inspects log-captured items after this resolves.
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/bindToDestination.test.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/bindToDestination.test.ts
index 877484078..a7c8999c8 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/bindToDestination.test.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/bindToDestination.test.ts
@@ -41,6 +41,13 @@ standardSuite('R-D Bind to Destination', (log) => {
   const findFileItems = (items: Record<string, unknown>[]): Record<string, unknown>[] =>
     findTestItemsByPrefix(items, '__rl-test-btd-');
 
+  const AI_ASSISTANT_DISPLAY_NAMES = [
+    'Claude Code Chat',
+    'Gemini Code Assist',
+    'Cursor AI Assistant',
+    'GitHub Copilot Chat',
+  ];
+
   test('[assisted] bind-to-destination-004: selecting a terminal destination binds it and shows success toast', async () => {
     await createTerminal('rl-btd-004', terminals);
 
@@ -139,22 +146,17 @@ standardSuite('R-D Bind to Destination', (log) => {
     log('✓ Picker showed unbound file; bind succeeded with correct status bar toast');
   });
 
-  test('[assisted] bind-to-destination-006: selecting an AI assistant destination binds it and shows success toast', async () => {
+  test('[assisted] bind-to-destination-006: selecting a built-in AI assistant destination binds it and shows success toast', async () => {
     const logCapture = getLogCapture();
     logCapture.mark('before-btd-006');
 
     await waitForHuman(
       'bind-to-destination-006',
-      'Press Cmd+R Cmd+D, select any available AI assistant entry',
+      'Press Cmd+R Cmd+D, select any available built-in AI assistant entry',
     );
 
     const lines = logCapture.getLinesSince('before-btd-006');
 
-    const AI_ASSISTANT_DISPLAY_NAMES = [
-      'Claude Code Chat',
-      'Cursor AI Assistant',
-      'GitHub Copilot Chat',
-    ];
     const boundToAny = AI_ASSISTANT_DISPLAY_NAMES.some((name) =>
       lines.some((line) => line.includes(`✓ RangeLink bound to ${name}`)),
     );
@@ -314,17 +316,18 @@ standardSuite('R-D Bind to Destination', (log) => {
     log('✓ No bind or unbind toast after Escape — binding state unchanged');
   });
 
-  test('[assisted] bind-to-destination-011: re-binding same AI assistant shows already-bound message', async () => {
+  test('[assisted] bind-to-destination-011: re-binding same built-in AI assistant shows already-bound message', async () => {
     const logCapture = getLogCapture();
     logCapture.mark('before-btd-011');
 
     await waitForHuman(
       'bind-to-destination-011',
-      'Cmd+R Cmd+D → select an AI assistant → Cmd+R Cmd+D → select same AI assistant',
+      'Cmd+R Cmd+D → select a built-in AI assistant → Cmd+R Cmd+D → select same built-in AI assistant',
       [
-        '1. Press Cmd+R Cmd+D and select any AI assistant (e.g., Claude Code Chat)',
-        '2. Press Cmd+R Cmd+D again',
-        '3. Select the same AI assistant a second time',
+        '1. Press Cmd+R Cmd+D and select any built-in AI assistant (e.g., Claude Code Chat)',
+        '2. Press Cmd+R Cmd+D and select any built-in AI assistant (e.g., Gemini Code Assist)',
+        '3. Press Cmd+R Cmd+D again',
+        '3. Select the same built-in AI assistant a second time',
       ],
     );
 
@@ -339,11 +342,6 @@ standardSuite('R-D Bind to Destination', (log) => {
       `Expected exactly 2 showQuickPick entries (two destination picker opens, no confirmation dialog), got ${quickPickEntries.length}`,
     );
 
-    const AI_ASSISTANT_DISPLAY_NAMES = [
-      'Claude Code Chat',
-      'Cursor AI Assistant',
-      'GitHub Copilot Chat',
-    ];
     const alreadyBoundLogged = AI_ASSISTANT_DISPLAY_NAMES.some((name) =>
       lines.some((line) => line.includes(`RangeLink: Already bound to ${name}`)),
     );
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/builtInAiAssistants.test.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/builtInAiAssistants.test.ts
index 4a0ed80ef..6a8f81548 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/builtInAiAssistants.test.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/builtInAiAssistants.test.ts
@@ -6,10 +6,18 @@ import * as vscode from 'vscode';
 import {
   CMD_BIND_TO_CLAUDE_CODE,
   CMD_BIND_TO_DESTINATION,
+  CMD_BIND_TO_GEMINI_CODE_ASSIST,
   CMD_COPY_LINK_RELATIVE,
   CMD_JUMP_TO_DESTINATION,
 } from '../../constants/commandIds';
-import { CLAUDE_CODE_EXTENSION_ID } from '../../utils/aiAssistants/isClaudeCodeAvailable';
+import {
+  DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+  DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+} from '../../constants/settingDefaults';
+import {
+  EXTENSION_ID_CLAUDE_CODE,
+  EXTENSION_ID_GEMINI_CODE_ASSIST,
+} from '../../utils/aiAssistants/builtInAiAssistants';
 import {
   assertStatusBarMsgLogged,
   cleanupFiles,
@@ -20,12 +28,15 @@ import {
   openEditor,
   settle,
   standardSuite,
+  waitForExtensionActive,
   waitForHumanVerdict,
 } from '../helpers';
 
 const AI_ASSISTANTS_GROUP_LABEL = 'AI Assistants';
 const CLAUDE_CODE_DISPLAY_NAME = 'Claude Code Chat';
 const CLAUDE_CODE_BIND_STATUS_BAR_MESSAGE = '✓ RangeLink bound to Claude Code Chat';
+const GEMINI_CODE_ASSIST_DISPLAY_NAME = 'Gemini Code Assist';
+const GEMINI_BIND_STATUS_BAR_MESSAGE = '✓ RangeLink bound to Gemini Code Assist';
 
 standardSuite('Built-in AI Assistants', (log) => {
   const tmpFileUris: vscode.Uri[] = [];
@@ -229,6 +240,208 @@ standardSuite('Built-in AI Assistants', (log) => {
 
     log('✓ Warm paste: content delivered to Claude Code (cold + warm both PASS)');
   });
+
+  test('[assisted] gemini-code-assist-002: binding to Gemini Code Assist and sending a link delivers content to chat', async () => {
+    const fileUri = createWorkspaceFile('gc-002', 'line 1\nline 2\nline 3\n');
+    tmpFileUris.push(fileUri);
+    await openEditor(fileUri);
+    await settle();
+
+    await waitForExtensionActive(EXTENSION_ID_GEMINI_CODE_ASSIST, log);
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-gc-002-bind');
+
+    await vscode.commands.executeCommand(CMD_BIND_TO_GEMINI_CODE_ASSIST);
+    await settle();
+
+    const bindLines = logCapture.getLinesSince('before-gc-002-bind');
+    assertStatusBarMsgLogged(bindLines, {
+      message: GEMINI_BIND_STATUS_BAR_MESSAGE,
+    });
+
+    const bindDestinationLog = bindLines.find(
+      (line) => line.includes('PasteDestinationManager') && line.includes('bound to'),
+    );
+    assert.ok(
+      bindDestinationLog,
+      `Expected a PasteDestinationManager "bound to" log line in the ${bindLines.length} bind lines`,
+    );
+
+    const doc = await vscode.workspace.openTextDocument(fileUri);
+    const editor = await vscode.window.showTextDocument(doc);
+    editor.selection = new vscode.Selection(0, 0, 1, 6);
+    await settle();
+
+    logCapture.mark('before-gc-002-send');
+
+    await vscode.commands.executeCommand(CMD_COPY_LINK_RELATIVE);
+    await settle();
+
+    const sendLines = logCapture.getLinesSince('before-gc-002-send');
+
+    const pasteSuccessLog = sendLines.find(
+      (line) =>
+        line.includes('ComposablePasteDestination.pasteLink') && line.includes('Pasted link'),
+    );
+    assert.ok(
+      pasteSuccessLog,
+      'Expected paste link success log after send (code-side paste fired)',
+    );
+
+    const clipboardPasteLog = sendLines.find(
+      (line) =>
+        line.includes('VscodeAdapter.pasteClipboardToAiAssistant') &&
+        line.includes('Clipboard paste succeeded'),
+    );
+    assert.ok(clipboardPasteLog, 'Expected Clipboard paste succeeded log');
+
+    const verdict = await waitForHumanVerdict(
+      'gemini-code-assist-002',
+      'Did the RangeLink + selected code appear in Gemini Code Assist chat?',
+      [
+        '1. The RangeLink send was fired automatically',
+        '2. Click PASS if the link + selected code appeared in Gemini Code Assist chat input',
+        '3. Click FAIL otherwise',
+      ],
+    );
+    assert.strictEqual(
+      verdict,
+      'pass',
+      'Human reported the RangeLink did not appear in Gemini Code Assist chat (code-side paste logs fired — the paste dispatched but did not reach the chat input)',
+    );
+
+    log('✓ Bind status confirmed + content delivered to Gemini Code Assist chat');
+  });
+
+  test('[assisted] gemini-code-assist-003: cold panel paste — content arrives in Gemini Code Assist chat after first R-L since bind', async () => {
+    const fileUri = createWorkspaceFile('gc-003', 'line 1\nline 2\nline 3\n');
+    tmpFileUris.push(fileUri);
+    const doc = await vscode.workspace.openTextDocument(fileUri);
+    const editor = await vscode.window.showTextDocument(doc);
+    editor.selection = new vscode.Selection(0, 0, 1, 6);
+    await settle();
+
+    await waitForExtensionActive(EXTENSION_ID_GEMINI_CODE_ASSIST, log);
+
+    await vscode.commands.executeCommand(CMD_BIND_TO_GEMINI_CODE_ASSIST);
+    await settle();
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-gc-003');
+
+    await vscode.commands.executeCommand(CMD_COPY_LINK_RELATIVE);
+    await settle();
+
+    const lines = logCapture.getLinesSince('before-gc-003');
+
+    const pasteSuccessLog = lines.find(
+      (line) =>
+        line.includes('ComposablePasteDestination.pasteLink') && line.includes('Pasted link'),
+    );
+    assert.ok(pasteSuccessLog, 'Expected paste link success log after cold paste send');
+
+    const clipboardPasteLog = lines.find(
+      (line) =>
+        line.includes('VscodeAdapter.pasteClipboardToAiAssistant') &&
+        line.includes('Clipboard paste succeeded'),
+    );
+    assert.ok(clipboardPasteLog, 'Expected Clipboard paste succeeded log');
+
+    const verdict = await waitForHumanVerdict(
+      'gemini-code-assist-003',
+      'Cold paste: did the RangeLink appear in Gemini Code Assist chat?',
+      [
+        '1. Lines 1-2 of gc-003 are already selected',
+        '2. The send was fired automatically (no keypress needed)',
+        '3. Click PASS if the RangeLink appeared in Gemini Code Assist chat input',
+        '4. Click FAIL otherwise',
+      ],
+    );
+    assert.strictEqual(
+      verdict,
+      'pass',
+      'Human reported the RangeLink did not appear in Gemini Code Assist chat (code-side paste logs fired — the paste dispatched but did not reach the chat input)',
+    );
+
+    log('✓ Cold paste: content delivered to Gemini Code Assist (verdict PASS)');
+  });
+
+  test('[assisted] gemini-code-assist-004: warm panel paste — second R-L delivers content without cold-start refocus', async () => {
+    const fileUri = createWorkspaceFile('gc-004', 'line 1\nline 2\nline 3\nline 4\n');
+    tmpFileUris.push(fileUri);
+    const doc = await vscode.workspace.openTextDocument(fileUri);
+    const editor = await vscode.window.showTextDocument(doc);
+    editor.selection = new vscode.Selection(0, 0, 1, 6);
+    await settle();
+
+    await waitForExtensionActive(EXTENSION_ID_GEMINI_CODE_ASSIST, log);
+
+    await vscode.commands.executeCommand(CMD_BIND_TO_GEMINI_CODE_ASSIST);
+    await settle();
+
+    // First send (cold) — warms the panel
+    await vscode.commands.executeCommand(CMD_COPY_LINK_RELATIVE);
+    await settle();
+
+    const coldVerdict = await waitForHumanVerdict(
+      'gemini-code-assist-004-cold',
+      'Cold send: did the RangeLink appear in Gemini Code Assist chat?',
+      [
+        '1. Lines 1-2 of gc-004 are selected; cold send was fired automatically',
+        '2. Click PASS if the RangeLink appeared in Gemini Code Assist chat input',
+        '3. Click FAIL otherwise',
+      ],
+    );
+    assert.strictEqual(
+      coldVerdict,
+      'pass',
+      'Human reported the cold-send RangeLink did not appear in Gemini Code Assist chat',
+    );
+
+    // Select lines 3-4 for warm send
+    await vscode.window.showTextDocument(doc);
+    editor.selection = new vscode.Selection(2, 0, 3, 6);
+    await settle();
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-gc-004-warm');
+
+    await vscode.commands.executeCommand(CMD_COPY_LINK_RELATIVE);
+    await settle();
+
+    const lines = logCapture.getLinesSince('before-gc-004-warm');
+
+    const pasteSuccessLog = lines.find(
+      (line) =>
+        line.includes('ComposablePasteDestination.pasteLink') && line.includes('Pasted link'),
+    );
+    assert.ok(pasteSuccessLog, 'Expected paste link success log on warm send');
+
+    const clipboardPasteLog = lines.find(
+      (line) =>
+        line.includes('VscodeAdapter.pasteClipboardToAiAssistant') &&
+        line.includes('Clipboard paste succeeded'),
+    );
+    assert.ok(clipboardPasteLog, 'Expected Clipboard paste succeeded log on warm send');
+
+    const warmVerdict = await waitForHumanVerdict(
+      'gemini-code-assist-004-warm',
+      'Warm send: did the lines 3-4 RangeLink appear in Gemini Code Assist chat without refocus flicker?',
+      [
+        '1. Lines 3-4 of gc-004 are selected; warm send was fired automatically',
+        '2. Click PASS if the new RangeLink appeared AND the panel did not flicker/refocus',
+        '3. Click FAIL otherwise (no content, or visible flicker indicating cold-start path)',
+      ],
+    );
+    assert.strictEqual(
+      warmVerdict,
+      'pass',
+      'Human reported the warm-send RangeLink did not appear cleanly in Gemini Code Assist chat',
+    );
+
+    log('✓ Warm paste: content delivered to Gemini Code Assist (cold + warm both PASS)');
+  });
 });
 
 standardSuite('Built-in AI Assistants — Destination Picker', (log) => {
@@ -239,9 +452,9 @@ standardSuite('Built-in AI Assistants — Destination Picker', (log) => {
     // `test:release:with-extensions` config installs it; the standard `test:release:automated`
     // config does not. Without this guard, the test runs in both configs and fails in the
     // standard one because "GitHub Copilot Chat" takes the top slot when Claude Code is absent.
-    if (!vscode.extensions.getExtension(CLAUDE_CODE_EXTENSION_ID)) {
+    if (!vscode.extensions.getExtension(EXTENSION_ID_CLAUDE_CODE)) {
       log(
-        `Skipping claude-code-001 — "${CLAUDE_CODE_EXTENSION_ID}" extension is not installed in this test config (expected in test:release:automated; runs only under test:release:with-extensions).`,
+        `Skipping claude-code-001 — "${EXTENSION_ID_CLAUDE_CODE}" extension is not installed in this test config (expected in test:release:automated; runs only under test:release:with-extensions).`,
       );
       this.skip();
     }
@@ -319,17 +532,110 @@ standardSuite('Built-in AI Assistants — Destination Picker', (log) => {
   });
 
   test('claude-code-007: Cold-start validation rejects invalid config and falls back to defaults', async function (this: MochaContext) {
-    if (!vscode.extensions.getExtension(CLAUDE_CODE_EXTENSION_ID)) {
+    if (!vscode.extensions.getExtension(EXTENSION_ID_CLAUDE_CODE)) {
       log('Skipping claude-code-007 — Claude Code extension not installed in this test config');
       this.skip();
     }
 
     const config = vscode.workspace.getConfiguration('rangelink.destinations.claudeCode');
 
-    // Set delay <= interval so the validation rejects it (by default, delay >
-    // interval so the config is valid; flipping that relationship makes it invalid).
+    // Set invalid config: delay (100) <= interval (400)
+    await config.update('coldStartDelayMs', 100, vscode.ConfigurationTarget.Workspace);
+    await config.update('coldRefocusIntervalMs', 400, vscode.ConfigurationTarget.Workspace);
+    await settle();
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-cc-007');
+
+    await vscode.commands.executeCommand(CMD_BIND_TO_CLAUDE_CODE);
+    await settle();
+
+    await vscode.commands.executeCommand(CMD_JUMP_TO_DESTINATION);
+    await settle();
+
+    const lines = logCapture.getLinesSince('before-cc-007');
+    const warningLog = lines.find((line) =>
+      line.includes('coldStartDelayMs must be greater than coldRefocusIntervalMs'),
+    );
+    assert.ok(
+      warningLog,
+      'Expected validation warning log when coldStartDelayMs <= coldRefocusIntervalMs',
+    );
+
+    log('✓ claude-code-007 — invalid config triggers fallback to defaults');
+  });
+
+  test('gemini-code-assist-001: Gemini Code Assist appears in destination picker when available', async function (this: MochaContext) {
+    if (!vscode.extensions.getExtension(EXTENSION_ID_GEMINI_CODE_ASSIST)) {
+      log(
+        `Skipping gemini-code-assist-001 — "${EXTENSION_ID_GEMINI_CODE_ASSIST}" extension is not installed in this test config.`,
+      );
+      this.skip();
+    }
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-gc-001');
+
+    await openAndDismiss(CMD_BIND_TO_DESTINATION);
+
+    const lines = logCapture.getLinesSince('before-gc-001');
+    const items = extractQuickPickItemsLogged(lines);
+    assert.ok(items, 'Expected showQuickPick log entry from destination picker');
+
+    const geminiItem = items!.find((item) => item.displayName === GEMINI_CODE_ASSIST_DISPLAY_NAME);
+    assert.ok(
+      geminiItem,
+      `Expected "${GEMINI_CODE_ASSIST_DISPLAY_NAME}" in the destination picker items`,
+    );
+    assert.strictEqual(geminiItem!.itemKind, 'bindable');
+
+    log('✓ gemini-code-assist-001 — Gemini Code Assist appears in the destination picker');
+  });
+
+  test('gemini-code-assist-005: Cold-start default settings produce correct ColdRefocusConfig', async () => {
+    const config = vscode.workspace.getConfiguration('rangelink.destinations.gemini');
+    const totalMs = config.get<number>(
+      'coldStartDelayMs',
+      DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+    );
+    const intervalMs = config.get<number>(
+      'coldRefocusIntervalMs',
+      DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+    );
+
+    assert.strictEqual(
+      totalMs,
+      DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+      'Expected default coldStartDelayMs',
+    );
+    assert.strictEqual(
+      intervalMs,
+      DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+      'Expected default coldRefocusIntervalMs',
+    );
+    assert.ok(
+      totalMs > intervalMs,
+      `Expected coldStartDelayMs (${totalMs}) > coldRefocusIntervalMs (${intervalMs})`,
+    );
+
+    log('✓ Default Gemini cold-start config produces valid ColdRefocusConfig');
+  });
+
+  test('gemini-code-assist-006: Cold-start validation rejects invalid config and falls back to defaults', async function (this: MochaContext) {
+    if (!vscode.extensions.getExtension(EXTENSION_ID_GEMINI_CODE_ASSIST)) {
+      log(
+        'Skipping gemini-code-assist-006 — Gemini Code Assist extension not installed in this test config',
+      );
+      this.skip();
+    }
+
     const INVALID_DELAY_MS = 100;
     const INVALID_INTERVAL_MS = 400;
+
+    const config = vscode.workspace.getConfiguration('rangelink.destinations.gemini');
+
+    // Set delay <= interval so the validation rejects it (by default, delay >
+    // interval so the config is valid; flipping that relationship makes it invalid).
     await config.update('coldStartDelayMs', INVALID_DELAY_MS, vscode.ConfigurationTarget.Workspace);
     await config.update(
       'coldRefocusIntervalMs',
@@ -338,19 +644,21 @@ standardSuite('Built-in AI Assistants — Destination Picker', (log) => {
     );
     await settle();
 
+    await waitForExtensionActive(EXTENSION_ID_GEMINI_CODE_ASSIST, log);
+
     const logCapture = getLogCapture();
-    logCapture.mark('before-cc-007');
+    logCapture.mark('before-gc-006');
 
     // Validation lives inside getColdRefocus, which is a thunk only invoked
     // during focus() — not at bind() time. CMD_JUMP_TO_DESTINATION triggers
     // focusBoundDestination() → focus() → getColdRefocus() → validation warning.
-    await vscode.commands.executeCommand(CMD_BIND_TO_CLAUDE_CODE);
+    await vscode.commands.executeCommand(CMD_BIND_TO_GEMINI_CODE_ASSIST);
     await settle();
 
     await vscode.commands.executeCommand(CMD_JUMP_TO_DESTINATION);
     await settle();
 
-    const lines = logCapture.getLinesSince('before-cc-007');
+    const lines = logCapture.getLinesSince('before-gc-006');
     const warningLog = lines.find(
       (line) =>
         line.includes('coldStartDelayMs must be greater than coldRefocusIntervalMs') &&
@@ -361,6 +669,6 @@ standardSuite('Built-in AI Assistants — Destination Picker', (log) => {
       'Expected validation warning log with "using defaults" when coldStartDelayMs <= coldRefocusIntervalMs',
     );
 
-    log('✓ claude-code-007 — invalid config triggers fallback to defaults');
+    log('✓ gemini-code-assist-006 — invalid config triggers fallback to defaults');
   });
 });
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/clipboardPreservation.test.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/clipboardPreservation.test.ts
index 8516abe91..1316881ed 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/clipboardPreservation.test.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/clipboardPreservation.test.ts
@@ -20,6 +20,7 @@ import {
   createAndBindCapturingTerminal,
   createTerminal,
   createWorkspaceFile,
+  getLogCapture,
   loadSettingsProfile,
   openAndDismiss,
   openEditor,
@@ -316,4 +317,59 @@ standardSuite('Clipboard Preservation — Assisted', (log) => {
     await assertClipboardRestored('clipboard-preservation-009: always + picker dismissed');
     log('✓ Clipboard unchanged after picker dismissed (no operation performed)');
   });
+
+  test('[assisted] clipboard-preservation-010: focus command failure preserves link in clipboard for manual paste', async () => {
+    await loadSettingsProfile('default', log);
+
+    const lines = Array.from({ length: 5 }, (_, i) => `line ${i + 1}`);
+    const fileUri = createWorkspaceFile('cbp-010', lines.join('\n') + '\n');
+    tmpFileUris.push(fileUri);
+
+    const relPath = vscode.workspace.asRelativePath(fileUri);
+    await openEditor(fileUri);
+    await settle();
+    await writeClipboardSentinel();
+
+    const logCapture = getLogCapture();
+    logCapture.mark('before-010');
+
+    await waitForHuman(
+      'clipboard-preservation-010',
+      `clipboard.preserve="always". Bind "Dummy AI (Focus-Fail)" via Cmd+R Cmd+D, then select lines 1-3 in the test file and press Cmd+R Cmd+L. The focus command throws — you should see a warning. Sentinel: "${CLIPBOARD_SENTINEL}".`,
+      [
+        '1. Press Cmd+R Cmd+D → select "Dummy AI (Focus-Fail)" from the picker',
+        `2. Click back into the test file (${relPath}) and select lines 1-3`,
+        '3. Press Cmd+R Cmd+L — the focus command will throw an intentional error',
+        '4. Observe the warning message (manual paste instruction)',
+        '5. Press Cancel to continue (test verifies the link stayed in the clipboard)',
+      ],
+    );
+
+    await settle();
+
+    const lines010 = logCapture.getLinesSince('before-010');
+    const focusFailLog = lines010.find((line) => line.includes('Focus failed, cannot paste link'));
+    assert.ok(
+      focusFailLog,
+      'Expected "Focus failed, cannot paste link" log — the focus command should have thrown',
+    );
+
+    const warningToastLog = lines010.find(
+      (line) =>
+        line.includes('VscodeAdapter.showWarningMessage') && line.toLowerCase().includes('paste'),
+    );
+    assert.ok(
+      warningToastLog,
+      'Expected warning toast log instructing manual paste after focus failure',
+    );
+
+    const clipboardContent = await assertClipboardChanged(
+      'clipboard-preservation-010: focus-fail — link must stay in clipboard',
+    );
+    assert.ok(
+      clipboardContent.includes('#L'),
+      `Expected a RangeLink link in clipboard (with #L) but got: ${clipboardContent}`,
+    );
+    log('✓ Clipboard not restored after focus failure — link stays in clipboard for manual paste');
+  });
 });
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/commandRegistration.test.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/commandRegistration.test.ts
index 6a6007278..91919413d 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/commandRegistration.test.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/commandRegistration.test.ts
@@ -20,6 +20,7 @@ const EXPECTED_COMMAND_IDS = [
   'rangelink.bindToTextEditorHere',
   'rangelink.bindToCursorAI',
   'rangelink.bindToClaudeCode',
+  'rangelink.bindToGeminiCodeAssist',
   'rangelink.bindToGitHubCopilotChat',
   'rangelink.unbindDestination',
   'rangelink.jumpToBoundDestination',
diff --git a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/customAiAssistants.test.ts b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/customAiAssistants.test.ts
index 4973f7afb..4c4c5236e 100644
--- a/packages/rangelink-vscode-extension/src/__integration-tests__/suite/customAiAssistants.test.ts
+++ b/packages/rangelink-vscode-extension/src/__integration-tests__/suite/customAiAssistants.test.ts
@@ -18,8 +18,8 @@ import {
   writeClipboardSentinel,
 } from '../helpers';
 
-const EXPECTED_CUSTOM_ASSISTANTS_COUNT = 6;
-const EXPECTED_CUSTOM_AI_REGISTRATIONS = 5;
+const EXPECTED_CUSTOM_ASSISTANTS_COUNT = 7;
+const EXPECTED_CUSTOM_AI_REGISTRATIONS = 6;
 
 standardSuite('Custom AI Assistants', (_log) => {
   test('custom-ai-assistant-001: three-tier config is parsed and logged at activation', () => {
@@ -77,6 +77,10 @@ standardSuite('Custom AI Assistants', (_log) => {
       registrationLogs.some((l) => l.includes('custom-ai:rangelink.dummy-ai-extension-fallback')),
       'Expected registration for Fallback (rangelink.dummy-ai-extension-fallback)',
     );
+    assert.ok(
+      registrationLogs.some((l) => l.includes('custom-ai:rangelink.dummy-ai-extension-focus-fail')),
+      'Expected registration for Focus-Fail (rangelink.dummy-ai-extension-focus-fail)',
+    );
   });
 
   test('custom-ai-assistant-004: dummy extension insertText command is detectable', async () => {
@@ -116,6 +120,7 @@ standardSuite('Custom AI Assistants', (_log) => {
       'Expected dummyAi.insertWithArgs command',
     );
     assert.ok(commands.includes('dummyAi.focusForPaste'), 'Expected dummyAi.focusForPaste command');
+    assert.ok(commands.includes('dummyAi.focusFail'), 'Expected dummyAi.focusFail command');
     assert.ok(commands.includes('dummyAi.focusPanel'), 'Expected dummyAi.focusPanel command');
     assert.ok(commands.includes('dummyAi.getText'), 'Expected dummyAi.getText command');
     assert.ok(commands.includes('dummyAi.clearAll'), 'Expected dummyAi.clearAll command');
diff --git a/packages/rangelink-vscode-extension/src/__tests__/constants/packageJsonContracts.test.ts b/packages/rangelink-vscode-extension/src/__tests__/constants/packageJsonContracts.test.ts
index 67b2b9e35..56a270c64 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/constants/packageJsonContracts.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/constants/packageJsonContracts.test.ts
@@ -1,4 +1,5 @@
 import packageJson from '../../../package.json';
+import { AI_ASSISTANT_KINDS } from '../../types';
 
 interface CommandContribution {
   command: string;
@@ -184,6 +185,15 @@ describe('package.json contributions', () => {
         });
       });
 
+      it('rangelink.bindToGeminiCodeAssist', () => {
+        expect(findCommand('rangelink.bindToGeminiCodeAssist')).toStrictEqual({
+          command: 'rangelink.bindToGeminiCodeAssist',
+          title: 'Bind to Gemini Code Assist',
+          category: 'RangeLink',
+          icon: '$(link)',
+        });
+      });
+
       it('rangelink.bindToGitHubCopilotChat', () => {
         expect(findCommand('rangelink.bindToGitHubCopilotChat')).toStrictEqual({
           command: 'rangelink.bindToGitHubCopilotChat',
@@ -193,6 +203,22 @@ describe('package.json contributions', () => {
         });
       });
 
+      it('has a bind command for every AI_ASSISTANT_KIND — add a new it() above when extending AI_ASSISTANT_KINDS', () => {
+        const kindToCommandId: Record<string, string> = {
+          'claude-code': 'rangelink.bindToClaudeCode',
+          'cursor-ai': 'rangelink.bindToCursorAI',
+          'gemini-code-assist': 'rangelink.bindToGeminiCodeAssist',
+          'github-copilot-chat': 'rangelink.bindToGitHubCopilotChat',
+        };
+
+        expect(AI_ASSISTANT_KINDS).toHaveLength(4);
+
+        for (const kind of AI_ASSISTANT_KINDS) {
+          const commandId = kindToCommandId[kind];
+          expect(findCommand(commandId)).toBeDefined();
+        }
+      });
+
       it('rangelink.unbindDestination', () => {
         expect(findCommand('rangelink.unbindDestination')).toStrictEqual({
           command: 'rangelink.unbindDestination',
@@ -478,7 +504,7 @@ describe('package.json contributions', () => {
     });
 
     it('has the expected number of commands', () => {
-      expect(commands).toHaveLength(47);
+      expect(commands).toHaveLength(48);
     });
   });
 
@@ -755,7 +781,7 @@ describe('package.json contributions', () => {
     });
 
     it('has the expected number of configuration properties', () => {
-      expect(Object.keys(properties)).toHaveLength(17);
+      expect(Object.keys(properties)).toHaveLength(19);
     });
   });
 
diff --git a/packages/rangelink-vscode-extension/src/__tests__/destinations/DestinationRegistry.test.ts b/packages/rangelink-vscode-extension/src/__tests__/destinations/DestinationRegistry.test.ts
index 487a21b92..b7151c124 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/destinations/DestinationRegistry.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/destinations/DestinationRegistry.test.ts
@@ -300,9 +300,10 @@ describe('DestinationRegistry', () => {
       expect(displayNames).toStrictEqual({
         terminal: 'Terminal',
         'text-editor': 'Text Editor',
+        'claude-code': 'Claude Code Chat',
         'cursor-ai': 'Cursor AI Assistant',
+        'gemini-code-assist': 'Gemini Code Assist',
         'github-copilot-chat': 'GitHub Copilot Chat',
-        'claude-code': 'Claude Code Chat',
       });
     });
   });
diff --git a/packages/rangelink-vscode-extension/src/__tests__/destinations/PasteDestinationManager.test.ts b/packages/rangelink-vscode-extension/src/__tests__/destinations/PasteDestinationManager.test.ts
index 13d4f7de3..c288c3267 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/destinations/PasteDestinationManager.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/destinations/PasteDestinationManager.test.ts
@@ -28,6 +28,7 @@ import {
   createMockEditorComposablePasteDestination,
   createMockFocusCapability,
   createMockFormattedLink,
+  createMockGeminiCodeAssistDestination,
   createMockGitHubCopilotChatDestination,
   createMockTerminal,
   createMockTerminalComposablePasteDestination,
@@ -351,6 +352,14 @@ describe('PasteDestinationManager', () => {
         2000,
       );
       expectContextKeys(localAdapter.__getVscodeInstance(), { 'rangelink.isBound': true });
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        {
+          fn: 'PasteDestinationManager.commitBind',
+          kind: 'cursor-ai',
+          displayName: 'Cursor AI Assistant',
+        },
+        'Successfully bound to "Cursor AI Assistant"',
+      );
 
       localManager.dispose();
     });
@@ -415,6 +424,64 @@ describe('PasteDestinationManager', () => {
         2000,
       );
       expectContextKeys(mockAdapter.__getVscodeInstance(), { 'rangelink.isBound': true });
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        {
+          fn: 'PasteDestinationManager.commitBind',
+          kind: 'claude-code',
+          displayName: 'Claude Code Chat',
+        },
+        'Successfully bound to "Claude Code Chat"',
+      );
+    });
+
+    it('should bind to gemini-code-assist when available', async () => {
+      const mockDestination = createMockGeminiCodeAssistDestination({ isAvailable: true });
+      jest.spyOn(mockRegistry, 'create').mockReturnValue(mockDestination);
+
+      const result = await manager.bind({ kind: 'gemini-code-assist' });
+
+      expect(result).toBeOkWith((value: BindSuccessInfo) => {
+        expect(value).toStrictEqual({
+          destinationName: 'Gemini Code Assist',
+          destinationKind: 'gemini-code-assist',
+        });
+      });
+      expect(manager.isBound()).toBe(true);
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).toHaveBeenCalledTimes(1);
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).toHaveBeenNthCalledWith(
+        1,
+        '✓ RangeLink bound to Gemini Code Assist',
+        2000,
+      );
+      expectContextKeys(mockAdapter.__getVscodeInstance(), { 'rangelink.isBound': true });
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        {
+          fn: 'PasteDestinationManager.commitBind',
+          kind: 'gemini-code-assist',
+          displayName: 'Gemini Code Assist',
+        },
+        'Successfully bound to "Gemini Code Assist"',
+      );
+    });
+
+    it('should fail when gemini-code-assist not available', async () => {
+      const mockDestination = createMockGeminiCodeAssistDestination({ isAvailable: false });
+      jest.spyOn(mockRegistry, 'create').mockReturnValue(mockDestination);
+
+      const result = await manager.bind({ kind: 'gemini-code-assist' });
+
+      expect(result).toBeRangeLinkExtensionErrorErr('DESTINATION_BIND_FAILED', {
+        message: 'Gemini Code Assist not available',
+        functionName: 'PasteDestinationManager.bindGenericDestination',
+        details: { failedBindDetails: 'DESTINATION_NOT_AVAILABLE' },
+      });
+      expect(manager.isBound()).toBe(false);
+      expect(formatMessageSpy).toHaveBeenCalledWith('ERROR_GEMINI_CODE_ASSIST_NOT_AVAILABLE');
+      expect(mockAdapter.__getVscodeInstance().window.showErrorMessage).toHaveBeenCalledWith(
+        'RangeLink: Cannot bind Gemini Code Assist - extension not installed or not active',
+      );
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).not.toHaveBeenCalled();
+      expectContextKeys(mockAdapter.__getVscodeInstance(), { 'rangelink.isBound': false });
     });
 
     it('should bind to github-copilot-chat when available', async () => {
@@ -1171,6 +1238,30 @@ describe('PasteDestinationManager', () => {
       expectContextKeys(mockAdapter.__getVscodeInstance(), { 'rangelink.isBound': false });
     });
 
+    it('should unbind gemini-code-assist successfully', async () => {
+      const mockDestination = createMockGeminiCodeAssistDestination({ isAvailable: true });
+      jest.spyOn(mockRegistry, 'create').mockReturnValue(mockDestination);
+
+      await manager.bind({ kind: 'gemini-code-assist' });
+
+      manager.unbind();
+
+      expect(manager.isBound()).toBe(false);
+      expect(manager.getBoundDestination()).toBeUndefined();
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).toHaveBeenCalledTimes(2);
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).toHaveBeenNthCalledWith(
+        1,
+        '✓ RangeLink bound to Gemini Code Assist',
+        2000,
+      );
+      expect(mockAdapter.__getVscodeInstance().window.setStatusBarMessage).toHaveBeenNthCalledWith(
+        2,
+        '✓ RangeLink unbound from Gemini Code Assist',
+        2000,
+      );
+      expectContextKeys(mockAdapter.__getVscodeInstance(), { 'rangelink.isBound': false });
+    });
+
     it('should unbind text-editor successfully', async () => {
       const mockUri = createMockUri('/workspace/src/file.ts');
       const mockDocument = createMockDocument({ uri: mockUri });
@@ -2124,6 +2215,22 @@ describe('PasteDestinationManager', () => {
 
       expect(manager.isClipboardRestorationApplicable(false)).toBe(true);
     });
+
+    it('returns false when built-in AI assistant is bound and paste failed', async () => {
+      const { manager: localManager } = createManager({
+        envOptions: { appName: 'Cursor' },
+      });
+      await localManager.bind({ kind: 'cursor-ai' });
+
+      // Real built-in AI assistants provide a failure instruction ("Paste (Cmd/Ctrl+V)").
+      // The mock defaults to undefined, so configure it to reflect the real contract.
+      const boundDest = localManager.getBoundDestination()!;
+      (boundDest.getUserInstruction as jest.Mock).mockReturnValue('Paste (Cmd/Ctrl+V)');
+
+      expect(localManager.isClipboardRestorationApplicable(false)).toBe(false);
+
+      localManager.dispose();
+    });
   });
 
   describe('dispose()', () => {
diff --git a/packages/rangelink-vscode-extension/src/__tests__/destinations/destinationBuilders.test.ts b/packages/rangelink-vscode-extension/src/__tests__/destinations/destinationBuilders.test.ts
index de560eaf2..e1badbb7f 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/destinations/destinationBuilders.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/destinations/destinationBuilders.test.ts
@@ -21,6 +21,7 @@ import {
   createMockVscodeAdapter,
   spyOnIsClaudeCodeAvailable,
   spyOnIsCursorIDEDetected,
+  spyOnIsGeminiCodeAssistAvailable,
   spyOnIsGitHubCopilotChatAvailable,
 } from '../helpers';
 
@@ -291,6 +292,46 @@ describe('destinationBuilders', () => {
       );
     });
 
+    it('creates gemini-code-assist destination with correct id and displayName', () => {
+      const builder = getBuiltinBuilder('gemini-code-assist');
+      const context = createMockContext();
+
+      const destination = builder({ kind: 'gemini-code-assist' }, context);
+
+      expect({ id: destination.id, displayName: destination.displayName }).toStrictEqual({
+        id: 'gemini-code-assist',
+        displayName: 'Gemini Code Assist',
+      });
+    });
+
+    it('gemini-code-assist isAvailable delegates to isGeminiCodeAssistAvailable', async () => {
+      const spy = spyOnIsGeminiCodeAssistAvailable().mockResolvedValue(true);
+      const builder = getBuiltinBuilder('gemini-code-assist');
+      const context = createMockContext();
+      const destination = builder({ kind: 'gemini-code-assist' }, context);
+
+      expect(await destination.isAvailable()).toBe(true);
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+
+    it('gemini-code-assist getUserInstruction returns undefined on auto-paste success', () => {
+      const builder = getBuiltinBuilder('gemini-code-assist');
+      const context = createMockContext();
+      const destination = builder({ kind: 'gemini-code-assist' }, context);
+
+      expect(destination.getUserInstruction(AutoPasteResult.Success)).toBeUndefined();
+    });
+
+    it('gemini-code-assist getUserInstruction returns instruction message on auto-paste failure', () => {
+      const builder = getBuiltinBuilder('gemini-code-assist');
+      const context = createMockContext();
+      const destination = builder({ kind: 'gemini-code-assist' }, context);
+
+      expect(destination.getUserInstruction(AutoPasteResult.Failure)).toBe(
+        'Paste (Cmd/Ctrl+V) in Gemini Code Assist to use.',
+      );
+    });
+
     it('creates github-copilot-chat destination with correct id and displayName', () => {
       const builder = getBuiltinBuilder('github-copilot-chat');
       const context = createMockContext();
@@ -638,7 +679,7 @@ describe('destinationBuilders', () => {
   });
 
   describe('registerAllDestinationBuilders', () => {
-    it('registers all five built-in destination kinds', () => {
+    it('registers all six built-in destination kinds', () => {
       const registeredKinds: DestinationKind[] = [];
       const mockRegistry = {
         register: (kind: DestinationKind, _builder: DestinationBuilder) => {
@@ -653,6 +694,7 @@ describe('destinationBuilders', () => {
         'text-editor',
         'cursor-ai',
         'claude-code',
+        'gemini-code-assist',
         'github-copilot-chat',
       ]);
     });
@@ -680,6 +722,7 @@ describe('destinationBuilders', () => {
         'custom-ai:acme.spark-ai',
         'cursor-ai',
         'claude-code',
+        'gemini-code-assist',
         'github-copilot-chat',
       ]);
     });
@@ -706,6 +749,7 @@ describe('destinationBuilders', () => {
         'text-editor',
         'claude-code',
         'cursor-ai',
+        'gemini-code-assist',
         'github-copilot-chat',
       ]);
     });
diff --git a/packages/rangelink-vscode-extension/src/__tests__/destinations/utils/buildDestinationQuickPickItems.test.ts b/packages/rangelink-vscode-extension/src/__tests__/destinations/utils/buildDestinationQuickPickItems.test.ts
index 8703bcebd..1412da869 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/destinations/utils/buildDestinationQuickPickItems.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/destinations/utils/buildDestinationQuickPickItems.test.ts
@@ -2,9 +2,11 @@ import * as vscode from 'vscode';
 
 import {
   buildDestinationQuickPickItems,
+  BUILTIN_AI_COUNT,
   DESTINATION_PICKER_SEQUENCE,
 } from '../../../destinations/utils/buildDestinationQuickPickItems';
 import type { FileMoreQuickPickItem, GroupedDestinationItems } from '../../../types';
+import { AI_ASSISTANT_KINDS } from '../../../types';
 import { createMockEligibleFile, createMockTextEditorQuickPickItem } from '../../helpers';
 
 const separator = (label: string): vscode.QuickPickItem => ({
@@ -17,6 +19,7 @@ describe('buildDestinationQuickPickItems', () => {
     it('defines the correct order of destination kinds', () => {
       expect(DESTINATION_PICKER_SEQUENCE).toStrictEqual([
         'claude-code',
+        'gemini-code-assist',
         'cursor-ai',
         'github-copilot-chat',
         'terminal',
@@ -27,6 +30,94 @@ describe('buildDestinationQuickPickItems', () => {
     });
   });
 
+  describe('BUILTIN_AI_COUNT', () => {
+    it('equals AI_ASSISTANT_KINDS.length — update this test and the behavioral test below when adding a new built-in AI assistant', () => {
+      expect(BUILTIN_AI_COUNT).toBe(AI_ASSISTANT_KINDS.length);
+      expect(BUILTIN_AI_COUNT).toBe(4);
+    });
+
+    it('places custom AI assistants between built-in AI assistants and non-AI destinations', () => {
+      const mockTerminal = { name: 'bash' } as vscode.Terminal;
+      const grouped: GroupedDestinationItems = {
+        'claude-code': [
+          {
+            label: 'Claude Code Chat',
+            displayName: 'Claude Code Chat',
+            bindOptions: { kind: 'claude-code' },
+            itemKind: 'bindable',
+          },
+        ],
+        'gemini-code-assist': [
+          {
+            label: 'Gemini Code Assist',
+            displayName: 'Gemini Code Assist',
+            bindOptions: { kind: 'gemini-code-assist' },
+            itemKind: 'bindable',
+          },
+        ],
+        'cursor-ai': [
+          {
+            label: 'Cursor AI',
+            displayName: 'Cursor AI',
+            bindOptions: { kind: 'cursor-ai' },
+            itemKind: 'bindable',
+          },
+        ],
+        'github-copilot-chat': [
+          {
+            label: 'GitHub Copilot Chat',
+            displayName: 'GitHub Copilot Chat',
+            bindOptions: { kind: 'github-copilot-chat' },
+            itemKind: 'bindable',
+          },
+        ],
+        'custom-ai:my-ai': [
+          {
+            label: 'My Custom AI',
+            displayName: 'My Custom AI',
+            bindOptions: { kind: 'custom-ai:my-ai' },
+            itemKind: 'bindable',
+          },
+        ],
+        terminal: [
+          {
+            label: 'Terminal "bash"',
+            displayName: 'Terminal "bash"',
+            bindOptions: { kind: 'terminal', terminal: mockTerminal },
+            isActive: false,
+            itemKind: 'bindable',
+            terminalInfo: { terminal: mockTerminal, name: 'bash', isActive: false },
+          },
+        ],
+      };
+
+      const identityLabelBuilder = (name: string): string => name;
+      const result = buildDestinationQuickPickItems(grouped, identityLabelBuilder);
+
+      const labels = result.map((item) => ('displayName' in item ? item.displayName : item.label));
+
+      expect(labels).toStrictEqual([
+        'AI Assistants',
+        'Claude Code Chat',
+        'Gemini Code Assist',
+        'Cursor AI',
+        'GitHub Copilot Chat',
+        'My Custom AI',
+        'Terminals',
+        'Terminal "bash"',
+      ]);
+
+      const aiSeparatorIndex = labels.indexOf('AI Assistants');
+      const terminalSeparatorIndex = labels.indexOf('Terminals');
+      const customAiIndex = labels.indexOf('My Custom AI');
+      const copilotIndex = labels.indexOf('GitHub Copilot Chat');
+
+      expect(customAiIndex).toBeGreaterThan(copilotIndex);
+      expect(customAiIndex).toBeLessThan(terminalSeparatorIndex);
+      expect(aiSeparatorIndex).toBeLessThan(copilotIndex);
+    });
+  });
+
   describe('buildDestinationQuickPickItems()', () => {
     const identityLabelBuilder = (name: string): string => name;
     const indentedLabelBuilder = (name: string): string => `    $(arrow-right) ${name}`;
diff --git a/packages/rangelink-vscode-extension/src/__tests__/extension.test.ts b/packages/rangelink-vscode-extension/src/__tests__/extension.test.ts
index ec5b7e78e..416d5dae9 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/extension.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/extension.test.ts
@@ -504,6 +504,61 @@ describe('Extension lifecycle', () => {
     (vscode.commands.registerCommand as jest.Mock).mockImplementation(mockCommands.registerCommand);
   });
 
+  // Command IDs registered (sorted alphabetically)
+  const expectedCommands = [
+    'rangelink.bindToClaudeCode',
+    'rangelink.bindToCursorAI',
+    'rangelink.bindToDestination',
+    'rangelink.bindToGeminiCodeAssist',
+    'rangelink.bindToGitHubCopilotChat',
+    'rangelink.bindToTerminal',
+    'rangelink.bindToTerminalHere',
+    'rangelink.bindToTextEditor',
+    'rangelink.bindToTextEditorHere',
+    'rangelink.bookmark.add',
+    'rangelink.bookmark.list',
+    'rangelink.bookmark.manage',
+    'rangelink.copyLinkOnlyWithAbsolutePath',
+    'rangelink.copyLinkOnlyWithRelativePath',
+    'rangelink.copyLinkWithAbsolutePath',
+    'rangelink.copyLinkWithRelativePath',
+    'rangelink.copyPortableLinkWithAbsolutePath',
+    'rangelink.copyPortableLinkWithRelativePath',
+    'rangelink.editorContent.bind',
+    'rangelink.editorContent.pasteFilePath',
+    'rangelink.editorContent.pasteRelativeFilePath',
+    'rangelink.editorContent.unbind',
+    'rangelink.editorContext.copyLink',
+    'rangelink.editorContext.copyLinkAbsolute',
+    'rangelink.editorContext.copyPortableLink',
+    'rangelink.editorContext.copyPortableLinkAbsolute',
+    'rangelink.editorContext.pasteSelectedText',
+    'rangelink.editorContext.saveBookmark',
+    'rangelink.editorTab.pasteFilePath',
+    'rangelink.editorTab.pasteRelativeFilePath',
+    'rangelink.explorer.bind',
+    'rangelink.explorer.pasteFilePath',
+    'rangelink.explorer.pasteRelativeFilePath',
+    'rangelink.explorer.unbind',
+    'rangelink.goToRangeLink',
+    'rangelink.handleDocumentLinkClick',
+    'rangelink.handleFilePathClick',
+    'rangelink.jumpToBoundDestination',
+    'rangelink.openStatusBarMenu',
+    'rangelink.pasteCurrentFileAbsolutePath',
+    'rangelink.pasteCurrentFileRelativePath',
+    'rangelink.pasteFileAbsolutePath',
+    'rangelink.pasteFileRelativePath',
+    'rangelink.pasteSelectedTextToDestination',
+    'rangelink.showVersion',
+    'rangelink.terminal.bind',
+    'rangelink.terminal.copyLinkGuard',
+    'rangelink.terminal.linkBridge',
+    'rangelink.terminal.pasteSelectedTextToDestination',
+    'rangelink.terminal.unbind',
+    'rangelink.unbindDestination',
+  ];
+
   it('should register all commands on activate', async () => {
     const mockContext = {
       subscriptions: [] as vscode.Disposable[],
@@ -536,60 +591,6 @@ describe('Extension lifecycle', () => {
     // Extension imported at top
     extension.activate(mockContext as any);
 
-    // Command IDs registered (sorted alphabetically)
-    const expectedCommands = [
-      'rangelink.bindToClaudeCode',
-      'rangelink.bindToCursorAI',
-      'rangelink.bindToDestination',
-      'rangelink.bindToGitHubCopilotChat',
-      'rangelink.bindToTerminal',
-      'rangelink.bindToTerminalHere',
-      'rangelink.bindToTextEditor',
-      'rangelink.bindToTextEditorHere',
-      'rangelink.bookmark.add',
-      'rangelink.bookmark.list',
-      'rangelink.bookmark.manage',
-      'rangelink.copyLinkOnlyWithAbsolutePath',
-      'rangelink.copyLinkOnlyWithRelativePath',
-      'rangelink.copyLinkWithAbsolutePath',
-      'rangelink.copyLinkWithRelativePath',
-      'rangelink.copyPortableLinkWithAbsolutePath',
-      'rangelink.copyPortableLinkWithRelativePath',
-      'rangelink.editorContent.bind',
-      'rangelink.editorContent.pasteFilePath',
-      'rangelink.editorContent.pasteRelativeFilePath',
-      'rangelink.editorContent.unbind',
-      'rangelink.editorContext.copyLink',
-      'rangelink.editorContext.copyLinkAbsolute',
-      'rangelink.editorContext.copyPortableLink',
-      'rangelink.editorContext.copyPortableLinkAbsolute',
-      'rangelink.editorContext.pasteSelectedText',
-      'rangelink.editorContext.saveBookmark',
-      'rangelink.editorTab.pasteFilePath',
-      'rangelink.editorTab.pasteRelativeFilePath',
-      'rangelink.explorer.bind',
-      'rangelink.explorer.pasteFilePath',
-      'rangelink.explorer.pasteRelativeFilePath',
-      'rangelink.explorer.unbind',
-      'rangelink.goToRangeLink',
-      'rangelink.handleDocumentLinkClick',
-      'rangelink.handleFilePathClick',
-      'rangelink.jumpToBoundDestination',
-      'rangelink.openStatusBarMenu',
-      'rangelink.pasteCurrentFileAbsolutePath',
-      'rangelink.pasteCurrentFileRelativePath',
-      'rangelink.pasteFileAbsolutePath',
-      'rangelink.pasteFileRelativePath',
-      'rangelink.pasteSelectedTextToDestination',
-      'rangelink.showVersion',
-      'rangelink.terminal.bind',
-      'rangelink.terminal.copyLinkGuard',
-      'rangelink.terminal.linkBridge',
-      'rangelink.terminal.pasteSelectedTextToDestination',
-      'rangelink.terminal.unbind',
-      'rangelink.unbindDestination',
-    ];
-
     expect(mockCommands.registerCommand).toHaveBeenCalledTimes(expectedCommands.length);
     expect(vscode.window.createOutputChannel).toHaveBeenCalledWith('RangeLink');
 
@@ -622,10 +623,12 @@ describe('Extension lifecycle', () => {
 
     const INFRASTRUCTURE_COUNT = 3;
     const PROVIDER_COUNT = 4;
-    const COMMAND_COUNT = 50;
     const DESTINATION_MANAGER_LISTENERS = 3;
     const EXPECTED_SUBSCRIPTION_COUNT =
-      INFRASTRUCTURE_COUNT + PROVIDER_COUNT + COMMAND_COUNT + DESTINATION_MANAGER_LISTENERS;
+      INFRASTRUCTURE_COUNT +
+      PROVIDER_COUNT +
+      expectedCommands.length +
+      DESTINATION_MANAGER_LISTENERS;
 
     expect(mockContext.subscriptions.length).toBe(EXPECTED_SUBSCRIPTION_COUNT);
   });
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockBindableQuickPickItem.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockBindableQuickPickItem.ts
index 85343d145..91d1737bd 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockBindableQuickPickItem.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockBindableQuickPickItem.ts
@@ -1,6 +1,7 @@
 import type * as vscode from 'vscode';
 
 import type {
+  AIAssistantDestinationKind,
   BindableQuickPickItem,
   EligibleFile,
   EligibleTerminal,
@@ -44,7 +45,7 @@ export const createMockTerminalQuickPickItem = (
  * @returns A BindableQuickPickItem for the AI assistant
  */
 export const createMockAIAssistantQuickPickItem = (
-  kind: 'claude-code' | 'cursor-ai' | 'github-copilot-chat',
+  kind: AIAssistantDestinationKind,
   displayName: string,
 ): BindableQuickPickItem => ({
   label: displayName,
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockDestinationRegistry.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockDestinationRegistry.ts
index 302f45a76..f90fd49db 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockDestinationRegistry.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockDestinationRegistry.ts
@@ -6,6 +6,7 @@ import { DESTINATION_KINDS, type DestinationKind } from '../../types';
 import { createMockClaudeCodeComposableDestination } from './createMockClaudeCodeComposableDestination';
 import { createMockCursorAIComposableDestination } from './createMockCursorAIComposableDestination';
 import { createMockEditorComposablePasteDestination } from './createMockEditorComposablePasteDestination';
+import { createMockGeminiCodeAssistComposableDestination } from './createMockGeminiCodeAssistComposableDestination';
 import { createMockGitHubCopilotChatComposableDestination } from './createMockGitHubCopilotChatComposableDestination';
 import { createMockTerminalComposablePasteDestination } from './createMockTerminalComposablePasteDestination';
 import { createMockTerminalPasteDestination } from './createMockTerminalPasteDestination';
@@ -21,8 +22,9 @@ export interface MockDestinationRegistryOptions {
   destinations?: {
     terminal?: jest.Mocked<PasteDestination>;
     'text-editor'?: jest.Mocked<PasteDestination>;
-    'cursor-ai'?: jest.Mocked<PasteDestination>;
     'claude-code'?: jest.Mocked<PasteDestination>;
+    'gemini-code-assist'?: jest.Mocked<PasteDestination>;
+    'cursor-ai'?: jest.Mocked<PasteDestination>;
     'github-copilot-chat'?: jest.Mocked<PasteDestination>;
   };
 
@@ -41,9 +43,10 @@ export interface MockDestinationRegistryOptions {
 const DEFAULT_DISPLAY_NAMES: Record<DestinationKind, string> = {
   terminal: 'Terminal',
   'text-editor': 'Text Editor',
+  'claude-code': 'Claude Code Chat',
   'cursor-ai': 'Cursor AI Assistant',
+  'gemini-code-assist': 'Gemini Code Assist',
   'github-copilot-chat': 'GitHub Copilot Chat',
-  'claude-code': 'Claude Code Chat',
 };
 
 /**
@@ -63,10 +66,12 @@ export const createMockDestinationRegistry = (
     terminal: createMockTerminalPasteDestination(),
     'text-editor':
       createMockEditorComposablePasteDestination() as unknown as jest.Mocked<PasteDestination>,
-    'cursor-ai':
-      createMockCursorAIComposableDestination() as unknown as jest.Mocked<PasteDestination>,
     'claude-code':
       createMockClaudeCodeComposableDestination() as unknown as jest.Mocked<PasteDestination>,
+    'gemini-code-assist':
+      createMockGeminiCodeAssistComposableDestination() as unknown as jest.Mocked<PasteDestination>,
+    'cursor-ai':
+      createMockCursorAIComposableDestination() as unknown as jest.Mocked<PasteDestination>,
     'github-copilot-chat':
       createMockGitHubCopilotChatComposableDestination() as unknown as jest.Mocked<PasteDestination>,
   };
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockFocusCapabilityFactory.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockFocusCapabilityFactory.ts
index 9697db6ee..1ab7c9509 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockFocusCapabilityFactory.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockFocusCapabilityFactory.ts
@@ -1,5 +1,5 @@
 import type { FocusCapabilityFactory } from '../../destinations/capabilities';
-import type { LazyResolvedFocusCapability } from '../../destinations/capabilities/LazyResolvedFocusCapability';
+import type { LazyResolvedFocusCapability } from '../../destinations/capabilities';
 
 /**
  * Create a mock LazyResolvedFocusCapability for testing.
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistComposableDestination.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistComposableDestination.ts
new file mode 100644
index 000000000..c49d26fab
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistComposableDestination.ts
@@ -0,0 +1,26 @@
+import {
+  createMockSingletonComposablePasteDestination,
+  type MockSingletonComposablePasteDestinationConfig,
+} from './createMockSingletonComposablePasteDestination';
+
+/**
+ * Create a mock Gemini Code Assist ComposablePasteDestination for testing (Paradigm B).
+ *
+ * Uses Paradigm B (real class with mocked capabilities). This creates an actual
+ * ComposablePasteDestination instance with mock capabilities injected.
+ *
+ * For Paradigm A (pure jest mocks), use createMockGeminiCodeAssistDestination instead.
+ *
+ * @param overrides - Optional config overrides
+ * @returns ComposablePasteDestination instance configured as Gemini Code Assist
+ */
+export const createMockGeminiCodeAssistComposableDestination = (
+  overrides?: Omit<MockSingletonComposablePasteDestinationConfig, 'id'>,
+) =>
+  createMockSingletonComposablePasteDestination({
+    id: 'gemini-code-assist',
+    displayName: 'Gemini Code Assist',
+    jumpSuccessMessage: '✓ Focused Gemini Code Assist',
+    loggingDetails: { assistantType: 'gemini-code-assist' },
+    ...overrides,
+  });
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistDestination.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistDestination.ts
new file mode 100644
index 000000000..c11e7dc5d
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/createMockGeminiCodeAssistDestination.ts
@@ -0,0 +1,22 @@
+import {
+  createBaseMockPasteDestination,
+  type MockDestinationOptions,
+} from './createBaseMockPasteDestination';
+
+/**
+ * Create a mock Gemini Code Assist destination for testing (Paradigm A).
+ *
+ * Uses Paradigm A (pure jest mocks). For Paradigm B (real class with mocked
+ * capabilities), use createMockGeminiCodeAssistComposableDestination.
+ *
+ * @param overrides - Optional overrides for mock behavior
+ * @returns Mock PasteDestination configured as Gemini Code Assist
+ */
+export const createMockGeminiCodeAssistDestination = (
+  overrides?: Omit<MockDestinationOptions, 'id'>,
+) =>
+  createBaseMockPasteDestination({
+    id: 'gemini-code-assist',
+    displayName: 'Gemini Code Assist',
+    ...overrides,
+  });
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/index.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/index.ts
index 1db4ba5c1..27cb5ce3f 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/helpers/index.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/index.ts
@@ -35,6 +35,8 @@ export * from './createMockExtensions';
 export * from './createMockFormattedLink';
 export * from './createMockFocusCapabilityFactory';
 export * from './createMockGetWorkspaceFolder';
+export * from './createMockGeminiCodeAssistComposableDestination';
+export * from './createMockGeminiCodeAssistDestination';
 export * from './createMockGitHubCopilotChatComposableDestination';
 export * from './createMockGitHubCopilotChatDestination';
 export * from './createMockInsertFactory';
@@ -76,6 +78,7 @@ export * from './spyOnFormatMessage';
 export * from './spyOnGenerateLinkFromSelections';
 export * from './spyOnIsClaudeCodeAvailable';
 export * from './spyOnIsCursorIDEDetected';
+export * from './spyOnIsGeminiCodeAssistAvailable';
 export * from './spyOnIsGitHubCopilotChatAvailable';
 export * from './spyOnResolveWorkspacePath';
 export * from './spyOnShowFilePicker';
diff --git a/packages/rangelink-vscode-extension/src/__tests__/helpers/spyOnIsGeminiCodeAssistAvailable.ts b/packages/rangelink-vscode-extension/src/__tests__/helpers/spyOnIsGeminiCodeAssistAvailable.ts
new file mode 100644
index 000000000..4645458ec
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/__tests__/helpers/spyOnIsGeminiCodeAssistAvailable.ts
@@ -0,0 +1,9 @@
+import type { Logger } from 'barebone-logger';
+
+import type { VscodeAdapter } from '../../ide/vscode/VscodeAdapter';
+import * as isGeminiCodeAssistAvailableModule from '../../utils/aiAssistants/isGeminiCodeAssistAvailable';
+
+export const spyOnIsGeminiCodeAssistAvailable = (): jest.SpyInstance<
+  Promise<boolean>,
+  [VscodeAdapter, Logger]
+> => jest.spyOn(isGeminiCodeAssistAvailableModule, 'isGeminiCodeAssistAvailable');
diff --git a/packages/rangelink-vscode-extension/src/__tests__/services/ClipboardRouter.test.ts b/packages/rangelink-vscode-extension/src/__tests__/services/ClipboardRouter.test.ts
index cff7090d5..abefeeb3c 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/services/ClipboardRouter.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/services/ClipboardRouter.test.ts
@@ -145,7 +145,7 @@ describe('ClipboardRouter', () => {
 
       expect(mockPreserver.preserve).toHaveBeenCalledTimes(1);
       expect(capturedShouldRestore?.()).toBe(false);
-      expect(mockDestinationManager.isClipboardRestorationApplicable).toHaveBeenCalledTimes(1);
+      expect(mockDestinationManager.isClipboardRestorationApplicable).toHaveBeenCalledWith(true);
     });
 
     it('skips preservation when destinationBehavior is ClipboardOnly', async () => {
diff --git a/packages/rangelink-vscode-extension/src/__tests__/wireSubscriptions.test.ts b/packages/rangelink-vscode-extension/src/__tests__/wireSubscriptions.test.ts
index 4a5381bbb..707f0cc24 100644
--- a/packages/rangelink-vscode-extension/src/__tests__/wireSubscriptions.test.ts
+++ b/packages/rangelink-vscode-extension/src/__tests__/wireSubscriptions.test.ts
@@ -2,6 +2,7 @@ import {
   CMD_BIND_TO_CLAUDE_CODE,
   CMD_BIND_TO_CURSOR_AI,
   CMD_BIND_TO_DESTINATION,
+  CMD_BIND_TO_GEMINI_CODE_ASSIST,
   CMD_BIND_TO_GITHUB_COPILOT_CHAT,
   CMD_BIND_TO_TERMINAL,
   CMD_BIND_TO_TERMINAL_HERE,
@@ -74,6 +75,7 @@ const EXPECTED_COMMANDS = [
   CMD_BIND_TO_TEXT_EDITOR_HERE,
   CMD_BIND_TO_CURSOR_AI,
   CMD_BIND_TO_CLAUDE_CODE,
+  CMD_BIND_TO_GEMINI_CODE_ASSIST,
   CMD_BIND_TO_GITHUB_COPILOT_CHAT,
   CMD_UNBIND_DESTINATION,
   CMD_BIND_TO_DESTINATION,
@@ -132,7 +134,7 @@ describe('wireSubscriptions', () => {
       expect(registeredCommands).toContain(cmd);
     }
 
-    expect(registeredCommands).toHaveLength(50);
+    expect(registeredCommands).toHaveLength(51);
   });
 
   it('registers 2 terminal link providers', () => {
diff --git a/packages/rangelink-vscode-extension/src/constants/commandIds.ts b/packages/rangelink-vscode-extension/src/constants/commandIds.ts
index 82a2fc739..7883655d4 100644
--- a/packages/rangelink-vscode-extension/src/constants/commandIds.ts
+++ b/packages/rangelink-vscode-extension/src/constants/commandIds.ts
@@ -7,6 +7,7 @@
 export const CMD_BIND_TO_CLAUDE_CODE = 'rangelink.bindToClaudeCode';
 export const CMD_BIND_TO_CURSOR_AI = 'rangelink.bindToCursorAI';
 export const CMD_BIND_TO_DESTINATION = 'rangelink.bindToDestination';
+export const CMD_BIND_TO_GEMINI_CODE_ASSIST = 'rangelink.bindToGeminiCodeAssist';
 export const CMD_BIND_TO_GITHUB_COPILOT_CHAT = 'rangelink.bindToGitHubCopilotChat';
 export const CMD_BIND_TO_TERMINAL = 'rangelink.bindToTerminal';
 export const CMD_BIND_TO_TERMINAL_HERE = 'rangelink.bindToTerminalHere';
diff --git a/packages/rangelink-vscode-extension/src/constants/settingDefaults.ts b/packages/rangelink-vscode-extension/src/constants/settingDefaults.ts
index e660334ac..679552e7f 100644
--- a/packages/rangelink-vscode-extension/src/constants/settingDefaults.ts
+++ b/packages/rangelink-vscode-extension/src/constants/settingDefaults.ts
@@ -1,3 +1,8 @@
+import { DEFAULT_DELIMITERS } from 'rangelink-core-ts';
+
+import type { ClipboardPreservationMode } from '../types/ClipboardPreservationMode';
+import type { PaddingMode } from '../utils/applySmartPadding';
+
 /**
  * Single source of truth for default values for all RangeLink extension settings.
  *
@@ -5,10 +10,14 @@
  * Keep entries sorted alphabetically by constant name within each section.
  */
 
-import { DEFAULT_DELIMITERS } from 'rangelink-core-ts';
+// =============================================================================
+// Destination Defaults
+// =============================================================================
 
-import type { ClipboardPreservationMode } from '../types/ClipboardPreservationMode';
-import type { PaddingMode } from '../utils/applySmartPadding';
+export const DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_REFOCUS_INTERVAL_MS = 300;
+export const DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_START_DELAY_MS = 1500;
+export const DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS = 300;
+export const DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS = 2500;
 
 // =============================================================================
 // Feature Flag Defaults — TODO: #366 remove when bookmarks graduates from beta
@@ -31,13 +40,6 @@ export const DEFAULT_DELIMITER_LINE = DEFAULT_DELIMITERS.line;
 export const DEFAULT_DELIMITER_POSITION = DEFAULT_DELIMITERS.position;
 export const DEFAULT_DELIMITER_RANGE = DEFAULT_DELIMITERS.range;
 
-// =============================================================================
-// Destination Defaults
-// =============================================================================
-
-export const DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_REFOCUS_INTERVAL_MS = 300;
-export const DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_START_DELAY_MS = 1500;
-
 // =============================================================================
 // Navigation Defaults
 // =============================================================================
diff --git a/packages/rangelink-vscode-extension/src/constants/settingKeys.ts b/packages/rangelink-vscode-extension/src/constants/settingKeys.ts
index 9908faf35..722934891 100644
--- a/packages/rangelink-vscode-extension/src/constants/settingKeys.ts
+++ b/packages/rangelink-vscode-extension/src/constants/settingKeys.ts
@@ -27,6 +27,10 @@ export const SETTING_DESTINATIONS_CLAUDE_CODE_COLD_REFOCUS_INTERVAL_MS =
   'destinations.claudeCode.coldRefocusIntervalMs';
 export const SETTING_DESTINATIONS_CLAUDE_CODE_COLD_START_DELAY_MS =
   'destinations.claudeCode.coldStartDelayMs';
+export const SETTING_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS =
+  'destinations.gemini.coldRefocusIntervalMs';
+export const SETTING_DESTINATIONS_GEMINI_COLD_START_DELAY_MS =
+  'destinations.gemini.coldStartDelayMs';
 
 // =============================================================================
 // Feature Flags — TODO: #366 remove when bookmarks graduates from beta
diff --git a/packages/rangelink-vscode-extension/src/destinations/DestinationAvailabilityService.ts b/packages/rangelink-vscode-extension/src/destinations/DestinationAvailabilityService.ts
index e6b6baaa7..6c749d7d6 100644
--- a/packages/rangelink-vscode-extension/src/destinations/DestinationAvailabilityService.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/DestinationAvailabilityService.ts
@@ -47,6 +47,7 @@ const isValidThreshold = (value: number): boolean =>
 const AI_ASSISTANT_UNAVAILABLE_MESSAGE_CODES: Record<AIAssistantDestinationKind, MessageCode> = {
   'claude-code': MessageCode.INFO_CLAUDE_CODE_NOT_AVAILABLE,
   'cursor-ai': MessageCode.INFO_CURSOR_AI_NOT_AVAILABLE,
+  'gemini-code-assist': MessageCode.INFO_GEMINI_CODE_ASSIST_NOT_AVAILABLE,
   'github-copilot-chat': MessageCode.INFO_GITHUB_COPILOT_CHAT_NOT_AVAILABLE,
 };
 
@@ -227,6 +228,7 @@ export class DestinationAvailabilityService {
 
         case 'claude-code':
         case 'cursor-ai':
+        case 'gemini-code-assist':
         case 'github-copilot-chat': {
           const displayNames = this.registry.getDisplayNames();
           const available = await this.isAIAssistantAvailable(kind);
diff --git a/packages/rangelink-vscode-extension/src/destinations/DestinationRegistry.ts b/packages/rangelink-vscode-extension/src/destinations/DestinationRegistry.ts
index 033dfb413..4c6bbe050 100644
--- a/packages/rangelink-vscode-extension/src/destinations/DestinationRegistry.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/DestinationRegistry.ts
@@ -20,6 +20,7 @@ const DISPLAY_NAME_CODES: Record<DestinationKind, MessageCode> = {
   terminal: MessageCode.DESTINATION_DISPLAY_NAME_TERMINAL,
   'text-editor': MessageCode.DESTINATION_DISPLAY_NAME_TEXT_EDITOR,
   'cursor-ai': MessageCode.DESTINATION_DISPLAY_NAME_CURSOR_AI,
+  'gemini-code-assist': MessageCode.DESTINATION_DISPLAY_NAME_GEMINI_CODE_ASSIST,
   'github-copilot-chat': MessageCode.DESTINATION_DISPLAY_NAME_GITHUB_COPILOT_CHAT,
   'claude-code': MessageCode.DESTINATION_DISPLAY_NAME_CLAUDE_CODE,
 };
diff --git a/packages/rangelink-vscode-extension/src/destinations/PasteDestinationManager.ts b/packages/rangelink-vscode-extension/src/destinations/PasteDestinationManager.ts
index 250f71cac..d6c198bb2 100644
--- a/packages/rangelink-vscode-extension/src/destinations/PasteDestinationManager.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/PasteDestinationManager.ts
@@ -71,6 +71,7 @@ export class PasteDestinationManager implements vscode.Disposable {
   > = {
     'claude-code': MessageCode.ERROR_CLAUDE_CODE_NOT_AVAILABLE,
     'cursor-ai': MessageCode.ERROR_CURSOR_AI_NOT_AVAILABLE,
+    'gemini-code-assist': MessageCode.ERROR_GEMINI_CODE_ASSIST_NOT_AVAILABLE,
     'github-copilot-chat': MessageCode.ERROR_GITHUB_COPILOT_CHAT_NOT_AVAILABLE,
   };
 
@@ -112,6 +113,7 @@ export class PasteDestinationManager implements vscode.Disposable {
       case 'text-editor':
         return this.bindTextEditor(options);
       case 'cursor-ai':
+      case 'gemini-code-assist':
       case 'github-copilot-chat':
       case 'claude-code':
         return this.bindGenericDestination(options.kind);
@@ -822,6 +824,7 @@ export class PasteDestinationManager implements vscode.Disposable {
 
       case 'claude-code':
       case 'cursor-ai':
+      case 'gemini-code-assist':
       case 'github-copilot-chat':
         // Chat assistants should provide getUserInstruction(AutoPasteResult.Failure)
         // and never reach this fallback method
diff --git a/packages/rangelink-vscode-extension/src/destinations/aiAssistantFocusCommands.ts b/packages/rangelink-vscode-extension/src/destinations/aiAssistantFocusCommands.ts
index 3151d27be..7bcf00ee3 100644
--- a/packages/rangelink-vscode-extension/src/destinations/aiAssistantFocusCommands.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/aiAssistantFocusCommands.ts
@@ -16,6 +16,10 @@ export const CLAUDE_CODE_FOCUS_COMMANDS = [
   'claude-vscode.editor.open', // Fallback: Open in new tab
 ];
 
+export const GEMINI_CODE_ASSIST_FOCUS_COMMANDS = [
+  'cloudcode.gemini.chatView.focus', // google.geminicodeassist extension ≥ 2.79
+];
+
 export const GITHUB_COPILOT_CHAT_FOCUS_COMMANDS = [
   'workbench.action.chat.open', // Primary: Opens/focuses the chat view
   'workbench.panel.chat.view.copilot.focus', // Fallback: Direct panel focus
diff --git a/packages/rangelink-vscode-extension/src/destinations/capabilities/AIAssistantFocusCapability.ts b/packages/rangelink-vscode-extension/src/destinations/capabilities/AIAssistantFocusCapability.ts
index b57eec82e..dd1d976dc 100644
--- a/packages/rangelink-vscode-extension/src/destinations/capabilities/AIAssistantFocusCapability.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/capabilities/AIAssistantFocusCapability.ts
@@ -16,7 +16,7 @@ import type { InsertFactory } from './insertFactories';
  * at intervals to keep the panel open while it initializes.
  * Uses InsertFactory injection for decoupled clipboard-based paste.
  *
- * Used by: Claude Code, Cursor AI, GitHub Copilot Chat
+ * Used by: Claude Code, Gemini Code Assist, Cursor AI, GitHub Copilot Chat
  */
 export class AIAssistantFocusCapability implements FocusCapability {
   private panelIsWarm = false;
diff --git a/packages/rangelink-vscode-extension/src/destinations/capabilities/index.ts b/packages/rangelink-vscode-extension/src/destinations/capabilities/index.ts
index 9f052d790..d0a8e4f03 100644
--- a/packages/rangelink-vscode-extension/src/destinations/capabilities/index.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/capabilities/index.ts
@@ -2,6 +2,7 @@ export type { EligibilityChecker } from './EligibilityChecker';
 export { ContentEligibilityChecker } from './ContentEligibilityChecker';
 export { EligibilityCheckerFactory } from './EligibilityCheckerFactory';
 
+export type { ColdRefocusConfig } from './ColdRefocusConfig';
 export type {
   FocusCapability,
   FocusResult,
@@ -11,10 +12,9 @@ export type {
 export { FocusErrorReason } from './FocusCapability';
 export { AIAssistantFocusCapability } from './AIAssistantFocusCapability';
 export { EditorFocusCapability } from './EditorFocusCapability';
+export { LazyResolvedFocusCapability } from './LazyResolvedFocusCapability';
 export { TerminalFocusCapability } from './TerminalFocusCapability';
 export { FocusCapabilityFactory } from './FocusCapabilityFactory';
-export { LazyResolvedFocusCapability } from './LazyResolvedFocusCapability';
-export { ColdRefocusConfig } from './ColdRefocusConfig';
 
 export type { InsertFactory } from './insertFactories';
 export {
diff --git a/packages/rangelink-vscode-extension/src/destinations/destinationBuilders.ts b/packages/rangelink-vscode-extension/src/destinations/destinationBuilders.ts
index e83ac4681..77029accd 100644
--- a/packages/rangelink-vscode-extension/src/destinations/destinationBuilders.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/destinationBuilders.ts
@@ -11,10 +11,14 @@ import type { CustomAiAssistantConfig } from '../config/parseCustomAiAssistants'
 import {
   DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_REFOCUS_INTERVAL_MS,
   DEFAULT_DESTINATIONS_CLAUDE_CODE_COLD_START_DELAY_MS,
+  DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+  DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
 } from '../constants/settingDefaults';
 import {
   SETTING_DESTINATIONS_CLAUDE_CODE_COLD_REFOCUS_INTERVAL_MS,
   SETTING_DESTINATIONS_CLAUDE_CODE_COLD_START_DELAY_MS,
+  SETTING_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+  SETTING_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
 } from '../constants/settingKeys';
 import { RangeLinkExtensionError, RangeLinkExtensionErrorCodes } from '../errors';
 import {
@@ -29,12 +33,19 @@ import {
   getUntitledDisplayName,
   isClaudeCodeAvailable,
   isCursorIDEDetected,
+  isGeminiCodeAssistAvailable,
   isGitHubCopilotChatAvailable,
 } from '../utils';
+import {
+  EXTENSION_ID_CLAUDE_CODE,
+  EXTENSION_ID_GEMINI_CODE_ASSIST,
+  EXTENSION_ID_GITHUB_COPILOT_CHAT,
+} from '../utils/aiAssistants/';
 
 import {
   CLAUDE_CODE_FOCUS_COMMANDS,
   CURSOR_AI_FOCUS_COMMANDS,
+  GEMINI_CODE_ASSIST_FOCUS_COMMANDS,
   GITHUB_COPILOT_CHAT_FOCUS_COMMANDS,
 } from './aiAssistantFocusCommands';
 import type { ColdRefocusConfig } from './capabilities/ColdRefocusConfig';
@@ -67,7 +78,7 @@ const BUILTIN_AI_ASSISTANTS: Record<string, BuiltinAiAssistantDef> = {
     userInstructionMessageCode: MessageCode.INFO_CURSOR_AI_USER_INSTRUCTIONS,
     isAvailable: (ctx) => isCursorIDEDetected(ctx.ideAdapter, ctx.logger),
   },
-  'anthropic.claude-code': {
+  [EXTENSION_ID_CLAUDE_CODE]: {
     kind: 'claude-code',
     focusCommands: CLAUDE_CODE_FOCUS_COMMANDS,
     displayName: 'Claude Code Chat',
@@ -98,7 +109,38 @@ const BUILTIN_AI_ASSISTANTS: Record<string, BuiltinAiAssistantDef> = {
       return { totalMs, intervalMs };
     },
   },
-  'github.copilot-chat': {
+  [EXTENSION_ID_GEMINI_CODE_ASSIST]: {
+    kind: 'gemini-code-assist',
+    focusCommands: GEMINI_CODE_ASSIST_FOCUS_COMMANDS,
+    displayName: 'Gemini Code Assist',
+    jumpMessageCode: MessageCode.STATUS_BAR_JUMP_SUCCESS_GEMINI_CODE_ASSIST,
+    userInstructionMessageCode: MessageCode.INFO_GEMINI_CODE_ASSIST_USER_INSTRUCTIONS,
+    isAvailable: (ctx) => isGeminiCodeAssistAvailable(ctx.ideAdapter, ctx.logger),
+    getColdRefocus: (context) => {
+      const totalMs = context.configReader.getWithDefault(
+        SETTING_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+        DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+      ) as number;
+      const intervalMs = context.configReader.getWithDefault(
+        SETTING_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+        DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+      ) as number;
+
+      if (totalMs <= intervalMs) {
+        context.logger.warn(
+          { fn: 'gemini.getColdRefocus', totalMs, intervalMs },
+          'coldStartDelayMs must be greater than coldRefocusIntervalMs, using defaults',
+        );
+        return {
+          totalMs: DEFAULT_DESTINATIONS_GEMINI_COLD_START_DELAY_MS,
+          intervalMs: DEFAULT_DESTINATIONS_GEMINI_COLD_REFOCUS_INTERVAL_MS,
+        };
+      }
+
+      return { totalMs, intervalMs };
+    },
+  },
+  [EXTENSION_ID_GITHUB_COPILOT_CHAT]: {
     kind: 'github-copilot-chat',
     focusCommands: GITHUB_COPILOT_CHAT_FOCUS_COMMANDS,
     displayName: 'GitHub Copilot Chat',
@@ -202,7 +244,7 @@ export const buildTextEditorDestination: DestinationBuilder = (options, context)
 // ============================================================================
 
 /**
- * Build a built-in AI assistant destination (Cursor AI, Claude Code, GitHub Copilot Chat).
+ * Build a built-in AI assistant destination (Cursor AI, Claude Code, Gemini Code Assist, GitHub Copilot Chat).
  *
  * Uses the standard focus+paste flow via AIAssistantFocusCapability.
  */
diff --git a/packages/rangelink-vscode-extension/src/destinations/index.ts b/packages/rangelink-vscode-extension/src/destinations/index.ts
index 4210dcf86..fa7c4f0dd 100644
--- a/packages/rangelink-vscode-extension/src/destinations/index.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/index.ts
@@ -1,3 +1,4 @@
+export * from './aiAssistantFocusCommands';
 export * from './capabilities';
 export * from './equality';
 export * from './types';
diff --git a/packages/rangelink-vscode-extension/src/destinations/utils/buildDestinationQuickPickItems.ts b/packages/rangelink-vscode-extension/src/destinations/utils/buildDestinationQuickPickItems.ts
index fa19d831e..62dec1171 100644
--- a/packages/rangelink-vscode-extension/src/destinations/utils/buildDestinationQuickPickItems.ts
+++ b/packages/rangelink-vscode-extension/src/destinations/utils/buildDestinationQuickPickItems.ts
@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
 
 import { RangeLinkExtensionError, RangeLinkExtensionErrorCodes } from '../../errors';
 import {
+  AI_ASSISTANT_KINDS,
   type BindableQuickPickItem,
   DESTINATION_KINDS,
   type DestinationQuickPickItem,
@@ -18,6 +19,8 @@ import { formatMessage } from '../../utils';
 
 import { buildTerminalDescription } from './buildTerminalDescription';
 
+export const BUILTIN_AI_COUNT = AI_ASSISTANT_KINDS.length;
+
 const isDestinationKind = (key: string): key is DestinationKind =>
   (DESTINATION_KINDS as readonly string[]).includes(key) || key.startsWith('custom-ai:');
 
@@ -35,6 +38,7 @@ type PickerSequenceKey = DestinationKind | 'file-more' | 'terminal-more';
  */
 export const DESTINATION_PICKER_SEQUENCE: readonly PickerSequenceKey[] = [
   'claude-code',
+  'gemini-code-assist',
   'cursor-ai',
   'github-copilot-chat',
   'terminal',
@@ -48,6 +52,7 @@ type DestinationGroup = 'ai' | 'terminal' | 'file';
 const DESTINATION_GROUP_MAP: Record<PickerSequenceKey, DestinationGroup> = {
   'claude-code': 'ai',
   'cursor-ai': 'ai',
+  'gemini-code-assist': 'ai',
   'github-copilot-chat': 'ai',
   terminal: 'terminal',
   'terminal-more': 'terminal',
@@ -89,9 +94,9 @@ export const buildDestinationQuickPickItems = (
     (key) => isCustomAiAssistantKind(key) && grouped[key as keyof GroupedDestinationItems],
   );
   const fullSequence: PickerSequenceKey[] = [
-    ...DESTINATION_PICKER_SEQUENCE.slice(0, 3),
+    ...DESTINATION_PICKER_SEQUENCE.slice(0, BUILTIN_AI_COUNT),
     ...(customAiKinds as PickerSequenceKey[]),
-    ...DESTINATION_PICKER_SEQUENCE.slice(3),
+    ...DESTINATION_PICKER_SEQUENCE.slice(BUILTIN_AI_COUNT),
   ];
 
   for (const key of fullSequence) {
diff --git a/packages/rangelink-vscode-extension/src/i18n/messages.en.ts b/packages/rangelink-vscode-extension/src/i18n/messages.en.ts
index 03cb7d89f..eab676fac 100644
--- a/packages/rangelink-vscode-extension/src/i18n/messages.en.ts
+++ b/packages/rangelink-vscode-extension/src/i18n/messages.en.ts
@@ -38,6 +38,7 @@ export const messagesEn: Record<MessageCode, string> = {
 
   [MessageCode.DESTINATION_DISPLAY_NAME_CLAUDE_CODE]: 'Claude Code Chat',
   [MessageCode.DESTINATION_DISPLAY_NAME_CURSOR_AI]: 'Cursor AI Assistant',
+  [MessageCode.DESTINATION_DISPLAY_NAME_GEMINI_CODE_ASSIST]: 'Gemini Code Assist',
   [MessageCode.DESTINATION_DISPLAY_NAME_GITHUB_COPILOT_CHAT]: 'GitHub Copilot Chat',
   [MessageCode.DESTINATION_DISPLAY_NAME_TERMINAL]: 'Terminal',
   [MessageCode.DESTINATION_DISPLAY_NAME_TEXT_EDITOR]: 'Text Editor',
@@ -69,6 +70,8 @@ export const messagesEn: Record<MessageCode, string> = {
   [MessageCode.ERROR_CUSTOM_AI_NOT_AVAILABLE]:
     'RangeLink: Cannot bind {extensionName} - extension not installed or not active',
   [MessageCode.ERROR_FILE_PATH_NAVIGATION_FAILED]: 'RangeLink: Failed to open file {path}: {error}',
+  [MessageCode.ERROR_GEMINI_CODE_ASSIST_NOT_AVAILABLE]:
+    'RangeLink: Cannot bind Gemini Code Assist - extension not installed or not active',
   [MessageCode.ERROR_GITHUB_COPILOT_CHAT_NOT_AVAILABLE]:
     'RangeLink: Cannot bind GitHub Copilot Chat - extension not installed or not active',
   [MessageCode.ERROR_INVALID_DELIMITER_CONFIG]:
@@ -126,6 +129,10 @@ export const messagesEn: Record<MessageCode, string> = {
   [MessageCode.INFO_CURSOR_AI_NOT_AVAILABLE]:
     'This command is designed for Cursor IDE, which has built-in AI chat.\n\nRangeLink can paste code ranges directly into Cursor AI chat for faster context sharing. To use this feature, open your project in Cursor IDE instead of VS Code.',
   [MessageCode.INFO_CURSOR_AI_USER_INSTRUCTIONS]: 'Paste (Cmd/Ctrl+V) in Cursor chat to use.',
+  [MessageCode.INFO_GEMINI_CODE_ASSIST_NOT_AVAILABLE]:
+    'RangeLink can seamlessly integrate with Gemini Code Assist for faster context sharing of precise code ranges.\n\nInstall and activate the Gemini Code Assist extension to use it as a paste destination.',
+  [MessageCode.INFO_GEMINI_CODE_ASSIST_USER_INSTRUCTIONS]:
+    'Paste (Cmd/Ctrl+V) in Gemini Code Assist to use.',
   [MessageCode.INFO_GITHUB_COPILOT_CHAT_NOT_AVAILABLE]:
     'RangeLink can seamlessly integrate with GitHub Copilot Chat for faster context sharing of precise code ranges.\n\nInstall and activate the GitHub Copilot Chat extension to use it as a paste destination.',
   [MessageCode.INFO_GITHUB_COPILOT_CHAT_USER_INSTRUCTIONS]:
@@ -176,6 +183,7 @@ export const messagesEn: Record<MessageCode, string> = {
   [MessageCode.STATUS_BAR_JUMP_SUCCESS_CURSOR_AI]: '✓ Focused Cursor AI Assistant',
   [MessageCode.STATUS_BAR_JUMP_SUCCESS_CUSTOM_AI]: '✓ Focused {extensionName}',
   [MessageCode.STATUS_BAR_JUMP_SUCCESS_EDITOR]: '✓ Focused Editor: "{resourceName}"',
+  [MessageCode.STATUS_BAR_JUMP_SUCCESS_GEMINI_CODE_ASSIST]: '✓ Focused Gemini Code Assist',
   [MessageCode.STATUS_BAR_JUMP_SUCCESS_GITHUB_COPILOT_CHAT]: '✓ Focused GitHub Copilot Chat',
   [MessageCode.STATUS_BAR_JUMP_SUCCESS_TERMINAL]: '✓ Focused Terminal: "{resourceName}"',
   [MessageCode.STATUS_BAR_BOOKMARK_SAVED]: '✓ Bookmark saved: {label}',
diff --git a/packages/rangelink-vscode-extension/src/services/ClipboardRouter.ts b/packages/rangelink-vscode-extension/src/services/ClipboardRouter.ts
index 25ca51c5a..6b7ceb6f0 100644
--- a/packages/rangelink-vscode-extension/src/services/ClipboardRouter.ts
+++ b/packages/rangelink-vscode-extension/src/services/ClipboardRouter.ts
@@ -38,12 +38,12 @@ export class ClipboardRouter {
       options.control.destinationBehavior !== DestinationBehavior.ClipboardOnly &&
       this.destinationManager.isBound();
     if (shouldPreserve) {
-      let pasteSucceeded = false;
+      let sendSucceeded = false;
       await this.clipboardPreserver.preserve(
         async () => {
-          pasteSucceeded = await this.executeCopyAndSend(options);
+          sendSucceeded = await this.executeCopyAndSend(options);
         },
-        () => this.destinationManager.isClipboardRestorationApplicable(pasteSucceeded),
+        () => this.destinationManager.isClipboardRestorationApplicable(sendSucceeded),
       );
     } else {
       await this.executeCopyAndSend(options);
diff --git a/packages/rangelink-vscode-extension/src/types/BindOptions.ts b/packages/rangelink-vscode-extension/src/types/BindOptions.ts
index 0ec7747a7..a99700e8b 100644
--- a/packages/rangelink-vscode-extension/src/types/BindOptions.ts
+++ b/packages/rangelink-vscode-extension/src/types/BindOptions.ts
@@ -48,6 +48,14 @@ export interface ClaudeCodeBindOptions extends WithDestinationKind {
   readonly kind: Extract<DestinationKind, 'claude-code'>;
 }
 
+/**
+ * Bind to Gemini Code Assist chat panel.
+ * Future: may include panel reference for specific instance targeting.
+ */
+export interface GeminiCodeAssistBindOptions extends WithDestinationKind {
+  readonly kind: Extract<DestinationKind, 'gemini-code-assist'>;
+}
+
 /**
  * Bind to a user-defined custom AI assistant.
  */
@@ -73,4 +81,5 @@ export type BindOptions =
   | CursorAIBindOptions
   | CopilotChatBindOptions
   | ClaudeCodeBindOptions
+  | GeminiCodeAssistBindOptions
   | CustomAiAssistantBindOptions;
diff --git a/packages/rangelink-vscode-extension/src/types/DestinationKind.ts b/packages/rangelink-vscode-extension/src/types/DestinationKind.ts
index d839e80c6..735eadf0b 100644
--- a/packages/rangelink-vscode-extension/src/types/DestinationKind.ts
+++ b/packages/rangelink-vscode-extension/src/types/DestinationKind.ts
@@ -7,6 +7,7 @@
 export const DESTINATION_KINDS = [
   'claude-code',
   'cursor-ai',
+  'gemini-code-assist',
   'github-copilot-chat',
   'terminal',
   'text-editor',
@@ -43,6 +44,7 @@ export const isCustomAiAssistantKind = (kind: string): kind is CustomAiAssistant
 export const AI_ASSISTANT_KINDS = [
   'claude-code',
   'cursor-ai',
+  'gemini-code-assist',
   'github-copilot-chat',
 ] as const satisfies readonly BuiltInDestinationKind[];
 
diff --git a/packages/rangelink-vscode-extension/src/types/MessageCode.ts b/packages/rangelink-vscode-extension/src/types/MessageCode.ts
index e23bcbd0c..01852136c 100644
--- a/packages/rangelink-vscode-extension/src/types/MessageCode.ts
+++ b/packages/rangelink-vscode-extension/src/types/MessageCode.ts
@@ -42,6 +42,7 @@ export enum MessageCode {
   // Destination display formats (user-facing, used in picker menus)
   DESTINATION_DISPLAY_NAME_CLAUDE_CODE = 'DESTINATION_DISPLAY_NAME_CLAUDE_CODE',
   DESTINATION_DISPLAY_NAME_CURSOR_AI = 'DESTINATION_DISPLAY_NAME_CURSOR_AI',
+  DESTINATION_DISPLAY_NAME_GEMINI_CODE_ASSIST = 'DESTINATION_DISPLAY_NAME_GEMINI_CODE_ASSIST',
   DESTINATION_DISPLAY_NAME_GITHUB_COPILOT_CHAT = 'DESTINATION_DISPLAY_NAME_GITHUB_COPILOT_CHAT',
   DESTINATION_DISPLAY_NAME_TERMINAL = 'DESTINATION_DISPLAY_NAME_TERMINAL',
   DESTINATION_DISPLAY_NAME_TEXT_EDITOR = 'DESTINATION_DISPLAY_NAME_TEXT_EDITOR',
@@ -65,6 +66,7 @@ export enum MessageCode {
   ERROR_CURSOR_AI_NOT_AVAILABLE = 'ERROR_CURSOR_AI_NOT_AVAILABLE',
   ERROR_CUSTOM_AI_NOT_AVAILABLE = 'ERROR_CUSTOM_AI_NOT_AVAILABLE',
   ERROR_FILE_PATH_NAVIGATION_FAILED = 'ERROR_FILE_PATH_NAVIGATION_FAILED',
+  ERROR_GEMINI_CODE_ASSIST_NOT_AVAILABLE = 'ERROR_GEMINI_CODE_ASSIST_NOT_AVAILABLE',
   ERROR_GITHUB_COPILOT_CHAT_NOT_AVAILABLE = 'ERROR_GITHUB_COPILOT_CHAT_NOT_AVAILABLE',
   ERROR_INVALID_DELIMITER_CONFIG = 'ERROR_INVALID_DELIMITER_CONFIG',
   ERROR_LINK_GENERATION_FAILED = 'ERROR_LINK_GENERATION_FAILED',
@@ -106,6 +108,8 @@ export enum MessageCode {
   INFO_CUSTOM_AI_USER_INSTRUCTIONS = 'INFO_CUSTOM_AI_USER_INSTRUCTIONS',
   INFO_CURSOR_AI_NOT_AVAILABLE = 'INFO_CURSOR_AI_NOT_AVAILABLE',
   INFO_CURSOR_AI_USER_INSTRUCTIONS = 'INFO_CURSOR_AI_USER_INSTRUCTIONS',
+  INFO_GEMINI_CODE_ASSIST_NOT_AVAILABLE = 'INFO_GEMINI_CODE_ASSIST_NOT_AVAILABLE',
+  INFO_GEMINI_CODE_ASSIST_USER_INSTRUCTIONS = 'INFO_GEMINI_CODE_ASSIST_USER_INSTRUCTIONS',
   INFO_GITHUB_COPILOT_CHAT_NOT_AVAILABLE = 'INFO_GITHUB_COPILOT_CHAT_NOT_AVAILABLE',
   INFO_GITHUB_COPILOT_CHAT_USER_INSTRUCTIONS = 'INFO_GITHUB_COPILOT_CHAT_USER_INSTRUCTIONS',
   INFO_JUMP_FOCUS_FAILED = 'INFO_JUMP_FOCUS_FAILED',
@@ -146,6 +150,7 @@ export enum MessageCode {
   STATUS_BAR_JUMP_SUCCESS_CURSOR_AI = 'STATUS_BAR_JUMP_SUCCESS_CURSOR_AI',
   STATUS_BAR_JUMP_SUCCESS_CUSTOM_AI = 'STATUS_BAR_JUMP_SUCCESS_CUSTOM_AI',
   STATUS_BAR_JUMP_SUCCESS_EDITOR = 'STATUS_BAR_JUMP_SUCCESS_EDITOR',
+  STATUS_BAR_JUMP_SUCCESS_GEMINI_CODE_ASSIST = 'STATUS_BAR_JUMP_SUCCESS_GEMINI_CODE_ASSIST',
   STATUS_BAR_JUMP_SUCCESS_GITHUB_COPILOT_CHAT = 'STATUS_BAR_JUMP_SUCCESS_GITHUB_COPILOT_CHAT',
   STATUS_BAR_JUMP_SUCCESS_TERMINAL = 'STATUS_BAR_JUMP_SUCCESS_TERMINAL',
   STATUS_BAR_LINK_COPIED_TO_CLIPBOARD = 'STATUS_BAR_LINK_COPIED_TO_CLIPBOARD',
diff --git a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isClaudeCodeAvailable.test.ts b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isClaudeCodeAvailable.test.ts
index f0fbfa1b1..1fc1c1a97 100644
--- a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isClaudeCodeAvailable.test.ts
+++ b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isClaudeCodeAvailable.test.ts
@@ -1,17 +1,12 @@
-/**
- * Tests for isClaudeCodeAvailable utility.
- */
-
 import { createMockLogger } from 'barebone-logger-testing';
 
 import {
   createMockVscodeAdapter,
   type VscodeAdapterWithTestHooks,
 } from '../../../__tests__/helpers';
-import {
-  isClaudeCodeAvailable,
-  CLAUDE_CODE_EXTENSION_ID,
-} from '../../aiAssistants/isClaudeCodeAvailable';
+import { CLAUDE_CODE_FOCUS_COMMANDS } from '../../../destinations/aiAssistantFocusCommands';
+import { EXTENSION_ID_CLAUDE_CODE } from '../../aiAssistants/builtInAiAssistants';
+import { isClaudeCodeAvailable } from '../../aiAssistants/isClaudeCodeAvailable';
 
 describe('isClaudeCodeAvailable', () => {
   let mockAdapter: VscodeAdapterWithTestHooks;
@@ -24,7 +19,7 @@ describe('isClaudeCodeAvailable', () => {
   describe('extension detection', () => {
     it('should return true when Claude Code extension is installed and active', () => {
       mockAdapter = createMockVscodeAdapter({
-        extensionsOptions: [{ id: CLAUDE_CODE_EXTENSION_ID, isActive: true }],
+        extensionsOptions: [{ id: EXTENSION_ID_CLAUDE_CODE, isActive: true }],
       });
 
       const result = isClaudeCodeAvailable(mockAdapter, mockLogger);
@@ -33,7 +28,7 @@ describe('isClaudeCodeAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isClaudeCodeAvailable',
-          extensionId: CLAUDE_CODE_EXTENSION_ID,
+          extensionId: 'anthropic.claude-code',
           extensionFound: true,
           extensionActive: true,
           isAvailable: true,
@@ -44,7 +39,7 @@ describe('isClaudeCodeAvailable', () => {
 
     it('should return false when Claude Code extension is installed but inactive', () => {
       mockAdapter = createMockVscodeAdapter({
-        extensionsOptions: [{ id: CLAUDE_CODE_EXTENSION_ID, isActive: false }],
+        extensionsOptions: [{ id: EXTENSION_ID_CLAUDE_CODE, isActive: false }],
       });
 
       const result = isClaudeCodeAvailable(mockAdapter, mockLogger);
@@ -53,7 +48,7 @@ describe('isClaudeCodeAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isClaudeCodeAvailable',
-          extensionId: CLAUDE_CODE_EXTENSION_ID,
+          extensionId: 'anthropic.claude-code',
           extensionFound: true,
           extensionActive: false,
           isAvailable: false,
@@ -73,7 +68,7 @@ describe('isClaudeCodeAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isClaudeCodeAvailable',
-          extensionId: CLAUDE_CODE_EXTENSION_ID,
+          extensionId: 'anthropic.claude-code',
           extensionFound: false,
           extensionActive: false,
           isAvailable: false,
@@ -98,7 +93,7 @@ describe('isClaudeCodeAvailable', () => {
       mockAdapter = createMockVscodeAdapter({
         extensionsOptions: [
           { id: 'ms-vscode.csharp', isActive: true },
-          { id: CLAUDE_CODE_EXTENSION_ID, isActive: true },
+          { id: EXTENSION_ID_CLAUDE_CODE, isActive: true },
           { id: 'GitHub.copilot', isActive: true },
         ],
       });
@@ -110,10 +105,7 @@ describe('isClaudeCodeAvailable', () => {
 
     it('should use exact extension ID match', () => {
       mockAdapter = createMockVscodeAdapter({
-        extensionsOptions: [
-          // Similar but not exact match
-          { id: 'anthropic.claude-code-beta', isActive: true },
-        ],
+        extensionsOptions: [{ id: 'anthropic.claude-code-beta', isActive: true }],
       });
 
       const result = isClaudeCodeAvailable(mockAdapter, mockLogger);
@@ -122,3 +114,13 @@ describe('isClaudeCodeAvailable', () => {
     });
   });
 });
+
+describe('CLAUDE_CODE_FOCUS_COMMANDS', () => {
+  it('should export focus commands array with primary and fallback commands', () => {
+    expect(CLAUDE_CODE_FOCUS_COMMANDS).toStrictEqual([
+      'claude-vscode.focus',
+      'claude-vscode.sidebar.open',
+      'claude-vscode.editor.open',
+    ]);
+  });
+});
diff --git a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isCursorIDEDetected.test.ts b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isCursorIDEDetected.test.ts
index c016c1acd..7224a4148 100644
--- a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isCursorIDEDetected.test.ts
+++ b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isCursorIDEDetected.test.ts
@@ -8,6 +8,7 @@ import {
   createMockVscodeAdapter,
   type VscodeAdapterWithTestHooks,
 } from '../../../__tests__/helpers';
+import { CURSOR_AI_FOCUS_COMMANDS } from '../../../destinations/aiAssistantFocusCommands';
 import { isCursorIDEDetected } from '../../aiAssistants/isCursorIDEDetected';
 
 describe('isCursorIDEDetected', () => {
@@ -236,3 +237,12 @@ describe('isCursorIDEDetected', () => {
     });
   });
 });
+
+describe('CURSOR_AI_FOCUS_COMMANDS', () => {
+  it('should export focus commands array with primary and fallback commands', () => {
+    expect(CURSOR_AI_FOCUS_COMMANDS).toStrictEqual([
+      'aichat.newchataction',
+      'workbench.action.toggleAuxiliaryBar',
+    ]);
+  });
+});
diff --git a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGeminiCodeAssistAvailable.test.ts b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGeminiCodeAssistAvailable.test.ts
new file mode 100644
index 000000000..7e95be90b
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGeminiCodeAssistAvailable.test.ts
@@ -0,0 +1,146 @@
+import { createMockLogger } from 'barebone-logger-testing';
+
+import {
+  createMockVscodeAdapter,
+  type VscodeAdapterWithTestHooks,
+} from '../../../__tests__/helpers';
+import { GEMINI_CODE_ASSIST_FOCUS_COMMANDS } from '../../../destinations/aiAssistantFocusCommands';
+import { EXTENSION_ID_GEMINI_CODE_ASSIST } from '../../aiAssistants/builtInAiAssistants';
+import { isGeminiCodeAssistAvailable } from '../../aiAssistants/isGeminiCodeAssistAvailable';
+
+describe('isGeminiCodeAssistAvailable', () => {
+  let mockAdapter: VscodeAdapterWithTestHooks;
+  let mockLogger: ReturnType<typeof createMockLogger>;
+
+  beforeEach(() => {
+    mockLogger = createMockLogger();
+  });
+
+  describe('extension detection', () => {
+    it('should return true when extension is installed and active', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [{ id: EXTENSION_ID_GEMINI_CODE_ASSIST, isActive: true }],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(true);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: true,
+          extensionActive: true,
+        },
+        'Gemini Code Assist detected and active',
+      );
+    });
+
+    it('should return false when extension is installed but inactive', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [{ id: EXTENSION_ID_GEMINI_CODE_ASSIST, isActive: false }],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(false);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: true,
+          extensionActive: false,
+        },
+        'Gemini Code Assist not available (not installed or not active)',
+      );
+    });
+
+    it('should return false when extension is not installed', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(false);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: false,
+          extensionActive: false,
+        },
+        'Gemini Code Assist not available (not installed or not active)',
+      );
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not match other Google extensions', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [{ id: 'GoogleCloudTools.cloudcode', isActive: true }],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(false);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: false,
+          extensionActive: false,
+        },
+        'Gemini Code Assist not available (not installed or not active)',
+      );
+    });
+
+    it('should handle mixed extensions list', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [
+          { id: 'other.extension', isActive: true },
+          { id: EXTENSION_ID_GEMINI_CODE_ASSIST, isActive: true },
+          { id: 'another.extension', isActive: false },
+        ],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(true);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: true,
+          extensionActive: true,
+        },
+        'Gemini Code Assist detected and active',
+      );
+    });
+
+    it('should use exact extension ID match', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        extensionsOptions: [{ id: 'google.geminicodeassist-preview', isActive: true }],
+      });
+
+      const result = await isGeminiCodeAssistAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(false);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGeminiCodeAssistAvailable',
+          extensionId: 'google.geminicodeassist',
+          extensionFound: false,
+          extensionActive: false,
+        },
+        'Gemini Code Assist not available (not installed or not active)',
+      );
+    });
+  });
+});
+
+describe('GEMINI_CODE_ASSIST_FOCUS_COMMANDS', () => {
+  it('should export focus commands array', () => {
+    expect(GEMINI_CODE_ASSIST_FOCUS_COMMANDS).toStrictEqual(['cloudcode.gemini.chatView.focus']);
+  });
+});
diff --git a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGitHubCopilotChatAvailable.test.ts b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGitHubCopilotChatAvailable.test.ts
index 8a6325d6b..be0f2c245 100644
--- a/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGitHubCopilotChatAvailable.test.ts
+++ b/packages/rangelink-vscode-extension/src/utils/__tests__/aiAssistants/isGitHubCopilotChatAvailable.test.ts
@@ -1,7 +1,3 @@
-/**
- * Tests for isGitHubCopilotChatAvailable utility.
- */
-
 import { createMockLogger } from 'barebone-logger-testing';
 
 import {
@@ -9,10 +5,10 @@ import {
   type VscodeAdapterWithTestHooks,
 } from '../../../__tests__/helpers';
 import { GITHUB_COPILOT_CHAT_FOCUS_COMMANDS } from '../../../destinations/aiAssistantFocusCommands';
+import { EXTENSION_ID_GITHUB_COPILOT_CHAT } from '../../aiAssistants/builtInAiAssistants';
 import {
   isGitHubCopilotChatAvailable,
   GITHUB_COPILOT_CHAT_COMMAND,
-  GITHUB_COPILOT_CHAT_EXTENSION_ID,
 } from '../../aiAssistants/isGitHubCopilotChatAvailable';
 
 describe('isGitHubCopilotChatAvailable', () => {
@@ -35,7 +31,7 @@ describe('isGitHubCopilotChatAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isGitHubCopilotChatAvailable',
-          chatCommand: GITHUB_COPILOT_CHAT_COMMAND,
+          chatCommand: 'workbench.action.chat.open',
           detectionMethod: 'command',
         },
         'GitHub Copilot Chat detected via command availability',
@@ -57,25 +53,32 @@ describe('isGitHubCopilotChatAvailable', () => {
 
       expect(result).toBe(true);
       expect(mockLogger.debug).toHaveBeenCalledWith(
-        expect.objectContaining({ detectionMethod: 'command' }),
-        expect.any(String),
+        {
+          fn: 'isGitHubCopilotChatAvailable',
+          chatCommand: 'workbench.action.chat.open',
+          detectionMethod: 'command',
+        },
+        'GitHub Copilot Chat detected via command availability',
       );
     });
 
     it('should not check extension when command detection succeeds', async () => {
       mockAdapter = createMockVscodeAdapter({
         commandsOptions: { availableCommands: [GITHUB_COPILOT_CHAT_COMMAND] },
-        extensionsOptions: [{ id: GITHUB_COPILOT_CHAT_EXTENSION_ID, isActive: true }],
+        extensionsOptions: [{ id: EXTENSION_ID_GITHUB_COPILOT_CHAT, isActive: true }],
       });
 
       const result = await isGitHubCopilotChatAvailable(mockAdapter, mockLogger);
 
       expect(result).toBe(true);
-      // Should only log once for command detection
       expect(mockLogger.debug).toHaveBeenCalledTimes(1);
       expect(mockLogger.debug).toHaveBeenCalledWith(
-        expect.objectContaining({ detectionMethod: 'command' }),
-        expect.any(String),
+        {
+          fn: 'isGitHubCopilotChatAvailable',
+          chatCommand: 'workbench.action.chat.open',
+          detectionMethod: 'command',
+        },
+        'GitHub Copilot Chat detected via command availability',
       );
     });
   });
@@ -84,7 +87,7 @@ describe('isGitHubCopilotChatAvailable', () => {
     it('should return true when extension is installed and active', async () => {
       mockAdapter = createMockVscodeAdapter({
         commandsOptions: { availableCommands: [] },
-        extensionsOptions: [{ id: GITHUB_COPILOT_CHAT_EXTENSION_ID, isActive: true }],
+        extensionsOptions: [{ id: EXTENSION_ID_GITHUB_COPILOT_CHAT, isActive: true }],
       });
 
       const result = await isGitHubCopilotChatAvailable(mockAdapter, mockLogger);
@@ -93,7 +96,7 @@ describe('isGitHubCopilotChatAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isGitHubCopilotChatAvailable',
-          extensionId: GITHUB_COPILOT_CHAT_EXTENSION_ID,
+          extensionId: 'github.copilot-chat',
           extensionFound: true,
           extensionActive: true,
           detectionMethod: 'extension',
@@ -105,7 +108,7 @@ describe('isGitHubCopilotChatAvailable', () => {
     it('should return false when extension is installed but inactive', async () => {
       mockAdapter = createMockVscodeAdapter({
         commandsOptions: { availableCommands: [] },
-        extensionsOptions: [{ id: GITHUB_COPILOT_CHAT_EXTENSION_ID, isActive: false }],
+        extensionsOptions: [{ id: EXTENSION_ID_GITHUB_COPILOT_CHAT, isActive: false }],
       });
 
       const result = await isGitHubCopilotChatAvailable(mockAdapter, mockLogger);
@@ -114,7 +117,7 @@ describe('isGitHubCopilotChatAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isGitHubCopilotChatAvailable',
-          extensionId: GITHUB_COPILOT_CHAT_EXTENSION_ID,
+          extensionId: 'github.copilot-chat',
           extensionFound: true,
           extensionActive: false,
           detectionMethod: 'none',
@@ -135,7 +138,7 @@ describe('isGitHubCopilotChatAvailable', () => {
       expect(mockLogger.debug).toHaveBeenCalledWith(
         {
           fn: 'isGitHubCopilotChatAvailable',
-          extensionId: GITHUB_COPILOT_CHAT_EXTENSION_ID,
+          extensionId: 'github.copilot-chat',
           extensionFound: false,
           extensionActive: false,
           detectionMethod: 'none',
@@ -157,8 +160,27 @@ describe('isGitHubCopilotChatAvailable', () => {
       expect(result).toBe(false);
     });
 
+    it('should match fallback focus command when primary is not registered', async () => {
+      mockAdapter = createMockVscodeAdapter({
+        commandsOptions: {
+          availableCommands: ['workbench.panel.chat.view.copilot.focus'],
+        },
+      });
+
+      const result = await isGitHubCopilotChatAvailable(mockAdapter, mockLogger);
+
+      expect(result).toBe(true);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGitHubCopilotChatAvailable',
+          chatCommand: 'workbench.panel.chat.view.copilot.focus',
+          detectionMethod: 'command',
+        },
+        'GitHub Copilot Chat detected via command availability',
+      );
+    });
+
     it('should handle other Copilot extensions without chat', async () => {
-      // Only the base Copilot extension (not chat)
       mockAdapter = createMockVscodeAdapter({
         commandsOptions: { availableCommands: [] },
         extensionsOptions: [{ id: 'GitHub.copilot', isActive: true }],
@@ -174,7 +196,7 @@ describe('isGitHubCopilotChatAvailable', () => {
         commandsOptions: { availableCommands: [] },
         extensionsOptions: [
           { id: 'other.extension', isActive: true },
-          { id: GITHUB_COPILOT_CHAT_EXTENSION_ID, isActive: true },
+          { id: EXTENSION_ID_GITHUB_COPILOT_CHAT, isActive: true },
           { id: 'another.extension', isActive: false },
         ],
       });
@@ -182,6 +204,16 @@ describe('isGitHubCopilotChatAvailable', () => {
       const result = await isGitHubCopilotChatAvailable(mockAdapter, mockLogger);
 
       expect(result).toBe(true);
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        {
+          fn: 'isGitHubCopilotChatAvailable',
+          extensionId: 'github.copilot-chat',
+          extensionFound: true,
+          extensionActive: true,
+          detectionMethod: 'extension',
+        },
+        'GitHub Copilot Chat detected via extension',
+      );
     });
   });
 });
@@ -193,8 +225,4 @@ describe('GITHUB_COPILOT_CHAT_FOCUS_COMMANDS', () => {
       'workbench.panel.chat.view.copilot.focus',
     ]);
   });
-
-  it('should have the chat.open command as the primary (first) command', () => {
-    expect(GITHUB_COPILOT_CHAT_FOCUS_COMMANDS[0]).toBe('workbench.action.chat.open');
-  });
 });
diff --git a/packages/rangelink-vscode-extension/src/utils/aiAssistants/builtInAiAssistants.ts b/packages/rangelink-vscode-extension/src/utils/aiAssistants/builtInAiAssistants.ts
new file mode 100644
index 000000000..5bf38aa83
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/utils/aiAssistants/builtInAiAssistants.ts
@@ -0,0 +1,3 @@
+export const EXTENSION_ID_CLAUDE_CODE = 'anthropic.claude-code';
+export const EXTENSION_ID_GEMINI_CODE_ASSIST = 'google.geminicodeassist';
+export const EXTENSION_ID_GITHUB_COPILOT_CHAT = 'github.copilot-chat';
diff --git a/packages/rangelink-vscode-extension/src/utils/aiAssistants/index.ts b/packages/rangelink-vscode-extension/src/utils/aiAssistants/index.ts
index b00e07509..9d6caf37a 100644
--- a/packages/rangelink-vscode-extension/src/utils/aiAssistants/index.ts
+++ b/packages/rangelink-vscode-extension/src/utils/aiAssistants/index.ts
@@ -8,6 +8,8 @@
  * - Claude Code (Anthropic extension)
  */
 
+export * from './builtInAiAssistants';
 export * from './isClaudeCodeAvailable';
 export * from './isCursorIDEDetected';
+export * from './isGeminiCodeAssistAvailable';
 export * from './isGitHubCopilotChatAvailable';
diff --git a/packages/rangelink-vscode-extension/src/utils/aiAssistants/isClaudeCodeAvailable.ts b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isClaudeCodeAvailable.ts
index 5efa7b201..8f154c07d 100644
--- a/packages/rangelink-vscode-extension/src/utils/aiAssistants/isClaudeCodeAvailable.ts
+++ b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isClaudeCodeAvailable.ts
@@ -2,16 +2,16 @@ import type { Logger } from 'barebone-logger';
 
 import type { VscodeAdapter } from '../../ide/vscode/VscodeAdapter';
 
-export const CLAUDE_CODE_EXTENSION_ID = 'anthropic.claude-code';
+import { EXTENSION_ID_CLAUDE_CODE } from './builtInAiAssistants';
 
 export const isClaudeCodeAvailable = (ideAdapter: VscodeAdapter, logger: Logger): boolean => {
-  const extension = ideAdapter.getExtension(CLAUDE_CODE_EXTENSION_ID);
+  const extension = ideAdapter.getExtension(EXTENSION_ID_CLAUDE_CODE);
   const isAvailable = extension !== undefined && extension.isActive;
 
   logger.debug(
     {
       fn: 'isClaudeCodeAvailable',
-      extensionId: CLAUDE_CODE_EXTENSION_ID,
+      extensionId: EXTENSION_ID_CLAUDE_CODE,
       extensionFound: extension !== undefined,
       extensionActive: extension?.isActive ?? false,
       isAvailable,
diff --git a/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGeminiCodeAssistAvailable.ts b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGeminiCodeAssistAvailable.ts
new file mode 100644
index 000000000..6f878d402
--- /dev/null
+++ b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGeminiCodeAssistAvailable.ts
@@ -0,0 +1,27 @@
+import type { Logger } from 'barebone-logger';
+
+import type { VscodeAdapter } from '../../ide/vscode/VscodeAdapter';
+
+import { EXTENSION_ID_GEMINI_CODE_ASSIST } from './builtInAiAssistants';
+
+export const isGeminiCodeAssistAvailable = async (
+  ideAdapter: VscodeAdapter,
+  logger: Logger,
+): Promise<boolean> => {
+  const extension = ideAdapter.getExtension(EXTENSION_ID_GEMINI_CODE_ASSIST);
+  const isAvailable = extension !== undefined && extension.isActive;
+
+  logger.debug(
+    {
+      fn: 'isGeminiCodeAssistAvailable',
+      extensionId: EXTENSION_ID_GEMINI_CODE_ASSIST,
+      extensionFound: extension !== undefined,
+      extensionActive: extension?.isActive ?? false,
+    },
+    isAvailable
+      ? 'Gemini Code Assist detected and active'
+      : 'Gemini Code Assist not available (not installed or not active)',
+  );
+
+  return isAvailable;
+};
diff --git a/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGitHubCopilotChatAvailable.ts b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGitHubCopilotChatAvailable.ts
index a1db3e442..ce00dd081 100644
--- a/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGitHubCopilotChatAvailable.ts
+++ b/packages/rangelink-vscode-extension/src/utils/aiAssistants/isGitHubCopilotChatAvailable.ts
@@ -1,24 +1,27 @@
 import type { Logger } from 'barebone-logger';
-import type { Extension } from 'vscode';
 
+import { GITHUB_COPILOT_CHAT_FOCUS_COMMANDS } from '../../destinations/aiAssistantFocusCommands';
 import type { VscodeAdapter } from '../../ide/vscode/VscodeAdapter';
 
-export const GITHUB_COPILOT_CHAT_COMMAND = 'workbench.action.chat.open';
+import { EXTENSION_ID_GITHUB_COPILOT_CHAT } from './builtInAiAssistants';
 
-export const GITHUB_COPILOT_CHAT_EXTENSION_ID = 'GitHub.copilot-chat';
+export const GITHUB_COPILOT_CHAT_COMMAND = 'workbench.action.chat.open';
 
 export const isGitHubCopilotChatAvailable = async (
   ideAdapter: VscodeAdapter,
   logger: Logger,
 ): Promise<boolean> => {
   const commands = await ideAdapter.getCommands();
-  const commandExists = commands.includes(GITHUB_COPILOT_CHAT_COMMAND);
+  const chatCommand = GITHUB_COPILOT_CHAT_FOCUS_COMMANDS.find((command) =>
+    commands.includes(command),
+  );
+  const commandExists = chatCommand !== undefined;
 
   if (commandExists) {
     logger.debug(
       {
         fn: 'isGitHubCopilotChatAvailable',
-        chatCommand: GITHUB_COPILOT_CHAT_COMMAND,
+        chatCommand,
         detectionMethod: 'command',
       },
       'GitHub Copilot Chat detected via command availability',
@@ -26,15 +29,13 @@ export const isGitHubCopilotChatAvailable = async (
     return true;
   }
 
-  const extension = ideAdapter.extensions.find(
-    (ext: Extension<unknown>) => ext.id === GITHUB_COPILOT_CHAT_EXTENSION_ID,
-  );
+  const extension = ideAdapter.getExtension(EXTENSION_ID_GITHUB_COPILOT_CHAT);
   const extensionAvailable = extension !== undefined && extension.isActive;
 
   logger.debug(
     {
       fn: 'isGitHubCopilotChatAvailable',
-      extensionId: GITHUB_COPILOT_CHAT_EXTENSION_ID,
+      extensionId: EXTENSION_ID_GITHUB_COPILOT_CHAT,
       extensionFound: extension !== undefined,
       extensionActive: extension?.isActive ?? false,
       detectionMethod: extensionAvailable ? 'extension' : 'none',
diff --git a/packages/rangelink-vscode-extension/src/wireSubscriptions.ts b/packages/rangelink-vscode-extension/src/wireSubscriptions.ts
index ab9e8e5a0..d64d8255e 100644
--- a/packages/rangelink-vscode-extension/src/wireSubscriptions.ts
+++ b/packages/rangelink-vscode-extension/src/wireSubscriptions.ts
@@ -5,6 +5,7 @@ import {
   CMD_BIND_TO_CLAUDE_CODE,
   CMD_BIND_TO_CURSOR_AI,
   CMD_BIND_TO_DESTINATION,
+  CMD_BIND_TO_GEMINI_CODE_ASSIST,
   CMD_BIND_TO_GITHUB_COPILOT_CHAT,
   CMD_BIND_TO_TERMINAL,
   CMD_BIND_TO_TERMINAL_HERE,
@@ -55,7 +56,12 @@ import {
 } from './constants';
 import type { WiringServices } from './createWiringServices';
 import type { SubscriptionRegistrar } from './SubscriptionRegistrar';
-import { type FilePathClickArgs, PathFormat, type RangeLinkClickArgs } from './types';
+import {
+  type AIAssistantDestinationKind,
+  type FilePathClickArgs,
+  PathFormat,
+  type RangeLinkClickArgs,
+} from './types';
 
 /**
  * Wire all commands and providers into subscriptions.
@@ -152,8 +158,9 @@ export const wireSubscriptions = (
   for (const [cmd, kind] of [
     [CMD_BIND_TO_CURSOR_AI, 'cursor-ai'],
     [CMD_BIND_TO_CLAUDE_CODE, 'claude-code'],
+    [CMD_BIND_TO_GEMINI_CODE_ASSIST, 'gemini-code-assist'],
     [CMD_BIND_TO_GITHUB_COPILOT_CHAT, 'github-copilot-chat'],
-  ] as const) {
+  ] satisfies [string, AIAssistantDestinationKind][]) {
     registrar.registerCommand(
       cmd,
       createBindAIAssistantCommand(
diff --git a/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/extension.js b/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/extension.js
index 5198423cd..4134dd2cd 100644
--- a/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/extension.js
+++ b/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/extension.js
@@ -41,6 +41,14 @@ function activate(context) {
     }),
   );
 
+  context.subscriptions.push(
+    vscode.commands.registerCommand('dummyAi.focusFail', async () => {
+      throw new Error(
+        'dummyAi.focusFail: intentional failure for TC-010 clipboard-preservation test',
+      );
+    }),
+  );
+
   context.subscriptions.push(
     vscode.commands.registerCommand('dummyAi.focusPanel', async () => {
       if (!provider?._view) {
diff --git a/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/package.json b/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/package.json
index 57ba3713b..7556b7cc6 100644
--- a/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/package.json
+++ b/packages/rangelink-vscode-extension/test-fixtures/dummy-ai-extension/package.json
@@ -19,6 +19,10 @@
         "command": "dummyAi.focusForPaste",
         "title": "Dummy AI: Focus for Paste"
       },
+      {
+        "command": "dummyAi.focusFail",
+        "title": "Dummy AI: Focus Fail (intentional failure)"
+      },
       {
         "command": "dummyAi.focusPanel",
         "title": "Dummy AI: Focus Panel"