v3.43.0 Release Notes (#8089)

- GLM-4.6
- kat-coder-pro
- Add parsing of env variable patterns to the mcpconfig.json

- TLS Proxy support issues for VSCode
- Add supportsReasoning flag to OpenAI reasoning models
- Fix thinking not available for some models in the OpenAI provider
- Fix invalid signature field issues when switching between Gemini and Anthropic providers
- Extract OpenRouter model filtering into reusable utility and use it in different model pickers
- Fix a11y for auto approve checkbox
- Improve ModelPickerModal provider list layout

- Migrate WhatsNewModal to new shared dialogue component

Co-authored-by: Arafatkatze <arafat.da.khan@gmail.com>

.changeset/eight-pants-explode.md

@@ -1,5 +0,0 @@
----
-claude-dev: minor
----
-
-This minor change adds new models and image support for rleated models, adds fetching of model info from API, updates tool handling, and adds retrieval usage stats for individual messages and a user's monthly token usage.

.changeset/every-stars-bow.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Fix highlighted text flashing when task header is collapsed.

.changeset/fix-proxy-standalone-check.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fixed TLS/proxy issues for users behind corporate MITM inspection proxies by correcting the IS_STANDALONE environment variable check. The check now uses explicit string comparison (`=== "true"`) instead of truthy evaluation, which was incorrectly triggering standalone mode in VSCode builds because the string `"false"` is truthy in JavaScript.

.changeset/floppy-ads-stay.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add X-Cerebras-3rd-Party-Integration header to Cerebras API requests.

.changeset/great-planets-train.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Added microwave family system prompt configuration

.changeset/hip-boxes-sin.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-removing tooltips from auto approve menu

.changeset/kind-paws-win.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-fix: Standalone, ensure cwd is the install dir to find resources reliably

.changeset/rotten-olives-build.md

@@ -1,5 +0,0 @@
----
-"cline-vscode": patch
----
-
-Add Explain Changes feature for reviewing code changes with AI-powered explanations

.changeset/shaggy-tips-cross.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Fixed a bug where terminal commands with double quotes are broken when "Terminal Execution Mode" is set to "Background Exec"

.changeset/sour-views-attend.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Slash commands can now be typed anywhere in a message, not just at the beginning. This matches the behavior of @ mentions for a more flexible input experience.

.changeset/tender-breads-own.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Adds bottom padding to the last message to fix last response text getting cut off by auto approve settings bar.

.changeset/warm-dogs-dance.md

@@ -1,5 +0,0 @@
----
-claude-dev: patch
----
-
-Add task history recovery documentation with storage paths, recovery command usage, and troubleshooting guide.

.claude/commands/hotfix-release.md

@@ -0,0 +1,194 @@
+# Hotfix Release
+
+Create a hotfix release by cherry-picking specific commits from main onto the latest release tag.
+
+## Overview
+
+This workflow helps you:
+1. Select specific commits from main to include in a hotfix
+2. Create a release notes commit on main (changelog + version bump)
+3. Cherry-pick everything onto the latest release tag
+4. Tag and push the new release
+
+## Step 1: Setup and Gather Information
+
+First, ensure we're on main and up to date:
+
+```bash
+git checkout main && git pull origin main
+```
+
+Get the latest release tag:
+
+```bash
+git tag --sort=-v:refname | head -1
+```
+
+## Step 2: Present Commits Since Last Release
+
+Show all commits on main since the last release tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git log ${LAST_TAG}..HEAD --oneline --format="%h %s (%an)"
+```
+
+Also get the commit messages already on the tag (to identify previously cherry-picked commits). Note: Run these as separate commands to avoid shell parsing issues with parentheses in author names:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+PREV_TAG=$(git tag --sort=-v:refname | head -2 | tail -1)
+```
+
+```bash
+git log $PREV_TAG..$LAST_TAG --oneline --format="%s"
+```
+
+**Present the list** to the user in a numbered format with commit hash, subject, and author. For any commits whose subject line already appears in the tag's history (previously cherry-picked in an earlier hotfix) or are "Release Notes" commits, add `(already in previous hotfix)` or `(release notes - skip)` after them so the user knows to skip those.
+
+Ask which commits to include in the hotfix.
+
+Use the ask_followup_question tool to let the user specify which commits they want (by number or hash).
+
+## Step 3: Analyze Selected Commits
+
+For each selected commit:
+1. Get the full commit message: `git show --no-patch --format="%B" <hash>`
+2. Get the diff to understand the change: `git show <hash> --stat`
+3. Find the associated PR if any: `gh pr list --search "<hash>" --state merged --json number,title --jq '.[0]'`
+
+Build a mental model of what these changes do for the changelog.
+
+## Step 4: Determine New Version Number
+
+Parse the current version from package.json and the last tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+echo "Last release: $LAST_TAG"
+cat package.json | grep '"version"'
+```
+
+Hotfixes always increment the patch version (e.g., 3.40.0 -> 3.40.1, or 3.40.1 -> 3.40.2).
+
+**Ask the user to confirm the new version number.**
+
+## Step 5: Create Release Notes Commit on Main
+
+On the main branch, create a commit that updates:
+
+1. **CHANGELOG.md** - Add a new section for the hotfix version at the top:
+   ```markdown
+   ## [3.40.1]
+
+   - Description of fix 1
+   - Description of fix 2
+   ```
+
+   Write clear, user-friendly descriptions based on your analysis of the commits.
+
+2. **package.json** - Update the version field to the new version
+
+3. **Delete changesets** for the commits being included in the hotfix. This prevents the changeset bot from including duplicate entries in the next regular release.
+
+   Find and delete the changeset files associated with the selected commits:
+   ```bash
+   ls .changeset/
+   ```
+
+   Each changeset file in `.changeset/` corresponds to a PR. Read them to identify which ones belong to the commits you're hotfixing, then delete those files.
+
+**Skip running `npm run install:all`** - the automation handles outdated lockfiles.
+
+Commit with message format: `v{VERSION} Release Notes (hotfix)`
+
+In the commit body, mention:
+- This is for a hotfix release
+- List the cherry-picked commits that will be included
+
+```bash
+git add CHANGELOG.md package.json .changeset/
+git commit -m "v3.40.1 Release Notes (hotfix)
+
+Hotfix release including:
+- <commit1-hash>: <description>
+- <commit2-hash>: <description>
+"
+```
+
+Push to main:
+
+```bash
+git push origin main
+```
+
+## Step 6: Build the Hotfix on the Tag
+
+Checkout the last release tag (detached HEAD):
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git checkout $LAST_TAG
+```
+
+Cherry-pick the selected commits in order:
+
+```bash
+git cherry-pick <commit1-hash>
+git cherry-pick <commit2-hash>
+# ... etc
+```
+
+Finally, cherry-pick the release notes commit you just pushed to main:
+
+```bash
+# Get the hash of the release notes commit (should be HEAD of main)
+RELEASE_NOTES_COMMIT=$(git rev-parse main)
+git cherry-pick $RELEASE_NOTES_COMMIT
+```
+
+## Step 7: Tag and Push
+
+After all cherry-picks are applied successfully:
+
+```bash
+# Tag the new release
+git tag v{VERSION}
+
+# Push the tag to remote
+git push origin v{VERSION}
+```
+
+## Step 8: Return to Main and Summary
+
+Return to main branch:
+
+```bash
+git checkout main
+```
+
+**Copy a Slack announcement message to clipboard** with the version and PR links for each included fix:
+
+```
+VS Code Hotfix v{VERSION} Published
+
+- Description of fix 1 https://github.com/cline/cline/pull/{PR_NUMBER}
+- Description of fix 2 https://github.com/cline/cline/pull/{PR_NUMBER}
+```
+
+Present a final summary:
+- New version: v{VERSION}
+- Tag pushed: yes
+- Commits included: (list them)
+- Slack message copied to clipboard: yes
+
+Remind the user to:
+1. Manually trigger the publish release GitHub Action at: https://github.com/cline/cline/actions/workflows/publish.yml (paste `v{VERSION}` as the tag)
+2. Post the Slack message to announce the hotfix
+
+## Important Notes
+
+- This workflow does NOT create a release branch - only tags
+- The release notes commit goes to main first, then gets cherry-picked to the tag
+- This keeps main's history accurate while allowing hotfix releases from tags
+- If cherry-pick conflicts occur, resolve them before continuing

.clinerules/workflows/hotfix-release.md

@@ -0,0 +1 @@
+../../.claude/commands/hotfix-release.md

.github/workflows/changeset-converter.yml

@@ -58,7 +58,7 @@ jobs:
                   cache: "npm"
 
             - name: Install Dependencies
-              run: npm install changeset
+              run: npm ci
 
             # Check if there are any new changesets to process
             - name: Check for changesets

.github/workflows/publish-nightly.yml

@@ -74,8 +74,8 @@ jobs:
                   CLINE_ENVIRONMENT: production
                   # OpenTelemetry production defaults (can be overridden at runtime)
                   OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: console,otlp
-                  OTEL_METRICS_EXPORTER: console,otlp
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
                   OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
                   OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
                   OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}

.github/workflows/publish.yml

@@ -99,8 +99,8 @@ jobs:
                   ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
                   # OpenTelemetry production defaults (can be overridden at runtime)
                   OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: console,otlp
-                  OTEL_METRICS_EXPORTER: console,otlp
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
                   OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
                   OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
                   OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}

.github/workflows/trigger-jetbrains-tests.yml

@@ -1,6 +1,6 @@
 name: Trigger Jetbrains Plugin <-> Cline Tests
 on:
-  pull_request:
+  pull_request_target:
     types: [opened, synchronize, reopened]
 permissions:
   contents: read
@@ -22,7 +22,24 @@ jobs:
           owner: cline
           repositories: intellij-plugin
 
+      - name: Sanitize untrusted inputs
+        id: sanitize
+        env:
+          RAW_BRANCH_NAME: ${{ github.head_ref }}
+          RAW_PR_TITLE: ${{ github.event.pull_request.title }}
+        run: |
+          # Sanitize branch name for JSON
+          BRANCH_NAME_JSON=$(jq -n --arg b "$RAW_BRANCH_NAME" '$b')
+          echo "branch_name=$BRANCH_NAME_JSON" >> $GITHUB_OUTPUT
+          
+          # Sanitize PR title for JSON
+          PR_TITLE_JSON=$(jq -n --arg t "$RAW_PR_TITLE" '$t')
+          echo "pr_title=$PR_TITLE_JSON" >> $GITHUB_OUTPUT
+
       - name: Trigger IntelliJ Plugin Integration Test
+        env:
+          BRANCH_NAME: ${{ steps.sanitize.outputs.branch_name }}
+          PR_TITLE: ${{ steps.sanitize.outputs.pr_title }}
         run: |
           curl -X POST \
             -H "Authorization: Bearer ${{ steps.app-token.outputs.token }}" \
@@ -35,10 +52,10 @@ jobs:
             "event_type": "cline-pr-check",
             "client_payload": {
               "pr_number": "${{ github.event.number }}",
-              "branch_name": "${{ github.head_ref }}",
+              "branch_name": $BRANCH_NAME,
               "action": "${{ github.event.action }}",
               "sha": "${{ github.event.pull_request.head.sha }}",
-              "pr_title": ${{ toJSON(github.event.pull_request.title) }},
+              "pr_title": $PR_TITLE,
               "pr_url": "${{ github.event.pull_request.html_url }}"
             }
           }
@@ -47,7 +64,6 @@ jobs:
       - name: Log trigger details
         run: |
           echo "Triggered IntelliJ Plugin integration test for:"
-          echo "  PR #${{ github.event.number }}: ${{ github.event.pull_request.title }}"
-          echo "  Branch: ${{ github.head_ref }}"
+          echo "  PR #${{ github.event.number }}"
           echo "  Action: ${{ github.event.action }}"
           echo "  SHA: ${{ github.event.pull_request.head.sha }}"

.vscodeignore

@@ -40,9 +40,6 @@ buf.yaml
 .changeset/
 .clinerules/
 
-# Include specific file needed for Background Exec mode
-!standalone/runtime-files/vscode/enhanced-terminal.js
-
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)
 webview-ui/src/**
 webview-ui/public/**

CHANGELOG.md

@@ -1,16 +1,98 @@
 # Changelog
 
+## [3.43.0]
+
+### Added
+
+- GLM-4.6
+- kat-coder-pro
+- Add parsing of env variable patterns to the mcpconfig.json
+
+### Fixed
+- TLS Proxy support issues for VSCode
+- Add supportsReasoning flag to OpenAI reasoning models
+- Fix thinking not available for some models in the OpenAI provider
+- Fix invalid signature field issues when switching between Gemini and Anthropic providers
+- Extract OpenRouter model filtering into reusable utility and use it in different model pickers
+- Fix a11y for auto approve checkbox
+- Improve ModelPickerModal provider list layout
+
+### Refactored
+- Migrate WhatsNewModal to new shared dialogue component
+
+## [3.42.0]
+
+### Added
+
+- Expose `getAvailableSlashCommands` rpc endpoint to UI clients
+- Made slash command menu and context menu accessible and screenreader-friendly
+- Made expanding/collapsing UI components accessible
+
+### Fixed
+
+- Devstral OpenRouter model ID and routing issues
+- Incorrect pricing display for Devstral model in the extension
+
+## [3.41.0]
+
+### Added
+
+- OpenAI GPT-5.2
+- Devstral-2512 (formerly stealth model "Microwave")
+- Improvements to chat modal model picker
+- Amazon Nova 2 Lite
+- DeepSeek 3.2 to native tool calling allow list
+- Responses API support for Codex models in OpenAI provider (requires native tool calling)
+- Xmas Special Santa Cline
+- Welcome screen UI enhancements
+
+### Fixed
+
+- Initial checkpoint commit now non-blocking for improved responsiveness in large repositories
+- Gemini Vertex models erroring when thinking parameters are not supported
+- Restrictive file permissions for secrets.json
+- Ollama streaming requests not aborting when task is cancelled
+
+### Refactored
+
+- OpenAI provider to centralize temperature configuration and include missing GPT-5 model settings
+- OpenAI native handler to use metadata for model capabilities
+- Vertex provider to use metadata for model capabilities
+
+## [3.40.2]
+
+- Fix logout on network errors during token refresh (e.g., opening laptop while offline)
+
+## [3.40.1]
+
+- Fix cost calculation display for Anthropic API requests
+
+## [3.40.0]
+
+- Fix highlighted text flashing when task header is collapsed
+- Add X-Cerebras-3rd-Party-Integration header to Cerebras API requests
+- Add microwave family system prompt configuration
+- Remove tooltips from auto approve menu
+- Fix Standalone, ensure cwd is the install dir to find resources reliably
+- Fix a bug where terminal commands with double quotes are broken when "Terminal Execution Mode" is set to "Background Exec"
+- Add support for slash commands anywhere in a message, not just at the beginning. This matches the behavior of @ mentions for a more flexible input experience.
+- Add bottom padding to the last message to fix last response text getting cut off by auto approve settings bar.
+- Add default thinking level for Gemini 3 Pro models in Gemini provider
+
 ## [3.39.2]
+
 - Fix for microwave model and thinking settings
 
 ## [3.39.1]
+
 - Fix Openrouter and Cline Provider model info
 
 ## [3.39.0]
+
 - Add Explain Changes feature
 - Add microwave Stealth model
-- Add Tabbed Model Picker with Recommended and Free tabs 
-- Add support to View remote rules and workflows in the editor 
+- Add Tabbed Model Picker with Recommended and Free tabs
+- Add support to View remote rules and workflows in the editor
 - Enable NTC (Native Tool Calling) by default
 - Bug fixes and improvements for LiteLLM provider
 
@@ -34,19 +116,21 @@
 ## [3.38.1]
 
 ### Fixed
+
 - Fixed handling of 'signature' field in sanitizeAnthropicContentBlock to properly preserve it when thinking is enabled, as required by Anthropic's API.
 
 ## [3.38.0]
 
 ### Added
+
 - Gemini 3 Pro Preview model
 - AquaVoice Avalon model for voice-to-text dictation
 
 ### Fixed
+
 - Automatic context truncation when AWS Bedrock token usage rate limits are exceeded
 - Removed new_task tool from system prompts, updated slash command prompts, and added helper function for native tool calling validation
 
-
 ## [3.37.1]
 
 - Comprehensive changes to better support GPT 5.1 - System prompt, tools, deep-planning, focus chain, etc.

cli/README.md

@@ -70,3 +70,4 @@ Apache-2.0 - see [LICENSE](https://github.com/cline/cline/blob/main/LICENSE) for
 -   Report issues: [GitHub Issues](https://github.com/cline/cline/issues)
 -   Community: [GitHub Discussions](https://github.com/cline/cline/discussions)
 -   Documentation: [docs.cline.bot](https://docs.cline.bot)
+-   Cline CLI Architecture: [architecture.md](./architecture.md)

cli/architecture.md

@@ -0,0 +1,292 @@
+# Cline CLI Architecture
+
+The CLI is a **standalone terminal interface** for the Cline AI coding assistant, written in Go. It provides the same autonomous coding capabilities as the VS Code extension but runs entirely in the terminal.
+
+## High-Level Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                           User Terminal                                 │
+└─────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                         cline (Go binary)                               │
+│                         cmd/cline/main.go                               │
+│   • Cobra CLI commands (task, auth, config, instance, etc.)             │
+│   • Interactive input via Bubble Tea                                    │
+│   • Streaming output with markdown rendering                            │
+└─────────────────────────────────────────────────────────────────────────┘
+          │ gRPC (50052)                                │ starts subprocess
+          ▼                                             ▼
+┌─────────────────────────┐                  ┌─────────────────────────┐
+│      cline-core         │◄────────────────►│      cline-host         │
+│      (Node.js)          │   gRPC (51052)   │      (Go binary)        │
+│                         │                  │   cmd/cline-host/main.go│
+│  • AI/LLM orchestration │                  │                         │
+│  • Tool execution       │                  │  • Workspace paths      │
+│  • Task state mgmt      │                  │  • File diff editing    │
+│  • Message handling     │                  │  • Clipboard access     │
+└─────────────────────────┘                  │  • Environment info     │
+          │                                  └─────────────────────────┘
+          │ SQLite (self-registration)
+          ▼
+┌─────────────────────────────────────────────────────────────────────────┐
+│                   ~/.cline/data/locks/locks.db                          │
+│            (Instance registry - core self-registers on startup)         │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+## Entry Points (`cmd/`)
+
+### `cmd/cline/main.go` - Main CLI
+
+Cobra-based CLI with commands:
+
+- **Root**: `cline [prompt]` - Start a task directly
+- **task**: Create, send, view, list, pause, restore tasks
+- **auth**: Authentication setup and provider configuration
+- **config**: Read/write settings
+- **instance**: Manage running Cline instances
+- **logs**: View and clean log files
+- **doctor**: System health check
+
+### `cmd/cline-host/main.go` - Host Bridge Service
+
+Separate gRPC server providing host environment operations to cline-core:
+
+- Workspace paths
+- File diff editing
+- Clipboard access
+- Shutdown coordination
+
+---
+
+## `pkg/cli/` Subsystems
+
+### 1. `auth/` - Authentication System
+
+Handles authentication with Cline service and BYO (Bring Your Own) API providers.
+
+| File                      | Purpose                                                                  |
+| ------------------------- | ------------------------------------------------------------------------ |
+| `auth_cline_provider.go`  | OAuth login flow - opens browser, subscribes to auth callback stream     |
+| `auth_menu.go`            | Interactive menu showing auth options based on current state             |
+| `auth_subscription.go`    | gRPC stream subscription for auth status updates                         |
+| `wizard_byo.go`           | Interactive wizard for configuring BYO providers                         |
+| `wizard_byo_bedrock.go`   | AWS Bedrock-specific credential setup                                    |
+| `wizard_byo_oca.go`       | Oracle Code Assist setup                                                 |
+| `providers_list.go`       | Retrieves configured providers from core state                           |
+| `providers_byo.go`        | Provider selection UI and field configuration                            |
+| `models_*.go`             | Model listing (static lists + dynamic fetch from OpenRouter/OpenAI/Ollama) |
+
+**Flow**: User runs `cline auth` → Menu shows options → For BYO: wizard guides through provider/key/model selection → Config saved via gRPC to core.
+
+---
+
+### 2. `clerror/` - Error Handling
+
+Parses and classifies API errors from the Cline service.
+
+**Error Types:**
+
+- `ErrorTypeAuth` - 401, bad API key
+- `ErrorTypeBalance` - Insufficient credits
+- `ErrorTypeRateLimit` - 429, quota exceeded
+- `ErrorTypeNetwork` - Connection issues
+- `ErrorTypeUnknown` - Catch-all
+
+Extracts billing details (balance, spent, buy credits URL) from error responses.
+
+---
+
+### 3. `config/` - Configuration Management
+
+| File                  | Purpose                                                                    |
+| --------------------- | -------------------------------------------------------------------------- |
+| `manager.go`          | gRPC interface for reading/writing settings via `UpdateSettingsCli` RPC    |
+| `settings_renderer.go`| Pretty-prints config values, censors sensitive fields (keys, secrets)      |
+
+Supports dot-notation paths: `cline config get auto-approval-settings.actions.read-files`
+
+---
+
+### 4. `display/` - Terminal Display System
+
+The most complex subsystem - handles all visual output.
+
+| File                    | Purpose                                                              |
+| ----------------------- | -------------------------------------------------------------------- |
+| `renderer.go`           | Central coordinator with lipgloss styles, color methods, markdown delegation |
+| `streaming.go`          | Real-time streaming display with deduplication                       |
+| `segment_streamer.go`   | Streaming segments (header + body) with context-aware headers        |
+| `typewriter.go`         | Character-by-character animation with variable delays                |
+| `markdown_renderer.go`  | Glamour wrapper for terminal markdown rendering                      |
+| `tool_renderer.go`      | Tool operation formatting ("Cline is editing `file.ts`")             |
+| `tool_result_parser.go` | Parses structured tool results (file lists, search results)          |
+| `banner.go`             | Session startup banner with version/model/workspace                  |
+| `deduplicator.go`       | MD5-based deduplication with 2-second window                         |
+| `system_renderer.go`    | Rich error/warning boxes for balance errors, auth failures           |
+| `ansi.go`               | TTY detection, line clearing with escape codes                       |
+
+---
+
+### 5. `global/` - Global State Management
+
+| File               | Purpose                                                                    |
+| ------------------ | -------------------------------------------------------------------------- |
+| `global.go`        | Global config (paths, verbosity, output format), initialization            |
+| `registry.go`      | Instance discovery via SQLite, health checking, default instance management|
+| `cline-clients.go` | Starts cline-core + cline-host processes, port allocation, cleanup         |
+
+**Instance lifecycle:**
+
+1. Find available port pair
+2. Start `cline-host` on port+1000
+3. Start `cline-core` on port
+4. Wait for core to self-register in SQLite
+5. Set as default if first instance
+
+---
+
+### 6. `handlers/` - Message Handlers
+
+Routes incoming messages from cline-core to appropriate renderers.
+
+| File               | Purpose                                                               |
+| ------------------ | --------------------------------------------------------------------- |
+| `handler.go`       | Handler registry with priority-based routing                          |
+| `ask_handlers.go`  | Approval requests: tool, command, followup, api_req_failed, etc.      |
+| `say_handlers.go`  | Status messages: text, reasoning, command_output, tool, checkpoint, etc. |
+
+Uses `DisplayContext` providing renderer access, state, and context flags (isLast, isPartial, isStreamingMode).
+
+---
+
+### 7. `output/` - Output Coordination
+
+| File                  | Purpose                                                                 |
+| --------------------- | ----------------------------------------------------------------------- |
+| `coordinator.go`      | Coordinates streaming output with interactive input (saves/restores input state) |
+| `input_model.go`      | Bubble Tea model for rich input (message, approval, feedback types)     |
+| `slash_completion.go` | Autocomplete dropdown for slash commands                                |
+
+**Key pattern:** When output needs to print while input is visible, the coordinator saves input state, clears the form, prints, then restores input.
+
+---
+
+### 8. `slash/` - Slash Command Registry
+
+Central registry for commands like `/plan`, `/act`, `/cancel`:
+
+- **CLI-local commands**: Handled directly by CLI
+- **Backend commands**: Fetched from core via gRPC, filtered by `CliCompatible` flag
+
+---
+
+### 9. `sqlite/` - Instance Locking
+
+Manages the distributed locking system:
+
+- **Instance locks**: Track running Cline instances by address
+- **File locks**: Coordinate file access across instances
+- SQLite database created by cline-core, CLI reads/writes for discovery
+
+---
+
+### 10. `task/` - Task Management
+
+| File                    | Purpose                                                              |
+| ----------------------- | -------------------------------------------------------------------- |
+| `manager.go`            | Core orchestrator: create, cancel, resume, restore tasks; stream handling |
+| `stream_coordinator.go` | Deduplication and turn management for dual streams                   |
+| `input_handler.go`      | Interactive input during follow mode (polling, approval detection)   |
+| `history_handler.go`    | Direct disk access to `taskHistory.json`                             |
+| `settings_parser.go`    | Parse settings from CLI flags                                        |
+| `follow_options.go`     | Configuration for follow behavior                                    |
+
+**Streaming:** Task manager subscribes to two gRPC streams:
+
+1. `SubscribeToState` - Full state updates
+2. `SubscribeToPartialMessage` - Streaming AI responses
+
+---
+
+### 11. `terminal/` - Terminal Handling
+
+Enhanced keyboard protocol support and terminal configuration:
+
+- Enables modifyOtherKeys and Kitty keyboard protocol
+- Detects terminal type (VS Code, iTerm, Ghostty, Kitty, etc.)
+- Auto-configures shift+enter keybindings for various terminals
+
+---
+
+### 12. `types/` - Type Definitions
+
+| File           | Purpose                                                           |
+| -------------- | ----------------------------------------------------------------- |
+| `messages.go`  | `ClineMessage`, `AskType`, `SayType`, `ToolType` enums, proto conversion |
+| `state.go`     | `ConversationState` with thread-safe message access               |
+| `history.go`   | `HistoryItem` matching taskHistory.json format                    |
+
+---
+
+### 13. `updater/` - Auto-Update
+
+Background auto-update checking:
+
+- 24-hour check interval (cached)
+- Queries npm registry for newer versions
+- Supports `latest` and `nightly` channels
+- Runs `npm install -g cline` to update
+
+---
+
+## `pkg/common/` - Shared Types
+
+| File            | Purpose                                                      |
+| --------------- | ------------------------------------------------------------ |
+| `constants.go`  | `SETTINGS_SUBFOLDER`, `DEFAULT_CLINE_CORE_PORT`              |
+| `schema.go`     | SQL queries for instance/file locks                          |
+| `types.go`      | `CoreInstanceInfo`, `LockRow`, `DefaultCoreInstance`         |
+| `utils.go`      | Port checking, health checks, address normalization, retry logic |
+
+---
+
+## `pkg/generated/` - Auto-Generated
+
+| File                  | Purpose                                                                                                              |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `providers.go`        | Provider definitions (Anthropic, OpenAI, Bedrock, etc.) with field metadata and model specs - generated from TypeScript sources |
+| `field_overrides.go`  | Manual overrides for field filtering                                                                                 |
+
+---
+
+## `pkg/hostbridge/` - CLI-to-Core Bridge
+
+This is the **reverse bridge** allowing cline-core to request host environment operations:
+
+| File                    | Purpose                                              |
+| ----------------------- | ---------------------------------------------------- |
+| `grpc_server.go`        | Main server registering all services                 |
+| `simple_workspace.go`   | Workspace service: returns CWD as workspace path     |
+| `diff.go`               | In-memory file diff editing with line-based operations |
+| `env.go`                | Clipboard access, version info, shutdown coordination |
+| `window.go`             | UI stubs (no-ops or console output)                  |
+
+**Why this exists:** The same cline-core logic runs in VS Code and CLI. In VS Code, the "host" is the extension with editor APIs. In CLI, hostbridge emulates these capabilities with terminal-appropriate implementations.
+
+---
+
+## Key Design Decisions
+
+1. **Two-process model:** `cline` CLI manages instances; `cline-core` is the actual AI engine (Node.js). This allows reusing the same core as the VS Code extension.
+
+2. **Self-registration via SQLite:** `cline-core` registers itself in a SQLite database on startup. The CLI discovers instances by reading this database, enabling multi-instance support.
+
+3. **Host bridge abstraction:** The `cline-host` process provides platform-specific operations (clipboard, workspace paths) via gRPC, allowing `cline-core` to remain host-agnostic.
+
+4. **Streaming-first UI:** The CLI uses gRPC streaming to display AI responses in real-time with typewriter-style rendering.
+
+5. **Dual stream handling:** Task manager subscribes to both state updates and partial messages, using deduplication to prevent duplicate rendering.

cli/pkg/cli/config/manager.go

@@ -92,7 +92,6 @@ func (m *Manager) ListSettings(ctx context.Context) error {
 		"telemetrySetting",
 		"planActSeparateModelsSetting",
 		"enableCheckpointsSetting",
-		"mcpMarketplaceEnabled",
 		"shellIntegrationTimeout",
 		"terminalReuseEnabled",
 		"mcpResponsesCollapsed",
@@ -111,6 +110,7 @@ func (m *Manager) ListSettings(ctx context.Context) error {
 		"dictationSettings",
 		"autoCondenseThreshold",
 		"autoApprovalSettings",
+		"hooksEnabled",
 	}
 
 	// Render each field using the renderer

cli/pkg/cli/config/settings_renderer.go

@@ -77,10 +77,9 @@ func RenderField(key string, value interface{}, censor bool) error {
 	case "mode", "telemetrySetting", "preferredLanguage", "customPrompt",
 		"defaultTerminalProfile", "mcpDisplayMode", "openaiReasoningEffort",
 		"planActSeparateModelsSetting", "enableCheckpointsSetting",
-		"mcpMarketplaceEnabled", "terminalReuseEnabled",
-		"mcpResponsesCollapsed", "strictPlanModeEnabled",
+		"terminalReuseEnabled", "mcpResponsesCollapsed", "strictPlanModeEnabled",
 		"useAutoCondense", "yoloModeToggled", "shellIntegrationTimeout",
-		"terminalOutputLineLimit", "autoCondenseThreshold":
+		"terminalOutputLineLimit", "autoCondenseThreshold", "hooksEnabled":
 		fmt.Printf("%s: %s\n", camelToKebab(key), formatValue(value, key, censor))
 		return nil
 

cli/pkg/cli/display/tool_renderer.go

@@ -161,6 +161,14 @@ func (tr *ToolRenderer) generateToolHeader(tool *types.ToolMessage, verbTense st
 		}
 		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
 
+	case string(types.ToolTypeWebSearch):
+		if verbTense == "wants to" {
+			action = "wants to search for"
+		} else {
+			action = "is searching for"
+		}
+		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
+
 	case string(types.ToolTypeListCodeDefinitionNames):
 		if verbTense == "wants to" {
 			action = "wants to list code definitions in"
@@ -207,8 +215,8 @@ func (tr *ToolRenderer) GenerateToolContentPreview(tool *types.ToolMessage) stri
 		previewMd := fmt.Sprintf("```\n%s\n```", preview)
 		return tr.renderMarkdown(previewMd)
 
-	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch), string(types.ToolTypeFileDeleted):
-		// No preview for read/fetch operations
+	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch), string(types.ToolTypeWebSearch), string(types.ToolTypeFileDeleted):
+		// No preview for read/fetch/search operations
 		return ""
 
 	default:
@@ -243,7 +251,8 @@ func (tr *ToolRenderer) GenerateToolContentBody(tool *types.ToolMessage) string
 		string(types.ToolTypeListFilesRecursive),
 		string(types.ToolTypeListCodeDefinitionNames),
 		string(types.ToolTypeSearchFiles),
-		string(types.ToolTypeWebFetch):
+		string(types.ToolTypeWebFetch),
+		string(types.ToolTypeWebSearch):
 		// Use parser for structured output
 		preview := toolParser.ParseToolResult(tool)
 		return tr.renderMarkdown(preview)

cli/pkg/cli/display/tool_result_parser.go

@@ -224,6 +224,11 @@ func (p *ToolResultParser) ParseWebFetch(content, url string) string {
 	return ""
 }
 
+// ParseWebSearch formats webSearch tool results
+func (p *ToolResultParser) ParseWebSearch(content, query string) string {
+	return ""
+}
+
 // detectLanguage returns syntax highlighting language based on file extension
 func (p *ToolResultParser) detectLanguage(ext string) string {
 	langMap := map[string]string{
@@ -289,6 +294,8 @@ func (p *ToolResultParser) ParseToolResult(tool *types.ToolMessage) string {
 		return p.ParseCodeDefinitions(tool.Content)
 	case "webFetch":
 		return p.ParseWebFetch(tool.Content, tool.Path)
+	case "webSearch":
+		return p.ParseWebSearch(tool.Content, tool.Path)
 	default:
 		return tool.Content
 	}

cli/pkg/cli/global/cline-clients.go

@@ -478,8 +478,9 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 	
 	env = append(env,
 		fmt.Sprintf("NODE_PATH=%s", nodePath),
-		"GRPC_TRACE=all",
-		"GRPC_VERBOSITY=DEBUG",
+		// These control gRPC debug logging
+		//"GRPC_TRACE=all",
+		//"GRPC_VERBOSITY=DEBUG",
 		"NODE_ENV=development",
 	)
 	cmd.Env = env

cli/pkg/cli/task/input_handler.go

@@ -251,7 +251,8 @@ func determineAutoApprovalAction(msg *types.ClineMessage) (string, error) {
 			types.ToolTypeListFilesRecursive,
 			types.ToolTypeListCodeDefinitionNames,
 			types.ToolTypeSearchFiles,
-			types.ToolTypeWebFetch:
+			types.ToolTypeWebFetch,
+			types.ToolTypeWebSearch:
 			return "read_files", nil
 		case types.ToolTypeEditedExistingFile,
 			types.ToolTypeNewFileCreated:

cli/pkg/cli/task/manager.go

@@ -984,6 +984,33 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
+		case msg.Say == string(types.SayTypeMcpServerResponse):
+			msgKey := fmt.Sprintf("%d", msg.Timestamp)
+			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
+				coordinator.MarkProcessedInCurrentTurn(msgKey)
+			}
+
+		case msg.Say == string(types.SayTypeMcpNotification):
+			msgKey := fmt.Sprintf("%d", msg.Timestamp)
+			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
+				coordinator.MarkProcessedInCurrentTurn(msgKey)
+			}
+
+		case msg.Say == string(types.SayTypeUseMcpServer):
+			msgKey := fmt.Sprintf("%d", msg.Timestamp)
+			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
+				coordinator.MarkProcessedInCurrentTurn(msgKey)
+			}
+
 		case msg.Say == string(types.SayTypeCheckpointCreated):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
@@ -1007,6 +1034,14 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 				}
 			}
 
+		case msg.Say == string(types.SayTypeCompletionResult):
+			msgKey := fmt.Sprintf("%d", msg.Timestamp)
+			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+				coordinator.MarkProcessedInCurrentTurn(msgKey)
+			}
+
 		case msg.Ask == string(types.AskTypeCommandOutput):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {

cli/pkg/cli/task/settings_parser.go

@@ -290,6 +290,12 @@ func setSimpleField(settings *cline.Settings, key, value string) error {
 			return err
 		}
 		settings.ActModeAwsBedrockCustomSelected = boolPtr(val)
+	case "hooks_enabled":
+		val, err := parseBool(value)
+		if err != nil {
+			return err
+		}
+		settings.HooksEnabled = boolPtr(val)
 
 	// Integer fields
 	case "request_timeout_ms":

cli/pkg/cli/types/messages.go

@@ -113,6 +113,7 @@ const (
 	ToolTypeListCodeDefinitionNames ToolType = "listCodeDefinitionNames"
 	ToolTypeSearchFiles             ToolType = "searchFiles"
 	ToolTypeWebFetch                ToolType = "webFetch"
+	ToolTypeWebSearch               ToolType = "webSearch"
 	ToolTypeSummarizeTask           ToolType = "summarizeTask"
 )
 

cli/pkg/hostbridge/env.go

@@ -77,7 +77,7 @@ func (s *EnvService) GetHostVersion(ctx context.Context, req *cline.EmptyRequest
 
 	return &host.GetHostVersionResponse{
 		Platform:     proto.String("Cline CLI"),
-		Version:      proto.String(""),
+		Version:      proto.String(global.CliVersion),
 		ClineType:    proto.String("CLI"),
 		ClineVersion: proto.String(global.CliVersion),
 	}, nil

docs/cline-cli/samples/github-integration.mdx

@@ -9,7 +9,7 @@ Automate GitHub issue analysis with AI. Mention `@cline` in any issue comment to
 
 
 <Note>
-**New to Cline CLI?** This sample assumes you understand Cline CLI basics and have completed the [Installation Guide](https://docs.cline.bot/cline-cli/installation). If you're new to Cline CLI, we recommend starting with the [GitHub RCA sample](../github-issue-rca) first, as it's simpler and will help you understand the fundamentals before setting up GitHub Actions.
+**New to Cline CLI?** This sample assumes you understand Cline CLI basics and have completed the [Installation Guide](https://docs.cline.bot/cline-cli/installation). If you're new to Cline CLI, we recommend starting with the [GitHub RCA sample](./github-issue-rca) first, as it's simpler and will help you understand the fundamentals before setting up GitHub Actions.
 </Note>
 
 ## The Workflow

docs/cline-cli/three-core-flows.mdx

@@ -152,7 +152,7 @@ For in-depth commands and flags, check out the [CLI reference](/cline-cli/cli-re
     Understand how YOLO mode works and when to use full automation versus manual approval.
   </Card>
   
-  <Card title="Task management" icon="clipboard-check" href="/getting-started/task-management">
+  <Card title="Task management" icon="clipboard-check" href="/features/tasks/task-management">
     Learn how Cline tracks and manages tasks, including saving and restoring state from checkpoints.
   </Card>
 </Columns>

docs/docs.json

@@ -139,7 +139,14 @@
 							"features/editing-messages",
 							"features/explain-changes",
 							"features/focus-chain",
-							"features/hooks",
+							{
+								"group": "Hooks",
+								"pages": [
+									"features/hooks/index",
+									"features/hooks/hook-reference",
+									"features/hooks/samples"
+								]
+							},
 							"features/multiroot-workspace",
 							"features/plan-and-act",
 							{
@@ -271,18 +278,47 @@
 						"pages": [
 							"enterprise-solutions/overview",
 							"enterprise-solutions/onboarding",
-							"enterprise-solutions/members/roles-and-permissions",
+							"enterprise-solutions/team-management/managing-members",
 							{
-								"group": "Provider Remote Configuration",
+								"group": "SaaS Provider Configuration",
 								"pages": [
+									"enterprise-solutions/configuration/remote-configuration/overview",
 									{
 										"group": "AWS Bedrock",
 										"pages": [
-											"enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration",
-											"enterprise-solutions/provider-remote-config/aws-bedrock/member-configuration"
+											"enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
+										]
+									},
+									{
+										"group": "LiteLLM",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/litellm/member-configuration"
+										]
+									},
+									{
+										"group": "Google Vertex AI",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration"
 										]
 									}
 								]
+							},
+							{
+								"group": "Control Other Cline Features",
+								"pages": [
+									"enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode"
+								]
+							},
+							{
+								"group": "Monitoring",
+								"pages": [
+									"enterprise-solutions/monitoring/overview",
+									"enterprise-solutions/monitoring/telemetry",
+									"enterprise-solutions/monitoring/opentelemetry"
+								]
 							}
 						]
 					}
@@ -354,13 +390,17 @@
 			"source": "/cline-cli/samples",
 			"destination": "/cline-cli/samples/overview"
 		},
+		{
+			"source": "/features/hooks/real-world-examples",
+			"destination": "/features/hooks/samples"
+		},
 		{
 			"source": "/enterprise-solutions/configure-AWS-Bedrock-Admin",
-			"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration"
+			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration"
 		},
 		{
 			"source": "/enterprise-solutions/configure-AWS-Bedrock-Member",
-			"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/member-configuration"
+			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
 		},
 		{
 			"source": "/enterprise-solutions/configure-workOS-authkit",
@@ -369,6 +409,14 @@
 		{
 			"source": "/enterprise-solutions/Onboarding your Organization",
 			"destination": "/enterprise-solutions/onboarding"
+		},
+		{
+			"source": "/enterprise-solutions/team-management/overview",
+			"destination": "/enterprise-solutions/team-management/managing-members"
+		},
+		{
+			"source": "/enterprise-solutions/team-management/roles-and-permissions",
+			"destination": "/enterprise-solutions/team-management/managing-members"
 		}
 	],
 	"search": {

docs/enterprise-solutions/configuration/choosing-your-deployment.mdx

@@ -0,0 +1,105 @@
+---
+title: "Choosing Your Configuration Path"
+sidebarTitle: "Deployment Guide"
+description: "Decide between SaaS and Self-Hosted configuration for your Cline Enterprise deployment"
+---
+
+Choose the right configuration approach for your organization. Most teams start with SaaS for quick deployment, while enterprises with complex requirements opt for self-hosted infrastructure.
+
+## Configuration Paths
+
+<CardGroup cols={2}>
+  <Card title="SaaS Provider Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    ### Quick Setup via Web Console
+    
+    ✅ No infrastructure required  
+    ✅ 5-10 minute configuration  
+    ✅ Web-based admin console  
+    ✅ Automatic updates  
+    ✅ Simplified credential management
+    
+    **Best for:**
+    - Small to medium teams (5-50 developers)
+    - Quick deployment needs
+    - Limited DevOps resources
+    - Standard security requirements
+    - Single region deployments
+  </Card>
+  
+  <Card title="Self-Hosted Configuration" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
+    ### Full Infrastructure Control
+    
+    ✅ Your own AWS/GCP/K8s  
+    ✅ VPC endpoints & private connectivity  
+    ✅ Multi-account setups  
+    ✅ Advanced compliance & audit  
+    ✅ GitOps workflows
+    
+    **Best for:**
+    - Large enterprises (50+ developers)
+    - Complex security requirements
+    - Existing cloud infrastructure
+    - Multi-region deployments
+    - Custom compliance needs
+  </Card>
+</CardGroup>
+
+## Detailed Comparison
+
+### Feature Comparison
+
+| Feature | SaaS | Self-Hosted |
+|---------|------|-------------|
+| **Configuration** | Web UI | YAML + Helm/Kubernetes |
+| **Infrastructure** | None required | Full AWS/GCP/K8s |
+| **VPC Endpoints** | Basic | Full private connectivity |
+| **Multi-Account** | ❌ | ✅ |
+| **IAM** | Standard RBAC roles | Standard RBAC roles |
+| **Compliance** | Standard | Custom frameworks |
+| **GitOps** | ❌ | ✅ |
+| **Maintenance** | Managed by Cline | Self-managed |
+| **Updates** | Automatic (extension) | Automatic (extension) + Infrastructure control |
+
+### Security & Compliance
+
+| Capability | SaaS | Self-Hosted |
+|------------|------|-------------|
+| **Network Encryption** | HTTPS/TLS | HTTPS/TLS |
+| **Network** | Public internet | Private VPC endpoints |
+| **Access Control** | Standard RBAC | Standard RBAC |
+| **Audit Logs** | OpenTelemetry traces | OpenTelemetry traces + Infrastructure logs |
+| **Data Residency** | Cline-managed deployment | Customer-controlled deployment |
+
+### Cost Structure
+
+| Cost Category | SaaS | Self-Hosted |
+|---------------|------|-------------|
+| **Cline Subscription** | Fixed enterprise fee | Fixed enterprise fee |
+| **Inference Provider Costs** | Usage-based | Usage-based |
+| **Infrastructure** | ✅ None required | Kubernetes, networking, storage |
+| **Personnel** | ✅ None required | DevOps team needed |
+| **Total Cost Profile** | Predictable and simple | Variable based on scale |
+
+## Migration Path
+
+<Note>
+Most organizations start with SaaS configuration for quick deployment, then migrate to self-hosted later as requirements grow. This minimizes risk and ensures your infrastructure meets actual usage patterns.
+</Note>
+
+## Getting Started
+
+<CardGroup cols={2}>
+  <Card title="Start with SaaS" icon="rocket" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Begin with quick SaaS setup
+  </Card>
+  
+  <Card title="Deploy Self-Hosted" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
+    Plan your infrastructure deployment
+  </Card>
+</CardGroup>
+
+## Need Help Deciding?
+
+- [**Contact Cline Enterprise Sales**](https://cline.bot/contact-sales) for a consultation on your specific requirements
+- [**Start with SaaS**](/enterprise-solutions/configuration/remote-configuration/overview) if unsure - it's lower risk and you can always migrate later
+- [**Review Self-Hosted Requirements**](/enterprise-solutions/configuration/infrastructure-configuration/overview) if you have existing infrastructure that could benefit from self-hosted deployment

docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/overview.mdx

@@ -0,0 +1,35 @@
+---
+title: "Overview"
+sidebarTitle: "Overview"
+description: "Configure Cline settings for your enterprise deployment"
+---
+
+This section covers configuration options for controlling Cline's behavior in enterprise deployments.
+
+## Available Settings
+
+<Card title="YOLO Mode" icon="rocket" href="/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode">
+  Control enterprise access to autonomous operation mode with complete auto-approval
+</Card>
+
+## Configuration Methods
+
+These settings can be configured through:
+
+
+### Individual Users
+- Users can toggle settings in their local Cline interface
+- Enterprise policies can restrict certain settings
+- Changes apply immediately to new tasks
+
+## Enterprise Controls
+
+Administrators can enforce policies through remote configuration:
+
+```json
+{
+  "yoloModeAllowed": false
+}
+```
+
+When `yoloModeAllowed` is set to `false`, users cannot enable YOLO Mode in their local Cline interface.

docs/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/yolo-mode.mdx

@@ -0,0 +1,233 @@
+---
+title: "YOLO Mode"
+sidebarTitle: "YOLO Mode"
+description: "Enterprise controls for YOLO Mode autonomous operation"
+---
+
+YOLO Mode enables Cline to operate with complete autonomy, auto-approving all actions without user confirmation. For Enterprise administrators, this page covers how to control access to YOLO Mode across your organization.
+
+<Note>
+For complete details about YOLO Mode functionality, risks, and best practices, see [YOLO Mode in Features](/features/yolo-mode).
+</Note>
+
+## Overview
+
+When YOLO Mode is enabled, Cline automatically approves all operations including file changes, terminal commands, browser actions, and mode transitions. This provides maximum automation speed but removes all safety guardrails.
+
+<Warning>
+YOLO Mode is powerful but potentially dangerous. Administrators should carefully consider which teams or users should have access to this feature.
+</Warning>
+
+## Enterprise Administrator Configuration
+
+As an Enterprise administrator, you can control whether users in your organization can enable YOLO Mode through remote configuration.
+
+### Disabling YOLO Mode for All Users
+
+Add the following to your remote configuration JSON:
+
+```json
+{
+  "yoloModeAllowed": false
+}
+```
+
+When `yoloModeAllowed` is set to `false`:
+- The YOLO Mode toggle is disabled in all user interfaces
+- Users cannot enable YOLO Mode even in their local settings
+- This policy applies immediately to all team members
+- Enterprise policy takes precedence over individual preferences
+
+### Enabling YOLO Mode for All Users
+
+```json
+{
+  "yoloModeAllowed": true
+}
+```
+
+When `yoloModeAllowed` is set to `true` or omitted:
+- Users can enable or disable YOLO Mode in their local Cline settings
+- Individual users make their own decisions about using YOLO Mode
+- No organizational restrictions apply
+
+## Enterprise Policy Recommendations
+
+### Recommended Approach
+
+Most organizations should **disable YOLO Mode by default** for the following reasons:
+
+<AccordionGroup>
+  <Accordion title="Security & Compliance" icon="shield">
+    YOLO Mode removes all approval gates, potentially allowing:
+    - Unreviewed code changes to critical systems
+    - Execution of commands without oversight
+    - Automated actions that may violate compliance policies
+    - Risk of data exposure through unmonitored operations
+  </Accordion>
+  
+  <Accordion title="Code Quality Control" icon="code">
+    Without approval prompts:
+    - Changes happen too quickly to review in real-time
+    - Mistakes can compound before detection
+    - Quality gates are bypassed
+    - Rollback becomes more complex
+  </Accordion>
+  
+  <Accordion title="Audit Requirements" icon="clipboard-check">
+    Many industries require:
+    - Documented approval trails for code changes
+    - Clear accountability for automated actions
+    - Traceable decision-making processes
+    - YOLO Mode may conflict with these requirements
+  </Accordion>
+</AccordionGroup>
+
+### Exceptions: When to Allow YOLO Mode
+
+Consider enabling YOLO Mode for:
+
+**Sandbox/Development Environments**
+- Isolated testing environments
+- Personal development machines
+- Proof-of-concept projects
+- Temporary exploratory work
+
+**Specialized Roles**
+- DevOps automation engineers (with proper monitoring)
+- Research & development teams in sandboxed environments
+- Teams with robust rollback and recovery procedures
+
+**Controlled Use Cases**
+- Scripted CI/CD pipelines with comprehensive logging
+- Automated testing scenarios
+- Demonstration or training environments
+
+## Enterprise Considerations
+
+### Security Implications
+
+When YOLO Mode is enabled in your organization:
+
+**Risk Factors:**
+- All tool executions happen automatically without human review
+- Potential for rapid propagation of mistakes across multiple files
+- Reduced opportunity to catch security vulnerabilities before implementation
+- Automated operations may bypass existing security controls
+
+**Mitigations:**
+- Implement comprehensive logging and monitoring
+- Restrict YOLO Mode to non-production environments
+- Require periodic security reviews for teams using YOLO Mode
+- Ensure version control and rollback procedures are in place
+
+### Monitoring Requirements
+
+When allowing YOLO Mode in your organization, implement:
+
+**Mandatory Monitoring:**
+1. **Real-time Activity Tracking**
+   - Monitor which users enable YOLO Mode
+   - Track when YOLO Mode is active
+   - Log all automated actions taken
+
+2. **Audit Trail Maintenance**
+   - Preserve complete history of YOLO Mode sessions
+   - Document what was automated and when
+   - Maintain records for compliance purposes
+
+3. **Anomaly Detection**
+   - Alert on unusual patterns of automated actions
+   - Flag high-risk operations performed automatically
+   - Monitor for potential security incidents
+
+### Monitoring YOLO Mode Usage
+
+When YOLO Mode is enabled (by policy), track usage through:
+
+**Telemetry Events:**
+- Captures when users toggle YOLO Mode on/off
+- Records which tasks were executed with YOLO Mode enabled
+- Provides aggregate usage statistics across your organization
+
+**Task History:**
+- Task metadata indicates whether YOLO Mode was active
+- Complete action logs show automated approvals
+- Enables post-action review and analysis
+
+**Audit Logs:**
+- Standard logging captures all automated decisions
+- Tool executions are recorded with timestamps
+- Provides compliance trail for regulated environments
+
+## Recommended Policies by Organization Size
+
+### Small Teams (5-20 developers)
+- **Default:** Disabled
+- **Exceptions:** Allow for individual sandbox environments
+- **Monitoring:** Basic telemetry sufficient
+
+### Medium Organizations (20-100 developers)
+- **Default:** Disabled
+- **Exceptions:** Permit for designated dev/test environments only
+- **Monitoring:** Required telemetry + regular audit reviews
+
+### Large Enterprises (100+ developers)
+- **Default:** Strictly disabled
+- **Exceptions:** Require security approval for each use case
+- **Monitoring:** Comprehensive telemetry + real-time alerting + compliance reporting
+
+## Technical Implementation
+
+### Configuration Management
+
+**Centralized Control through Remote Configuration:**
+
+```json
+{
+  "yoloModeAllowed": false,
+  // Other policies...
+}
+```
+
+This setting:
+- Applies instantly to all connected clients
+- Cannot be overridden by individual users
+- Persists across Cline restarts
+- Is synchronized across all team members
+
+### Policy Enforcement
+
+The enforcement mechanism:
+1. Users authenticate with your enterprise configuration server
+2. Remote configuration is downloaded and applied
+3. Local UI respects enterprise policy settings
+4. YOLO Mode toggle is disabled if policy forbids it
+5. Users see a message explaining the enterprise restriction
+
+## Compliance Considerations
+
+For organizations in regulated industries:
+
+**SOC 2 Compliance:**
+- YOLO Mode may conflict with change management controls
+- Document decision to allow/disallow in security policies
+- Implement compensating controls if YOLO Mode is permitted
+
+**GDPR/Data Protection:**
+- Automated operations must still respect data handling policies
+- Ensure YOLO Mode doesn't bypass data protection safeguards
+- Maintain audit trails of automated data processing
+
+**Industry-Specific:**
+- Financial services: Generally incompatible with Reg requirements
+- Healthcare: May violate HIPAA audit trail requirements
+- Government: Often conflicts with approval workflow mandates
+
+## Support & Questions
+
+For help configuring YOLO Mode policies:
+- Review [Remote Configuration Overview](/enterprise-solutions/configuration/remote-configuration/overview)
+- See [Features: YOLO Mode](/features/yolo-mode) for detailed functionality
+- Contact your Enterprise support representative
+- Join our [Discord](https://discord.gg/cline) for community discussion

docs/enterprise-solutions/configuration/infrastructure-configuration/mcp/mcp-marketplace.mdx

@@ -0,0 +1,565 @@
+---
+title: "MCP Marketplace"
+sidebarTitle: "MCP Marketplace"
+description: "Deploy pre-built enterprise MCP servers from the Cline marketplace with one-click configuration"
+---
+
+The MCP Marketplace provides curated, enterprise-ready integrations with popular development tools and services. All marketplace servers are built with enterprise security, compliance, and scalability in mind.
+
+## Enterprise Marketplace Benefits
+
+<CardGroup cols={2}>
+  <Card title="One-Click Deployment" icon="rocket">
+    Deploy complex integrations instantly with pre-configured enterprise settings.
+  </Card>
+  
+  <Card title="Security Hardened" icon="shield-check">
+    All servers include enterprise security features, audit logging, and compliance controls.
+  </Card>
+  
+  <Card title="Maintained & Updated" icon="sync">
+    Regular security updates and feature enhancements managed by Cline Enterprise team.
+  </Card>
+  
+  <Card title="Enterprise Support" icon="headset">
+    Dedicated support channels for marketplace integration issues and customization.
+  </Card>
+</CardGroup>
+
+## Available Integrations
+
+### Development Tools
+
+<CardGroup cols={3}>
+  <Card title="GitHub Enterprise" icon="github">
+    Repository management, issue tracking, PR workflows, and code analysis
+  </Card>
+  
+  <Card title="GitLab Enterprise" icon="gitlab">
+    Project management, CI/CD pipelines, merge requests, and security scanning
+  </Card>
+  
+  <Card title="Bitbucket Enterprise" icon="bitbucket">  
+    Source code management, build pipelines, and deployment automation
+  </Card>
+</CardGroup>
+
+### Project Management
+
+<CardGroup cols={3}>
+  <Card title="Jira Enterprise" icon="jira">
+    Issue tracking, sprint management, custom fields, and workflow automation
+  </Card>
+  
+  <Card title="Azure DevOps" icon="microsoft">
+    Work items, boards, repos, pipelines, and test management
+  </Card>
+  
+  <Card title="Linear" icon="linear">
+    Issue tracking, project planning, and development workflow integration
+  </Card>
+</CardGroup>
+
+### Communication & Collaboration
+
+<CardGroup cols={3}>
+  <Card title="Slack Enterprise Grid" icon="slack">
+    Notifications, bot interactions, file sharing, and workflow automation
+  </Card>
+  
+  <Card title="Microsoft Teams" icon="microsoft-teams">
+    Chat notifications, meeting integration, and collaborative workflows
+  </Card>
+  
+  <Card title="Discord" icon="discord">
+    Community management, bot interactions, and developer notifications
+  </Card>
+</CardGroup>
+
+### Cloud Services
+
+<CardGroup cols={3}>
+  <Card title="AWS Services" icon="aws">
+    EC2, S3, Lambda, RDS, CloudWatch, and other AWS service integrations
+  </Card>
+  
+  <Card title="Google Cloud" icon="google-cloud">
+    Compute Engine, Cloud Storage, BigQuery, and GCP service management
+  </Card>
+  
+  <Card title="Azure Services" icon="azure">
+    Virtual Machines, Storage Accounts, Functions, and Azure resource management
+  </Card>
+</CardGroup>
+
+## Installing Marketplace Servers
+
+### Via Cline Enterprise Dashboard
+
+1. **Access Marketplace**: Navigate to `Settings > Enterprise > MCP Marketplace`
+2. **Browse Integrations**: Filter by category, popularity, or search by name
+3. **Review Details**: Check compatibility, permissions, and configuration requirements
+4. **Install**: Click "Install" and configure required settings
+5. **Deploy**: Approve deployment to your selected environment
+
+### Via Configuration File
+
+Install marketplace servers through enterprise configuration:
+
+```yaml
+# enterprise-mcp-config.yaml
+mcp:
+  marketplace_servers:
+    - name: "github-enterprise"
+      package: "@cline/mcp-github-enterprise"
+      version: "2.1.0"
+      environment: "production"
+      
+      config:
+        github:
+          base_url: "https://github.company.com/api/v3"
+          token: "${GITHUB_ENTERPRISE_TOKEN}"
+          organization: "company"
+          
+        features:
+          issue_management: true
+          pull_request_automation: true
+          code_analysis: true
+          security_scanning: true
+          
+        permissions:
+          repositories: "read-write"
+          issues: "write"
+          pull_requests: "write"
+          
+        compliance:
+          audit_logging: true
+          data_retention_days: 365
+          encryption_at_rest: true
+          
+    - name: "jira-enterprise"
+      package: "@cline/mcp-jira-enterprise"
+      version: "1.8.3"
+      environment: "production"
+      
+      config:
+        jira:
+          base_url: "https://company.atlassian.net"
+          username: "${JIRA_USERNAME}"
+          api_token: "${JIRA_API_TOKEN}"
+          
+        projects:
+          - key: "DEV"
+            permissions: ["read", "write", "transition"]
+          - key: "OPS"
+            permissions: ["read", "comment"]
+            
+        compliance:
+          field_encryption: ["description", "comments"]
+          audit_trail: true
+```
+
+### Via CLI
+
+Deploy using the Cline Enterprise CLI:
+
+```bash
+# Install GitHub Enterprise integration
+cline-enterprise mcp install github-enterprise \
+  --version 2.1.0 \
+  --config-file github-config.yaml \
+  --environment production
+
+# Install Slack Enterprise Grid integration  
+cline-enterprise mcp install slack-enterprise-grid \
+  --version 1.5.2 \
+  --config workspace_id=T1234567890 \
+  --config bot_token=${SLACK_BOT_TOKEN} \
+  --environment production
+
+# List installed marketplace servers
+cline-enterprise mcp list --environment production
+
+# Check server status
+cline-enterprise mcp status github-enterprise --environment production
+```
+
+## Configuration Examples
+
+### GitHub Enterprise Integration
+
+```yaml
+# github-enterprise-config.yaml
+github:
+  base_url: "https://github.company.com/api/v3"
+  token: "${GITHUB_ENTERPRISE_TOKEN}"
+  organization: "company"
+  
+  # Repository access controls
+  repositories:
+    allowed_patterns:
+      - "company/*"
+      - "internal/*"
+    blocked_patterns:
+      - "*/secrets"
+      - "*/private-keys"
+      
+  # Feature configuration
+  features:
+    issue_management:
+      enabled: true
+      auto_assign: true
+      labels:
+        - "ai-generated"
+        - "cline-task"
+        
+    pull_requests:
+      enabled: true
+      auto_review_request: true
+      required_approvals: 2
+      enforce_branch_protection: true
+      
+    code_analysis:
+      enabled: true
+      languages: ["typescript", "python", "go", "rust"]
+      security_scan: true
+      
+  # Security and compliance
+  security:
+    webhook_secret: "${GITHUB_WEBHOOK_SECRET}"
+    rate_limiting:
+      requests_per_hour: 5000
+      burst_limit: 100
+    ip_whitelist:
+      - "10.0.0.0/8"
+      - "192.168.0.0/16"
+      
+  audit:
+    log_level: "INFO"
+    include_payloads: false
+    retention_days: 365
+    destinations: ["datadog", "splunk"]
+```
+
+### Jira Enterprise Integration
+
+```yaml
+# jira-enterprise-config.yaml
+jira:
+  base_url: "https://company.atlassian.net"
+  username: "${JIRA_USERNAME}"
+  api_token: "${JIRA_API_TOKEN}"
+  
+  # Project access configuration
+  projects:
+    - key: "DEV"
+      name: "Development"
+      permissions: ["read", "write", "transition", "assign"]
+      issue_types: ["Story", "Bug", "Task", "Subtask"]
+      
+    - key: "OPS"
+      name: "Operations"  
+      permissions: ["read", "comment", "watch"]
+      
+  # Custom field mappings
+  custom_fields:
+    story_points: "customfield_10002"
+    epic_link: "customfield_10014"
+    sprint: "customfield_10020"
+    
+  # Workflow automation
+  automation:
+    auto_transition:
+      enabled: true
+      rules:
+        - from_status: "To Do"
+          to_status: "In Progress"
+          condition: "assignee_changed"
+          
+    auto_assign:
+      enabled: true
+      rules:
+        - issue_type: "Bug"
+          component: "Frontend"
+          assignee: "frontend-team-lead"
+          
+  # Security and compliance
+  security:
+    encrypt_fields: ["description", "comment"]
+    mask_sensitive_data: true
+    audit_changes: true
+    
+  compliance:
+    gdpr_compliant: true
+    data_retention_policy: "365_days"
+    audit_log_retention: "7_years"
+```
+
+### Slack Enterprise Grid Integration
+
+```yaml
+# slack-enterprise-config.yaml
+slack:
+  workspace_id: "T1234567890"
+  bot_token: "${SLACK_BOT_TOKEN}"
+  signing_secret: "${SLACK_SIGNING_SECRET}"
+  
+  # Channel management
+  channels:
+    notifications:
+      - name: "#dev-alerts"
+        types: ["deployments", "errors", "security"]
+      - name: "#ai-activity"
+        types: ["cline-tasks", "completions"]
+        
+    private_channels:
+      - name: "#security-incidents"
+        members: ["security-team"]
+        types: ["security-alerts", "compliance-issues"]
+        
+  # Bot behavior
+  bot:
+    display_name: "Cline Enterprise"
+    default_channel: "#general"
+    response_delay_ms: 1000
+    
+    commands:
+      - command: "/cline-status"
+        description: "Check Cline Enterprise status"
+        permission: "all"
+        
+      - command: "/cline-deploy"
+        description: "Trigger deployment"
+        permission: "admin"
+        
+  # Enterprise features
+  enterprise:
+    app_approval_required: true
+    data_residency: "US"
+    compliance_export: true
+    
+    dlp:
+      enabled: true
+      scan_messages: true
+      block_sensitive_data: true
+      
+  # Security settings
+  security:
+    require_app_approval: true
+    audit_api_calls: true
+    encrypt_messages: true
+    retain_audit_logs_days: 2555  # 7 years
+```
+
+## Enterprise Management
+
+### Multi-Environment Deployment
+
+Deploy marketplace servers across environments:
+
+```yaml
+# environments-config.yaml
+environments:
+  development:
+    marketplace_servers:
+      - github-enterprise:
+          version: "2.1.0-beta"
+          config_override:
+            github:
+              base_url: "https://github-dev.company.com/api/v3"
+              organization: "company-dev"
+              
+  staging:
+    marketplace_servers:
+      - github-enterprise:
+          version: "2.1.0-rc1"  
+          config_override:
+            github:
+              base_url: "https://github-staging.company.com/api/v3"
+              organization: "company-staging"
+              
+  production:
+    marketplace_servers:
+      - github-enterprise:
+          version: "2.1.0"
+          config_override:
+            github:
+              base_url: "https://github.company.com/api/v3"
+              organization: "company"
+```
+
+### Version Management
+
+Control marketplace server versions:
+
+```bash
+# List available versions
+cline-enterprise mcp versions github-enterprise
+
+# Upgrade to latest version
+cline-enterprise mcp upgrade github-enterprise --version 2.2.0 --environment staging
+
+# Rollback to previous version
+cline-enterprise mcp rollback github-enterprise --version 2.1.0 --environment staging
+
+# Pin to specific version (disable auto-updates)
+cline-enterprise mcp pin github-enterprise --version 2.1.0
+```
+
+### Health Monitoring
+
+Monitor marketplace server health:
+
+```yaml
+# monitoring-config.yaml
+monitoring:
+  marketplace_servers:
+    health_checks:
+      interval_seconds: 30
+      timeout_seconds: 10
+      
+    metrics:
+      - server_status
+      - request_latency
+      - error_rate
+      - resource_usage
+      
+    alerts:
+      - name: "marketplace-server-down"
+        condition: "server_status != 1"
+        severity: "critical"
+        
+      - name: "high-error-rate"
+        condition: "error_rate > 0.05"  
+        severity: "warning"
+        
+      - name: "performance-degradation"
+        condition: "request_latency > 5s"
+        severity: "warning"
+```
+
+## Security & Compliance
+
+### Enterprise Security Features
+
+All marketplace servers include:
+
+- **Authentication Integration**: SSO, SAML, OAuth2 support
+- **Authorization Controls**: RBAC and fine-grained permissions
+- **Audit Logging**: Comprehensive activity tracking
+- **Data Encryption**: At-rest and in-transit encryption
+- **Network Security**: VPN, IP whitelisting, private endpoints
+- **Compliance**: SOC2, GDPR, HIPAA compliance frameworks
+
+### Data Governance
+
+Configure data handling policies:
+
+```yaml
+# data-governance-config.yaml
+data_governance:
+  classification:
+    public:
+      retention_days: 90
+      backup_required: false
+      
+    internal:
+      retention_days: 365
+      backup_required: true
+      encryption_required: false
+      
+    confidential:
+      retention_days: 2555  # 7 years
+      backup_required: true
+      encryption_required: true
+      audit_access: true
+      
+    restricted:
+      retention_days: 2555
+      backup_required: true  
+      encryption_required: true
+      audit_access: true
+      approval_required: true
+      
+  privacy:
+    pii_detection: true
+    pii_masking: true
+    gdpr_compliance: true
+    data_subject_requests: true
+    
+  compliance:
+    frameworks: ["SOC2", "GDPR", "CCPA", "HIPAA"]
+    audit_frequency: "quarterly"
+    certification_renewal: "annual"
+```
+
+## Best Practices
+
+### Installation
+1. **Review Permissions**: Always review required permissions before installation
+2. **Test in Staging**: Deploy to staging environment first
+3. **Configuration Validation**: Validate configuration files before deployment
+4. **Backup Current State**: Create configuration backups before changes
+5. **Monitor Deployment**: Watch health metrics during rollout
+
+### Configuration  
+1. **Environment Separation**: Use different configurations per environment
+2. **Secret Management**: Store sensitive data in secure secret stores
+3. **Version Pinning**: Pin versions for production deployments
+4. **Access Controls**: Implement least-privilege access policies
+5. **Regular Updates**: Schedule regular security and feature updates
+
+### Monitoring
+1. **Health Checks**: Monitor server health continuously
+2. **Performance Metrics**: Track latency and throughput
+3. **Error Tracking**: Alert on error rates and failure patterns
+4. **Resource Usage**: Monitor CPU, memory, and network usage
+5. **Audit Reviews**: Regular review of audit logs and access patterns
+
+## Troubleshooting
+
+### Common Issues
+
+**Installation Failures**:
+```bash
+# Check marketplace connectivity
+cline-enterprise mcp marketplace-status
+
+# Verify authentication
+cline-enterprise auth verify --service marketplace
+
+# Check installation logs
+cline-enterprise logs mcp-installer --lines 100
+```
+
+**Configuration Errors**:
+```bash
+# Validate configuration
+cline-enterprise mcp validate-config --file config.yaml
+
+# Test connectivity 
+cline-enterprise mcp test-connection github-enterprise --environment staging
+
+# Check server status
+cline-enterprise mcp status --all
+```
+
+**Performance Issues**:
+```bash
+# Check server metrics
+cline-enterprise mcp metrics github-enterprise --duration 1h
+
+# View recent error logs
+cline-enterprise logs github-enterprise --level error --lines 50
+```
+
+## Support
+
+For marketplace server issues:
+
+- **Documentation**: Check server-specific documentation in the dashboard
+- **Community**: Join the Cline Enterprise community forum
+- **Support Tickets**: Create support tickets for critical issues
+- **Professional Services**: Engage professional services for custom configurations
+
+Enterprise customers have access to dedicated support channels with SLA guarantees.

docs/enterprise-solutions/configuration/infrastructure-configuration/mcp/overview.mdx

@@ -0,0 +1,571 @@
+---
+title: "MCP Integration"
+sidebarTitle: "Overview"
+description: "Configure Model Context Protocol (MCP) servers and marketplace integrations for enterprise Cline deployments"
+---
+
+Model Context Protocol (MCP) provides standardized communication between AI models and external data sources, tools, and services. Enterprise MCP integration allows you to securely connect Cline to your organization's systems while maintaining governance and compliance.
+
+## Enterprise MCP Benefits
+
+<CardGroup cols={2}>
+  <Card title="Extensible Architecture" icon="puzzle-piece">
+    Connect to unlimited external tools, databases, APIs, and services through standardized MCP servers.
+  </Card>
+  
+  <Card title="Enterprise Security" icon="shield-alt">
+    Secure authentication, authorization, and audit trails for all MCP server communications.
+  </Card>
+  
+  <Card title="Centralized Management" icon="network-wired">
+    Manage and deploy MCP servers enterprise-wide with version control and configuration management.
+  </Card>
+  
+  <Card title="Compliance Ready" icon="clipboard-check">
+    Built-in logging, monitoring, and data governance for regulatory compliance requirements.
+  </Card>
+</CardGroup>
+
+## MCP Architecture Overview
+
+```mermaid
+graph TB
+    A[Cline Enterprise] --> B[MCP Hub]
+    B --> C[MCP Marketplace]
+    B --> D[Remote MCP Servers]
+    B --> E[Internal MCP Servers]
+    
+    C --> F[GitHub Integration]
+    C --> G[Slack Integration] 
+    C --> H[Jira Integration]
+    
+    D --> I[Custom APIs]
+    D --> J[Databases]
+    D --> K[Cloud Services]
+    
+    E --> L[Internal Tools]
+    E --> M[Legacy Systems]
+    E --> N[Security Systems]
+    
+    O[Enterprise Admin] --> B
+    P[Audit Logging] --> B
+    Q[Authentication] --> B
+```
+
+## Core Components
+
+<CardGroup cols={2}>
+  <Card title="MCP Marketplace" icon="store" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/mcp-marketplace">
+    Pre-built, enterprise-ready MCP servers for popular tools and services with one-click deployment.
+  </Card>
+  
+  <Card title="Remote MCP Servers" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/remote-mcp-servers">
+    Deploy and manage custom MCP servers across your infrastructure with centralized configuration.
+  </Card>
+</CardGroup>
+
+## Enterprise Configuration
+
+### Basic MCP Hub Setup
+
+Configure the central MCP hub for your enterprise deployment:
+
+```yaml
+# mcp-hub-config.yaml
+mcp:
+  hub:
+    enabled: true
+    port: 8080
+    authentication:
+      method: "enterprise-sso"
+      jwt_secret: "${MCP_JWT_SECRET}"
+      
+    # Server discovery
+    discovery:
+      methods: ["marketplace", "remote", "local"]
+      marketplace_url: "https://mcp.cline.bot/marketplace"
+      
+    # Security settings
+    security:
+      enforce_tls: true
+      allowed_origins: ["https://*.company.com"]
+      rate_limiting:
+        requests_per_minute: 1000
+        burst_size: 100
+        
+    # Audit and compliance
+    audit:
+      enabled: true
+      log_level: "INFO"
+      destinations: ["file", "syslog", "datadog"]
+      retention_days: 90
+```
+
+### Multi-Environment Configuration
+
+Deploy MCP configurations across environments:
+
+<Tabs>
+<Tab title="Development">
+```yaml
+# mcp-dev-config.yaml
+mcp:
+  environment: "development"
+  
+  servers:
+    - name: "github-dev"
+      type: "marketplace"
+      package: "@cline/mcp-github"
+      version: "latest"
+      config:
+        github_token: "${GITHUB_DEV_TOKEN}"
+        org: "company-dev"
+        
+    - name: "local-db"
+      type: "remote" 
+      url: "http://localhost:3001"
+      auth:
+        type: "api-key"
+        key: "${DEV_DB_API_KEY}"
+        
+  policies:
+    allow_experimental: true
+    auto_update: true
+    rate_limits:
+      relaxed: true
+```
+</Tab>
+
+<Tab title="Production">
+```yaml
+# mcp-prod-config.yaml
+mcp:
+  environment: "production"
+  
+  servers:
+    - name: "github-prod"
+      type: "marketplace"
+      package: "@cline/mcp-github"
+      version: "1.2.3"  # Pinned version
+      config:
+        github_token: "${GITHUB_PROD_TOKEN}"
+        org: "company"
+        
+    - name: "crm-integration"
+      type: "remote"
+      url: "https://mcp-crm.internal.company.com"
+      auth:
+        type: "mtls"
+        cert_path: "/certs/mcp-client.pem"
+        key_path: "/certs/mcp-client-key.pem"
+        
+    - name: "security-scanner"
+      type: "remote"
+      url: "https://security-mcp.company.com"
+      auth:
+        type: "oauth2"
+        client_id: "${SECURITY_CLIENT_ID}"
+        client_secret: "${SECURITY_CLIENT_SECRET}"
+        
+  policies:
+    allow_experimental: false
+    auto_update: false
+    strict_versioning: true
+    
+  monitoring:
+    metrics: true
+    health_checks: true
+    alert_on_failure: true
+```
+</Tab>
+</Tabs>
+
+## Server Management
+
+### Lifecycle Management
+
+Manage MCP server deployments with GitOps:
+
+```yaml
+# mcp-server-manifest.yaml
+apiVersion: mcp.cline.bot/v1
+kind: MCPServer
+metadata:
+  name: custom-api-server
+  namespace: cline-enterprise
+spec:
+  image: company/custom-mcp-server:v1.0.0
+  replicas: 3
+  
+  config:
+    api_endpoint: "https://api.internal.company.com"
+    timeout: 30s
+    retry_attempts: 3
+    
+  auth:
+    type: service-account
+    service_account: mcp-custom-api
+    
+  resources:
+    requests:
+      memory: "256Mi"
+      cpu: "100m"
+    limits:
+      memory: "512Mi" 
+      cpu: "500m"
+      
+  monitoring:
+    enabled: true
+    metrics_port: 9090
+    health_endpoint: "/health"
+    
+  security:
+    network_policy: strict
+    pod_security_standard: restricted
+```
+
+### Configuration Management
+
+Use Helm charts for enterprise MCP deployments:
+
+```yaml
+# values-prod.yaml
+mcp:
+  hub:
+    replicaCount: 3
+    image:
+      repository: cline/mcp-hub-enterprise
+      tag: "1.5.2"
+      
+  servers:
+    marketplace:
+      enabled: true
+      catalog_url: "https://enterprise-catalog.company.com"
+      
+    custom:
+      - name: "salesforce"
+        enabled: true
+        image: "company/mcp-salesforce:1.0.0"
+        config:
+          instance_url: "https://company.my.salesforce.com"
+          
+      - name: "jira"
+        enabled: true
+        image: "company/mcp-jira:2.1.0"
+        config:
+          base_url: "https://company.atlassian.net"
+          
+  ingress:
+    enabled: true
+    className: nginx
+    annotations:
+      cert-manager.io/cluster-issuer: "letsencrypt-prod"
+    hosts:
+      - host: mcp.company.com
+        paths:
+          - path: /
+            pathType: Prefix
+    tls:
+      - secretName: mcp-tls
+        hosts:
+          - mcp.company.com
+```
+
+## Security & Governance
+
+### Authentication & Authorization
+
+Configure enterprise authentication for MCP servers:
+
+```yaml
+# mcp-auth-config.yaml
+authentication:
+  providers:
+    - name: "enterprise-sso"
+      type: "oidc"
+      issuer: "https://sso.company.com"
+      client_id: "${SSO_CLIENT_ID}"
+      client_secret: "${SSO_CLIENT_SECRET}"
+      
+    - name: "service-accounts"
+      type: "jwt"
+      signing_key: "${SERVICE_ACCOUNT_KEY}"
+      
+authorization:
+  policies:
+    - name: "developers"
+      subjects: ["group:developers"]
+      resources: ["mcp:servers:read", "mcp:servers:execute"]
+      
+    - name: "admins"
+      subjects: ["group:mcp-admins"]
+      resources: ["mcp:*"]
+      
+    - name: "security-team"
+      subjects: ["group:security"]
+      resources: ["mcp:audit:*", "mcp:servers:security-*"]
+      
+  rbac:
+    enabled: true
+    default_role: "viewer"
+```
+
+### Network Security
+
+Implement network policies for MCP communications:
+
+```yaml
+# mcp-network-policy.yaml
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: mcp-server-policy
+  namespace: cline-enterprise
+spec:
+  podSelector:
+    matchLabels:
+      app: mcp-server
+  policyTypes:
+    - Ingress
+    - Egress
+    
+  ingress:
+    - from:
+        - namespaceSelector:
+            matchLabels:
+              name: cline-enterprise
+        - podSelector:
+            matchLabels:
+              app: cline-core
+      ports:
+        - protocol: TCP
+          port: 8080
+          
+  egress:
+    # Allow DNS
+    - to: []
+      ports:
+        - protocol: UDP
+          port: 53
+    # Allow HTTPS to external APIs
+    - to: []
+      ports:
+        - protocol: TCP
+          port: 443
+```
+
+## Monitoring & Observability
+
+### Metrics Collection
+
+Configure comprehensive MCP monitoring:
+
+```yaml
+# mcp-monitoring.yaml
+monitoring:
+  metrics:
+    enabled: true
+    interval: 30s
+    
+    collectors:
+      - name: "server-health"
+        metrics:
+          - mcp_server_status
+          - mcp_server_response_time
+          - mcp_server_error_rate
+          
+      - name: "hub-performance"
+        metrics:
+          - mcp_hub_requests_total
+          - mcp_hub_request_duration
+          - mcp_hub_active_connections
+          
+      - name: "resource-usage"
+        metrics:
+          - mcp_memory_usage
+          - mcp_cpu_usage
+          - mcp_network_io
+          
+  alerts:
+    - name: "server-down"
+      condition: "mcp_server_status == 0"
+      severity: "critical"
+      notification_channels: ["pagerduty", "slack"]
+      
+    - name: "high-error-rate"
+      condition: "mcp_server_error_rate > 0.05"
+      severity: "warning"
+      notification_channels: ["slack"]
+      
+    - name: "performance-degradation"
+      condition: "mcp_server_response_time > 5s"
+      severity: "warning"
+      notification_channels: ["email"]
+```
+
+### Audit Logging
+
+Implement comprehensive audit trails:
+
+```json
+{
+  "timestamp": "2024-01-15T10:30:00Z",
+  "event_type": "mcp_server_call",
+  "user_id": "john.doe@company.com",
+  "session_id": "sess_abc123",
+  "server_name": "github-prod",
+  "method": "github.create_issue",
+  "request": {
+    "repository": "company/project",
+    "title": "Bug fix required",
+    "sensitive_data_detected": false
+  },
+  "response": {
+    "status": "success",
+    "issue_id": "12345",
+    "duration_ms": 234
+  },
+  "compliance": {
+    "data_classification": "internal",
+    "retention_required": true,
+    "pii_detected": false
+  }
+}
+```
+
+## Custom MCP Server Development
+
+### Development Framework
+
+Create custom MCP servers using the enterprise SDK:
+
+```typescript
+// custom-mcp-server.ts
+import { MCPServer, Tool, Resource } from '@cline/mcp-enterprise-sdk';
+
+class CustomAPIServer extends MCPServer {
+  constructor() {
+    super({
+      name: 'custom-api-server',
+      version: '1.0.0',
+      description: 'Custom API integration server'
+    });
+    
+    this.addTool(new DatabaseQueryTool());
+    this.addResource(new UserDataResource());
+  }
+}
+
+class DatabaseQueryTool implements Tool {
+  name = 'query_database';
+  description = 'Query the company database';
+  
+  async execute(params: any) {
+    // Implement database query logic
+    const result = await this.database.query(params.sql);
+    
+    // Audit log the query
+    await this.auditLog({
+      action: 'database_query',
+      query: params.sql,
+      user: params.user_id,
+      results_count: result.length
+    });
+    
+    return result;
+  }
+  
+  async validate(params: any): Promise<boolean> {
+    // Implement query validation
+    return params.sql && !this.containsMaliciousSQL(params.sql);
+  }
+}
+```
+
+### Deployment Pipeline
+
+Automate MCP server deployments:
+
+```yaml
+# .github/workflows/deploy-mcp-server.yml
+name: Deploy MCP Server
+on:
+  push:
+    branches: [main]
+    paths: ['mcp-servers/**']
+    
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      
+      - name: Build MCP Server
+        run: |
+          docker build -t company/mcp-server:${{ github.sha }} .
+          docker push company/mcp-server:${{ github.sha }}
+          
+      - name: Deploy to Staging
+        run: |
+          helm upgrade mcp-server-staging ./helm-chart \
+            --set image.tag=${{ github.sha }} \
+            --namespace mcp-staging
+            
+      - name: Run Integration Tests
+        run: |
+          kubectl wait --for=condition=ready pod -l app=mcp-server -n mcp-staging
+          npm run test:integration
+          
+      - name: Deploy to Production
+        if: success()
+        run: |
+          helm upgrade mcp-server-prod ./helm-chart \
+            --set image.tag=${{ github.sha }} \
+            --namespace mcp-prod
+```
+
+## Best Practices
+
+### Security
+1. **Authentication**: Always require authentication for MCP servers
+2. **Encryption**: Use TLS for all MCP communications
+3. **Validation**: Validate all inputs and sanitize outputs
+4. **Least Privilege**: Grant minimal required permissions
+5. **Audit**: Log all MCP server interactions
+
+### Performance
+1. **Caching**: Implement response caching where appropriate
+2. **Connection Pooling**: Reuse connections to external services
+3. **Async Operations**: Use non-blocking operations for I/O
+4. **Resource Limits**: Set appropriate CPU and memory limits
+5. **Load Balancing**: Scale MCP servers based on demand
+
+### Reliability
+1. **Health Checks**: Implement comprehensive health endpoints
+2. **Circuit Breakers**: Fail fast when external services are down
+3. **Retry Logic**: Implement exponential backoff for failures
+4. **Graceful Degradation**: Provide fallback behavior
+5. **Monitoring**: Set up proactive alerting and monitoring
+
+## Production Checklist
+
+Before deploying MCP servers to production:
+
+- [ ] Security review completed
+- [ ] Authentication and authorization configured
+- [ ] Network policies implemented
+- [ ] Monitoring and alerting set up
+- [ ] Audit logging enabled
+- [ ] Resource limits configured
+- [ ] Health checks implemented
+- [ ] Integration tests passing
+- [ ] Disaster recovery plan documented
+- [ ] Compliance requirements validated
+
+## Getting Started
+
+Ready to implement enterprise MCP integration? Start with:
+
+1. [MCP Marketplace](/enterprise-solutions/configuration/infrastructure-configuration/mcp/mcp-marketplace) - Deploy pre-built integrations
+2. [Remote MCP Servers](/enterprise-solutions/configuration/infrastructure-configuration/mcp/remote-mcp-servers) - Configure custom servers
+3. Review our [MCP Development Guide](/mcp/mcp-overview) for building custom integrations

docs/enterprise-solutions/configuration/infrastructure-configuration/overview.mdx

@@ -0,0 +1,95 @@
+---
+title: "Self-Hosted Configuration"
+sidebarTitle: "Overview"
+description: "Deploy and configure Cline on your own infrastructure with enterprise-grade security and compliance"
+---
+
+<Warning>
+**Self-Hosted Configuration Path**
+
+This section is for enterprises deploying **self-hosted Cline infrastructure** with complex security, compliance, and multi-environment requirements. Configuration is done through YAML files, Kubernetes/Helm deployments, and infrastructure-as-code.
+
+**Looking for simple setup?** See [SaaS Provider Configuration](/enterprise-solutions/configuration/remote-configuration/overview) for quick configuration through the app.cline.bot admin console - no infrastructure deployment required, just web-based settings.
+</Warning>
+
+Self-Hosted Configuration provides centralized control over all aspects of your Cline deployment on your own infrastructure, from AI providers to custom workflows. This section covers how to configure, manage, and optimize your enterprise Cline installation with advanced security, compliance, and operational features.
+
+## Configuration Categories
+
+<CardGroup cols={2}>
+  <Card title="Providers" icon="cloud" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/overview">
+    Configure AI providers including AWS Bedrock, LiteLLM, and Google Vertex AI with enterprise-grade security and governance.
+  </Card>
+  
+  <Card title="MCP Integration" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/mcp/overview">
+    Manage Model Context Protocol servers, marketplace integrations, and remote MCP server configurations.
+  </Card>
+  
+  <Card title="Rules Engine" icon="shield-check" href="/enterprise-solutions/configuration/infrastructure-configuration/rules">
+    Define and enforce enterprise governance rules, security policies, and compliance requirements.
+  </Card>
+  
+  <Card title="Workflows" icon="workflow" href="/enterprise-solutions/configuration/infrastructure-configuration/workflows">
+    Create automated workflows for development processes, approval chains, and integration pipelines.
+  </Card>
+</CardGroup>
+
+## Advanced Controls
+
+<CardGroup cols={2}>
+  <Card title="Control Other Cline Features" icon="toggles" href="/enterprise-solutions/configuration/infrastructure-configuration/control-other-cline-features/overview">
+    Enable or disable specific Cline features across your organization with granular permission controls.
+  </Card>
+  
+  <Card title="Monitoring" icon="chart-line" href="/enterprise-solutions/monitoring/overview">
+    Configure OpenTelemetry integration for comprehensive monitoring, logging, and analytics.
+  </Card>
+</CardGroup>
+
+## Getting Started
+
+1. **Assessment**: Review your current infrastructure and integration requirements
+2. **Provider Setup**: Configure your preferred AI providers with enterprise credentials
+3. **Security Configuration**: Implement rules and access controls
+4. **Monitoring Setup**: Enable telemetry and monitoring for operational visibility
+5. **User Onboarding**: Deploy configurations to your development teams
+
+## Enterprise Architecture Considerations
+
+### Security & Compliance
+- **Zero Trust Architecture**: All configurations support zero-trust security models
+- **Audit Logging**: Complete audit trails for all configuration changes
+- **Role-Based Access**: Granular permissions for different administrative roles
+- **Data Sovereignty**: Keep sensitive data within your infrastructure boundaries
+
+### Scalability & Performance
+- **Multi-Region Support**: Deploy configurations across multiple geographic regions  
+- **Load Balancing**: Distribute AI provider requests across multiple endpoints
+- **Caching Strategies**: Optimize performance with intelligent caching
+- **Rate Limiting**: Prevent abuse with configurable rate limits
+
+### Integration & Automation
+- **GitOps Integration**: Version control your configurations alongside code
+- **CI/CD Pipeline Integration**: Automate configuration deployment
+- **Webhook Support**: React to configuration changes with custom automation
+- **API-First Design**: Programmatically manage all configurations
+
+## Configuration Management
+
+All enterprise configurations support:
+
+- **Version Control**: Track changes with full revision history
+- **Environment Promotion**: Deploy configurations from dev → staging → production
+- **Rollback Capabilities**: Quickly revert problematic configurations
+- **Configuration Validation**: Automated testing of configuration changes
+- **Drift Detection**: Monitor and alert on configuration drift
+
+## Next Steps
+
+Ready to configure your enterprise deployment? Start with:
+
+1. [Provider Configuration](/enterprise-solutions/configuration/infrastructure-configuration/providers/overview) - Set up your AI providers
+2. [Security Rules](/enterprise-solutions/configuration/infrastructure-configuration/rules) - Implement governance policies
+3. [Monitoring Setup](/enterprise-solutions/monitoring/overview) - Enable operational visibility
+
+For hands-on configuration assistance, contact your Cline Enterprise support team or refer to our implementation guides.

docs/enterprise-solutions/configuration/infrastructure-configuration/providers/aws-bedrock/overview.mdx

@@ -0,0 +1,182 @@
+---
+title: "AWS Bedrock Configuration"
+sidebarTitle: "AWS Bedrock"
+description: "Configure AWS Bedrock for your Cline deployment"
+---
+
+<Info>
+**Configuration Path: Self-Hosted**
+
+This guide covers Bedrock configuration for self-hosted deployments. For simple web-based setup, see [AWS Bedrock SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration).
+</Info>
+
+Configure Cline to use AWS Bedrock for enterprise access to Claude and other foundation models through Amazon's managed service.
+
+## Configuration Format
+
+Configure Bedrock through your remote configuration JSON using the `providerSettings.AwsBedrock` section:
+
+```json
+{
+  "providerSettings": {
+    "AwsBedrock": {
+      "models": [
+        {
+          "id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+          "name": "Claude 3.5 Sonnet"
+        }
+      ],
+      "awsRegion": "us-east-1"
+    }
+  }
+}
+```
+
+## Configuration Fields
+
+| Field | Type | Description | Required |
+|-------|------|-------------|----------|
+| `models` | Array | List of model configurations | Yes |
+| `awsRegion` | String | AWS region (e.g., `us-east-1`) | Yes |
+| `awsUseCrossRegionInference` | Boolean | Enable cross-region inference | No |
+| `awsUseGlobalInference` | Boolean | Enable global inference routing | No |
+| `awsBedrockUsePromptCache` | Boolean | Enable prompt caching | No |
+| `awsBedrockEndpoint` | String | Custom Bedrock endpoint URL | No |
+| `customModels` | Array | Custom model configurations | No |
+
+### Model Configuration
+
+Each model in the `models` array requires:
+
+```json
+{
+  "id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+  "name": "Claude 3.5 Sonnet",
+  "info": {
+    "maxTokens": 8192,
+    "contextWindow": 200000,
+    "supportsImages": true,
+    "supportsPromptCache": true
+  }
+}
+```
+
+## Common Model IDs
+
+| Model ID | Description | Context Window |
+|----------|-------------|----------------|
+| `anthropic.claude-3-5-sonnet-20241022-v2:0` | Latest Claude Sonnet | 200K tokens |
+| `anthropic.claude-3-5-haiku-20241022-v1:0` | Latest Claude Haiku | 200K tokens |
+| `anthropic.claude-3-opus-20240229-v1:0` | Claude Opus | 200K tokens |
+
+<Note>
+Model availability varies by region. See [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) for region-specific model availability.
+</Note>
+
+## Example Configurations
+
+### Basic Configuration
+
+```json
+{
+  "providerSettings": {
+    "AwsBedrock": {
+      "models": [
+        {
+          "id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+          "name": "Claude 3.5 Sonnet"
+        }
+      ],
+      "awsRegion": "us-east-1"
+    }
+  }
+}
+```
+
+### With Prompt Caching
+
+```json
+{
+  "providerSettings": {
+    "AwsBedrock": {
+      "models": [
+        {
+          "id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+          "name": "Claude 3.5 Sonnet"
+        }
+      ],
+      "awsRegion": "us-east-1",
+      "awsBedrockUsePromptCache": true
+    }
+  }
+}
+```
+
+### Multiple Models
+
+```json
+{
+  "providerSettings": {
+    "AwsBedrock": {
+      "models": [
+        {
+          "id": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+          "name": "Claude 3.5 Sonnet"
+        },
+        {
+          "id": "anthropic.claude-3-5-haiku-20241022-v1:0",
+          "name": "Claude 3.5 Haiku"
+        }
+      ],
+      "awsRegion": "us-east-1"
+    }
+  }
+}
+```
+
+## Prerequisites
+
+Before configuring Cline to use Bedrock, you need:
+
+1. **AWS Account** with Bedrock access enabled
+2. **IAM Permissions** for Bedrock API calls (`bedrock:InvokeModel`, `bedrock:InvokeModelWithResponseStream`)
+3. **Model Access** enabled for desired models in the Bedrock console
+4. **AWS Credentials** configured (IAM role, access keys, or AWS profile)
+
+<Tip>
+For AWS account setup and IAM configuration, see the [AWS Bedrock documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html).
+</Tip>
+
+## Troubleshooting
+
+**"Access Denied" Errors**
+
+Ensure your AWS credentials have the required Bedrock permissions. See [AWS IAM documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html) for permission requirements.
+
+**"Model Not Found" Errors**
+
+Verify model access is enabled in the AWS Bedrock console and the model is available in your configured region.
+
+**High Latency**
+
+Consider using a region closer to your users or enabling cross-region inference for better performance.
+
+## Related Resources
+
+<CardGroup cols={2}>
+  <Card title="AWS Bedrock Docs" icon="book" href="https://docs.aws.amazon.com/bedrock/">
+    Complete AWS Bedrock documentation
+  </Card>
+  
+  <Card title="Model Access" icon="key" href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html">
+    How to enable model access
+  </Card>
+  
+  <Card title="IAM Permissions" icon="shield" href="https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html">
+    Required IAM permissions
+  </Card>
+  
+  <Card title="Pricing" icon="dollar-sign" href="https://aws.amazon.com/bedrock/pricing/">
+    AWS Bedrock pricing details
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/providers/custom.mdx

@@ -0,0 +1,254 @@
+---
+title: "Custom Provider Configuration"
+sidebarTitle: "Custom Providers"
+description: "Configure custom OpenAI-compatible providers for your Cline deployment"
+---
+
+<Info>
+**Configuration Path: Self-Hosted**
+
+This guide covers custom provider configuration for self-hosted deployments.
+</Info>
+
+Configure Cline to use any OpenAI-compatible API provider, including Azure OpenAI, self-hosted inference servers, and other third-party services.
+
+## What are Custom Providers?
+
+Custom providers include any API that implements the OpenAI API format:
+
+- **Azure OpenAI Service**: Microsoft's managed OpenAI models
+- **vLLM**: Self-hosted inference server
+- **Ollama**: Local model runner
+- **Text Generation Inference (TGI)**: Hugging Face's inference server
+- **LocalAI**: Local OpenAI API replacement
+- **Other OpenAI-compatible APIs**: Any custom implementation
+
+## Configuration Format
+
+Configure custom providers through your remote configuration JSON using the `providerSettings.OpenAiCompatible` section:
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "https://your-api.company.com/v1"
+    }
+  }
+}
+```
+
+## Configuration Fields
+
+| Field | Type | Description | Required |
+|-------|------|-------------|----------|
+| `models` | Array | List of model configurations | Yes |
+| `openAiBaseUrl` | String | API endpoint base URL | Yes |
+| `openAiApiKey` | String | API key for authentication | No |
+| `openAiModelId` | String | Default model identifier | No |
+
+### Azure OpenAI Specific Fields
+
+For Azure OpenAI, additional fields are available:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `azureApiVersion` | String | Azure API version (e.g., `2024-02-15-preview`) |
+
+## Example Configurations
+
+### Azure OpenAI
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "https://your-resource.openai.azure.com/openai/deployments/gpt-4-turbo",
+      "openAiApiKey": "your-azure-api-key",
+      "azureApiVersion": "2024-02-15-preview"
+    }
+  }
+}
+```
+
+### Self-Hosted vLLM
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "meta-llama/Llama-2-70b-chat-hf",
+          "name": "Llama 2 70B"
+        }
+      ],
+      "openAiBaseUrl": "http://vllm.company.com:8000/v1"
+    }
+  }
+}
+```
+
+### Local Ollama
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "codellama",
+          "name": "Code Llama"
+        }
+      ],
+      "openAiBaseUrl": "http://localhost:11434/v1"
+    }
+  }
+}
+```
+
+### Text Generation Inference (TGI)
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "mistralai/Mistral-7B-Instruct-v0.2",
+          "name": "Mistral 7B Instruct"
+        }
+      ],
+      "openAiBaseUrl": "http://tgi.company.com:8080/v1",
+      "openAiApiKey": "your-tgi-api-key"
+    }
+  }
+}
+```
+
+### LocalAI
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-3.5-turbo",
+          "name": "Local GPT-3.5"
+        }
+      ],
+      "openAiBaseUrl": "http://localhost:8080/v1"
+    }
+  }
+}
+```
+
+### Internal Network (No Auth)
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "custom-model",
+          "name": "Custom Model"
+        }
+      ],
+      "openAiBaseUrl": "http://internal.api:8000/v1"
+    }
+  }
+}
+```
+
+## Model Configuration
+
+Each model requires basic information:
+
+```json
+{
+  "id": "model-identifier",
+  "name": "Display Name",
+  "info": {
+    "maxTokens": 4096,
+    "contextWindow": 128000,
+    "supportsImages": true,
+    "supportsPromptCache": false
+  }
+}
+```
+
+## Prerequisites
+
+Before configuring a custom provider, you need:
+
+1. **API Endpoint**: URL of your OpenAI-compatible API
+2. **API Key** (if required): Authentication credentials
+3. **Model IDs**: Names of available models
+4. **Network Access**: Connectivity from where Cline is being used
+
+## Troubleshooting
+
+**Connection Errors**
+
+Verify the endpoint is accessible:
+```bash
+curl https://your-api.company.com/v1/models
+```
+
+**Authentication Errors**
+
+Test authentication with your API key:
+```bash
+curl -H "Authorization: Bearer your-api-key" \
+  https://your-api.company.com/v1/models
+```
+
+**Model Not Found**
+
+Ensure the model ID in your configuration matches what the API expects. Check available models:
+```bash
+curl -H "Authorization: Bearer your-api-key" \
+  https://your-api.company.com/v1/models
+```
+
+**Timeout Issues**
+
+If responses are slow:
+- Check network latency
+- Verify server has adequate resources
+- Consider using faster models
+
+## Provider Documentation
+
+For setup and deployment of these services, see their official documentation:
+
+<CardGroup cols={2}>
+  <Card title="Azure OpenAI" icon="microsoft" href="https://learn.microsoft.com/en-us/azure/ai-services/openai/">
+    Microsoft's managed OpenAI service
+  </Card>
+  
+  <Card title="vLLM" icon="server" href="https://docs.vllm.ai/">
+    High-performance inference engine
+  </Card>
+  
+  <Card title="Ollama" icon="download" href="https://ollama.ai/">
+    Run models locally
+  </Card>
+  
+  <Card title="Text Generation Inference" icon="code" href="https://huggingface.co/docs/text-generation-inference/">
+    Hugging Face inference server
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/providers/google-vertex/overview.mdx

@@ -0,0 +1,185 @@
+---
+title: "Google Vertex AI Configuration"
+sidebarTitle: "Google Vertex"
+description: "Configure Google Vertex AI for your Cline deployment"
+---
+
+<Info>
+**Configuration Path: Self-Hosted**
+
+This guide covers Vertex AI configuration for self-hosted deployments. For simple web-based setup, see [Google Vertex SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration).
+</Info>
+
+Configure Cline to use Google Vertex AI for enterprise access to Gemini and other Google AI models through Google Cloud Platform.
+
+## Configuration Format
+
+Configure Vertex AI through your remote configuration JSON using the `providerSettings.Vertex` section:
+
+```json
+{
+  "providerSettings": {
+    "Vertex": {
+      "models": [
+        {
+          "id": "claude-3-5-sonnet-v2@20241022",
+          "name": "Claude 3.5 Sonnet"
+        }
+      ],
+      "vertexProjectId": "my-project-id",
+      "vertexRegion": "us-central1"
+    }
+  }
+}
+```
+
+## Configuration Fields
+
+| Field | Type | Description | Required |
+|-------|------|-------------|----------|
+| `models` | Array | List of model configurations | Yes |
+| `vertexProjectId` | String | Google Cloud project ID | Yes |
+| `vertexRegion` | String | GCP region (e.g., `us-central1`) | Yes |
+
+### Model Configuration
+
+Each model in the `models` array requires:
+
+```json
+{
+  "id": "claude-3-5-sonnet-v2@20241022",
+  "name": "Claude 3.5 Sonnet",
+  "info": {
+    "maxTokens": 8192,
+    "contextWindow": 200000,
+    "supportsImages": true,
+    "supportsPromptCache": true
+  }
+}
+```
+
+## Common Model IDs
+
+| Model ID | Description | Context Window |
+|----------|-------------|----------------|
+| `claude-3-5-sonnet-v2@20241022` | Claude 3.5 Sonnet | 200K tokens |
+| `claude-3-5-haiku@20241022` | Claude 3.5 Haiku | 200K tokens |
+| `claude-3-opus@20240229` | Claude 3 Opus | 200K tokens |
+| `gemini-2.0-flash-exp` | Gemini Flash (experimental) | 1M tokens |
+| `gemini-1.5-pro-002` | Gemini Pro | 2M tokens |
+| `gemini-1.5-flash-002` | Gemini Flash | 1M tokens |
+
+<Note>
+Model availability varies by region. See [Vertex AI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models) for region-specific model availability.
+</Note>
+
+## Example Configurations
+
+### Basic Configuration
+
+```json
+{
+  "providerSettings": {
+    "Vertex": {
+      "models": [
+        {
+          "id": "claude-3-5-sonnet-v2@20241022",
+          "name": "Claude 3.5 Sonnet"
+        }
+      ],
+      "vertexProjectId": "my-company-prod",
+      "vertexRegion": "us-central1"
+    }
+  }
+}
+```
+
+### Multiple Models
+
+```json
+{
+  "providerSettings": {
+    "Vertex": {
+      "models": [
+        {
+          "id": "claude-3-5-sonnet-v2@20241022",
+          "name": "Claude 3.5 Sonnet"
+        },
+        {
+          "id": "gemini-1.5-pro-002",
+          "name": "Gemini Pro"
+        }
+      ],
+      "vertexProjectId": "my-company-prod",
+      "vertexRegion": "us-central1"
+    }
+  }
+}
+```
+
+### With Extended Thinking
+
+```json
+{
+  "providerSettings": {
+    "Vertex": {
+      "models": [
+        {
+          "id": "claude-3-5-sonnet-v2@20241022",
+          "name": "Claude 3.5 Sonnet",
+          "thinkingBudgetTokens": 1600
+        }
+      ],
+      "vertexProjectId": "my-company-prod",
+      "vertexRegion": "us-central1"
+    }
+  }
+}
+```
+
+## Prerequisites
+
+Before configuring Cline to use Vertex AI, you need:
+
+1. **Google Cloud Project** with Vertex AI API enabled
+2. **Service Account** with Vertex AI User role (`roles/aiplatform.user`)
+3. **Service Account Credentials** configured for authentication
+4. **Model Access** verified in your project and region
+
+<Tip>
+For Google Cloud setup and authentication configuration, see the [Vertex AI documentation](https://cloud.google.com/vertex-ai/docs/generative-ai/start/quickstarts/quickstart-multimodal).
+</Tip>
+
+## Troubleshooting
+
+**"Permission Denied" Errors**
+
+Ensure your service account has the required Vertex AI permissions. See [Google Cloud IAM documentation](https://cloud.google.com/vertex-ai/docs/general/access-control) for permission requirements.
+
+**"API Not Enabled" Errors**
+
+Verify the Vertex AI API is enabled in your Google Cloud project.
+
+**"Model Not Found" Errors**
+
+Check that the model is available in your configured region and that your project has access to it.
+
+## Related Resources
+
+<CardGroup cols={2}>
+  <Card title="Vertex AI Docs" icon="book" href="https://cloud.google.com/vertex-ai/docs">
+    Complete Vertex AI documentation
+  </Card>
+  
+  <Card title="Service Accounts" icon="key" href="https://cloud.google.com/iam/docs/service-accounts">
+    Service account best practices
+  </Card>
+  
+  <Card title="Model Guide" icon="brain" href="https://cloud.google.com/vertex-ai/docs/generative-ai/learn/models">
+    Available models and features
+  </Card>
+  
+  <Card title="Pricing" icon="dollar-sign" href="https://cloud.google.com/vertex-ai/pricing">
+    Vertex AI pricing details
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/providers/litellm/overview.mdx

@@ -0,0 +1,215 @@
+---
+title: "LiteLLM Configuration"
+sidebarTitle: "LiteLLM"
+description: "Configure LiteLLM proxy for your Cline deployment"
+---
+
+<Info>
+**Configuration Path: Self-Hosted**
+
+This guide covers LiteLLM configuration for self-hosted deployments. For web-based setup, see [LiteLLM SaaS Configuration](/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration).
+</Info>
+
+Configure Cline to use an existing LiteLLM proxy for unified access to multiple AI models through a single API endpoint.
+
+## What is LiteLLM?
+
+[LiteLLM](https://github.com/BerriAI/litellm) is an open-source proxy that provides a unified OpenAI-compatible API for accessing 100+ AI models from different providers. Cline connects to your deployed LiteLLM instance.
+
+<Note>
+LiteLLM is a separate service you deploy and manage. This guide covers how to configure Cline to connect to an existing LiteLLM deployment.
+</Note>
+
+## Configuration Format
+
+Configure LiteLLM through your remote configuration JSON using the `providerSettings.OpenAiCompatible` section:
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "https://litellm.yourcompany.com/v1"
+    }
+  }
+}
+```
+
+## Configuration Fields
+
+| Field | Type | Description | Required |
+|-------|------|-------------|----------|
+| `models` | Array | List of model configurations | Yes |
+| `openAiBaseUrl` | String | LiteLLM proxy endpoint URL | Yes |
+| `openAiApiKey` | String | API key for authentication | No |
+
+### Model Configuration
+
+Each model in the `models` array requires:
+
+```json
+{
+  "id": "gpt-4-turbo",
+  "name": "GPT-4 Turbo",
+  "info": {
+    "maxTokens": 4096,
+    "contextWindow": 128000,
+    "supportsImages": true
+  }
+}
+```
+
+<Note>
+Model IDs must match the model names configured in your LiteLLM proxy deployment.
+</Note>
+
+## Example Configurations
+
+### Basic Configuration
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "https://litellm.company.com/v1"
+    }
+  }
+}
+```
+
+### With Authentication
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "https://litellm.company.com/v1",
+      "openAiApiKey": "sk-your-litellm-key"
+    }
+  }
+}
+```
+
+### Multiple Models
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        },
+        {
+          "id": "claude-3-5-sonnet",
+          "name": "Claude 3.5 Sonnet"
+        },
+        {
+          "id": "gemini-pro",
+          "name": "Gemini Pro"
+        }
+      ],
+      "openAiBaseUrl": "https://litellm.company.com/v1",
+      "openAiApiKey": "sk-your-litellm-key"
+    }
+  }
+}
+```
+
+### Internal Network (No Auth)
+
+```json
+{
+  "providerSettings": {
+    "OpenAiCompatible": {
+      "models": [
+        {
+          "id": "gpt-4-turbo",
+          "name": "GPT-4 Turbo"
+        }
+      ],
+      "openAiBaseUrl": "http://litellm.internal:4000/v1"
+    }
+  }
+}
+```
+
+## Prerequisites
+
+Before configuring Cline to use LiteLLM, you need:
+
+1. **LiteLLM Proxy** deployed and accessible
+2. **LiteLLM Configuration** with desired models enabled
+3. **API Key** (if authentication is enabled)
+4. **Network Access** from where Cline is being used
+
+<Tip>
+For LiteLLM deployment and configuration, see the [LiteLLM documentation](https://docs.litellm.ai/docs/proxy/quick_start).
+</Tip>
+
+## Troubleshooting
+
+**Connection Errors**
+
+Verify the LiteLLM proxy is running and accessible:
+```bash
+curl https://litellm.yourcompany.com/health
+```
+
+**Authentication Errors**
+
+Check your API key is valid:
+```bash
+curl -H "Authorization: Bearer sk-your-key" \
+  https://litellm.yourcompany.com/v1/models
+```
+
+**Model Not Found**
+
+Verify the model is configured in your LiteLLM deployment. Model IDs in Cline's config must match the model names in LiteLLM's configuration.
+
+## Benefits of Using LiteLLM
+
+- **Multi-Provider Access**: Connect to multiple AI providers through one endpoint
+- **Load Balancing**: Distribute requests across providers automatically
+- **Fallback Support**: Automatic retry with different models on failure
+- **Cost Tracking**: Monitor usage and costs across all models
+- **Rate Limiting**: Control usage at the proxy level
+
+## Related Resources
+
+<CardGroup cols={2}>
+  <Card title="LiteLLM Docs" icon="book" href="https://docs.litellm.ai/">
+    Complete LiteLLM documentation
+  </Card>
+  
+  <Card title="LiteLLM GitHub" icon="github" href="https://github.com/BerriAI/litellm">
+    Source code and deployment examples
+  </Card>
+  
+  <Card title="Proxy Setup" icon="server" href="https://docs.litellm.ai/docs/proxy/quick_start">
+    LiteLLM proxy deployment guide
+  </Card>
+  
+  <Card title="Supported Providers" icon="list" href="https://docs.litellm.ai/docs/providers">
+    List of supported AI providers
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/providers/overview.mdx

@@ -0,0 +1,144 @@
+---
+title: "AI Provider Configuration"
+sidebarTitle: "Overview"
+description: "Configure AI provider settings for your Cline deployment"
+---
+
+<Info>
+**Configuration Path: Self-Hosted**
+
+This section covers provider configuration for self-hosted deployments. For web-based configuration through app.cline.bot, see [SaaS Provider Configuration](/enterprise-solutions/configuration/remote-configuration/overview).
+</Info>
+
+Configure which AI providers your team can use and manage provider credentials centrally. Cline supports major AI providers with enterprise-grade authentication options.
+
+## Supported Providers
+
+<CardGroup cols={2}>
+  <Card title="AWS Bedrock" icon="aws" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/aws-bedrock">
+    Amazon's managed service for Claude and other foundation models
+  </Card>
+  
+  <Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/google-vertex">
+    Google Cloud's AI platform with Gemini and PaLM models
+  </Card>
+  
+  <Card title="LiteLLM" icon="zap" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/litellm">
+    Universal proxy for accessing 100+ AI models through a unified API
+  </Card>
+  
+  <Card title="Custom Providers" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/custom">
+    OpenAI-compatible APIs and self-hosted models
+  </Card>
+</CardGroup>
+
+## What is Provider Configuration?
+
+Provider configuration in Cline allows administrators to:
+
+1. **Manage Credentials Centrally**: Store API keys and authentication details in one place
+2. **Control Model Access**: Specify which models teams can use
+3. **Enforce Provider Usage**: Direct all team members to approved providers
+
+## How It Works
+
+Provider settings are configured through your remote configuration JSON file:
+
+```json
+{
+  "providerSettings": {
+    "provider": "bedrock",
+    "bedrockRegion": "us-east-1",
+    "bedrockServiceRole": "arn:aws:iam::..."
+  }
+}
+```
+
+When configured, these settings:
+- Apply to all team members automatically
+- Override individual user settings
+- Ensure consistent provider usage across the team
+
+## Configuration Options
+
+### Provider Selection
+
+Choose from supported providers:
+- **bedrock**: Use AWS Bedrock
+- **vertex**: Use Google Vertex AI  
+- **openai**: Use OpenAI API
+- **azure**: Use Azure OpenAI
+- **litellm**: Use a LiteLLM proxy
+
+### Authentication
+
+Each provider supports different authentication methods:
+
+**AWS Bedrock:**
+- IAM roles with cross-account access
+- Access keys (not recommended for production)
+
+**Google Vertex AI:**
+- Service account JSON keys
+- Workload Identity (for GKE deployments)
+
+**OpenAI/Azure:**
+- API keys
+
+**LiteLLM:**
+- Endpoint URL + API key
+
+## Example Configurations
+
+### AWS Bedrock with IAM Role
+```json
+{
+  "providerSettings": {
+    "provider": "bedrock",
+    "bedrockRegion": "us-east-1",
+    "bedrockServiceRole": "arn:aws:iam::123456789012:role/ClineBedrockRole"
+  }
+}
+```
+
+### Google Vertex AI
+```json
+{
+  "providerSettings": {
+    "provider": "vertex",
+    "vertexProject": "my-project-id",
+    "vertexRegion": "us-central1"
+  }
+}
+```
+
+### LiteLLM Proxy
+```json
+{
+  "providerSettings": {
+    "provider": "litellm",
+    "litellmBaseUrl": "https://litellm.company.com",
+    "litellmApiKey": "sk-..."
+  }
+}
+```
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Configure AWS Bedrock" icon="aws" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/aws-bedrock">
+    Set up AWS Bedrock integration
+  </Card>
+  
+  <Card title="Configure Google Vertex" icon="google" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/google-vertex">
+    Set up Google Vertex AI integration
+  </Card>
+  
+  <Card title="Configure LiteLLM" icon="zap" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/litellm">
+    Set up LiteLLM proxy integration
+  </Card>
+  
+  <Card title="Configure Custom Provider" icon="plug" href="/enterprise-solutions/configuration/infrastructure-configuration/providers/custom">
+    Set up custom OpenAI-compatible provider
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/rules.mdx

@@ -0,0 +1,239 @@
+---
+title: "Rules"
+sidebarTitle: "Rules"
+description: "Custom instruction files that guide Cline's behavior in your enterprise deployment"
+---
+
+Rules are custom instruction files that provide Cline with guidelines about your coding preferences, standards, and best practices. These instructions get added to Cline's context when working on tasks.
+
+## What are Rules?
+
+Rules are simple markdown files stored in a `.clinerules/` directory that contain your team's conventions, preferences, and guidelines. They help Cline understand your:
+
+- Coding style and conventions
+- Preferred libraries and frameworks
+- Architectural patterns
+- Testing strategies
+- Documentation standards
+- Communication preferences
+
+<Tip>
+Rules are just `.md` files - no complex configuration needed!
+</Tip>
+
+## Quick Example
+
+Here's a simple rule file that guides TypeScript development:
+
+```markdown
+# TypeScript Conventions
+
+## Code Style
+- Use 2-space indentation
+- Prefer `const` over `let`
+- Always use explicit return types for functions
+- Use named exports instead of default exports
+
+## Testing
+- Write unit tests for all utility functions
+- Use Vitest as the testing framework
+- Aim for 80%+ code coverage
+
+## Dependencies
+- Prefer native TypeScript features over external libraries
+- Use Zod for runtime type validation
+- Use date-fns for date manipulation
+```
+
+## Creating Rules
+
+<Tabs>
+  <Tab title="Using /newrule Command">
+    The easiest way to create a rule is with the `/newrule` command:
+    
+    1. During a conversation with Cline, type `/newrule`
+    2. Cline will analyze your conversation and preferences
+    3. It creates an appropriately named `.md` file in `.clinerules/`
+    
+    **Example:**
+    ```
+    /newrule
+    
+    Based on our conversation, create a rule for React component structure
+    ```
+  </Tab>
+  
+  <Tab title="Manual Creation">
+    You can also create rule files manually:
+    
+    1. Create a `.clinerules/` directory in your repository root
+    2. Add markdown files with your guidelines
+    3. Use descriptive names like `react-patterns.md` or `api-conventions.md`
+    
+    **File structure:**
+    ```
+    your-repo/
+    ├── .clinerules/
+    │   ├── typescript-style.md
+    │   ├── testing-standards.md
+    │   └── code-review-checklist.md
+    └── src/
+    ```
+  </Tab>
+</Tabs>
+
+## Global vs Workspace Rules
+
+<CardGroup cols={2}>
+  <Card title="Workspace Rules" icon="folder">
+    **Location:** `.clinerules/` in your repository
+    
+    **Scope:** Specific to that project
+    
+    **Use for:** Project-specific conventions and patterns
+  </Card>
+  
+  <Card title="Global Rules" icon="globe">
+    **Location:** `Documents/Cline/` directory
+    
+    **Scope:** All your projects
+    
+    **Use for:** Personal preferences that apply everywhere
+  </Card>
+</CardGroup>
+
+## Managing Rules
+
+### Toggling Rules
+
+You can enable or disable individual rule files:
+
+1. Click the rules icon in Cline's interface
+2. Toggle rules on/off as needed
+3. Changes apply immediately to new tasks
+
+<Note>
+Disabling a rule removes it from Cline's context, but keeps the file intact. You can re-enable it anytime.
+</Note>
+
+### Enterprise Remote Rules
+
+<Info>
+Enterprise deployments can configure **remote global rules** that apply to all team members. These are managed through your infrastructure configuration and cannot be toggled off by individual developers.
+
+See [Self-Hosted Configuration](/enterprise-solutions/configuration/infrastructure-configuration/overview) for details on remote rules.
+</Info>
+
+## Compatible Formats
+
+Cline also respects rules from other AI coding tools:
+
+| File/Directory | Tool | Location |
+|----------------|------|----------|
+| `.cursorrules` | Cursor | Workspace root (single file) |
+| `.cursor/rules/` | Cursor | Workspace directory (`.mdc` files) |
+| `.windsurfrules` | Windsurf | Workspace root (single file) |
+| `AGENTS.md` | Various | Workspace root + recursive search |
+
+<Note>
+**AGENTS.md behavior:** Cline only searches for nested `AGENTS.md` files recursively if a top-level `AGENTS.md` exists in your workspace root. If found, all `AGENTS.md` files are combined with their relative paths as headers.
+</Note>
+
+These files work the same way as `.clinerules/` files and can be toggled on/off independently.
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Keep Rules Focused" icon="bullseye">
+    Each rule file should focus on one topic:
+    - ✅ `typescript-conventions.md`
+    - ✅ `react-component-structure.md`
+    - ❌ `everything-about-our-codebase.md`
+  </Accordion>
+  
+  <Accordion title="Be Specific, Not Generic" icon="crosshairs">
+    Base rules on actual team preferences, not assumptions:
+    - ✅ "We use React Query for server state management"
+    - ❌ "Use best practices for state management"
+  </Accordion>
+  
+  <Accordion title="Update Rules as Projects Evolve" icon="rotate">
+    Review and update rules periodically:
+    - When adopting new technologies
+    - After major architectural changes
+    - When team conventions evolve
+  </Accordion>
+  
+  <Accordion title="Don't Overdo It" icon="gauge-simple-high">
+    Too many rules can overwhelm Cline's context:
+    - Start with 3-5 essential rules
+    - Add more only when truly needed
+    - Remove outdated rules promptly
+  </Accordion>
+</AccordionGroup>
+
+## Example Rule Files
+
+<AccordionGroup>
+  <Accordion title="API Design Standards" icon="code">
+```markdown
+# API Design Standards
+
+## REST Conventions
+- Use plural nouns for endpoints (`/users`, not `/user`)
+- Use HTTP methods semantically (GET, POST, PUT, DELETE)
+- Return appropriate status codes
+
+## Response Format
+\`\`\`typescript
+{
+  data: T,
+  error?: string,
+  metadata?: {
+    page: number,
+    total: number
+  }
+}
+\`\`\`
+
+## Error Handling
+- Always return error messages in `error` field
+- Use 4xx for client errors, 5xx for server errors
+- Include request ID in error responses
+```
+  </Accordion>
+  
+  <Accordion title="Testing Requirements" icon="vial">
+```markdown
+# Testing Requirements
+
+## Test Organization
+- Place tests next to source files (`Button.test.tsx`)
+- Use `describe` blocks to group related tests
+- Write descriptive test names
+
+## Coverage Requirements
+- Unit tests for all utility functions
+- Integration tests for API endpoints
+- E2E tests for critical user flows
+- Minimum 80% coverage for new code
+
+## Mocking Strategy
+- Mock external API calls
+- Use test fixtures for complex data
+- Prefer dependency injection for testability
+```
+  </Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Workflows" icon="diagram-project" href="/enterprise-solutions/configuration/infrastructure-configuration/workflows">
+    Combine rules with automated workflows
+  </Card>
+  
+  <Card title="Remote Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Deploy global rules for your team
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/infrastructure-configuration/workflows.mdx

@@ -0,0 +1,324 @@
+---
+title: "Workflows"
+sidebarTitle: "Workflows"
+description: "Reusable instruction sets that can be invoked on-demand via slash commands"
+---
+
+Workflows are markdown files containing reusable instructions that you can invoke on-demand using slash commands. Think of them as "rules you can call when needed" rather than always-active guidelines.
+
+## What are Workflows?
+
+Workflows are similar to [Rules](/enterprise-solutions/configuration/infrastructure-configuration/rules), but with one key difference:
+
+<CardGroup cols={2}>
+  <Card title="Rules" icon="book">
+    **Always Active**
+    
+    Automatically applied to every task when toggled on
+    
+    Example: Coding standards, style guides
+  </Card>
+  
+  <Card title="Workflows" icon="diagram-project">
+    **On-Demand**
+    
+    Invoked only when you use the slash command
+    
+    Example: Deployment checklists, review processes
+  </Card>
+</CardGroup>
+
+<Tip>
+Workflows are just markdown files, no complex configuration needed!
+</Tip>
+
+## Quick Example
+
+Here's a simple deployment workflow:
+
+**File:** `.clinerules/workflows/deploy.md`
+
+```markdown
+# Deployment Workflow
+
+Before deploying to production, ensure:
+
+## Pre-Deployment Checklist
+1. All tests passing (unit, integration, e2e)
+2. Code review approved by 2+ engineers
+3. Staging environment tested successfully
+4. Database migrations reviewed
+5. Rollback plan documented
+
+## Deployment Steps
+1. Create deployment branch from main
+2. Run final test suite
+3. Deploy to production
+4. Monitor error rates for 30 minutes
+5. Verify key user flows
+
+## Post-Deployment
+1. Update deployment log
+2. Notify team in #deployments channel
+3. Monitor metrics for 24 hours
+```
+
+**Usage:**
+```
+/deploy
+
+I'm ready to deploy the new authentication feature
+```
+
+When invoked, Cline adds the workflow instructions to its context for that specific task.
+
+## Creating Workflows
+
+<Tabs>
+  <Tab title="Manual Creation">
+    Create workflow files in the `.clinerules/workflows/` directory:
+    
+    1. Create `.clinerules/workflows/` in your repository root
+    2. Add markdown files with your workflow instructions
+    3. Use descriptive names matching your slash command
+    
+    **File structure:**
+    ```
+    your-repo/
+    ├── .clinerules/
+    │   └── workflows/
+    │       ├── deploy.md
+    │       ├── code-review.md
+    │       └── bug-triage.md
+    └── src/
+    ```
+  </Tab>
+  
+  <Tab title="Slash Command">
+    You can also create workflows during a conversation:
+    
+    1. Have a conversation about a process you want to codify
+    2. Type `/newrule` and specify it should be a workflow
+    3. Cline creates the workflow file in `.clinerules/workflows/`
+    
+    <Note>
+    The `/newrule` command can create both rules and workflows - just specify your intent clearly.
+    </Note>
+  </Tab>
+</Tabs>
+
+## Using Workflows
+
+### Invoking Workflows
+
+Simply type `/` followed by the workflow filename (without `.md`):
+
+```
+/deploy
+/code-review  
+/bug-triage
+```
+
+The workflow instructions are added to Cline's context for the current task only.
+
+### Workflow Naming
+
+- Use lowercase with hyphens: `deploy.md`, `code-review.md`
+- Keep names short and memorable
+- Name should indicate the workflow's purpose
+
+<Warning>
+Workflow filenames become slash commands, so choose names that are easy to type and remember.
+</Warning>
+
+## Global vs Workspace Workflows
+
+<CardGroup cols={2}>
+  <Card title="Workspace Workflows" icon="folder">
+    **Location:** `.clinerules/workflows/` in your repository
+    
+    **Scope:** Specific to that project
+    
+    **Use for:** Project-specific processes and checklists
+  </Card>
+  
+  <Card title="Global Workflows" icon="globe">
+    **Location:** `Documents/Cline/Workflows/` directory
+    
+    **Scope:** All your projects
+    
+    **Use for:** Personal workflows that apply everywhere
+  </Card>
+</CardGroup>
+
+<Info>
+**Precedence:** Local workflows override global workflows if they have the same name.
+</Info>
+
+## Managing Workflows
+
+### Toggling Workflows
+
+You can enable or disable workflows:
+
+1. Click the rules icon in Cline's interface
+2. Switch to the "Workflows" tab
+3. Toggle workflows on/off as needed
+
+<Note>
+Disabling a workflow prevents it from being invoked, but keeps the file intact. The slash command won't work until you re-enable it.
+</Note>
+
+### Enterprise Remote Workflows
+
+<Info>
+Enterprise deployments can configure **remote global workflows** that are available to all team members. These are managed through your infrastructure configuration.
+
+See [Self-Hosted Configuration](/enterprise-solutions/configuration/infrastructure-configuration/overview) for details on remote workflows.
+</Info>
+
+## Example Workflows
+
+<AccordionGroup>
+  <Accordion title="Code Review Workflow" icon="code-review">
+```markdown
+# Code Review Workflow
+
+## Pre-Review Checklist
+- [ ] Code follows project style guide
+- [ ] All tests pass locally
+- [ ] No console.log or debugging code
+- [ ] Comments explain "why" not "what"
+- [ ] PR description is clear and complete
+
+## Review Focus Areas
+1. **Architecture**: Does this fit our existing patterns?
+2. **Security**: Any potential vulnerabilities?
+3. **Performance**: Any obvious bottlenecks?
+4. **Testing**: Are edge cases covered?
+5. **Documentation**: Is it clear how to use new features?
+
+## Review Response
+- Address all feedback within 24 hours
+- Mark conversations as resolved when addressed
+- Re-request review after major changes
+```
+  </Accordion>
+  
+  <Accordion title="Bug Triage Workflow" icon="bug">
+```markdown
+# Bug Triage Workflow
+
+## Information Gathering
+1. Reproduce the bug in local environment
+2. Identify affected versions/environments
+3. Check if similar issues exist
+4. Gather error logs and stack traces
+
+## Priority Assessment
+**P0 (Critical)**: Production down, data loss, security breach
+**P1 (High)**: Major feature broken, significant user impact
+**P2 (Medium)**: Minor feature broken, workaround available
+**P3 (Low)**: Cosmetic issue, minimal impact
+
+## Create Ticket
+- Use template: "Bug Report"
+- Add reproduction steps
+- Include screenshots/videos if applicable
+- Tag with affected component
+- Assign priority label
+
+## Next Steps
+- P0/P1: Immediate fix required
+- P2: Schedule for current sprint
+- P3: Add to backlog
+```
+  </Accordion>
+  
+  <Accordion title="Feature Planning Workflow" icon="lightbulb">
+```markdown
+# Feature Planning Workflow
+
+## Requirements Gathering
+1. Define the user problem we're solving
+2. List success criteria (measurable)
+3. Identify edge cases and constraints
+4. Document technical dependencies
+
+## Design Considerations
+1. How does this fit existing architecture?
+2. What data models are needed?
+3. What API changes are required?
+4. How will this impact performance?
+
+## Implementation Plan
+1. Break into smaller, shippable pieces
+2. Identify which pieces can be done in parallel
+3. Note any feature flags needed
+4. Plan for backwards compatibility
+
+## Testing Strategy
+1. What unit tests are needed?
+2. What integration tests are needed?
+3. How will we test edge cases?
+4. What manual testing is required?
+```
+  </Accordion>
+</AccordionGroup>
+
+## Best Practices
+
+<AccordionGroup>
+  <Accordion title="Keep Workflows Action-Oriented" icon="list-check">
+    Workflows should contain **actionable steps**, not general advice:
+    - ✅ "Run `npm test` and verify all tests pass"
+    - ❌ "Make sure testing is done properly"
+  </Accordion>
+  
+  <Accordion title="Use Checklists" icon="square-check">
+    Format workflows as checklists when possible:
+    - Easy to follow step-by-step
+    - Clear progress tracking
+    - Reduces missed steps
+  </Accordion>
+  
+  <Accordion title="Include Context" icon="circle-info">
+    Add **why** behind each step:
+    ```markdown
+    1. Check staging environment first
+       (Catching issues in staging prevents production incidents)
+    ```
+  </Accordion>
+  
+  <Accordion title="Version as Code" icon="code-branch">
+    Workflows live in your repository:
+    - Track changes in git
+    - Review updates in PRs
+    - Maintain history of process evolution
+  </Accordion>
+</AccordionGroup>
+
+## Workflows vs Rules: When to Use Each
+
+| Use Rules When | Use Workflows When |
+|----------------|-------------------|
+| Guidance should apply to every task | Process is invoked occasionally |
+| Standards that rarely change | Checklist for specific scenarios |
+| Always-on coding conventions | On-demand deployment processes |
+| General coding style | Specific review procedures |
+
+**Example:**
+- **Rule**: "Use TypeScript strict mode and explicit return types"
+- **Workflow**: "Follow these 10 steps when deploying to production"
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Rules" icon="book" href="/enterprise-solutions/configuration/infrastructure-configuration/rules">
+    Learn about always-active rules
+  </Card>
+  
+  <Card title="Remote Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Deploy global workflows for your team
+  </Card>
+</CardGroup>

docs/enterprise-solutions/configuration/overview.mdx

@@ -0,0 +1,97 @@
+---
+title: "Configuration Overview"
+sidebarTitle: "Overview"
+description: "Understanding enterprise configuration options for inference providers and system settings"
+---
+
+Cline offers two distinct approaches to configure inference providers and system settings for your organization. Understanding the difference between these approaches will help you choose the right configuration method for your needs.
+
+## Configuration Types
+
+<Info>
+**Need help choosing?** See the [Deployment Guide](/enterprise-solutions/configuration/choosing-your-deployment) for a detailed comparison and decision tree.
+</Info>
+
+<CardGroup cols={2}>
+  <Card title="SaaS Provider Configuration" icon="cloud" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    **Simple cloud-based setup**
+    
+    Configure inference providers through the Cline [admin console](https://app.cline.bot/dashboard). Ideal for quick organizational deployment with minimal infrastructure requirements.
+  </Card>
+  
+  <Card title="Self-Hosted Configuration" icon="server" href="/enterprise-solutions/configuration/infrastructure-configuration/overview">
+    **Advanced enterprise setup**
+    
+    Deep infrastructure integration with VPC endpoints, multi-account support, compliance features, and custom workflows on your own infrastructure.
+  </Card>
+</CardGroup>
+
+## Choosing the Right Configuration
+
+### Use SaaS Configuration When:
+- **Quick Setup**: You need to get your team up and running quickly
+- **Centralized Management**: You want simple, cloud-based provider management
+- **Standard Requirements**: Your organization has typical security and compliance needs
+- **Small to Medium Teams**: You're managing dozens to hundreds of users
+
+### Use Self-Hosted Configuration When:
+- **Enterprise Security**: You need advanced security features and compliance controls
+- **Complex Infrastructure**: You have existing AWS/GCP infrastructure to integrate with
+- **Custom Workflows**: You need custom rules, workflows, and automation
+- **Large Organizations**: You're managing hundreds to thousands of users
+- **Air-Gapped Environments**: You need on-premises or restricted network deployment
+
+## Configuration Comparison
+
+| Feature | SaaS Configuration | Self-Hosted Configuration |
+|---------|-------------------|---------------------------|
+| **Setup Complexity** | Simple | Advanced |
+| **Deployment Time** | Minutes | Days to Weeks |
+| **Infrastructure Required** | None | AWS/GCP/Azure |
+| **Compliance Features** | Basic | Advanced |
+| **Custom Rules** | No | Yes |
+| **Multi-Account Support** | No | Yes |
+| **VPC Integration** | No | Yes |
+| **Cost** | Lower | Higher |
+
+## Getting Started
+
+<Steps>
+<Step title="Evaluate Your Requirements">
+Review your organization's security, compliance, and infrastructure requirements to determine which configuration approach fits your needs.
+</Step>
+
+<Step title="Choose Your Path">
+Select either SaaS Configuration for simple setup or Self-Hosted Configuration for advanced enterprise features. Use the [Deployment Guide](/enterprise-solutions/configuration/choosing-your-deployment) if you need help deciding.
+</Step>
+
+<Step title="Follow Configuration Guide">
+Complete the setup process using the detailed guides for your chosen configuration type.
+</Step>
+
+<Step title="Onboard Team Members">
+Once configured, team members can connect using the provider-specific member guides.
+</Step>
+</Steps>
+
+---
+
+## Available Providers
+
+Both configuration approaches support the same core inference providers:
+
+<CardGroup cols={3}>
+  <Card title="AWS Bedrock" icon="aws">
+    Enterprise AI models with AWS infrastructure integration and security features.
+  </Card>
+  
+  <Card title="LiteLLM" icon="layer-group">
+    Unified proxy for accessing 100+ AI models through a single interface.
+  </Card>
+  
+  <Card title="Google Vertex AI" icon="google">
+    Google Cloud's AI platform with advanced ML capabilities and global infrastructure.
+  </Card>
+</CardGroup>
+
+The main difference lies in how these providers are configured and managed within your organization's infrastructure and security requirements.

docs/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration.mdx

@@ -4,7 +4,8 @@ sidebarTitle: "Configure AWS Bedrock (Admin)"
 description: "This guide explains how administrators configure AWS Bedrock as the organization-wide LLM provider for Cline."
 ---
 
-As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users. This centralized approach ensures consistent access to Amazon's AI models while maintaining your organization's security and compliance requirements through VPC endpoints, region controls, and prompt caching optimizations.
+
+As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Amazon's AI models while maintaining your organization's security and compliance requirements through region controls and basic configuration options.
 
 ## Before You Begin
 
@@ -13,9 +14,6 @@ To get started with setting up AWS Bedrock as your organization's LLM provider,
 **Administrator access to the Cline Admin console**  
 You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
 
-<Info>
-**Quick Check**: Try accessing the settings page now. If you can see the provider configuration options, you're good to go.
-</Info>
 
 **AWS Bedrock account with the right permissions**  
 Your AWS account needs specific Bedrock permissions to work with Cline. 

docs/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration.mdx

@@ -0,0 +1,112 @@
+---
+title: "Configure Google Vertex AI Provider (Admin)"
+sidebarTitle: "Configure Google Vertex (Admin)"
+description: "This guide explains how administrators configure Google Vertex AI as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add Google Vertex AI as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach ensures consistent access to Google's Gemini models while maintaining your organization's project boundaries and regional settings.
+
+## Before You Begin
+
+To get started with setting up Google Vertex AI as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+
+**Google Cloud Project with Vertex AI enabled**  
+You need a Google Cloud project with the Vertex AI API enabled and appropriate models accessible.
+
+<Note>
+If you haven't set up Google Cloud or Vertex AI yet, work with your cloud team to enable the Vertex AI API and ensure necessary quotas are configured.
+</Note>
+
+**Project configuration details**  
+You'll need your Google Cloud project ID and preferred region for Vertex AI model access.
+
+<Tip>
+Service accounts should have the minimum IAM permissions needed for Vertex AI access to follow security best practices.
+</Tip>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select Google Vertex AI as the API Provider">
+Open the **API Provider** dropdown menu and select **Google Vertex AI**. This will open the Vertex AI configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure Vertex AI Settings">
+The configuration panel includes settings that control how Vertex AI works for your organization:
+
+<AccordionGroup>
+<Accordion title="Project ID (required)">
+Enter your Google Cloud project ID where Vertex AI is enabled. This project will be used for all AI model requests from your organization members.
+
+<Tip>
+Use a dedicated project for AI workloads to better track usage and costs. Ensure the project has sufficient quotas for your team's expected usage.
+</Tip>
+</Accordion>
+
+<Accordion title="Region (required)">
+Select the Google Cloud region where your Vertex AI models should be accessed. Common options include `us-central1`, `us-east4`, or `europe-west4`.
+
+[View Google Cloud Regions](https://cloud.google.com/docs/geography-and-regions)
+
+<Note>
+Choose a region close to your team's location for optimal performance. Some models may not be available in all regions.
+</Note>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use Google Vertex AI with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "Google Vertex AI" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only Vertex AI as a provider
+4. Verify that Gemini models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your Google Cloud project has Vertex AI API enabled.
+
+**Project access errors**  
+Verify the project ID is correct and that Vertex AI API is enabled. Check that the project has appropriate billing configured and hasn't exceeded quotas.
+
+**Regional availability issues**  
+Confirm the selected region supports the Gemini models you want to use. Some newer models may only be available in specific regions.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change project or region later**  
+You can update these settings at any time. Members will need to ensure their local Google Cloud credentials have access to the new project/region.
+
+For further details, consult the [Google Cloud Vertex AI Documentation](https://cloud.google.com/vertex-ai/docs) and coordinate with your internal cloud team.

docs/enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration.mdx

@@ -0,0 +1,177 @@
+---
+title: "Configure Google Vertex AI in VS Code (Members)"
+sidebarTitle: "Configure Google Vertex (Member)"
+description: "Guide for engineers connecting to their organization's Google Vertex AI setup through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's Google Vertex AI setup. This guide walks you through configuring your Google Cloud credentials in VS Code so you can start using Vertex AI models through your organization's configured project and regional settings. Your administrator has already configured the provider settings—you just need to add your credentials to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's Google Vertex AI setup, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Google Cloud credentials with Vertex AI access**  
+You need Google Cloud credentials that have permission to access Vertex AI in your organization's configured project and region.
+
+<Note>
+If you're unsure which method to use, check with your administrator or IT team about how your organization has configured Google Cloud access.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area (it will display as `vertex_ai/gemini-pro` or similar)
+
+</Step>
+
+<Step title="Select Your Authentication Method">
+Choose one of the following credential methods to authenticate with Google Vertex AI:
+
+<AccordionGroup>
+<Accordion title="Service Account Key">
+Use a service account JSON key file for Vertex AI access.
+
+[Learn more about Service Account Keys](https://cloud.google.com/iam/docs/service-accounts)
+
+1. Select the **Service Account Key** authentication method
+2. Upload or paste your service account JSON key content
+3. The key should have `aiplatform.user` or similar Vertex AI permissions
+4. These credentials are stored locally and used only by the VS Code extension
+</Accordion>
+
+<Accordion title="Google Cloud SDK">
+Use the Google Cloud SDK installed on your machine with your authenticated account.
+
+[Learn more about Google Cloud SDK](https://cloud.google.com/sdk/docs/install)
+
+1. Select the **Google Cloud SDK** authentication method
+2. Ensure you've authenticated with `gcloud auth login`
+3. Verify your account has access to the organization's Vertex AI project
+4. Cline will use your default Google Cloud credentials automatically
+</Accordion>
+
+<Accordion title="Application Default Credentials">
+Use Google Cloud's application default credentials (ADC) chain.
+
+1. Select the **Application Default Credentials** method
+2. Ensure ADC is properly configured in your environment
+3. This works well for environments where Google Cloud credentials are managed centrally
+4. Cline will automatically detect credentials from your environment
+</Accordion>
+</AccordionGroup>
+
+<Note>
+The Google Cloud Project ID and Region are preconfigured by your administrator and do not need to be set in the extension.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After selecting your authentication method, the extension will display checkmarks for enabled features:
+
+- ✓ Supports images (for Gemini Pro Vision and similar models)
+- ✓ Supports multimodal inputs
+- ✓ Supports function calling (for supported models)
+
+The project ID and region settings will be locked (shown with a lock icon 🔒) as they're controlled by your administrator.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your credentials work correctly with the configured Vertex AI project and region.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity, then test multimodal capabilities if needed by sharing an image.
+</Tip>
+</Step>
+</Steps>
+
+## Model Usage
+
+### Available Model Families
+The models available through your organization's Vertex AI setup typically include:
+
+**Gemini Models:**
+- **Gemini Pro**: Advanced reasoning, code generation, and multimodal capabilities
+- **Gemini Pro Vision**: Image understanding and visual question answering
+- **Gemini Ultra**: Most capable model for complex reasoning tasks
+
+**PaLM Models:**
+- **PaLM 2 for Text**: Text generation and completion
+- **PaLM 2 for Chat**: Conversational AI interactions
+- **Codey**: Specialized for code generation and explanation
+
+**Specialized Models:**
+- **Text Embedding**: For semantic search and similarity tasks  
+- **Custom Models**: Your organization's fine-tuned variants (if available)
+
+### Model Selection Strategy
+Choose models based on your development needs:
+
+- **General tasks**: Use Gemini Pro for most text and reasoning tasks
+- **Visual content**: Use Gemini Pro Vision when working with images
+- **Code-heavy work**: Use Codey models for programming tasks
+- **Complex reasoning**: Use Gemini Ultra for sophisticated problem-solving
+- **Embedding tasks**: Use Text Embedding models for semantic operations
+
+### Multimodal Capabilities
+Take advantage of Vertex AI's multimodal features:
+
+- **Image Analysis**: Upload images directly in Cline for analysis
+- **Visual Question Answering**: Ask questions about images
+- **Code Screenshots**: Get explanations of code from screenshots
+- **Document Processing**: Analyze charts, graphs, and visual data
+
+## Troubleshooting
+
+**Google Vertex AI not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Vertex AI configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Access Denied" or "Invalid Credentials")**  
+Verify your chosen credential method has the necessary IAM permissions to access Vertex AI in the configured project and region. Required permissions include `aiplatform.endpoints.predict` and `aiplatform.models.predict`.
+
+**Project access errors**  
+Ask your administrator to confirm which Google Cloud project is configured for your organization. Ensure your Google Cloud credentials have access to that specific project.
+
+**Regional access errors**  
+Verify your credentials have access to Vertex AI in the configured region. Some models may not be available in all regions, so confirm with your administrator about the selected region.
+
+**Google Cloud SDK authentication issues**  
+Ensure Google Cloud SDK is properly installed and authenticated:
+```bash
+gcloud auth login
+gcloud config set project YOUR_PROJECT_ID
+gcloud auth application-default login
+```
+
+**Service account key errors**  
+Verify the service account key is valid and hasn't expired. Check that the service account has the proper Vertex AI permissions in your organization's project. Ensure the JSON key file is properly formatted and contains all required fields.
+
+**Model access errors or "model not found"**  
+Some models may not be enabled in your organization's project or region. Contact your administrator if specific models are not available. Verify that your organization has enabled the models you're trying to use in the Google Cloud Console.
+
+## Security Best Practices
+
+When configuring your Google Cloud credentials, follow these security guidelines:
+
+- Use service accounts with minimal required permissions for Vertex AI access
+- Rotate service account keys regularly (every 90 days recommended)
+- Never store credentials in code or version control
+- Use Google Cloud SDK where possible for better credential management
+- Consider using Workload Identity for containerized development environments
+- Report any suspicious activity or unauthorized access attempts
+
+Your organization administrator controls which models and regions are available. The extension will automatically display available models based on your project's configuration and regional availability.
+
+For more information about Google Cloud authentication and Vertex AI permissions, refer to the [Google Cloud IAM Documentation](https://cloud.google.com/iam/docs) and coordinate with your organization's cloud administrator.

docs/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration.mdx

@@ -0,0 +1,120 @@
+---
+title: "Configure LiteLLM Provider (Admin)"
+sidebarTitle: "Configure LiteLLM (Admin)"
+description: "This guide explains how administrators configure LiteLLM as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add LiteLLM as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach provides unified access to multiple AI models through your LiteLLM proxy interface.
+
+## Before You Begin
+
+To get started with setting up LiteLLM as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+<Info>
+**Quick Check**: Try accessing the settings page now. If you can see the provider configuration options, you're good to go.
+</Info>
+
+**LiteLLM proxy instance running**  
+You need a deployed LiteLLM proxy that your team can access. This can be self-hosted or managed through a cloud provider.
+
+<Note>
+If you haven't deployed LiteLLM yet, work with your infrastructure team to set up a LiteLLM proxy instance.
+</Note>
+
+**LiteLLM endpoint details**  
+You'll need the base URL of your LiteLLM proxy and optionally a master key if your deployment requires authentication.
+
+<Tip>
+Ensure your LiteLLM proxy is accessible from your team's development environments and has the models you want to make available configured.
+</Tip>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select LiteLLM as the API Provider">
+Open the **API Provider** dropdown menu and select **LiteLLM**. This will open the LiteLLM configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure LiteLLM Settings">
+The configuration panel includes settings that control how LiteLLM works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (required)">
+Enter your LiteLLM proxy endpoint URL. This should be the full URL where your LiteLLM proxy is accessible, such as `https://litellm.yourcompany.com` or `http://your-proxy:4000`.
+
+<Tip>
+Use HTTPS endpoints in production for security. Make sure the URL is accessible from your team's development environments.
+</Tip>
+</Accordion>
+
+<Accordion title="Master Key (optional)">
+If your LiteLLM proxy requires authentication, enter the master key here. This will be used to authenticate requests from all organization members.
+
+<Note>
+**Centralized API Key Management**: By configuring the Master Key at the organization level, you enable centralized API key management. Organization members won't need to manage their own individual API keys - access is fully managed through this centralized configuration.
+</Note>
+
+<Warning>
+The master key provides full access to your LiteLLM proxy. Only enter this if your proxy requires authentication and you want centralized key management.
+</Warning>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use LiteLLM with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "LiteLLM" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only LiteLLM as a provider
+4. Verify that the configured models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization and that your LiteLLM proxy is accessible from their network.
+
+**Connection errors to LiteLLM proxy**  
+Verify the Base URL is correct and accessible. Check that any firewalls or security groups allow access from your team's IP addresses or development environments.
+
+**Authentication failures**  
+If using a master key, verify it's correctly entered and has proper permissions in your LiteLLM deployment. Check the LiteLLM proxy logs for authentication errors.
+
+**Models not available**  
+Confirm the models are properly configured in your LiteLLM proxy deployment. The available models depend on how your LiteLLM proxy is configured.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change endpoint or key later**  
+You can update these settings at any time. Changes take effect immediately for all organization members.
+
+For further details about LiteLLM deployment and configuration, consult the [LiteLLM Documentation](https://docs.litellm.ai/) and coordinate with your infrastructure team.

docs/enterprise-solutions/configuration/remote-configuration/litellm/member-configuration.mdx

@@ -0,0 +1,168 @@
+---
+title: "Configure LiteLLM in VS Code (Members)"
+sidebarTitle: "Configure LiteLLM (Member)"
+description: "Guide for engineers connecting to their organization's LiteLLM proxy through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's LiteLLM proxy setup. This guide walks you through configuring your connection in VS Code so you can start using multiple AI models through your organization's unified proxy interface. Your administrator has already configured the provider settings—you just need to add your credentials to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's LiteLLM proxy, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Access credentials for your organization's LiteLLM proxy**  
+You need credentials to access your organization's LiteLLM proxy. This might be an API key, or the proxy might be configured for open access within your network.
+
+<Note>
+If you're unsure about the credentials needed, check with your administrator or IT team about how to access your organization's LiteLLM proxy.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area (it will display as `LiteLLM` or show a specific model name)
+
+</Step>
+
+<Step title="Configure LiteLLM Connection">
+The LiteLLM configuration options depend on how your organization has set up the proxy:
+
+<AccordionGroup>
+<Accordion title="API Key Authentication">
+If your organization requires API key authentication:
+
+1. Select or confirm the **LiteLLM** provider is selected
+2. Enter your assigned API key in the **API Key** field
+3. The base URL should already be configured by your administrator
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally in VS Code and are only used by the Cline extension.
+</Tip>
+</Accordion>
+
+<Accordion title="Open Access (No Authentication)">
+If your LiteLLM proxy is configured for open access within your network:
+
+1. Select or confirm the **LiteLLM** provider is selected  
+2. Leave the API key field empty
+3. The extension will connect directly to the configured proxy endpoint
+4. No additional authentication is required
+
+<Info>
+Open access is common when the LiteLLM proxy is deployed within a secure network environment.
+</Info>
+</Accordion>
+
+<Accordion title="Custom Configuration">
+If your organization uses custom authentication or specific connection parameters:
+
+1. Follow any custom instructions provided by your administrator
+2. Contact your IT team if you encounter connection issues
+3. Additional configuration may be needed outside of VS Code
+
+<Note>
+Custom configurations might require specific network settings or additional authentication steps.
+</Note>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Select Available Models">
+Once connected, you'll see the models available through your organization's LiteLLM proxy:
+
+- View available models in the model dropdown
+- Models are determined by your administrator's proxy configuration  
+- You can switch between models for different types of tasks
+- Some models may be restricted based on your access level
+
+<Tip>
+**Model Selection**
+
+Choose models based on your task requirements:
+- **Fast models** (like GPT-3.5-turbo) for quick responses
+- **Powerful models** (like GPT-4) for complex reasoning
+- **Specialized models** for code generation or specific domains
+</Tip>
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your connection works correctly with the LiteLLM proxy.
+
+<Tip>
+**Testing Recommendation**
+
+Test the connection in plan mode first to verify everything works correctly before using it for actual development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Model Usage
+
+### Available Model Categories
+The models available through your LiteLLM proxy typically include:
+
+**Text Generation Models:**
+- OpenAI GPT-4, GPT-3.5-turbo variants
+- Anthropic Claude 3 Sonnet, Haiku, Opus
+- Open source models like Llama 2, Mistral
+
+**Code-Specific Models:**
+- OpenAI GPT-4 for code
+- CodeLlama variants
+- Specialized code completion models
+
+**Multimodal Models:**
+- GPT-4 Vision for image analysis
+- Claude 3 models with vision capabilities
+
+### Model Selection Strategy
+Choose models based on your development needs:
+
+- **Quick iterations**: Use faster, cost-effective models
+- **Complex problems**: Use more powerful models  
+- **Code-heavy tasks**: Use code-specialized models
+- **Visual content**: Use multimodal models when working with images
+
+## Troubleshooting
+
+**LiteLLM not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the LiteLLM configuration and that you have the latest version of the Cline extension.
+
+**Connection errors or timeouts**  
+Verify your network can reach the LiteLLM proxy endpoint. Check with your IT team about firewall rules or VPN requirements. Ensure the proxy endpoint is accessible from your development environment.
+
+**Authentication failures**  
+If using API key authentication, verify the key is correctly entered and hasn't expired. Contact your administrator to confirm your key is active and has the proper permissions.
+
+**Models not loading or are limited**  
+The available models depend on your organization's LiteLLM configuration. Contact your administrator if you need access to specific models or if expected models aren't available.
+
+**Slow response times**  
+Response times depend on the models being used and proxy load. Try switching to faster models for routine tasks. Contact your administrator if performance is consistently poor.
+
+**Error messages from specific models**  
+Some models may be temporarily unavailable or have specific limitations. Try alternative models or contact your administrator if specific models are consistently failing.
+
+## Security Best Practices
+
+When working with your organization's LiteLLM proxy:
+
+- Keep your API credentials secure and don't share them
+- Use appropriate models for the sensitivity of your data  
+- Follow your organization's usage guidelines
+- Report any suspicious activity or unauthorized access attempts
+- Regularly update the Cline extension for security patches
+
+Your organization administrator controls which models are available and usage policies. The extension will automatically display available models based on your proxy configuration and access level.

docs/enterprise-solutions/configuration/remote-configuration/overview.mdx

@@ -0,0 +1,102 @@
+---
+title: "SaaS Provider Configuration"
+sidebarTitle: "Overview"
+description: "Configure inference providers through the Cline hosted admin console for centralized organization management"
+---
+
+
+SaaS Provider Configuration allows administrators to centrally configure inference providers for their entire organization through the Cline hosted admin console. This approach ensures consistent provider access, security policies, and cost management across all team members without requiring individual developer setup or infrastructure deployment.
+
+## How Remote Configuration Works
+
+Remote configuration operates through Cline's hosted service at [app.cline.bot](https://app.cline.bot), where administrators can:
+
+<CardGroup cols={2}>
+  <Card title="Centralized Setup" icon="gear">
+    Configure providers once for the entire organization through the web-based admin console.
+  </Card>
+  
+  <Card title="Automatic Enforcement" icon="shield-check">
+    Team members automatically receive the configured provider settings when signed into their organization.
+  </Card>
+  
+  <Card title="Simplified Onboarding" icon="user-plus">
+    New team members get instant access to inference providers without complex individual configuration.
+  </Card>
+  
+  <Card title="Consistent Experience" icon="users">
+    Ensure all team members use the same models, regions, and settings organization-wide.
+  </Card>
+</CardGroup>
+
+## Supported Providers
+
+Cline supports remote configuration for the following inference providers:
+
+| Provider | Use Case | Configuration | Member Setup |
+|----------|----------|---------------|--------------|
+| **Cline** | Organizations using Cline's native provider with centralized API key management | API provider selection, model access | No individual API keys needed - fully managed by organization |
+| **Amazon Bedrock** | Organizations using AWS infrastructure | Region selection, VPC endpoints, cross-region inference, prompt caching | AWS credential configuration in VS Code |
+| **LiteLLM** | Organizations requiring multi-model access through a unified proxy | Proxy endpoint, authentication, model routing | API key or endpoint configuration in VS Code (or centralized with Master Key) |
+| **Google Vertex AI** | Organizations using Google Cloud Platform | Project ID, region selection, model access | Service account or credential configuration in VS Code |
+
+
+## Configuration Process
+
+The typical remote configuration process follows these steps:
+
+<Steps>
+<Step title="Administrator Setup">
+Access the Cline admin console and configure the desired inference provider with organization-wide settings.
+</Step>
+
+<Step title="Automatic Distribution">
+Provider configuration is automatically distributed to all organization members signed into Cline.
+</Step>
+
+<Step title="Member Credential Setup">
+Team members add their individual credentials (API keys, AWS profiles, etc.) to connect to the configured provider.
+</Step>
+
+<Step title="Immediate Access">
+Once credentials are configured, members can immediately start using the inference provider through Cline.
+</Step>
+</Steps>
+
+## Benefits of Remote Configuration
+
+### **For Administrators**
+- **Centralized Control**: Manage all provider settings from one location
+- **Security Compliance**: Ensure consistent security policies across the organization
+- **Easy Updates**: Change provider settings organization-wide instantly
+
+### **For Team Members**  
+- **Simplified Setup**: No need to research provider configuration options
+- **Consistent Experience**: Same models and features available to everyone
+- **Quick Onboarding**: Get started immediately with pre-configured providers
+- **Focus on Development**: Spend time coding instead of configuring inference providers
+
+## Getting Started
+
+To get started with provider remote configuration:
+
+1. **Choose Your Provider**: Select the inference provider that best fits your organization's needs and existing infrastructure
+2. **Admin Configuration**: Follow the provider-specific admin configuration guide
+3. **Member Onboarding**: Have team members complete the provider-specific member configuration
+4. **Start Developing**: Begin using Cline with centrally managed inference provider access
+
+Select your provider below to begin the configuration process:
+
+<CardGroup cols={3}>
+  <Card title="Amazon Bedrock" icon="aws" href="/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration">
+    AWS-based AI models with enterprise security and compliance features.
+  </Card>
+  
+  <Card title="LiteLLM" icon="layer-group" href="/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration">
+    Unified proxy for accessing 100+ AI models through a single interface.
+  </Card>
+  
+  <Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration">
+    Google Cloud's AI platform with advanced ML capabilities and global infrastructure.
+  </Card>
+</CardGroup>

docs/enterprise-solutions/managing-members.mdx

@@ -1,63 +0,0 @@
----
-title: "Managing Members"
-sidebarTitle: "Managing Members"
-description: "A guide to adding, removing, and editing members in your enterprise organization."
----
-
-This guide covers the practical steps for adding, editing, and removing members from your enterprise dashboard. For a conceptual overview of roles and permissions, see the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions).
-
-<Frame caption="The Members Dashboard provides a central place to manage your team.">
-	<img src="https://storage.googleapis.com/cline_public_images/members-dash.png" alt="Members Dashboard" />
-</Frame>
-
-## Adding Members
-
-To invite someone to your organization, you must have an open seat available on your organization.
-
-1.  Navigate to the **Members** tab in your dashboard.
-2.  Click the **Add Members** button.
-3.  Enter one or more email addresses, separated by commas.
-4.  Select a role for the new member(s). It's best practice to start with the "Member" role unless you know they need admin privileges.
-5.  Click **Send Invitation**.
-
-Invited users will receive an email with a link to join. You can cancel a pending invitation at any time by clicking the trash icon next to the user's email in the 'Pending Invites' section.
-
-<Tip>
-  **Managing Users at Scale**
-
-  When inviting a large number of users, you can paste a comma-separated list of emails directly into the invitation field. While role changes and removals are performed individually, this bulk invitation feature helps streamline the onboarding process for entire teams.
-</Tip>
-
-<Frame caption="Adding members to your organization">
-	<img src="https://storage.googleapis.com/cline_public_images/adding-members.png" alt="Confirm Member Removal" />
-</Frame>
-
-## Editing Member Roles
-
-As your team's needs change, you can adjust member roles directly from the dashboard.
-
-- Find the member in your list.
-- Under the "Role" column, click the dropdown menu.
-- Select their new role. The change takes effect immediately.
-
-Refer to the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions) for a detailed breakdown of what each role can do.
-
-## Removing Members
-
-Removing a member immediately revokes their access to all organization-specific resources, including shared API keys and configurations.
-
-1.  Go to the **Members Dashboard**.
-2.  Find the member in the list and click the red trash icon (<Icon icon="trash" iconType="solid" />).
-3.  Confirm the removal when prompted.
-
-<Frame caption="You will be asked to confirm before a member is permanently removed.">
-	<img src="https://storage.googleapis.com/cline_public_images/remove-user.png" alt="Confirm Member Removal" />
-</Frame>
-
-## Troubleshooting Invitations
-
-If an invited user is having trouble joining, check these common issues:
-
--   **Invitation Not Received**: Ask the user to check their spam or junk mail folder. If it's not there, cancel the pending invitation and try sending it again, verifying the email address is correct.
-
--   **"Invalid Domain" Error**: The user's email address must belong to a domain that has been verified for your organization. Work with your IT administrator to ensure the necessary domains are configured.

docs/enterprise-solutions/members/managing-members.mdx

@@ -1,63 +0,0 @@
----
-title: "Managing Members"
-sidebarTitle: "Managing Members"
-description: "A guide to adding, removing, and editing members in your enterprise organization."
----
-
-This guide covers the practical steps for adding, editing, and removing members from your enterprise dashboard. For a conceptual overview of roles and permissions, see the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions).
-
-<Frame caption="The Members Dashboard provides a central place to manage your team.">
-	<img src="https://storage.googleapis.com/cline_public_images/members-dash.png" alt="Members Dashboard" />
-</Frame>
-
-## Adding Members
-
-To invite someone to your organization, you must have an open seat available on your organization.
-
-1.  Navigate to the **Members** tab in your dashboard.
-2.  Click the **Add Members** button.
-3.  Enter one or more email addresses, separated by commas.
-4.  Select a role for the new member(s). It's best practice to start with the "Member" role unless you know they need admin privileges.
-5.  Click **Send Invitation**.
-
-Invited users will receive an email with a link to join. You can cancel a pending invitation at any time by clicking the trash icon next to the user's email in the 'Pending Invites' section.
-
-<Tip>
-  **Managing Users at Scale**
-
-  When inviting a large number of users, you can paste a comma-separated list of emails directly into the invitation field. While role changes and removals are performed individually, this bulk invitation feature helps streamline the onboarding process for entire teams.
-</Tip>
-
-<Frame caption="Adding members to your organization">
-	<img src="https://storage.googleapis.com/cline_public_images/adding-members.png" alt="Confirm Member Removal" />
-</Frame>
-
-## Editing Member Roles
-
-As your team's needs change, you can adjust member roles directly from the dashboard.
-
-- Find the member in your list.
-- Under the "Role" column, click the dropdown menu.
-- Select their new role. The change takes effect immediately.
-
-Refer to the [Roles and Permissions](/enterprise-solutions/members/roles-and-permissions) for a detailed breakdown of what each role can do.
-
-## Removing Members
-
-Removing a member immediately revokes their access to all organization-specific resources, including shared API keys and configurations.
-
-1.  Go to the **Members Dashboard**.
-2.  Find the member in the list and click the red trash icon (<Icon icon="trash" iconType="solid" />).
-3.  Confirm the removal when prompted.
-
-<Frame caption="You will be asked to confirm before a member is permanently removed.">
-	<img src="https://storage.googleapis.com/cline_public_images/remove-user.png" alt="Confirm Member Removal" />
-</Frame>
-
-## Troubleshooting Invitations
-
-If an invited user is having trouble joining, check these common issues:
-
--   **Invitation Not Received**: Ask the user to check their spam or junk mail folder. If it's not there, cancel the pending invitation and try sending it again, verifying the email address is correct.
-
--   **"Invalid Domain" Error**: The user's email address must belong to a domain that has been verified for your organization. Work with your IT administrator to ensure the necessary domains are configured.

docs/enterprise-solutions/members/overview.mdx

@@ -1,27 +0,0 @@
----
-title: "Members Overview"
-sidebarTitle: "Overview"
-description: "An overview of member management in your enterprise organization."
----
-
-This section provides a comprehensive guide to managing members in your enterprise organization. Here, you'll find everything you need to know about roles, permissions, and the practical steps for adding, editing, and removing members from your dashboard.
-
-## Key Topics
-
-<CardGroup cols={2}>
-    <Card
-        title="Roles and Permissions"
-        icon="user-shield"
-        href="/enterprise-solutions/members/roles-and-permissions"
-    >
-        A detailed breakdown of the available roles and their specific permissions.
-    </Card>
-    <Card
-        title="Managing Members"
-        icon="users-gear"
-        href="/enterprise-solutions/members/managing-members"
-    >
-        A practical guide to adding, editing, and removing members from your
-        dashboard.
-    </Card>
-</CardGroup>

docs/enterprise-solutions/members/roles-and-permissions.mdx

@@ -1,83 +0,0 @@
----
-title: "Roles and Permissions"
-sidebarTitle: "Roles and Permissions"
-description: "An overview of member roles, permissions, and best practices for your enterprise organization."
----
-
-Choosing the right role for each member is crucial for maintaining security and ensuring your team can work effectively. This guide provides a detailed breakdown of the available roles, their specific permissions, and best practices for managing your organization.
-
-## Role Definitions
-
-Here’s a summary of the available roles and their intended use cases.
-
-<CardGroup cols={1}>
-  <Card title="Owner" icon="user-crown">
-    **Best for:** The primary account holder or a small number of designated leaders.
-
-    Owners have unrestricted access to all settings, including billing, member management, and security configurations. To maintain tight control over the organization, the number of Owners should be kept to a minimum.
-  </Card>
-  <Card title="Admin" icon="user-gear">
-    **Best for:** Team leads or IT administrators who need to manage users and configurations.
-
-    Admins can invite, edit, and remove members, as well as manage provider configurations. They have broad access but cannot manage billing or change the Owner. This is a suitable role for trusted team managers.
-  </Card>
-  <Card title="Member" icon="user">
-    **Best for:** Most developers and individual contributors.
-
-    Members can use Cline with the organization's shared resources but cannot change any settings or view other users' activity. This is the safest default role for new users.
-  </Card>
-</CardGroup>
-
-## Permissions Matrix
-
-For a detailed comparison, this matrix outlines the specific capabilities of each role.
-
-| Permission                  | Member | Admin  | Owner  |
-| --------------------------- | :----: | :----: | :----: |
-| **General Usage**           |        |        |        |
-| Use Cline                   |   ✅   |   ✅   |   ✅   |
-| Access Shared API Providers |   ✅   |   ✅   |   ✅   |
-|                             |        |        |        |
-| **Member Management**       |        |        |        |
-| View Members                |   ❌   |   ✅   |   ✅   |
-| Invite New Members          |   ❌   |   ✅   |   ✅   |
-| Edit Member Roles           |   ❌   |   ✅   |   ✅   |
-| Remove Members              |   ❌   |   ✅   |   ✅   |
-| Remove Admins               |   ❌   |   ❌   |   ✅   |
-|                             |        |        |        |
-| **Configuration**           |        |        |        |
-| Configure API Providers     |   ❌   |   ✅   |   ✅   |
-| Manage Security Settings    |   ❌   |   ❌   |   ✅   |
-|                             |        |        |        |
-| **Billing & Ownership**     |        |        |        |
-| View Billing Information    |   ❌   |   ❌   |   ✅   |
-| Manage Subscription         |   ❌   |   ❌   |   ✅   |
-| Transfer Ownership          |   ❌   |   ❌   |   ✅   |
-
-## Role Management Best Practices
-
-Effective role management is fundamental to securing your organization.
-
--   **Apply the Principle of Least Privilege**: Always assign the role with the minimum necessary permissions. Most users should be **Members**. Grant **Admin** rights only to those who are responsible for user management or technical configuration.
-
--   **Limit the Number of Owners**: The **Owner** role should be reserved for one or two key individuals who control the account and billing. This centralization of power prevents accidental or malicious changes to critical settings.
-
--   **Regularly Audit Roles**: Periodically review the list of Admins and Owners to ensure the assigned roles are still appropriate. When a team member's responsibilities change, adjust their role accordingly.
-
-## Identity Providers and Domain Verification
-
-For a user to successfully join and sign in to your organization, two conditions must be met:
-1.  Their email must be managed by your organization's verified **Identity Provider (IDP)**, such as Microsoft Entra ID, Okta, or AWS.
-2.  Your organization must have a **verified domain** with a provider like Google or Microsoft.
-
-This ensures that only authenticated users from your company can access your Cline organization.
-
-## Seat Management and Invitations
-
-Each user in your organization, regardless of role, consumes one seat from your license.
-
--   When an invitation is sent, a seat is considered "pending."
--   If an invited user does not accept, the invitation can be revoked to free up the seat.
--   Removing a member from the organization immediately frees up a seat.
-
-Now that you understand the different roles and how to manage them, you can proceed to [configuring provider remote access](/enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration) for your organization.

docs/enterprise-solutions/monitoring/opentelemetry.mdx

@@ -0,0 +1,266 @@
+---
+title: "OpenTelemetry Integration"
+sidebarTitle: "OpenTelemetry"
+description: "Export Cline telemetry to your observability platform using OpenTelemetry Protocol (OTLP)"
+---
+
+Cline includes opt-in OpenTelemetry support for exporting metrics and logs to your own observability infrastructure using the OpenTelemetry Protocol (OTLP).
+
+<Note>
+OpenTelemetry integration is **optional** and intended for advanced users with existing observability infrastructure. Most users won't need this feature.
+</Note>
+
+## What is OpenTelemetry?
+
+[OpenTelemetry](https://opentelemetry.io/) is an industry-standard observability framework that provides a unified way to collect and export telemetry data (metrics, logs, and traces).
+
+Cline's OpenTelemetry support allows you to:
+- Export telemetry to your own systems
+- Integrate with observability platforms like Datadog, New Relic, Grafana Cloud, etc.
+- Maintain full control over your monitoring data
+- Use your organization's existing monitoring infrastructure
+
+## Supported Features
+
+Cline supports OpenTelemetry's **OTLP (OpenTelemetry Protocol)** export with:
+
+<CardGroup cols={2}>
+  <Card title="Metrics Export" icon="chart-bar">
+    Export metrics about Cline usage, performance, and errors
+  </Card>
+  
+  <Card title="Logs Export" icon="file-lines">
+    Export structured logs for debugging and analysis
+  </Card>
+</CardGroup>
+
+### Export Formats
+
+Cline supports three OTLP export protocols:
+
+- **gRPC** (default, recommended)
+- **HTTP/protobuf**
+- **HTTP/JSON**
+
+### Export Destinations
+
+You can export to:
+- **Console** (for testing)
+- **OTLP endpoint** (your own collector or observability platform)
+
+## Configuration
+
+OpenTelemetry is configured using environment variables before launching Cline.
+
+### Basic Setup
+
+Enable OpenTelemetry and configure an OTLP endpoint:
+
+```bash
+# Enable OpenTelemetry
+export OTEL_TELEMETRY_ENABLED=1
+
+# Configure metrics and logs export
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_LOGS_EXPORTER=otlp
+
+# Set your OTLP endpoint
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://your-collector:4317
+
+# Optional: Set protocol (default is grpc)
+export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+```
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OTEL_TELEMETRY_ENABLED` | Enable OpenTelemetry (`1` or `true`) | Disabled |
+| `OTEL_METRICS_EXPORTER` | Metrics exporter type (`console`, `otlp`, or both) | None |
+| `OTEL_LOGS_EXPORTER` | Logs exporter type (`console`, `otlp`, or both) | None |
+| `OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP endpoint URL | None |
+| `OTEL_EXPORTER_OTLP_PROTOCOL` | Protocol (`grpc`, `http/protobuf`, `http/json`) | `grpc` |
+| `OTEL_EXPORTER_OTLP_INSECURE` | Allow insecure connections | `false` |
+| `OTEL_EXPORTER_OTLP_HEADERS` | Custom headers (comma-separated `key=value` pairs) | None |
+
+### Advanced Configuration
+
+**Separate endpoints for metrics and logs:**
+```bash
+export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://metrics-collector:4317
+export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=https://logs-collector:4317
+```
+
+**Custom headers for authentication:**
+```bash
+export OTEL_EXPORTER_OTLP_HEADERS="api-key=your-key,x-custom-header=value"
+```
+
+**Multiple exporters (console + OTLP):**
+```bash
+export OTEL_METRICS_EXPORTER=console,otlp
+export OTEL_LOGS_EXPORTER=console,otlp
+```
+
+**Export intervals:**
+```bash
+# Metrics export interval in milliseconds (default: 60000)
+export OTEL_METRIC_EXPORT_INTERVAL=30000
+
+# Logs batch size and timeout
+export OTEL_LOG_BATCH_SIZE=512
+export OTEL_LOG_BATCH_TIMEOUT=5000
+export OTEL_LOG_MAX_QUEUE_SIZE=2048
+```
+
+## Integration Examples
+
+### Datadog
+
+Export to Datadog using their OTLP endpoint:
+
+```bash
+export OTEL_TELEMETRY_ENABLED=1
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://api.datadoghq.com
+export OTEL_EXPORTER_OTLP_HEADERS="dd-api-key=YOUR_DD_API_KEY"
+```
+
+### New Relic
+
+Export to New Relic:
+
+```bash
+export OTEL_TELEMETRY_ENABLED=1
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net:4317
+export OTEL_EXPORTER_OTLP_HEADERS="api-key=YOUR_NEW_RELIC_LICENSE_KEY"
+```
+
+### Grafana Cloud
+
+Export to Grafana Cloud:
+
+```bash
+export OTEL_TELEMETRY_ENABLED=1
+export OTEL_METRICS_EXPORTER=otlp
+export OTEL_LOGS_EXPORTER=otlp
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp-gateway-prod-us-central-0.grafana.net/otlp
+export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Basic YOUR_BASE64_CREDENTIALS"
+```
+
+
+## Testing Configuration
+
+Test your configuration with console output before sending to a real endpoint:
+
+```bash
+# Enable console output to see what data would be exported
+export OTEL_TELEMETRY_ENABLED=1
+export OTEL_METRICS_EXPORTER=console
+export OTEL_LOGS_EXPORTER=console
+```
+
+Then launch Cline and check the console output for metrics and logs.
+
+## Troubleshooting
+
+### No Data Being Exported
+
+1. **Verify OpenTelemetry is enabled:**
+   ```bash
+   echo $OTEL_TELEMETRY_ENABLED
+   ```
+   Should output `1` or `true`
+
+2. **Check exporters are configured:**
+   ```bash
+   echo $OTEL_METRICS_EXPORTER
+   echo $OTEL_LOGS_EXPORTER
+   ```
+
+3. **Test with console exporter first:**
+   ```bash
+   export OTEL_METRICS_EXPORTER=console
+   export OTEL_LOGS_EXPORTER=console
+   ```
+
+### Connection Errors
+
+1. **Verify endpoint is accessible:**
+   ```bash
+   curl -v https://your-otlp-endpoint:4317
+   ```
+
+2. **Check if insecure mode is needed:**
+   ```bash
+   export OTEL_EXPORTER_OTLP_INSECURE=true
+   ```
+
+3. **Verify authentication headers:**
+   Double-check your API keys and authentication headers are correct
+
+### Debug Mode
+
+Enable debug logging to see detailed OpenTelemetry information:
+
+```bash
+export TEL_DEBUG_DIAGNOSTICS=true
+```
+
+This will output detailed information about:
+- Configuration being used
+- Exporters being created
+- Connection attempts
+- Export successes/failures
+
+## What Gets Exported
+
+When Opentelemetry is enabled, Cline exports:
+
+### Metrics
+- Feature usage counts
+- Task execution metrics 
+- Error rates and types
+- Performance measurements
+
+### Logs
+- System events
+- Error logs with context
+- Operational information
+
+<Warning>
+Exported data is already anonymous and doesn't include code content, file paths, or sensitive information. However, you're responsible for securing the data once exported to your systems.
+</Warning>
+
+## Limitations
+
+Current OpenTelemetry support in Cline:
+- ✅ OTLP metrics export (console, gRPC, HTTP)
+- ✅ OTLP logs export (console, gRPC, HTTP)
+- ✅ Basic configuration via environment variables
+- ❌ Distributed tracing (not yet implemented)
+- ❌ Custom instrumentation API (not yet exposed)
+- ❌ Sampling configuration (uses defaults)
+
+## Best Practices
+
+1. **Test First**: Always test with console exporter before sending to production
+2. **Secure Credentials**: Never hardcode API keys; use secure environment variable management
+3. **Monitor Costs**: Be aware of data ingestion costs with your observability platform
+4. **Start Simple**: Begin with metrics only, add logs if needed
+5. **Use Compression**: OTLP supports compression; check if your endpoint requires it
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Configure simple built-in telemetry
+  </Card>
+  
+  <Card title="OpenTelemetry Docs" icon="book" href="https://opentelemetry.io/docs/">
+    Learn more about OpenTelemetry
+  </Card>
+</CardGroup>

docs/enterprise-solutions/monitoring/overview.mdx

@@ -0,0 +1,111 @@
+---
+title: "Enterprise Monitoring"
+sidebarTitle: "Overview"
+description: "Optional telemetry and observability for your Cline deployment"
+---
+
+Cline includes optional monitoring capabilities for organizations that want to track usage and integrate with their observability infrastructure.
+
+## Monitoring Options
+
+<CardGroup cols={2}>
+  <Card title="Cline Telemetry" icon="chart-simple" href="/enterprise-solutions/monitoring/telemetry">
+    Built-in anonymous usage tracking that helps improve Cline (opt-in)
+  </Card>
+  
+  <Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Export metrics and logs to your own observability backends (advanced)
+  </Card>
+</CardGroup>
+
+## Cline Telemetry
+
+Cline includes opt-in telemetry for anonymous usage tracking:
+
+- Feature usage patterns
+- Task completion rates  
+- Error occurrences
+- Performance metrics
+
+Users can enable or disable telemetry in Cline settings. All data is anonymous and does not include code content, file paths, or sensitive information.
+
+See [Cline Telemetry](/enterprise-solutions/monitoring/telemetry) for configuration details.
+
+## OpenTelemetry Integration
+
+For advanced monitoring needs, Cline supports OpenTelemetry's OTLP (OpenTelemetry Protocol) for exporting metrics and logs to your own infrastructure.
+
+This allows you to:
+- Export telemetry to your existing observability platforms
+- Integrate with tools like Datadog, New Relic, or Grafana Cloud
+- Maintain full control over your monitoring data
+- Aggregate metrics across your organization
+
+<Note>
+OpenTelemetry integration is **optional** and requires additional configuration. Most users don't need this feature.
+</Note>
+
+See [OpenTelemetry](/enterprise-solutions/monitoring/opentelemetry) for setup instructions.
+
+## Use Cases
+
+### When to Use Cline Telemetry
+- You want to help improve Cline through anonymous usage data
+- No additional setup required
+- Suitable for most users
+
+### When to Use OpenTelemetry
+- You need granular metrics in your own systems
+- You're integrating with existing observability infrastructure
+- You want detailed logs and metrics for debugging
+- You need custom dashboards or alerting
+
+## Getting Started
+
+<Steps>
+<Step title="Choose Your Approach">
+Decide whether basic telemetry or OpenTelemetry integration fits your needs
+</Step>
+
+<Step title="Enable Telemetry">
+For basic telemetry, enable it in Cline settings. For OpenTelemetry, see the configuration guide.
+</Step>
+
+<Step title="Verify Data Collection">
+Confirm telemetry is being collected as expected
+</Step>
+</Steps>
+
+## Privacy & Security
+
+All Cline monitoring features are designed with privacy in mind:
+
+<CardGroup cols={2}>
+  <Card title="Anonymous" icon="user-secret">
+    No personal information collected
+  </Card>
+  
+  <Card title="Optional" icon="toggle-on">
+    Users can disable at any time
+  </Card>
+  
+  <Card title="Local First" icon="laptop">
+    Code never leaves your machine
+  </Card>
+  
+  <Card title="Transparent" icon="code">
+    Open source - see what's collected
+  </Card>
+</CardGroup>
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Configure Telemetry" icon="gear" href="/enterprise-solutions/monitoring/telemetry">
+    Set up basic telemetry settings
+  </Card>
+  
+  <Card title="OpenTelemetry Setup" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Advanced monitoring with OpenTelemetry
+  </Card>
+</CardGroup>

docs/enterprise-solutions/monitoring/telemetry.mdx

@@ -0,0 +1,133 @@
+---
+title: "Cline Telemetry"
+sidebarTitle: "Cline Telemetry"
+description: "Configure usage analytics and event tracking"
+---
+
+Cline includes telemetry to help understand usage patterns and improve the product. Users can control whether to share this data.
+
+## What is Cline Telemetry?
+
+Telemetry captures anonymous usage events such as:
+
+- Features used (which tools, commands, workflows)
+- Task completion rates
+- Error occurrences
+- Performance metrics
+
+<Info>
+All telemetry data is **anonymous** and does not include code content, file contents, or other sensitive information.
+</Info>
+
+## User Controls
+
+### Enabling/Disabling Cline Telemetry
+
+Individual users can control telemetry through Cline settings:
+
+1. Open Cline settings
+2. Find "Cline Telemetry" toggle
+3. Enable or disable as preferred
+
+Changes take effect immediately.
+
+### What Gets Collected
+
+When telemetry is enabled, Cline captures:
+
+<AccordionGroup>
+  <Accordion title="Feature Usage" icon="cursor-click">
+    - Tools executed (e.g., read_file, execute_command)
+    - Slash commands used
+    - Workflows triggered
+    - Settings changed
+  </Accordion>
+  
+  <Accordion title="Task Metrics" icon="tasks">
+    - Task started/completed events
+    - Mode switches (Plan/Act)
+    - Checkpoint usage
+    - Task duration
+  </Accordion>
+  
+  <Accordion title="Error Events" icon="triangle-exclamation">
+    - API failures
+    - Tool execution errors
+    - System errors
+    - Error types and frequencies
+  </Accordion>
+</AccordionGroup>
+
+### What Doesn't Get Collected
+
+Cline Telemetry **never** includes:
+
+- Your code or file contents
+- File paths or names
+- Command arguments or parameters
+- Conversation content
+- Personal information
+- API keys or credentials
+
+## Enterprise Configuration
+
+Administrators can set default telemetry state through remote configuration:
+
+```json
+{
+  "telemetryEnabled": true
+}
+```
+
+<Note>
+Even with enterprise configuration, individual users can still disable Cline Telemetry in their local settings.
+</Note>
+
+## Advanced Monitoring
+
+For organizations needing detailed monitoring, Cline supports optional OpenTelemetry integration to export telemetry data to your own observability systems.
+
+See [Enterprise Monitoring](/enterprise-solutions/monitoring/overview) for details on available monitoring options.
+
+## Privacy
+
+Cline's telemetry is designed with privacy in mind:
+
+<CardGroup cols={2}>
+  <Card title="Anonymous" icon="user-secret">
+    No personal information is collected
+  </Card>
+  
+  <Card title="Optional" icon="toggle-on">
+    Users can disable at any time
+  </Card>
+  
+  <Card title="Local First" icon="laptop">
+    Code never leaves your machine
+  </Card>
+  
+  <Card title="Transparent" icon="eye">
+    Open source - see exactly what's collected
+  </Card>
+</CardGroup>
+
+## Why Telemetry Matters
+
+Anonymous usage data helps:
+
+- **Identify bugs**: Discover issues affecting users
+- **Prioritize features**: Focus on most-used capabilities
+- **Improve performance**: Find and fix slow operations
+- **Enhance reliability**: Track and reduce error rates
+
+## Related
+
+<CardGroup cols={2}>
+  <Card title="OpenTelemetry" icon="chart-line" href="/enterprise-solutions/monitoring/opentelemetry">
+    Enterprise monitoring and observability
+  </Card>
+  
+  <Card title="Privacy" icon="shield" href="/more-info/telemetry">
+    Full telemetry documentation
+  </Card>
+</CardGroup>

docs/enterprise-solutions/onboarding.mdx

@@ -51,7 +51,7 @@ User roles are mapped automatically from your IdP:
 - **Member** in IdP → **Member** role in Cline
 
 <Info>
-    For what each role can access, see the [Roles and Permissions](./members/roles-and-permissions) page.
+    For what each role can access, see the [Roles and Permissions](/enterprise-solutions/team-management/managing-members) page.
 </Info>
 
 If needed, you can configure additional user attributes in the Cline Admin console:

docs/enterprise-solutions/overview.mdx

@@ -1,7 +1,7 @@
 ---
 title: "Cline Enterprise"
 sidebarTitle: "Overview"
-description: "Enterprise security, governance, and observability for the coding agent 3 million developers trust"
+description: "Enterprise security, governance, and observability for the coding agent millions of developers trust"
 ---
 
 Cline Enterprise brings centralized governance to the same open-source architecture that millions of developers already use. Your code stays in your environment, you use your own inference at your negotiated rates, and you get the security and observability capabilities that platform teams need for org-wide deployment.
@@ -57,10 +57,10 @@ Platform teams need central control when thousands of developers use AI. Individ
 
 Enterprise governance provides:
 - **SSO authentication**: Corporate credentials instead of personal API keys
-- **Role-based access control**: Fine-grained permissions per team and project
+- **Role-based access control**: Three-tier hierarchy (Member/Admin/Owner) with organization-scoped permissions
 - **Model and tool controls**: Govern which models and tools each team accesses
 - **Remote configuration**: Manage settings for all developers from one dashboard
-- **Full audit logging**: Every AI interaction tracked with detailed logs
+- **Usage tracking and observability**: OpenTelemetry integration for monitoring usage, costs, and performance with selective audit logging for administrative operations
 
 Configure once, deploy everywhere. Developers work how they prefer while you maintain control.
 
@@ -77,7 +77,7 @@ The same observability standards you require for production systems.
 
 ## Deployment
 
-Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments, on-premises, or air-gapped networks. Configure to work with your existing security policies and compliance requirements.
+Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments. Configure to work with your existing security policies and compliance requirements.
 
 Rolling out to your organization:
 1. Configure Cline Core to connect to your infrastructure
@@ -87,7 +87,7 @@ Rolling out to your organization:
 
 ## Next Steps
 
-- Review [security architecture](/enterprise-solutions/security-concerns)
+- Review security architecture
 - Configure [cloud provider setup](/provider-config/aws-bedrock/api-key) (AWS Bedrock, Vertex AI, Azure)
 - Set up [MCP servers](/mcp/mcp-overview) for custom tooling
 - Add [custom instructions](/features/cline-rules) for your codebase

docs/enterprise-solutions/team-management/managing-members.mdx

@@ -0,0 +1,317 @@
+---
+title: "Managing Members"
+sidebarTitle: "Managing Members"
+description: "Complete guide to managing team members, roles, and permissions in your Cline Enterprise organization"
+---
+
+Effective member management is essential for maintaining security and enabling your team to work productively. This guide covers everything you need to know about roles, permissions, and day-to-day member administration.
+
+## Understanding Roles
+
+Choose the right role for each team member to balance security with productivity. Here's what each role is designed for:
+
+<CardGroup cols={3}>
+  <Card title="Owner" icon="crown" color="#9D4EDD">
+    **Primary account holder**
+    
+    Unrestricted access to all settings including billing, security, and ownership transfer. Keep this limited to 1-2 key leaders.
+  </Card>
+  
+  <Card title="Admin" icon="user-gear" color="#7209B7">
+    **Team leads & IT managers**
+    
+    Can manage users and configure providers. Ideal for trusted managers who need operational control without billing access.
+  </Card>
+  
+  <Card title="Member" icon="user" color="#560BAD">
+    **Developers & contributors**
+    
+    Can use Cline with shared resources but cannot change settings. The safest default for most team members.
+  </Card>
+</CardGroup>
+
+## Permissions Matrix
+
+Understand exactly what each role can do with this comprehensive permissions breakdown:
+
+| Permission | Member | Admin | Owner |
+| :--- | :---: | :---: | :---: |
+| **General Usage** | | | |
+| Use Cline | ✅ | ✅ | ✅ |
+| Access Shared API Providers | ✅ | ✅ | ✅ |
+| | | | |
+| **Member Management** | | | |
+| View Members | ❌ | ✅ | ✅ |
+| Invite New Members | ❌ | ✅ | ✅ |
+| Edit Member Roles | ❌ | ✅ | ✅ |
+| Remove Members | ❌ | ✅ | ✅ |
+| Remove Admins | ❌ | ❌ | ✅ |
+| | | | |
+| **Configuration** | | | |
+| Configure API Providers | ❌ | ✅ | ✅ |
+| Manage Security Settings | ❌ | ❌ | ✅ |
+| | | | |
+| **Billing & Ownership** | | | |
+| View Billing Information | ❌ | ❌ | ✅ |
+| Manage Subscription | ❌ | ❌ | ✅ |
+| Transfer Ownership | ❌ | ❌ | ✅ |
+
+<Note>
+**Quick Reference:** Most users should be **Members**. Grant **Admin** only to those managing users or configs. Reserve **Owner** for 1-2 account leaders.
+</Note>
+
+## Member Management Tasks
+
+<Tabs>
+  <Tab title="Adding Members">
+    ### Inviting New Team Members
+    
+    1. **Navigate to Members**
+       - Go to your organization dashboard at app.cline.bot
+       - Click on "Members" in the sidebar
+    
+    2. **Send Invitation**
+       - Click "Invite Member"
+       - Enter the user's email address (must be from your verified domain)
+       - Select the appropriate role (Member, Admin, or Owner)
+       - Click "Send Invite"
+    
+    3. **Invitation Status**
+       - Invited users will receive an email with a join link
+       - Pending invitations show in your member list with "Pending" status
+       - Each pending invitation holds one seat from your license
+    
+    <Tip>
+    **Bulk Invitations:** Need to add multiple users? Contact support@cline.bot for assistance with bulk invite CSV imports.
+    </Tip>
+  </Tab>
+  
+  <Tab title="Editing Roles">
+    ### Changing Member Permissions
+    
+    1. **Locate the Member**
+       - Navigate to the Members page
+       - Find the user you want to modify
+    
+    2. **Change Role**
+       - Click the dropdown next to their current role
+       - Select the new role from the menu
+       - Confirm the change
+    
+    3. **Effective Immediately**
+       - Role changes take effect instantly
+       - The user may need to sign out and back in to see updated permissions
+    
+    <Warning>
+    **Admin to Member:** Downgrading an Admin to Member will immediately revoke their ability to manage users and configurations. Ensure they no longer need these permissions.
+    </Warning>
+  </Tab>
+  
+  <Tab title="Removing Members">
+    ### Offboarding Team Members
+    
+    1. **Access Member List**
+       - Navigate to your organization's Members page
+       - Locate the user to remove
+    
+    2. **Remove User**
+       - Click the menu icon (⋮) next to their name
+       - Select "Remove from Organization"
+       - Confirm the removal
+    
+    3. **Immediate Effects**
+       - User loses access to the organization immediately
+       - Their seat is freed and can be assigned to someone else
+       - Audit logs are preserved for compliance
+    
+    <Info>
+    **Data Retention:** Removing a member does not delete their historical activity logs. All audit trails remain intact for compliance purposes.
+    </Info>
+  </Tab>
+  
+  <Tab title="Revoking Invites">
+    ### Canceling Pending Invitations
+    
+    If an invited user hasn't accepted yet, you can revoke the invitation:
+    
+    1. Find the pending invitation in your Members list
+    2. Click "Revoke Invitation"
+    3. The seat is immediately freed for another user
+    
+    This is useful when:
+    - The wrong email was used
+    - The user no longer needs access
+    - You need to reassign the seat urgently
+  </Tab>
+</Tabs>
+
+## Identity & Access Requirements
+
+For users to successfully join your organization, two conditions must be met:
+
+<Steps>
+  <Step title="Verified Identity Provider">
+    Your organization must use a verified **Identity Provider (IDP)** such as:
+    - Microsoft Entra ID (Azure AD)
+    - Okta
+    - Google Workspace
+    - AWS IAM Identity Center
+    
+    Users must authenticate through your IDP to access the organization.
+  </Step>
+  
+  <Step title="Domain Verification">
+    Your organization must have a **verified domain**. You'll need to verify ownership of your domain through your domain provider (e.g., Google, Microsoft, Cloudflare).
+    
+    Only users with email addresses from verified domains can join.
+  </Step>
+</Steps>
+
+<Note>
+These requirements ensure that only authenticated users from your company can access your Cline organization, preventing unauthorized access.
+</Note>
+
+## Seat Management
+
+Understanding how seats work helps you manage your license effectively:
+
+<AccordionGroup>
+  <Accordion title="How Seats Are Calculated" icon="chair">
+    - Each user (Owner, Admin, or Member) consumes **one seat**
+    - Pending invitations also hold one seat
+    - Removing a member or revoking an invite immediately frees the seat
+    - Your license determines the maximum number of seats available
+  </Accordion>
+  
+  <Accordion title="When Seats Are Used" icon="user-plus">
+    A seat is consumed when:
+    - You send an invitation (marked as "pending")
+    - An invited user accepts and joins
+    - An existing user is granted access through SSO
+  </Accordion>
+  
+  <Accordion title="Freeing Up Seats" icon="user-minus">
+    To free a seat:
+    - Remove an active member from the organization
+    - Revoke a pending invitation
+    - Wait for a pending invite to expire (if configured)
+  </Accordion>
+  
+  <Accordion title="Upgrading Your License" icon="arrow-up">
+    Need more seats?
+    - **Teams Plan:** Contact your account manager or visit app.cline.bot/settings/billing to upgrade your license.
+    - **Enterprise Plan:** Includes unlimited seats with no per-user restrictions.
+  </Accordion>
+</AccordionGroup>
+
+## Security Best Practices
+
+Follow these guidelines to maintain a secure organization:
+
+<CardGroup cols={2}>
+  <Card title="Principle of Least Privilege" icon="shield-check">
+    Always assign the minimum role necessary. Most users should be Members. Only grant Admin or Owner privileges when required for job duties.
+  </Card>
+  
+  <Card title="Limit Owner Roles" icon="user-lock">
+    Keep Owners to 1-2 key individuals who manage billing and security. This centralization prevents accidental or malicious changes to critical settings.
+  </Card>
+  
+  <Card title="Regular Audits" icon="clipboard-check">
+    Review your member list quarterly. Remove inactive users promptly and verify that Admin/Owner roles are still appropriate for each user.
+  </Card>
+  
+  <Card title="Offboarding Process" icon="door-open">
+    Create a standard offboarding checklist: remove from Cline, revoke IDP access, document in audit log, and reassign any critical responsibilities.
+  </Card>
+</CardGroup>
+
+<Warning>
+**Owner Accountability:** Since Owners control billing and can transfer ownership, choose these individuals carefully and document the selection in your organization's security policies.
+</Warning>
+
+## Advanced Scenarios
+
+<AccordionGroup>
+  <Accordion title="Transferring Ownership" icon="exchange">
+    Only the current Owner can transfer ownership:
+    
+    1. Navigate to Organization Settings
+    2. Go to the "Ownership" section
+    3. Select the new Owner from the member list
+    4. Confirm the transfer with your authentication
+    5. The new Owner receives immediate control
+    
+    **Important:** This action cannot be undone by the previous Owner. The new Owner must initiate a reverse transfer if needed.
+  </Accordion>
+  
+  <Accordion title="Managing Multiple Admins" icon="users-gear">
+    When you have multiple Admins:
+    
+    - Document each Admin's area of responsibility
+    - Use audit logs to track configuration changes
+    - Consider creating rotation schedules for large teams
+    - Establish escalation paths for Owner-level decisions
+  </Accordion>
+  
+  <Accordion title="Temporary Access" icon="clock">
+    For contractors or temporary staff:
+    
+    - Create them as Members with expiration calendar reminders
+    - Document their access period in your internal systems
+    - Set calendar reminders to remove them when the contract ends
+    - Consider using time-limited IDP accounts if your IDP supports it
+  </Accordion>
+</AccordionGroup>
+
+## Troubleshooting
+
+<AccordionGroup>
+  <Accordion title="User Can't Accept Invitation" icon="circle-exclamation">
+    **Common causes:**
+    - Email domain doesn't match verified domain
+    - User's IDP access hasn't been granted yet
+    - Invitation link expired
+    
+    **Solution:** Verify domain verification is complete and resend the invitation.
+  </Accordion>
+  
+  <Accordion title="Can't Remove an Admin" icon="user-slash">
+    **Cause:** Only Owners can remove Admins.
+    
+    **Solution:** Ask an Owner to perform the removal, or if you need to remove your organization's sole Owner, contact support@cline.bot.
+  </Accordion>
+  
+  <Accordion title="Out of Seats" icon="triangle-exclamation">
+    **When you've reached your license limit:**
+    - Remove inactive members to free seats
+    - Revoke pending invitations that are no longer needed
+    - Upgrade your license to add more seats
+  </Accordion>
+</AccordionGroup>
+
+## Next Steps
+
+Now that you understand member management, proceed with configuring your organization:
+
+<CardGroup cols={2}>
+  <Card 
+    title="Configure Providers" 
+    icon="plug" 
+    href="/enterprise-solutions/configuration/choosing-your-deployment"
+  >
+    Set up API providers for your team to use
+  </Card>
+  
+  <Card 
+    title="Monitor Usage" 
+    icon="chart-line" 
+    href="/enterprise-solutions/monitoring/overview"
+  >
+    Track team activity and resource consumption
+  </Card>
+</CardGroup>
+
+<Tip>
+**Getting Started Fast?** The quickest path is: 1) Invite your team as Members, 2) Configure one API provider, 3) Let your team start using Cline. You can refine roles and settings later.
+</Tip>

docs/features/explain-changes.mdx

@@ -3,11 +3,13 @@ title: "Explain Changes"
 sidebarTitle: "Explain Changes"
 ---
 
+<Note>
+This feature is only available in **VS Code**. The diff view with inline comments requires VS Code's native diff capabilities.
+</Note>
+
+
 Explain Changes is an AI-powered code review feature that adds inline explanations to your code changes. When Cline makes modifications to your codebase, you can click a button to get streaming, contextual explanations that appear directly in VS Code's diff view.
 
-<Note>
-Explain Changes requires **[Checkpoints](/features/checkpoints)** to be enabled. Make sure to enable checkpoints in your Cline settings before using this feature.
-</Note>
 
 <Frame>
 	<video
@@ -21,6 +23,9 @@ Explain Changes requires **[Checkpoints](/features/checkpoints)** to be enabled.
 
 
 ## How It Works
+<Note>
+Explain Changes requires **[Checkpoints](/features/checkpoints)** to be enabled. Make sure to enable checkpoints in your Cline settings before using this feature.
+</Note>
 
 After Cline completes a task that involves file changes, you'll see an "Explain Changes" button alongside the "View Changes" button in the completion message. Clicking this button:
 

docs/features/hooks.mdx

@@ -1,419 +0,0 @@
----
-title: "Hooks"
-sidebarTitle: "Hooks"
-description: "Inject custom logic into Cline's workflow to validate operations, monitor tool usage, and shape AI decisions"
----
-
-Hooks let you inject custom logic into Cline's workflow at key moments. Think of them as automated checkpoints where you can validate operations before they execute, monitor tool usage as it happens, and shape how Cline makes decisions.
-
-Hooks run automatically when specific events happen during development. They receive detailed information about each operation, can block problematic actions before they cause issues, and can inject context that guides future AI decisions.
-
-The real power comes from combining these capabilities. You can:
-
-- Stop operations before they cause problems (like creating `.js` files in a TypeScript project)
-- Learn from what's happening and build up project knowledge over time
-- Monitor performance and catch issues as they emerge
-- Track everything for analytics or compliance
-- Trigger external tools or services at the right moments
-
-<Warning>
-Hooks are currently supported on macOS and Linux only. Windows support is not available.
-</Warning>
-
-## Getting Started
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/hooks.gif" alt="Hooks in action" />
-</Frame>
-
-Enabling hooks in Cline is straightforward. Here's what you need to do:
-
-<Steps>
-<Step title="Enable Hooks in Settings">
-Open Cline settings and check the **"Enable Hooks"** checkbox.
-
-You can find this setting by:
-1. Opening Cline
-2. Click the "Settings" button on the top right corner
-3. Click the "Feature" section in the left side navigation menu.
-4. Scroll down until you see the "Enable Hooks" checkbox and check it. 
-</Step>
-
-<Step title="Choose Your Hook Location">
-Decide where to place your hooks:
-
-**For personal or organization-wide hooks:**
-- Create hooks in `~/Documents/Cline/Rules/Hooks/`
-- These apply to all workspaces automatically
-
-**For project-specific hooks:**
-- Create hooks in `.clinerules/hooks/` in your project root
-- These only apply to the specific workspace
-- Commit them to version control so your team can use them too
-</Step>
-
-<Step title="Create Your First Hook">
-Hook files must have exact names with no file extensions. For example, to create a TaskStart hook:
-
-```bash
-# Create the hook file
-vim .clinerules/hooks/TaskStart
-```
-
-Add your script (must start with shebang)
-``` bash
-#!/usr/bin/env bash
-
-# Store piped input into a variable
-input=$(cat)
-
-# Dump the entire JSON payload
-echo "$input" | jq .
-
-# Get the type of a field
-echo "$input" | jq -r '.timestamp | type'
-```
-
-This example script demonstrates the key mechanics of hook input/output: reading the JSON payload from stdin with `input=$(cat)`, and using `jq` to inspect the data structure and field types that your hook receives. This helps you understand what data is available before building more complex hook logic.
-
-**Make it executable**
-
-```bash
-chmod +x .clinerules/hooks/TaskStart
-```
-</Step>
-
-<Step title="Test Your Hook">
-Start a task in Cline and verify your hook executes.
-</Step>
-</Steps>
-
-<Tip>
-Start with a simple hook that just logs information before building complex validation logic. This helps you understand the data structure and timing.
-</Tip>
-
-
-## What You Can Build
-
-Once you understand the basics, hooks open up creative possibilities:
-
-<CardGroup cols={2}>
-  <Card title="Intelligent Code Review" icon="code-branch">
-    Run linters or custom validators before files get saved. Block commits that don't pass checks. Track code quality metrics over time.
-  </Card>
-  
-  <Card title="Security Enforcement" icon="shield-halved">
-    Prevent operations that violate security policies. Detect when sensitive data might be exposed. Audit all file access for compliance.
-  </Card>
-  
-  <Card title="Development Analytics" icon="chart-line">
-    Measure how long different operations take. Identify patterns in how the AI works. Generate productivity reports from hook data.
-  </Card>
-  
-  <Card title="Integration Hub" icon="plug">
-    Connect to issue trackers when certain keywords appear. Update project management tools. Sync with external APIs at the right moments.
-  </Card>
-</CardGroup>
-
-The key is combining hooks with external tools. A hook can be the glue between Cline's workflow and the rest of your development ecosystem.
-
-
-## Hook Types
-
-Cline provides multiple hook types that let you tap into different stages of the AI workflow. They're organized into categories based on their trigger points and use cases.
-
-<Note>
-The hook names below are the exact file names you need to create. For example, to use the TaskStart hook, create a file named `TaskStart` (no file extension) in your hooks directory.
-</Note>
-
-Each hook receives base fields in addition to its specific data: `clineVersion`, `hookName`, `timestamp`, `taskId`, `workspaceRoots`, `userId`.
-
-### Tool Execution
-
-These hooks intercept and validate tool operations before and after they execute. Use them to enforce policies, track changes, and learn from operations.
-
-#### PreToolUse
-
-Runs before any tool executes. Use it to block invalid operations, validate parameters, and enforce project policies before changes happen.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "PreToolUse",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "preToolUse": {
-    "toolName": "string",
-    "parameters": {}
-  }
-}
-```
-
-#### PostToolUse
-
-Runs after a tool completes. Use it to learn from results, track performance metrics, and build project knowledge based on operations performed.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "PostToolUse",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "postToolUse": {
-    "toolName": "string",
-    "parameters": {},
-    "result": "string",
-    "success": boolean,
-    "executionTimeMs": number
-  }
-}
-```
-
-### User Interaction
-
-These hooks monitor and enhance user communication with Cline. Use them to validate input, inject context, and track interaction patterns.
-
-#### UserPromptSubmit
-
-Runs when a user sends a message to Cline. Use it to validate input, inject context based on the prompt, and track interaction patterns.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "UserPromptSubmit",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "userPromptSubmit": {
-    "prompt": "string",
-    "attachments": ["string"]
-  }
-}
-```
-
-### Task Lifecycle
-
-These hooks monitor and respond to task state changes from start to finish. Use them to track progress, restore state, and trigger workflows.
-
-#### TaskStart
-
-Runs when a new task begins. Use it to detect project type, initialize tracking, and inject initial context that shapes how Cline approaches the work.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "TaskStart",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "taskStart": {
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string",
-      "initialTask": "string"
-    }
-  }
-}
-```
-
-#### TaskResume
-
-Runs when a task resumes after interruption. Use it to restore state, refresh context, and log resumption for analytics or external system notifications.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "TaskResume",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "taskResume": {
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string"
-    },
-    "previousState": {
-      "lastMessageTs": "string",
-      "messageCount": "string",
-      "conversationHistoryDeleted": "string"
-    }
-  }
-}
-```
-
-#### TaskCancel
-
-Runs when a task is cancelled. Use it to cleanup resources, log cancellation details, and notify external systems about interrupted work.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "TaskCancel",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "taskCancel": {
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string",
-      "completionStatus": "string"
-    }
-  }
-}
-```
-
-{/*
-#### TaskComplete
-
-Runs when a task finishes successfully. Use it for final cleanup, tracking metrics, generating reports, and triggering post-task workflows.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "TaskComplete",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "taskComplete": {
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string"
-    }
-  }
-}
-```
-*/}
-
-### System Events
-
-These hooks monitor internal Cline operations and system-level events. Use them to track context usage, log system behavior, and analyze performance patterns.
-
-{/*
-#### PreCompact
-
-Runs before conversation context is truncated to fit token limits. Use it to monitor compaction frequency, log events, and track context usage patterns.
-
-**Input Fields:**
-```json
-{
-  "clineVersion": "string",
-  "hookName": "PreCompact",
-  "timestamp": "string",
-  "taskId": "string",
-  "workspaceRoots": ["string"],
-  "userId": "string",
-  "preCompact": {
-    "contextSize": number,
-    "messagesToCompact": number,
-    "compactionStrategy": "string"
-  }
-}
-```
-*/}
-
-### JSON Communication
-
-Hooks receive JSON via stdin and return JSON via stdout.
-
-**Output structure:**
-```json
-{
-  "cancel": false,
-  "contextModification": "WORKSPACE_RULES: Use TypeScript",
-  "errorMessage": "Error details if blocking"
-}
-```
-
-Your hook script can output logging or diagnostic information to stdout during execution, as long as the JSON response is the last thing written. Cline will parse only the final JSON object from stdout.
-
-For example:
-```bash
-#!/usr/bin/env bash
-echo "Processing hook..."  # This is fine
-echo "Tool: $tool_name"    # This is also fine
-# The JSON must be last:
-echo '{"cancel": false}'
-```
-
-The `cancel` field controls whether execution continues. Set it to `true` to block an action, `false` to allow it.
-
-The `contextModification` field injects text into the conversation. This affects future AI decisions, not the current one. Use prefixes like `WORKSPACE_RULES:` or `PERFORMANCE:` to help categorize the context.
-
-### Understanding Context Timing
-
-Context injection affects future decisions, not current ones. When a hook runs:
-
-1. The AI has already decided what to do
-2. The hook can block or allow it
-3. Any context gets added to the conversation
-4. The next AI request sees that context
-
-This means PreToolUse hooks are for blocking bad actions, while PostToolUse hooks are for learning from completed ones.
-
-
-## Troubleshooting
-
-### Hook Not Running
-- Ensure the "Enable Hooks" setting is checked
-- Verify the hook file is executable (`chmod +x hookname`)
-- Check the hook file has no syntax errors
-- Look for errors in VSCode's Output panel (Cline channel)
-
-### Hook Timing Out
-- Reduce complexity of the hook script
-- Avoid expensive operations (network calls, heavy computations)
-- Consider moving complex logic to a background process
-
-### Context Not Affecting Behavior
-Remember that context modifications affect future AI decisions, not the current operation. The AI's current behavior is based on the previous "API Request..." block, and your `contextModification` gets injected into the next "API Request..." block. This means if you need immediate effect, you should use PreToolUse hooks for validation and return `cancel: true` in your hook's JSON response to block Cline from continuing.
-
-When adding context, ensure your modifications are clear and actionable so the AI can understand and apply them effectively. Also check that your context isn't being truncated due to the 50KB limit, as this could prevent important information from reaching the AI.
-
-### Handling Strings with Quotes in JSON Payloads
-When your hook needs to include strings containing unescaped quote characters (`"`) in JSON output, use jq's `--arg` flag for proper escaping:
-
-```bash
-#!/usr/bin/env bash
-
-# When $output contains unescaped quote characters (")...
-output='{"foo":"bar"}'
-
-# Use the --arg flag for automatic string escaping
-jq -n --arg ctx "$output" '{cancel: false, contextModification: $ctx}'
-
-# This will result in:
-# {
-#     "cancel": false,
-#     "contextModification": "{\"foo\":\"bar\"}"
-# }
-```
-
-The `--arg` flag automatically escapes special characters, preventing JSON parsing errors when your context modification includes complex strings or nested JSON structures.
-
-<Warning>
-Hooks run with the same permissions as VS Code. They can access all workspace files and environment variables. Review hooks from untrusted sources before enabling them.
-</Warning>
-
-## Related Features
-
-Hooks complement other Cline features:
-
-- [Cline Rules](/features/cline-rules) define high-level guidance that hooks can enforce
-- [Checkpoints](/features/checkpoints) let you roll back changes if a hook didn't catch an issue
-- [Auto-Approve](/features/auto-approve) works well with hooks as safety nets for automated operations

docs/features/hooks/hook-reference.mdx

@@ -0,0 +1,437 @@
+---
+title: "Hook Reference"
+sidebarTitle: "Hook Reference"
+description: "Complete API reference for all Cline hook types, JSON schemas, and field documentation"
+---
+
+This reference provides complete technical documentation for all hook types, their JSON schemas, input/output formats, and communication protocols.
+
+## Hook Types
+
+Cline provides multiple hook types that let you tap into different stages of the AI workflow. They're organized into categories based on their trigger points and use cases.
+
+<Note>
+The hook names below are the exact file names you need to create. For example, to use the TaskStart hook, create a file named `TaskStart` (no file extension) in your hooks directory.
+</Note>
+
+Each hook receives base fields in addition to its specific data: `clineVersion`, `hookName`, `timestamp`, `taskId`, `workspaceRoots`, `userId`.
+
+### Tool Execution Hooks
+
+These hooks intercept and validate tool operations before and after they execute. Use them to enforce policies, track changes, and learn from operations.
+
+#### `PreToolUse`
+
+Triggered immediately before Cline uses any tool (see the [Cline Tools Reference Guide](/cline-tools) for all available tools). Use it to block invalid operations, validate parameters, and enforce project policies before changes happen.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "PreToolUse",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "preToolUse": {
+    "toolName": "string",
+    "parameters": {}
+  }
+}
+```
+
+**Example Usage:**
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Block creating .js files in TypeScript projects
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+if [[ "$tool_name" == "write_to_file" ]]; then
+  file_path=$(echo "$input" | jq -r '.preToolUse.parameters.path')
+  if [[ "$file_path" == *.js ]] && [[ -f "tsconfig.json" ]]; then
+    echo '{"cancel": true, "errorMessage": "JavaScript files not allowed in TypeScript project"}'
+    exit 0
+  fi
+fi
+
+echo '{"cancel": false}'
+```
+
+#### `PostToolUse`
+
+Triggered immediately after Cline uses any tool (see the [Cline Tools Reference Guide](/cline-tools) for all available tools). Use it to learn from results, track performance metrics, and build project knowledge based on operations performed.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "PostToolUse",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "postToolUse": {
+    "toolName": "string",
+    "parameters": {},
+    "result": "string",
+    "success": boolean,
+    "executionTimeMs": number
+  }
+}
+```
+
+**Example Usage:**
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Log slow operations for performance monitoring
+execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs')
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+
+if (( execution_time > 5000 )); then
+  context="PERFORMANCE: Slow operation detected - $tool_name took ${execution_time}ms"
+  echo "{\"cancel\": false, \"contextModification\": \"$context\"}"
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### User Interaction Hooks
+
+These hooks monitor and enhance user communication with Cline. Use them to validate input, inject context, and track interaction patterns.
+
+#### `UserPromptSubmit`
+
+Triggered when the user enters text into the prompt box and presses enter to start a new task, continue a completed task, or resume a cancelled task. Use it to validate input, inject context based on the prompt, and track interaction patterns.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "UserPromptSubmit",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "userPromptSubmit": {
+    "prompt": "string",
+    "attachments": ["string"]
+  }
+}
+```
+
+**Example Usage:**
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Inject coding standards context for certain keywords
+prompt=$(echo "$input" | jq -r '.userPromptSubmit.prompt')
+context=""
+
+if echo "$prompt" | grep -qi "component\|react"; then
+  context="CODING_STANDARDS: Follow React functional component patterns with proper TypeScript types"
+elif echo "$prompt" | grep -qi "api\|endpoint"; then
+  context="CODING_STANDARDS: Use consistent REST API patterns with proper error handling"
+fi
+
+if [[ -n "$context" ]]; then
+  jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### Task Lifecycle Hooks
+
+These hooks monitor and respond to task state changes from start to finish. Use them to track progress, restore state, and trigger workflows.
+
+#### `TaskStart`
+
+Triggered once at the beginning of a new task. Use it to detect project type, initialize tracking, and inject initial context that shapes how Cline approaches the work.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskStart",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskStart": {
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string",
+      "initialTask": "string"
+    }
+  }
+}
+```
+
+**Example Usage:**
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Detect project type and inject relevant context
+context=""
+
+if [[ -f "package.json" ]]; then
+  if grep -q "react" package.json; then
+    context="PROJECT_TYPE: React application detected. Follow component-based architecture."
+  elif grep -q "express" package.json; then
+    context="PROJECT_TYPE: Express.js API detected. Follow RESTful patterns."
+  else
+    context="PROJECT_TYPE: Node.js project detected."
+  fi
+elif [[ -f "requirements.txt" ]] || [[ -f "pyproject.toml" ]]; then
+  context="PROJECT_TYPE: Python project detected. Follow PEP 8 standards."
+elif [[ -f "Cargo.toml" ]]; then
+  context="PROJECT_TYPE: Rust project detected. Follow Rust conventions."
+fi
+
+if [[ -n "$context" ]]; then
+  jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+#### `TaskResume`
+
+Triggered when the user resumes a task that has been cancelled or aborted. Use it to restore state, refresh context, and log resumption for analytics or external system notifications.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskResume",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskResume": {
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    },
+    "previousState": {
+      "lastMessageTs": "string",
+      "messageCount": "string",
+      "conversationHistoryDeleted": "string"
+    }
+  }
+}
+```
+
+#### `TaskCancel`
+
+Triggered when the user cancels a task or aborts a hook execution. Use it to cleanup resources, log cancellation details, and notify external systems about interrupted work.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskCancel",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskCancel": {
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    }
+  }
+}
+```
+
+#### `TaskComplete`
+
+Triggered when Cline finishes its work and successfully executes the `attempt_completion` tool to finalize the task output. Use it to track completion metrics, generate reports, log task outcomes, and trigger completion workflows.
+
+**Input Fields:**
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskComplete",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskComplete": {
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    }
+  }
+}
+```
+
+**Example Usage:**
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Extract task metadata
+task_id=$(echo "$input" | jq -r '.taskComplete.taskMetadata.taskId // "unknown"')
+ulid=$(echo "$input" | jq -r '.taskComplete.taskMetadata.ulid // "unknown"')
+
+# Log completion
+completion_log="$HOME/.cline_completions/$(date +%Y-%m-%d).log"
+mkdir -p "$(dirname "$completion_log")"
+
+echo "$(date -Iseconds): Task $task_id completed (ULID: $ulid)" >> "$completion_log"
+
+# Provide context about completion
+context="TASK_COMPLETED: Task $task_id finished successfully. Completion logged."
+jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+```
+
+### System Events Hooks
+
+These hooks monitor internal Cline operations and system-level events. Use them to track context usage, log system behavior, and analyze performance patterns.
+
+## JSON Communication Protocol
+
+Hooks receive JSON via stdin and return JSON via stdout.
+
+### Input Format
+
+All hooks receive a JSON object through stdin with this base structure:
+
+```json
+{
+  "clineVersion": "string",
+  "hookName": "string", 
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "[hookSpecificField]": {
+    // Hook-specific data structure
+  }
+}
+```
+
+### Output Format
+
+Your hook script must output a JSON response as the final stdout content:
+
+```json
+{
+  "cancel": false,
+  "contextModification": "WORKSPACE_RULES: Use TypeScript",
+  "errorMessage": "Error details if blocking"
+}
+```
+
+**Field Descriptions:**
+
+- **`cancel`** (required): Boolean controlling whether execution continues
+  - `true`: Block the current action
+  - `false`: Allow the action to proceed
+
+- **`contextModification`** (optional): String that gets injected into the conversation
+  - Affects future AI decisions, not the current one
+  - Use clear prefixes like `WORKSPACE_RULES:`, `PERFORMANCE:`, `SECURITY:` for categorization
+  - Maximum length: 50KB
+
+- **`errorMessage`** (optional): String shown to user when `cancel` is `true`
+  - Only displayed when blocking an action
+  - Should explain why the action was blocked
+
+### Logging During Execution
+
+Your hook script can output logging or diagnostic information to stdout during execution, as long as the JSON response is the last thing written:
+
+```bash
+#!/usr/bin/env bash
+echo "Processing hook..."  # This is fine
+echo "Tool: $tool_name"    # This is also fine
+
+# The JSON must be last:
+echo '{"cancel": false}'
+```
+
+Cline will parse only the final JSON object from stdout.
+
+### Error Handling
+
+Hook execution errors don't prevent task execution - only returning `"cancel": true` can halt a task. All other errors are treated as hook failures, not reasons to abort the task.
+
+**Hook Status Display:**
+
+- **Completed** (grey): Hook executed successfully, regardless of whether it returned `"cancel": false` or no JSON output
+- **Failed** (red): Hook exited with non-zero status, output invalid JSON, or timed out. The UI displays the error details (e.g., exit code number)
+- **Aborted** (red): Hook returned `"cancel": true`, halting the task. User must manually resume the task to continue
+
+**Important:** Even when a hook fails (non-zero exit, invalid JSON, timeout), Cline continues with the task. Only `"cancel": true` stops execution.
+
+### Context Modification Timing
+
+Context injection affects future decisions, not current ones. When a hook runs:
+
+1. The AI has already decided what to do
+2. The hook can block or allow it
+3. Any context gets added to the conversation
+4. The next AI request sees that context
+
+This means:
+- **PreToolUse hooks**: Use for blocking bad actions + injecting context for next decision
+- **PostToolUse hooks**: Use for learning from completed actions
+
+### Helpful Tip: String Escaping in JSON
+
+When your hook needs to include strings containing unescaped quote characters (`"`) in JSON output, use jq's `--arg` flag for proper escaping:
+
+```bash
+#!/usr/bin/env bash
+
+# When $output contains unescaped quote characters (")...
+output='{"foo":"bar"}'
+
+# Use the --arg flag for automatic string escaping
+jq -n --arg ctx "$output" '{cancel: false, contextModification: $ctx}'
+
+# This will result in:
+# {
+#     "cancel": false,
+#     "contextModification": "{\"foo\":\"bar\"}"
+# }
+```
+
+The `--arg` flag automatically escapes special characters, preventing JSON parsing errors when your context modification includes complex strings or nested JSON structures.
+
+## Hook Execution Environment
+
+### Execution Context
+
+Hooks are executable scripts that run with the same permissions as VS Code. They have unrestricted access to:
+- The entire filesystem (any file the user can access)
+- All environment variables
+- System commands and tools
+- Network resources
+
+Hooks can perform any operation the user could perform in a terminal, including reading and writing files outside the workspace, making network requests, and executing system commands.
+
+### Security Considerations
+
+<Warning>
+Hooks run with the same permissions as VS Code. They can access all workspace files and environment variables. Review hooks from untrusted sources before enabling them.
+</Warning>
+
+### Performance Guidelines
+
+Hooks have a 30 second timeout. As long as your hook completes within this time, it can perform any operations needed, including network calls or heavy computations.
+
+### Hook Discovery
+
+Cline searches for hooks in this order:
+1. Project-specific: `.clinerules/hooks/` in workspace root
+2. User-global: `~/Documents/Cline/Hooks/`
+
+Project-specific hooks override global hooks with the same name.

docs/features/hooks/index.mdx

@@ -0,0 +1,146 @@
+---
+title: "Hooks Overview"
+sidebarTitle: "Overview"
+description: "Inject custom logic into Cline's workflow to validate operations, monitor tool usage, and shape AI decisions"
+---
+
+Hooks let you inject custom logic into Cline's workflow at key moments. Think of them as automated checkpoints where you can validate operations before they execute, monitor tool usage as it happens, and shape how Cline makes decisions.
+
+Hooks run automatically when specific events happen during development. They receive detailed information about each operation, can block problematic actions before they cause issues, and can inject context that guides future AI decisions.
+
+The real power comes from combining these capabilities. You can:
+
+- Stop operations before they cause problems (like creating `.js` files in a TypeScript project)
+- Learn from what's happening and build up project knowledge over time
+- Monitor performance and catch issues as they emerge
+- Track everything for analytics or compliance
+- Trigger external tools or services at the right moments
+
+## Getting Started
+
+<Frame>
+	<img src="https://storage.googleapis.com/cline_public_images/hooks.gif" alt="Hooks in action" />
+</Frame>
+
+<Note>
+Hooks work across all platforms: Windows, macOS, and Linux. The bash examples in this documentation work with standard shells on all platforms (including Git Bash or WSL on Windows).
+</Note>
+
+Setting up hooks in Cline is user-friendly with the built-in hooks management interface. Here's how to get started:
+
+<Steps>
+<Step title="Access the Hooks Interface">
+Navigate to the Hooks management interface:
+
+<Frame>
+  <img src="/assets/hooks/hooks-interface-with-dropdown.png" alt="Hooks management interface showing Global Hooks and project-specific hooks with dropdown menu" />
+</Frame>
+
+1. Open Cline (ensure hooks are enabled in settings)
+2. Look for the **Hooks** tab at the top (alongside Rules and Workflows)
+3. Click on **Hooks** to open the hooks management panel
+
+The interface shows you all available hook types and existing hooks organized by workspace.
+</Step>
+
+<Step title="Understand Hook Locations">
+Hooks are automatically organized by location in the interface:
+
+**Global Hooks** - Apply to all workspaces:
+- Stored in `~/Documents/Cline/Hooks/`
+- Perfect for personal coding standards and universal rules
+
+**Project-Specific Hooks** - Apply only to current project:
+- Stored in `.clinerules/hooks/` within your repo
+- Great for project-specific validation and team workflows
+- Can be committed to version control for team sharing
+
+Multi-root workspaces run hooks from all of the repos in your open workspace, making it easy to manage and run hooks across different repos within the same workspace.
+</Step>
+
+<Step title="Create Your First Hook">
+Use the intuitive interface to create hooks:
+
+<Frame>
+  <img src="/assets/hooks/hooks-empty-state.png" alt="Empty hooks interface showing New hook... dropdowns for both Global Hooks and project-specific hooks before any hooks are created" />
+</Frame>
+
+1. **Choose your location**: Decide between Global Hooks or project-specific hooks
+2. **Select hook type**: Click the **"New hook..."** dropdown in your chosen location
+3. **Pick a hook type**: The dropdown shows all available hook types that haven't been created yet in this location. Only one of each hook type is allowed per hooks directory, so the dropdown automatically filters to show only the remaining available types.
+
+<Frame>
+  <img src="/assets/hooks/new-hook-dropdown.png" alt="Creating a new hook with the dropdown menu showing UserPromptSubmit selected with description" />
+</Frame>
+
+4. **Review and edit the hook**: Click the pencil icon to review the hook's code and add your custom logic
+5. **Enable the hook**: Once you understand and approve of the hook's behavior, toggle the switch to activate it
+
+<Frame>
+  <img src="/assets/hooks/hook-controls.png" alt="Hook management controls showing toggle, edit, and delete buttons for each hook" />
+</Frame>
+
+<Warning>
+Always review a hook's code before enabling it. Hooks execute automatically during your workflow, so it's important to understand what they do before activation.
+</Warning>
+</Step>
+
+<Step title="Test Your Hook">
+To develop and refine your hook, you'll need to trigger it multiple times during testing. Each hook type is triggered by different events in Cline's workflow. For example:
+
+- **TaskStart** hooks trigger when you start a new task
+- **PreToolUse** hooks trigger before Cline executes tools like file editing
+- **PostToolUse** hooks trigger after tool execution completes
+- **UserPromptSubmit** hooks trigger when you submit a message to Cline
+
+For complete details on when each hook type is triggered and how to test them effectively, see the [Hook Reference](/features/hooks/hook-reference) documentation. This includes the specific conditions that trigger each hook and examples of how to invoke them during development.
+</Step>
+</Steps>
+
+<Tip>
+Start with a simple hook that just logs information before building complex validation logic. This helps you understand the data structure and timing.
+</Tip>
+
+## What You Can Build
+
+Once you understand the basics, hooks open up creative possibilities:
+
+<CardGroup cols={2}>
+  <Card title="Intelligent Code Review" icon="code-branch">
+    Run linters or custom validators before files get saved. Block commits that don't pass checks. Track code quality metrics over time.
+  </Card>
+  
+  <Card title="Security Enforcement" icon="shield-halved">
+    Prevent operations that violate security policies. Detect when sensitive data might be exposed. Audit all file access for compliance.
+  </Card>
+  
+  <Card title="Development Analytics" icon="chart-line">
+    Measure how long different operations take. Identify patterns in how the AI works. Generate productivity reports from hook data.
+  </Card>
+  
+  <Card title="Integration Hub" icon="plug">
+    Connect to issue trackers when certain keywords appear. Update project management tools. Sync with external APIs at the right moments.
+  </Card>
+</CardGroup>
+
+The key is combining hooks with external tools. A hook can be the glue between Cline's workflow and the rest of your development ecosystem.
+
+## Explore the Documentation
+
+<CardGroup cols={2}>
+  <Card title="Hook Reference" icon="book" href="/features/hooks/hook-reference">
+    Complete API reference for all hook types, JSON schemas, and field documentation.
+  </Card>
+  
+  <Card title="Samples" icon="code" href="/features/hooks/samples">
+    Practical examples and complete working scripts for common use cases.
+  </Card>
+</CardGroup>
+
+## Related Features
+
+Hooks complement other Cline features:
+
+- [Cline Rules](/features/cline-rules) define high-level guidance that hooks can enforce
+- [Checkpoints](/features/checkpoints) let you roll back changes if a hook didn't catch an issue
+- [Auto-Approve](/features/auto-approve) works well with hooks as safety nets for automated operations

docs/features/hooks/samples.mdx

@@ -0,0 +1,755 @@
+---
+title: "Samples"
+sidebarTitle: "Samples"
+description: "Practical hook examples organized by complexity level - from beginner to advanced patterns"
+---
+
+This page provides complete, production-ready hook examples organized by skill level. Each example includes full working code, detailed explanations, and guidance on when to use each pattern.
+
+## How to Use These Samples
+
+Each sample is designed to be:
+- **Copy-and-paste ready**: Use them directly or as starting points
+- **Educational**: Learn hook concepts through progressive complexity
+- **Practical**: Solve real development workflow challenges
+
+Choose samples based on your experience level and gradually work up to more advanced patterns.
+
+---
+
+## Beginner Examples
+
+Perfect for getting started with hooks. These examples demonstrate core concepts with straightforward logic.
+
+### 1. Project Type Detection
+
+**Hook:** `TaskStart`
+
+```bash
+#!/usr/bin/env bash
+# Project Type Detection Hook
+# 
+# Overview: Automatically detects project type at task start and injects relevant
+# coding standards and best practices into the AI context. This helps Cline understand
+# your project structure and apply appropriate conventions from the beginning.
+#
+# Demonstrates: Basic hook input/output, file system checks, conditional logic,
+# and context injection to guide AI behavior.
+
+input=$(cat)
+
+# Read basic JSON structure and detect project type
+context=""
+
+# Check for different project indicators
+if [[ -f "package.json" ]]; then
+  if grep -q "react" package.json; then
+    context="PROJECT_TYPE: React application detected. Follow component-based architecture and use functional components."
+  elif grep -q "express" package.json; then
+    context="PROJECT_TYPE: Express.js API detected. Follow RESTful patterns and proper middleware structure."
+  else
+    context="PROJECT_TYPE: Node.js project detected. Use proper npm scripts and dependency management."
+  fi
+elif [[ -f "requirements.txt" ]] || [[ -f "pyproject.toml" ]]; then
+  context="PROJECT_TYPE: Python project detected. Follow PEP 8 standards and use virtual environments."
+elif [[ -f "Cargo.toml" ]]; then
+  context="PROJECT_TYPE: Rust project detected. Follow Rust conventions and use proper error handling."
+elif [[ -f "go.mod" ]]; then
+  context="PROJECT_TYPE: Go project detected. Follow Go conventions and use proper package structure."
+fi
+
+# Return the context to guide Cline's behavior
+if [[ -n "$context" ]]; then
+  jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+**Key Concepts:**
+- Reading hook input with `input=$(cat)`
+- Using file system checks to detect project type
+- Returning context to influence AI behavior
+- Basic JSON output with `jq`
+
+### 2. File Extension Validator
+
+**Hook:** `PreToolUse`
+
+```bash
+#!/usr/bin/env bash
+# File Extension Validator Hook
+#
+# Overview: Enforces TypeScript file extensions in TypeScript projects by blocking
+# creation of .js and .jsx files. This prevents common mistakes where developers
+# accidentally create JavaScript files when they should be using TypeScript.
+#
+# Demonstrates: PreToolUse blocking, parameter extraction, conditional validation,
+# and providing clear error messages to guide users toward correct file extensions.
+
+input=$(cat)
+
+# Extract tool information
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+
+# Only process file creation tools
+if [[ "$tool_name" != "write_to_file" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Check if this is a TypeScript project
+if [[ ! -f "tsconfig.json" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Get the file path from tool parameters
+file_path=$(echo "$input" | jq -r '.preToolUse.parameters.path // empty')
+
+if [[ -z "$file_path" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Block .js files in TypeScript projects
+if [[ "$file_path" == *.js ]]; then
+  echo '{"cancel": true, "errorMessage": "JavaScript files (.js) are not allowed in TypeScript projects. Use .ts extension instead."}'
+  exit 0
+fi
+
+# Block .jsx files, suggest .tsx
+if [[ "$file_path" == *.jsx ]]; then
+  echo '{"cancel": true, "errorMessage": "JSX files (.jsx) are not allowed in TypeScript projects. Use .tsx extension instead."}'
+  exit 0
+fi
+
+# Everything is OK
+echo '{"cancel": false}'
+```
+
+**Key Concepts:**
+- Extracting tool name and parameters
+- Conditional logic based on project state
+- Blocking operations with `"cancel": true`
+- Providing helpful error messages
+
+### 3. Basic Performance Monitor
+
+**Hook:** `PostToolUse`
+
+```bash
+#!/usr/bin/env bash
+# Basic Performance Monitor Hook
+#
+# Overview: Monitors tool execution times and logs operations that exceed a 3-second
+# threshold. This helps identify performance bottlenecks and provides feedback to
+# users about system resource issues that may be slowing down Cline's operations.
+#
+# Demonstrates: PostToolUse hook usage, arithmetic operations in bash, simple file
+# logging, and conditional context injection based on performance metrics.
+
+input=$(cat)
+
+# Extract performance information
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs // 0')
+success=$(echo "$input" | jq -r '.postToolUse.success')
+
+# Log slow operations (threshold: 3 seconds)
+if (( execution_time > 3000 )); then
+  # Create simple log directory
+  mkdir -p "$HOME/.cline_logs"
+  
+  # Log the slow operation
+  echo "$(date -Iseconds): SLOW OPERATION - $tool_name took ${execution_time}ms" >> "$HOME/.cline_logs/performance.log"
+  
+  # Provide feedback to user
+  context="PERFORMANCE: Operation $tool_name took ${execution_time}ms. Consider checking system resources if this happens frequently."
+  jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+**Key Concepts:**
+- Processing results after tool execution
+- Basic arithmetic operations in bash
+- Simple file logging
+- Conditional context injection
+
+## Intermediate Examples
+
+These examples demonstrate more advanced concepts including external tool integration, pattern matching, and structured logging.
+
+### 4. Code Quality with Linting
+
+**Hook:** `PreToolUse`
+
+```bash
+#!/usr/bin/env bash
+# Code Quality Linting Hook
+#
+# Overview: Integrates ESLint and Flake8 to enforce code quality standards before
+# files are written. Blocks file creation if linting errors are detected, ensuring
+# all code meets quality standards. Supports TypeScript, JavaScript, and Python files.
+#
+# Demonstrates: External tool integration, temporary file handling, regex pattern
+# matching, and comprehensive error reporting with actionable feedback.
+
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+
+# Only lint file write operations
+if [[ "$tool_name" != "write_to_file" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+file_path=$(echo "$input" | jq -r '.preToolUse.parameters.path // empty')
+
+# Skip non-code files
+if [[ ! "$file_path" =~ \.(ts|tsx|js|jsx|py|rs)$ ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Get file content from the tool parameters  
+content=$(echo "$input" | jq -r '.preToolUse.parameters.content // empty')
+
+if [[ -z "$content" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Create temporary file for linting
+temp_file=$(mktemp)
+echo "$content" > "$temp_file"
+
+# Run appropriate linter based on file extension
+lint_errors=""
+if [[ "$file_path" =~ \.(ts|tsx)$ ]] && command -v eslint > /dev/null; then
+  lint_output=$(eslint "$temp_file" --format=json 2>/dev/null || true)
+  if [[ "$lint_output" != "[]" ]] && [[ -n "$lint_output" ]]; then
+    error_count=$(echo "$lint_output" | jq '.[0].errorCount // 0')
+    if (( error_count > 0 )); then
+      messages=$(echo "$lint_output" | jq -r '.[0].messages[] | "\(.line):\(.column) \(.message)"')
+      lint_errors="ESLint errors found:\n$messages"
+    fi
+  fi
+elif [[ "$file_path" =~ \.py$ ]] && command -v flake8 > /dev/null; then
+  lint_output=$(flake8 "$temp_file" 2>/dev/null || true)
+  if [[ -n "$lint_output" ]]; then
+    lint_errors="Flake8 errors found:\n$lint_output"
+  fi
+fi
+
+# Cleanup
+rm -f "$temp_file"
+
+# Block if linting errors found
+if [[ -n "$lint_errors" ]]; then
+  error_message="Code quality check failed. Please fix these issues:\n\n$lint_errors"
+  jq -n --arg msg "$error_message" '{"cancel": true, "errorMessage": $msg}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+**Key Concepts:**
+- Temporary file creation and cleanup
+- External tool integration (eslint, flake8)
+- Complex pattern matching with regex
+- Structured error reporting
+
+### 5. Security Scanner
+
+**Hook:** `PreToolUse`
+
+```bash
+#!/usr/bin/env bash
+# Security Scanner Hook
+#
+# Overview: Scans file content for hardcoded secrets (API keys, tokens, passwords)
+# before files are written. Blocks creation of files containing secrets except in
+# safe locations like .env.example files or documentation, preventing credential leaks.
+#
+# Demonstrates: Pattern matching with regex arrays, file path exception handling,
+# security-focused validation, and clear user guidance in error messages.
+
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+
+# Only check file operations
+if [[ "$tool_name" != "write_to_file" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+content=$(echo "$input" | jq -r '.preToolUse.parameters.content // empty')
+file_path=$(echo "$input" | jq -r '.preToolUse.parameters.path // empty')
+
+# Skip if no content
+if [[ -z "$content" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Define secret patterns (simplified for readability)
+secrets_found=""
+
+# Check for API keys
+if echo "$content" | grep -qi "api[_-]*key.*[=:].*['\"][a-z0-9_-]{10,}['\"]"; then
+  secrets_found+="- API key pattern detected\n"
+fi
+
+# Check for tokens
+if echo "$content" | grep -qi "token.*[=:].*['\"][a-z0-9_-]{10,}['\"]"; then
+  secrets_found+="- Token pattern detected\n"
+fi
+
+# Check for passwords
+if echo "$content" | grep -qi "password.*[=:].*['\"][^'\"]{8,}['\"]"; then
+  secrets_found+="- Password pattern detected\n"
+fi
+
+# Allow secrets in safe files
+safe_patterns=("\.env\.example$" "\.env\.template$" "/docs/" "\.md$")
+is_safe_file=false
+for safe_pattern in "${safe_patterns[@]}"; do
+  if [[ "$file_path" =~ $safe_pattern ]]; then
+    is_safe_file=true
+    break
+  fi
+done
+
+if [[ -n "$secrets_found" ]] && [[ "$is_safe_file" == false ]]; then
+  error_message="🔒 SECURITY ALERT: Potential secrets detected in $file_path
+
+$secrets_found
+Please use environment variables or a secrets management service instead."
+
+  jq -n --arg msg "$error_message" '{"cancel": true, "errorMessage": $msg}'
+else
+  echo '{"cancel": false}'
+fi
+```
+
+**Key Concepts:**
+- Pattern arrays and iteration
+- File path exception handling  
+- Security-focused validation
+- Clear user guidance in error messages
+
+### 6. Git Workflow Assistant
+
+**Hook:** `PostToolUse`
+
+```bash
+#!/usr/bin/env bash
+# Git Workflow Assistant Hook
+#
+# Overview: Analyzes file modifications and provides intelligent git workflow suggestions
+# based on file types and current branch. Encourages best practices like feature branches
+# for components and test branches for test files, with actionable git commands.
+#
+# Demonstrates: Git integration, branch analysis, file path pattern matching, and
+# contextual suggestions to guide users toward better git practices.
+
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+success=$(echo "$input" | jq -r '.postToolUse.success')
+
+# Only process successful file modifications
+if [[ "$success" != "true" ]] || [[ "$tool_name" != "write_to_file" && "$tool_name" != "replace_in_file" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Check if we're in a git repository
+if ! git rev-parse --git-dir > /dev/null 2>&1; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+file_path=$(echo "$input" | jq -r '.postToolUse.parameters.path // empty')
+current_branch=$(git branch --show-current 2>/dev/null || echo "main")
+
+# Analyze file type and suggest appropriate branch naming
+context=""
+if [[ "$file_path" == *"component"* ]] && [[ "$current_branch" == "main" || "$current_branch" == "master" ]]; then
+  component_name=$(basename "$file_path" .tsx .ts .jsx .js)
+  context="GIT_WORKFLOW: Consider creating a feature branch: git checkout -b feature/add-${component_name,,}-component"
+elif [[ "$file_path" == *"test"* ]] || [[ "$file_path" == *"spec"* ]]; then
+  if [[ "$current_branch" == "main" || "$current_branch" == "master" ]]; then
+    context="GIT_WORKFLOW: Consider creating a test branch: git checkout -b test/add-tests-$(basename "$(dirname "$file_path")")"
+  fi
+fi
+
+# Add staging guidance
+if [[ -n "$context" ]]; then
+  context="$context After completing changes, use 'git add $file_path' to stage for commit."
+else
+  context="GIT_WORKFLOW: File modified: $file_path. Use 'git add $file_path' when ready to commit."
+fi
+
+jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+```
+
+**Key Concepts:**
+- Git repository detection
+- Branch analysis and suggestions
+- File path analysis for context
+- Actionable user guidance
+
+## Advanced Examples
+
+These examples showcase sophisticated patterns including external integrations, asynchronous processing, and complex state management.
+
+### 7. Comprehensive Task Lifecycle Manager
+
+**Hook:** `TaskComplete`
+
+```bash
+#!/usr/bin/env bash
+# Comprehensive Task Lifecycle Manager Hook
+#
+# Overview: Tracks task completions by generating detailed markdown reports with
+# workspace information and git state, and optionally sends webhook notifications
+# to external systems. Perfect for enterprise environments requiring audit trails.
+#
+# Demonstrates: Complex data extraction, structured report generation, markdown
+# heredocs, asynchronous webhook notifications, and robust error handling.
+
+input=$(cat)
+
+# Extract task metadata using proper API field paths
+task_id=$(echo "$input" | jq -r '.taskId')
+ulid=$(echo "$input" | jq -r '.taskComplete.taskMetadata.ulid // "unknown"')
+completion_time=$(echo "$input" | jq -r '.timestamp')
+
+# Create completion report directory with error handling
+reports_dir="$HOME/.cline_reports"
+if [[ ! -d "$(dirname "$reports_dir")" ]]; then
+  echo '{"cancel": false, "errorMessage": "Cannot access home directory"}' 
+  exit 0
+fi
+mkdir -p "$reports_dir" || exit 0
+
+# Generate safe, unique report filename
+safe_task_id=$(echo "$task_id" | tr -cd '[:alnum:]_-' | head -c 50)
+report_file="$reports_dir/completion_$(date +%Y%m%d_%H%M%S)_${safe_task_id}.md"
+
+# Collect comprehensive workspace information
+git_branch=$(git branch --show-current 2>/dev/null || echo "No git repository")
+git_status_count=$(git status --porcelain 2>/dev/null | wc -l || echo "0")
+project_name=$(basename "$PWD")
+
+# Generate detailed completion report
+cat > "$report_file" << EOF
+# Cline Task Completion Report
+
+**Task ID:** $task_id  
+**ULID:** $ulid  
+**Completed:** $(date -Iseconds)  
+**Completion Time:** $completion_time
+
+## Workspace Information
+- **Project:** $project_name
+- **Git Branch:** $git_branch
+- **Modified Files:** $git_status_count
+
+## Completion Status
+✅ Task completed successfully
+
+## Next Steps
+- Review changes made during this task
+- Consider committing changes if appropriate  
+- Run tests to verify functionality
+EOF
+
+# Send webhook notification if configured
+webhook_url="${COMPLETION_WEBHOOK_URL:-}"
+if [[ -n "$webhook_url" ]]; then
+  payload=$(jq -n \
+    --arg task_id "$task_id" \
+    --arg ulid "$ulid" \
+    --arg workspace "$project_name" \
+    --arg timestamp "$completion_time" \
+    '{
+      event: "task_completed",
+      task_id: $task_id,
+      ulid: $ulid,
+      workspace: $workspace,
+      timestamp: $timestamp
+    }')
+  
+  # Send notification in background with timeout
+  (curl -X POST \
+    -H "Content-Type: application/json" \
+    -d "$payload" \
+    "$webhook_url" \
+    --max-time 5 \
+    --silent > /dev/null 2>&1) &
+fi
+
+context="TASK_COMPLETED: ✅ Task $task_id finished successfully. Report saved to: $(basename "$report_file")"
+jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+```
+
+**Key Concepts:**
+- Complex data extraction and validation
+- Structured report generation
+- Asynchronous webhook notifications
+- Error handling and resource management
+
+### 8. Intelligent User Input Enhancer  
+
+**Hook:** `UserPromptSubmit`
+
+```bash
+#!/usr/bin/env bash
+# Intelligent User Input Enhancer Hook
+#
+# Overview: Analyzes user prompts to detect potentially harmful commands, logs user
+# activity for analytics, and intelligently injects project and git context based on
+# prompt keywords. Provides safety guards while enhancing AI responses with relevant context.
+#
+# Demonstrates: UserPromptSubmit hook usage, multi-pattern safety validation, intelligent
+# context detection from prompts, structured JSON logging, and dynamic suggestion generation.
+
+input=$(cat)
+
+user_prompt=$(echo "$input" | jq -r '.userPromptSubmit.prompt')
+task_id=$(echo "$input" | jq -r '.taskId')
+user_id=$(echo "$input" | jq -r '.userId')
+
+# Log user activity for analytics
+activity_log="$HOME/.cline_user_activity/$(date +%Y-%m-%d).log"
+mkdir -p "$(dirname "$activity_log")"
+
+activity_entry=$(jq -n \
+  --arg timestamp "$(date -Iseconds)" \
+  --arg task_id "$task_id" \
+  --arg user_id "$user_id" \
+  --arg prompt_length "${#user_prompt}" \
+  '{
+    timestamp: $timestamp,
+    task_id: $task_id,
+    user_id: $user_id,
+    prompt_length: ($prompt_length | tonumber),
+    workspace: env.PWD
+  }')
+
+echo "$activity_entry" >> "$activity_log"
+
+context_modifications=""
+cancel_request=false
+
+# Safety validation
+harmful_patterns=("rm -rf" "delete.*all" "format.*drive" "sudo.*passwd")
+for pattern in "${harmful_patterns[@]}"; do
+  if echo "$user_prompt" | grep -qi "$pattern"; then
+    cancel_request=true
+    error_message="🚨 SAFETY ALERT: Potentially harmful command detected. Please review your request."
+    break
+  fi
+done
+
+# Intelligent context enhancement
+if [[ "$cancel_request" == false ]]; then
+  # Detect project context
+  if echo "$user_prompt" | grep -qi "file\|directory\|folder"; then
+    if [[ -f "package.json" ]]; then
+      project_name=$(jq -r '.name // "unknown"' package.json 2>/dev/null)
+      context_modifications+="PROJECT_CONTEXT: Working in Node.js project '$project_name'. "
+    elif [[ -f "requirements.txt" ]]; then
+      context_modifications+="PROJECT_CONTEXT: Working in Python project. "
+    fi
+  fi
+  
+  # Git context enhancement
+  if echo "$user_prompt" | grep -qi "git\|commit\|branch" && git rev-parse --git-dir > /dev/null 2>&1; then
+    current_branch=$(git branch --show-current 2>/dev/null)
+    uncommitted=$(git status --porcelain | wc -l)
+    context_modifications+="GIT_CONTEXT: On branch '$current_branch' with $uncommitted uncommitted changes. "
+  fi
+  
+  # Tool suggestions
+  if echo "$user_prompt" | grep -qi "search.*code\|find.*function"; then
+    context_modifications+="SUGGESTION: Consider using search_files tool for code exploration. "
+  fi
+fi
+
+# Return response
+if [[ "$cancel_request" == true ]]; then
+  jq -n --arg msg "$error_message" '{"cancel": true, "errorMessage": $msg}'
+else
+  if [[ -n "$context_modifications" ]]; then
+    jq -n --arg ctx "$context_modifications" '{"cancel": false, "contextModification": $ctx}'
+  else
+    echo '{"cancel": false}'
+  fi
+fi
+```
+
+**Key Concepts:**
+- User interaction analysis and logging
+- Multi-pattern safety validation
+- Intelligent context detection
+- Dynamic suggestion generation
+
+### 9. Multi-Service Integration Hub
+
+**Hook:** `PostToolUse`
+
+```bash
+#!/usr/bin/env bash
+# Multi-Service Integration Hub Hook
+#
+# Overview: Detects file modifications by type (dependencies, CI/CD, frontend, backend, tests)
+# and sends asynchronous webhook notifications to multiple external services like Slack and
+# CI/CD systems. Enables seamless integration of Cline operations into enterprise workflows.
+#
+# Demonstrates: Advanced pattern matching with associative arrays, multi-service webhook
+# orchestration, asynchronous background processing, and enterprise notification patterns.
+
+input=$(cat)
+
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+success=$(echo "$input" | jq -r '.postToolUse.success')
+file_path=$(echo "$input" | jq -r '.postToolUse.parameters.path // empty')
+
+# Only process successful file operations
+if [[ "$success" != "true" ]] || [[ "$tool_name" != "write_to_file" && "$tool_name" != "replace_in_file" ]]; then
+  echo '{"cancel": false}'
+  exit 0
+fi
+
+# Define workflow triggers
+declare -A triggers=(
+  ["package\\.json|yarn\\.lock"]="dependencies"
+  ["\\.github/workflows/"]="ci_cd"
+  ["src/.*component"]="frontend"
+  ["api/.*\\.(ts|js)"]="backend"
+  [".*\\.(test|spec)\\."]="testing"
+)
+
+# Determine triggered workflows
+triggered_workflows=""
+for pattern in "${!triggers[@]}"; do
+  if [[ "$file_path" =~ $pattern ]]; then
+    workflow_type="${triggers[$pattern]}"
+    triggered_workflows+="$workflow_type "
+  fi
+done
+
+context="WORKFLOW: File modified: $file_path"
+
+if [[ -n "$triggered_workflows" ]]; then
+  # Slack notification (async)
+  slack_webhook="${SLACK_WEBHOOK_URL:-}"
+  if [[ -n "$slack_webhook" ]]; then
+    slack_payload=$(jq -n \
+      --arg file "$file_path" \
+      --arg workflows "$triggered_workflows" \
+      --arg workspace "$(basename "$PWD")" \
+      '{
+        text: ("🔧 Cline modified `" + $file + "` in " + $workspace),
+        color: "good",
+        fields: [{
+          title: "Triggered Workflows",
+          value: $workflows,
+          short: true
+        }]
+      }')
+    
+    (curl -X POST -H "Content-Type: application/json" -d "$slack_payload" "$slack_webhook" --max-time 5 --silent > /dev/null 2>&1) &
+  fi
+
+  # CI/CD webhook (async)  
+  ci_webhook="${CI_WEBHOOK_URL:-}"
+  if [[ -n "$ci_webhook" ]]; then
+    ci_payload=$(jq -n \
+      --arg file "$file_path" \
+      --arg workflows "$triggered_workflows" \
+      '{
+        event: "file_modified",
+        file_path: $file,
+        workflows: ($workflows | split(" "))
+      }')
+    
+    (curl -X POST -H "Content-Type: application/json" -d "$ci_payload" "$ci_webhook" --max-time 5 --silent > /dev/null 2>&1) &
+  fi
+
+  context+=" Triggered workflows: $triggered_workflows. Notifications sent to configured services."
+fi
+
+jq -n --arg ctx "$context" '{"cancel": false, "contextModification": $ctx}'
+```
+
+**Key Concepts:**
+- Multi-service integration patterns
+- Asynchronous webhook orchestration  
+- Complex workflow detection
+- Enterprise notification systems
+
+## Usage Tips
+
+### Running Multiple Hooks
+
+You can use multiple hooks together by creating separate files for each hook type:
+
+```bash
+# Create hooks directory
+mkdir -p .clinerules/hooks
+
+# Create multiple hooks
+touch .clinerules/hooks/PreToolUse
+touch .clinerules/hooks/PostToolUse
+touch .clinerules/hooks/TaskStart
+
+# Make them executable
+chmod +x .clinerules/hooks/*
+```
+
+### Environment Configuration
+
+Set up environment variables for external integrations:
+
+```bash
+# Add to your .bashrc or .zshrc
+export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/..."
+export JIRA_URL="https://yourcompany.atlassian.net"
+export JIRA_USER="your-email@company.com"
+export JIRA_TOKEN="your-api-token"
+export CI_WEBHOOK_URL="https://your-ci-system.com/hooks/cline"
+```
+
+### Testing Your Hooks
+
+Test hooks manually by simulating their input:
+
+```bash
+# Test a PreToolUse hook
+echo '{
+  "clineVersion": "1.0.0",
+  "hookName": "PreToolUse",
+  "timestamp": "2024-01-01T12:00:00Z",
+  "taskId": "test",
+  "workspaceRoots": ["/path/to/workspace"],
+  "userId": "test-user",
+  "preToolUse": {
+    "toolName": "write_to_file",
+    "parameters": {
+      "path": "test.js",
+      "content": "console.log(\"test\");"
+    }
+  }
+}' | .clinerules/hooks/PreToolUse
+```
+
+These examples provide a solid foundation for implementing hooks in your development workflow. Customize them based on your specific needs, tools, and integrations.

docs/features/slash-commands/explain-changes.mdx

@@ -2,6 +2,9 @@
 title: "Explain Changes Command"
 sidebarTitle: "/explain-changes"
 ---
+<Note>
+This command is only available in **VS Code**. The diff view with inline comments requires VS Code's native diff capabilities.
+</Note>
 
 `/explain-changes` is a slash command that generates AI-powered explanations for any git diff. Unlike the [Explain Changes button](/features/explain-changes) which explains changes from a completed task, this command lets you explain changes between any two git references - commits, branches, tags, PRs, staged changes, or your working directory.
 

docs/getting-started/installing-cline.mdx

@@ -10,7 +10,7 @@ description: "Get Cline up and running in your favorite IDE with these simple in
 ## Before You Begin
 
 <CardGroup cols={1}>
-  <Card title="Create Your Account" icon="user-plus" href="https://app.cline.bot/signup">
+  <Card title="Create Your Account" icon="user-plus" href="https://app.cline.bot/login">
     Sign up for a **free Cline account** to get:
     - Access to multiple AI models including stealth models
     - Seamless setup without managing API keys
@@ -361,10 +361,9 @@ description: "Get Cline up and running in your favorite IDE with these simple in
     <Info>
     You'll be redirected to [app.cline.bot](https://app.cline.bot) to authenticate. After signing in, you'll automatically return to your editor.
     </Info>
-    <Frame>
-            <img src="/assets/installation/login.png" alt="Cline sign up screen" 
-            />
-          </Frame>
+    <Info>
+    You'll be redirected to the Cline authentication page to sign in with your account.
+    </Info>
   </Step>
 
   <Step title="You're All Set!">
@@ -403,7 +402,7 @@ description: "Get Cline up and running in your favorite IDE with these simple in
     Connect with our team and community for support, tips, and discussions.
   </Card>
   
-  <Card title="Read the Docs" icon="book-open" href="/getting-started/for-new-coders">
-    Explore guides for new coders, model selection, and advanced features.
+  <Card title="Read the Docs" icon="book-open" href="/getting-started/selecting-your-model">
+    Explore model selection guides and advanced features to get the most out of Cline.
   </Card>
 </CardGroup>

docs/introduction/welcome.mdx

@@ -29,7 +29,7 @@ Cline is an open source AI coding agent that brings frontier AI models directly
     Master Cline's powerful features and optimize your workflow
   </Card>
 
-  <Card title="Enterprise" icon="building" href="/enterprise-solutions/security-concerns">
+  <Card title="Enterprise" icon="building" href="/enterprise-solutions/overview">
     Deploy Cline in your organization with confidence
   </Card>
 </CardGroup>

docs/provider-config/baseten.mdx

@@ -38,6 +38,7 @@ For the most updated pricing, please visit: https://www.baseten.co/products/mode
 -   `deepseek-ai/DeepSeek-R1-0528` - Latest revision of DeepSeek's reasoning model (163K context) - \$2.55/\$5.95 per 1M tokens
 -   `deepseek-ai/DeepSeek-V3.1` - Hybrid reasoning with advanced tool calling (163K context) - \$0.50/\$1.50 per 1M tokens
 -   `deepseek-ai/DeepSeek-V3-0324` - Fast general-purpose with enhanced reasoning (163K context) - \$0.77/\$0.77 per 1M tokens
+-   `deepseek-ai/DeepSeek-V3.2` - Fast general-purpose with enhanced reasoning (163K context) - \$0.77/\$0.77 per 1M tokens
 
 ### Production-First Architecture
 

docs/provider-config/sap-aicore.mdx

@@ -14,7 +14,7 @@ SAP AI Core, and Generative AI Hub, are offerings from SAP BTP. You need an acti
 
 ### Getting a Service Binding
 
-1. **Access:** Go to your subaccount via [BTP Cloud Cockpit](cockpit.btp.cloud.sap/cockpit)
+1. **Access:** Go to your subaccount via [BTP Cloud Cockpit](https://cockpit.btp.cloud.sap/cockpit)
 2. **Create a Service Binding:** Go to "Instances and Subscriptions", select your SAP AI Core service instance and click on Service Bindings > Create.
 3. **Copy the Service Binding:** Copy the service binding values.
 

esbuild.mjs

@@ -125,7 +125,7 @@ const copyWasmFiles = {
 
 const buildEnvVars = {
 	"import.meta.url": "_importMetaUrl",
-	"process.env.IS_STANDALONE": JSON.stringify(standalone),
+	"process.env.IS_STANDALONE": JSON.stringify(standalone ? "true" : "false"),
 }
 
 if (production) {

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "claude-dev",
-	"version": "3.39.2",
+	"version": "3.43.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "claude-dev",
-			"version": "3.39.1",
+			"version": "3.43.0",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.37.0",
@@ -43,7 +43,6 @@
 				"@playwright/test": "^1.55.1",
 				"@sap-ai-sdk/ai-api": "^2.1.0",
 				"@sap-ai-sdk/orchestration": "^2.1.0",
-				"@sentry/browser": "^9.12.0",
 				"@streamparser/json": "^0.0.22",
 				"@tailwindcss/vite": "^4.1.14",
 				"@types/uuid": "^10.0.0",
@@ -1677,13 +1676,13 @@
 			}
 		},
 		"node_modules/@changesets/apply-release-plan": {
-			"version": "7.0.12",
-			"resolved": "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-7.0.12.tgz",
-			"integrity": "sha512-EaET7As5CeuhTzvXTQCRZeBUcisoYPDDcXvgTE/2jmmypKp0RC7LxKj/yzqeh/1qFTZI7oDGFcL1PHRuQuketQ==",
+			"version": "7.0.14",
+			"resolved": "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-7.0.14.tgz",
+			"integrity": "sha512-ddBvf9PHdy2YY0OUiEl3TV78mH9sckndJR14QAt87KLEbIov81XO0q0QAmvooBxXlqRRP8I9B7XOzZwQG7JkWA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@changesets/config": "^3.1.1",
+				"@changesets/config": "^3.1.2",
 				"@changesets/get-version-range-type": "^0.4.0",
 				"@changesets/git": "^3.0.4",
 				"@changesets/should-skip-package": "^0.1.2",
@@ -1724,27 +1723,27 @@
 			}
 		},
 		"node_modules/@changesets/cli": {
-			"version": "2.29.6",
-			"resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.29.6.tgz",
-			"integrity": "sha512-6qCcVsIG1KQLhpQ5zE8N0PckIx4+9QlHK3z6/lwKnw7Tir71Bjw8BeOZaxA/4Jt00pcgCnCSWZnyuZf5Il05QQ==",
+			"version": "2.29.8",
+			"resolved": "https://registry.npmjs.org/@changesets/cli/-/cli-2.29.8.tgz",
+			"integrity": "sha512-1weuGZpP63YWUYjay/E84qqwcnt5yJMM0tep10Up7Q5cS/DGe2IZ0Uj3HNMxGhCINZuR7aO9WBMdKnPit5ZDPA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"@changesets/apply-release-plan": "^7.0.12",
+				"@changesets/apply-release-plan": "^7.0.14",
 				"@changesets/assemble-release-plan": "^6.0.9",
 				"@changesets/changelog-git": "^0.2.1",
-				"@changesets/config": "^3.1.1",
+				"@changesets/config": "^3.1.2",
 				"@changesets/errors": "^0.2.0",
 				"@changesets/get-dependents-graph": "^2.1.3",
-				"@changesets/get-release-plan": "^4.0.13",
+				"@changesets/get-release-plan": "^4.0.14",
 				"@changesets/git": "^3.0.4",
 				"@changesets/logger": "^0.1.1",
 				"@changesets/pre": "^2.0.2",
-				"@changesets/read": "^0.6.5",
+				"@changesets/read": "^0.6.6",
 				"@changesets/should-skip-package": "^0.1.2",
 				"@changesets/types": "^6.1.0",
 				"@changesets/write": "^0.4.0",
-				"@inquirer/external-editor": "^1.0.0",
+				"@inquirer/external-editor": "^1.0.2",
 				"@manypkg/get-packages": "^1.1.3",
 				"ansi-colors": "^4.1.3",
 				"ci-info": "^3.7.0",
@@ -1778,9 +1777,9 @@
 			}
 		},
 		"node_modules/@changesets/config": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/@changesets/config/-/config-3.1.1.tgz",
-			"integrity": "sha512-bd+3Ap2TKXxljCggI0mKPfzCQKeV/TU4yO2h2C6vAihIo8tzseAn2e7klSuiyYYXvgu53zMN1OeYMIQkaQoWnA==",
+			"version": "3.1.2",
+			"resolved": "https://registry.npmjs.org/@changesets/config/-/config-3.1.2.tgz",
+			"integrity": "sha512-CYiRhA4bWKemdYi/uwImjPxqWNpqGPNbEBdX1BdONALFIDK7MCUj6FPkzD+z9gJcvDFUQJn9aDVf4UG7OT6Kog==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
@@ -1817,16 +1816,16 @@
 			}
 		},
 		"node_modules/@changesets/get-release-plan": {
-			"version": "4.0.13",
-			"resolved": "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-4.0.13.tgz",
-			"integrity": "sha512-DWG1pus72FcNeXkM12tx+xtExyH/c9I1z+2aXlObH3i9YA7+WZEVaiHzHl03thpvAgWTRaH64MpfHxozfF7Dvg==",
+			"version": "4.0.14",
+			"resolved": "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-4.0.14.tgz",
+			"integrity": "sha512-yjZMHpUHgl4Xl5gRlolVuxDkm4HgSJqT93Ri1Uz8kGrQb+5iJ8dkXJ20M2j/Y4iV5QzS2c5SeTxVSKX+2eMI0g==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@changesets/assemble-release-plan": "^6.0.9",
-				"@changesets/config": "^3.1.1",
+				"@changesets/config": "^3.1.2",
 				"@changesets/pre": "^2.0.2",
-				"@changesets/read": "^0.6.5",
+				"@changesets/read": "^0.6.6",
 				"@changesets/types": "^6.1.0",
 				"@manypkg/get-packages": "^1.1.3"
 			}
@@ -1863,14 +1862,14 @@
 			}
 		},
 		"node_modules/@changesets/parse": {
-			"version": "0.4.1",
-			"resolved": "https://registry.npmjs.org/@changesets/parse/-/parse-0.4.1.tgz",
-			"integrity": "sha512-iwksMs5Bf/wUItfcg+OXrEpravm5rEd9Bf4oyIPL4kVTmJQ7PNDSd6MDYkpSJR1pn7tz/k8Zf2DhTCqX08Ou+Q==",
+			"version": "0.4.2",
+			"resolved": "https://registry.npmjs.org/@changesets/parse/-/parse-0.4.2.tgz",
+			"integrity": "sha512-Uo5MC5mfg4OM0jU3up66fmSn6/NE9INK+8/Vn/7sMVcdWg46zfbvvUSjD9EMonVqPi9fbrJH9SXHn48Tr1f2yA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@changesets/types": "^6.1.0",
-				"js-yaml": "^3.13.1"
+				"js-yaml": "^4.1.1"
 			}
 		},
 		"node_modules/@changesets/pre": {
@@ -1887,15 +1886,15 @@
 			}
 		},
 		"node_modules/@changesets/read": {
-			"version": "0.6.5",
-			"resolved": "https://registry.npmjs.org/@changesets/read/-/read-0.6.5.tgz",
-			"integrity": "sha512-UPzNGhsSjHD3Veb0xO/MwvasGe8eMyNrR/sT9gR8Q3DhOQZirgKhhXv/8hVsI0QpPjR004Z9iFxoJU6in3uGMg==",
+			"version": "0.6.6",
+			"resolved": "https://registry.npmjs.org/@changesets/read/-/read-0.6.6.tgz",
+			"integrity": "sha512-P5QaN9hJSQQKJShzzpBT13FzOSPyHbqdoIBUd2DJdgvnECCyO6LmAOWSV+O8se2TaZJVwSXjL+v9yhb+a9JeJg==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
 				"@changesets/git": "^3.0.4",
 				"@changesets/logger": "^0.1.1",
-				"@changesets/parse": "^0.4.1",
+				"@changesets/parse": "^0.4.2",
 				"@changesets/types": "^6.1.0",
 				"fs-extra": "^7.0.1",
 				"p-filter": "^2.1.0",
@@ -2199,14 +2198,14 @@
 			}
 		},
 		"node_modules/@inquirer/external-editor": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.1.tgz",
-			"integrity": "sha512-Oau4yL24d2B5IL4ma4UpbQigkVhzPDXLoqy1ggK4gnHg/stmkffJE4oOXHXF3uz0UEpywG68KcyXsyYpA1Re/Q==",
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz",
+			"integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"chardet": "^2.1.0",
-				"iconv-lite": "^0.6.3"
+				"chardet": "^2.1.1",
+				"iconv-lite": "^0.7.0"
 			},
 			"engines": {
 				"node": ">=18"
@@ -2220,6 +2219,23 @@
 				}
 			}
 		},
+		"node_modules/@inquirer/external-editor/node_modules/iconv-lite": {
+			"version": "0.7.0",
+			"resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.0.tgz",
+			"integrity": "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ==",
+			"dev": true,
+			"license": "MIT",
+			"dependencies": {
+				"safer-buffer": ">= 2.1.2 < 3.0.0"
+			},
+			"engines": {
+				"node": ">=0.10.0"
+			},
+			"funding": {
+				"type": "opencollective",
+				"url": "https://opencollective.com/express"
+			}
+		},
 		"node_modules/@isaacs/balanced-match": {
 			"version": "4.0.1",
 			"resolved": "https://registry.npmjs.org/@isaacs/balanced-match/-/balanced-match-4.0.1.tgz",
@@ -4718,69 +4734,6 @@
 				"node": ">=20.0.0"
 			}
 		},
-		"node_modules/@sentry-internal/browser-utils": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"dependencies": {
-				"@sentry/core": "9.12.0"
-			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@sentry-internal/feedback": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"dependencies": {
-				"@sentry/core": "9.12.0"
-			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@sentry-internal/replay": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"dependencies": {
-				"@sentry-internal/browser-utils": "9.12.0",
-				"@sentry/core": "9.12.0"
-			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@sentry-internal/replay-canvas": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"dependencies": {
-				"@sentry-internal/replay": "9.12.0",
-				"@sentry/core": "9.12.0"
-			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@sentry/browser": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"dependencies": {
-				"@sentry-internal/browser-utils": "9.12.0",
-				"@sentry-internal/feedback": "9.12.0",
-				"@sentry-internal/replay": "9.12.0",
-				"@sentry-internal/replay-canvas": "9.12.0",
-				"@sentry/core": "9.12.0"
-			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/@sentry/core": {
-			"version": "9.12.0",
-			"license": "MIT",
-			"engines": {
-				"node": ">=18"
-			}
-		},
 		"node_modules/@sindresorhus/merge-streams": {
 			"version": "4.0.0",
 			"license": "MIT",
@@ -7598,9 +7551,9 @@
 			}
 		},
 		"node_modules/chardet": {
-			"version": "2.1.0",
-			"resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.0.tgz",
-			"integrity": "sha512-bNFETTG/pM5ryzQ9Ad0lJOTa6HWD/YsScAR3EnCPZRPlQh77JocYktSHOUHelyhm8IARL+o4c4F1bP5KVOjiRA==",
+			"version": "2.1.1",
+			"resolved": "https://registry.npmjs.org/chardet/-/chardet-2.1.1.tgz",
+			"integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
 			"license": "MIT"
 		},
 		"node_modules/check-error": {

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.39.2",
+	"version": "3.43.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -486,7 +486,6 @@
 		"@playwright/test": "^1.55.1",
 		"@sap-ai-sdk/ai-api": "^2.1.0",
 		"@sap-ai-sdk/orchestration": "^2.1.0",
-		"@sentry/browser": "^9.12.0",
 		"@streamparser/json": "^0.0.22",
 		"@tailwindcss/vite": "^4.1.14",
 		"@types/uuid": "^10.0.0",

proto/cline/account.proto

@@ -113,6 +113,7 @@ message UsageTransaction {
   int32 prompt_tokens = 10;
   int32 total_tokens = 11;
   string user_id = 12;
+  string operation = 13;
 }
 
 message PaymentTransaction {
@@ -135,4 +136,5 @@ message OrganizationUsageTransaction {
   int32 prompt_tokens = 10;
   int32 total_tokens = 11;
   string user_id = 12;
+  string operation = 13;
 }

proto/cline/hooks.proto

@@ -77,7 +77,45 @@ message TaskCompleteData {
 
 // Data for PreCompact hook
 message PreCompactData {
-  int64 context_size = 1;
-  int32 messages_to_compact = 2;
-  string compaction_strategy = 3;
+  // Task identification
+  string task_id = 1;
+  string ulid = 2;
+
+  // Context size information
+  int64 context_size = 3; // Number of messages in API conversation history
+
+  // Compaction strategy indicating how conversation history is managed:
+  // * auto-condense:                   AI-powered compression using summarize_task tool
+  // * standard-truncation-firstpair:   Keep only the original task (used during auto-condense)
+  // * standard-truncation-lasthalf:    Keep first pair + most recent 50% of conversation
+  // * standard-truncation-lastquarter: Keep first pair + most recent 25% of conversation (aggressive)
+  string compaction_strategy = 4;
+
+  // API request tracking
+  int64 previous_api_req_index = 5; // Index of last API request in clineMessages
+
+  // Token usage data from last API request
+  int64 tokens_in = 6;
+  int64 tokens_out = 7;
+  int64 tokens_in_cache = 8;
+  int64 tokens_out_cache = 9;
+
+  // Truncation information (if applicable)
+  int32 deleted_range_start = 10; // Start index of deleted conversation range
+  int32 deleted_range_end = 11; // End index of deleted conversation range
+
+  // Context JSON file path
+  // Path to a temporary JSON file containing the full API conversation history
+  // The file contains an array of message objects with role and content
+  // Hooks can read this file to analyze conversation contents before compaction
+  // This file will be automatically cleaned up after the hook completes
+  string context_json_path = 12;
+
+  // Context raw/formatted file path
+  // Path to a temporary text file containing the complete context window sent to the LLM
+  // This includes the system prompt, environment details, conversation history, and all formatting
+  // Represents the actual input the LLM receives (format varies by provider)
+  // Use this to analyze total context size, overhead, and exactly what the model sees
+  // This file will be automatically cleaned up after the hook completes
+  string context_raw_path = 13;
 }

proto/cline/models.proto

@@ -103,6 +103,7 @@ message OpenRouterModelInfo {
   optional string name = 13;
   optional double temperature = 14;
   optional bool supports_reasoning = 15;
+  optional ApiFormat api_format = 16;
 }
 
 // Shared response message for model information
@@ -377,6 +378,8 @@ message OcaModelInfo {
   optional string banner = 16;
   // Canonical model identifier as reported by OCA
   string model_name = 17;
+  // The API format used by this model
+  optional ApiFormat api_format = 18;
 }
 
 // Aggregated OCA model catalog keyed by model identifier
@@ -431,6 +434,14 @@ enum ApiProvider {
   NOUSRESEARCH = 39;
 }
 
+enum ApiFormat {
+  ANTHROPIC_CHAT = 0;
+  GEMINI_CHAT = 1;
+  OPENAI_CHAT = 2;
+  R1_CHAT = 3;
+  OPENAI_RESPONSES = 4;
+}
+
 // Model info for OpenAI-compatible models
 message OpenAiCompatibleModelInfo {
   optional int64 max_tokens = 1;
@@ -447,6 +458,7 @@ message OpenAiCompatibleModelInfo {
   repeated ModelTier tiers = 12;
   optional double temperature = 13;
   optional bool is_r1_format_required = 14;
+  optional ApiFormat api_format = 15;
 }
 
 // Model info for LiteLLM models
@@ -464,6 +476,7 @@ message LiteLLMModelInfo {
   optional string description = 11;
   repeated ModelTier tiers = 12;
   optional double temperature = 13;
+  optional ApiFormat api_format = 14;
 }
 
 // Main ApiConfiguration message

proto/cline/slash.proto

@@ -8,9 +8,25 @@ option go_package = "github.com/cline/grpc-go/cline";
 option java_multiple_files = true;
 option java_package = "bot.cline.proto";
 
-// SlashService provides methods for managing slash
+// SlashService provides methods for managing slash commands
 service SlashService {
   // Sends button click message
   rpc reportBug(StringRequest) returns (Empty);
   rpc condense(StringRequest) returns (Empty);
+
+  // Get available slash commands for autocomplete (used by CLI)
+  rpc getAvailableSlashCommands(EmptyRequest) returns (SlashCommandsResponse);
+}
+
+// Slash command definition for autocomplete
+message SlashCommandInfo {
+  string name = 1; // Command name without slash, e.g., "newtask", "smol"
+  string description = 2; // Human-readable description
+  string section = 3; // "default", "custom", or "cli"
+  bool cli_compatible = 4; // false for VS Code-only commands like explain-changes
+}
+
+// Response containing all available slash commands
+message SlashCommandsResponse {
+  repeated SlashCommandInfo commands = 1;
 }

proto/cline/state.proto

@@ -227,6 +227,8 @@ message Settings {
   optional OpenAiCompatibleModelInfo plan_mode_aihubmix_model_info = 131;
   optional string act_mode_aihubmix_model_id = 132;
   optional OpenAiCompatibleModelInfo act_mode_aihubmix_model_info = 133;
+  optional bool cline_web_tools_enabled = 134;
+  optional bool hooks_enabled = 135;
 }
 
 message DictationSettings {
@@ -365,6 +367,8 @@ message UpdateSettingsRequest {
   optional string cline_env = 31;
   optional bool native_tool_call_enabled = 32;
   optional OnboardingModelGroup onboarding_models = 33;
+  optional bool cline_web_tools_enabled = 34;
+  optional bool enable_parallel_tool_calling = 35;
 }
 
 message UpdateTerminalConnectionTimeoutRequest {

src/common.ts

@@ -2,6 +2,7 @@ import * as vscode from "vscode"
 import {
 	cleanupMcpMarketplaceCatalogFromGlobalState,
 	migrateCustomInstructionsToGlobalRules,
+	migrateHooksEnabledToBoolean,
 	migrateTaskHistoryToFile,
 	migrateWelcomeViewCompleted,
 	migrateWorkspaceToGlobalStorage,
@@ -62,6 +63,9 @@ export async function initialize(context: vscode.ExtensionContext): Promise<Webv
 	// Ensure taskHistory.json exists and migrate legacy state (runs once)
 	await migrateTaskHistoryToFile(context)
 
+	// Migrate hooksEnabled from ClineFeatureSetting to boolean (one-time cleanup)
+	await migrateHooksEnabledToBoolean(context)
+
 	// Clean up MCP marketplace catalog from global state (moved to disk cache)
 	await cleanupMcpMarketplaceCatalogFromGlobalState(context)
 

src/core/api/index.ts

@@ -51,6 +51,7 @@ export interface ApiHandler {
 	createMessage(systemPrompt: string, messages: ClineStorageMessage[], tools?: ClineTool[], useResponseApi?: boolean): ApiStream
 	getModel(): ApiHandlerModel
 	getApiStreamUsage?(): Promise<ApiStreamUsageChunk | undefined>
+	abort?(): void
 }
 
 export interface ApiHandlerModel {
@@ -61,6 +62,7 @@ export interface ApiHandlerModel {
 export interface ApiProviderInfo {
 	providerId: string
 	model: ApiHandlerModel
+	mode: Mode
 	customPrompt?: string // "compact"
 	autoCondenseThreshold?: number // 0-1 range
 }
@@ -178,6 +180,8 @@ function createHandlerForProvider(
 				openAiNativeApiKey: options.openAiNativeApiKey,
 				reasoningEffort: mode === "plan" ? options.planModeReasoningEffort : options.actModeReasoningEffort,
 				apiModelId: mode === "plan" ? options.planModeApiModelId : options.actModeApiModelId,
+				thinkingBudgetTokens:
+					mode === "plan" ? options.planModeThinkingBudgetTokens : options.actModeThinkingBudgetTokens,
 			})
 		case "deepseek":
 			return new DeepSeekHandler({

src/core/api/providers/bedrock.ts

@@ -104,6 +104,7 @@ interface CachePointContentBlock {
 
 // Define provider options type based on AWS SDK patterns
 interface ProviderChainOptions {
+	clientConfig?: { userAgentAppId?: string }
 	ignoreCache?: boolean
 	profile?: string
 }
@@ -211,7 +212,12 @@ export class AwsBedrockHandler implements ApiHandler {
 		sessionToken?: string
 	}> {
 		// Configure provider options
-		const providerOptions: ProviderChainOptions = {}
+		const providerOptions: ProviderChainOptions = {
+			clientConfig: {
+				// set the inner sts client userAgentAppId
+				userAgentAppId: `cline#${ExtensionRegistryInfo.version}`,
+			},
+		}
 		const useProfile =
 			(this.options.awsAuthentication === undefined && this.options.awsUseProfile) ||
 			this.options.awsAuthentication === "profile"

src/core/api/providers/claude-code.ts

@@ -121,7 +121,7 @@ export class ClaudeCodeHandler implements ApiHandler {
 									function: {
 										id: content.id,
 										name: content.name,
-										arguments: content.input,
+										arguments: JSON.stringify(content.input),
 									},
 								},
 							}

src/core/api/providers/cline.ts

@@ -199,7 +199,7 @@ export class ClineHandler implements ApiHandler {
 					// @ts-ignore-next-line
 					let totalCost = (chunk.usage.cost || 0) + (chunk.usage.cost_details?.upstream_inference_cost || 0)
 
-					if (["x-ai/grok-code-fast-1", "minimax/minimax-m2", "stealth/microwave"].includes(this.getModel().id)) {
+					if (["x-ai/grok-code-fast-1", "minimax/minimax-m2"].includes(this.getModel().id)) {
 						totalCost = 0
 					}
 

src/core/api/providers/gemini.ts

@@ -16,9 +16,6 @@ import { RetriableError, withRetry } from "../retry"
 import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
 import { ApiStream } from "../transform/stream"
 
-// Define a default TTL for the cache (e.g., 15 minutes in seconds)
-const _DEFAULT_CACHE_TTL_SECONDS = 900
-
 const rateLimitPatterns = [/got status: 429/i, /429 Too Many Requests/i, /rate limit exceeded/i, /too many requests/i]
 
 interface GeminiHandlerOptions extends CommonApiHandlerOptions {
@@ -120,13 +117,17 @@ export class GeminiHandler implements ApiHandler {
 		const _thinkingBudget = this.options.thinkingBudgetTokens ?? 0
 		const maxBudget = info.thinkingConfig?.maxBudget ?? 24576
 		const thinkingBudget = Math.min(_thinkingBudget, maxBudget)
-		// When ThinkingLevel is defineded, thinking budget cannot be zero
+		// When ThinkingLevel is defined, thinking budget cannot be zero
 		// and only level is used to control thinking behavior.
+		// Only set thinkingLevel for models that support it
 		let thinkingLevel: ThinkingLevel | undefined
-		if (this.options.thinkingLevel === "low") {
-			thinkingLevel = ThinkingLevel.LOW
-		} else if (this.options.thinkingLevel === "high") {
-			thinkingLevel = ThinkingLevel.HIGH
+		if (info.thinkingConfig?.supportsThinkingLevel) {
+			const level = this.options.thinkingLevel || info.thinkingConfig.geminiThinkingLevel
+			if (level === "high") {
+				thinkingLevel = ThinkingLevel.HIGH
+			} else if (level === "low") {
+				thinkingLevel = ThinkingLevel.LOW
+			}
 		}
 
 		// Set up base generation config
@@ -139,16 +140,18 @@ export class GeminiHandler implements ApiHandler {
 			temperature: info.temperature ?? 1,
 		}
 
-		// Add thinking config if the model supports it
-		requestConfig.thinkingConfig = {
-			// Turn off thinking:
-			// thinkingBudget: 0
-			// Turn on dynamic thinking:
-			// thinkingBudget: -1
-			// Turn on fixed thinking budget:
-			thinkingBudget: thinkingLevel ? undefined : thinkingBudget,
-			thinkingLevel,
-			includeThoughts: thinkingBudget > 0 || !!thinkingLevel,
+		// Add thinking config only if the model supports it
+		if (info.thinkingConfig) {
+			requestConfig.thinkingConfig = {
+				// Turn off thinking:
+				// thinkingBudget: 0
+				// Turn on dynamic thinking:
+				// thinkingBudget: -1
+				// Turn on fixed thinking budget:
+				thinkingBudget: thinkingLevel ? undefined : thinkingBudget, // Use budget only if thinkingLevel is not set
+				thinkingLevel,
+				includeThoughts: thinkingBudget > 0 || !!thinkingLevel,
+			}
 		}
 
 		// Generate content using the configured parameters

src/core/api/providers/mistral.ts

@@ -30,9 +30,25 @@ export class MistralHandler implements ApiHandler {
 			}
 			try {
 				// Create HTTP client with custom fetch for proxy support
+				// The Mistral SDK's HTTPClient passes a Request object to the fetcher,
+				// but we need to extract the URL and init options to pass to our fetch wrapper
+				// which properly handles proxy configuration in standalone mode (JetBrains/CLI)
 				const httpClient = new HTTPClient({
-					fetcher: (request) => {
-						return fetch(request)
+					fetcher: async (input: RequestInfo | URL, init?: RequestInit) => {
+						// Handle both string/URL and Request object inputs
+						if (input instanceof Request) {
+							return fetch(input.url, {
+								method: input.method,
+								headers: input.headers,
+								body: input.body,
+								redirect: input.redirect,
+								signal: input.signal,
+								// duplex is required when sending a body stream in Node.js/undici
+								duplex: input.body ? "half" : undefined,
+								...init,
+							} as RequestInit)
+						}
+						return fetch(input, init)
 					},
 				})
 

src/core/api/providers/ollama.ts

@@ -121,4 +121,8 @@ export class OllamaHandler implements ApiHandler {
 			},
 		}
 	}
+
+	abort(): void {
+		this.client?.abort()
+	}
 }

src/core/api/providers/openai-native.ts

@@ -1,10 +1,18 @@
-import { ModelInfo, OpenAiNativeModelId, openAiNativeDefaultModelId, openAiNativeModels } from "@shared/api"
+import {
+	ModelInfo,
+	OpenAiCompatibleModelInfo,
+	OpenAiNativeModelId,
+	openAiNativeDefaultModelId,
+	openAiNativeModels,
+} from "@shared/api"
 import { calculateApiCostOpenAI } from "@utils/cost"
 import OpenAI from "openai"
 import type { ChatCompletionReasoningEffort, ChatCompletionTool } from "openai/resources/chat/completions"
 import { Logger } from "@/services/logging/Logger"
 import { ClineStorageMessage } from "@/shared/messages/content"
 import { fetch } from "@/shared/net"
+import { ApiFormat } from "@/shared/proto/cline/models"
+import { isGPT5ModelFamily } from "@/utils/model-utils"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
 import { convertToOpenAiMessages } from "../transform/openai-format"
@@ -15,6 +23,7 @@ import { getOpenAIToolParams, ToolCallProcessor } from "../transform/tool-call-p
 interface OpenAiNativeHandlerOptions extends CommonApiHandlerOptions {
 	openAiNativeApiKey?: string
 	reasoningEffort?: string
+	thinkingBudgetTokens?: number
 	apiModelId?: string
 }
 
@@ -61,13 +70,12 @@ export class OpenAiNativeHandler implements ApiHandler {
 	}
 
 	@withRetry()
-	async *createMessage(
-		systemPrompt: string,
-		messages: ClineStorageMessage[],
-		tools?: ChatCompletionTool[],
-		useResponseFormat = false,
-	): ApiStream {
-		if (useResponseFormat) {
+	async *createMessage(systemPrompt: string, messages: ClineStorageMessage[], tools?: ChatCompletionTool[]): ApiStream {
+		// Responses API requires tool format to be set to OPENAI_RESPONSES with native tools calling enabled
+		if (this.getModel()?.info?.apiFormat === ApiFormat.OPENAI_RESPONSES) {
+			if (!tools?.length) {
+				throw new Error("Native Tool Call must be enabled in your setting for OpenAI Responses API")
+			}
 			yield* this.createResponseStream(systemPrompt, messages, tools)
 		} else {
 			yield* this.createCompletionStream(systemPrompt, messages, tools)
@@ -83,119 +91,57 @@ export class OpenAiNativeHandler implements ApiHandler {
 		const model = this.getModel()
 		const toolCallProcessor = new ToolCallProcessor()
 
-		switch (model.id) {
-			case "o1":
-			case "o1-preview":
-			case "o1-mini": {
-				// o1 doesn't support streaming, non-1 temp, or system prompt
-				const response = await client.chat.completions.create({
-					model: model.id,
-					messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
-				})
+		// Handle o1 models separately as they don't support streaming
+		if (model.info.supportsStreaming === false) {
+			const response = await client.chat.completions.create({
+				model: model.id,
+				messages: [{ role: "user", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
+			})
+			yield {
+				type: "text",
+				text: response.choices[0]?.message.content || "",
+			}
+			yield* this.yieldUsage(model.info, response.usage)
+			return
+		}
+
+		const systemRole = model.info.systemRole ?? "system"
+		const includeReasoning = this.options.thinkingBudgetTokens && model.info.supportsReasoningEffort
+		const includeTools = model.info.supportsTools ?? true
+		const reasoningEffort = includeReasoning
+			? (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium"
+			: undefined
+
+		const stream = await client.chat.completions.create({
+			model: model.id,
+			messages: [{ role: systemRole, content: systemPrompt }, ...convertToOpenAiMessages(messages)],
+			stream: true,
+			stream_options: { include_usage: true },
+			reasoning_effort: reasoningEffort,
+			...(model.info.temperature !== undefined ? { temperature: model.info.temperature } : {}),
+			...(includeTools ? getOpenAIToolParams(tools, isGPT5ModelFamily(model.id)) : {}),
+		})
+
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+			if (delta?.content) {
 				yield {
 					type: "text",
-					text: response.choices[0]?.message.content || "",
+					text: delta.content,
 				}
-
-				yield* this.yieldUsage(model.info, response.usage)
-
-				break
 			}
-			case "o4-mini":
-			case "o3":
-			case "o3-mini": {
-				const stream = await client.chat.completions.create({
-					model: model.id,
-					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
-					stream: true,
-					stream_options: { include_usage: true },
-					reasoning_effort: (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium",
-				})
 
-				for await (const chunk of stream) {
-					const delta = chunk.choices[0]?.delta
-					if (delta?.content) {
-						yield {
-							type: "text",
-							text: delta.content,
-						}
-					}
-					if (chunk.usage) {
-						// Only last chunk contains usage
-						yield* this.yieldUsage(model.info, chunk.usage)
-					}
+			if (delta?.tool_calls) {
+				try {
+					yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
+				} catch (error) {
+					console.error("Error processing tool call delta:", error, delta.tool_calls)
 				}
-				break
 			}
-			case "gpt-5-2025-08-07":
-			case "gpt-5-mini-2025-08-07":
-			case "gpt-5-nano-2025-08-07":
-			case "gpt-5.1-2025-11-13":
-			case "gpt-5.1-chat-latest":
-			case "gpt-5.1": {
-				const stream = await client.chat.completions.create({
-					model: model.id,
-					temperature: 1,
-					messages: [{ role: "developer", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
-					stream: true,
-					stream_options: { include_usage: true },
-					reasoning_effort: (this.options.reasoningEffort as ChatCompletionReasoningEffort) || "medium",
-					...getOpenAIToolParams(tools),
-				})
 
-				for await (const chunk of stream) {
-					const delta = chunk.choices[0]?.delta
-					if (delta?.content) {
-						yield {
-							type: "text",
-							text: delta.content,
-						}
-					}
-
-					if (delta?.tool_calls) {
-						try {
-							yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
-						} catch (error) {
-							console.error("Error processing tool call delta:", error, delta.tool_calls)
-						}
-					}
-
-					if (chunk.usage) {
-						// Only last chunk contains usage - stream is ending
-						yield* this.yieldUsage(model.info, chunk.usage)
-					}
-				}
-				break
-			}
-			default: {
-				const stream = await client.chat.completions.create({
-					model: model.id,
-					// max_completion_tokens: this.getModel().info.maxTokens,
-					temperature: 0,
-					messages: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
-					stream: true,
-					stream_options: { include_usage: true },
-					...getOpenAIToolParams(tools),
-				})
-
-				for await (const chunk of stream) {
-					const delta = chunk.choices[0]?.delta
-					if (delta?.content) {
-						yield {
-							type: "text",
-							text: delta.content,
-						}
-					}
-
-					if (delta?.tool_calls) {
-						yield* toolCallProcessor.processToolCallDeltas(delta.tool_calls)
-					}
-
-					if (chunk.usage) {
-						// Only last chunk contains usage - stream is ending
-						yield* this.yieldUsage(model.info, chunk.usage)
-					}
-				}
+			if (chunk.usage) {
+				// Only last chunk contains usage
+				yield* this.yieldUsage(model.info, chunk.usage)
 			}
 		}
 	}
@@ -203,7 +149,7 @@ export class OpenAiNativeHandler implements ApiHandler {
 	private async *createResponseStream(
 		systemPrompt: string,
 		messages: ClineStorageMessage[],
-		tools?: ChatCompletionTool[],
+		tools: ChatCompletionTool[],
 	): ApiStream {
 		const client = this.ensureClient()
 		const model = this.getModel()
@@ -402,15 +348,16 @@ export class OpenAiNativeHandler implements ApiHandler {
 		}
 	}
 
-	getModel(): { id: OpenAiNativeModelId; info: ModelInfo } {
+	getModel(): { id: OpenAiNativeModelId; info: OpenAiCompatibleModelInfo } {
 		const modelId = this.options.apiModelId
 		if (modelId && modelId in openAiNativeModels) {
 			const id = modelId as OpenAiNativeModelId
-			return { id, info: openAiNativeModels[id] }
+			const info = openAiNativeModels[id]
+			return { id, info: { ...info } }
 		}
 		return {
 			id: openAiNativeDefaultModelId,
-			info: openAiNativeModels[openAiNativeDefaultModelId],
+			info: { ...openAiNativeModels[openAiNativeDefaultModelId] },
 		}
 	}
 }

src/core/api/providers/vertex.ts

@@ -83,84 +83,41 @@ export class VertexHandler implements ApiHandler {
 
 		// Claude implementation
 		const budget_tokens = this.options.thinkingBudgetTokens || 0
-		const reasoningOn = !!(
-			(modelId.includes("3-7") ||
-				modelId.includes("sonnet-4") ||
-				modelId.includes("opus-4") ||
-				modelId.includes("haiku-4-5")) &&
-			budget_tokens !== 0
-		)
+		// Use model metadata to determine if reasoning should be enabled
+		const reasoningOn = (model.info.supportsReasoning ?? false) && budget_tokens !== 0
+
 		// Tools are available only when native tools are enabled.
 		const nativeToolsOn = tools?.length ? tools?.length > 0 : false
 
-		let stream
+		const anthropicMessages = sanitizeAnthropicMessages(messages, model.info.supportsPromptCache ?? false)
 
-		switch (modelId) {
-			case "claude-haiku-4-5@20251001":
-			case "claude-sonnet-4-5@20250929":
-			case "claude-sonnet-4@20250514":
-			case "claude-opus-4-5@20251101":
-			case "claude-opus-4-1@20250805":
-			case "claude-opus-4@20250514":
-			case "claude-3-7-sonnet@20250219":
-			case "claude-3-5-sonnet-v2@20241022":
-			case "claude-3-5-sonnet@20240620":
-			case "claude-3-5-haiku@20241022":
-			case "claude-3-opus@20240229":
-			case "claude-3-haiku@20240307": {
-				const anthropicMessages = sanitizeAnthropicMessages(messages, true)
-				stream = await clientAnthropic.beta.messages.create(
+		const stream = await clientAnthropic.beta.messages.create(
+			{
+				model: modelId,
+				max_tokens: model.info.maxTokens || 8192,
+				thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
+				temperature: reasoningOn ? undefined : 0,
+				system: [
 					{
-						model: modelId,
-						max_tokens: model.info.maxTokens || 8192,
-						thinking: reasoningOn ? { type: "enabled", budget_tokens: budget_tokens } : undefined,
-						temperature: reasoningOn ? undefined : 0,
-						system: [
-							{
-								text: systemPrompt,
-								type: "text",
-								cache_control: { type: "ephemeral" },
-							},
-						],
-						messages: anthropicMessages,
-						stream: true,
-						tools: nativeToolsOn ? (tools as AnthropicTool[]) : undefined,
-						// tool_choice options:
-						// - none: disables tool use, even if tools are provided. Claude will not call any tools.
-						// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
-						// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
-						// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
-						tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
+						text: systemPrompt,
+						type: "text",
+						cache_control: model.info.supportsPromptCache ? { type: "ephemeral" } : undefined,
 					},
-					{
-						headers: {},
-					},
-				)
-				break
-			}
-			default: {
-				stream = await clientAnthropic.beta.messages.create({
-					model: modelId,
-					max_tokens: model.info.maxTokens || 8192,
-					temperature: 0,
-					system: [
-						{
-							text: systemPrompt,
-							type: "text",
-						},
-					],
-					messages: sanitizeAnthropicMessages(messages, false),
-					stream: true,
-					tools: tools?.length ? (tools as AnthropicTool[]) : undefined,
-					// tool_choice options:
-					// - none: disables tool use, even if tools are provided. Claude will not call any tools.
-					// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
-					// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
-					tool_choice: tools ? { type: "any" } : undefined,
-				})
-				break
-			}
-		}
+				],
+				messages: anthropicMessages,
+				stream: true,
+				tools: nativeToolsOn ? (tools as AnthropicTool[]) : undefined,
+				// tool_choice options:
+				// - none: disables tool use, even if tools are provided. Claude will not call any tools.
+				// - auto: allows Claude to decide whether to call any provided tools or not. This is the default value when tools are provided.
+				// - any: tells Claude that it must use one of the provided tools, but doesn’t force a particular tool.
+				// NOTE: Forcing tool use when tools are provided will result in error when thinking is also enabled.
+				tool_choice: nativeToolsOn && !reasoningOn ? { type: "any" } : undefined,
+			},
+			{
+				headers: {},
+			},
+		)
 
 		const lastStartedToolCall = { id: "", name: "", arguments: "" }