test: add comprehensive test suite for applyFileReadContextHistoryUpdates

Add extensive test coverage for the applyFileReadContextHistoryUpdates method in ContextManager. Tests cover various scenarios including:
- Early return when fileReadIndices is empty
- Handling single file occurrences
- Updating duplicate file reads (keeping only last occurrence)
- FILE_MENTION type with multiple files
- Text block replacements in API messages
- Edge cases and error conditions

This ensures the file read deduplication logic works correctly across different message types and file configurations.

.changeset/forty-carpets-grin.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Add DeepSeek 3.2 to native tool calling allow list

.changeset/silver-masks-clap.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Prevent simultaneuos refreshes when restoring auth info

.claude/commands/hotfix-release.md

@@ -1 +0,0 @@
-../../.clinerules/workflows/hotfix-release.md

.claude/commands/release.md

@@ -1 +0,0 @@
-../../.clinerules/workflows/release.md

.claude/hooks/claude-code-for-web-setup.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-# Only run in Claude Code remote environments
-if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
-  exit 0
-fi
-
-cd "$CLAUDE_PROJECT_DIR"
-
-echo "=== Claude Code for Web Setup ==="
-echo ""
-
-# Install latest gh CLI tool
-echo "Installing GitHub CLI..."
-GH_VERSION=$(curl -s https://api.github.com/repos/cli/cli/releases/latest | grep '"tag_name"' | cut -d'"' -f4 | sed 's/^v//')
-curl -sL "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_amd64.tar.gz" -o /tmp/gh.tar.gz
-tar -xzf /tmp/gh.tar.gz -C /tmp
-sudo mv "/tmp/gh_${GH_VERSION}_linux_amd64/bin/gh" /usr/local/bin/gh
-rm -rf /tmp/gh.tar.gz /tmp/gh_${GH_VERSION}_linux_amd64
-echo "Installed gh version: $(gh --version | head -1)"
-echo ""
-
-# Check if GITHUB_TOKEN is set and configure gh
-if [ -n "${GITHUB_TOKEN:-}" ]; then
-  echo "GITHUB_TOKEN is configured - gh CLI is ready to use"
-  echo ""
-  echo "You can use gh commands directly, for example:"
-  echo "  gh issue list --repo cline/cline --limit 5"
-  echo "  gh pr list --repo cline/cline --state open"
-  echo "  gh issue view 123 --repo cline/cline"
-  echo ""
-else
-  echo "GITHUB_TOKEN is not set - gh CLI will have limited functionality"
-  echo ""
-  echo "To enable full GitHub API access:"
-  echo "1. Create a Fine-grained Personal Access Token at https://github.com/settings/tokens?type=beta"
-  echo "2. Add it as GITHUB_TOKEN in your Claude Code environment settings"
-  echo ""
-fi
-
-# Install project dependencies
-echo "Installing dependencies..."
-npm run install:all
-
-# Generate gRPC/protobuf types (required for TypeScript)
-echo "Generating proto types..."
-npm run protos
-
-echo ""
-echo "Session setup complete!"

.claude/settings.json

@@ -1,14 +0,0 @@
-{
-	"hooks": {
-		"SessionStart": [
-			{
-				"hooks": [
-					{
-						"type": "command",
-						"command": "$CLAUDE_PROJECT_DIR/.claude/hooks/claude-code-for-web-setup.sh"
-					}
-				]
-			}
-		]
-	}
-}

.clinerules/workflows/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/workflows/release.md

@@ -1,232 +0,0 @@
-# Release
-
-Prepare and publish a release from the open changeset PR.
-
-## Overview
-
-This workflow helps you:
-1. Find and checkout the open changeset PR
-2. Clean up the changelog (fix version format, wordsmith entries)
-3. Push changes back to the PR branch
-4. Merge with proper commit message format
-5. Tag and push the release (after verifying the commit)
-6. Trigger the publish workflow
-7. Update GitHub release notes
-8. Provide final summary with Slack announcement
-
-## Step 1: Find the Changeset PR
-
-Look for the open changeset PR:
-
-```bash
-gh pr list --search "Changeset version bump" --state open --json number,title,headRefName,url
-```
-
-If no PR is found, inform the user there's no changeset PR ready. They may need to:
-- Merge PRs with changesets to main first
-- Manually trigger the Changeset Converter workflow at: https://github.com/cline/cline/actions/workflows/changeset-converter.yml
-
-## Step 2: Gather PR Information
-
-Get the PR details:
-
-```bash
-PR_NUMBER=<number from step 1>
-gh pr view $PR_NUMBER --json body,files,headRefName
-```
-
-Checkout the PR branch:
-
-```bash
-git fetch origin changeset-release/main
-git checkout changeset-release/main
-```
-
-If the branch has diverged from remote, reset to the remote version:
-
-```bash
-git reset --hard origin/changeset-release/main
-```
-
-## Step 3: Analyze the Changes
-
-Read the current CHANGELOG.md to see what the automation generated:
-
-```bash
-head -50 CHANGELOG.md
-```
-
-Get the version from package.json:
-
-```bash
-cat package.json | grep '"version"'
-```
-
-**Present to the user:**
-- The version number that will be released
-- The raw changelog entries from the changeset PR
-- Whether this is a patch, minor, or major release
-
-## Step 4: Clean Up the Changelog
-
-The changelog needs these fixes:
-
-1. **Add brackets to version number**: Change `## 3.44.1` to `## [3.44.1]`
-
-2. **No category headers**: Don't use `### Added`, `### Fixed`, etc. Just a flat list of bullet points.
-
-3. **Order entries from most important to least important**:
-   - Lead with major new features or significant fixes users care about
-   - End with minor fixes or internal changes
-
-4. **Write user-friendly descriptions**:
-   - This is for end users, not developers—explain what changed in plain language
-   - Remove commit hashes from the beginning of lines (the automation adds these)
-   - Look at the actual commit diffs (`git show <hash>`) and PRs to understand what changed
-   - Write colorful descriptions that explain the value and impact, not just technical details
-   - Consolidate related changes into single entries when appropriate
-
-**Ask the user** to review the proposed changelog changes before applying them. Show them:
-- Current (raw) changelog section
-- Proposed (cleaned) changelog section
-
-Once approved, apply the changes to CHANGELOG.md.
-
-## Step 5: Commit and Push Changes
-
-After making changelog edits:
-
-```bash
-git add CHANGELOG.md
-git commit -m "Clean up changelog formatting"
-git push origin changeset-release/main
-```
-
-## Step 6: Merge the PR
-
-**Ask the user to confirm** they're ready to merge.
-
-Merge the PR with the proper commit message format:
-
-```bash
-VERSION=<version from package.json>
-gh pr merge $PR_NUMBER --squash --subject "v${VERSION} Release Notes" --body ""
-```
-
-**If merge is blocked by branch protection:**
-- Users with admin privileges can add the `--admin` flag to bypass
-- Users without admin privileges need to get the PR approved through normal review first before merging
-
-## Step 7: Tag the Release
-
-After the merge completes, checkout main and pull:
-
-```bash
-git checkout main
-git pull origin main
-```
-
-**IMPORTANT: Verify the latest commit is the release commit before tagging:**
-
-```bash
-git log -1 --oneline
-```
-
-Confirm the commit message matches `v{VERSION} Release Notes` (e.g., `v3.44.1 Release Notes`). Do NOT blindly tag HEAD without verification.
-
-Once verified, tag and push:
-
-```bash
-VERSION=<version>
-git tag v${VERSION}
-git push origin v${VERSION}
-```
-
-## Step 8: Trigger Publish Workflow
-
-**Copy the tag to clipboard** so the user can easily paste it into the GitHub Actions workflow:
-
-```bash
-echo -n "v{VERSION}" | pbcopy
-```
-
-**Tell the user to trigger the publish workflow:**
-1. Go to: https://github.com/cline/cline/actions/workflows/publish.yml
-2. Select **"release"** for release-type
-3. Paste **`v{VERSION}`** as the tag (already in clipboard)
-
-**Wait for the user** to confirm the publish workflow has completed before proceeding.
-
-## Step 9: Update GitHub Release Notes
-
-Once the user confirms the publish workflow is done, fetch the auto-generated release content:
-
-```bash
-VERSION=<version>
-gh release view v${VERSION} --json body --jq '.body'
-```
-
-The auto-generated release has:
-- `## What's Changed` - PR list (we'll replace this with our changelog)
-- `## New Contributors` - First-time contributors (keep this if present)
-- `**Full Changelog**` - Comparison link (keep this)
-
-Build the new release body:
-1. Start with `## What's Changed` header
-2. Add our changelog content (from CHANGELOG.md for this version)
-3. Keep the `## New Contributors` section if it exists
-4. Keep the `**Full Changelog**` link
-
-Update the release:
-
-```bash
-gh release edit v${VERSION} --notes "<new body content>"
-```
-
-Verify the release was updated:
-
-```bash
-gh release view v${VERSION}
-```
-
-## Step 10: Final Summary
-
-**Copy a Slack announcement message to clipboard** (include the full changelog, not just highlights):
-
-```bash
-echo "VS Code v{VERSION} Released
-
-- Changelog entry 1
-- Changelog entry 2
-- Changelog entry 3" | pbcopy
-```
-
-**Present a final summary:**
-- Version released: v{VERSION}
-- PR merged: #{PR_NUMBER}
-- Tag pushed: v{VERSION}
-- Release: https://github.com/cline/cline/releases/tag/v{VERSION}
-- Slack message copied to clipboard
-
-**Final reminder:**
-Post the Slack message to announce the release
-
-## Handling Edge Cases
-
-### No changesets found
-If the changeset PR body shows no changes, inform the user they need to merge PRs with changesets first.
-
-### Merge conflicts
-If there are conflicts on the changeset branch, help the user resolve them:
-```bash
-git fetch origin main
-git rebase origin/main
-# resolve conflicts
-git push origin changeset-release/main --force-with-lease
-```
-
-### User wants to add more changes
-If the user wants to include additional PRs before releasing:
-1. Ask them to merge those PRs to main first
-2. The changeset automation will update the PR automatically
-3. Re-run this workflow after the PR is updated

.github/CODEOWNERS

@@ -1,4 +1,4 @@
 /docs/
 /.github/   @saoudrizwan @garoth @sjf
 /README.md  @saoudrizwan @nickbaumann98
-/src/core/storage/ @celestial-vault @abeatrix
+/src/core/storage/ @celestial-vault

.github/workflows/claude-issue-triage.yml

@@ -1,173 +0,0 @@
-name: Claude Issue Triage
-
-on:
-  issues:
-    types: [opened]
-  # Manual trigger for backfilling existing issues. Run from terminal:
-  #   gh workflow run claude-issue-triage.yml -f issue_number=1234
-  # Or batch process:
-  #   gh issue list --state open --limit 10 --json number --jq '.[].number' | while read num; do
-  #     gh workflow run claude-issue-triage.yml -f issue_number=$num
-  #     sleep 60
-  #   done
-  workflow_dispatch:
-    inputs:
-      issue_number:
-        description: 'Issue number to triage'
-        required: true
-        type: string
-
-jobs:
-  claude-issue-triage:
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 120
-    # SECURITY: These permissions are intentionally restrictive.
-    # - contents: read  -> Claude can read the codebase but CANNOT write/push any code
-    # - issues: write   -> Claude can comment and add labels (the only write access needed)
-    # - pull-requests: read -> Claude can view PR context but CANNOT create PRs
-    # This ensures that even if a malicious user attempts prompt injection via issue content,
-    # Claude cannot modify repository code, create branches, or open PRs.
-    permissions:
-      contents: read
-      issues: write
-      pull-requests: read
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Run Issue Response & Triage
-        id: triage
-        uses: anthropics/claude-code-action@v1
-        with:
-          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          allowed_non_write_users: "*"
-          # Allow all tools - security is enforced by GitHub permissions above (contents: read, issues: write)
-          claude_args: --model claude-opus-4-5-20251101 --allowedTools "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch"
-          prompt: |
-            You're a GitHub issue first responder for the open source Cline repository.
-
-            **Issue:** #${{ github.event.issue.number || inputs.issue_number }}
-            **Title:** ${{ github.event.issue.title || 'See issue details below' }}
-            **Author:** @${{ github.event.issue.user.login || 'See issue details below' }}
-
-            ## Your job
-
-            Investigate this issue thoroughly, then post a single helpful comment that helps the user and gives maintainers the context they need.
-
-            ## Investigation
-
-            Start by reading the full issue:
-            gh issue view ${{ github.event.issue.number || inputs.issue_number }}
-
-            ### Search for duplicates and related issues
-
-            Search thoroughly for existing issues that match this one:
-            gh issue list --search "<keywords from the issue>" --state all --limit 30
-            gh issue list --search "<error messages>" --state all --limit 20
-            gh issue list --search "<affected feature/component>" --state all --limit 20
-
-            For each relevant issue you find, read it including its comments:
-            gh issue view <number> --comments
-
-            You're looking for:
-            - **Duplicates**: Issues describing the same problem. Link to them and explain why you think they're duplicates. If closed, check how they were resolved - the solution might apply here.
-            - **Related issues**: Similar problems or context that could help. Pull useful information from their comments (workarounds others found, debugging steps that helped, maintainer explanations). Link to them and explain the connection.
-
-            If there are closed issues with solutions, surface those solutions prominently - this might immediately solve the user's problem.
-
-            ### Analyze recent changes (ALWAYS DO THIS)
-
-            Many issues are regressions from recent releases. **Always** check what changed recently:
-            gh release list --limit 10
-            gh pr list --state merged --limit 50 --json number,title,mergedAt,author,body
-
-            Look for PRs merged in the last few weeks that might correlate with the issue. If you find a likely connection:
-            gh pr view <number>
-            gh pr diff <number>
-            git log --since="1 month ago" --oneline -- <relevant paths>
-            git show <commit>
-
-            **Always include your findings in your comment:**
-            - If you find a regression, call it out explicitly: which PR/commit likely caused it, who authored it, what changed, and suggest a fix direction if you can see one.
-            - If you don't find anything related, still mention it: "I analyzed recent PRs and releases but didn't find any changes that seem related to this issue."
-
-            ### Search the codebase
-
-            Find the relevant code:
-            - Use grep/find to locate code related to the issue
-            - Key areas: `src/api/` (providers/models), `src/core/prompts/` (tools/prompts), platform-specific code for VS Code vs JetBrains
-
-            ### Find documentation
-
-            Cline docs are at **https://docs.cline.bot/** and built with Mintlify from the `docs/` directory.
-
-            The URL structure maps directly to the file structure:
-            - `docs/getting-started/selecting-your-model.mdx` → https://docs.cline.bot/getting-started/selecting-your-model
-            - `docs/troubleshooting.mdx` → https://docs.cline.bot/troubleshooting
-            - Headings become anchors: `## Which Model` → `#which-model`
-
-            Search the `docs/` directory to find relevant documentation, then construct URLs to link users to:
-            ```bash
-            ls docs/
-            grep -r "keyword" docs/ --include="*.mdx" -l
-            ```
-
-            ### Identify subject matter experts
-
-            For issues that clearly need engineering attention:
-            git log --since="6 months ago" --format="%an" -- <relevant paths> | sort | uniq -c | sort -rn | head -5
-
-            Cross-reference with GitHub usernames. Include in your response (@mention, do NOT assign):
-
-            | SME | Reason |
-            |-----|--------|
-            | @username1 | Authored PR #X which modified this area |
-            | @username2 | Primary contributor to affected file |
-
-            ## Weak model detection
-
-            Many issues are caused by users running small or non-frontier models that don't tool-call reliably. Signs include:
-            - Model failing to use tools correctly
-            - Nonsensical or malformed responses
-            - User is running a small/local model or older model version
-
-            If this looks like a weak model issue, kindly suggest they try reproducing with Claude Sonnet and report back if it persists. Link to https://docs.cline.bot/getting-started/selecting-your-model if helpful. Still label and triage normally.
-
-            ## Your comment
-
-            Write a single comment as a helpful community member. Be conversational, not robotic. Include what's relevant:
-
-            - **Helpful response** - Answer their question, suggest a fix, provide a workaround. If you found solutions in related closed issues, surface those prominently.
-            - **Duplicates and related issues** - Link to any you found and explain why they're duplicates/related. Summarize useful context from their comments.
-            - **Regression analysis** - If this looks like a regression, explain what change likely caused it, link to the PR/commit, and tag the author.
-            - **Clarifying questions** - If you need more info, ask specific questions. Don't ask for things already provided.
-            - **SME table** - Include the table above if this needs engineering attention. Don't tag people for questions with obvious answers or weak-model issues.
-            - **Context for maintainers** - Relevant code paths, what you found. Keep it concise.
-            - **Docs links** - If there's relevant documentation, link to it naturally in your response as a recommendation (e.g., "For more details, check out [the Ollama setup guide](url)"). Do NOT add a "Sources" section at the end - integrate doc links into your response where they're helpful.
-            - **Possible Duplicates section** - ALWAYS include a "Possible Duplicates" section at the end of your comment listing issues that might be duplicates so maintainers can quickly close if appropriate. If none found, say "No obvious duplicates found."
-
-            ## Labels
-            First, retrieve all available labels and read their descriptions to understand what each is for:
-            gh label list --json name,description --limit 100
-
-            Then apply the appropriate labels based on your analysis. Only use labels from the list above—do not create new labels.
-            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "label1,label2"
-
-            If your regression analysis found a likely culprit (a recent PR/commit that probably caused this issue), add the "Regression" label:
-            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "Regression"
-
-            IMPORTANT: After posting your comment, add the "Bot Responded" label to indicate this issue has received an automated response:
-            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "Bot Responded"
-
-            ## Remember
-
-            - **This is a one-time automated response** - you will NOT see their reply or respond again. Never say things like "I can help you", "let me know", "once I have that info", or "I can give you more targeted help" - you won't be there to follow up. If you ask clarifying questions, frame them for the maintainers who will follow up, e.g., "If you can share X, that would help the maintainers diagnose this."
-            - Don't be formulaic. Respond to what the issue actually needs.
-            - Surface solutions from past issues - often the fastest path to helping.
-            - Connecting regressions to specific changes is extremely valuable.
-            - Link issues with #number so they're clickable.

.github/workflows/publish.yml

@@ -36,8 +36,6 @@ jobs:
             - uses: actions/checkout@v4
               with:
                   ref: ${{ github.event.inputs.tag }}
-                  fetch-depth: 0
-                  fetch-tags: true
 
             - name: Setup Node.js
               uses: actions/setup-node@v4
@@ -118,31 +116,22 @@ jobs:
                     echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   fi
 
-            - name: Get Previous Tag
-              id: prev_tag
-              run: |
-                  CURRENT_TAG="${{ steps.validate_tag.outputs.tag }}"
-                  PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
-                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
-
-            - name: Get Changelog Entry
-              id: changelog
-              run: |
-                  # Get content between first ## [ and second ## [
-                  CONTENT=$(awk '/^## \[/{if(found) exit; found=1; next} found{print}' CHANGELOG.md)
-                  echo "content<<EOF" >> $GITHUB_OUTPUT
-                  echo "$CONTENT" >> $GITHUB_OUTPUT
-                  echo "EOF" >> $GITHUB_OUTPUT
+            # - name: Get Changelog Entry
+            #   id: changelog
+            #   uses: mindsers/changelog-reader-action@v2
+            #   with:
+            #       # This expects a standard Keep a Changelog format
+            #       # "latest" means it will read whichever is the most recent version
+            #       # set in "## [1.2.3] - 2025-01-28" style
+            #       version: latest
 
             - name: Create GitHub Release
               uses: softprops/action-gh-release@v1
               with:
                   tag_name: ${{ steps.validate_tag.outputs.tag }}
                   files: "*.vsix"
-                  body: |
-                      ${{ steps.changelog.outputs.content }}
-
-                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.validate_tag.outputs.tag }}
+                  # body: ${{ steps.changelog.outputs.content }}
+                  generate_release_notes: true
                   prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.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 }}"

.gitignore

@@ -14,7 +14,6 @@ pnpm-lock.yaml
 .clineignore
 .venv
 .actrc
-CLAUDE.local.md
 
 webview-ui/src/**/*.js
 webview-ui/src/**/*.js.map

.vscode/launch.json

@@ -12,10 +12,7 @@
 			"args": [
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"--disable-workspace-trust",
-				"--disable-extension",
-				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
-				"--disable-extension",
-				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"--disable-extensions", // Avoid conflicts with installed extensions
 				"${workspaceFolder}"
 			],
 			"outFiles": [
@@ -36,10 +33,7 @@
 			"args": [
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"--disable-workspace-trust",
-				"--disable-extension",
-				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
-				"--disable-extension",
-				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"--disable-extensions", // Avoid conflicts with installed extensions
 				"${workspaceFolder}"
 			],
 			"outFiles": [
@@ -60,10 +54,7 @@
 			"args": [
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"--disable-workspace-trust",
-				"--disable-extension",
-				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
-				"--disable-extension",
-				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"--disable-extensions", // Avoid conflicts with installed extensions
 				"${workspaceFolder}"
 			],
 			"outFiles": [
@@ -86,10 +77,7 @@
 				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
 				"--sync=off",
-				"--disable-extension",
-				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
-				"--disable-extension",
-				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"--disable-extensions", // Avoid conflicts with installed extensions
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],

.vscode/settings.json

@@ -27,7 +27,5 @@
 		"source.removeUnused.biome": "always",
 		"source.removeUnusedImports": "always",
 		"source.organizeImports.biome": "always"
-	},
-	// Disable auto-forwarding ports to prevent Simple Browser from opening the Vite dev server
-	"remote.autoForwardPorts": false
+	}
 }

.vscodeignore

@@ -40,6 +40,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/**

.worktreeinclude

@@ -1 +0,0 @@
-.gitignore

CHANGELOG.md

@@ -1,134 +1,5 @@
 # Changelog
 
-## [3.46.1]
-
-### Fixed
-
-- Remove GLM 4.6 from free models
-
-
-## [3.46.0]
-
-### Added
-
-- Added GLM 4.7 model
-- Enhanced background terminal execution with command tracking, log file output, zombie process prevention (10-minute timeout), and clickable log paths in UI
-- Apply Patch tool for GPT-5+ models (replacing current diff edit tools)
-
-### Fixed
-
-- Duplicate error messages during streaming for Diff Edit tool when Parallel Tool Calling is not enabled
-- Banner carousel styling and dismiss functionality
-- Typos in Gemini system prompt overrides
-- Model picker favorites ordering, star toggle, and keyboard navigation for OpenRouter and Vercel AI Gateway providers
-- Fetch remote config values from the cache
-
-### Refactored
-
-- Anthropic handler to use metadata for reasoning support
-- Bedrock provider to use metadata for reasoning support
-
-## [3.45.1]
-
-- Fixed MCP settings race condition where toggling auto-approve or changing timeout settings would cause the UI to flash and revert
-
-## [3.45.0]
-
-- Added Gemini 3 Flash Preview model
-
-## [3.44.2]
-
-- Polished the model picker UI with checkmarks for selected models, tooltips on Plan/Act tabs, and consistent arrow pointers across all popup modals
-- Improved WhatsNew modal responsiveness and cleaned up redundant UI elements
-- Fixed GLM models outputting garbled text in thinking tags—reasoning is now properly disabled for these models
-
-## [3.44.1]
-
-- Fixed a critical bug where local MCP servers stopped connecting after v3.42.0—all user-configured stdio-based MCP servers should now work again
-- Fixed remotely configured API keys not being extracted correctly for enterprise users
-- Added support for dynamic tool instructions that adapt based on runtime context, laying groundwork for future context-aware features
-
-## [3.44.0]
-
-## Added
-
-- Updating minor version to show a proper banner for the release
-
-## [3.43.1]
-
-### Patch Changes
-
-- Fix GLM-4.6 Model reference id
-
-## [3.43.0]
-
-### Added
-
-- GLM-4.6
-- kat-coder-pro
-- Add parsing of env variable patterns to the mcpconfig.json
-
-### Fixed
-
-- TLS Proxy support issues for VSCode
-- Add supportsReasoning flag to OpenAI reasoning models
-- Fix thinking not available for some models in the OpenAI provider
-- Fix invalid signature field issues when switching between Gemini and Anthropic providers
-- Extract OpenRouter model filtering into reusable utility and use it in different model pickers
-- Fix a11y for auto approve checkbox
-- Improve ModelPickerModal provider list layout
-
-### Refactored
-
-- Migrate WhatsNewModal to new shared dialogue component
-
-## [3.42.0]
-
-### Added
-
-- Expose `getAvailableSlashCommands` rpc endpoint to UI clients
-- Made slash command menu and context menu accessible and screenreader-friendly
-- Made expanding/collapsing UI components accessible
-
-### Fixed
-
-- Devstral OpenRouter model ID and routing issues
-- Incorrect pricing display for Devstral model in the extension
-
-## [3.41.0]
-
-### Added
-
-- OpenAI GPT-5.2
-- Devstral-2512 (formerly stealth model "Microwave")
-- Improvements to chat modal model picker
-- Amazon Nova 2 Lite
-- DeepSeek 3.2 to native tool calling allow list
-- Responses API support for Codex models in OpenAI provider (requires native tool calling)
-- Xmas Special Santa Cline
-- Welcome screen UI enhancements
-
-### Fixed
-
-- Initial checkpoint commit now non-blocking for improved responsiveness in large repositories
-- Gemini Vertex models erroring when thinking parameters are not supported
-- Restrictive file permissions for secrets.json
-- Ollama streaming requests not aborting when task is cancelled
-
-### Refactored
-
-- OpenAI provider to centralize temperature configuration and include missing GPT-5 model settings
-- OpenAI native handler to use metadata for model capabilities
-- Vertex provider to use metadata for model capabilities
-
-## [3.40.2]
-
-- Fix logout on network errors during token refresh (e.g., opening laptop while offline)
-
-## [3.40.1]
-
-- Fix cost calculation display for Anthropic API requests
-
 ## [3.40.0]
 
 - Fix highlighted text flashing when task header is collapsed

cli/README.md

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

cli/architecture.md

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

cli/cmd/cline-host/main.go

@@ -14,9 +14,8 @@ import (
 )
 
 var (
-	port       int
-	verbose    bool
-	workspaces []string
+	port    int
+	verbose bool
 )
 
 func main() {
@@ -29,7 +28,6 @@ func main() {
 
 	rootCmd.Flags().IntVarP(&port, "port", "p", 51052, "port to listen on")
 	rootCmd.Flags().BoolVarP(&verbose, "verbose", "v", false, "verbose logging")
-	rootCmd.Flags().StringSliceVar(&workspaces, "workspace", nil, "workspace paths")
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
@@ -41,7 +39,7 @@ func runServer(cmd *cobra.Command, args []string) error {
 	ctx := cmd.Context()
 
 	// Create gRPC hostbridge service
-	service := hostbridge.NewGrpcServer(port, verbose, workspaces)
+	service := hostbridge.NewGrpcServer(port, verbose)
 
 	// Handle graceful shutdown
 	ctx, cancel := context.WithCancel(ctx)

cli/cmd/cline/main.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"slices"
 	"strings"
 
 	"github.com/charmbracelet/huh"
@@ -26,13 +25,12 @@ var (
 	outputFormat string
 
 	// Task creation flags (for root command)
-	images     []string
-	files      []string
-	mode       string
-	settings   []string
-	yolo       bool
-	oneshot    bool
-	workspaces []string
+	images   []string
+	files    []string
+	mode     string
+	settings []string
+	yolo     bool
+	oneshot  bool
 )
 
 func main() {
@@ -72,23 +70,12 @@ see the manual page: man cline`,
 
 			var instanceAddress string
 
-			// Validate workspace paths exist
-			if err := common.ValidateDirsExist(workspaces); err != nil {
-				return err
-			}
-
-			// Build the full workspace list: cwd first, then additional workspaces
-			allWorkspaces, err := buildWorkspaceList(workspaces)
-			if err != nil {
-				return fmt.Errorf("failed to build workspace list: %w", err)
-			}
-
 			// If --address flag not provided, start instance BEFORE getting prompt
 			if !cmd.Flags().Changed("address") {
 				if global.Config.Verbose {
 					fmt.Println("Starting new Cline instance...")
 				}
-				instance, err := global.Clients.StartNewInstance(ctx, allWorkspaces...)
+				instance, err := global.Clients.StartNewInstance(ctx)
 				if err != nil {
 					return fmt.Errorf("failed to start new instance: %w", err)
 				}
@@ -144,8 +131,8 @@ see the manual page: man cline`,
 
 			// If no prompt from args or stdin, show interactive input
 			if prompt == "" {
-				// Pass the mode flag and workspaces to banner so it shows correct info
-				prompt, err = promptForInitialTask(ctx, instanceAddress, mode, allWorkspaces)
+				// Pass the mode flag to banner so it shows correct mode
+				prompt, err = promptForInitialTask(ctx, instanceAddress, mode)
 				if err != nil {
 					// Check if user cancelled - exit cleanly without error
 					if err == huh.ErrUserAborted {
@@ -165,14 +152,13 @@ see the manual page: man cline`,
 			}
 
 			return cli.CreateAndFollowTask(ctx, prompt, cli.TaskOptions{
-				Images:     images,
-				Files:      files,
-				Mode:       mode,
-				Settings:   settings,
-				Yolo:       yolo,
-				Address:    instanceAddress,
-				Verbose:    verbose,
-				Workspaces: allWorkspaces,
+				Images:   images,
+				Files:    files,
+				Mode:     mode,
+				Settings: settings,
+				Yolo:     yolo,
+				Address:  instanceAddress,
+				Verbose:  verbose,
 			})
 		},
 	}
@@ -189,7 +175,6 @@ see the manual page: man cline`,
 	rootCmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
 	rootCmd.Flags().BoolVar(&yolo, "no-interactive", false, "enable yolo mode (non-interactive)")
 	rootCmd.Flags().BoolVarP(&oneshot, "oneshot", "o", false, "full autonomous mode")
-	rootCmd.Flags().StringSliceVarP(&workspaces, "workspace", "w", nil, "additional workspace paths (can be specified multiple times)")
 
 	rootCmd.AddCommand(cli.NewTaskCommand())
 	rootCmd.AddCommand(cli.NewInstanceCommand())
@@ -204,9 +189,9 @@ see the manual page: man cline`,
 	}
 }
 
-func promptForInitialTask(ctx context.Context, instanceAddress, modeFlag string, workspaces []string) (string, error) {
+func promptForInitialTask(ctx context.Context, instanceAddress, modeFlag string) (string, error) {
 	// Show session banner before the initial input
-	showSessionBanner(ctx, instanceAddress, modeFlag, workspaces)
+	showSessionBanner(ctx, instanceAddress, modeFlag)
 
 	var prompt string
 
@@ -248,7 +233,7 @@ func promptForInitialTask(ctx context.Context, instanceAddress, modeFlag string,
 }
 
 // showSessionBanner displays session info before initial prompt
-func showSessionBanner(ctx context.Context, instanceAddress, modeFlag string, workspaces []string) {
+func showSessionBanner(ctx context.Context, instanceAddress, modeFlag string) {
 	bannerInfo := display.BannerInfo{
 		Version: global.CliVersion,
 		Mode:    modeFlag, // Use the mode from command flag, not state
@@ -259,7 +244,10 @@ func showSessionBanner(ctx context.Context, instanceAddress, modeFlag string, wo
 		bannerInfo.Mode = "plan"
 	}
 
-	bannerInfo.Workdirs = workspaces
+	// Get current working directory (this is what Cline will use)
+	if cwd, err := os.Getwd(); err == nil {
+		bannerInfo.Workdir = cwd
+	}
 
 	// Get provider/model using auth functions (same logic as auth menu)
 	manager, err := cli.NewTaskManagerForAddress(ctx, instanceAddress)
@@ -357,37 +345,4 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 	}
 
 	return content.String(), nil
-}
-
-// buildWorkspaceList builds the full workspace list with cwd as the first entry
-func buildWorkspaceList(additionalWorkspaces []string) ([]string, error) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get current working directory: %w", err)
-	}
-
-	// Start with cwd
-	workspaces := []string{cwd}
-
-	// Add additional workspaces, avoiding duplicates
-	for _, ws := range additionalWorkspaces {
-		// Normalize the path
-		absPath, err := common.AbsPath(ws)
-		if err != nil {
-			return nil, fmt.Errorf("failed to resolve workspace path %s: %w", ws, err)
-		}
-
-		// Skip if it's the same as cwd
-		if absPath == cwd {
-			continue
-		}
-
-		// Check for duplicates
-		isDuplicate := slices.Contains(workspaces, absPath)
-		if !isDuplicate {
-			workspaces = append(workspaces, absPath)
-		}
-	}
-
-	return workspaces, nil
-}
+}

cli/go.mod

@@ -1,6 +1,6 @@
 module github.com/cline/cli
 
-go 1.24.0
+go 1.23.0
 
 require (
 	github.com/atotto/clipboard v0.1.4

cli/man/cline.1.md

@@ -70,10 +70,6 @@ When using the instant task syntax **cline "prompt"** the following options are
 
 :   Starting mode. Options: **act** (default), **plan**
 
-**-w**, **\--workspace** *path*
-
-:   Additional workspace paths. Can be specified multiple times to include multiple directories. The current working directory is always included as the first workspace. Example: cline -w /path/to/other/project "refactor shared code"
-
 # GLOBAL OPTIONS
 
 These options apply to all subcommands:
@@ -82,28 +78,6 @@ These options apply to all subcommands:
 
 :   Output format. Options: **rich** (default), **json**, **plain**
 
-    When you use **-F json**, the CLI prints each client message as JSON.
-
-    Each message is a **ClineMessage** object.
-
-    Required fields:
-
-    - **type**: "ask" or "say"
-    - **text**: message text
-    - **ts**: Unix epoch timestamp in milliseconds
-
-    Optional fields (omitted when empty):
-
-    - **reasoning**: reasoning text
-    - **say**: say subtype (present when type is "say")
-    - **ask**: ask subtype (present when type is "ask")
-    - **partial**: streaming flag
-    - **images**: list of image URIs
-    - **files**: list of file paths
-    - **lastCheckpointHash**: git checkpoint hash
-    - **isCheckpointCheckedOut**: checkpoint checkout flag
-    - **isOperationOutsideWorkspace**: workspace safety flag
-
 **-h**, **\--help**
 
 :   Display help information for the command.

cli/pkg/cli/auth/providers_list.go

@@ -47,7 +47,7 @@ func GetProviderConfigurations(ctx context.Context, manager *task.Manager) (*Pro
 	}
 
 	// Parse state_json as map[string]interface{}
-	var stateData map[string]any
+	var stateData map[string]interface{}
 	if err := json.Unmarshal([]byte(stateJSON), &stateData); err != nil {
 		return nil, fmt.Errorf("failed to parse state JSON: %w", err)
 	}
@@ -57,7 +57,7 @@ func GetProviderConfigurations(ctx context.Context, manager *task.Manager) (*Pro
 	}
 
 	// Extract apiConfiguration object from state
-	apiConfig, ok := stateData["apiConfiguration"].(map[string]any)
+	apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
 	if !ok {
 		if global.Config.Verbose {
 			fmt.Println("[DEBUG] No apiConfiguration found in state")
@@ -128,11 +128,11 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 		modelID := getProviderSpecificModelID(r.apiConfig, "plan", provider)
 
 		// Determine if credentials exist
-		hasCreds := checkCredentialsExists(r.apiConfig, provider)
+		hasCreds := checkAPIKeyExists(r.apiConfig, provider)
 
 		// Determine readiness: OCA uses auth state presence; others need creds and model
 		if provider == cline.ApiProvider_OCA {
-			state, _ := GetLatestOCAState(context.Background(), 2*time.Second)
+			state, _ := GetLatestOCAState(context.Background(), 2 *time.Second)
 			if state == nil || state.User == nil {
 				continue
 			}
@@ -156,7 +156,7 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 			Mode:      "Ready",
 			Provider:  provider,
 			ModelID:   modelID,
-			HasAPIKey: checkCredentialsExists(r.apiConfig, provider),
+			HasAPIKey: checkAPIKeyExists(r.apiConfig, provider),
 			BaseURL:   baseURL,
 		})
 		seenProviders[provider] = true
@@ -192,7 +192,7 @@ func extractProviderFromState(stateData map[string]interface{}, mode string) *Pr
 	modelID := getProviderSpecificModelID(stateData, mode, provider)
 
 	// Check if API key exists
-	hasCredentials := checkCredentialsExists(stateData, provider)
+	hasAPIKey := checkAPIKeyExists(stateData, provider)
 
 	// Get base URL for Ollama (can be shown publicly)
 	baseURL := ""
@@ -206,7 +206,7 @@ func extractProviderFromState(stateData map[string]interface{}, mode string) *Pr
 		Mode:      capitalizeMode(mode),
 		Provider:  provider,
 		ModelID:   modelID,
-		HasAPIKey: hasCredentials,
+		HasAPIKey: hasAPIKey,
 		BaseURL:   baseURL,
 	}
 }
@@ -215,7 +215,7 @@ func extractProviderFromState(stateData map[string]interface{}, mode string) *Pr
 // 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 {
 	case "anthropic":
@@ -303,23 +303,19 @@ func getProviderSpecificModelID(stateData map[string]interface{}, mode string, p
 	return modelID
 }
 
-// checkCredentialsExists checks if API key field exists in state (never retrieve actual key)
-func checkCredentialsExists(stateData map[string]interface{}, provider cline.ApiProvider) bool {
+// checkAPIKeyExists checks if API key field exists in state (never retrieve actual key)
+func checkAPIKeyExists(stateData map[string]interface{}, provider cline.ApiProvider) bool {
 	// Get field mapping from centralized function
 	fields, err := GetProviderFields(provider)
 	if err != nil {
 		return false
 	}
 
-	// Check if the key exists and is not empty
-	if value, ok := stateData[fields.APIKeyField]; ok {
-		if str, ok := value.(string); ok && str != "" {
-			return true
-		}
-	}
+	keyField := fields.APIKeyField
 
-	if value, ok := stateData[fields.UseProfileField]; ok {
-		if hasProfileField, ok := value.(bool); ok && hasProfileField {
+	// Check if the key exists and is not empty
+	if value, ok := stateData[keyField]; ok {
+		if str, ok := value.(string); ok && str != "" {
 			return true
 		}
 	}
@@ -442,13 +438,13 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 	stateJSON := state.StateJson
 
 	// Parse state_json as map[string]interface{}
-	var stateData map[string]any
+	var stateData map[string]interface{}
 	if err := json.Unmarshal([]byte(stateJSON), &stateData); err != nil {
 		return nil, fmt.Errorf("failed to parse state JSON: %w", err)
 	}
 
 	// Extract apiConfiguration object from state
-	apiConfig, ok := stateData["apiConfiguration"].(map[string]any)
+	apiConfig, ok := stateData["apiConfiguration"].(map[string]interface{})
 	if !ok {
 		verboseLog("[DEBUG] No apiConfiguration found in state")
 		verboseLog("[DEBUG] Available keys in stateData: %v", getMapKeys(stateData))
@@ -473,38 +469,36 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 
 	// Check each BYO provider for API key presence
 	providersToCheck := []struct {
-		provider  cline.ApiProvider
-		keyFields []string
+		provider cline.ApiProvider
+		keyField string
 	}{
-		{cline.ApiProvider_ANTHROPIC, []string{"apiKey"}},
-		{cline.ApiProvider_OPENAI, []string{"openAiApiKey"}},
-		{cline.ApiProvider_OPENAI_NATIVE, []string{"openAiNativeApiKey"}},
-		{cline.ApiProvider_OPENROUTER, []string{"openRouterApiKey"}},
-		{cline.ApiProvider_XAI, []string{"xaiApiKey"}},
-		{cline.ApiProvider_BEDROCK, []string{"awsAccessKey", "awsUseProfile"}},
-		{cline.ApiProvider_GEMINI, []string{"geminiApiKey"}},
-		{cline.ApiProvider_OLLAMA, []string{"ollamaBaseUrl"}}, // Ollama uses baseUrl instead of API key
-		{cline.ApiProvider_CEREBRAS, []string{"cerebrasApiKey"}},
-		{cline.ApiProvider_HICAP, []string{"hicapApiKey"}},
-		{cline.ApiProvider_NOUSRESEARCH, []string{"nousResearchApiKey"}},
+		{cline.ApiProvider_ANTHROPIC, "apiKey"},
+		{cline.ApiProvider_OPENAI, "openAiApiKey"},
+		{cline.ApiProvider_OPENAI_NATIVE, "openAiNativeApiKey"},
+		{cline.ApiProvider_OPENROUTER, "openRouterApiKey"},
+		{cline.ApiProvider_XAI, "xaiApiKey"},
+		{cline.ApiProvider_BEDROCK, "awsAccessKey"},
+		{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 {
-		verboseLog("[DEBUG] Checking for %s key: %s", GetProviderDisplayName(providerCheck.provider), providerCheck.keyFields)
-		for _, keyField := range providerCheck.keyFields {
-			if value, ok := apiConfig[keyField]; ok {
-				verboseLog("[DEBUG]   Found key, value type: %T, is empty: %v", value, value == "")
-				if str, ok := value.(string); ok && str != "" {
-					configuredProviders = append(configuredProviders, providerCheck.provider)
-					verboseLog("[DEBUG]   ✓ Provider %s is configured", GetProviderDisplayName(providerCheck.provider))
-					break
-				}
-			} else {
-				verboseLog("[DEBUG]   Key %s not found", keyField)
+		verboseLog("[DEBUG] Checking for %s key: %s", GetProviderDisplayName(providerCheck.provider), providerCheck.keyField)
+		if value, ok := apiConfig[providerCheck.keyField]; ok {
+			verboseLog("[DEBUG]   Found key, value type: %T, is empty: %v", value, value == "")
+			if str, ok := value.(string); ok && str != "" {
+				configuredProviders = append(configuredProviders, providerCheck.provider)
+				verboseLog("[DEBUG]   ✓ Provider %s is configured", GetProviderDisplayName(providerCheck.provider))
 			}
+		} else {
+			verboseLog("[DEBUG]   Key %s not found", providerCheck.keyField)
 		}
 	}
 
+
 	verboseLog("[DEBUG] Total configured providers: %d", len(configuredProviders))
 	for _, p := range configuredProviders {
 		verboseLog("[DEBUG]   - %s", GetProviderDisplayName(p))

cli/pkg/cli/auth/update_api_configurations.go

@@ -54,7 +54,6 @@ type ProviderFields struct {
 	// Provider-specific additional model ID fields
 	PlanModeProviderSpecificModelIDField string // e.g., "planModeOpenRouterModelId"
 	ActModeProviderSpecificModelIDField  string // e.g., "actModeOpenRouterModelId"
-	UseProfileField                      string // e.g., "awsUseProfile" (for bedrock) (optional, empty if not applicable)
 }
 
 // GetProviderFields returns the field mapping for a given provider
@@ -97,7 +96,6 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 
 	case cline.ApiProvider_BEDROCK:
 		return ProviderFields{
-			UseProfileField:                      "awsUseProfile",
 			APIKeyField:                          "awsAccessKey",
 			PlanModeModelIDField:                 "planModeApiModelId",
 			ActModeModelIDField:                  "actModeApiModelId",

cli/pkg/cli/auth/wizard_byo_bedrock.go

@@ -15,23 +15,23 @@ import (
 // BedrockConfig holds all AWS Bedrock-specific configuration fields
 type BedrockConfig struct {
 	// Profile authentication fields
-	UseProfile bool   // Always true for successful config
-	Profile    string // Optional: AWS profile name (empty = default)
-	Region     string // Required: AWS region
-	Endpoint   string // Optional: Custom VPC endpoint URL
-
+	UseProfile              bool   // Always true for successful config
+	Profile                 string // Optional: AWS profile name (empty = default)
+	Region                  string // Required: AWS region
+	Endpoint                string // Optional: Custom VPC endpoint URL
+	
 	// Optional features
-	UseCrossRegionInference bool // Optional: Enable cross-region inference
-	UseGlobalInference      bool // Optional: Use global inference endpoint
-	UsePromptCache          bool // Optional: Enable prompt caching
-
+	UseCrossRegionInference bool   // Optional: Enable cross-region inference
+	UseGlobalInference      bool   // Optional: Use global inference endpoint
+	UsePromptCache          bool   // Optional: Enable prompt caching
+	
 	// Authentication method (always "profile")
-	Authentication string // Always set to "profile"
-
+	Authentication          string // Always set to "profile"
+	
 	// Legacy fields (no longer used in profile-only flow)
-	AccessKey    string // No longer used
-	SecretKey    string // No longer used
-	SessionToken string // No longer used
+	AccessKey               string // No longer used
+	SecretKey               string // No longer used
+	SessionToken            string // No longer used
 }
 
 // PromptForBedrockConfig displays a profile-first authentication form for Bedrock configuration
@@ -130,12 +130,7 @@ func ApplyBedrockConfig(ctx context.Context, manager *task.Manager, config *Bedr
 	// Build the API configuration with all Bedrock fields
 	apiConfig := &cline.ModelsApiConfiguration{}
 
-	// Set provider for both Plan and Act modes
-	bedrockProvider := cline.ApiProvider_BEDROCK
-	apiConfig.PlanModeApiProvider = &bedrockProvider
-	apiConfig.ActModeApiProvider = &bedrockProvider
-
-	// Set model ID field - this is the primary model ID used by Cline Core
+	// Set model ID fields
 	apiConfig.PlanModeApiModelId = proto.String(modelID)
 	apiConfig.ActModeApiModelId = proto.String(modelID)
 	apiConfig.PlanModeAwsBedrockCustomModelBaseId = proto.String(modelID)
@@ -171,8 +166,6 @@ func ApplyBedrockConfig(ctx context.Context, manager *task.Manager, config *Bedr
 
 	// Build field mask including all fields we're setting (excluding access keys)
 	fieldPaths := []string{
-		"planModeApiProvider",
-		"actModeApiProvider",
 		"planModeApiModelId",
 		"actModeApiModelId",
 		"planModeAwsBedrockCustomModelBaseId",

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
 

cli/pkg/cli/display/banner.go

@@ -1,19 +1,22 @@
 package display
 
 import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
-	"github.com/cline/cli/pkg/common"
 )
 
 // BannerInfo contains information to display in the session banner
 type BannerInfo struct {
-	Version  string
-	Provider string
-	ModelID  string
-	Workdirs []string // workspace directories
-	Mode     string
+	Version    string
+	Provider   string
+	ModelID    string
+	Workdir    string
+	Mode       string
 }
 
 // RenderSessionBanner renders a nice banner showing version, model, and workspace info
@@ -78,22 +81,131 @@ func RenderSessionBanner(info BannerInfo) string {
 
 	// Model line - dim gray
 	if info.Provider != "" && info.ModelID != "" {
-		lines = append(lines, dimStyle.Render(info.Provider+"/"+common.ShortenPath(info.ModelID, 30)))
+		lines = append(lines, dimStyle.Render(info.Provider+"/"+shortenPath(info.ModelID, 30)))
 	}
 
-	for _, wd := range info.Workdirs {
-		lines = append(lines, dimStyle.Render(common.ShortenPath(wd, 45)))
-	}
-
-	// Checkpoint warning for multi-root workspaces
-	if len(info.Workdirs) > 1 {
-		warningStyle := lipgloss.NewStyle().
-			Foreground(lipgloss.Color("3")). // Yellow warning color
-			Italic(true)
-		lines = append(lines, "")
-		lines = append(lines, warningStyle.Render("⚠ Checkpoints disabled for multi-root workspaces"))
+	// Workspace line - dim gray
+	if info.Workdir != "" {
+		lines = append(lines, dimStyle.Render(shortenPath(info.Workdir, 45)))
 	}
 
 	content := lipgloss.JoinVertical(lipgloss.Left, lines...)
 	return boxStyle.Render(content)
 }
+
+// shortenPath shortens a filesystem path to fit within maxLen
+func shortenPath(path string, maxLen int) string {
+	// Try to replace home directory with ~ (cross-platform)
+	if homeDir, err := os.UserHomeDir(); err == nil {
+		if strings.HasPrefix(path, homeDir) {
+			shortened := "~" + path[len(homeDir):]
+			// Always use ~ version if we can
+			path = shortened
+		}
+	}
+
+	if len(path) <= maxLen {
+		return path
+	}
+
+	// If still too long, show last few path components
+	if len(path) > maxLen {
+		parts := strings.Split(path, string(filepath.Separator))
+		if len(parts) > 2 {
+			// Show last 2-3 components
+			lastParts := parts[len(parts)-2:]
+			shortened := "..." + string(filepath.Separator) + strings.Join(lastParts, string(filepath.Separator))
+			if len(shortened) <= maxLen {
+				return shortened
+			}
+		}
+	}
+
+	// Last resort: truncate with ellipsis
+	if len(path) > maxLen {
+		return "..." + path[len(path)-maxLen+3:]
+	}
+
+	return path
+}
+
+// ExtractBannerInfoFromState extracts banner info from state JSON
+func ExtractBannerInfoFromState(stateJSON, version string) (BannerInfo, error) {
+	var state map[string]interface{}
+	if err := json.Unmarshal([]byte(stateJSON), &state); err != nil {
+		return BannerInfo{}, fmt.Errorf("failed to parse state JSON: %w", err)
+	}
+
+	info := BannerInfo{
+		Version: version,
+	}
+
+	// Extract mode
+	if mode, ok := state["mode"].(string); ok {
+		info.Mode = mode
+	}
+
+	// Extract workspace roots
+	if workspaceRoots, ok := state["workspaceRoots"].([]interface{}); ok && len(workspaceRoots) > 0 {
+		if root, ok := workspaceRoots[0].(map[string]interface{}); ok {
+			if path, ok := root["path"].(string); ok {
+				info.Workdir = path
+			}
+		}
+	}
+
+	// Extract API configuration to get provider/model
+	if apiConfig, ok := state["apiConfiguration"].(map[string]interface{}); ok {
+		// Try common keys for provider and model (both camelCase and lowercase variants)
+		providerKeys := []string{"apiProvider", "api_provider"}
+		modelKeys := []string{"apiModelId", "api_model_id"}
+
+		// Try to extract provider
+		for _, key := range providerKeys {
+			if provider, ok := apiConfig[key].(string); ok && provider != "" {
+				info.Provider = provider
+				break
+			}
+		}
+
+		// Try to extract model ID
+		for _, key := range modelKeys {
+			if modelID, ok := apiConfig[key].(string); ok && modelID != "" {
+				info.ModelID = shortenModelID(modelID)
+				break
+			}
+		}
+	}
+
+	return info, nil
+}
+
+// shortenModelID shortens long model IDs for display
+func shortenModelID(modelID string) string {
+	// Remove date suffixes only if they're at the end (e.g., -20241022)
+	// Check if the model ID ends with -YYYYMMDD pattern
+	if len(modelID) > 9 {
+		suffix := modelID[len(modelID)-9:] // Last 9 chars: -20241022
+		if suffix[0] == '-' &&
+		   (strings.HasPrefix(suffix[1:], "202") || strings.HasPrefix(suffix[1:], "201")) {
+			// Verify all remaining chars are digits
+			allDigits := true
+			for _, c := range suffix[1:] {
+				if c < '0' || c > '9' {
+					allDigits = false
+					break
+				}
+			}
+			if allDigits {
+				return modelID[:len(modelID)-9]
+			}
+		}
+	}
+
+	// If still too long, show first 40 chars
+	if len(modelID) > 40 {
+		return modelID[:37] + "..."
+	}
+
+	return modelID
+}

cli/pkg/cli/display/tool_renderer.go

@@ -161,14 +161,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 +207,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), string(types.ToolTypeFileDeleted):
+		// No preview for read/fetch operations
 		return ""
 
 	default:
@@ -251,8 +243,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

@@ -224,11 +224,6 @@ func (p *ToolResultParser) ParseWebFetch(content, url string) string {
 	return ""
 }
 
-// ParseWebSearch formats webSearch tool results
-func (p *ToolResultParser) ParseWebSearch(content, query string) string {
-	return ""
-}
-
 // detectLanguage returns syntax highlighting language based on file extension
 func (p *ToolResultParser) detectLanguage(ext string) string {
 	langMap := map[string]string{
@@ -294,8 +289,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

@@ -36,7 +36,7 @@ func (c *ClineClients) Initialize(ctx context.Context) error {
 }
 
 // StartNewInstance starts a new Cline instance and waits for cline-core to self-register
-func (c *ClineClients) StartNewInstance(ctx context.Context, workspaces ...string) (*common.CoreInstanceInfo, error) {
+func (c *ClineClients) StartNewInstance(ctx context.Context) (*common.CoreInstanceInfo, error) {
 	// Find available ports
 	corePort, hostPort, err := common.FindAvailablePortPair()
 	if err != nil {
@@ -48,7 +48,7 @@ func (c *ClineClients) StartNewInstance(ctx context.Context, workspaces ...strin
 	}
 
 	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, workspaces)
+	hostCmd, err := startClineHost(hostPort, corePort)
 	if err != nil {
 		return nil, fmt.Errorf("failed to start cline-host: %w", err)
 	}
@@ -120,7 +120,7 @@ func (c *ClineClients) StartNewInstance(ctx context.Context, workspaces ...strin
 }
 
 // StartNewInstanceAtPort starts a new Cline instance at the specified port and waits for self-registration
-func (c *ClineClients) StartNewInstanceAtPort(ctx context.Context, corePort int, workspaces ...string) (*common.CoreInstanceInfo, error) {
+func (c *ClineClients) StartNewInstanceAtPort(ctx context.Context, corePort int) (*common.CoreInstanceInfo, error) {
 	// Find available host port (core port + 1000)
 	hostPort := corePort + 1000
 	coreAddress := fmt.Sprintf("localhost:%d", corePort)
@@ -135,7 +135,7 @@ func (c *ClineClients) StartNewInstanceAtPort(ctx context.Context, corePort int,
 	}
 
 	// Start cline-host first
-	hostCmd, err := startClineHost(hostPort, workspaces)
+	hostCmd, err := startClineHost(hostPort, corePort)
 	if err != nil {
 		return nil, fmt.Errorf("failed to start cline-host: %w", err)
 	}
@@ -242,7 +242,7 @@ func (c *ClineClients) EnsureInstanceAtAddress(ctx context.Context, address stri
 	return fmt.Errorf("cannot start remote instance at %s", normalized)
 }
 
-func startClineHost(hostPort int, workspaces []string) (*exec.Cmd, error) {
+func startClineHost(hostPort, corePort int) (*exec.Cmd, error) {
 	if Config.Verbose {
 		fmt.Printf("Starting cline-host on port %d\n", hostPort)
 	}
@@ -255,18 +255,10 @@ func startClineHost(hostPort int, workspaces []string) (*exec.Cmd, error) {
 	binDir := path.Dir(execPath)
 	clineHostPath := path.Join(binDir, "cline-host")
 
-	// Build command arguments
-	args := []string{
-		"--verbose",
-		"--port", fmt.Sprintf("%d", hostPort),
-	}
-
-	for _, ws := range workspaces {
-		args = append(args, "--workspace", ws)
-	}
-
 	// Start the cline-host process
-	cmd := exec.Command(clineHostPath, args...)
+	cmd := exec.Command(clineHostPath,
+		"--verbose",
+		"--port", fmt.Sprintf("%d", hostPort))
 
 	// Create logs directory in ~/.cline/logs
 	logsDir := path.Join(Config.ConfigPath, "logs")
@@ -341,7 +333,7 @@ func KillInstanceByAddress(ctx context.Context, registry *ClientRegistry, addres
 	if Config.Verbose {
 		fmt.Printf("Waiting for instance to clean up registry entry...\n")
 	}
-	for range 5 {
+	for i := 0; i < 5; i++ {
 		time.Sleep(1 * time.Second)
 		if !registry.HasInstanceAtAddress(address) {
 			if Config.Verbose {
@@ -416,15 +408,15 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 		// This handles the case where we're running from cli/bin/cline
 		devClineCorePath := path.Join(binDir, "..", "..", "dist-standalone", "cline-core.js")
 		devInstallDir := path.Join(binDir, "..", "..", "dist-standalone")
-
+		
 		if Config.Verbose {
 			fmt.Printf("Primary location not found, trying development path: %s\n", devClineCorePath)
 		}
-
+		
 		if _, err := os.Stat(devClineCorePath); os.IsNotExist(err) {
 			return nil, fmt.Errorf("cline-core.js not found at '%s' or '%s'. Please ensure you're running from the correct location or reinstall with 'npm install -g cline'", clineCorePath, devClineCorePath)
 		}
-
+		
 		finalClineCorePath = devClineCorePath
 		finalInstallDir = devInstallDir
 		if Config.Verbose {
@@ -483,16 +475,15 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 	realNodeModules := path.Join(finalInstallDir, "node_modules")
 	fakeNodeModules := path.Join(finalInstallDir, "fake_node_modules")
 	nodePath := fmt.Sprintf("%s%c%s", realNodeModules, os.PathListSeparator, fakeNodeModules)
-
+	
 	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
-
+	
 	if Config.Verbose {
 		fmt.Printf("NODE_PATH set to: %s\n", nodePath)
 	}

cli/pkg/cli/output/input_model.go

@@ -9,13 +9,12 @@ import (
 	"github.com/charmbracelet/bubbles/textarea"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
-	"github.com/cline/cli/pkg/cli/slash"
 )
 
 // InputType represents the type of input being collected
 type InputType int
 
-const INPUT_WIDTH = 46
+const INPUT_WIDTH = 46 
 
 const (
 	InputTypeMessage InputType = iota
@@ -25,11 +24,11 @@ const (
 
 // InputSubmitMsg is sent when the user submits input
 type InputSubmitMsg struct {
-	Value         string
-	InputType     InputType
-	Approved      bool // For approval type
-	NeedsFeedback bool // For approval type
-	NoAskAgain    bool // For approval type - indicates "don't ask again" was selected
+	Value          string
+	InputType      InputType
+	Approved       bool // For approval type
+	NeedsFeedback  bool // For approval type
+	NoAskAgain     bool // For approval type - indicates "don't ask again" was selected
 }
 
 // InputCancelMsg is sent when the user cancels input (Ctrl+C)
@@ -37,8 +36,8 @@ type InputCancelMsg struct{}
 
 // ChangeInputTypeMsg changes the current input type
 type ChangeInputTypeMsg struct {
-	InputType   InputType
-	Title       string
+	InputType InputType
+	Title     string
 	Placeholder string
 }
 
@@ -58,7 +57,7 @@ type InputModel struct {
 	placeholder string
 	currentMode string // "plan" or "act"
 	width       int
-	lastHeight  int // Track height for cleanup on submit
+	lastHeight  int    // Track height for cleanup on submit
 
 	// For approval type
 	approvalOptions []string
@@ -67,9 +66,6 @@ type InputModel struct {
 
 	// Styles (huh-inspired theme)
 	styles fieldStyles
-
-	// Slash command autocomplete dropdown
-	completion CompletionModel
 }
 
 // fieldStyles holds the styling for the input field
@@ -119,17 +115,12 @@ func newFieldStyles() fieldStyles {
 
 // NewInputModel creates a new input model
 func NewInputModel(inputType InputType, title, placeholder, currentMode string) InputModel {
-	return NewInputModelWithRegistry(inputType, title, placeholder, currentMode, nil)
-}
-
-// NewInputModelWithRegistry creates a new input model with slash command autocomplete support
-func NewInputModelWithRegistry(inputType InputType, title, placeholder, currentMode string, registry *slash.Registry) InputModel {
 	ta := textarea.New()
 	ta.Placeholder = placeholder
 	ta.Focus()
 	ta.CharLimit = 0
 	ta.ShowLineNumbers = false
-	ta.Prompt = "" // Remove prompt prefix (this is what adds the inner border!)
+	ta.Prompt = ""  // Remove prompt prefix (this is what adds the inner border!)
 	ta.SetHeight(5)
 	// Don't set width here - let WindowSizeMsg handle it
 	ta.SetWidth(INPUT_WIDTH)
@@ -147,11 +138,11 @@ func NewInputModelWithRegistry(inputType InputType, title, placeholder, currentM
 		cursorColor = lipgloss.Color("39") // Blue for act
 	}
 
-	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()  // No cursor line highlighting
-	ta.FocusedStyle.EndOfBuffer = lipgloss.NewStyle() // No end-of-buffer styling
+	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()   // No cursor line highlighting
+	ta.FocusedStyle.EndOfBuffer = lipgloss.NewStyle()  // No end-of-buffer styling
 	ta.FocusedStyle.Placeholder = styles.placeholder
 	ta.FocusedStyle.Text = styles.textArea
-	ta.FocusedStyle.Prompt = lipgloss.NewStyle() // No prompt styling
+	ta.FocusedStyle.Prompt = lipgloss.NewStyle()       // No prompt styling
 	ta.Cursor.Style = lipgloss.NewStyle().Foreground(cursorColor)
 	ta.Cursor.TextStyle = styles.textArea
 
@@ -163,7 +154,6 @@ func NewInputModelWithRegistry(inputType InputType, title, placeholder, currentM
 		currentMode: currentMode,
 		width:       0, // Will be set by first WindowSizeMsg
 		styles:      styles,
-		completion:  NewCompletionModel(registry),
 	}
 
 	// For approval type, set up options
@@ -227,6 +217,13 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	default:
+		// Forward all other messages to textarea (including blink ticks)
+		if !m.suspended && (m.inputType == InputTypeMessage || m.inputType == InputTypeFeedback) {
+			m.textarea, cmd = m.textarea.Update(msg)
+			return m, cmd
+		}
+
 	case tea.KeyMsg:
 		if m.suspended {
 			return m, nil
@@ -234,31 +231,6 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		// Handle keys for text input types (Message/Feedback)
 		if m.inputType == InputTypeMessage || m.inputType == InputTypeFeedback {
-			// When completion menu is visible, let it handle navigation keys first
-			if m.completion.Visible() {
-				// ctrl+c always cancels, even with dropdown open
-				if msg.String() == "ctrl+c" {
-					return m, func() tea.Msg { return InputCancelMsg{} }
-				}
-
-				var handled bool
-				m.completion, cmd, handled = m.completion.Update(msg)
-				if handled {
-					// Check if a completion was selected
-					if applied := m.completion.Apply(); applied != "" {
-						m.textarea.SetValue(applied)
-						m.textarea.CursorEnd()
-					}
-					return m, cmd
-				}
-
-				// Key not handled by completion - pass to textarea and update completion
-				m.textarea, cmd = m.textarea.Update(msg)
-				m.completion.CheckInput(m.textarea.Value())
-				return m, cmd
-			}
-
-			// Normal key handling when completion menu is NOT visible
 			switch msg.String() {
 			case "ctrl+c":
 				return m, func() tea.Msg { return InputCancelMsg{} }
@@ -267,11 +239,6 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				// Open external editor (like huh does)
 				return m, m.openEditor()
 
-			case "tab":
-				// Tab without dropdown visible - do nothing special
-				m.textarea, cmd = m.textarea.Update(msg)
-				return m, cmd
-
 			case "enter":
 				// Intercept enter for submit (textarea handles alt+enter and ctrl+j for newlines)
 				return m.handleSubmit()
@@ -282,9 +249,8 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				return m, cmd
 			}
 
-			// Pass all other keys to textarea, then check for slash completion
+			// Pass all other keys to textarea (including alt+enter, ctrl+j for newlines)
 			m.textarea, cmd = m.textarea.Update(msg)
-			m.completion.CheckInput(m.textarea.Value())
 			return m, cmd
 		}
 
@@ -310,13 +276,6 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				return m, nil
 			}
 		}
-
-	default:
-		// Forward all other messages to textarea (including blink ticks)
-		if !m.suspended && (m.inputType == InputTypeMessage || m.inputType == InputTypeFeedback) {
-			m.textarea, cmd = m.textarea.Update(msg)
-			return m, cmd
-		}
 	}
 
 	return m, nil
@@ -406,11 +365,6 @@ func (m *InputModel) View() string {
 	case InputTypeMessage, InputTypeFeedback:
 		parts = append(parts, m.textarea.View())
 
-		// Render completion dropdown if visible
-		if m.completion.Visible() {
-			parts = append(parts, m.completion.View())
-		}
-
 	case InputTypeApproval:
 		var options []string
 		for i, option := range m.approvalOptions {
@@ -457,7 +411,7 @@ func (m *InputModel) Clone() *InputModel {
 	ta.ShowLineNumbers = false
 	ta.Prompt = ""
 	ta.SetHeight(5)
-	ta.SetWidth(INPUT_WIDTH)
+	ta.SetWidth(INPUT_WIDTH) 
 	ta.Focus()
 
 	// Configure keybindings
@@ -492,7 +446,6 @@ func (m *InputModel) Clone() *InputModel {
 		selectedOption:  m.selectedOption,
 		pendingApproval: m.pendingApproval, // Preserve approval decision
 		styles:          m.styles,
-		completion:      NewCompletionModel(m.completion.registry), // Preserve registry, start fresh state
 	}
 
 	return clone
@@ -542,8 +495,3 @@ func (m *InputModel) openEditor() tea.Cmd {
 		return editorFinishedMsg{content: content, err: err}
 	})
 }
-
-// SetSlashRegistry sets the slash command registry for autocomplete
-func (m *InputModel) SetSlashRegistry(registry *slash.Registry) {
-	m.completion.SetRegistry(registry)
-}

cli/pkg/cli/output/slash_completion.go

@@ -1,265 +0,0 @@
-package output
-
-import (
-	"fmt"
-	"strings"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/cline/cli/pkg/cli/slash"
-)
-
-const maxVisibleCompletions = 7
-
-// completionStyles holds the styling for the completion dropdown
-type completionStyles struct {
-	menu            lipgloss.Style
-	selected        lipgloss.Style
-	normalName      lipgloss.Style
-	description     lipgloss.Style
-	scrollIndicator lipgloss.Style
-}
-
-// newCompletionStyles creates the default styles for the completion dropdown
-func newCompletionStyles() completionStyles {
-	return completionStyles{
-		menu: lipgloss.NewStyle().
-			Border(lipgloss.RoundedBorder()).
-			BorderForeground(lipgloss.Color("238")).
-			Padding(0, 1),
-		selected: lipgloss.NewStyle().
-			Background(lipgloss.Color("62")).
-			Foreground(lipgloss.Color("230")),
-		normalName: lipgloss.NewStyle().
-			Foreground(lipgloss.AdaptiveColor{Light: "235", Dark: "252"}),
-		description: lipgloss.NewStyle().
-			Foreground(lipgloss.Color("243")),
-		scrollIndicator: lipgloss.NewStyle().
-			Foreground(lipgloss.Color("243")),
-	}
-}
-
-// CompletionModel is a Bubbletea model for slash command autocomplete dropdown
-type CompletionModel struct {
-	registry *slash.Registry
-	visible  bool
-	matches  []slash.Command
-	index    int // selected item (0-based)
-	scroll   int // scroll offset for long lists
-	styles   completionStyles
-
-	// pendingApply holds the command to apply after selection
-	pendingApply string
-}
-
-// NewCompletionModel creates a new completion model with the given registry
-func NewCompletionModel(registry *slash.Registry) CompletionModel {
-	return CompletionModel{
-		registry: registry,
-		styles:   newCompletionStyles(),
-	}
-}
-
-// SetRegistry sets the slash command registry
-func (m *CompletionModel) SetRegistry(registry *slash.Registry) {
-	m.registry = registry
-}
-
-// Visible returns whether the completion dropdown is currently visible
-func (m CompletionModel) Visible() bool {
-	return m.visible
-}
-
-// Update handles key messages for the completion dropdown.
-// Returns the updated model, any commands, and whether the key was handled.
-// If handled is true, the parent should NOT pass the key to the textarea.
-func (m CompletionModel) Update(msg tea.Msg) (CompletionModel, tea.Cmd, bool) {
-	if !m.visible {
-		return m, nil, false
-	}
-
-	keyMsg, ok := msg.(tea.KeyMsg)
-	if !ok {
-		return m, nil, false
-	}
-
-	switch keyMsg.String() {
-	case "up":
-		m.navigateUp()
-		return m, nil, true
-
-	case "down":
-		m.navigateDown()
-		return m, nil, true
-
-	case "tab", "enter":
-		// Select the current completion
-		if len(m.matches) > 0 {
-			selected := m.matches[m.index]
-			m.pendingApply = "/" + selected.Name + " "
-		}
-		m.Hide()
-		return m, nil, true
-
-	case "esc":
-		m.Hide()
-		return m, nil, true
-	}
-
-	// Key not handled by completion - let parent process it
-	return m, nil, false
-}
-
-// CheckInput updates the completion state based on the current input value.
-// Call this after each input change to show/hide/update the dropdown.
-func (m *CompletionModel) CheckInput(value string) {
-	if m.registry == nil {
-		return
-	}
-
-	// Only activate if input starts with "/" (first character requirement)
-	if !strings.HasPrefix(value, "/") {
-		m.Hide()
-		return
-	}
-
-	// Extract the command being typed (everything after "/" until space/newline)
-	rest := value[1:] // Everything after the "/"
-
-	// If there's whitespace, the command is complete - hide dropdown
-	if idx := strings.IndexAny(rest, " \n\t"); idx != -1 {
-		m.Hide()
-		return
-	}
-
-	// Update matches based on prefix
-	m.updateMatches(rest)
-	m.visible = len(m.matches) > 0
-}
-
-// Apply returns the command string to insert (if any) and clears the pending state.
-// The parent should call this after Update returns handled=true for tab/enter.
-func (m *CompletionModel) Apply() string {
-	result := m.pendingApply
-	m.pendingApply = ""
-	return result
-}
-
-// Hide hides the completion dropdown and resets state
-func (m *CompletionModel) Hide() {
-	m.visible = false
-	m.matches = nil
-	m.index = 0
-	m.scroll = 0
-}
-
-// View renders the completion dropdown
-func (m CompletionModel) View() string {
-	if !m.visible || len(m.matches) == 0 {
-		return ""
-	}
-
-	var lines []string
-
-	// Calculate visible range
-	endIdx := min(m.scroll+maxVisibleCompletions, len(m.matches))
-
-	// Show scroll indicator if there are items above
-	if m.scroll > 0 {
-		lines = append(lines, m.styles.scrollIndicator.Render("  ↑ more"))
-	}
-
-	// Find the longest command name for alignment
-	maxNameLen := 0
-	for _, cmd := range m.matches {
-		nameLen := len(cmd.Name) + 1 // +1 for the "/"
-		if nameLen > maxNameLen {
-			maxNameLen = nameLen
-		}
-	}
-	// Cap at reasonable width
-	if maxNameLen > 15 {
-		maxNameLen = 15
-	}
-
-	// Render visible items
-	for i := m.scroll; i < endIdx; i++ {
-		cmd := m.matches[i]
-		name := "/" + cmd.Name
-		desc := cmd.Description
-
-		// Truncate description if too long
-		maxDescLen := 35
-		if len(desc) > maxDescLen {
-			desc = desc[:maxDescLen-3] + "..."
-		}
-
-		// Pad name for alignment
-		paddedName := fmt.Sprintf("%-*s", maxNameLen, name)
-
-		if i == m.index {
-			// Selected item - highlight the entire line
-			line := fmt.Sprintf("> %s  %s", paddedName, desc)
-			lines = append(lines, m.styles.selected.Render(line))
-		} else {
-			// Normal item
-			line := fmt.Sprintf("  %s  %s", m.styles.normalName.Render(paddedName), m.styles.description.Render(desc))
-			lines = append(lines, line)
-		}
-	}
-
-	// Show scroll indicator if there are items below
-	if endIdx < len(m.matches) {
-		lines = append(lines, m.styles.scrollIndicator.Render("  ↓ more"))
-	}
-
-	return m.styles.menu.Render(strings.Join(lines, "\n"))
-}
-
-// updateMatches filters commands by prefix and updates the matches list
-func (m *CompletionModel) updateMatches(prefix string) {
-	if m.registry == nil {
-		m.matches = nil
-		return
-	}
-	m.matches = m.registry.GetMatching(prefix)
-	// Reset selection if out of bounds
-	if m.index >= len(m.matches) {
-		m.index = 0
-		m.scroll = 0
-	}
-	m.adjustScroll()
-}
-
-// navigateUp moves selection up in the dropdown
-func (m *CompletionModel) navigateUp() {
-	if len(m.matches) == 0 {
-		return
-	}
-	m.index--
-	if m.index < 0 {
-		m.index = len(m.matches) - 1
-	}
-	m.adjustScroll()
-}
-
-// navigateDown moves selection down in the dropdown
-func (m *CompletionModel) navigateDown() {
-	if len(m.matches) == 0 {
-		return
-	}
-	m.index++
-	if m.index >= len(m.matches) {
-		m.index = 0
-	}
-	m.adjustScroll()
-}
-
-// adjustScroll ensures the selected item is visible in the dropdown
-func (m *CompletionModel) adjustScroll() {
-	if m.index < m.scroll {
-		m.scroll = m.index
-	} else if m.index >= m.scroll+maxVisibleCompletions {
-		m.scroll = m.index - maxVisibleCompletions + 1
-	}
-}

cli/pkg/cli/slash/registry.go

@@ -1,125 +0,0 @@
-package slash
-
-import (
-	"context"
-	"strings"
-	"sync"
-
-	"github.com/cline/grpc-go/client"
-	"github.com/cline/grpc-go/cline"
-)
-
-// Command represents a slash command available for autocomplete
-type Command struct {
-	Name          string
-	Description   string
-	Section       string // "default", "custom", or "cli"
-	CLICompatible bool
-}
-
-// Registry holds available slash commands for autocomplete
-type Registry struct {
-	mu       sync.RWMutex
-	commands []Command
-}
-
-// CLI-local commands (handled by CLI, not sent to backend)
-var cliLocalCommands = []Command{
-	{Name: "plan", Description: "Switch to plan mode", Section: "cli", CLICompatible: true},
-	{Name: "act", Description: "Switch to act mode", Section: "cli", CLICompatible: true},
-	{Name: "cancel", Description: "Cancel the current task", Section: "cli", CLICompatible: true},
-	{Name: "exit", Description: "Exit follow mode", Section: "cli", CLICompatible: true},
-}
-
-// NewRegistry creates a new slash command registry
-func NewRegistry() *Registry {
-	return &Registry{
-		commands: make([]Command, 0),
-	}
-}
-
-// FetchFromBackend fetches available commands from cline-core backend
-func (r *Registry) FetchFromBackend(ctx context.Context, c *client.ClineClient) error {
-	resp, err := c.Slash.GetAvailableSlashCommands(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return err
-	}
-
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	// Start with CLI-local commands
-	r.commands = append([]Command{}, cliLocalCommands...)
-
-	// Add backend commands (only CLI-compatible ones)
-	for _, cmd := range resp.Commands {
-		if cmd.CliCompatible {
-			r.commands = append(r.commands, Command{
-				Name:          cmd.Name,
-				Description:   cmd.Description,
-				Section:       cmd.Section,
-				CLICompatible: cmd.CliCompatible,
-			})
-		}
-	}
-
-	return nil
-}
-
-// GetCommands returns all available commands
-func (r *Registry) GetCommands() []Command {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	// Return a copy to avoid race conditions
-	result := make([]Command, len(r.commands))
-	copy(result, r.commands)
-	return result
-}
-
-// GetMatching returns commands that start with the given prefix (case-insensitive)
-func (r *Registry) GetMatching(prefix string) []Command {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	prefix = strings.ToLower(prefix)
-	var matches []Command
-	for _, cmd := range r.commands {
-		if strings.HasPrefix(strings.ToLower(cmd.Name), prefix) {
-			matches = append(matches, cmd)
-		}
-	}
-	return matches
-}
-
-// IsValid checks if a command name is valid
-func (r *Registry) IsValid(name string) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	name = strings.ToLower(name)
-	for _, cmd := range r.commands {
-		if strings.ToLower(cmd.Name) == name {
-			return true
-		}
-	}
-	return false
-}
-
-// IsCLILocal checks if a command is handled locally by CLI (not sent to backend)
-func (r *Registry) IsCLILocal(name string) bool {
-	name = strings.ToLower(name)
-	for _, cmd := range cliLocalCommands {
-		if strings.ToLower(cmd.Name) == name {
-			return true
-		}
-	}
-	return false
-}
-
-// HasCommands returns true if the registry has any commands loaded
-func (r *Registry) HasCommands() bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	return len(r.commands) > 0
-}

cli/pkg/cli/task.go

@@ -20,14 +20,13 @@ import (
 
 // TaskOptions contains options for creating a task
 type TaskOptions struct {
-	Images     []string
-	Files      []string
-	Mode       string
-	Settings   []string
-	Yolo       bool
-	Address    string
-	Verbose    bool
-	Workspaces []string
+	Images   []string
+	Files    []string
+	Mode     string
+	Settings []string
+	Yolo     bool
+	Address  string
+	Verbose  bool
 }
 
 func NewTaskCommand() *cobra.Command {

cli/pkg/cli/task/input_handler.go

@@ -38,13 +38,13 @@ type InputHandler struct {
 // NewInputHandler creates a new input handler
 func NewInputHandler(manager *Manager, coordinator *StreamCoordinator, cancelFunc context.CancelFunc) *InputHandler {
 	return &InputHandler{
-		manager:     manager,
-		coordinator: coordinator,
-		cancelFunc:  cancelFunc,
-		isRunning:   false,
-		pollTicker:  time.NewTicker(500 * time.Millisecond),
-		resultChan:  make(chan output.InputSubmitMsg, 1),
-		cancelChan:  make(chan struct{}, 1),
+		manager:      manager,
+		coordinator:  coordinator,
+		cancelFunc:   cancelFunc,
+		isRunning:    false,
+		pollTicker:   time.NewTicker(500 * time.Millisecond),
+		resultChan:   make(chan output.InputSubmitMsg, 1),
+		cancelChan:   make(chan struct{}, 1),
 	}
 }
 
@@ -251,8 +251,7 @@ 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:
@@ -281,12 +280,11 @@ func determineAutoApprovalAction(msg *types.ClineMessage) (string, error) {
 func (ih *InputHandler) promptForInput(ctx context.Context) (string, bool, error) {
 	currentMode := ih.manager.GetCurrentMode()
 
-	model := output.NewInputModelWithRegistry(
+	model := output.NewInputModel(
 		output.InputTypeMessage,
 		"Cline is ready for your message...",
-		"/plan or /act to switch modes\nctrl+e to open editor\ntab to autocomplete commands",
+		"/plan or /act to switch modes\nctrl+e to open editor",
 		currentMode,
-		ih.manager.GetSlashRegistry(),
 	)
 
 	return ih.runInputProgram(ctx, model)
@@ -296,13 +294,12 @@ func (ih *InputHandler) promptForInput(ctx context.Context) (string, bool, error
 func (ih *InputHandler) promptForApproval(ctx context.Context, msg *types.ClineMessage) (bool, string, error) {
 	// Store the approval message for later use in determining auto-approval action
 	ih.approvalMessage = msg
-
-	model := output.NewInputModelWithRegistry(
+	
+	model := output.NewInputModel(
 		output.InputTypeApproval,
 		"Let Cline use this tool?",
 		"",
 		ih.manager.GetCurrentMode(),
-		ih.manager.GetSlashRegistry(), // Pass registry for feedback input after approval
 	)
 
 	message, shouldSend, err := ih.runInputProgram(ctx, model)
@@ -397,7 +394,7 @@ func (ih *InputHandler) runInputProgram(ctx context.Context, model output.InputM
 				// Need to collect feedback - will be handled by model state change
 				return "", false, nil
 			}
-
+			
 			// Check if NoAskAgain was selected
 			if result.NoAskAgain && result.Approved && ih.approvalMessage != nil {
 				// Determine which auto-approval action to enable
@@ -413,7 +410,7 @@ func (ih *InputHandler) runInputProgram(ctx context.Context, model output.InputM
 					}
 				}
 			}
-
+			
 			// Store approval state for when feedback comes back
 			ih.feedbackApproval = false
 			ih.feedbackApproved = result.Approved
@@ -443,7 +440,6 @@ func (w *inputProgramWrapper) Init() tea.Cmd {
 }
 
 func (w *inputProgramWrapper) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-
 	switch msg := msg.(type) {
 	case output.InputSubmitMsg:
 		// Handle input submission - clear the screen before quitting

cli/pkg/cli/task/manager.go

@@ -14,7 +14,6 @@ import (
 	"github.com/cline/cli/pkg/cli/display"
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/handlers"
-	"github.com/cline/cli/pkg/cli/slash"
 	"github.com/cline/cli/pkg/cli/types"
 	"github.com/cline/grpc-go/client"
 	"github.com/cline/grpc-go/cline"
@@ -37,7 +36,6 @@ type Manager struct {
 	systemRenderer   *display.SystemMessageRenderer
 	streamingDisplay *display.StreamingDisplay
 	handlerRegistry  *handlers.HandlerRegistry
-	slashRegistry    *slash.Registry
 	isStreamingMode  bool
 	isInteractive    bool
 	currentMode      string // "plan" or "act"
@@ -65,7 +63,6 @@ func NewManager(client *client.ClineClient) *Manager {
 		systemRenderer:   systemRenderer,
 		streamingDisplay: streamingDisplay,
 		handlerRegistry:  registry,
-		slashRegistry:    slash.NewRegistry(),
 		currentMode:      "plan", // Default mode
 	}
 }
@@ -79,10 +76,6 @@ func NewManagerForAddress(ctx context.Context, address string) (*Manager, error)
 
 	manager := NewManager(client)
 	manager.clientAddress = address
-
-	// Fetch slash commands from backend (non-blocking, errors are logged)
-	manager.fetchSlashCommands(ctx)
-
 	return manager, nil
 }
 
@@ -100,25 +93,9 @@ func NewManagerForDefault(ctx context.Context) (*Manager, error) {
 		manager.clientAddress = global.Clients.GetRegistry().GetDefaultInstance()
 	}
 
-	// Fetch slash commands from backend (non-blocking, errors are logged)
-	manager.fetchSlashCommands(ctx)
-
 	return manager, nil
 }
 
-// fetchSlashCommands fetches available slash commands from the backend
-// This is non-blocking and errors are logged but don't prevent manager creation
-func (m *Manager) fetchSlashCommands(ctx context.Context) {
-	if err := m.slashRegistry.FetchFromBackend(ctx, m.client); err != nil {
-		if global.Config.Verbose {
-			m.renderer.RenderDebug("Failed to fetch slash commands: %v", err)
-		}
-		// Non-fatal: CLI-local commands are still available
-	} else if global.Config.Verbose {
-		m.renderer.RenderDebug("Loaded %d slash commands", len(m.slashRegistry.GetCommands()))
-	}
-}
-
 // SwitchToInstance switches the manager to use a different Cline instance
 func (m *Manager) SwitchToInstance(ctx context.Context, address string) error {
 	m.mu.Lock()
@@ -1007,33 +984,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) {
@@ -1057,14 +1007,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) {
@@ -1286,11 +1228,6 @@ func (m *Manager) GetCurrentMode() string {
 	return m.currentMode
 }
 
-// GetSlashRegistry returns the slash command registry
-func (m *Manager) GetSlashRegistry() *slash.Registry {
-	return m.slashRegistry
-}
-
 // extractModeFromState extracts the current mode from state JSON
 func (m *Manager) extractModeFromState(stateJson string) string {
 	var rawState map[string]interface{}

cli/pkg/cli/task/settings_parser.go

@@ -290,12 +290,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":

cli/pkg/cli/types/history.go

@@ -3,16 +3,15 @@ package types
 // HistoryItem represents a task history item from taskHistory.json
 // This struct matches the JSON format stored on disk
 type HistoryItem struct {
-	Id             string   `json:"id"`
-	Ulid           string   `json:"ulid,omitempty"`
-	Ts             int64    `json:"ts"`
-	Task           string   `json:"task"`
-	TokensIn       int32    `json:"tokensIn"`
-	TokensOut      int32    `json:"tokensOut"`
-	CacheWrites    int32    `json:"cacheWrites,omitempty"`
-	CacheReads     int32    `json:"cacheReads,omitempty"`
-	TotalCost      float64  `json:"totalCost"`
-	Size           int64    `json:"size,omitempty"`
-	IsFavorited    bool     `json:"isFavorited,omitempty"`
-	WorkspacePaths []string `json:"workspacePaths,omitempty"`
+	Id          string  `json:"id"`
+	Ulid        string  `json:"ulid,omitempty"`
+	Ts          int64   `json:"ts"`
+	Task        string  `json:"task"`
+	TokensIn    int32   `json:"tokensIn"`
+	TokensOut   int32   `json:"tokensOut"`
+	CacheWrites int32   `json:"cacheWrites,omitempty"`
+	CacheReads  int32   `json:"cacheReads,omitempty"`
+	TotalCost   float64 `json:"totalCost"`
+	Size        int64   `json:"size,omitempty"`
+	IsFavorited bool    `json:"isFavorited,omitempty"`
 }

cli/pkg/cli/types/messages.go

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

cli/pkg/common/utils.go

@@ -4,9 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"os"
 	"os/exec"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -185,72 +183,3 @@ DEBUGGING STEPS:
 For additional help, visit: https://github.com/cline/cline/issues
 `, maxRetries, lastErr, GetNodeVersion())
 }
-
-// validateDirsExist validates that all workspace paths exist on the filesystem
-func ValidateDirsExist(paths []string) error {
-	for _, p := range paths {
-		info, err := os.Stat(p)
-		if err != nil {
-			if os.IsNotExist(err) {
-				return fmt.Errorf("path does not exist: %s", p)
-			}
-			return fmt.Errorf("failed to access path %s: %w", p, err)
-		}
-		if !info.IsDir() {
-			return fmt.Errorf("path is not a directory: %s", p)
-		}
-	}
-	return nil
-}
-
-// absPath returns the absolute path, resolving symlinks
-func AbsPath(path string) (string, error) {
-	// First get absolute path
-	abs, err := filepath.Abs(path)
-	if err != nil {
-		return "", err
-	}
-	// Then resolve any symlinks
-	resolved, err := filepath.EvalSymlinks(abs)
-	if err != nil {
-		// If symlink resolution fails, return the absolute path
-		return abs, nil
-	}
-	return resolved, nil
-}
-
-// shortenPath shortens a filesystem path to fit within maxLen
-func ShortenPath(path string, maxLen int) string {
-	// Try to replace home directory with ~ (cross-platform)
-	if homeDir, err := os.UserHomeDir(); err == nil {
-		if strings.HasPrefix(path, homeDir) {
-			shortened := "~" + path[len(homeDir):]
-			// Always use ~ version if we can
-			path = shortened
-		}
-	}
-
-	if len(path) <= maxLen {
-		return path
-	}
-
-	// If still too long, show last few path components
-	if len(path) > maxLen {
-		parts := strings.Split(path, string(filepath.Separator))
-		if len(parts) > 2 {
-			// Show last 2-3 components
-			lastParts := parts[len(parts)-2:]
-			shortened := "..." + string(filepath.Separator) + strings.Join(lastParts, string(filepath.Separator))
-			if len(shortened) <= maxLen {
-				return shortened
-			}
-		}
-	}
-
-	// Last resort: truncate with ellipsis
-	if len(path) > maxLen {
-		return "..." + path[len(path)-maxLen+3:]
-	}
-
-	return path
-}

cli/pkg/hostbridge/grpc_server.go

@@ -16,17 +16,15 @@ import (
 type GrpcServer struct {
 	port       int
 	verbose    bool
-	workspaces []string
 	server     *grpc.Server
 	shutdownCh chan struct{}
 }
 
 // NewGrpcServer creates a new GrpcServer
-func NewGrpcServer(port int, verbose bool, workspaces []string) *GrpcServer {
+func NewGrpcServer(port int, verbose bool) *GrpcServer {
 	return &GrpcServer{
 		port:       port,
 		verbose:    verbose,
-		workspaces: workspaces,
 		shutdownCh: make(chan struct{}),
 	}
 }
@@ -52,7 +50,7 @@ func (s *GrpcServer) Start(ctx context.Context) error {
 	grpc_health_v1.RegisterHealthServer(s.server, healthServer)
 
 	// Register services
-	workspaceService := NewSimpleWorkspaceService(s.verbose, s.workspaces)
+	workspaceService := NewSimpleWorkspaceService(s.verbose)
 	host.RegisterWorkspaceServiceServer(s.server, workspaceService)
 
 	windowService := NewWindowService(s.verbose)

cli/pkg/hostbridge/simple_workspace.go

@@ -12,15 +12,13 @@ import (
 // SimpleWorkspaceService implements a basic workspace service without complex dependencies
 type SimpleWorkspaceService struct {
 	host.UnimplementedWorkspaceServiceServer
-	verbose    bool
-	workspaces []string
+	verbose bool
 }
 
 // NewSimpleWorkspaceService creates a new SimpleWorkspaceService
-func NewSimpleWorkspaceService(verbose bool, workspaces []string) *SimpleWorkspaceService {
+func NewSimpleWorkspaceService(verbose bool) *SimpleWorkspaceService {
 	return &SimpleWorkspaceService{
-		verbose:    verbose,
-		workspaces: workspaces,
+		verbose: verbose,
 	}
 }
 
@@ -30,24 +28,14 @@ func (s *SimpleWorkspaceService) GetWorkspacePaths(ctx context.Context, req *hos
 		log.Printf("GetWorkspacePaths called")
 	}
 
-	paths := []string{}
-
-	if len(s.workspaces) == 0 {
-		cwd, err := os.Getwd()
-		if err != nil {
-			return nil, err
-		}
-		paths = append(paths, cwd)
-	} else {
-		paths = s.workspaces
-	}
-
-	if s.verbose {
-		log.Printf("Returning configured workspaces: %v", paths)
+	// Get current working directory as the workspace
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, err
 	}
 
 	return &host.GetWorkspacePathsResponse{
-		Paths: paths,
+		Paths: []string{cwd},
 	}, nil
 }
 

docs/cline-cli/cli-reference.mdx

@@ -95,12 +95,6 @@ INSTANT TASK OPTIONS
        -m, --mode mode
               Starting mode.  Options: act (default), plan
 
-       -w, --workspace path
-              Additional workspace paths.  Can be specified multiple times to
-              include multiple directories.  The current working directory is
-              always included as the first workspace.  Example: cline -w
-              /path/to/other/project "refactor shared code"
-
 GLOBAL OPTIONS
        These options apply to all subcommands:
 
@@ -284,29 +278,6 @@ TASK SETTINGS
 
        mode   Starting mode (act/plan)
 
-       hooks_enabled
-              Enable or disable hooks for the task (true/false)
-
-HOOKS INTEGRATION
-       Hooks let you inject custom logic into Cline's workflow at key moments.
-       They can validate operations before they execute, monitor tool usage,
-       and shape AI decisions. This allows you to integrate hooks into
-       automated workflows, CI/CD pipelines, and headless task execution.
-
-       Enable hooks for a task:
-
-              cline "prompt" -s hooks_enabled=true
-
-       Configure hooks globally:
-
-              cline config set hooks-enabled=true
-              cline config get hooks-enabled
-
-       Note: Hooks in the CLI are only supported on macOS and Linux.
-
-       For complete hooks documentation, see:
-       <https://docs.cline.bot/features/hooks/index>
-
 NOTES & EXAMPLES
        The cline task send and cline task new commands support reading from
        stdin, enabling powerful pipeline compositions:
@@ -377,43 +348,6 @@ COPYRIGHT
        Copyright © 2025 Cline Bot Inc. Licensed under the Apache License 2.0.
 ```
 
-## JSON output (-F json)
-
-When you run a command with `-F json` (or `--output-format json`), Cline prints each client message as JSON.
-
-### ClineMessage schema
-
-| Field | Type | Required | Notes |
-|-------|------|----------|-------|
-| `type` | `"ask" or "say"` | Yes | Top-level message category. |
-| `text` | `string` | Yes | Human-readable message content. |
-| `ts` | `number` | Yes | Unix epoch timestamp in milliseconds. |
-| `reasoning` | `string` | No | Omitted when empty. |
-| `say` | `string` | No | Omitted when empty. Present when `type` is `"say"`. |
-| `ask` | `string` | No | Omitted when empty. Present when `type` is `"ask"`. |
-| `partial` | `boolean` | No | Omitted when false. `true` for streaming updates. |
-| `images` | `string[]` | No | Omitted when empty. Image URIs when included with a message. |
-| `files` | `string[]` | No | Omitted when empty. File paths when attached to a message. |
-| `lastCheckpointHash` | `string` | No | Omitted when empty. Git checkpoint hash when available. |
-| `isCheckpointCheckedOut` | `boolean` | No | Omitted when false. `true` if Cline checked out a checkpoint. |
-| `isOperationOutsideWorkspace` | `boolean` | No | Omitted when false. `true` if an operation happened outside the workspace. |
-
-<Note>
-Most fields are optional and omitted when empty. If you parse this output, treat missing fields as “not present”, not as empty strings.
-</Note>
-
-### Example
-
-```json
-{
-  "type": "say",
-  "text": "Cline is about to run a command.",
-  "ts": 1760501486669,
-  "say": "command",
-  "partial": false
-}
-```
-
 ### Shell Completion
 
 Generate autocompletion scripts for various shells:

docs/cline-cli/overview.mdx

@@ -57,20 +57,6 @@ During installation, you'll authenticate and configure your preferred provider u
 - Create GitLab pipelines that generate migration scripts from schema changes
 - Build Jenkins jobs that use Cline to analyze test failures and suggest fixes
 
-## Hooks integration
-
-[Hooks](/features/hooks/index) let you inject custom logic into Cline's workflow to validate operations and enforce policies. You can enable hooks when running tasks from the command line:
-
-```bash
-# Enable hooks for a task
-cline "What does this repo do?" -s hooks_enabled=true
-
-# Configure hooks globally via CLI
-cline config set hooks-enabled=true
-```
-
-This allows you to integrate hooks into automated workflows, CI/CD pipelines, and headless task execution for consistent enforcement across all environments.
-
 ## Learn more
 
 <Columns cols={2}>

docs/docs.json

@@ -278,47 +278,18 @@
 						"pages": [
 							"enterprise-solutions/overview",
 							"enterprise-solutions/onboarding",
-							"enterprise-solutions/team-management/managing-members",
+							"enterprise-solutions/members/roles-and-permissions",
 							{
-								"group": "SaaS Provider Configuration",
+								"group": "Provider Remote 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"
+											"enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration",
+											"enterprise-solutions/provider-remote-config/aws-bedrock/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"
-								]
 							}
 						]
 					}
@@ -396,11 +367,11 @@
 		},
 		{
 			"source": "/enterprise-solutions/configure-AWS-Bedrock-Admin",
-			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/admin-configuration"
+			"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/admin-configuration"
 		},
 		{
 			"source": "/enterprise-solutions/configure-AWS-Bedrock-Member",
-			"destination": "/enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
+			"destination": "/enterprise-solutions/provider-remote-config/aws-bedrock/member-configuration"
 		},
 		{
 			"source": "/enterprise-solutions/configure-workOS-authkit",
@@ -409,14 +380,6 @@
 		{
 			"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/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/managing-members.mdx

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

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

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

docs/enterprise-solutions/members/overview.mdx

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

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

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

docs/enterprise-solutions/monitoring/opentelemetry.mdx

@@ -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

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

docs/enterprise-solutions/overview.mdx

@@ -1,7 +1,7 @@
 ---
 title: "Cline Enterprise"
 sidebarTitle: "Overview"
-description: "Enterprise security, governance, and observability for the coding agent 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/provider-remote-config/aws-bedrock/admin-configuration.mdx

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

docs/enterprise-solutions/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/exploring-clines-tools/cline-tools-guide.mdx

@@ -13,6 +13,46 @@ Cline is your AI assistant that can:
 -   Automate repetitive tasks
 -   Integrate with external tools
 
+## First Steps
+
+1. **Start a Task**
+
+    - Type your request in the chat
+    - Example: "Create a new React component called Header"
+
+2. **Provide Context**
+
+    - Use @ mentions to add files, folders, or URLs
+    - Example: "@file:src/components/App.tsx"
+
+3. **Review Changes**
+    - Cline will show diffs before making changes
+    - You can edit or reject changes
+
+## Key Features
+
+1. **File Editing**
+
+    - Create new files
+    - Modify existing code
+    - Search and replace across files
+
+2. **Terminal Commands**
+
+    - Run npm commands
+    - Start development servers
+    - Install dependencies
+
+3. **Code Analysis**
+
+    - Find and fix errors
+    - Refactor code
+    - Add documentation
+
+4. **Browser Integration**
+    - Test web pages
+    - Capture screenshots
+    - Inspect console logs
 
 ## Available Tools
 
@@ -44,7 +84,6 @@ Cline has access to the following tools for various tasks:
     - `ask_followup_question`: Ask user for clarification
     - `attempt_completion`: Present final results
 
-
 Each tool has specific parameters and usage patterns. Here are some examples:
 
 -   Create a new file (write_to_file):

docs/features/auto-approve.mdx

@@ -1,104 +1,59 @@
----
-title: "Auto Approve"
-sidebarTitle: "Auto Approve"
-description: "Let Cline take specific actions without asking for approval every time."
----
-
-Auto Approve lets you decide which actions Cline can take without prompting you each time. It keeps you out of approval popups during routine work, while still letting you keep tight control over high-risk actions.
-
-If you find yourself repeatedly clicking approve for the same safe operations, Auto Approve is the setting that fixes that. The goal is fewer interruptions without losing the ability to review changes when it matters.
+The Auto Approve menu lets you set fine-grained permissions on what you allow Cline to do in an automated way.
 
 <Frame>
-	<video
-		style={{ width: "100%" }}
-		src="https://storage.googleapis.com/cline_public_images/autoapprove.mp4"
-		autoPlay
-		controls
-		playsInline
-	/>
+	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/auto-approve.png" alt="Auto Approve" />
 </Frame>
 
 ## How it works
 
-Auto Approve is evaluated per tool call. When Cline is about to read a file, edit a file, run a command, or use the browser, Cline checks your Auto Approve settings for that category.
+By default, Cline will ask for your permission before calling any tool, including reading or writing files.
 
-A few details matter in practice:
+If you want to allow Cline to do something without asking, you can set the Auto Approve permission for that tool.
 
-- **Workspace vs outside your workspace**: “Read all files” and “Edit all files” only extend the base toggle. If the base toggle is off, the “all files” option does nothing.
+## Permission Options
 
-- **Terminal commands**: Cline treats terminal commands as either safe or requiring approval. “Execute safe commands” covers the first category. “Execute all commands” extends this to commands flagged as requiring approval.
+-   **Read project files**
 
-- **Notifications**: If enabled, Cline sends OS-level notifications when approval is required, and when an auto-approved terminal command has been running for 30 seconds and may need attention.
+    -   Allows Cline to read files within your current workspace without asking
+    -   **Read all files**
+        -   Extends read permission to files outside your workspace (system files, config files, etc.)
 
-<Note>
-	[YOLO mode](/features/yolo-mode) bypasses these granular approvals.
-</Note>
+-   **Edit project files**
 
-## Permissions
+    -   Allows Cline to modify files within your current workspace without confirmation
+    -   **Edit all files**
+        -   Extends modification permission to files outside your workspace
 
-These labels match what you see in the Auto Approve menu.
+-   **Execute safe commands**
 
-| Setting | What it allows | Notes |
-|--------|-----------------|------|
-| Read project files | Read files, list files, search in your workspace | Good default for most tasks |
-| Read all files | Read files outside your workspace | Requires “Read project files” |
-| Edit project files | Create and edit files in your workspace | Consider using checkpoints |
-| Edit all files | Edit files outside your workspace | Requires “Edit project files” |
-| Execute safe commands | Run terminal commands marked safe | Can still run long |
-| Execute all commands | Run commands marked as requiring approval | Requires “Execute safe commands” |
-| Use the browser | Allows use of the browser tool for web fetching and searching | Proxy issues can apply |
-| Use MCP servers | Use MCP tools and access MCP resources | Some servers also have per-tool auto-approve |
-| Enable notifications | Notifies you about long-running auto-approved commands | Helpful for terminal work |
+    -   Allows execution of terminal commands that the model deems non-destructive
+    -   **Execute all commands**
+        -   Permits execution of any terminal command without asking
 
-<Warning>
-	“Read all files” and “Edit all files” only matter if their base toggle is enabled. They extend access outside your workspace.
-</Warning>
+-   **Use the browser**
 
-<Card title="Networking & proxies" icon="globe" href="/troubleshooting/networking-and-proxies">
-	If browser-based tools fail in corporate networks, this page covers the common fixes.
-</Card>
+    -   Allows Cline to use the browser tool to fetch web content
 
-## Safe vs approval-required command examples
+-   **Use MCP servers**
 
-Cline does not use a fixed allowlist of safe or unsafe commands. The model marks each command with a `requires_approval` flag based on the command and its arguments, and Auto Approve uses that flag.
+    -   Permits connection to and usage of MCP servers for extended functionality
 
-These are examples, not guarantees.
+-   **Maximum requests**
+    -   Sets the number of consecutive automated actions Cline can take before requiring your input
 
-### Commonly treated as safe
+## Best Practices
 
-| Example | Why it is usually safe |
-|--------|-------------------------|
-| `npm run build` | Build output, no direct file deletions |
-| `npm test` | Runs tests |
-| `git status` | Read-only |
-| `ls -la` | Read-only |
-| `cat package.json` | Read-only |
+Personally, I like to keep auto-editing disabled because it gives me a chance to review changes every step of the way.
 
-### Commonly requires approval
+For most serious development workflows, I recommend starting with:
 
-| Example | Why it often needs approval |
-|--------|------------------------------|
-| `npm install <pkg>` | Modifies dependencies and lockfiles |
-| `rm -rf <path>` | Deletes files |
-| `mv <a> <b>` | Moves files (can overwrite) |
-| `sed -i ...` | In-place file edits |
-| `curl https://...` | Downloads and executes remote code |
+-   Auto-approving read access to project files
+-   Setting a reasonable maximum request limit (10-20)
 
-<Note>
-	Whether a command is treated as safe depends on the exact command, flags, and the current task. When in doubt, keep command auto-approval off and approve commands manually.
-</Note>
+This gives Cline enough freedom to explore your codebase without constant interruptions, while still requiring permission for edits or potentially destructive actions.
 
-## Enable notifications
+As you build more trust in Cline's capabilities with your specific projects, you can gradually increase the permissions to match your comfort level.
 
-Auto-approved actions can run for a while, especially long terminal commands. If you enable notifications, Cline can notify you when an auto-approved command has been running for a while and may need attention.
+Remember that you can always adjust these settings as your needs change - tighten permissions for critical production work, or loosen them when prototyping and exploring.
 
-## Recommendations
-
-A good default setup is:
-
-- Enable **Read project files**
-- Leave **Edit project files**, **Execute safe commands**, **Use the browser**, and **Use MCP servers** off until you have a specific reason to enable them
-
-If you enable edits, use [Checkpoints](/features/checkpoints) so you can roll back quickly.
-
-If you’re working in a sensitive environment (production credentials, personal files, corporate devices), keep external file access and command execution locked down and approve actions manually as you go.
+You can even use the quick "star" actions to quickly toggle your auto-approved selections on and off as you go.

docs/features/commands-and-shortcuts/keyboard-shortcuts.mdx

@@ -3,192 +3,94 @@ title: "Keyboard Shortcuts"
 sidebarTitle: "Keyboard Shortcuts"
 ---
 
-Speed up your workflow by accessing Cline's AI assistance without taking your hands off the keyboard.
+Cline's keyboard shortcuts let you access AI assistance without taking your hands off the keyboard. Speed up your workflow by using hotkeys for common Cline actions.
 
-<Tip>
-**The One Shortcut You Need:** `Ctrl+'` (Windows/Linux) or `Cmd+'` (macOS)
+## Default Keyboard Shortcuts
 
-This context-aware shortcut handles your most common needs:
-- **With text selected:** Adds code to Cline chat
-- **Without selection:** Focuses the chat input
+Cline comes with the following built-in keyboard shortcuts to streamline your workflow:
 
-Master this one shortcut, and you're 90% there.
-</Tip>
+| Action                  | Windows/Linux | macOS   | Condition                    | Description                               |
+| ----------------------- | ------------- | ------- | ---------------------------- | ----------------------------------------- |
+| Add to Cline            | `Ctrl+'`      | `Cmd+'` | When text is selected        | Adds selected code to Cline chat          |
+| Focus Chat Input        | `Ctrl+'`      | `Cmd+'` | When no text is selected     | Focuses the Cline chat input field        |
+| Generate Commit Message | (unset)       | (unset) | When Git is the SCM provider | Available through the Source Control view |
 
-## Default Shortcuts
+## Available Commands for Custom Shortcuts
 
-Cline has minimal default shortcuts by design, so they won't conflict with your existing VSCode setup:
+While Cline has only a few default keyboard shortcuts, you can assign your own shortcuts to any of these commands:
 
-| Shortcut | Windows/Linux | macOS | What It Does |
-| -------- | ------------- | ----- | ------------ |
-| **Add to Chat / Focus Input** | `Ctrl+'` | `Cmd+'` | Context-aware: adds selected code or focuses chat |
+| Command ID                                                                               | Description                                   |
+| ---------------------------------------------------------------------------------------- | --------------------------------------------- |
+| [`cline.addToChat`](/features/commands-and-shortcuts/code-commands)                      | Adds selected code to Cline chat              |
+| [`cline.addTerminalOutputToChat`](/features/commands-and-shortcuts/terminal-integration) | Adds terminal output to Cline                 |
+| `cline.focusChatInput`                                                                   | Focuses the Cline chat input field            |
+| [`cline.generateGitCommitMessage`](/features/commands-and-shortcuts/git-integration)     | Generates a commit message for staged changes |
+| [`cline.explainCode`](/features/commands-and-shortcuts/code-commands)                    | Explains selected code                        |
+| [`cline.improveCode`](/features/commands-and-shortcuts/code-commands)                    | Suggests improvements for selected code       |
+| [`cline.fixWithCline`](/features/commands-and-shortcuts/code-commands)                   | Fixes code with errors                        |
+| `claude-dev.SidebarProvider.focus`                                                       | Opens and focuses the Cline sidebar           |
 
-That's it! Everything else is available for you to customize.
+## Customizing Keyboard Shortcuts
 
-## Quick Workflow Examples
+You can customize Cline's keyboard shortcuts to match your preferences:
 
-Here's how keyboard shortcuts fit into real coding workflows:
+1. Open the Keyboard Shortcuts editor in VSCode:
 
-### Debug & Fix Workflow
+    - Press `Ctrl+K Ctrl+S` (Windows/Linux) or `Cmd+K Cmd+S` (macOS)
+    - Or go to File > Preferences > Keyboard Shortcuts
 
-1. **Find error in code** → VSCode highlights it
-2. **Select the problematic code** → `Shift+Arrow` or `Ctrl+L` / `Cmd+L`
-3. **Send to Cline** → `Ctrl+'` / `Cmd+'`
-4. **Ask for help** → Type your question, hit `Enter`
+2. Search for "Cline" to see all available commands
 
-### Code Review Workflow
+3. Click on the pencil icon next to any command to change its shortcut
 
-1. **Review a function** → Select it with `Ctrl+L` / `Cmd+L`
-2. **Get AI review** → `Ctrl+'` / `Cmd+'` then ask "Review this"
-3. **Iterate** → Apply suggestions and repeat
+4. Press the keys you want to assign to that command
 
-### Terminal Integration Workflow
+5. Press Enter to save the new shortcut
 
-1. **Open terminal** → Press `` Ctrl+` `` / `` Cmd+` ``
-2. **Run your command** → Execute in terminal
-3. **Capture output** → Press `Alt+T` (after assigning shortcut)
-4. **Get help** → Ask Cline to interpret errors or output
+## Suggested Custom Shortcuts
 
-<Info>
-**Pro Tip:** Assign `Alt+T` to the `cline.addTerminalOutputToChat` command for quick terminal output capture. Without a shortcut, you can still right-click in the terminal and select "Add to Cline" - but the keyboard approach is much faster for frequent debugging workflows.
-</Info>
+Here are some suggested shortcuts you might find useful:
 
-## Customizing Shortcuts
+| Action                | Suggested Shortcut             | Command ID                                | Description                   |
+| --------------------- | ------------------------------ | ----------------------------------------- | ----------------------------- |
+| Open Cline Sidebar    | `Ctrl+Shift+C` / `Cmd+Shift+C` | `claude-dev.SidebarProvider.focus`        | Opens the Cline sidebar panel |
+| New Task              | `Alt+N`                        | `cline.plusButtonClicked`                 | Starts a new Cline task       |
+| Add Terminal to Cline | `Alt+T`                        | `cline.addTerminalOutputToChat`           | Adds terminal output to Cline |
+| Clear Current Task    | `Alt+C`                        | (Requires custom keybinding to UI action) | Clears the current task       |
 
-Want to assign shortcuts to more Cline commands? Here's how:
+## Keyboard-Only Workflow
 
-**Step 1:** Open VSCode's Keyboard Shortcuts editor
-- Press `Ctrl+K Ctrl+S` (Windows/Linux) or `Cmd+K Cmd+S` (macOS)
-- Or: **File → Preferences → Keyboard Shortcuts**
+With the right shortcuts, you can use Cline without ever touching the mouse:
 
-**Step 2:** Search for "Cline"
+1. Select code with keyboard navigation (`Shift+Arrow` keys)
+2. Send to Cline with `Ctrl+'` / `Cmd+'`
+3. Type your question and press Enter
+4. Review the response and apply suggestions
 
-**Step 3:** Click the ✏️ icon next to any command
+## Editor Integration Shortcuts
 
-**Step 4:** Press your desired key combo, then `Enter`
+Cline's keyboard shortcuts integrate seamlessly with VSCode's built-in shortcuts:
 
-<Warning>
-**Avoid Conflicts:** Check that your shortcut doesn't override important VSCode commands. The shortcuts editor will warn you about conflicts.
-</Warning>
+-   Use VSCode's selection shortcuts (`Ctrl+L` / `Cmd+L` to select line, etc.) before sending code to Cline
+-   Combine with VSCode's split editor shortcuts to view code and Cline side by side
+-   Use VSCode's terminal focus shortcut (`` Ctrl+` `` / `` Cmd+` ``) before capturing terminal output
 
-## Available Commands Reference
+## Tips for Effective Use
 
-<Accordion title="Task Management Commands">
+-   **Learn the default shortcut first**: The `Ctrl+'` / `Cmd+'` shortcut is versatile - it adds selected code to chat when text is selected, or focuses the chat input when nothing is selected
+-   **Create muscle memory**: Use keyboard shortcuts consistently to build habits
+-   **Customize for your workflow**: Assign shortcuts to commands you use frequently
+-   **Consider ergonomics**: Choose shortcuts that are comfortable for your keyboard layout
 
-These commands help you navigate and manage Cline tasks:
+Keyboard shortcuts may seem like a small optimization, but they can significantly speed up your workflow when using Cline regularly. By keeping your hands on the keyboard, you maintain your coding flow while still getting AI assistance exactly when you need it.
 
-| Command ID | Description | Suggested Shortcut |
-| ---------- | ----------- | ------------------ |
-| `cline.plusButtonClicked` | Start a new task | `Ctrl+Shift+N` / `Cmd+Shift+N` |
-| `cline.historyButtonClicked` | Open task history | `Ctrl+Shift+H` / `Cmd+Shift+H` |
-| `claude-dev.SidebarProvider.focus` | Open Cline sidebar | `Ctrl+Shift+L` / `Cmd+Shift+L` |
+## How to Find All Available Commands
 
-**Note:** `claude-dev` prefix is for historical reasons - it works with Cline.
+To see all Cline commands that can be assigned shortcuts:
 
-</Accordion>
-
-<Accordion title="Code Interaction Commands">
-
-Work directly with your code:
-
-| Command ID | Description | Suggested Shortcut |
-| ---------- | ----------- | ------------------ |
-| `cline.addToChat` | Add selected code to chat | `Ctrl+'` / `Cmd+'` ⭐ (default) |
-| `cline.focusChatInput` | Focus chat input | `Ctrl+'` / `Cmd+'` ⭐ (default) |
-| `cline.explainCode` | Explain selected code | `Ctrl+Shift+E` / `Cmd+Shift+E` |
-| `cline.improveCode` | Suggest code improvements | `Ctrl+Shift+I` / `Cmd+Shift+I` |
-
-⭐ These share the same shortcut - it's context-aware!
-
-</Accordion>
-
-<Accordion title="Terminal Integration Commands">
-
-Connect Cline with your terminal:
-
-| Command ID | Description | Suggested Shortcut |
-| ---------- | ----------- | ------------------ |
-| `cline.addTerminalOutputToChat` | Add terminal output to Cline | `Alt+T` |
-
-**Tip:** Use this after running commands to get help interpreting output or fixing errors.
-
-</Accordion>
-
-<Accordion title="Git Integration Commands">
-
-Generate commit messages with AI:
-
-| Command ID | Description | Suggested Shortcut |
-| ---------- | ----------- | ------------------ |
-| `cline.generateGitCommitMessage` | Generate commit message | `Ctrl+Shift+G` / `Cmd+Shift+G` |
-| `cline.abortGitCommitMessage` | Stop generation | `Ctrl+Shift+Esc` / `Cmd+Shift+Esc` |
-
-</Accordion>
-
-<Accordion title="Settings & Configuration Commands (Advanced)">
-
-These commands open Cline's configuration panels. Most users access these via the sidebar buttons, but keyboard shortcuts can be useful for:
-
-- **Frequent MCP server developers** who constantly adjust server configurations
-- **Demo/presentation scenarios** where you need quick, keyboard-only navigation
-- **Accessibility workflows** where mouse usage is minimized
-
-| Command ID | Description | Suggested Shortcut |
-| ---------- | ----------- | ------------------ |
-| `cline.settingsButtonClicked` | Open Cline settings | `Ctrl+Alt+,` / `Cmd+Opt+,` |
-| `cline.mcpButtonClicked` | Open MCP servers config | `Ctrl+Alt+M` / `Cmd+Opt+M` |
-| `cline.accountButtonClicked` | Open account settings | `Ctrl+Alt+A` / `Cmd+Opt+A` |
-| `cline.openWalkthrough` | Open walkthrough guide | (not recommended) |
-
-**Our take:** Unless you're constantly tweaking settings or building MCP servers, the sidebar buttons are more convenient. But if you find yourself opening these panels frequently, shortcuts can save time.
-
-</Accordion>
-
-## What About "Fix with Cline"?
-
-<Warning>
-**You CAN'T assign a keyboard shortcut to "Fix with Cline"**
-
-This command only appears in the **lightbulb menu** (💡) when VSCode detects errors in your code. It needs the error context to work, so it's not available as a standalone command.
-
-**Workarounds:**
-- Click the 💡 lightbulb icon that appears next to errors
-- Or select code with errors and use `Ctrl+'` / `Cmd+'` to ask Cline to fix them
-- Or right-click and select "Add to Cline"
-</Warning>
-
-Learn more about code actions in our [Code Commands documentation](/features/commands-and-shortcuts/code-commands).
-
-## Best Practices
-
-<Tip>
-**Start Simple**
-
-Don't try to memorize 20 shortcuts on day one. Start with:
-1. `Ctrl+'` / `Cmd+'` (the essential one)
-2. Add 1-2 more based on your actual usage patterns
-3. Build muscle memory over time
-</Tip>
-
-**Choose Shortcuts Wisely:**
-- **Be ergonomic:** Use comfortable key combinations
-- **Create patterns:** Group related commands (e.g., all Cline shortcuts use `Ctrl+Shift+...`)
-- **Avoid conflicts:** Don't override VSCode essentials like `Ctrl+C` or `Ctrl+S`
-- **Use modifiers:** Combine `Ctrl`/`Cmd` + `Shift` + `Alt` to reduce conflicts
-
-**Build the Habit:**
-- Use shortcuts consistently for a week to build muscle memory
-- Keep a note of your custom shortcuts until they're automatic
-- Review monthly to see if your workflow has changed
-
-## Discovering Commands
-
-Not sure what commands are available? Use VSCode's Command Palette:
-
-1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
-2. Type "Cline" to filter
-3. Browse all available commands
-4. Assign shortcuts to your favorites
+1. Open the Command Palette (`Ctrl+Shift+P` / `Cmd+Shift+P`)
+2. Type "Cline" to filter the list
+3. Browse the available commands
 
 <Frame>
 	<img
@@ -197,8 +99,4 @@ Not sure what commands are available? Use VSCode's Command Palette:
 	/>
 </Frame>
 
----
-
-<Info>
-**Remember:** The goal isn't to memorize every possible shortcut. Master `Ctrl+'` / `Cmd+'` first, then gradually add shortcuts for commands you use frequently. Quality over quantity!
-</Info>
+This helps you discover features you might not have known about and assign shortcuts to the ones you use most frequently.

docs/features/explain-changes.mdx

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

docs/features/hooks/hook-reference.mdx

@@ -432,6 +432,6 @@ Hooks have a 30 second timeout. As long as your hook completes within this time,
 
 Cline searches for hooks in this order:
 1. Project-specific: `.clinerules/hooks/` in workspace root
-2. User-global: `~/Documents/Cline/Hooks/`
+2. User-global: `~/Documents/Cline/Rules/Hooks/`
 
 Project-specific hooks override global hooks with the same name.

docs/features/hooks/index.mdx

@@ -47,7 +47,7 @@ The interface shows you all available hook types and existing hooks organized by
 Hooks are automatically organized by location in the interface:
 
 **Global Hooks** - Apply to all workspaces:
-- Stored in `~/Documents/Cline/Hooks/`
+- Stored in `~/Documents/Cline/Rules/Hooks/`
 - Perfect for personal coding standards and universal rules
 
 **Project-Specific Hooks** - Apply only to current project:
@@ -137,30 +137,10 @@ The key is combining hooks with external tools. A hook can be the glue between C
   </Card>
 </CardGroup>
 
-## CLI support
-
-Hooks are also available in the [Cline CLI](/cline-cli/overview). You can enable or disable hooks when running tasks from the command line:
-
-```bash
-# Enable hooks for a task
-cline "What does this repo do?" -s hooks_enabled=true
-
-# Configure hooks globally via CLI
-cline config set hooks-enabled=true
-cline config get hooks-enabled
-```
-
-This allows you to integrate hooks into automated workflows, CI/CD pipelines, and headless task execution.
-
-<Note>
-Hooks in the CLI are only supported on macOS and Linux. Windows support is not yet available.
-</Note>
-
-## Related features
+## Related Features
 
 Hooks complement other Cline features:
 
 - [Cline Rules](/features/cline-rules) define high-level guidance that hooks can enforce
 - [Checkpoints](/features/checkpoints) let you roll back changes if a hook didn't catch an issue
 - [Auto-Approve](/features/auto-approve) works well with hooks as safety nets for automated operations
-- [Cline CLI](/cline-cli/overview) enables hooks in terminal-based and automated workflows

docs/features/multiroot-workspace.mdx

@@ -1,260 +1,164 @@
 ---
-title: "Multi-Root Workspaces"
-sidebarTitle: "Multi-Root Workspaces"
+title: "Multiroot Workspace Support"
+sidebarTitle: "Multiroot Workspace"
 ---
 
-Cline works with VSCode's multi-root workspaces, letting you manage multiple project folders or repositories in a single window. Whether you're working with a monorepo or separate Git repositories, Cline can read files, write code, and run commands across all of them.
-
-<Frame>
-  <video
-    src="https://storage.googleapis.com/cline_public_images/multiworkspace.mp4"
-    autoPlay
-    muted
-    loop
-    playsInline
-    controls
-  />
-</Frame>
-
-<Warning>
-Multi-root workspaces have two limitations:
-- **Cline rules** only work in the primary workspace folder
-- **Checkpoints** are disabled (restored when you return to a single folder)
-
-See [Current Limitations](#current-limitations) for details.
-</Warning>
-
-## Understanding Multi-Root Workspaces
-
-Before diving in, it helps to understand the two common patterns for organizing related projects.
-
-### Why Use Multi-Root Workspaces?
-
-Cline can complete tasks that span multiple projects or repositories:
-
-- **Refactoring**: Update an API contract and fix all consumers across repos
-- **Feature development**: Implement a feature that touches frontend, backend, and shared code
-- **Dependency updates**: Coordinate version bumps across related projects
-- **Documentation**: Generate docs that reference code from multiple repositories
-
-**Example prompt:**
-```
-Update the User type in the contracts repo, then update both the frontend 
-and backend to use the new fields. Make sure the API validates the new 
-required field.
-```
-## Setting Up a Multi-Root Workspace
-
-### Monorepos vs Multiple Repositories
-
-**Monorepo**: One Git repository containing multiple projects or packages. All code shares the same version history.
-
-```
-my-company/                    # Single Git repo
-├── .git/
-├── packages/
-│   ├── web/                   # React frontend
-│   ├── api/                   # Node.js backend
-│   └── shared/                # Common utilities
-└── package.json
-```
-
-**Multiple Repositories**: Separate Git repositories, each with their own history, opened together in one VSCode workspace.
-
-```
-~/projects/
-├── fullstack.code-workspace   # Workspace config file
-├── frontend/                  # git@github.com:acme/frontend.git
-│   └── .git/
-├── backend/                   # git@github.com:acme/backend.git
-│   └── .git/
-└── contracts/                 # git@github.com:acme/api-contracts.git
-    └── .git/
-```
-
-Cline supports both patterns, as well as hybrid setups where some folders are Git repositories and others are not. The key difference: with multiple repositories, each folder has its own `.git` directory and Cline tracks them independently.
-
-### Adding Folders to Your Workspace
-
-You can add folders to your workspace in several ways:
-
-- **File menu**: Use `File > Add Folder to Workspace` in VSCode
-- **Drag and drop**: Drag folders directly into VSCode's file explorer
-- **Workspace file**: Create a `.code-workspace` file (recommended for teams)
-- **Command palette**: Run `Workspaces: Add Folder to Workspace`
-
-For detailed instructions, see [Microsoft's multi-root workspace guide](https://code.visualstudio.com/docs/editor/multi-root-workspaces).
-
-## Working with Multiple Repositories
-
-When you open separate Git repositories in one workspace, Cline treats each as an independent project with its own version control.
-
-### What Cline Tracks Per Repository
-
-For each workspace folder, Cline detects:
-
-| Property | Description |
-|----------|-------------|
-| **Path** | Absolute path to the folder |
-| **Name** | Derived from folder name or workspace file |
-| **VCS Type** | Git, Mercurial, or None |
-| **Commit Hash** | Current HEAD commit (for Git/Mercurial repos) |
-
-This means Cline understands that your frontend and backend might be at different commits, on different branches, or even use different version control systems.
+Cline's Multiroot feature works seamlessly with VSCode's multi-root workspaces, letting you manage multiple project folders in a single workspace.
 
 <Note>
-While Cline detects VCS information for all workspace folders, certain features only use the **primary workspace** (the first folder): [Cline rules](/features/cline-rules), [workflows](/features/slash-commands/workflows/index), and [Git-related features](/features/at-mentions/git-mentions) like `@git` mentions.
+**Important:** Multi-root workspaces are currently an experimental feature and have the following limitations:
+- **Cline rules** only work in the first workspace folder
+- **Checkpoints** are automatically disabled with a warning message
+- Both features are restored when you return to a single-folder workspace
 </Note>
 
-## Referencing Files Across Workspaces
+## What is multiroot workspace support?
 
-### Natural Language References
+Instead of being limited to one project folder, Cline can read files, write code, and run commands across all folders in your VSCode workspace. This is helpful when working with monorepos, microservices, or when you're working on related projects simultaneously.
 
-Cline understands natural references to your workspaces:
+### How it works
+
+When you open multiple workspace folders in VSCode, Cline automatically:
+- Designates one folder as the **primary workspace** (typically the first folder added)
+- Tracks all workspace folders and their paths
+- Resolves file paths intelligently across workspaces
+- Displays workspace information in the environment details for each API request
+
+## Getting Started
+
+### Setting Up Multi-Root Workspaces
+
+1. **Add folders to your workspace:**
+   - Use `File > Add Folder to Workspace` in VSCode
+   - Or create a `.code-workspace` file with multiple folder paths
+   - Drag and drop folders to the File Explorer
+   - Select multiple folders when opening a new workspace
+
+2. **Start using Cline** - Cline will automatically detect all your workspace folders and interact with them as needed.
+
+For detailed instructions on setting up multi-root workspaces in VS Code, see [Microsoft's official guide](https://code.visualstudio.com/docs/editing/workspaces/multi-root-workspaces).
+
+### Technical behavior
+
+**Workspace detection**
+- Cline detects all workspace folders when a task starts
+- The first workspace folder becomes the primary workspace by default
+- Each workspace can have its own VCS (Git, SVN, etc.)
+
+**Path resolution**
+- Relative paths are resolved relative to the primary workspace
+- You can use workspace hints to target specific workspaces: `@workspaceName:path/to/file`
+- Cline attempts to intelligently determine which workspace a file belongs to
+
+**Command execution**
+- Commands execute in the appropriate workspace context
+- The working directory is set based on where files are being accessed
+
+## Working across workspaces
+
+### Referencing specific workspaces
+
+You can reference different workspaces naturally in your prompts:
 
 ```
-"Read the package.json in the frontend folder"
+"Read the package.json in my frontend folder and compare it with the backend dependencies"
 ```
 
 ```
-"Compare the user model in backend with the TypeScript types in contracts"
+"Create a shared utility function and update both the client and server to use it"
 ```
 
 ```
-"Search for TODO comments across all workspaces"
+"Search for TODO comments across all my workspace folders"
 ```
 
-### Workspace Hints Syntax
+### Workspace hints
 
-For explicit references, use the `@workspace:path` syntax:
+Use workspace hints to explicitly reference files in specific workspaces:
 
-| Syntax | Description |
-|--------|-------------|
-| `@frontend:src/App.tsx` | File in the "frontend" workspace |
-| `@backend:server.ts` | File in the "backend" workspace |
-| `@contracts:types/` | Folder in the "contracts" workspace |
+```
+@frontend:src/App.tsx
+@backend:server.ts
+```
 
-This syntax is especially useful when:
-- Multiple workspaces have files with the same name
-- You want to be explicit about which project you mean
-- Cline needs to resolve ambiguity
+This syntax helps Cline resolve ambiguity when multiple workspaces contain similarly named files.
 
-### How Workspace Names Work
 
-Workspace names are derived from:
-1. The `name` field in your `.code-workspace` file (if specified)
-2. The folder name (default)
-
-If two folders have the same name, append numbers or use the workspace file to give them unique names.
-
-## Common Configurations
+## Common use cases
 
 ### Monorepo Development
 
+Perfect for when you have related projects in one repository:
+
 ```
-~/projects/my-app/
-├── my-app.code-workspace      # Workspace config file
+my-app.code-workspace
 ├── web/          (React frontend)
-├── api/          (Node.js backend)  
+├── api/          (Node.js backend)
 ├── mobile/       (React Native)
 └── shared/       (Common utilities)
 ```
 
-All folders share one Git history. Changes across packages are atomic.
+Ask Cline: *"Update the API endpoint in both web and mobile apps to match the new backend route"*
 
-**Example prompt:** *"Update the API endpoint in both web and mobile apps to match the new backend route"*
+### Microservices Architecture
 
-### Microservices with Separate Repos
+Manage multiple services from one workspace:
 
 ```
-~/projects/services/
-├── services.code-workspace    # Workspace config file
-├── user-service/       (git: github.com/acme/user-service)
-├── payment-service/    (git: github.com/acme/payment-service)
-├── gateway/            (git: github.com/acme/api-gateway)
-└── proto/              (git: github.com/acme/service-protos)
+services.code-workspace
+├── user-service/
+├── payment-service/  
+├── notifications/
+└── infrastructure/
 ```
 
-Each service has its own repository. Cline can update the proto definitions and regenerate clients across all services.
+### Full-Stack Development
 
-**Example prompt:** *"Add a new field to the UserProfile message in proto, then update user-service and gateway to handle it"*
-
-### Full-Stack with Shared Contracts
+Keep everything together while maintaining separation:
 
 ```
-~/projects/fullstack/
-├── fullstack.code-workspace   # Workspace config file
-├── client/         (git: github.com/acme/web-client)
-├── server/         (git: github.com/acme/api-server)
-└── types/          (git: github.com/acme/shared-types)
+fullstack.code-workspace
+├── client/       (Frontend)
+├── server/       (Backend API)
+├── docs/         (Documentation)  
+└── deploy/       (Scripts & config)
 ```
 
-The types repository defines interfaces used by both client and server. When you update a type, Cline can fix both consumers.
 
-### Hybrid Setup
+### Auto-Approve Integration
 
-```
-~/projects/project/
-├── project.code-workspace     # Workspace config file
-├── main-app/       (git: github.com/acme/main-app)
-├── vendor/         (no VCS - vendored dependencies)
-└── scripts/        (no VCS - local automation)
-```
+Multiroot workspaces work with [Auto Approve](/features/auto-approve):
 
-Mix of repositories and plain folders. Cline adapts to each folder's configuration.
+- Enable permissions for operations within workspace folders
+- Restrict auto-approve for files outside your workspace(s)
+- Configure different levels for different workspace folders
 
-## Current Limitations
+### Cross-Workspace Operations
 
-Two features have limitations in multi-root workspace mode:
+Cline can complete tasks spanning multiple workspaces:
 
-### Cline Rules
+- **Refactoring**: Update imports and references across projects
+- **Feature development**: Implement features requiring changes in multiple services  
+- **Documentation**: Generate docs referencing code from multiple folders
+- **Testing**: Build & run tests across all workspaces and analyze results
 
-[Cline rules](/features/cline-rules) (`.clinerules/` directory) only work in the **primary workspace** (the first folder in your workspace). Rules in other workspace folders are ignored.
-
-**Workaround:** Place shared rules in the primary workspace, or use global rules (`~/Documents/Cline/Rules/`) which apply everywhere.
-
-### Checkpoints
-
-[Checkpoints](/features/checkpoints) are disabled in multi-root workspace mode. Cline displays a warning when this happens.
-
-**Why:** Checkpoints use a shadow Git repository to track changes. With multiple repositories, coordinating checkpoints across independent Git histories adds complexity that isn't yet supported.
-
-**Workaround:** Use your normal Git workflow. Commit frequently, or create branches for experimental work.
-
-Both limitations are restored when you return to a single-folder workspace.
+When working with large multiroot workspaces, start in [Plan mode](/features/plan-and-act) to let Cline understand your project structure before making changes.
 
 ## Best Practices
 
 ### Organizing Your Workspaces
 
 1. **Group related projects** that often need coordinated changes
-2. **Use a workspace file** for reproducible setups across your team
-3. **Name folders clearly** so workspace hints are intuitive
-4. **Consider the primary workspace** for Cline rules placement
+2. **Use consistent folder structures** across workspaces when possible
+3. **Name folders clearly** so Cline can understand your project structure
 
-### Effective Prompting
+### Effective Prompting & Tips
 
-- **Be specific** when it matters: *"Update the user model in the backend workspace"*
-- **Reference relationships**: *"The frontend uses types from the contracts workspace"*
-- **Describe cross-workspace changes**: *"This needs to update both web and mobile"*
-- **Scope searches** for large codebases: *"Search for 'TODO' only in the frontend workspace"*
+When working with multiroot workspaces, these approaches work best:
 
-### Working with Large Workspaces
-
-- Break large tasks into workspace-specific operations when possible
-- Use [Plan mode](/features/plan-and-act) to let Cline understand structure first
-- Add a `.clineignore` file to reduce noise, speed up scanning, and keep Cline focused on source code:
-
-```text
-# Dependencies
-**/node_modules/
-
-# Build outputs
-**/dist/
-**/build/
-
-# VCS metadata
-**/.git/
-```
-
-For more patterns and gotchas, see the [.clineignore File Guide](/prompting/prompt-engineering-guide#clineignore-file-guide).
+- **Be specific** about which workspace when it matters: *"Update the user model in the backend workspace"*
+- **Reference relationships**: *"The frontend uses the API types from the shared workspace"*
+- **Describe cross-workspace operations**: *"This change needs to be reflected in both the web and mobile apps"*
+- **Scope your searches** when dealing with large codebases: *"Search for 'TODO' in just the frontend workspace"*
+- **Break down large tasks** into workspace-specific operations when possible
+- **Consider excluding large folders** like `node_modules` from your workspace search Scope

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

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

docs/getting-started/installing-cline.mdx

@@ -10,7 +10,7 @@ description: "Get Cline up and running in your favorite IDE with these simple in
 ## Before You Begin
 
 <CardGroup cols={1}>
-  <Card title="Create Your Account" icon="user-plus" href="https://app.cline.bot/login">
+  <Card title="Create Your Account" icon="user-plus" href="https://app.cline.bot/signup">
     Sign up for a **free Cline account** to get:
     - Access to multiple AI models including stealth models
     - Seamless setup without managing API keys

docs/introduction/welcome.mdx

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

docs/package.json

@@ -13,7 +13,7 @@
 	"license": "ISC",
 	"description": "",
 	"dependencies": {
-		"mintlify": "^4.2.249"
+		"mintlify": "^4.2.23"
 	},
 	"overrides": {
 		"tar-fs": "^3.1.1",

docs/provider-config/baseten.mdx

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

esbuild.mjs

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

evals/diff-edits/dashboard/requirements.txt

@@ -1,4 +1,4 @@
-streamlit==1.43.2
+streamlit>=1.28.0
 plotly>=5.17.0
 pandas>=2.0.0
 numpy>=1.24.0

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.46.1",
+	"version": "3.40.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -378,7 +378,7 @@
 		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
 		"test": "npm-run-all test:unit test:integration",
 		"test:integration": "vscode-test",
-		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha",
+		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha # Use `UPDATE_SNAPSHOTS=true npm run test:unit` to rebuild prompt snapshots",
 		"test:coverage": "vscode-test --coverage",
 		"test:sca-server": "npx tsx watch scripts/test-standalone-core-api-server.ts",
 		"test:tp-orchestrator": "npx tsx scripts/testing-platform-orchestrator.ts",
@@ -463,7 +463,7 @@
 		"@grpc/grpc-js": "^1.9.15",
 		"@grpc/reflection": "^1.0.4",
 		"@mistralai/mistralai": "^1.5.0",
-		"@modelcontextprotocol/sdk": "^1.25.1",
+		"@modelcontextprotocol/sdk": "^1.11.1",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/core": "^2.1.0",
 		"@opentelemetry/exporter-logs-otlp-grpc": "^0.56.0",

proto/cline/account.proto

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

proto/cline/hooks.proto

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

proto/cline/models.proto

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