feat(telemetry): add policy-based telemetry control with env override

Implement TelemetrySettingsPolicyManager to centrally manage telemetry
state with support for environment-level overrides. This allows
enterprises to completely disable all telemetry via
OTEL_TELEMETRY_ENABLED=0 environment variable, regardless of user
preferences or IDE settings.

Key changes:
- Add policy manager that evaluates telemetry state from multiple sources
- Support OTEL_TELEMETRY_ENABLED=0 to force-disable all telemetry
- Dynamically switch between active and NoOp telemetry providers
- Update .env.example with clearer documentation about override behavior
- Make telemetry state updates async to properly await policy changes
- Subscribe to policy changes for runtime provider switching

This ensures enterprise environments have a reliable kill switch for
all telemetry that cannot be overridden by user settings.

.changeset/fruity-crabs-mate.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fixed proto naming issue - RPC >>> Rpc

.changeset/grumpy-maps-sneeze.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-fix a11y for auto approve checkbox

.changeset/short-carrots-tie.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Support Feature Flags default values

.changeset/smooth-items-hammer.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Adding oca as a provider to cline cli

.changeset/wet-islands-film.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Changes to allow users to manually enter model names (eg. presets) when using OpenRouter

.claude/commands/hotfix-release.md

@@ -1,194 +0,0 @@
-# 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/hooks/PostToolUse.example

@@ -1,19 +1,54 @@
 #!/usr/bin/env bash
+# PostToolUse Hook Example
+# 
+# This hook runs AFTER a tool is executed. It can:
+# 1. Observe tool results and outcomes
+# 2. Add context for FUTURE tool uses via contextModification
+# 3. Log or track tool usage patterns
+#
+# IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
+# The tool has already completed when this hook runs.
 
-echo "PostToolUse running inside local cline/.clinerules/hooks/ directory"
-
+# Read the hook input (JSON via stdin)
 input=$(cat)
-echo $input | jq .
 
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
+# Extract tool information
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName // "unknown"')
+parameters=$(echo "$input" | jq -r '.postToolUse.parameters // {}')
+result=$(echo "$input" | jq -r '.postToolUse.result // ""')
+success=$(echo "$input" | jq -r '.postToolUse.success // false')
+execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs // 0')
 
+# Example 1: Learning from file operations
+# Track successful file creations to build context about project structure
+# if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
+#   path=$(echo "$parameters" | jq -r '.path // ""')
+#   cat <<EOF
+# {
+#   "shouldContinue": true,
+#   "contextModification": "FILE_OPERATIONS: Successfully created '$path'. Future operations should maintain consistency with this file's patterns and structure."
+# }
+# EOF
+#   exit 0
+# fi
+
+# Example 2: Performance monitoring
+# Warn about slow operations
+# if [[ "$execution_time" -gt 5000 ]]; then
+#   cat <<EOF
+# {
+#   "shouldContinue": true,
+#   "contextModification": "PERFORMANCE: Tool '$tool_name' took ${execution_time}ms to complete. Consider optimizing future similar operations or breaking them into smaller steps."
+# }
+# EOF
+#   exit 0
+# fi
+
+# Example 3: Context injection for future tool uses
+# The context will be available in the NEXT API request
 cat <<EOF
 {
-  "cancel": false,
-  "contextModification": "PostToolUse response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "PostToolUse hook custom errorMessage"
+  "shouldContinue": true,
+  "contextModification": "TOOL_RESULT: The tool '$tool_name' completed with success=$success. Consider validating the results before proceeding to the next step."
 }
 EOF

.clinerules/hooks/PreToolUse.example

@@ -1,19 +1,42 @@
 #!/usr/bin/env bash
+# PreToolUse Hook Example
+# 
+# This hook runs BEFORE a tool is executed. It can:
+# 1. Block execution by returning {"shouldContinue": false}
+# 2. Add context for FUTURE tool uses via contextModification
+# 3. Validate tool parameters
+#
+# IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
+# The tool parameters are already determined when this hook runs.
 
-echo "PreToolUse running inside local cline/.clinerules/hooks/ directory"
-
+# Read the hook input (JSON via stdin)
 input=$(cat)
-echo $input | jq .
 
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
+# Extract tool information
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName // "unknown"')
+parameters=$(echo "$input" | jq -r '.preToolUse.parameters // {}')
 
+# Example 1: Validation - Block invalid operations
+# Uncomment to prevent creating .js files in a TypeScript project
+# if [[ "$tool_name" == "write_to_file" ]]; then
+#   path=$(echo "$parameters" | jq -r '.path // ""')
+#   if [[ "$path" == *.js ]]; then
+#     cat <<EOF
+# {
+#   "shouldContinue": false,
+#   "errorMessage": "VALIDATION FAILED: Cannot create .js files in TypeScript project. Please use .ts extension instead.",
+#   "contextModification": "WORKSPACE_RULES: This is a strict TypeScript project. All new files must use .ts or .tsx extensions."
+# }
+# EOF
+#     exit 0
+#   fi
+# fi
+
+# Example 2: Context injection for future tool uses
+# The context will be available in the NEXT API request after this tool completes
 cat <<EOF
 {
-  "cancel": false,
-  "contextModification": "PreToolUse response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "PreToolUse hook custom errorMessage"
+  "shouldContinue": true,
+  "contextModification": "WORKSPACE_RULES: [For future tool uses] This is a TypeScript React project. When creating files, use .ts/.tsx extensions and include detailed comments explaining the purpose and usage of each function."
 }
 EOF

.clinerules/hooks/README.md

@@ -3,8 +3,8 @@
 ## Overview
 
 Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks can be placed in either:
-- **Global hooks directory**: `~/Documents/Cline/Hooks/` (applies to all workspaces)
-- **Workspace hooks directory**: `.clinerules/hooks/` (applies to the workspace the repo is part of)
+- **Global hooks directory**: `~/Documents/Cline/Rules/Hooks/` (applies to all workspaces)
+- **Workspace hooks directory**: `.clinerules/hooks/` (applies to specific workspace)
 
 Hooks run automatically when enabled.
 
@@ -17,54 +17,17 @@ Hooks run automatically when enabled.
 
 ## Available Hooks
 
-### TaskStart Hook
-- **When**: Runs when a NEW task is started (not when resuming)
-- **Purpose**: Initialize task context, validate task requirements, set up environment
-- **Global Location**: `~/Documents/Cline/Hooks/TaskStart`
-- **Workspace Location**: `.clinerules/hooks/TaskStart`
-
-### TaskResume Hook
-- **When**: Runs when an EXISTING task is resumed (after user clicks resume button)
-- **Purpose**: Validate resumed task state, restore context, check for changes since last run
-- **Global Location**: `~/Documents/Cline/Hooks/TaskResume`
-- **Workspace Location**: `.clinerules/hooks/TaskResume`
-
-### TaskCancel Hook
-- **When**: Runs when a task is cancelled or a hook is aborted by the user (only if there's actual active work or work was started)
-- **Purpose**: Clean up resources, log cancellation, save state
-- **Global Location**: `~/Documents/Cline/Hooks/TaskCancel`
-- **Workspace Location**: `.clinerules/hooks/TaskCancel`
-- **Note**: This hook is NOT cancellable
-
-### TaskComplete Hook (coming soon!)
-- **When**: Runs when a task is marked as complete
-- **Purpose**: Log completion status, perform final cleanup, generate reports
-- **Global Location**: `~/Documents/Cline/Hooks/TaskComplete`
-- **Workspace Location**: `.clinerules/hooks/TaskComplete`
-
-### UserPromptSubmit Hook
-- **When**: Runs when the user submits a prompt/message (initial task, resume, or feedback)
-- **Purpose**: Validate user input, preprocess prompts, add context to user messages
-- **Global Location**: `~/Documents/Cline/Hooks/UserPromptSubmit`
-- **Workspace Location**: `.clinerules/hooks/UserPromptSubmit`
-
 ### PreToolUse Hook
 - **When**: Runs BEFORE a tool is executed
 - **Purpose**: Validate parameters, block execution, or add context
-- **Global Location**: `~/Documents/Cline/Hooks/PreToolUse`
-- **Workspace Location**: `.clinerules/hooks/PreToolUse`
+- **Global Location**: `~/Documents/Cline/Rules/Hooks/PreToolUse` (all platforms)
+- **Workspace Location**: `.clinerules/hooks/PreToolUse` (all platforms)
 
 ### PostToolUse Hook
 - **When**: Runs AFTER a tool completes
 - **Purpose**: Observe results, track patterns, or add context
-- **Global Location**: `~/Documents/Cline/Hooks/PostToolUse`
-- **Workspace Location**: `.clinerules/hooks/PostToolUse`
-
-### PreCompact Hook (coming soon!)
-- **When**: Runs BEFORE the conversation context is compacted/truncated
-- **Purpose**: Observe compaction events, log context management, track token usage
-- **Global Location**: `~/Documents/Cline/Hooks/PreCompact`
-- **Workspace Location**: `.clinerules/hooks/PreCompact`
+- **Global Location**: `~/Documents/Cline/Rules/Hooks/PostToolUse` (all platforms)
+- **Workspace Location**: `.clinerules/hooks/PostToolUse` (all platforms)
 
 ## Cross-Platform Hook Format
 
@@ -74,12 +37,13 @@ Cline uses a git-style approach for hooks that works consistently across all pla
 - **No file extensions**: Hooks are named exactly `PreToolUse` or `PostToolUse` (no `.bat`, `.cmd`, `.sh` etc.)
 - **Shebang required**: First line must be a shebang (e.g., `#!/usr/bin/env bash` or `#!/usr/bin/env node`)
 - **Executable on Unix**: On Unix/Linux/macOS, hooks must be executable: `chmod +x PreToolUse`
-- **Windows**: Not currently supported.
+- **Windows**: No special permissions needed - hooks are executed through the shell
 
 ### How It Works
 
 Like git hooks, Cline executes hook files through a shell that interprets the shebang line:
 - On Unix/Linux/macOS: Native shell execution with shebang support
+- On Windows: Shell execution handles shebang interpretation
 
 This means:
 - ✅ Same hook script works on all platforms
@@ -91,10 +55,16 @@ This means:
 **On Unix/Linux/macOS:**
 ```bash
 # Create hook file
-nano ~/Documents/Cline/Hooks/PreToolUse
+nano ~/Documents/Cline/Rules/Hooks/PreToolUse
 
 # Make executable
-chmod +x ~/Documents/Cline/Hooks/PreToolUse
+chmod +x ~/Documents/Cline/Rules/Hooks/PreToolUse
+```
+
+**On Windows:**
+```batch
+REM Create hook file (note: no file extension)
+notepad %USERPROFILE%\Documents\Cline\Rules\Hooks\PreToolUse
 ```
 
 ## Context Injection Timing
@@ -137,46 +107,11 @@ All hooks receive:
 ```json
 {
   "clineVersion": "string",
-  "hookName": "TaskStart" | "TaskResume" | "TaskCancel" | "TaskComplete" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PreCompact",
+  "hookName": "PreToolUse" | "PostToolUse",
   "timestamp": "string",
   "taskId": "string",
   "workspaceRoots": ["string"],
   "userId": "string",
-  "taskStart": {  // Only for TaskStart
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string",
-      "initialTask": "string"
-    }
-  },
-  "taskResume": {  // Only for TaskResume
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string"
-    },
-    "previousState": {
-      "lastMessageTs": "string",
-      "messageCount": "string",
-      "conversationHistoryDeleted": "string"
-    }
-  },
-  "taskCancel": {  // Only for TaskCancel
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string",
-      "completionStatus": "string"
-    }
-  },
-  "taskComplete": {  // Only for TaskComplete
-    "taskMetadata": {
-      "taskId": "string",
-      "ulid": "string"
-    }
-  },
-  "userPromptSubmit": {  // Only for UserPromptSubmit
-    "prompt": "string",
-    "attachments": ["string"]
-  },
   "preToolUse": {  // Only for PreToolUse
     "toolName": "string",
     "parameters": {}
@@ -187,11 +122,6 @@ All hooks receive:
     "result": "string",
     "success": boolean,
     "executionTimeMs": number
-  },
-  "preCompact": {  // Only for PreCompact
-    "contextSize": number,
-    "messagesToCompact": number,
-    "compactionStrategy": "string"
   }
 }
 ```
@@ -201,21 +131,38 @@ All hooks receive:
 All hooks must return:
 ```json
 {
-  "cancel": boolean,                   // Required: false to continue, true to block execution
-  "contextModification": "string",     // Optional: Context for future AI decisions
+  "shouldContinue": boolean,           // Required: Allow or block execution
+  "contextModification": "string",      // Optional: Context for future tool uses
   "errorMessage": "string"             // Optional: Error details if blocking
 }
 ```
 
-**Note**: The `cancel` field works as follows:
-- `false` (or omitted): Allow execution to continue
-- `true`: Block execution and show error message to user
+## Context Modification Format
+
+Use structured prefixes to help the AI understand context type:
+
+- `WORKSPACE_RULES:` - Project conventions and requirements
+- `FILE_OPERATIONS:` - File creation/modification patterns
+- `TOOL_RESULT:` - Outcomes of tool executions
+- `PERFORMANCE:` - Performance concerns
+- `VALIDATION:` - Validation results
+- Custom prefixes as needed
+
+Example:
+```bash
+cat <<EOF
+{
+  "shouldContinue": true,
+  "contextModification": "WORKSPACE_RULES: This is a TypeScript project. All new files must use .ts or .tsx extensions."
+}
+EOF
+```
 
 ## Hook Execution Limits
 
-- **Timeout**: Hooks must complete within 30 seconds (configurable via `HOOK_EXECUTION_TIMEOUT_MS`)
-- **Context Size**: Context modifications are limited to 50KB (configurable via `MAX_CONTEXT_MODIFICATION_SIZE`)
-- **Error Handling**: Expected errors (file not found, permission denied, not a directory) are handled silently; unexpected file system errors are propagated
+- **Timeout**: Hooks must complete within 30 seconds
+- **Context Size**: Context modifications are limited to 50KB
+- **Error Handling**: Unexpected file system errors are propagated; expected errors (file not found, permission denied) are handled silently
 
 ## Common Use Cases
 
@@ -230,15 +177,15 @@ path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
 if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
   cat <<EOF
 {
-  "cancel": true,
+  "shouldContinue": false,
   "errorMessage": "Cannot create .js files in TypeScript project",
-  "contextModification": "Use .ts/.tsx extensions only"
+  "contextModification": "WORKSPACE_RULES: Use .ts/.tsx extensions only"
 }
 EOF
   exit 0
 fi
 
-echo '{"cancel": false}'
+echo '{"shouldContinue": true}'
 ```
 
 ### 2. Context Building - Learn from Operations
@@ -253,12 +200,12 @@ path=$(echo "$input" | jq -r '.postToolUse.parameters.path // ""')
 if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
   cat <<EOF
 {
-  "cancel": false,
-  "contextModification": "Created '$path'. Maintain consistency with this file's patterns in future operations."
+  "shouldContinue": true,
+  "contextModification": "FILE_OPERATIONS: Created '$path'. Maintain consistency with this file's patterns in future operations."
 }
 EOF
 else
-  echo '{"cancel": false}'
+  echo '{"shouldContinue": true}'
 fi
 ```
 
@@ -273,12 +220,12 @@ tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
 if [[ "$execution_time" -gt 5000 ]]; then
   cat <<EOF
 {
-  "cancel": false,
-  "contextModification": "Tool '$tool_name' took ${execution_time}ms. Consider optimizing future similar operations."
+  "shouldContinue": true,
+  "contextModification": "PERFORMANCE: Tool '$tool_name' took ${execution_time}ms. Consider optimizing future similar operations."
 }
 EOF
 else
-  echo '{"cancel": false}'
+  echo '{"shouldContinue": true}'
 fi
 ```
 
@@ -292,7 +239,7 @@ input=$(cat)
 echo "$input" >> ~/.cline/hook-logs/tool-usage.jsonl
 
 # Allow execution
-echo '{"cancel": false}'
+echo '{"shouldContinue": true}'
 ```
 
 ## Global vs Workspace Hooks
@@ -300,40 +247,44 @@ echo '{"cancel": false}'
 Cline supports two levels of hooks:
 
 ### Global Hooks
-- **Location**: `~/Documents/Cline/Hooks/` (macOS/Linux)
+- **Location**: `~/Documents/Cline/Rules/Hooks/` (macOS/Linux) or `%USERPROFILE%\Documents\Cline\Rules\Hooks\` (Windows)
 - **Scope**: Apply to ALL workspaces and projects
 - **Use Case**: Organization-wide policies, personal preferences, universal validations
-- **Priority**: Order not guaranteed when combined with workspace hooks
+- **Priority**: Execute FIRST, before workspace hooks
 
 ### Workspace Hooks
 - **Location**: `.clinerules/hooks/` in each workspace root
 - **Scope**: Apply only to the specific workspace
 - **Use Case**: Project-specific rules, team conventions, repository requirements
-- **Priority**: Order not guaranteed when combined with global hooks
+- **Priority**: Execute AFTER global hooks
 
 ### Hook Execution
 
 When multiple hooks exist (global and/or workspace):
-- All hooks for a given step are executed **concurrently** using `Promise.all`
-- **Execution order is not guaranteed** - hooks run in parallel
-- If ALL hooks allow execution (`cancel: false`), the tool proceeds
-- If ANY hook blocks (`cancel: true`), execution is blocked
+- All hooks for a given step (PreToolUse or PostToolUse) are executed
+- **Execution order is not guaranteed** - hooks may run concurrently
+- If ALL hooks allow execution (`shouldContinue: true`), the tool proceeds
+- If ANY hook blocks (`shouldContinue: false`), execution is blocked
 
 **Result Combination:**
-- `cancel`: If ANY hook returns `true`, execution is blocked
-- `contextModification`: All context strings are concatenated with double newlines (`\n\n`)
-- `errorMessage`: All error messages are concatenated with single newlines (`\n`)
+- `shouldContinue`: Must be `true` from ALL hooks for execution to proceed
+- `contextModification`: All context strings are concatenated
+- `errorMessage`: All error messages are concatenated
 
 ### Setting Up Global Hooks
 
 1. The global hooks directory is automatically created at:
-   - macOS/Linux: `~/Documents/Cline/Hooks/`
+   - macOS/Linux: `~/Documents/Cline/Rules/Hooks/`
+   - Windows: `%USERPROFILE%\Documents\Cline\Rules\Hooks\`
 
 2. Add your hook script:
    ```bash
    # Unix/Linux/macOS
-   nano ~/Documents/Cline/Hooks/PreToolUse
-   chmod +x ~/Documents/Cline/Hooks/PreToolUse
+   nano ~/Documents/Cline/Rules/Hooks/PreToolUse
+   chmod +x ~/Documents/Cline/Rules/Hooks/PreToolUse
+   
+   # Windows
+   notepad %USERPROFILE%\Documents\Cline\Rules\Hooks\PreToolUse
    ```
 
 3. Enable hooks in Cline settings
@@ -343,18 +294,18 @@ When multiple hooks exist (global and/or workspace):
 **Global Hook** (applies to all projects):
 ```bash
 #!/usr/bin/env bash
-# ~/Documents/Cline/Hooks/PreToolUse
+# ~/Documents/Cline/Rules/Hooks/PreToolUse
 # Universal rule: Never delete package.json
 input=$(cat)
 tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
 path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
 
 if [[ "$tool_name" == "write_to_file" && "$path" == *"package.json"* ]]; then
-  echo '{"cancel": true, "errorMessage": "Global policy: Cannot modify package.json"}'
+  echo '{"shouldContinue": false, "errorMessage": "Global policy: Cannot modify package.json"}'
   exit 0
 fi
 
-echo '{"cancel": false}'
+echo '{"shouldContinue": true}'
 ```
 
 **Workspace Hook** (applies to specific project):
@@ -367,11 +318,11 @@ tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
 path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
 
 if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
-  echo '{"cancel": true, "errorMessage": "Project rule: Use .ts files only"}'
+  echo '{"shouldContinue": false, "errorMessage": "Project rule: Use .ts files only"}'
   exit 0
 fi
 
-echo '{"cancel": false}'
+echo '{"shouldContinue": true}'
 ```
 
 **All hooks must allow execution for the tool to proceed.** Hooks may execute concurrently.
@@ -380,7 +331,7 @@ echo '{"cancel": false}'
 
 If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks (global and workspace) may execute concurrently. Their results will be combined:
 
-- **cancel**: If ANY hook returns `true`, execution is blocked
+- **shouldContinue**: If ANY hook returns false, execution is blocked
 - **contextModification**: All context modifications are concatenated
 - **errorMessage**: All error messages are concatenated
 
@@ -401,6 +352,7 @@ If you have multiple workspace roots, you can place hooks in each root's `.cline
 
 ### Context Not Affecting Behavior
 - Remember: context affects FUTURE decisions, not the current tool
+- Use PreToolUse for validation (blocking) if you need immediate effect
 - Ensure context modifications are clear and actionable
 - Check that context isn't being truncated (50KB limit)
 

.clinerules/hooks/TaskCancel.example

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-echo "TaskCancel running inside local cline/.clinerules/hooks/ directory"
-
-input=$(cat)
-echo $input | jq .
-
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
-
-cat <<EOF
-{
-  "cancel": false,
-  "contextModification": "TaskCancel response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "TaskCancel hook custom errorMessage"
-}
-EOF

.clinerules/hooks/TaskResume.example

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-echo "TaskResume running inside local cline/.clinerules/hooks/ directory"
-
-input=$(cat)
-echo $input | jq .
-
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
-
-cat <<EOF
-{
-  "cancel": false,
-  "contextModification": "TaskResume response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "TaskResume hook custom errorMessage"
-}
-EOF

.clinerules/hooks/TaskStart.example

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-echo "TaskStart running inside local cline/.clinerules/hooks/ directory"
-
-input=$(cat)
-echo $input | jq .
-
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
-
-cat <<EOF
-{
-  "cancel": false,
-  "contextModification": "TaskStart response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "TaskStart hook custom errorMessage"
-}
-EOF

.clinerules/hooks/UserPromptSubmit.example

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-
-echo "UserPromptSubmit running inside local cline/.clinerules/hooks/ directory"
-
-input=$(cat)
-echo $input | jq .
-
-for i in {1..5}; do
-  sleep 1
-  echo "$i"
-done
-
-cat <<EOF
-{
-  "cancel": false,
-  "contextModification": "UserPromptSubmit response from the local cline/.clinerules/hooks/ directory.",
-  "errorMessage": "UserPromptSubmit hook custom errorMessage"
-}
-EOF

.clinerules/network.md

@@ -1,90 +0,0 @@
-# Networking & Proxy Support
-
-To ensure Cline works correctly in all environments (VSCode, JetBrains, CLI) and with various network configurations (especially corporate proxies), strictly follow these guidelines for all network activity.
-
-In extension code, do NOT use the global `fetch` or a default `axios` instance. (Note, `shared/net.ts` is exempt from these rules because it sets up the fetch wrappers.) In Webview code, you SHOULD use global `fetch`.
-
-Global `fetch` and default `axios` do not automatically pick up proxy configurations in all environments (specifically JetBrains and CLI). You MUST use the provided utilities in `@/shared/net` which handle proxy agent configuration. In the webview, the browser/embedder handles proxies.
-
-## Guidelines
-
-### 1. Using `fetch`
-
-Instead of `fetch(...)`, import the proxy-aware wrapper:
-
-```typescript
-import { fetch } from '@/shared/net'
-
-// Usage is identical to global fetch
-const response = await fetch('https://api.example.com/data')
-```
-
-### 2. Using `axios`
-
-When using `axios`, you must apply the settings from `getAxiosSettings()`:
-
-```typescript
-import axios from 'axios'
-import { getAxiosSettings } from '@/shared/net'
-
-const response = await axios.get('https://api.example.com/data', {
-  headers: { 'Authorization': '...' },
-  ...getAxiosSettings() // <--- CRITICAL: Injects the proxy agent if needed
-})
-```
-
-### 3. Third-Party Clients (OpenAI, Ollama, etc.)
-
-Most API client libraries allow you to customize the `fetch` implementation. You **MUST** pass the proxy-aware `fetch` to these clients.
-
-**Example (OpenAI):**
-```typescript
-import OpenAI from "openai"
-import { fetch } from "@/shared/net"
-
-this.client = new OpenAI({
-  apiKey: '...',
-  fetch, // <--- CRITICAL: Pass our fetch wrapper
-})
-```
-
-### 4. Tests
-
-Use `mockFetchForTesting` to mock the underlying fetch implementation.
-
-**Example (callback):**
-
-```
-import { mockFetchForTesting } from "@/shared/net"
-
-...
-  let mockFetch = ...
-  mockFetchForTesting(mockFetch, () => {
-    // This calls mockFetch
-    fetch('https://foo.example').then(...)
-  })
-  // Original fetch is restored immediately when the call returns.
-```
-
-**Example (Promise):**
-
-```
-import { mockFetchForTesting } from "@/shared/net"
-
-...
-  let mockFetch = ...
-  await mockFetchForTesting(mockFetch, async () => {
-    await ...
-    // This calls mockFetch
-    await fetch('https://foo.example')
-    ...
-  })
-  // Original fetch is restored when the Promise from the callback settles
-```
-
-## Verification
-
-If you are adding a new network call or integration:
-1.  Check `@/shared/net.ts` is imported.
-2.  Ensure `fetch` or `getAxiosSettings` is being used.
-3.  Verify that third-party clients are configured to use the custom fetch.

.clinerules/workflows/address-pr-comments.md

@@ -1,29 +0,0 @@
-# Address PR Comments
-
-Review and address all comments on the current branch's PR.
-
-## Steps
-
-1. Get the current branch name and find the associated PR:
-   ```bash
-   gh pr view --json number,title,body
-   ```
-
-2. Understand the PR context:
-   - Get the full diff: `git diff origin/main...HEAD`
-   - Read the changed files to understand what the PR is doing
-   - Read related files if needed to understand the broader context
-   - Understand the intent and spirit of the changes, not just the code
-
-3. Fetch all PR comments:
-   - Inline comments: `gh api repos/{owner}/{repo}/pulls/{pr_number}/comments`
-   - General comments: `gh pr view {pr_number} --json comments,reviews`
-
-4. Present a summary of all comments with your recommendation for each (apply, skip, or respond). Ignore bot noise (changeset-bot, CI status, etc.).
-
-5. **Wait for my approval** before proceeding.
-
-6. After approval:
-   - Apply code changes and commit
-   - Reply to comments that were addressed or intentionally skipped
-   - Push commits

.clinerules/workflows/extension-release.md

@@ -122,9 +122,9 @@ const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
 					title="Previous Updates:"
 					classNames={{
 						trigger: "bg-transparent border-0 pl-0 pb-0 w-fit",
-						title: "font-bold text-(--vscode-foreground)",
+						title: "font-bold text-[var(--vscode-foreground)]",
 						indicator:
-							"text-(--vscode-foreground) mb-0.5 -rotate-180 data-[open=true]:-rotate-90 rtl:rotate-0 rtl:data-[open=true]:-rotate-90",
+							"text-[var(--vscode-foreground)] mb-0.5 -rotate-180 data-[open=true]:-rotate-90 rtl:rotate-0 rtl:data-[open=true]:-rotate-90",
 					}}>
 					<ul style={ulStyle}>
 						<li>

.clinerules/workflows/find-pr-reviewers.md

@@ -1,49 +0,0 @@
-# Find Best Reviewers for Current Branch
-
-Analyze my current branch to find the best people to review my PR based on **domain expertise** and git history.
-
-## Steps
-
-1. Get the current branch name and verify it's not `main`
-2. Get the diff between the current branch and `origin/main`:
-   - Use `git diff origin/main...HEAD --name-only` to get changed files
-   - Use `git diff origin/main...HEAD` to understand the nature/spirit of the changes
-3. **Identify the domain/feature area** being changed:
-   - Read the diff carefully to understand WHAT is being changed conceptually (e.g., "slash commands", "authentication", "API client", "UI components")
-   - This semantic understanding is crucial for finding the right reviewers
-4. Find domain experts by searching for related files and their contributors:
-   - Identify all files related to the feature/domain (not just the ones changed)
-   - Example: if changing slash commands, find ALL slash-command related files across the codebase
-   - Use `git log --format="%an <%ae>" -- <related-files-pattern>` to find who has expertise in that domain
-5. For additional context, also gather:
-   - `git blame -L <start>,<end> origin/main -- <file-path>` for exact lines changed
-   - Recent commit activity on related files
-6. Score and rank contributors by:
-   - **Highest weight: Domain expertise** - who has the most commits to files in this feature area (even files not touched by this PR)
-   - **Medium weight: Direct file expertise** - commits to the specific files being changed
-   - **Lower weight: Line-level ownership** - authored the exact lines being modified
-7. Exclude myself (check against my git config user.email)
-8. Present the top 5 reviewers as an ordered list
-
-## Output Format
-
-Output an ordered list:
-
-1. **Name** - Domain expert: 15 commits to slash-command related files, authored core parsing logic
-2. **Name** - 8 commits to affected files, recently added the feature being modified
-3. ...
-
-## Commands Reference
-```bash
-git config user.email
-git diff origin/main...HEAD --name-only
-git diff origin/main...HEAD
-# Find related files for a domain (adjust pattern based on what you learn from the diff)
-find . -type f \( -name "*slash-command*" -o -name "*SlashCommand*" \) | head -20
-# Get contributors for related files
-find . -type f \( -name "*slash-command*" -o -name "*SlashCommand*" \) -print0 | xargs -0 git log --format="%an <%ae>" -- | sort | uniq -c | sort -rn
-git log --format="%an <%ae>" -- <file> | sort | uniq -c | sort -rn
-git blame -L 10,20 origin/main -- <file>
-```
-
-Do NOT ask questions - analyze the changes, identify the domain, and output the reviewer list.

.clinerules/workflows/hotfix-release.md

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

.env.example

@@ -30,7 +30,10 @@ POSTHOG_TELEMETRY_ENABLED=true          # Enable PostHog telemetry (default: tru
 # Can run alongside PostHog or independently
 # Primary focus: Logs (events), with optional metrics support
 
-# Enable OpenTelemetry (set to 1 to enable)
+# Enable/Disable OpenTelemetry (set to 1 to enable, 0 to completely disable ALL telemetry)
+# IMPORTANT: Setting OTEL_TELEMETRY_ENABLED=0 will disable ALL telemetry providers,
+# regardless of user preferences or IDE settings. Use this for enterprise environments
+# where no telemetry should leave the network.
 # OTEL_TELEMETRY_ENABLED=1
 
 # Exporters: "console" for local debugging, "otlp" for remote collector

.github/workflows/changeset-converter.yml

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

.github/workflows/publish-nightly.yml

@@ -74,9 +74,10 @@ jobs:
                   CLINE_ENVIRONMENT: production
                   # OpenTelemetry production defaults (can be overridden at runtime)
                   OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: otlp
-                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
+                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
                   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 }}
+                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
               run: npm run publish:marketplace:nightly

.github/workflows/publish.yml

@@ -60,11 +60,11 @@ jobs:
 
             - name: Install root dependencies
               if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm install --include=optional
+              run: npm ci --include=optional
 
             - name: Install webview-ui dependencies
               if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm install --include=optional
+              run: cd webview-ui && npm ci --include=optional
 
             - name: Install Publishing Tools
               run: npm install -g @vscode/vsce ovsx
@@ -99,11 +99,12 @@ 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: otlp
-                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
+                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
                   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 }}
+                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
               run: |
                   # Required to generate the .vsix
                   vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"

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

@@ -1,6 +1,6 @@
 name: Trigger Jetbrains Plugin <-> Cline Tests
 on:
-  pull_request_target:
+  pull_request:
     types: [opened, synchronize, reopened]
 permissions:
   contents: read
@@ -22,24 +22,7 @@ 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 }}" \
@@ -52,10 +35,10 @@ jobs:
             "event_type": "cline-pr-check",
             "client_payload": {
               "pr_number": "${{ github.event.number }}",
-              "branch_name": $BRANCH_NAME,
+              "branch_name": "${{ github.head_ref }}",
               "action": "${{ github.event.action }}",
               "sha": "${{ github.event.pull_request.head.sha }}",
-              "pr_title": $PR_TITLE,
+              "pr_title": ${{ toJSON(github.event.pull_request.title) }},
               "pr_url": "${{ github.event.pull_request.html_url }}"
             }
           }
@@ -64,6 +47,7 @@ jobs:
       - name: Log trigger details
         run: |
           echo "Triggered IntelliJ Plugin integration test for:"
-          echo "  PR #${{ github.event.number }}"
+          echo "  PR #${{ github.event.number }}: ${{ github.event.pull_request.title }}"
+          echo "  Branch: ${{ github.head_ref }}"
           echo "  Action: ${{ github.event.action }}"
           echo "  SHA: ${{ github.event.pull_request.head.sha }}"

.vscode/launch.json

@@ -165,27 +165,6 @@
 			},
 			"console": "integratedTerminal",
 			"internalConsoleOptions": "openOnSessionStart"
-		},
-		{
-			"name": "Open Storybook",
-			"type": "node",
-			"request": "launch",
-			"runtimeExecutable": "npm",
-			"runtimeArgs": [
-				"run",
-				"storybook"
-			],
-			"cwd": "${workspaceFolder}/webview-ui",
-			"console": "integratedTerminal",
-			"internalConsoleOptions": "neverOpen",
-			"serverReadyAction": {
-				"pattern": "Local:.*http://localhost:([0-9]+)",
-				"uriFormat": "http://localhost:%s",
-				"action": "openExternally"
-			},
-			"env": {
-				"IS_DEV": "true"
-			}
 		}
 	]
 }

.vscode/tasks.json

@@ -263,26 +263,6 @@
 				"watch"
 			],
 			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
-		},
-		{
-			"type": "npm",
-			"script": "storybook",
-			"group": "build",
-			"problemMatcher": [],
-			"isBackground": false,
-			"label": "npm: storybook",
-			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview"
-			],
-			"presentation": {
-				"reveal": "always"
-			},
-			"options": {
-				"env": {
-					"IS_DEV": "true"
-				}
-			}
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -20,9 +20,6 @@ eslint-rules/**
 .husky/**
 .env
 
-# cli
-cli/**
-
 # Custom
 **/demo.gif
 .nvmrc
@@ -40,6 +37,9 @@ 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,189 +1,5 @@
 # Changelog
 
-## [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
-- Enable NTC (Native Tool Calling) by default
-- Bug fixes and improvements for LiteLLM provider
-
-## [3.38.3]
-
-- Task export feature now opens the task directory, allowing easy access to the full task files
-- Add Grok 4.1 and Grok Code to XAI provider
-- Enabled native tool calling for Baseten and Kimi K2 models
-- Add thinking level to Gemini 3.0 Pro preview
-- Expanded Hooks functionality
-- Removed Task Timeline from Task Header
-- Bug fix for slash commands
-- Bug fixes for Vertex provider
-- Bug fixes for thinking/reasoning issues across multiple providers when using native tool calling
-- Bug fixes for terminal usage on Windows devices
-
-## [3.38.2]
-
-- Add Claude Opus 4.5
-
-## [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.
-- Add AGENTS.md support
-- feat(models): Add free minimax/mimax-m2 model to the model picker
-
-## [3.37.0]
-
-### Added
-
-- GPT-5.1 with model-specific prompting: tailored system prompts, tool usage, focus chain, and deep-planning optimizations
-- Nous Research provider with Hermes 4 model family and custom system prompts
-- Switched to Aqua Voice's Avalon model in speech to text transcription
-- Added Linux support for speech to text
-- Model-family breakouts for deep-planning prompting, laying groundwork for enhanced slash commands
-- Expanded HTTP proxy support throughout the codebase
-- Improved focus chain prompting for frontier models (Anthropic, OpenAI, Gemini, xAI)
-
-### Fixed
-
-- Duplicate tool results prevention through existence checking
-- XML entity escaping in model content processor
-- Commit message generation in command palette
-- OpenAI Compatible provider temperature parameter type conversion
-
-## Documentation
-
-- Added missing proto generation step in CONTRIBUTING.md
-- New `npm run dev` script for streamlined terminal workflow (fixes #7335)
-
-## [3.36.1]
-
-- fix: remove native tool calling support from Gemini and XAI provider due to invalid tool names issues
-- fix: disable native tool callings for grok code models
-- Add MCP tool usage to GLM
-- Removes reasoning_details content field from Anthropic providers
-
-## [3.36.0]
-
-- Add: Hooks allow you to inject custom logic into Cline's workflow
-- Add: new provider AIhubmix
-- Add: Use http_proxy, https_proxy and no_proxy in JetBrains
-- Fix: Oca Token Refresh logic
-- Fix: issues where assistant message with empty content is added to conversation history
-- Fix: bug where the checkbox shows in the model selector dropdown
-- Fix: Switch from defaultUserAgentProvider to customUserAgent for Bedrock
-- Fix: support for `<think>` tags for better compatibility with open-source models
-- Fix: refinements to the GLM-4.6 system prompt
-
-## [3.35.1]
-
-- Add: Hicap API integration as provider
-- Fix: enable Add Header button in OpenAICompatibleProvider UI
-- Fix: Remove orphaned tool_results after truncation and empty content field issues in native tool call
-- Fix: render model description in markdown
-
-## [3.35.0]
-
-- Add native tool calling support with configurable setting.
-- Auto-approve is now always-on with a redesigned expanding menu. Settings simplified and notifications moved to General Settings.
-- added zai-glm-4.6 as a Cerebras model
-- Created GPT5 family specific system prompt template
-- Fix: show reasoning budget slider to models with valid thinking config
-- Requesty base URL, and API key fixes
-- Delete all Auth Tokens when logging out
-- Support for <think> tags for models that prefer that over <thinking>
-
-## [3.34.1]
-
-- Added support for MiniMax provider with MiniMax-M2 model
-- Remove Cline/code-supernova-1-million model
-- Changes to allow users to manually enter model names (eg. presets) when using OpenRouter
-
 ## [3.34.0]
 
 - Cline Teams is now free through 2025 for unlimited users. Includes Jetbrains, RBAC, centralized billing and more.

CLAUDE.md

@@ -1,125 +0,0 @@
-# CLAUDE.md
-
-This file is the secret sauce for working effectively in this codebase. It captures tribal knowledge—the nuanced, non-obvious patterns that make the difference between a quick fix and hours of back-and-forth & human intervention.
-
-**When to add to this file:**
-- User had to intervene, correct, or hand-hold
-- Multiple back-and-forth attempts were needed to get something working
-- You discovered something that required reading many files to understand
-- A change touched files you wouldn't have guessed
-- Something worked differently than you expected
-- User explicitly asks to "add this to CLAUDE.md"
-
-**Proactively suggest additions** when any of the above happen—don't wait to be asked.
-
-**What NOT to add:** Stuff you can figure out from reading a few files, obvious patterns, or standard practices. This file should be high-signal, not comprehensive.
-
-## gRPC/Protobuf Communication
-The extension and webview communicate via gRPC-like protocol over VS Code message passing.
-
-**Proto files live in `proto/`** (e.g., `proto/cline/task.proto`, `proto/cline/ui.proto`)
-- Each feature domain has its own `.proto` file
-- For simple data, use shared types in `proto/cline/common.proto` (`StringRequest`, `Empty`, `Int64Request`)
-- For complex data, define custom messages in the feature's `.proto` file
-- Naming: Services `PascalCaseService`, RPCs `camelCase`, Messages `PascalCase`
-- For streaming responses, use `stream` keyword (see `subscribeToAuthCallback` in `account.proto`)
-
-**Run `npm run protos`** after any proto changes—generates types in:
-- `src/shared/proto/` - Shared type definitions
-- `src/generated/grpc-js/` - Service implementations
-- `src/generated/nice-grpc/` - Promise-based clients
-- `src/generated/hosts/` - Generated handlers
-
-**Adding new enum values** (like a new `ClineSay` type) requires updating conversion mappings in `src/shared/proto-conversions/cline-message.ts`
-
-**Adding new RPC methods** requires:
-- Handler in `src/core/controller/<domain>/`
-- Call from webview via generated client: `UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))`
-
-**Example—the `explain-changes` feature touched:**
-- `proto/cline/task.proto` - Added `ExplainChangesRequest` message and `explainChanges` RPC
-- `proto/cline/ui.proto` - Added `GENERATE_EXPLANATION = 29` to `ClineSay` enum
-- `src/shared/ExtensionMessage.ts` - Added `ClineSayGenerateExplanation` type
-- `src/shared/proto-conversions/cline-message.ts` - Added mapping for new say type
-- `src/core/controller/task/explainChanges.ts` - Handler implementation
-- `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
-
-## Adding Tools to System Prompt
-This is tricky—multiple prompt variants and configs. **Always search for existing similar tools first and follow their pattern.** Look at the full chain from prompt definition → variant configs → handler → UI before implementing.
-
-1. **Add to `ClineDefaultTool` enum** in `src/shared/tools.ts`
-2. **Tool definition** in `src/core/prompts/system-prompt/tools/` (create file like `generate_explanation.ts`)
-   - Define variants for each `ModelFamily` (generic, next-gen, xs, etc.)
-   - Export variants array (e.g., `export const my_tool_variants = [GENERIC, NATIVE_NEXT_GEN, XS]`)
-   - **Fallback behavior**: If a variant isn't defined for a model family, `ClineToolSet.getToolByNameWithFallback()` automatically falls back to GENERIC. So you only need to export `[GENERIC]` unless the tool needs model-specific behavior.
-3. **Register in `src/core/prompts/system-prompt/tools/init.ts`** - Import and spread into `allToolVariants`
-4. **Add to variant configs** - Each model family has its own config in `src/core/prompts/system-prompt/variants/*/config.ts`. Add your tool's enum to the `.tools()` list:
-   - `generic/config.ts`, `next-gen/config.ts`, `gpt-5/config.ts`, `native-gpt-5/config.ts`, `native-gpt-5-1/config.ts`, `native-next-gen/config.ts`, `gemini-3/config.ts`, `glm/config.ts`, `hermes/config.ts`, `xs/config.ts`
-   - **Important**: If you add to a variant's config, make sure the tool spec exports a variant for that ModelFamily (or relies on GENERIC fallback)
-5. **Create handler** in `src/core/task/tools/handlers/`
-6. **Wire up in `ToolExecutor.ts`** if needed for execution flow
-7. **Add to tool parsing** in `src/core/assistant-message/index.ts` if needed
-8. **If tool has UI feedback**: add `ClineSay` enum in proto, update `src/shared/ExtensionMessage.ts`, update `src/shared/proto-conversions/cline-message.ts`, update `webview-ui/src/components/chat/ChatRow.tsx`
-
-## Modifying System Prompt
-**Read these first:** `src/core/prompts/system-prompt/README.md`, `tools/README.md`, `__tests__/README.md`
-
-System prompt is modular: **components** (reusable sections) + **variants** (model-specific configs) + **templates** (with `{{PLACEHOLDER}}` resolution).
-
-**Key directories:**
-- `components/` - Shared sections: `rules.ts`, `capabilities.ts`, `editing_files.ts`, etc.
-- `variants/` - Model-specific: `generic/`, `next-gen/`, `xs/`, `gpt-5/`, `gemini-3/`, `hermes/`, `glm/`, etc.
-- `templates/` - Template engine and placeholder definitions
-
-**Variant tiers (ask user which to modify):**
-- **Next-gen** (Claude 4, GPT-5, Gemini 2.5): `next-gen/`, `native-next-gen/`, `native-gpt-5/`, `native-gpt-5-1/`, `gemini-3/`, `gpt-5/`
-- **Standard** (default fallback): `generic/`
-- **Local/small models**: `xs/`, `hermes/`, `glm/`
-
-**How overrides work:** Variants can override components via `componentOverrides` in their `config.ts`, or provide a custom template in `template.ts` (e.g., `next-gen/template.ts` exports `rules_template`). If no override, the shared component from `components/` is used.
-
-**Example: Adding a rule to RULES section**
-1. Check if variant overrides rules: look for `rules_template` in `variants/*/template.ts` or `componentOverrides.RULES` in `config.ts`
-2. If shared: modify `components/rules.ts`
-3. If overridden: modify that variant's template
-4. XS variant is special—has heavily condensed inline content in `template.ts`
-
-**After any changes, regenerate snapshots:**
-```bash
-UPDATE_SNAPSHOTS=true npm run test:unit
-```
-Snapshots live in `__tests__/__snapshots__/`. Tests validate across model families and context variations (browser, MCP, focus chain).
-
-## Modifying Default Slash Commands
-Three places need updates:
-- `src/core/slash-commands/index.ts` - Command definitions
-- `src/core/prompts/commands.ts` - System prompt integration
-- `webview-ui/src/utils/slash-commands.ts` - Webview autocomplete
-
-## ChatRow Cancelled/Interrupted States
-When a ChatRow displays a loading/in-progress state (spinner), you must handle what happens when the task is cancelled. This is non-obvious because cancellation doesn't update the message content—you have to infer it from context.
-
-**The pattern:**
-1. A message has a `status` field (e.g., `"generating"`, `"complete"`, `"error"`) stored in `message.text` as JSON
-2. When cancelled mid-operation, the status stays `"generating"` forever—no one updates it
-3. To detect cancellation, check TWO conditions:
-   - `!isLast` — if this message is no longer the last message, something else happened after it (interrupted)
-   - `lastModifiedMessage?.ask === "resume_task" || "resume_completed_task"` — task was just cancelled and is waiting to resume
-
-**Example from `generate_explanation`:**
-```tsx
-const wasCancelled =
-    explanationInfo.status === "generating" &&
-    (!isLast ||
-        lastModifiedMessage?.ask === "resume_task" ||
-        lastModifiedMessage?.ask === "resume_completed_task")
-const isGenerating = explanationInfo.status === "generating" && !wasCancelled
-```
-
-**Why both checks?**
-- `!isLast` catches: cancelled → resumed → did other stuff → this old message is stale
-- `lastModifiedMessage?.ask === "resume_task"` catches: just cancelled, hasn't resumed yet, this message is still technically "last"
-
-**See also:** `BrowserSessionRow.tsx` uses similar pattern with `isLastApiReqInterrupted` and `isLastMessageResume`.
-
-**Backend side:** When streaming is cancelled, clean up properly (close tabs, clear comments, etc.) by checking `taskState.abort` after the streaming function returns.

CONTRIBUTING.md

@@ -46,11 +46,7 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
     ```bash
     npm run install:all
     ```
-4. Generate Protocol Buffer files (required before first build):
-    ```bash
-    npm run protos
-    ```
-5. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
 
 
 
@@ -89,10 +85,8 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 2. **Local Development**
     - Run `npm run install:all` to install dependencies
-    - Run `npm run protos` to generate Protocol Buffer files (required before first build)
     - Run `npm run test` to run tests locally
     - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
-    - **Terminal Workflow**: Use `npm run dev` (generates protos + runs watch mode) or `npm run watch` (if protos already generated)
     - Before submitting PR, run `npm run format:fix` to format your code
 
 3. **Linux-specific Setup**

README.md

@@ -2,7 +2,7 @@
 English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md" target="_blank">Español</a> | <a href="https://github.com/cline/cline/blob/main/locales/de/README.md" target="_blank">Deutsch</a> | <a href="https://github.com/cline/cline/blob/main/locales/ja/README.md" target="_blank">日本語</a> | <a href="https://github.com/cline/cline/blob/main/locales/zh-cn/README.md" target="_blank">简体中文</a> | <a href="https://github.com/cline/cline/blob/main/locales/zh-tw/README.md" target="_blank">繁體中文</a> | <a href="https://github.com/cline/cline/blob/main/locales/ko/README.md" target="_blank">한국어</a>
 </sub></div>
 
-# Cline
+# Cline – \#1 on OpenRouter
 
 <p align="center">
   <img src="https://media.githubusercontent.com/media/cline/cline/main/assets/docs/demo.gif" width="100%" />
@@ -43,7 +43,7 @@ Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.c
 4. When a task is completed, Cline will present the result to you with a terminal command like `open -a "Google Chrome" index.html`, which you run with a click of a button.
 
 > [!TIP]
-> Follow [this guide](https://docs.cline.bot/features/customization/opening-cline-in-sidebar) to open Cline on the right side of your editor. This lets you use Cline side-by-side with your file explorer, and see how he changes your workspace more clearly.
+> Use the `CMD/CTRL + Shift + P` shortcut to open the command palette and type "Cline: Open In New Tab" to open the extension as a tab in your editor. This lets you use Cline side-by-side with your file explorer, and see how he changes your workspace more clearly.
 
 ---
 
@@ -141,11 +141,6 @@ For example, when working with a local web server, you can use 'Restore Workspac
 
 To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
 
-## Enterprise
-
-Get the same Cline experience with enterprise-grade controls: SSO (SAML/OIDC), global policies and configuration, observability with audit trails, private networking (VPC/private link), and self-hosted or on-prem deployments, and enterprise support. Learn more at our [enterprise page](https://cline.bot/enterprise) or [talk to us](https://cline.bot/contact-sales).
-
-
 ## License
 
 [Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)

assets/icons/cline-bot.svg

@@ -1,30 +0,0 @@
-<?xml version="1.0" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
-<svg xmlns="http://www.w3.org/2000/svg">
-<metadata>
-<json>
-<![CDATA[
-{
-	"fontFamily": "cline-bot",
-	"majorVersion": 1,
-	"minorVersion": 0,
-	"fontURL": "https://cline.bot",
-	"designerURL": "https://cline.bot",
-	"licenseURL": "https://cline.bot",
-	"version": "Version 1.0",
-	"fontId": "cline-bot",
-	"psName": "cline-bot",
-	"subFamily": "Regular",
-	"fullName": "cline-bot",
-	"description": "Font generated by IcoMoon."
-}
-]]>
-</json>
-</metadata>
-<defs>
-<font id="cline-bot" horiz-adv-x="1024">
-<font-face units-per-em="1024" ascent="960" descent="-64" />
-<missing-glyph horiz-adv-x="1024" />
-<glyph unicode="&#x20;" horiz-adv-x="512" d="" />
-<glyph unicode="&#xe900;" glyph-name="cline" data-tags="cline" horiz-adv-x="977" d="M964.553 383.11l-60.285 121.406v69.495c0 115.545-92.939 209.321-207.647 209.321h-102.986c7.536 15.071 11.722 32.654 11.722 51.074 0 64.471-51.912 116.383-115.545 116.383s-115.545-51.912-115.545-116.383 4.186-35.166 11.722-51.074h-102.986c-114.708 0-207.647-93.776-207.647-209.321v-69.495l-61.959-121.406c-5.861-11.722-5.861-26.793 0-38.515l61.959-119.732v-69.495c0-115.545 92.939-209.321 207.647-209.321h415.294c114.708 0 207.647 93.776 207.647 209.321v69.495l60.285 119.732c5.861 11.722 5.861 25.956 0 38.515v0zM426.178 284.311c0-52.749-42.702-95.451-94.613-95.451s-94.613 42.702-94.613 95.451v169.132c0 52.749 42.702 95.451 94.613 95.451s94.613-42.702 94.613-95.451v-169.132zM731.787 284.311c0-52.749-42.702-95.451-94.613-95.451s-94.613 42.702-94.613 95.451v169.132c0 52.749 42.702 95.451 94.613 95.451s94.613-42.702 94.613-95.451v-169.132z" />
-</font></defs></svg>

biome.jsonc

@@ -70,7 +70,7 @@
 				"noControlCharactersInRegex": "off",
 				"noShadowRestrictedNames": "off",
 				"noArrayIndexKey": "info",
-				"noAssignInExpressions": "info"
+				"noAssignInExpressions": "warn"
 			},
 			"complexity": {
 				"noUselessConstructor": "off",
@@ -82,7 +82,7 @@
 				"noStaticOnlyClass": "off"
 			},
 			"security": {
-				"noDangerouslySetInnerHtml": "info"
+				"noDangerouslySetInnerHtml": "warn"
 			}
 		}
 	},
@@ -114,17 +114,17 @@
 	"files": {
 		"includes": [
 			"**",
-			"!**/dist",
-			"!**/dist-*",
-			"!**/out",
-			"!**/evals",
-			"!**/playwright",
-			"!**/test-results",
-			"!**/node_modules",
-			"!**/webview-ui/build",
-			"!**/generated",
-			"!**/proto",
-			"!**/tests/specs"
+			"!**/dist/**",
+			"!**/dist-*/**",
+			"!**/out/**",
+			"!**/evals/**",
+			"!**/playwright/**",
+			"!**/test-results/**",
+			"!**/node_modules/**",
+			"!**/webview-ui/build/**",
+			"!**/generated/**",
+			"!**/proto/**",
+			"!**/tests/specs/**"
 		]
 	},
 	"plugins": [

cli/cmd/cline/main.go

@@ -182,7 +182,7 @@ see the manual page: man cline`,
 	rootCmd.AddCommand(cli.NewVersionCommand())
 	rootCmd.AddCommand(cli.NewAuthCommand())
 	rootCmd.AddCommand(cli.NewLogsCommand())
-	// rootCmd.AddCommand(cli.NewDoctorCommand()) // Disabled for now
+	rootCmd.AddCommand(cli.NewDoctorCommand())
 
 	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
 		os.Exit(1)
@@ -345,4 +345,4 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 	}
 
 	return content.String(), nil
-}
+}

cli/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cline",
-	"version": "1.0.3",
+	"version": "1.0.0-nightly.18",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"main": "cline-core.js",
 	"bin": {
@@ -20,7 +20,7 @@
 		"vscode-uri"
 	],
 	"engines": {
-		"node": ">=20.0.0"
+		"node": ">=18.0.0"
 	},
 	"keywords": [
 		"cline",

cli/pkg/cli/auth/byo_quick_setup.go

@@ -28,7 +28,7 @@ func QuickSetupFromFlags(ctx context.Context, provider, apiKey, modelID, baseURL
 	}
 
 	// Create task manager for state operations
-	manager, err := createTaskManager(ctx)
+	manager, err := task.NewManagerForDefault(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to create task manager: %w", err)
 	}
@@ -75,12 +75,6 @@ func QuickSetupFromFlags(ctx context.Context, provider, apiKey, modelID, baseURL
 		}
 	}
 
-	// Flush pending state changes to disk immediately
-	// This ensures all configuration changes are persisted before the instance terminates
-	if _, err := manager.GetClient().State.FlushPendingState(ctx, &cline.EmptyRequest{}); err != nil {
-		return fmt.Errorf("failed to flush pending state: %w", err)
-	}
-
 	// Success message
 	fmt.Printf("\n✓ Successfully configured %s provider\n", GetProviderDisplayName(providerEnum))
 	fmt.Printf("  Model: %s\n", finalModelID)
@@ -176,7 +170,6 @@ func validateQuickSetupProvider(providerID string) (cline.ApiProvider, error) {
 		cline.ApiProvider_XAI:           true,
 		cline.ApiProvider_CEREBRAS:      true,
 		cline.ApiProvider_OLLAMA:        true,
-		cline.ApiProvider_NOUSRESEARCH:  true,
 	}
 
 	if !supportedProviders[provider] {

cli/pkg/cli/auth/providers_byo.go

@@ -26,7 +26,6 @@ func GetBYOProviderList() []BYOProviderOption {
 		{Name: "Google Gemini", Provider: cline.ApiProvider_GEMINI},
 		{Name: "Ollama", Provider: cline.ApiProvider_OLLAMA},
 		{Name: "Cerebras", Provider: cline.ApiProvider_CEREBRAS},
-		{Name: "NousResearch", Provider: cline.ApiProvider_NOUSRESEARCH},
 		{Name: "Oracle Code Assist", Provider: cline.ApiProvider_OCA},
 	}
 }
@@ -101,8 +100,6 @@ func GetBYOProviderPlaceholder(provider cline.ApiProvider) string {
 		return "e.g., qwen3-coder:30b"
 	case cline.ApiProvider_CEREBRAS:
 		return "e.g., gpt-oss-120b"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "e.g., Hermes-4-405B"
 	case cline.ApiProvider_OCA:
 		return "e.g., oca/llama4"
 	default:

cli/pkg/cli/auth/providers_list.go

@@ -111,9 +111,7 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 		cline.ApiProvider_GEMINI,
 		cline.ApiProvider_OLLAMA,
 		cline.ApiProvider_CEREBRAS,
-		cline.ApiProvider_NOUSRESEARCH,
 		cline.ApiProvider_OCA,
-		cline.ApiProvider_HICAP,
 	}
 
 	// Check each provider to see if it's ready to use
@@ -214,15 +212,13 @@ func extractProviderFromState(stateData map[string]interface{}, mode string) *Pr
 // mapProviderStringToEnum converts provider string from state to ApiProvider enum
 // Returns (provider, ok) where ok is false if the provider is unknown
 func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
-	normalizedStr := strings.ToLower(providerStr)
-	
 	// Map string values to enum values
-	switch normalizedStr {
+	switch providerStr {
 	case "anthropic":
 		return cline.ApiProvider_ANTHROPIC, true
-	case "openai", "openai-compatible": // internal name is 'openai', but this is actually the openai-compatible provider
+	case "openai-compatible": // internal name is 'openai', but this is actually the openai-compatible provider
 		return cline.ApiProvider_OPENAI, true
-	case "openai-native": // This is the native, official Open AI provider
+	case "openai", "openai-native": // This is the native, official Open AI provider
 		return cline.ApiProvider_OPENAI_NATIVE, true
 	case "openrouter":
 		return cline.ApiProvider_OPENROUTER, true
@@ -240,10 +236,6 @@ func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
 		return cline.ApiProvider_CLINE, true
 	case "oca":
 		return cline.ApiProvider_OCA, true
-	case "hicap":
-		return cline.ApiProvider_HICAP, true
-	case "nousResearch":
-		return cline.ApiProvider_NOUSRESEARCH, true
 	default:
 		return cline.ApiProvider_ANTHROPIC, false // Return 0 value with false
 	}
@@ -275,10 +267,6 @@ func GetProviderIDForEnum(provider cline.ApiProvider) string {
 		return "cline"
 	case cline.ApiProvider_OCA:
 		return "oca"
-	case cline.ApiProvider_HICAP:
-		return "hicap"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "nousResearch"
 	default:
 		return ""
 	}
@@ -356,10 +344,6 @@ func GetProviderDisplayName(provider cline.ApiProvider) string {
 		return "Cline (Official)"
 	case cline.ApiProvider_OCA:
 		return "Oracle Code Assist"
-	case cline.ApiProvider_HICAP:
-		return "Hicap"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "NousResearch"
 	default:
 		return "Unknown"
 	}
@@ -481,8 +465,6 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 		{cline.ApiProvider_GEMINI, "geminiApiKey"},
 		{cline.ApiProvider_OLLAMA, "ollamaBaseUrl"}, // Ollama uses baseUrl instead of API key
 		{cline.ApiProvider_CEREBRAS, "cerebrasApiKey"},
-		{cline.ApiProvider_HICAP, "hicapApiKey"},
-		{cline.ApiProvider_NOUSRESEARCH, "nousResearchApiKey"},
 	}
 
 	for _, providerCheck := range providersToCheck {

cli/pkg/cli/auth/update_api_configurations.go

@@ -154,23 +154,6 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 			PlanModeProviderSpecificModelIDField: "planModeOcaModelId",
 			ActModeProviderSpecificModelIDField:  "actModeOcaModelId",
 		}, nil
-	case cline.ApiProvider_HICAP:
-		return ProviderFields{
-			APIKeyField:                          "hicapApiKey",
-			PlanModeModelInfoField:               "planModeHicapModelInfo",
-			ActModeModelInfoField:                "actModeHicapModelInfo",
-			PlanModeProviderSpecificModelIDField: "planModeHicapModelId",
-			ActModeProviderSpecificModelIDField:  "actModeHicapModelId",
-		}, nil
-
-	case cline.ApiProvider_NOUSRESEARCH:
-		return ProviderFields{
-			APIKeyField:                          "nousResearchApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeProviderSpecificModelIDField: "planModeNousResearchModelId",
-			ActModeProviderSpecificModelIDField:  "actModeNousResearchModelId",
-		}, nil
 
 	default:
 		return ProviderFields{}, fmt.Errorf("unsupported provider: %v", provider)
@@ -285,10 +268,6 @@ func setAPIKeyField(apiConfig *cline.ModelsApiConfiguration, fieldName string, v
 		apiConfig.ClineApiKey = value
 	case "ocaApiKey":
 		apiConfig.OcaApiKey = value
-	case "hicapApiKey":
-		apiConfig.HicapApiKey = value
-	case "nousResearchApiKey":
-		apiConfig.NousResearchApiKey = value
 	}
 }
 
@@ -310,12 +289,6 @@ func setProviderSpecificModelID(apiConfig *cline.ModelsApiConfiguration, fieldNa
 	case "planModeOcaModelId":
 		apiConfig.PlanModeOcaModelId = value
 		apiConfig.ActModeOcaModelId = value
-	case "planModeHicapModelId":
-		apiConfig.PlanModeHicapModelId = value
-		apiConfig.ActModeHicapModelId = value
-	case "planModeNousResearchModelId":
-		apiConfig.PlanModeNousResearchModelId = value
-		apiConfig.ActModeNousResearchModelId = value
 	}
 }
 

cli/pkg/cli/auth/wizard_byo.go

@@ -517,7 +517,7 @@ func (pw *ProviderWizard) applyModelChange(provider cline.ApiProvider, modelID s
 		ModelInfo: modelInfo,
 	}
 
-	return UpdateProviderPartial(pw.ctx, pw.manager, provider, updates, true)
+	return UpdateProviderPartial(pw.ctx, pw.manager, provider, updates, false)
 }
 
 // SwitchToBYOProvider switches to a BYO provider that's already configured.

cli/pkg/cli/config.go

@@ -123,10 +123,7 @@ func setCommand() *cobra.Command {
 		Use:     "set <key=value> [key=value...]",
 		Aliases: []string{"s"},
 		Short:   "Set configuration variables",
-		Long:    `Set one or more global configuration variables using key=value format.
-		
-This command merges the provided settings with existing values, preserving
-unspecified fields. Only the fields you explicitly set will be updated.`,
+		Long:    `Set one or more global configuration variables using key=value format.`,
 		Args:    cobra.MinimumNArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -142,7 +139,7 @@ unspecified fields. Only the fields you explicitly set will be updated.`,
 				return err
 			}
 
-			// Update settings (server-side merge handles preserving existing values)
+			// Update settings
 			return configManager.UpdateSettings(ctx, settings, secrets)
 		},
 	}

cli/pkg/cli/config/manager.go

@@ -92,6 +92,7 @@ func (m *Manager) ListSettings(ctx context.Context) error {
 		"telemetrySetting",
 		"planActSeparateModelsSetting",
 		"enableCheckpointsSetting",
+		"mcpMarketplaceEnabled",
 		"shellIntegrationTimeout",
 		"terminalReuseEnabled",
 		"mcpResponsesCollapsed",
@@ -110,7 +111,6 @@ 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,9 +77,10 @@ func RenderField(key string, value interface{}, censor bool) error {
 	case "mode", "telemetrySetting", "preferredLanguage", "customPrompt",
 		"defaultTerminalProfile", "mcpDisplayMode", "openaiReasoningEffort",
 		"planActSeparateModelsSetting", "enableCheckpointsSetting",
-		"terminalReuseEnabled", "mcpResponsesCollapsed", "strictPlanModeEnabled",
+		"mcpMarketplaceEnabled", "terminalReuseEnabled",
+		"mcpResponsesCollapsed", "strictPlanModeEnabled",
 		"useAutoCondense", "yoloModeToggled", "shellIntegrationTimeout",
-		"terminalOutputLineLimit", "autoCondenseThreshold", "hooksEnabled":
+		"terminalOutputLineLimit", "autoCondenseThreshold":
 		fmt.Printf("%s: %s\n", camelToKebab(key), formatValue(value, key, censor))
 		return nil
 
@@ -188,7 +189,7 @@ func renderAutoApprovalSettings(value interface{}, censor bool) error {
 				}
 			}
 		} else {
-			// Print other fields normally (enabled, enableNotifications, favorites)
+			// Print other fields normally (enabled, maxRequests, enableNotifications, favorites)
 			fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
 		}
 	}

cli/pkg/cli/display/tool_renderer.go

@@ -106,14 +106,6 @@ func (tr *ToolRenderer) generateToolHeader(tool *types.ToolMessage, verbTense st
 		}
 		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
 
-	case string(types.ToolTypeFileDeleted):
-		if verbTense == "wants to" {
-			action = "wants to delete"
-		} else {
-			action = "is deleting"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
 	case string(types.ToolTypeListFilesTopLevel):
 		if verbTense == "wants to" {
 			action = "wants to list files in"
@@ -161,14 +153,6 @@ 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"
@@ -215,8 +199,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.ToolTypeWebSearch), string(types.ToolTypeFileDeleted):
-		// No preview for read/fetch/search operations
+	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch):
+		// No preview for read/fetch operations
 		return ""
 
 	default:
@@ -242,8 +226,7 @@ func (tr *ToolRenderer) GenerateToolContentBody(tool *types.ToolMessage) string
 	toolParser := NewToolResultParser(tr.mdRenderer)
 
 	switch tool.Tool {
-	case string(types.ToolTypeReadFile),
-		string(types.ToolTypeFileDeleted):
+	case string(types.ToolTypeReadFile):
 		// readFile: show header only, no body
 		return ""
 
@@ -251,8 +234,7 @@ func (tr *ToolRenderer) GenerateToolContentBody(tool *types.ToolMessage) string
 		string(types.ToolTypeListFilesRecursive),
 		string(types.ToolTypeListCodeDefinitionNames),
 		string(types.ToolTypeSearchFiles),
-		string(types.ToolTypeWebFetch),
-		string(types.ToolTypeWebSearch):
+		string(types.ToolTypeWebFetch):
 		// Use parser for structured output
 		preview := toolParser.ParseToolResult(tool)
 		return tr.renderMarkdown(preview)

cli/pkg/cli/display/tool_result_parser.go

@@ -221,12 +221,83 @@ func (p *ToolResultParser) ParseCodeDefinitions(content string) string {
 
 // ParseWebFetch formats webFetch tool results with content preview
 func (p *ToolResultParser) ParseWebFetch(content, url string) string {
-	return ""
-}
+	if content == "" {
+		return fmt.Sprintf("*Fetched content from %s (empty response)*", url)
+	}
 
-// ParseWebSearch formats webSearch tool results
-func (p *ToolResultParser) ParseWebSearch(content, query string) string {
-	return ""
+	lines := strings.Split(content, "\n")
+	
+	var result strings.Builder
+	
+	// Try to extract title
+	var title string
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "#") && !strings.HasPrefix(trimmed, "##") {
+			title = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+			break
+		}
+	}
+
+	if title != "" {
+		result.WriteString(fmt.Sprintf("**Title:** %s\n\n", title))
+	}
+
+	// Show preview of content
+	result.WriteString("**Preview:**\n")
+	
+	charCount := 0
+	maxChars := 500
+	previewLines := []string{}
+	
+	for _, line := range lines {
+		// Skip markdown headers
+		if strings.HasPrefix(strings.TrimSpace(line), "#") {
+			continue
+		}
+		
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			continue
+		}
+		
+		if charCount+len(trimmed) > maxChars {
+			break
+		}
+		
+		previewLines = append(previewLines, trimmed)
+		charCount += len(trimmed)
+	}
+
+	result.WriteString(strings.Join(previewLines, " "))
+	result.WriteString("...\n\n")
+
+	// Extract sections
+	sections := []string{}
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "##") {
+			section := strings.TrimSpace(strings.TrimPrefix(trimmed, "##"))
+			sections = append(sections, section)
+			if len(sections) >= 5 {
+				break
+			}
+		}
+	}
+
+	if len(sections) > 0 {
+		result.WriteString("**Sections Found:**\n")
+		for _, section := range sections {
+			result.WriteString(fmt.Sprintf("- %s\n", section))
+		}
+		result.WriteString("\n")
+	}
+
+	// Word count estimate
+	wordCount := len(strings.Fields(content))
+	result.WriteString(fmt.Sprintf("*[Full content: ~%s]*", p.formatWordCount(wordCount)))
+
+	return result.String()
 }
 
 // detectLanguage returns syntax highlighting language based on file extension
@@ -294,8 +365,6 @@ 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,9 +478,8 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 	
 	env = append(env,
 		fmt.Sprintf("NODE_PATH=%s", nodePath),
-		// These control gRPC debug logging
-		//"GRPC_TRACE=all",
-		//"GRPC_VERBOSITY=DEBUG",
+		"GRPC_TRACE=all",
+		"GRPC_VERBOSITY=DEBUG",
 		"NODE_ENV=development",
 	)
 	cmd.Env = env

cli/pkg/cli/handlers/ask_handlers.go

@@ -52,6 +52,8 @@ func (h *AskHandler) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
 		return h.handleResumeCompletedTask(msg, dc)
 	case string(types.AskTypeMistakeLimitReached):
 		return h.handleMistakeLimitReached(msg, dc)
+	case string(types.AskTypeAutoApprovalMaxReached):
+		return h.handleAutoApprovalMaxReached(msg, dc)
 	case string(types.AskTypeBrowserActionLaunch):
 		return h.handleBrowserActionLaunch(msg, dc)
 	case string(types.AskTypeUseMcpServer):
@@ -253,6 +255,25 @@ func (h *AskHandler) handleMistakeLimitReached(msg *types.ClineMessage, dc *Disp
 	return dc.Renderer.RenderMessage("ERROR", fmt.Sprintf("Mistake Limit Reached: %s. Approval required.", msg.Text), true)
 }
 
+// handleAutoApprovalMaxReached handles auto-approval max reached
+func (h *AskHandler) handleAutoApprovalMaxReached(msg *types.ClineMessage, dc *DisplayContext) error {
+	if dc.SystemRenderer != nil {
+		details := make(map[string]string)
+		if msg.Text != "" {
+			details["reason"] = msg.Text
+		}
+		dc.SystemRenderer.RenderError(
+			"warning",
+			"Auto-Approval Limit Reached",
+			"The maximum number of auto-approved requests has been reached. Manual approval is now required.",
+			details,
+		)
+		fmt.Printf("\n**Approval required to continue.**\n")
+		return nil
+	}
+	return dc.Renderer.RenderMessage("WARNING", fmt.Sprintf("Auto-approval limit reached: %s. Approval required.", msg.Text), true)
+}
+
 // handleBrowserActionLaunch handles browser action launch requests
 func (h *AskHandler) handleBrowserActionLaunch(msg *types.ClineMessage, dc *DisplayContext) error {
 	url := strings.TrimSpace(msg.Text)

cli/pkg/cli/logs.go

@@ -208,9 +208,9 @@ func listLogFiles(logsDir string) ([]logFileInfo, error) {
 		})
 	}
 
-	// Sort by created time (oldest first)
+	// Sort by created time (newest first)
 	sort.Slice(logs, func(i, j int) bool {
-		return logs[i].created.Before(logs[j].created)
+		return logs[i].created.After(logs[j].created)
 	})
 
 	return logs, nil
@@ -379,4 +379,4 @@ func renderLogsTable(logs []logFileInfo, markForDeletion bool) error {
 	fmt.Println()
 
 	return nil
-}
+}

cli/pkg/cli/task.go

@@ -394,7 +394,7 @@ func newTaskViewCommand() *cobra.Command {
 				return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), false)
 			} else if followComplete {
 				// Follow until completion
-				return taskManager.FollowConversationUntilCompletion(ctx, task.DefaultFollowOptions())
+				return taskManager.FollowConversationUntilCompletion(ctx)
 			} else {
 				// Default: show snapshot
 				return taskManager.ShowConversation(ctx)
@@ -668,10 +668,7 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 	// If yolo mode is enabled, follow until completion (non-interactive)
 	// Otherwise, follow in interactive mode
 	if opts.Yolo {
-		// Skip active task check since we just created the task
-		return taskManager.FollowConversationUntilCompletion(ctx, task.FollowOptions{
-			SkipActiveTaskCheck: true,
-		})
+		return taskManager.FollowConversationUntilCompletion(ctx)
 	} else {
 		return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
 	}

cli/pkg/cli/task/follow_options.go

@@ -1,15 +0,0 @@
-package task
-
-// FollowOptions contains options for following a conversation
-type FollowOptions struct {
-	// SkipActiveTaskCheck skips the check for an active task
-	// This is useful when following a task that was just created to avoid race conditions
-	SkipActiveTaskCheck bool
-}
-
-// DefaultFollowOptions returns the default options for following a conversation
-func DefaultFollowOptions() FollowOptions {
-	return FollowOptions{
-		SkipActiveTaskCheck: false,
-	}
-}

cli/pkg/cli/task/input_handler.go

@@ -251,14 +251,11 @@ func determineAutoApprovalAction(msg *types.ClineMessage) (string, error) {
 			types.ToolTypeListFilesRecursive,
 			types.ToolTypeListCodeDefinitionNames,
 			types.ToolTypeSearchFiles,
-			types.ToolTypeWebFetch,
-			types.ToolTypeWebSearch:
+			types.ToolTypeWebFetch:
 			return "read_files", nil
 		case types.ToolTypeEditedExistingFile,
 			types.ToolTypeNewFileCreated:
 			return "edit_files", nil
-		case types.ToolTypeFileDeleted:
-			return "apply_patch", nil
 		default:
 			return "", fmt.Errorf("unsupported tool type: %s", toolMsg.Tool)
 		}

cli/pkg/cli/task/manager.go

@@ -280,8 +280,9 @@ func (m *Manager) CheckSendEnabled(ctx context.Context) error {
 
 	// Error types which we allow sending on
 	errorTypes := []string{
-		string(types.AskTypeAPIReqFailed),        // "api_req_failed"
-		string(types.AskTypeMistakeLimitReached), // "mistake_limit_reached"
+		string(types.AskTypeAPIReqFailed),           // "api_req_failed"
+		string(types.AskTypeMistakeLimitReached),    // "mistake_limit_reached"
+		string(types.AskTypeAutoApprovalMaxReached), // "auto_approval_max_req_reached"
 	}
 
 	isError := false
@@ -753,21 +754,7 @@ func (m *Manager) FollowConversation(ctx context.Context, instanceAddress string
 }
 
 // FollowConversationUntilCompletion streams conversation updates until task completion
-func (m *Manager) FollowConversationUntilCompletion(ctx context.Context, opts FollowOptions) error {
-	// Check if there's an active task before entering follow mode
-	// Skip this check if we just created a task (to avoid race condition where task isn't active yet)
-	if !opts.SkipActiveTaskCheck {
-		err := m.CheckSendEnabled(ctx)
-		if err != nil {
-			if errors.Is(err, ErrNoActiveTask) {
-				fmt.Println("No task is currently running.")
-				return nil
-			}
-			// For other errors (like task busy), we can still enter follow mode
-			// as the user may want to observe the task
-		}
-	}
-
+func (m *Manager) FollowConversationUntilCompletion(ctx context.Context) error {
 	// Enable streaming mode
 	m.mu.Lock()
 	m.isStreamingMode = true
@@ -984,33 +971,6 @@ 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) {
@@ -1034,14 +994,6 @@ 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) {
@@ -1287,17 +1239,17 @@ func (m *Manager) updateMode(stateJson string) {
 
 // UpdateTaskAutoApprovalAction enables a specific auto-approval action for the current task
 func (m *Manager) UpdateTaskAutoApprovalAction(ctx context.Context, actionKey string) error {
-	boolPtr := func(b bool) *bool { return &b }
-
 	settings := &cline.Settings{
 		AutoApprovalSettings: &cline.AutoApprovalSettings{
-			Actions: &cline.AutoApprovalActions{},
+			Enabled:     true,
+			MaxRequests: 20, // Important: avoid maxRequests=0 bug
+			Actions:     &cline.AutoApprovalActions{},
 		},
 	}
 
 	// Set the specific action to true based on actionKey
-	truePtr := boolPtr(true)
-
+	truePtr := func() *bool { b := true; return &b }()
+	
 	switch actionKey {
 	case "read_files":
 		settings.AutoApprovalSettings.Actions.ReadFiles = truePtr

cli/pkg/cli/task/settings_parser.go

@@ -180,6 +180,8 @@ func setSimpleField(settings *cline.Settings, key, value string) error {
 		settings.PlanModeHuaweiCloudMaasModelId = strPtr(value)
 	case "plan_mode_oca_model_id":
 		settings.PlanModeOcaModelId = strPtr(value)
+	case "plan_mode_vercel_ai_gateway_model_id":
+		settings.PlanModeVercelAiGatewayModelId = strPtr(value)
 	case "act_mode_api_model_id":
 		settings.ActModeApiModelId = strPtr(value)
 	case "act_mode_reasoning_effort":
@@ -216,6 +218,8 @@ func setSimpleField(settings *cline.Settings, key, value string) error {
 		settings.ActModeHuaweiCloudMaasModelId = strPtr(value)
 	case "act_mode_oca_model_id":
 		settings.ActModeOcaModelId = strPtr(value)
+	case "act_mode_vercel_ai_gateway_model_id":
+		settings.ActModeVercelAiGatewayModelId = strPtr(value)
 
 	// Boolean fields
 	case "aws_use_cross_region_inference":
@@ -290,12 +294,6 @@ 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":
@@ -418,12 +416,24 @@ func setNestedField(settings *cline.Settings, parentField string, childFields ma
 func setAutoApprovalSettings(settings *cline.AutoApprovalSettings, fields map[string]string) error {
 	for key, value := range fields {
 		switch key {
+		case "enabled":
+			val, err := parseBool(value)
+			if err != nil {
+				return err
+			}
+			settings.Enabled = val
+		case "max_requests":
+			val, err := parseInt32(value)
+			if err != nil {
+				return err
+			}
+			settings.MaxRequests = val
 		case "enable_notifications":
 			val, err := parseBool(value)
 			if err != nil {
 				return err
 			}
-			settings.EnableNotifications = boolPtr(val)
+			settings.EnableNotifications = val
 		case "actions":
 			return fmt.Errorf("auto_approval_settings.actions requires nested dot notation (e.g., auto-approval-settings.actions.read-files=true)")
 		default:
@@ -662,8 +672,6 @@ func parseApiProvider(value string) (cline.ApiProvider, error) {
 		return cline.ApiProvider_DIFY, nil
 	case "oca":
 		return cline.ApiProvider_OCA, nil
-	case "minimax":
-		return cline.ApiProvider_MINIMAX, nil
 	default:
 		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("invalid api_provider '%s'", value)
 	}
@@ -738,14 +746,14 @@ func setSecretField(secrets *cline.Secrets, key, value string) error {
 		secrets.HuaweiCloudMaasApiKey = strPtr(value)
 	case "baseten_api_key":
 		secrets.BasetenApiKey = strPtr(value)
+	case "vercel_ai_gateway_api_key":
+		secrets.VercelAiGatewayApiKey = strPtr(value)
 	case "dify_api_key":
 		secrets.DifyApiKey = strPtr(value)
 	case "oca_api_key":
 		secrets.OcaApiKey = strPtr(value)
 	case "oca_refresh_token":
 		secrets.OcaRefreshToken = strPtr(value)
-	case "hicap_api_key":
-		secrets.HicapApiKey = strPtr(value)
 	default:
 		return fmt.Errorf("unsupported secret field '%s'", key)
 	}

cli/pkg/cli/types/messages.go

@@ -37,16 +37,17 @@ const (
 type AskType string
 
 const (
-	AskTypeFollowup            AskType = "followup"
-	AskTypePlanModeRespond     AskType = "plan_mode_respond"
-	AskTypeCommand             AskType = "command"
-	AskTypeCommandOutput       AskType = "command_output"
-	AskTypeCompletionResult    AskType = "completion_result"
-	AskTypeTool                AskType = "tool"
-	AskTypeAPIReqFailed        AskType = "api_req_failed"
-	AskTypeResumeTask          AskType = "resume_task"
-	AskTypeResumeCompletedTask AskType = "resume_completed_task"
-	AskTypeMistakeLimitReached AskType = "mistake_limit_reached"
+	AskTypeFollowup               AskType = "followup"
+	AskTypePlanModeRespond        AskType = "plan_mode_respond"
+	AskTypeCommand                AskType = "command"
+	AskTypeCommandOutput          AskType = "command_output"
+	AskTypeCompletionResult       AskType = "completion_result"
+	AskTypeTool                   AskType = "tool"
+	AskTypeAPIReqFailed           AskType = "api_req_failed"
+	AskTypeResumeTask             AskType = "resume_task"
+	AskTypeResumeCompletedTask    AskType = "resume_completed_task"
+	AskTypeMistakeLimitReached    AskType = "mistake_limit_reached"
+	AskTypeAutoApprovalMaxReached AskType = "auto_approval_max_req_reached"
 	AskTypeBrowserActionLaunch    AskType = "browser_action_launch"
 	AskTypeUseMcpServer           AskType = "use_mcp_server"
 	AskTypeNewTask                AskType = "new_task"
@@ -107,13 +108,11 @@ const (
 	ToolTypeEditedExistingFile      ToolType = "editedExistingFile"
 	ToolTypeNewFileCreated          ToolType = "newFileCreated"
 	ToolTypeReadFile                ToolType = "readFile"
-	ToolTypeFileDeleted             ToolType = "fileDeleted"
 	ToolTypeListFilesTopLevel       ToolType = "listFilesTopLevel"
 	ToolTypeListFilesRecursive      ToolType = "listFilesRecursive"
 	ToolTypeListCodeDefinitionNames ToolType = "listCodeDefinitionNames"
 	ToolTypeSearchFiles             ToolType = "searchFiles"
 	ToolTypeWebFetch                ToolType = "webFetch"
-	ToolTypeWebSearch               ToolType = "webSearch"
 	ToolTypeSummarizeTask           ToolType = "summarizeTask"
 )
 
@@ -248,6 +247,8 @@ func convertProtoAskType(askType cline.ClineAsk) string {
 		return string(AskTypeResumeCompletedTask)
 	case cline.ClineAsk_MISTAKE_LIMIT_REACHED:
 		return string(AskTypeMistakeLimitReached)
+	case cline.ClineAsk_AUTO_APPROVAL_MAX_REQ_REACHED:
+		return string(AskTypeAutoApprovalMaxReached)
 	case cline.ClineAsk_BROWSER_ACTION_LAUNCH:
 		return string(AskTypeBrowserActionLaunch)
 	case cline.ClineAsk_USE_MCP_SERVER:

cli/pkg/cli/updater/updater.go

@@ -375,7 +375,7 @@ func showFailureMessage(channel string) {
 
 func getCacheFilePath() string {
 	configDir := filepath.Join(os.Getenv("HOME"), ".cline", "data")
-	return filepath.Join(configDir, "cli-update-cache")
+	return filepath.Join(configDir, ".update-cache")
 }
 
 func loadCache() (cacheData, error) {
@@ -406,4 +406,4 @@ func saveCache(cache cacheData) error {
 	}
 
 	return os.WriteFile(cacheFile, data, 0644)
-}
+}

cli/pkg/common/utils.go

@@ -4,9 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"os/exec"
 	"strconv"
-	"strings"
 	"time"
 
 	"google.golang.org/grpc"
@@ -126,16 +124,6 @@ func NormalizeAddressForGRPC(address string) (string, error) {
 	return address, nil
 }
 
-// GetNodeVersion returns the current Node.js version, or "unknown" if unable to detect
-func GetNodeVersion() string {
-	cmd := exec.Command("node", "--version")
-	output, err := cmd.Output()
-	if err != nil {
-		return "unknown"
-	}
-	return strings.TrimSpace(string(output))
-}
-
 // RetryOperation performs an operation with retry logic
 func RetryOperation(maxRetries int, timeoutPerAttempt time.Duration, operation func() error) error {
 	var lastErr error
@@ -167,19 +155,5 @@ func RetryOperation(maxRetries int, timeoutPerAttempt time.Duration, operation f
 		}
 	}
 
-	return fmt.Errorf(`operation failed to after %d attempts: %w
-
-This is usually caused by an incompatible Node.js version
-
-REQUIREMENTS:
-• Node.js version 20+ is required
-• Current Node.js version: %s
-
-DEBUGGING STEPS:
-1. View recent logs: cline log list
-2. Logs are available in: ~/.cline/logs/
-3. The most recent cline-core log file is usually valuable
-
-For additional help, visit: https://github.com/cline/cline/issues
-`, maxRetries, lastErr, GetNodeVersion())
+	return fmt.Errorf("operation failed after %d attempts: %w", maxRetries, lastErr)
 }

cli/pkg/generated/providers.go

@@ -145,7 +145,6 @@ const (
 	XAI = "xai"
 	CEREBRAS = "cerebras"
 	OCA = "oca"
-	NOUSRESEARCH = "nousResearch"
 )
 
 // AllProviders returns a slice of enabled provider IDs for the CLI build.
@@ -162,7 +161,6 @@ var AllProviders = []string{
 	"xai",
 	"cerebras",
 	"oca",
-	"nousResearch",
 }
 
 // ConfigField represents a configuration field requirement
@@ -320,15 +318,6 @@ var rawConfigFields = `	[
 	    "fieldType": "password",
 	    "placeholder": "Enter your API key"
 	  },
-	  {
-	    "name": "nousResearchApiKey",
-	    "type": "string",
-	    "comment": "",
-	    "category": "nousResearch",
-	    "required": true,
-	    "fieldType": "password",
-	    "placeholder": "Enter your API key"
-	  },
 	  {
 	    "name": "ulid",
 	    "type": "string",
@@ -446,15 +435,6 @@ var rawConfigFields = `	[
 	    "fieldType": "url",
 	    "placeholder": "https://api.example.com"
 	  },
-	  {
-	    "name": "minimaxApiLine",
-	    "type": "string",
-	    "comment": "",
-	    "category": "general",
-	    "required": false,
-	    "fieldType": "string",
-	    "placeholder": ""
-	  },
 	  {
 	    "name": "ocaMode",
 	    "type": "string",
@@ -463,16 +443,7 @@ var rawConfigFields = `	[
 	    "required": false,
 	    "fieldType": "string",
 	    "placeholder": ""
-	  },
-	  {
-	    "name": "hicapApiKey",
-	    "type": "string",
-	    "comment": "",
-	    "category": "general",
-	    "required": true,
-	    "fieldType": "password",
-	    "placeholder": "Enter your API key"
-	  },
+	  }
 	]`
 
 // Raw model definitions data (parsed from TypeScript)
@@ -795,24 +766,6 @@ var rawModelDefinitions = `	{
 	      "supportsImages": false,
 	      "supportsPromptCache": false,
 	      "description": "A compact 20B open-weight Mixture-of-Experts language model designed for strong reasoning and tool use, ideal for edge devices and local inference."
-	    },
-	    "qwen.qwen3-coder-30b-a3b-v1:0": {
-	      "maxTokens": 8192,
-	      "contextWindow": 262144,
-	      "inputPrice": 0,
-	      "outputPrice": 0,
-	      "supportsImages": false,
-	      "supportsPromptCache": false,
-	      "description": "Qwen3 Coder 30B MoE model with 3.3B activated parameters, optimized for code generation and analysis with 256K context window."
-	    },
-	    "qwen.qwen3-coder-480b-a35b-v1:0": {
-	      "maxTokens": 8192,
-	      "contextWindow": 262144,
-	      "inputPrice": 0,
-	      "outputPrice": 1,
-	      "supportsImages": false,
-	      "supportsPromptCache": false,
-	      "description": "Qwen3 Coder 480B flagship MoE model with 35B activated parameters, designed for complex coding tasks with advanced reasoning capabilities and 256K context window."
 	    }
 	  },
 	  "gemini": {
@@ -1301,26 +1254,6 @@ var rawModelDefinitions = `	{
 	      "supportsPromptCache": false,
 	      "description": "SOTA performance with ~1500 tokens/s"
 	    }
-	  },
-	  "nousResearch": {
-	    "Hermes-4-405B": {
-	      "maxTokens": 8192,
-	      "contextWindow": 128000,
-	      "inputPrice": 0,
-	      "outputPrice": 0,
-	      "supportsImages": false,
-	      "supportsPromptCache": false,
-	      "description": "This is the largest model in the Hermes 4 family, and it is the fullest expression of our design, focused on advanced reasoning and creative depth rather than optimizing inference speed or cost."
-	    },
-	    "Hermes-4-70B": {
-	      "maxTokens": 8192,
-	      "contextWindow": 128000,
-	      "inputPrice": 0,
-	      "outputPrice": 0,
-	      "supportsImages": false,
-	      "supportsPromptCache": false,
-	      "description": "This incarnation of Hermes 4 balances scale and size. It handles complex reasoning tasks, while staying fast and cost effective. A versatile choice for many use cases."
-	    }
 	  }
 	}`
 
@@ -1490,18 +1423,6 @@ func GetProviderDefinitions() (map[string]ProviderDefinition, error) {
 		HasDynamicModels: false,
 		SetupInstructions: `Configure Oca API credentials`,
 	}
-
-	// NousResearch
-	definitions["nousResearch"] = ProviderDefinition{
-		ID:              "nousResearch",
-		Name:            "NousResearch",
-		RequiredFields:  getFieldsByProvider("nousResearch", configFields, true),
-		OptionalFields:  getFieldsByProvider("nousResearch", configFields, false),
-		Models:          modelDefinitions["nousResearch"],
-		DefaultModelID:  "Hermes-4-405B",
-		HasDynamicModels: false,
-		SetupInstructions: `Configure NousResearch API credentials`,
-	}
 	
 	return definitions, nil
 }
@@ -1529,7 +1450,6 @@ func GetProviderDisplayName(providerID string) string {
 		"xai": "X AI (Grok)",
 		"cerebras": "Cerebras",
 		"oca": "Oca",
-		"nousResearch": "NousResearch",
 	}
 	
 	if name, exists := displayNames[providerID]; exists {

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(global.CliVersion),
+		Version:      proto.String(""),
 		ClineType:    proto.String("CLI"),
 		ClineVersion: proto.String(global.CliVersion),
 	}, nil

docs/cline-cli/cli-reference.mdx

@@ -254,19 +254,6 @@ COMMANDS
        cline c l
               List all configuration variables and their values.
 
-   Context Window Configuration
-       For local model providers, you can configure the context window size:
-
-       Ollama
-              cline config s ollama-api-options-ctx-num=32768
-
-       LM Studio
-              cline config s lm-studio-max-tokens=32768
-
-       For other providers (Anthropic, OpenRouter, etc.), the context window
-       is defined per model in the model metadata and is not user-settable.
-       Cline uses each model's built-in context limits automatically.
-
 TASK SETTINGS
        Task settings are persisted in the ~/.cline/x/tasks directory.  When
        resuming a task with cline task open, task settings are automatically

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

@@ -1,324 +0,0 @@
----
-title: "GitHub Actions Integration"
-description: "Automatically respond to GitHub issues by mentioning @cline in comments using Cline CLI in GitHub Actions."
----
-
-# GitHub Integration Sample
-
-Automate GitHub issue analysis with AI. Mention `@cline` in any issue comment to trigger an autonomous investigation that reads files, analyzes code, and provides actionable insights - all running automatically in GitHub Actions.
-
-
-<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.
-</Note>
-
-## The Workflow
-
-Trigger Cline by mentioning `@cline` in any issue comment:
-
-<Frame>
-  <img src="https://storage.googleapis.com/cline_public_images/ss0a-comment.png" alt="Issue comment with @cline mention" width="600" />
-</Frame>
-
-Cline's automated analysis appears as a new comment, with insights drawn from your actual codebase:
-
-<Frame>
-  <img src="https://storage.googleapis.com/cline_public_images/ss0b-final.png" alt="Automated analysis response from Cline" width="600" />
-</Frame>
-
-The entire investigation runs autonomously in GitHub Actions - from file exploration to posting results.
-
-Let's configure your repository.
-
-## Prerequisites
-
-Before you begin, you'll need:
-
-- **Cline CLI knowledge** - Completed the [Installation Guide](https://docs.cline.bot/cline-cli/installation) and understand basic usage
-- **GitHub repository** - With admin access to configure Actions and secrets
-- **GitHub Actions familiarity** - Basic understanding of workflows and CI/CD
-- **API provider account** - OpenRouter, Anthropic, or similar with API key
-
-## Setup
-
-### 1. Copy the Workflow File
-
-
-
-Copy the workflow file from this sample to your repository. The workflow file must be placed in the `.github/workflows/` directory in your repository root for GitHub Actions to detect and run it. In this case, we'll name it `cline-responder.yml`.
-
-```bash
-# In your repository root
-mkdir -p .github/workflows
-curl -o .github/workflows/cline-responder.yml https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-integration/cline-responder.yml
-```
-
-Alternatively, you can copy the full workflow file directly into `.github/workflows/cline-responder.yml`:
-
-<Accordion title="Click to view the complete cline-responder.yml workflow">
-```yaml
-name: Cline Issue Assistant
-
-on:
-  issue_comment:
-    types: [created, edited]
-
-permissions:
-  issues: write
-
-jobs:
-  respond:
-    runs-on: ubuntu-latest
-    environment: cline-actions
-    steps:
-      - name: Check for @cline mention
-        id: detect
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const body = context.payload.comment?.body || "";
-            const isPR = !!context.payload.issue?.pull_request;
-            const hit = body.toLowerCase().includes("@cline");
-            core.setOutput("hit", (!isPR && hit) ? "true" : "false");
-            core.setOutput("issue_number", String(context.payload.issue?.number || ""));
-            core.setOutput("issue_url", context.payload.issue?.html_url || "");
-            core.setOutput("comment_body", body);
-
-      - name: Checkout repository
-        if: steps.detect.outputs.hit == 'true'
-        uses: actions/checkout@v4
-
-      # Node v20 is needed for Cline CLI on GitHub Actions Linux
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Setup Cline CLI
-        if: steps.detect.outputs.hit == 'true'
-        run: |
-          # Install the Cline CLI
-          sudo npm install -g cline
-
-      - name: Create Cline Instance
-        if: steps.detect.outputs.hit == 'true'
-        env:
-          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
-          CLINE_DIR: ${{ runner.temp }}/cline
-        run: |
-          # Create instance and capture output
-          INSTANCE_OUTPUT=$(cline instance new 2>&1)
-          
-          # Parse address from output (format: "  Address: 127.0.0.1:36733")
-          CLINE_ADDRESS=$(echo "$INSTANCE_OUTPUT" | grep "Address:" | grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]+')
-          echo "CLINE_ADDRESS=$CLINE_ADDRESS" >> $GITHUB_ENV
-          
-          # Configure API key
-          cline config set open-router-api-key=$OPENROUTER_API_KEY --address $CLINE_ADDRESS -v
-
-      - name: Download analyze script
-        if: steps.detect.outputs.hit == 'true'
-        run: |
-          export GITORG="YOUR-GITHUB-ORG"
-          export GITREPO="YOUR-GITHUB-REPO"
-
-          curl -L https://raw.githubusercontent.com/${GITORG}/${GITREPO}/refs/heads/main/git-scripts/analyze-issue.sh -o analyze-issue.sh
-          chmod +x analyze-issue.sh
-
-      - name: Run analysis
-        if: steps.detect.outputs.hit == 'true'
-        id: analyze
-        env:
-          ISSUE_URL: ${{ steps.detect.outputs.issue_url }}
-          COMMENT: ${{ steps.detect.outputs.comment_body }}
-          CLINE_ADDRESS: ${{ env.CLINE_ADDRESS }}
-        run: |
-          set -euo pipefail
-          
-          RESULT=$(./analyze-issue.sh "${ISSUE_URL}" "Analyze this issue. The user asked: ${COMMENT}" "$CLINE_ADDRESS")
-          
-          {
-            echo 'result<<EOF'
-            printf "%s\n" "$RESULT"
-            echo 'EOF'
-          } >> "$GITHUB_OUTPUT"
-
-      - name: Post response
-        if: steps.detect.outputs.hit == 'true'
-        uses: actions/github-script@v7
-        env:
-          ISSUE_NUMBER: ${{ steps.detect.outputs.issue_number }}
-          RESULT: ${{ steps.analyze.outputs.result }}
-        with:
-          script: |
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: Number(process.env.ISSUE_NUMBER),
-              body: process.env.RESULT || "(no output)"
-            });
-```
-</Accordion>
-
-<Warning>
-**You MUST edit the workflow file before committing!**
-
-Open `.github/workflows/cline-responder.yml` and update the "Download analyze script" step within the workflow to specify your GitHub organization and repository where the analysis script is stored:
-
-```yaml
-export GITORG="YOUR-GITHUB-ORG"      # Change this!
-export GITREPO="YOUR-GITHUB-REPO"    # Change this!
-```
-
-**Example:** If your repository is `github.com/acme/myproject`, set:
-```yaml
-export GITORG="acme"
-export GITREPO="myproject"
-```
-
-This tells the workflow where to download the analysis script from your repository after you commit it in step 3.
-</Warning>
-
-The workflow will look for new or updated issues, check for `@cline` mentions, and then
-start up an instance of the Cline CLI to dig into the issue, providing feedback
-as a reply to the issue.
-
-### 2. Configure API Keys
-
-Add your AI provider API keys as repository secrets:
-
-1. Go to your GitHub repository
-2. Navigate to **Settings** → **Environment** and Add a new environment.
-
-   <Frame>
-     <img src="https://storage.googleapis.com/cline_public_images/ss01-environment.png" alt="Navigate to Actions secrets" width="600" />
-   </Frame>
-
-   Make sure to name it "cline-actions" so that it matches the `environment`
-   value at the top of the `cline-responder.yml` file.
-
-3. Click **New repository secret**
-4. Add a secret for the `OPENROUTER_API_KEY` with a value of an API key from
-   [openrouter.com](https://openrouter.com).
-
-   <Frame>
-     <img src="https://storage.googleapis.com/cline_public_images/ss02-api-key.png" alt="Add API key secret" width="600" />
-   </Frame>
-
-5. Verify your secret is configured:
-
-   <Frame>
-     <img src="https://storage.googleapis.com/cline_public_images/ss03-ready.png" alt="API key configured" width="600" />
-   </Frame>
-
-Now you're ready to supply Cline with the credentials it needs in a GitHub Action.
-
-### 3. Add Analysis Script
-
-Add the analysis script from the `github-issue-rca` sample to your repository. **First, you'll need to create a `git-scripts` directory in your repository root where the script will be located.** Choose one of these options:
-
-**Option A: Download directly (Recommended)**
-
-```bash
-# In your repository root, create the directory and download the script
-mkdir -p git-scripts
-curl -o git-scripts/analyze-issue.sh https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-issue-rca/analyze-issue.sh
-chmod +x git-scripts/analyze-issue.sh
-```
-
-**Option B: Manual copy-paste**
-
-Create the directory and file manually, then paste the script content:
-
-```bash
-# In your repository root
-mkdir -p git-scripts
-# Create and edit the file with your preferred editor
-nano git-scripts/analyze-issue.sh  # or use vim, code, etc.
-```
-
-<Accordion title="Click to view the complete analyze-issue.sh script">
-```bash
-#!/bin/bash
-# Analyze a GitHub issue using Cline CLI
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <github-issue-url> [prompt] [address]"
-    echo "Example: $0 https://github.com/owner/repo/issues/123"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?'"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?' 127.0.0.1:46529"
-    exit 1
-fi
-
-# Gather the args
-ISSUE_URL="$1"
-PROMPT="${2:-What is the root cause of this issue?}"
-if [ -n "$3" ]; then
-    ADDRESS="--address $3"
-fi
-
-# Ask Cline for its analysis, showing only the summary
-cline -y "$PROMPT: $ISSUE_URL" --mode act $ADDRESS -F json | \
-    sed -n '/^{/,$p' | \
-    jq -r 'select(.say == "completion_result") | .text' | \
-    sed 's/\\n/\n/g'
-```
-
-After pasting the script content, make it executable:
-```bash
-chmod +x git-scripts/analyze-issue.sh
-```
-</Accordion>
-
-This analysis script calls Cline to execute a prompt on a GitHub issue,
-summarizing the output to populate the reply to the issue.
-
-### 4. Commit and Push
-
-```bash
-git add .github/workflows/cline-responder.yml
-git add git-scripts/analyze-issue.sh
-git commit -m "Add Cline issue assistant workflow"
-git push
-```
-
-## Usage
-
-Once set up, simply mention `@cline` in any issue comment:
-
-```
-@cline what's causing this error?
-
-@cline analyze the root cause
-
-@cline what are the security implications?
-```
-
-GitHub Actions will:
-1. Detect the `@cline` mention
-2. Start a Cline CLI instance
-3. Download the analysis script
-4. Analyze the issue using act mode with yolo (fully autonomous)
-5. Post Cline's analysis as a new comment
-
-**Note**: The workflow only triggers on issue comments, not pull request
-comments.
-
-## How It Works
-
-The workflow (`cline-responder.yml`):
-
-1. **Triggers** on issue comments (created or edited)
-2. **Detects** `@cline` mentions (case-insensitive)
-3. **Installs** Cline CLI globally using npm
-4. **Creates** a Cline instance using `cline instance new`
-5. **Configures** authentication using `cline config set open-router-api-key=...
-   --address ...`
-6. **Downloads** the reusable `analyze-issue.sh` script from the
-   `github-issue-rca` sample
-7. **Runs** analysis with the instance address
-8. **Posts** the analysis result as a comment
-
-## Related Samples
-
-- **[github-issue-rca](./github-issue-rca)**: The reusable script that powers this integration

docs/cline-cli/samples/github-issue-rca.mdx

@@ -1,383 +0,0 @@
----
-title: "GitHub Issue RCA Sample"
-description: "Automated GitHub issue analysis using Cline CLI to identify root causes."
----
-
-# GitHub Root Cause Analysis
-
-Automated GitHub issue analysis using Cline CLI. This script uses Cline's autonomous AI capabilities to fetch, analyze, and identify root causes of GitHub issues, outputting clean, parseable results that can be easily integrated into your development workflows.
-
-<Note>
-**New to Cline CLI?** This sample assumes you have already completed the [Installation Guide](https://docs.cline.bot/cline-cli/installation) and authenticated with `cline auth`. If you haven't set up Cline CLI yet, please start there first.
-</Note>
-
-<Frame>
-  <img src="https://storage.googleapis.com/cline_public_images/cli-rca.gif" alt="CLI Root Cause Analysis Demo" width="600" />
-</Frame>
-
-## Prerequisites
-
-This sample assumes you have already:
-
-- **Cline CLI** installed and authenticated ([Installation Guide](https://docs.cline.bot/cline-cli/installation))
-- **At least one AI model provider** configured (e.g., OpenRouter, Anthropic, OpenAI)
-- **Basic familiarity** with Cline CLI commands
-
-Additionally, you'll need:
-
-- **GitHub CLI** (`gh`) installed and authenticated
-- **jq** installed for JSON parsing
-- **bash** shell (or compatible shell)
-
-### Installation Instructions
-
-#### macOS
-
-<Note>
-These instructions require [Homebrew](https://brew.sh/) to be installed. If you don't have Homebrew, install it first by running:
-```bash
-/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-```
-</Note>
-
-```bash
-# Install GitHub CLI
-brew install gh
-
-# Install jq
-brew install jq
-
-# Authenticate with GitHub
-gh auth login
-```
-
-#### Linux
-
-```bash
-# Install GitHub CLI (Debian/Ubuntu)
-sudo apt install gh
-
-# Or for other Linux distributions, see: https://cli.github.com/manual/installation
-
-# Install jq (Debian/Ubuntu)
-sudo apt install jq
-
-# Authenticate with GitHub
-gh auth login
-```
-
-## Getting the Script
-
-**Option 1: Download directly with curl**
-```bash
-curl -O https://raw.githubusercontent.com/cline/cline/main/src/samples/cli/github-issue-rca/analyze-issue.sh
-```
-
-**Option 2: Copy the full script**
-
-<Accordion title="Click to view the complete analyze-issue.sh script">
-
-```bash
-#!/bin/bash
-# Analyze a GitHub issue using Cline CLI
-
-if [ -z "$1" ]; then
-    echo "Usage: $0 <github-issue-url> [prompt] [address]"
-    echo "Example: $0 https://github.com/owner/repo/issues/123"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?'"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause of this issue?' 127.0.0.1:46529"
-    exit 1
-fi
-
-# Gather the args
-ISSUE_URL="$1"
-PROMPT="${2:-What is the root cause of this issue?}"
-if [ -n "$3" ]; then
-    ADDRESS="--address $3"
-fi
-
-# Ask Cline for its analysis, showing only the summary
-cline -y "$PROMPT: $ISSUE_URL" --mode act $ADDRESS -F json | \
-    sed -n '/^{/,$p' | \
-    jq -r 'select(.say == "completion_result") | .text' | \
-    sed 's/\\n/\n/g'
-```
-
-</Accordion>
-
-<Note>
-**After downloading or creating the script**, make it executable by running:
-```bash
-chmod +x analyze-issue.sh
-```
-</Note>
-
-## Quick Usage Examples
-
-### Basic Usage
-
-Run this command in your terminal from the directory where you saved the script to analyze an issue with the default root cause prompt:
-
-```bash
-./analyze-issue.sh https://github.com/owner/repo/issues/123
-```
-
-This will:
-- Fetch issue #123 from the repository
-- Analyze the issue to identify root causes
-- Provide detailed analysis with recommendations
-
-### Custom Analysis Prompt
-
-Ask specific questions about the issue:
-
-```bash
-./analyze-issue.sh https://github.com/owner/repo/issues/456 "What is the security impact?"
-```
-
-### Using Specific Cline Instance
-
-Target a particular Cline instance by address:
-
-```bash
-./analyze-issue.sh https://github.com/owner/repo/issues/123 \
-    "What is the root cause of this issue?" \
-    127.0.0.1:46529
-```
-
-<Warning>
-This is useful when:
-- Running multiple Cline instances
-- Using a remote Cline server
-- Testing with specific configurations
-</Warning>
-
-<Note>
-The script will automatically handle everything: fetching the issue, analyzing it with Cline, and displaying the results. The analysis typically takes 30-60 seconds depending on the issue complexity.
-</Note>
-
-## How It Works
-
-Let's analyze each component of the script to understand how it works.
-
-### Argument Validation
-
-The script validates input and provides usage instructions:
-
-```bash
-if [ -z "$1" ]; then
-    echo "Usage: $0 <github-issue-url> [prompt] [address]"
-    echo "Example: $0 https://github.com/owner/repo/issues/123"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'What is the root cause?'"
-    echo "Example: $0 https://github.com/owner/repo/issues/123 'Analyze security impact' 127.0.0.1:46529"
-    exit 1
-fi
-```
-
-**Key Points:**
-- Validates required GitHub issue URL
-- Shows clear usage examples
-- Supports optional custom prompt
-- Supports optional Cline instance address
-
-### Argument Parsing
-
-The script extracts and sets up the arguments:
-
-```bash
-# Gather the args
-ISSUE_URL="$1"
-PROMPT="${2:-What is the root cause of this issue?}"
-if [ -n "$3" ]; then
-    ADDRESS="--address $3"
-fi
-```
-
-**Explanation:**
-- `ISSUE_URL="$1"` - First argument is always the issue URL
-- `PROMPT="${2:-...}"` - Second argument is optional, defaults to root cause analysis
-- `ADDRESS` - Third argument is optional, only set if provided
-
-### The Core Analysis Pipeline
-
-This is where the magic happens:
-
-```bash
-# Ask Cline for his analysis, showing only the summary
-cline -y "$PROMPT: $ISSUE_URL" --mode act $ADDRESS -F json | \
-    sed -n '/^{/,$p' | \
-    jq -r 'select(.say == "completion_result") | .text' | \
-    sed 's/\\n/\n/g'
-```
-
-<Accordion title="Pipeline Breakdown: Understanding Each Component">
-
-**1. `cline -y "$PROMPT: $ISSUE_URL"`**
-   - `-y` enables yolo mode (no user interaction)
-   - Constructs prompt with issue URL
-
-**2. `--mode act`**
-   - Enables act mode for active investigation
-   - Allows Cline to use tools (read files, run commands, etc.)
-
-**3. `$ADDRESS`**
-   - Optional address flag for specific instance
-   - Expands to `--address <ip:port>` if set
-
-**4. `-F json`**
-   - Outputs in JSON format for parsing
-
-**5. `sed -n '/^{/,$p'`**
-   - Extracts JSON from output
-   - Skips any non-JSON prefix lines
-
-**6. `jq -r 'select(.say == "completion_result") | .text'`**
-   - Filters for completion result messages
-   - Extracts the text field
-   - `-r` outputs raw strings (no JSON quotes)
-
-**7. `sed 's/\\n/\n/g'`**
-   - Converts escaped newlines to actual newlines
-   - Makes output readable
-
-</Accordion>
-
-## Sample Output
-
-Here's an example analyzing a real Flutter issue:
-
-```bash
-$ ./analyze-issue.sh https://github.com/csells/flutter_counter/issues/2
-```
-
-**Output:**
-
-```markdown
-**Root Cause Analysis of Issue #2: "setState isn't cutting it"**
-
-After examining the GitHub issue and analyzing the Flutter counter codebase, 
-I've identified the root cause of why setState() is insufficient for this 
-project's needs:
-
-## Current Implementation Problems
-
-The current Flutter counter app uses setState() for state management, which 
-has several limitations:
-
-1. **Local State Only**: setState() only works within a single widget, making 
-   it difficult to share state across the app
-2. **Rebuild Overhead**: Every setState() call rebuilds the entire widget tree, 
-   causing performance issues with complex UIs
-3. **No State Persistence**: State is lost when the widget is disposed
-4. **Testing Challenges**: setState-based logic is tightly coupled to the UI, 
-   making unit testing difficult
-
-## Why This Matters
-
-As the app grows beyond a simple counter, these limitations become critical:
-- Multiple screens need to access the count
-- State needs to persist across navigation
-- Business logic should be testable independently
-- UI should only rebuild when necessary
-
-## Recommended Solutions
-
-The issue mentions "Provider or Bloc" - both are excellent alternatives:
-
-1. **Provider**: Simple, lightweight state management using InheritedWidget
-   - Easy migration path from setState
-   - Good for small to medium apps
-   - Official Flutter recommendation
-
-2. **Bloc**: More structured approach with clear separation between events, 
-   states, and business logic
-   - Better for complex apps
-   - Excellent testability
-   - Clear architectural patterns
-
-3. **Riverpod**: Modern alternative to Provider with better performance and 
-   developer experience
-   - Compile-time safety
-   - Better testing support
-   - More flexible than Provider
-
-4. **GetX**: Full-featured solution with state management, routing, and 
-   dependency injection
-   - Minimal boilerplate
-   - Fast and lightweight
-   - All-in-one solution
-
-## Next Steps
-
-The current codebase needs refactoring to implement proper state management 
-architecture to handle more complex state scenarios effectively. Provider 
-would be the easiest migration path while Bloc provides better long-term 
-scalability.
-```
-
-## When to Use This Pattern
-
-This script pattern is ideal for various development scenarios where automated GitHub issue analysis can accelerate your workflow.
-
-### Bug Investigation
-
-Quickly analyze bug reports and identify root causes without manual code exploration:
-
-```bash
-./analyze-issue.sh https://github.com/project/repo/issues/123 \
-    "What is the root cause of this bug?"
-```
-
-### Feature Request Analysis
-
-Understand context and implications of feature requests:
-
-```bash
-./analyze-issue.sh https://github.com/project/repo/issues/456 \
-    "What are the implementation challenges?"
-```
-
-### Security Audits
-
-Assess security implications of reported issues:
-
-```bash
-./analyze-issue.sh https://github.com/project/repo/issues/789 \
-    "What are the security implications?"
-```
-
-### Documentation Generation
-
-Generate detailed technical documentation from issues:
-
-```bash
-./analyze-issue.sh https://github.com/project/repo/issues/654 \
-    "Provide detailed technical documentation for this issue"
-```
-
-### Code Review Assistance
-
-Get second opinions on proposed changes:
-
-```bash
-./analyze-issue.sh https://github.com/project/repo/issues/987 \
-    "Review the proposed solution approach"
-```
-
-## Conclusion
-
-This sample demonstrates how to build an autonomous GitHub issue analysis tool using Cline CLI:
-
-1. **Building autonomous CLI tools** using Cline's capabilities
-2. **Parsing structured JSON output** from Cline CLI
-3. **Creating flexible automation scripts** with custom prompting
-4. **Integrating with GitHub** for issue analysis
-5. **Handling command-line arguments** effectively
-
-This pattern can be adapted for many other automation scenarios, from pull request reviews to documentation generation to code quality analysis.
-
-## Related Resources
-
-- [CLI Installation Guide](https://docs.cline.bot/cline-cli/installation)
-- [CLI Reference Documentation](https://docs.cline.bot/cline-cli/cli-reference)
-- [Three Core Flows](https://docs.cline.bot/cline-cli/three-core-flows)

docs/cline-cli/samples/overview.mdx

@@ -1,32 +0,0 @@
----
-title: "Samples Overview"
-description: Example implementations demonstrating Cline CLI capabilities
----
-
-This section provides sample implementations that demonstrate various Cline CLI features and capabilities. Each sample includes complete code, detailed explanations, and real-world usage examples.
-
-## Available Samples
-
-<CardGroup cols={1}>
-  <Card 
-    title="GitHub Root Cause Analysis" 
-    icon="magnifying-glass-chart" 
-    href="/cline-cli/samples/github-issue-rca"
-  >
-    A command-line script that uses Cline's autonomous AI capabilities to fetch, analyze, and identify root causes of GitHub issues. Features JSON output parsing and non-interactive execution.
-  </Card>
-
-  <Card 
-    title="GitHub Integration (Actions)" 
-    icon="github" 
-    href="/cline-cli/samples/github-integration"
-  >
-    Automatically respond to GitHub issues by mentioning @cline in comments. Uses Cline CLI in GitHub Actions to create an AI-powered issue assistant that analyzes and responds autonomously.
-  </Card>
-</CardGroup>
-
-## Additional Resources
-
-- [CLI Installation Guide](/cline-cli/installation)
-- [CLI Reference Documentation](/cline-cli/cli-reference)
-- [Three Core Flows](/cline-cli/three-core-flows)

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

@@ -113,20 +113,6 @@ cline instances kill -a
 Keep track of instance addresses returned by `cline instance new`. When scripting multiple agents, store these IDs and direct your tasks to the appropriate instance.
 </Tip>
 
-## Configuring context window for local providers
-
-For Ollama and LM Studio, you can configure the model context window via CLI:
-
-```bash
-# For Ollama
-cline config s ollama-api-options-ctx-num=32768
-
-# For LM Studio
-cline config s lm-studio-max-tokens=32768
-```
-
-For other providers (Anthropic, OpenRouter, etc.), the context window is defined per model in the model metadata and is not user-configurable—Cline uses each model's built-in context limits automatically.
-
 ## Choosing the right flow
 
 - **Interactive mode**: Best for exploring new problems, learning how Cline works, or when you want to review plans before execution
@@ -152,7 +138,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="/features/tasks/task-management">
+  <Card title="Task management" icon="clipboard-check" href="/getting-started/task-management">
     Learn how Cline tracks and manages tasks, including saving and restoring state from checkpoints.
   </Card>
 </Columns>

docs/docs.json

@@ -88,14 +88,6 @@
 							"cline-cli/overview",
 							"cline-cli/installation",
 							"cline-cli/three-core-flows",
-							{
-								"group": "CLI Samples",
-								"pages": [
-									"cline-cli/samples/overview",
-									"cline-cli/samples/github-issue-rca",
-									"cline-cli/samples/github-integration"
-								]
-							},
 							"cline-cli/cli-reference"
 						]
 					},
@@ -137,16 +129,7 @@
 							"features/dictation",
 							"features/drag-and-drop",
 							"features/editing-messages",
-							"features/explain-changes",
 							"features/focus-chain",
-							{
-								"group": "Hooks",
-								"pages": [
-									"features/hooks/index",
-									"features/hooks/hook-reference",
-									"features/hooks/samples"
-								]
-							},
 							"features/multiroot-workspace",
 							"features/plan-and-act",
 							{
@@ -154,20 +137,12 @@
 								"pages": [
 									"features/slash-commands/new-task",
 									"features/slash-commands/new-rule",
-									"features/slash-commands/explain-changes",
 									"features/slash-commands/smol",
 									"features/slash-commands/report-bug",
 									"features/slash-commands/deep-planning"
 								]
 							},
-							{
-								"group": "Workflows",
-								"pages": [
-									"features/slash-commands/workflows/index",
-									"features/slash-commands/workflows/quickstart",
-									"features/slash-commands/workflows/best-practices"
-								]
-							},
+							"features/slash-commands/workflows",
 							{
 								"group": "Task Management",
 								"pages": [
@@ -205,7 +180,6 @@
 									"provider-config/fireworks",
 									"provider-config/zai",
 									"provider-config/gcp-vertex-ai",
-									"provider-config/baseten",
 									{
 										"group": "AWS Bedrock",
 										"pages": [
@@ -232,7 +206,8 @@
 									"provider-config/vscode-language-model-api",
 									"provider-config/sap-aicore",
 									"provider-config/vercel-ai-gateway",
-									"provider-config/requesty"
+									"provider-config/requesty",
+									"provider-config/baseten"
 								]
 							}
 						]
@@ -258,68 +233,18 @@
 						]
 					},
 					{
-						"group": "Reference",
-						"pages": [
-							"troubleshooting/networking-and-proxies",
-							"troubleshooting/terminal-quick-fixes",
-							"troubleshooting/terminal-integration-guide",
-							"troubleshooting/task-history-recovery",
-							"more-info/telemetry"
-						]
-					}
-				]
-			},
-			{
-				"tab": "Enterprise",
-				"icon": "building",
-				"groups": [
-					{
-						"group": "Enterprise Solutions",
+						"group": "Enterprise",
 						"pages": [
 							"enterprise-solutions/overview",
-							"enterprise-solutions/onboarding",
-							"enterprise-solutions/team-management/managing-members",
-							{
-								"group": "SaaS Provider Configuration",
-								"pages": [
-									"enterprise-solutions/configuration/remote-configuration/overview",
-									{
-										"group": "AWS Bedrock",
-										"pages": [
-											"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"
-								]
-							}
+							"enterprise-solutions/security-concerns"
+						]
+					},
+					{
+						"group": "Reference",
+						"pages": [
+							"troubleshooting/terminal-quick-fixes",
+							"troubleshooting/terminal-integration-guide",
+							"more-info/telemetry"
 						]
 					}
 				]
@@ -328,6 +253,11 @@
 				"tab": "Learn",
 				"icon": "graduation-cap",
 				"href": "https://cline.bot/learn"
+			},
+			{
+				"tab": "Blog",
+				"icon": "newspaper",
+				"href": "https://cline.bot/blog"
 			}
 		]
 	},
@@ -385,38 +315,6 @@
 		{
 			"source": "/getting-started/your-first-task",
 			"destination": "/getting-started/your-first-project"
-		},
-		{
-			"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/configuration/remote-configuration/aws-bedrock/admin-configuration"
-		},
-		{
-			"source": "/enterprise-solutions/configure-AWS-Bedrock-Member",
-			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
-		},
-		{
-			"source": "/enterprise-solutions/configure-workOS-authkit",
-			"destination": "/enterprise-solutions/onboarding"
-		},
-		{
-			"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

@@ -1,105 +0,0 @@
----
-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

@@ -1,35 +0,0 @@
----
-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

@@ -1,233 +0,0 @@
----
-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

@@ -1,565 +0,0 @@
----
-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

@@ -1,571 +0,0 @@
----
-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

@@ -1,95 +0,0 @@
----
-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

@@ -1,182 +0,0 @@
----
-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

@@ -1,254 +0,0 @@
----
-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

@@ -1,185 +0,0 @@
----
-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

@@ -1,215 +0,0 @@
----
-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

@@ -1,144 +0,0 @@
----
-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

@@ -1,239 +0,0 @@
----
-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

@@ -1,324 +0,0 @@
----
-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

@@ -1,97 +0,0 @@
----
-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

@@ -1,125 +0,0 @@
----
-title: "Configure AWS Bedrock Provider (Admin)"
-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 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
-
-To get started with setting up AWS Bedrock 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.
-
-
-**AWS Bedrock account with the right permissions**  
-Your AWS account needs specific Bedrock permissions to work with Cline. 
-
-<Note>
-If you don't have direct AWS access, coordinate with your cloud team to get these permissions set up before proceeding.
-</Note>
-
-**Your preferred AWS region**  
-Choose your primary AWS region carefully since this will be enforced for all users.
-
-<Tip>
-Check which models are available in your region first. Some newer models might not be available in all regions yet.
-</Tip>
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline-static-assets-prod/assets/AWS%20Remote%20Config.gif"
-	/>
-</Frame>
-
-## 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 AWS Bedrock as the API Provider">
-Open the **API Provider** dropdown menu and select **Amazon Bedrock**. This will open the Bedrock configuration panel where you'll configure all your organization-wide settings.
-</Step>
-
-<Step title="Configure Bedrock Settings">
-The configuration panel includes several settings that control how Bedrock works for your organization. Configure what you need:
-
-<AccordionGroup>
-<Accordion title="Region (required)">
-Enter your preferred AWS region like `us-west-2` or `us-east-1`. This region will be enforced for all organization members.
-
-[View AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
-
-<Tip>
-For most organizations, `us-east-1` or `us-west-2` are recommended as they have the best model availability.
-</Tip>
-</Accordion>
-
-<Accordion title="Custom VPC Endpoint (optional)">
-If your organization uses a private VPC endpoint for Bedrock, specify it here to ensure all API calls go through your network infrastructure.
-
-[Learn more about AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)
-</Accordion>
-
-<Accordion title="Cross-region Inference (optional)">
-Enable this to let Bedrock automatically route requests to other regions when your primary region has capacity constraints. Useful for maintaining availability during high-demand periods.
-
-[Learn more about Inference Profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html)
-</Accordion>
-
-<Accordion title="Global Inference Profile (optional)">
-Turn this on to use AWS's global inference routing, which automatically directs requests to the optimal region based on availability and latency.
-</Accordion>
-
-<Accordion title="Prompt Caching (optional)">
-Enable prompt caching to reduce costs and latency. Bedrock caches portions of prompts that remain consistent across requests, making repeated interactions faster and cheaper.
-
-[Learn more about Prompt Caching](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html)
-</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 AWS Bedrock 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 "Amazon Bedrock" 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 Bedrock as a provider
-
-## 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.
-
-**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 regions later**  
-You can update the region at any time. Members will need to ensure their local AWS credentials have access to the new region. For more information, refer to the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
-
-For further details, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your internal cloud team.

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

@@ -1,131 +0,0 @@
----
-title: "Configure AWS Bedrock in VS Code (Members)"
-sidebarTitle: "Configure AWS Bedrock (Member)"
-description: "Guide for engineers configuring AWS Bedrock credentials in VS Code after admin setup"
----
-
-As a team member, you can connect your local development environment to your organization's AWS Bedrock setup. This guide walks you through configuring your AWS credentials in VS Code so you can start using models through your organization's Bedrock infrastructure. 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 AWS Bedrock 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>
-
-**AWS credentials with Bedrock access**  
-You need AWS credentials that have permission to access Bedrock in your organization's configured region.
-
-<Note>
-If you don't have AWS credentials yet, reach out to your IT or cloud team to get access keys or AWS CLI profiles configured with the necessary Bedrock permissions.
-</Note>
-
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline-static-assets-prod/assets/VS%20Code%20Bedrock%20API%20Key.gif"
-	/>
-</Frame>
-
-## 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 `bedrock.anthropic.claude-sonnet-4-20250514-v1:0` or similar)
-
-</Step>
-
-<Step title="Select Your Authentication Method">
-Choose one of the following credential methods to authenticate with AWS Bedrock:
-
-<AccordionGroup>
-<Accordion title="AWS Bedrock API Key">
-Use dedicated AWS access keys specifically for Bedrock access.
-
-[Learn more about AWS Bedrock API Keys](https://docs.aws.amazon.com/bedrock/latest/userguide/api-keys.html)
-
-1. Select the **API Key** radio button
-2. Enter your AWS Access Key ID and Secret Access Key
-3. These credentials are stored locally and used only by the VS Code extension
-</Accordion>
-
-<Accordion title="AWS Profile">
-Use an existing AWS CLI profile configured on your machine.
-
-[Learn more about AWS CLI Profiles](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html)
-
-1. Select the **AWS Profile** radio button
-2. Choose or enter the profile name from your `~/.aws/credentials` file
-3. Cline will use the credentials associated with that profile
-</Accordion>
-
-<Accordion title="AWS Credentials">
-Use your default AWS credential chain (environment variables, EC2 instance roles, etc.).
-
-1. Select the **AWS Credentials** radio button
-2. Cline will automatically detect credentials from your environment using the standard AWS credential provider chain
-</Accordion>
-</AccordionGroup>
-
-<Note>
-The AWS Region is preconfigured by your administrator and does 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
-- ✓ Supports browser use
-- ✓ Supports prompt caching
-
-Additional settings like cross-region inference and global inference profile 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 Bedrock region.
-
-<Tip>
-**Testing Recommendation**
-
-It is recommended to test the connection in plan mode to verify everything works correctly before using it for actual tasks.
-</Tip>
-</Step>
-</Steps>
-
-
-## Troubleshooting
-
-**Authentication errors ("Access Denied" or "Invalid Credentials")**  
-Verify your chosen credential method has the necessary IAM permissions to call Bedrock in the configured region. Required permissions include `bedrock:InvokeModel` and `bedrock:InvokeModelWithResponseStream`. For more information, refer to [AWS Bedrock IAM Permissions](https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html).
-
-**Region-related errors or "model not available"**  
-Ask your administrator to confirm which region is configured for your organization. Ensure your AWS credentials have access to Bedrock in that specific region. [View AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
-
-**Don't see AWS Bedrock as an option**  
-Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Bedrock configuration. Try signing out and back into the extension.
-
-**AWS Credentials option not finding credentials**  
-Verify AWS CLI is installed and configured with `aws configure` ([AWS CLI Installation Guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)). Check that credentials are present in `~/.aws/credentials`. For EC2/ECS environments, ensure IAM roles are properly attached. If using environment variables, set `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
-
-
-## Security Best Practices
-
-When configuring your AWS credentials, follow these security guidelines:
-
-- Use IAM roles with minimum required permissions ([AWS IAM Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html))
-- Rotate access keys regularly if using the API Key method
-- Never store credentials in code or version control
-- Prefer AWS Profile method for better credential management
-- Consider using AWS SSO/federated roles for enhanced security
-
-Your organization administrator controls which models are available. The extension will automatically display available models based on your region's Bedrock configuration. For more information about available models, refer to the [AWS Bedrock Model Access documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html).
-
-For further assistance, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your organization's cloud administrator.

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

@@ -1,112 +0,0 @@
----
-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

@@ -1,177 +0,0 @@
----
-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

@@ -1,120 +0,0 @@
----
-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

@@ -1,168 +0,0 @@
----
-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

@@ -1,102 +0,0 @@
----
-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/monitoring/opentelemetry.mdx

@@ -1,266 +0,0 @@
----
-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

@@ -1,111 +0,0 @@
----
-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

@@ -1,133 +0,0 @@
----
-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

@@ -1,128 +0,0 @@
----
-title: "Onboarding"
-
-description: "This guide explains how administrators configure SSO provisioning and user management in Cline Enterprise."
----
-
-## Overview
-Cline Enterprise integrates with your existing identity provider (IdP) via WorkOS to deliver secure SSO and zero-touch user lifecycle management. In this guide, you'll connect your IdP (Okta, Azure AD, Google Workspace, or any SAML/OIDC provider), enable just-in-time (JIT) provisioning so new users are created automatically on first sign-in, and configure role mapping so permissions stay aligned with your directory—no manual invites or seat reconciliations required.
-
-
-## Prerequisites
-
-- [Cline Enterprise License](https://cline.bot/enterprise)
-- Access to your identity provider (IdP) configuration (e.g., Okta, Azure AD, Google Workspace)
-- Knowledge of your organization's SSO requirements
-
-## Configuration Steps
-
-### Step 1: Onboard to Cline Enterprise license
-
-Your IdP administrator will receive an email with a link to register their organization with WorkOS during onboarding.
-
-### Step 2: Configure Your Identity Provider
-
-Connect your identity provider (IdP) to WorkOS:
-
-1. In the WorkOS dashboard, go to **AuthKit → Connections**
-2. Click **Add Connection**
-3. Select your identity provider (e.g., Okta, Azure AD, Google Workspace, Generic SAML/OIDC)
-4. Follow the provider-specific setup instructions
-
-Each identity provider (IdP) will have its own setup process and required fields. Be sure to follow the specific instructions in the WorkOS dashboard for your chosen provider.
-For more explicit instruction on connecting your IdP, refer to the [WorkOS SSO documentation](https://workos.com/docs/authkit/sso)
-
-### Step 3: Configure User Provisioning
-
-Cline Enterprise uses **just-in-time provisioning** that works automatically:
-
-- **Organizations are created automatically**
-- **Users gain access automatically** on their first SSO sign-in, once their credentials have been configured by the IdP administrator.
-- **Roles sync automatically** from your IdP (Admin/Owner → Admin, Member → Member)
-- **No manual user invites or seat management** required
-
-No additional configuration is needed. Users are provisioned automatically when they sign in through SSO.
-
-### Step 4: Configure User Attributes Mapping
-
-User roles are mapped automatically from your IdP:
-
-- **Admin** in IdP → **Admin** role in Cline (Note: The first Owner of the org is created manually during onboarding)
-- **Member** in IdP → **Member** role in Cline
-
-<Info>
-    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:
-
-1. Go to **Settings → Authentication → User Attributes**
-2. Map attributes such as email and name based on your IdP configuration
-
-For information about available user attributes, see the [WorkOS User Object Documentation](https://workos.com/docs/authkit/user-management).
-
-### Step 5: Test SSO Connection
-
-Before allowing users to sign in, test the SSO flow to ensure everything is configured correctly.
-
-**To test the connection:**
-
-1. In the WorkOS dashboard (or Cline Admin console if available), locate and click **Test SSO Connection**
-2. You'll be redirected to your IdP's login page
-3. Enter valid credentials for a test user
-4. After successful authentication, you should be redirected back
-5. Confirm that the user's information (name, email, role) displays correctly
-
-**Expected outcome:** The test user is authenticated, their account details are visible, and their role matches what's configured in your IdP.
-
-**If the test fails:** Double-check your IdP configuration (redirect URIs, SAML certificates, attribute mappings). See the [WorkOS SSO documentation](https://workos.com/docs/authkit/sso) for troubleshooting guidance.
-
-### User Access
-
-Once SSO is configured, users in your IdP can access Cline automatically without manual invites or account setup.
-
-**First-time sign-in flow:**
-
-1. User navigates to Cline and clicks **Sign in with SSO**
-2. User authenticates via your organization's IdP
-3. Cline automatically creates their account in your Organization
-4. Role is assigned based on their IdP role (see [Step 4](#step-4-configure-user-attributes-mapping))
-5. User is redirected to Cline and can begin working
-
-**What happens automatically:**
-- Account creation with correct organization assignment
-- Role and permission assignment
-- Basic profile information (name, email) populated from IdP
-
-**No action required:** Users don't need to request access or wait for approval. Access is granted immediately upon successful IdP authentication.
-
-### Managing Access
-
-All access management and revocation of users is currently handled by your IdP:
-
-- Add users → access granted automatically on first login
-- Change roles → updated on next login
-- Remove users → access revoked automatically
-
-<Info>
-Role changes sync automatically on the user's next sign-in.
-</Info>
-
-### Changing your IdP
-
-In order to change to a different IdP, please contact support and we will guide you through this process.
-
----
-
-## Verification
-
-Steps to verify successful configuration:
-
-1. **Test User Sign-In**: Have a test user sign in through the SSO flow (access is granted automatically on first login)
-2. **Verify User Provisioning**: Confirm that the user is automatically created and has appropriate role permissions
-3. **Check User Attributes**: Verify that user information (name, email, organization) is correctly populated
-4. **Test Role Changes**: Update a user's role in your IdP and verify it syncs on their next login
-5. **Test User Deprovisioning**: Remove a user from your IdP and verify they lose access to Cline on their next login attempt
-6. **Review Audit Logs**: Check WorkOS audit logs to ensure authentication events are being recorded
-
----

docs/enterprise-solutions/overview.mdx

@@ -1,7 +1,7 @@
 ---
 title: "Cline Enterprise"
 sidebarTitle: "Overview"
-description: "Enterprise security, governance, and observability for the coding agent millions of developers trust"
+description: "Enterprise security, governance, and observability for the coding agent 3 million 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**: Three-tier hierarchy (Member/Admin/Owner) with organization-scoped permissions
+- **Role-based access control**: Fine-grained permissions per team and project
 - **Model and tool controls**: Govern which models and tools each team accesses
 - **Remote configuration**: Manage settings for all developers from one dashboard
-- **Usage tracking and observability**: OpenTelemetry integration for monitoring usage, costs, and performance with selective audit logging for administrative operations
+- **Full audit logging**: Every AI interaction tracked with detailed logs
 
 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. Configure to work with your existing security policies and compliance requirements.
+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.
 
 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
+- Review [security architecture](/enterprise-solutions/security-concerns)
 - 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/security-concerns.mdx

@@ -0,0 +1,61 @@
+---
+title: "Security Concerns"
+---
+
+## Enterprise Security with Cline
+
+Cline addresses enterprise security concerns through its unique client-side architecture that prioritizes data privacy, secure cloud integration, and transparent operations. Below is a comprehensive overview of how Cline maintains robust security measures for enterprise environments.
+
+### Client-Side Architecture
+
+Cline operates exclusively as a client-side VSCode extension with zero server-side components. This fundamental design choice ensures that your code and data remain within your secure environment at all times. Unlike traditional AI assistants that send data to external servers for processing, Cline connects directly to your chosen cloud provider's AI endpoints, keeping all sensitive information within your infrastructure boundaries.
+
+<Frame>
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-arch.png"
+		alt="Cline's relationship to local and remote assets"
+	/>
+</Frame>
+
+### Data Privacy Commitment
+
+Cline implements a strict zero data retention policy, meaning your intellectual property never leaves your secure environment. The extension does not collect, store, or transmit your code to any central servers. This approach significantly reduces potential attack vectors that might otherwise be introduced through data transmission to third-party systems. Telemetry collection is optional and requires explicit consent.
+
+### Cloud Provider Integration
+
+Enterprise teams can access cutting-edge AI models through their existing cloud deployments. Cline supports seamless integration with:
+
+-   AWS Bedrock
+-   Google Cloud Vertex AI
+-   Microsoft Azure
+
+These integrations utilize your organization's existing security credentials, including native IAM role assumption for AWS. This ensures that all AI processing occurs within your corporate cloud environment, maintaining compliance with your established security protocols.
+
+### Open-Source Transparency
+
+Cline's codebase is completely open-source, allowing for comprehensive security auditing by your internal teams. This transparency enables security professionals to verify exactly how the extension functions and confirm that it adheres to your organization's security requirements. Organizations can review the code to ensure it aligns with their security policies before deployment.
+
+### Controlled Modifications
+
+The extension implements safeguards against unauthorized changes to your codebase. Cline requires explicit user approval for all file modifications and terminal commands, preventing accidental or unwanted alterations. This approval-based workflow maintains the integrity of your projects while still providing AI assistance.
+
+### Enterprise Deployment Support
+
+For organizations with strict security review processes, Cline provides comprehensive documentation including detailed deployment diagrams, sequence diagrams illustrating all data flows, and complete security posture documentation. These materials facilitate thorough security reviews and help demonstrate compliance with enterprise data handling standards and regulations.
+
+### Access Control
+
+Enterprise editions of Cline (planned for Q2 2025) will include centralized administration features that allow organizations to:
+
+-   Manage user access with customizable permission levels
+-   Provision accounts with corporate credentials
+-   Immediately revoke access when needed
+-   Control which AI providers and LLM endpoints can be used
+-   Deploy standardized settings across the organization
+-   Prevent unauthorized use of personal API keys
+
+### Compliance and Governance
+
+Cline's architecture supports compliance with data sovereignty requirements and enterprise data handling regulations. The planned Enterprise Complete edition will further enhance governance with detailed audit logging, compliance reporting, and automated policy enforcement mechanisms.
+
+By combining client-side processing, direct cloud provider integration, and transparent operations, Cline offers enterprise teams a secure way to leverage AI assistance while maintaining strict control over their sensitive code and data.

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

@@ -1,317 +0,0 @@
----
-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/checkpoints.mdx

@@ -15,30 +15,6 @@ Cline creates a checkpoint after each tool use (file edits, commands, etc.). The
 
 For example, if you're working on a feature and Cline makes multiple file changes, each change creates a checkpoint. This means you can review each modification and, if needed, roll back to any point without affecting your main Git repository.
 
-## Enabling or Disabling Checkpoints
-
-Checkpoints are enabled by default in Cline. To toggle this feature:
-
-1. Open the Cline settings by clicking the gear icon in the Cline panel
-2. Go to "Feature Settings"
-3. Toggle the **"Enable Checkpoints"** checkbox on or off
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline_public_images/checkpoints.gif"
-		alt="Checkpoints toggle in settings"
-	/>
-</Frame>
-
-### When to Disable Checkpoints
-
-While checkpoints provide valuable safety nets, you might want to disable them in certain situations:
-
--   **Large repositories**: If you're working with very large codebases, checkpoints may use additional storage space
--   **Performance concerns**: On systems with limited resources, disabling checkpoints can slightly improve performance
--   **Simple tasks**: For quick, low-risk operations where rollback isn't needed
-
-
 ## Viewing Changes & Restoring
 
 After each tool use, you can: