Simulate partial ask

.changeset/eight-pants-explode.md

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

.changeset/every-stars-bow.md

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

.changeset/great-planets-train.md

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

.changeset/hip-boxes-sin.md

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

.changeset/kind-paws-win.md

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

.changeset/rotten-olives-build.md

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

.changeset/shaggy-tips-cross.md

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

.changeset/sour-views-attend.md

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

.changeset/tender-breads-own.md

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

.changeset/warm-dogs-dance.md

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

.clinerules/hooks/PostToolUse.example

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

.clinerules/hooks/PreToolUse.example

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

.clinerules/hooks/README.md

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

.clinerules/hooks/TaskCancel.example

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

.clinerules/hooks/TaskResume.example

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

.clinerules/hooks/TaskStart.example

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

.clinerules/hooks/UserPromptSubmit.example

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

.clinerules/network.md

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

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

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

.clinerules/workflows/extension-release.md

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

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

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

.github/workflows/publish-nightly.yml

@@ -74,9 +74,10 @@ jobs:
                   CLINE_ENVIRONMENT: production
                   # OpenTelemetry production defaults (can be overridden at runtime)
                   OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: console,otlp
-                  OTEL_METRICS_EXPORTER: console,otlp
+                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
+                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
                   OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
                   OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
                   OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
               run: npm run publish:marketplace:nightly

.github/workflows/publish.yml

@@ -60,11 +60,11 @@ jobs:
 
             - name: Install root dependencies
               if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm install --include=optional
+              run: npm ci --include=optional
 
             - name: Install webview-ui dependencies
               if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm install --include=optional
+              run: cd webview-ui && npm ci --include=optional
 
             - name: Install Publishing Tools
               run: npm install -g @vscode/vsce ovsx
@@ -99,11 +99,12 @@ jobs:
                   ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
                   # OpenTelemetry production defaults (can be overridden at runtime)
                   OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: console,otlp
-                  OTEL_METRICS_EXPORTER: console,otlp
+                  OTEL_LOGS_EXPORTER: ${{ secrets.OTEL_LOGS_EXPORTER }}
+                  OTEL_METRICS_EXPORTER: ${{ secrets.OTEL_METRICS_EXPORTER }}
                   OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
                   OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
                   OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+                  OTEL_METRIC_EXPORT_INTERVAL: ${{ secrets.OTEL_METRIC_EXPORT_INTERVAL }}
               run: |
                   # Required to generate the .vsix
                   vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"

.vscode/launch.json

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

.vscode/tasks.json

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

.vscodeignore

@@ -20,9 +20,6 @@ eslint-rules/**
 .husky/**
 .env
 
-# cli
-cli/**
-
 # Custom
 **/demo.gif
 .nvmrc

CHANGELOG.md

@@ -1,131 +1,12 @@
 # Changelog
 
-## [3.39.0]
-- Add Explain Changes feature
-- Add microwave Stealth model
-- Add Tabbed Model Picker with Recommended and Free tabs 
-- Add support to View remote rules and workflows in the editor 
-- Enable NTC (Native Tool Calling) by default
-- Bug fixes and improvements for LiteLLM provider
-
-## [3.38.3]
-
-- Task export feature now opens the task directory, allowing easy access to the full task files
-- Add Grok 4.1 and Grok Code to XAI provider
-- Enabled native tool calling for Baseten and Kimi K2 models
-- Add thinking level to Gemini 3.0 Pro preview
-- Expanded Hooks functionality
-- Removed Task Timeline from Task Header
-- Bug fix for slash commands
-- Bug fixes for Vertex provider
-- Bug fixes for thinking/reasoning issues across multiple providers when using native tool calling
-- Bug fixes for terminal usage on Windows devices
-
-## [3.38.2]
-
-- Add Claude Opus 4.5
-
-## [3.38.1]
-
-### Fixed
-- Fixed handling of 'signature' field in sanitizeAnthropicContentBlock to properly preserve it when thinking is enabled, as required by Anthropic's API.
-
-## [3.38.0]
-
-### Added
-- Gemini 3 Pro Preview model
-- AquaVoice Avalon model for voice-to-text dictation
-
-### Fixed
-- Automatic context truncation when AWS Bedrock token usage rate limits are exceeded
-- Removed new_task tool from system prompts, updated slash command prompts, and added helper function for native tool calling validation
-
-
-## [3.37.1]
-
-- Comprehensive changes to better support GPT 5.1 - System prompt, tools, deep-planning, focus chain, etc.
-- Add AGENTS.md support
-- feat(models): Add free minimax/mimax-m2 model to the model picker
-
-## [3.37.0]
-
-### Added
-
-- GPT-5.1 with model-specific prompting: tailored system prompts, tool usage, focus chain, and deep-planning optimizations
-- Nous Research provider with Hermes 4 model family and custom system prompts
-- Switched to Aqua Voice's Avalon model in speech to text transcription
-- Added Linux support for speech to text
-- Model-family breakouts for deep-planning prompting, laying groundwork for enhanced slash commands
-- Expanded HTTP proxy support throughout the codebase
-- Improved focus chain prompting for frontier models (Anthropic, OpenAI, Gemini, xAI)
-
-### Fixed
-
-- Duplicate tool results prevention through existence checking
-- XML entity escaping in model content processor
-- Commit message generation in command palette
-- OpenAI Compatible provider temperature parameter type conversion
-
-## Documentation
-
-- Added missing proto generation step in CONTRIBUTING.md
-- New `npm run dev` script for streamlined terminal workflow (fixes #7335)
-
-## [3.36.1]
-
-- fix: remove native tool calling support from Gemini and XAI provider due to invalid tool names issues
-- fix: disable native tool callings for grok code models
-- Add MCP tool usage to GLM
-- Removes reasoning_details content field from Anthropic providers
-
-## [3.36.0]
-
-- Add: Hooks allow you to inject custom logic into Cline's workflow
-- Add: new provider AIhubmix
-- Add: Use http_proxy, https_proxy and no_proxy in JetBrains
-- Fix: Oca Token Refresh logic
-- Fix: issues where assistant message with empty content is added to conversation history
-- Fix: bug where the checkbox shows in the model selector dropdown
-- Fix: Switch from defaultUserAgentProvider to customUserAgent for Bedrock
-- Fix: support for `<think>` tags for better compatibility with open-source models
-- Fix: refinements to the GLM-4.6 system prompt
-
-## [3.35.1]
-
-- Add: Hicap API integration as provider
-- Fix: enable Add Header button in OpenAICompatibleProvider UI
-- Fix: Remove orphaned tool_results after truncation and empty content field issues in native tool call
-- Fix: render model description in markdown
-
-## [3.35.0]
-
-- Add native tool calling support with configurable setting.
-- Auto-approve is now always-on with a redesigned expanding menu. Settings simplified and notifications moved to General Settings.
-- added zai-glm-4.6 as a Cerebras model
-- Created GPT5 family specific system prompt template
-- Fix: show reasoning budget slider to models with valid thinking config
-- Requesty base URL, and API key fixes
-- Delete all Auth Tokens when logging out
-- Support for <think> tags for models that prefer that over <thinking>
-
-## [3.34.1]
-
-- Added support for MiniMax provider with MiniMax-M2 model
-- Remove Cline/code-supernova-1-million model
-- Changes to allow users to manually enter model names (eg. presets) when using OpenRouter
-
-## [3.34.0]
-
-- Cline Teams is now free through 2025 for unlimited users. Includes Jetbrains, RBAC, centralized billing and more.
-- Use the “exacto” versions of GLM-4.6, Kimi-K2, and Qwen3-Coder in the Cline provider for the best balance of cost, speed, accuracy and tool-calling.
-
 ## [3.33.1]
 
 - Fix CLI installation copy text
 
 ## [3.33.0]
 
-- Added Cline CLI (Preview)
+- Added Cline CLI (Preview) 
 - Added Subagent support (Experimental)
 - Added Multi-Root Workspaces support (Enable in feature settings)
 - Add auto-retry with exponential backof for failed API requests

CLAUDE.md

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

CONTRIBUTING.md

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

README.md

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

assets/icons/cline-bot.svg

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

biome.jsonc

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

cli/cmd/cline/main.go

@@ -101,7 +101,10 @@ see the manual page: man cline`,
 				if !isUserReadyToUse(ctx, instanceAddress) {
 					// Create renderer for welcome messages
 					renderer := display.NewRenderer(global.Config.OutputFormat)
-					fmt.Printf("\n%s\n\n", renderer.Dim("Hey there! Looks like you're new here. Let's get you set up"))
+
+					markdown := "## hey there! looks like you're new here. let's get you set up"
+					rendered := renderer.RenderMarkdown(markdown)
+					fmt.Printf("\n%s\n\n", rendered)
 
 					if err := auth.HandleAuthMenuNoArgs(ctx); err != nil {
 						// Check if user cancelled - exit cleanly
@@ -116,7 +119,9 @@ see the manual page: man cline`,
 						return fmt.Errorf("credentials still not configured - please run 'cline auth' to complete setup")
 					}
 
-					fmt.Printf("\n%s\n\n", renderer.Dim("✓ Setup complete, you can now use the Cline CLI"))
+					markdown = "## ✓ setup complete, you can now use the cline cli"
+					rendered = renderer.RenderMarkdown(markdown)
+					fmt.Printf("\n%s\n\n", rendered)
 				}
 			} else {
 				// User specified --address flag, use that
@@ -182,7 +187,6 @@ see the manual page: man cline`,
 	rootCmd.AddCommand(cli.NewVersionCommand())
 	rootCmd.AddCommand(cli.NewAuthCommand())
 	rootCmd.AddCommand(cli.NewLogsCommand())
-	// rootCmd.AddCommand(cli.NewDoctorCommand()) // Disabled for now
 
 	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
 		os.Exit(1)
@@ -327,20 +331,17 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 
 	// Check if data is being piped to stdin
 	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		// Only try to read if there's actually data available
-		if stat.Size() > 0 {
-			stdinBytes, err := io.ReadAll(os.Stdin)
-			if err != nil {
-				return "", fmt.Errorf("failed to read from stdin: %w", err)
-			}
+		stdinBytes, err := io.ReadAll(os.Stdin)
+		if err != nil {
+			return "", fmt.Errorf("failed to read from stdin: %w", err)
+		}
 
-			stdinContent := strings.TrimSpace(string(stdinBytes))
-			if stdinContent != "" {
-				if content.Len() > 0 {
-					content.WriteString(" ")
-				}
-				content.WriteString(stdinContent)
+		stdinContent := strings.TrimSpace(string(stdinBytes))
+		if stdinContent != "" {
+			if content.Len() > 0 {
+				content.WriteString(" ")
 			}
+			content.WriteString(stdinContent)
 		}
 	}
 

cli/go.mod

@@ -8,10 +8,8 @@ require (
 	github.com/charmbracelet/bubbletea v1.3.6
 	github.com/charmbracelet/glamour v0.10.0
 	github.com/charmbracelet/huh v0.7.1-0.20251005153135-a01a1e304532
-	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834
 	github.com/cline/grpc-go v0.0.0
 	github.com/glebarez/go-sqlite v1.22.0
-	github.com/muesli/termenv v0.16.0
 	github.com/spf13/cobra v1.8.0
 	golang.org/x/term v0.32.0
 	google.golang.org/grpc v1.75.0
@@ -26,6 +24,7 @@ require (
 	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/catppuccin/go v0.3.0 // indirect
 	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 // indirect
 	github.com/charmbracelet/x/ansi v0.9.3 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
 	github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
@@ -46,6 +45,7 @@ require (
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/reflow v0.3.0 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect

cli/package.json

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

cli/pkg/cli/auth.go

@@ -6,38 +6,18 @@ import (
 )
 
 func NewAuthCommand() *cobra.Command {
-	cmd := &cobra.Command{
+	return &cobra.Command{
 		Use:   "auth",
-		Short: "Authenticate a provider and configure what model is used",
-		Long: `Authenticate a provider and configure what model is used
+		Short: "Authenticate a provider and configure model used",
+		Long: `Authenticate  a provider and configure model used
 
-Interactive Mode:
-  Run without flags to open an interactive menu where you can:
+This command opens an interactive menu where you can:
   - Sign in to your Cline account
   - Configure other LLM providers (Anthropic, OpenAI, etc.)
   - Select and switch between AI models
-  - Manage provider settings
-
-Quick Setup Mode:
-  Use flags to quickly configure a BYO provider non-interactively:
-  
-  Examples:
-    cline auth --provider openai-native --apikey sk-xxx --modelid gpt-5
-    cline auth -p anthropic -k sk-ant-xxx -m claude-sonnet-4-5-20250929
-    cline auth -p openai-compatible -k xxx -m gpt-4 -b https://api.example.com/v1
-    
-  Supported providers: openai-native, openai, anthropic, gemini, openrouter, xai, cerebras, ollama
-  Note: Bedrock provider requires interactive setup due to complex auth fields`,
+  - Manage provider settings`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return auth.RunAuthFlow(cmd.Context(), args)
 		},
 	}
-
-	// Add flags for quick setup mode
-	cmd.Flags().StringVarP(&auth.QuickProvider, "provider", "p", "", "Provider ID for quick setup (e.g., openai-native, anthropic)")
-	cmd.Flags().StringVarP(&auth.QuickAPIKey, "apikey", "k", "", "API key for the provider")
-	cmd.Flags().StringVarP(&auth.QuickModelID, "modelid", "m", "", "Model ID to configure (e.g., gpt-4o, claude-sonnet-4-5-20250929)")
-	cmd.Flags().StringVarP(&auth.QuickBaseURL, "baseurl", "b", "", "Base URL (optional, only for openai provider)")
-
-	return cmd
 }

cli/pkg/cli/auth/auth_menu.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/display"
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/task"
 	"github.com/cline/grpc-go/cline"
@@ -39,7 +38,7 @@ const (
 //	┃   Change Cline model (only if authenticated)				- hidden if not authenticated
 //	┃   Authenticate with Cline account / Sign out of Cline		- changes based on auth status
 //	┃   Select active provider (Cline or BYO)					- always shown. Used to switch between Cline and BYO providers
-//	┃   Configure BYO API providers								- always shown. Launches provider setup wizard
+//	┃   Configure API provider									- always shown. Launches provider setup wizard
 //	┃   Exit authorization wizard								- always shown. Exits the auth menu
 
 // RunAuthFlow is the entry point for the entire auth flow with instance management
@@ -69,25 +68,18 @@ func RunAuthFlow(ctx context.Context, args []string) error {
 // Main entry point for handling the `cline auth` command
 // HandleAuthCommand routes the auth command based on the number of arguments
 func HandleAuthCommand(ctx context.Context, args []string) error {
-
-	// Check if flags are provided for quick setup
-	if QuickProvider != "" || QuickAPIKey != "" || QuickModelID != "" || QuickBaseURL != "" {
-		if QuickProvider == "" || QuickAPIKey == "" || QuickModelID == "" {
-			return fmt.Errorf("quick setup requires --provider, --apikey, and --modelid flags. Use 'cline auth --help' for more information")
-		}
-		return QuickSetupFromFlags(ctx, QuickProvider, QuickAPIKey, QuickModelID, QuickBaseURL)
-	}
-
 	switch len(args) {
 	case 0:
-		// No args: Show uth wizard
+		// No args: Show menu (ShowAuthMenuNoArgs)
 		return HandleAuthMenuNoArgs(ctx)
-	case 1, 2, 3, 4:
-		fmt.Println("Invalid positional arguments. Correct usage:")
-		fmt.Println("  cline auth --provider <provider> --apikey <key> --modelid <model> --baseurl <optional>")
-		return nil
+	case 1:
+		// One arg: Provider ID only, prompt for API key
+		return QuickAPISetup(args[0], "")
+	case 2:
+		// Two args: Provider ID and API key
+		return QuickAPISetup(args[0], args[1])
 	default:
-		return fmt.Errorf("too many arguments. Use flags for quick setup: --provider, --apikey, --modelid --baseurl(optional)")
+		return fmt.Errorf("quick BYO API setup is currently stubbed - not yet implemented")
 	}
 }
 
@@ -173,34 +165,32 @@ func ShowAuthMenuWithStatus(isClineAuthenticated bool, hasOrganizations bool, cu
 		options = append(options,
 			huh.NewOption("Sign out of Cline", AuthActionClineLogin),
 			huh.NewOption("Select active provider (Cline or BYO)", AuthActionSelectProvider),
-			huh.NewOption("Configure BYO API providers", AuthActionBYOSetup),
+			huh.NewOption("Configure API provider", AuthActionBYOSetup),
 			huh.NewOption("Exit authorization wizard", AuthActionExit),
 		)
 	} else {
 		options = []huh.Option[AuthAction]{
 			huh.NewOption("Authenticate with Cline account", AuthActionClineLogin),
 			huh.NewOption("Select active provider (Cline or BYO)", AuthActionSelectProvider),
-			huh.NewOption("Configure BYO API providers", AuthActionBYOSetup),
+			huh.NewOption("Configure API provider", AuthActionBYOSetup),
 			huh.NewOption("Exit authorization wizard", AuthActionExit),
 		}
 	}
 
 	// Determine menu title based on status
 	var title string
-	renderer := display.NewRenderer(global.Config.OutputFormat)
 
 	// Always show Cline authentication status
 	if isClineAuthenticated {
-		title = fmt.Sprintf("Cline Account: %s Authenticated\n", renderer.Green("✓"))
+		title = "Cline Account: \033[32m✓\033[0m Authenticated\n"
 	} else {
-		title = fmt.Sprintf("Cline Account: %s Not authenticated\n", renderer.Red("✗"))
+		title = "Cline Account: \033[31m✗\033[0m Not authenticated\n"
 	}
 
 	// Show active provider and model if configured (regardless of Cline auth status)
+	// ANSI color codes: Normal intensity = \033[22m, White = \033[37m, Reset = \033[0m
 	if currentProvider != "" && currentModel != "" {
-		title += fmt.Sprintf("Active Provider: %s\nActive Model: %s\n",
-			renderer.White(currentProvider),
-			renderer.White(currentModel))
+		title += fmt.Sprintf("Active Provider: \033[22m\033[37m%s\033[0m\nActive Model: \033[22m\033[37m%s\033[0m\n", currentProvider, currentModel)
 	}
 
 	// Always end with a huh?
@@ -268,6 +258,11 @@ func HandleSelectProvider(ctx context.Context) error {
 		return HandleAuthMenuNoArgs(ctx)
 	}
 
+	if len(providerOptions) == 1 {
+		fmt.Println("Only one provider is configured. Configure another provider to switch between them.")
+		return HandleAuthMenuNoArgs(ctx)
+	}
+
 	providerOptions = append(providerOptions, huh.NewOption("(Cancel)", "cancel"))
 
 	// Show selection menu

cli/pkg/cli/auth/byo_quick_setup.go

@@ -1,247 +1,13 @@
 package auth
 
-import (
-	"context"
-	"fmt"
-	"strings"
+import "fmt"
 
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-)
-
-// Package-level variables for command-line flags
-var (
-	QuickProvider string // Provider ID (e.g., "openai", "anthropic")
-	QuickAPIKey   string // API key for the provider
-	QuickModelID  string // Model ID to configure
-	QuickBaseURL  string // Base URL (optional, for openai compatible only)
-)
-
-// QuickSetupFromFlags performs quick setup using command-line flags
-// Returns error if validation fails or configuration cannot be applied
-func QuickSetupFromFlags(ctx context.Context, provider, apiKey, modelID, baseURL string) error {
-	// Validate all input parameters
-	providerEnum, err := validateQuickSetupInputs(provider, apiKey, modelID, baseURL)
-	if err != nil {
-		return err
-	}
-
-	// Create task manager for state operations
-	manager, err := createTaskManager(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to create task manager: %w", err)
-	}
-
-	// Validate and fetch model information if needed
-	finalModelID, modelInfo, err := validateAndFetchModel(ctx, manager, providerEnum, modelID, apiKey)
-	if err != nil {
-		return fmt.Errorf("model validation failed: %w", err)
-	}
-
-	// For Ollama, baseURL is stored in the API key field
-	finalAPIKey := apiKey
-	finalBaseURL := baseURL
-	if providerEnum == cline.ApiProvider_OLLAMA {
-		if baseURL != "" {
-			finalAPIKey = baseURL
-			finalBaseURL = ""
-		} else if apiKey != "" {
-			// User provided API key for Ollama - treat it as baseURL
-			finalAPIKey = apiKey
-			finalBaseURL = ""
-		} else {
-			// Use default Ollama baseURL
-			finalAPIKey = "http://localhost:11434"
-			finalBaseURL = ""
-		}
-	}
-
-	// Configure the provider using existing AddProviderPartial function
-	if err := AddProviderPartial(ctx, manager, providerEnum, finalModelID, finalAPIKey, finalBaseURL, modelInfo); err != nil {
-		return fmt.Errorf("failed to configure provider: %w", err)
-	}
-
-	// Set the provider as active for both Plan and Act modes
-	if err := UpdateProviderPartial(ctx, manager, providerEnum, ProviderUpdatesPartial{}, true); err != nil {
-		return fmt.Errorf("failed to set provider as active: %w", err)
-	}
-
-	// Mark welcome view as completed
-	if err := markWelcomeViewCompleted(ctx, manager); err != nil {
-		// Non-fatal error, just log it
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] Warning: failed to mark welcome view as completed: %v\n", err)
-		}
-	}
-
-	// Flush pending state changes to disk immediately
-	// This ensures all configuration changes are persisted before the instance terminates
-	if _, err := manager.GetClient().State.FlushPendingState(ctx, &cline.EmptyRequest{}); err != nil {
-		return fmt.Errorf("failed to flush pending state: %w", err)
-	}
-
-	// Success message
-	fmt.Printf("\n✓ Successfully configured %s provider\n", GetProviderDisplayName(providerEnum))
-	fmt.Printf("  Model: %s\n", finalModelID)
-	if providerEnum == cline.ApiProvider_OLLAMA {
-		fmt.Printf("  Base URL: %s\n", finalAPIKey)
-	} else {
-		fmt.Println("  API Key: Configured")
-	}
-	if finalBaseURL != "" {
-		fmt.Printf("  Custom Base URL: %s\n", finalBaseURL)
-	}
-	fmt.Println("\nYou can now use Cline with this provider.")
-	fmt.Println("Run 'cline start' to begin a new task.")
-
-	return nil
-}
-
-// validateQuickSetupInputs validates all input parameters for quick setup
-// Returns the validated provider enum or an error if validation fails
-func validateQuickSetupInputs(provider, apiKey, modelID, baseURL string) (cline.ApiProvider, error) {
-	// Validate required parameters
-	if provider == "" {
-		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("provider is required. Use --provider or -p flag")
-	}
-
-	if strings.TrimSpace(apiKey) == "" && provider != "ollama" {
-		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("API key is required for %s provider. Use --apikey or -k flag", provider)
-	}
-
-	if strings.TrimSpace(modelID) == "" {
-		return cline.ApiProvider_ANTHROPIC, fmt.Errorf("model ID is required. Use --modelid or -m flag")
-	}
-
-	// Validate and map provider string to enum
-	providerEnum, err := validateQuickSetupProvider(provider)
-	if err != nil {
-		return cline.ApiProvider_ANTHROPIC, err
-	}
-
-	// Validate that baseURL is only provided for OpenAI-compatible providers
-	if err := validateBaseURL(baseURL, providerEnum); err != nil {
-		return cline.ApiProvider_ANTHROPIC, err
-	}
-
-	return providerEnum, nil
-}
-
-// validateBaseURL checks if the user's input includes a baseURL for a provider other than OpenAI (compatible)
-// Returns error if baseURL is provided for unsupported providers
-func validateBaseURL(baseURL string, providerEnum cline.ApiProvider) error {
-	if providerEnum != cline.ApiProvider_OPENAI {
-		if baseURL != "" {
-			return fmt.Errorf("base URL is only supported for OpenAI and OpenAI-compatible providers")
-		}
+// QuickAPISetup performs quick provider setup with provider ID and optional API key
+func QuickAPISetup(providerID, apiKey string) error {
+	fmt.Println("Quick BYO API setup is currently stubbed - not yet implemented.")
+	fmt.Printf("Requested provider: %s\n", providerID)
+	if apiKey != "" {
+		fmt.Println("Provided API key:", "<jk redacted>")
 	}
 	return nil
 }
-
-
-// validateQuickSetupProvider validates the provider ID and returns the enum value
-// Returns error if provider is invalid or not supported for quick setup
-func validateQuickSetupProvider(providerID string) (cline.ApiProvider, error) {
-	// Normalize provider ID (trim whitespace, lowercase)
-	normalizedID := strings.TrimSpace(strings.ToLower(providerID))
-
-	// Explicitly block Bedrock
-	if normalizedID == "bedrock" {
-		return cline.ApiProvider_BEDROCK, fmt.Errorf("bedrock provider is not supported for quick setup due to complex authentication requirements. Please use interactive setup: cline auth")
-	}
-
-	// Map provider string to enum using existing function
-	provider, ok := mapProviderStringToEnum(normalizedID)
-	if !ok {
-		// Provider not found - provide helpful error message
-		supportedProviders := []string{
-			"openai-native", "openai", "anthropic", "gemini",
-			"openrouter", "xai", "cerebras", "ollama",
-		}
-		return cline.ApiProvider_ANTHROPIC, fmt.Errorf(
-			"invalid provider '%s'. Supported providers: %s",
-			providerID,
-			strings.Join(supportedProviders, ", "),
-		)
-	}
-
-	// Validate against supported quick setup providers
-	supportedProviders := map[cline.ApiProvider]bool{
-		cline.ApiProvider_OPENAI_NATIVE: true,
-		cline.ApiProvider_OPENAI:        true,
-		cline.ApiProvider_ANTHROPIC:     true,
-		cline.ApiProvider_GEMINI:        true,
-		cline.ApiProvider_OPENROUTER:    true,
-		cline.ApiProvider_XAI:           true,
-		cline.ApiProvider_CEREBRAS:      true,
-		cline.ApiProvider_OLLAMA:        true,
-		cline.ApiProvider_NOUSRESEARCH:  true,
-	}
-
-	if !supportedProviders[provider] {
-		return provider, fmt.Errorf(
-			"provider '%s' is not supported for quick setup. Please use interactive setup: cline auth",
-			providerID,
-		)
-	}
-
-	return provider, nil
-}
-
-// validateAndFetchModel validates the model ID or fetches from provider if needed
-// Returns the final model ID and optional model info
-// For providers with static models, validates against the list
-// For providers with dynamic models, fetches the list if possible
-func validateAndFetchModel(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID, apiKey string) (string, interface{}, error) {
-	// Normalize model ID
-	modelID = strings.TrimSpace(modelID)
-	if modelID == "" {
-		return "", nil, fmt.Errorf("model ID cannot be empty")
-	}
-
-	// For most providers, we trust the user's input since we can't easily validate without making API calls
-	// The actual validation will happen when the model is used
-	switch provider {
-	case cline.ApiProvider_OPENROUTER:
-		// OpenRouter supports model info fetching, but it requires an API call
-		// For quick setup, we'll trust the user's input and return nil for model info
-		// The actual model info will be fetched when needed
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] OpenRouter model ID: %s (will be validated on first use)\n", modelID)
-		}
-		return modelID, nil, nil
-
-	case cline.ApiProvider_OLLAMA:
-		// Ollama models can be validated by fetching the list, but this requires the server to be running
-		// For quick setup, we'll trust the user's input
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] Ollama model ID: %s (will be validated when server is accessible)\n", modelID)
-		}
-		return modelID, nil, nil
-
-	default:
-		// For other providers (Anthropic, OpenAI, Gemini, XAI, Cerebras), trust user input
-		// Model validation will occur when the model is actually used
-		if global.Config.Verbose {
-			fmt.Printf("[DEBUG] %s model ID: %s (will be validated on first use)\n", GetProviderDisplayName(provider), modelID)
-		}
-		return modelID, nil, nil
-	}
-}
-
-// markWelcomeViewCompleted marks the welcome view as completed in the state
-// This prevents the welcome view from showing up after quick setup
-func markWelcomeViewCompleted(ctx context.Context, manager *task.Manager) error {
-	// Use the State service to update the welcome view flag
-	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
-	if err != nil {
-		return fmt.Errorf("failed to mark welcome view as completed: %w", err)
-	}
-
-	if global.Config.Verbose {
-		fmt.Println("[DEBUG] Marked welcome view as completed")
-	}
-
-	return nil
-}

cli/pkg/cli/auth/models_byo.go

@@ -0,0 +1 @@
+package auth

cli/pkg/cli/auth/models_list_fetch.go

@@ -14,33 +14,13 @@ import (
 
 // FetchOpenRouterModels fetches available OpenRouter models from Cline Core
 func FetchOpenRouterModels(ctx context.Context, manager *task.Manager) (map[string]*cline.OpenRouterModelInfo, error) {
-	resp, err := manager.GetClient().Models.RefreshOpenRouterModelsRpc(ctx, &cline.EmptyRequest{})
+	resp, err := manager.GetClient().Models.RefreshOpenRouterModels(ctx, &cline.EmptyRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch OpenRouter models: %w", err)
 	}
 	return resp.Models, nil
 }
 
-// FetchOcaModels fetches available Oca models from Cline Core
-func FetchOcaModels(ctx context.Context, manager *task.Manager) (map[string]*cline.OcaModelInfo, error) {
-	resp, err := manager.GetClient().Models.RefreshOcaModels(ctx, &cline.StringRequest{})
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch Oca models: %w", err)
-	}
-	return resp.Models, nil
-}
-
-// ConvertOpenRouterModelsToInterface converts OpenRouter model map to generic interface map.
-// This allows OpenRouter and Cline models to be used with the generic fetching utilities.
-func ConvertOpenRouterModelsToInterface(models map[string]*cline.OpenRouterModelInfo) map[string]interface{} {
-	result := make(map[string]interface{}, len(models))
-	for k, v := range models {
-		result[k] = v
-	}
-	return result
-}
-
-
 // FetchOpenAiModels fetches available OpenAI models from Cline Core
 // Takes the API key and returns a list of model IDs
 func FetchOpenAiModels(ctx context.Context, manager *task.Manager, baseURL, apiKey string) ([]string, error) {
@@ -120,9 +100,9 @@ func ConvertModelsMapToSlice(models map[string]interface{}) []string {
 	return result
 }
 
-// ConvertOcaModelsToInterface converts Oca model map to generic interface map.
-// This allows Oca and Cline models to be used with the generic fetching utilities.
-func ConvertOcaModelsToInterface(models map[string]*cline.OcaModelInfo) map[string]interface{} {
+// ConvertOpenRouterModelsToInterface converts OpenRouter model map to generic interface map.
+// This allows OpenRouter and Cline models to be used with the generic fetching utilities.
+func ConvertOpenRouterModelsToInterface(models map[string]*cline.OpenRouterModelInfo) map[string]interface{} {
 	result := make(map[string]interface{}, len(models))
 	for k, v := range models {
 		result[k] = v

cli/pkg/cli/auth/providers_byo.go

@@ -18,16 +18,14 @@ type BYOProviderOption struct {
 func GetBYOProviderList() []BYOProviderOption {
 	return []BYOProviderOption{
 		{Name: "Anthropic", Provider: cline.ApiProvider_ANTHROPIC},
-		{Name: "OpenAI Compatible", Provider: cline.ApiProvider_OPENAI},
-		{Name: "OpenAI (Official)", Provider: cline.ApiProvider_OPENAI_NATIVE},
+		{Name: "OpenAI", Provider: cline.ApiProvider_OPENAI},
+		{Name: "OpenAI Native", Provider: cline.ApiProvider_OPENAI_NATIVE},
 		{Name: "OpenRouter", Provider: cline.ApiProvider_OPENROUTER},
 		{Name: "X AI (Grok)", Provider: cline.ApiProvider_XAI},
 		{Name: "AWS Bedrock", Provider: cline.ApiProvider_BEDROCK},
 		{Name: "Google Gemini", Provider: cline.ApiProvider_GEMINI},
 		{Name: "Ollama", Provider: cline.ApiProvider_OLLAMA},
 		{Name: "Cerebras", Provider: cline.ApiProvider_CEREBRAS},
-		{Name: "NousResearch", Provider: cline.ApiProvider_NOUSRESEARCH},
-		{Name: "Oracle Code Assist", Provider: cline.ApiProvider_OCA},
 	}
 }
 
@@ -73,8 +71,6 @@ func SupportsBYOModelFetching(provider cline.ApiProvider) bool {
 		return true
 	case cline.ApiProvider_OLLAMA:
 		return true
-	case cline.ApiProvider_OCA:
-		return true
 	}
 
 	return SupportsStaticModelList(provider)
@@ -86,9 +82,9 @@ func GetBYOProviderPlaceholder(provider cline.ApiProvider) string {
 	case cline.ApiProvider_ANTHROPIC:
 		return "e.g., claude-sonnet-4-5-20250929"
 	case cline.ApiProvider_OPENAI:
-		return "e.g., openai/gpt-oss-120b"
-	case cline.ApiProvider_OPENAI_NATIVE:
 		return "e.g., gpt-5-2025-08-07"
+	case cline.ApiProvider_OPENAI_NATIVE:
+		return "e.g., openai/gpt-oss-120b"
 	case cline.ApiProvider_OPENROUTER:
 		return "e.g., google/gemini-2.0-flash-exp:free"
 	case cline.ApiProvider_XAI:
@@ -101,10 +97,6 @@ func GetBYOProviderPlaceholder(provider cline.ApiProvider) string {
 		return "e.g., qwen3-coder:30b"
 	case cline.ApiProvider_CEREBRAS:
 		return "e.g., gpt-oss-120b"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "e.g., Hermes-4-405B"
-	case cline.ApiProvider_OCA:
-		return "e.g., oca/llama4"
 	default:
 		return "Enter model ID"
 	}
@@ -135,8 +127,8 @@ func GetBYOAPIKeyFieldConfig(provider cline.ApiProvider) APIKeyFieldConfig {
 }
 
 // PromptForAPIKey prompts the user to enter an API key (or base URL for Ollama).
-// For OpenAI (Compatible) provider, also prompts for an optional base URL.
-func PromptForAPIKey(provider cline.ApiProvider) (string, string, error) {
+// For OpenAI Native provider, also prompts for an optional base URL.
+func PromptForAPIKey(provider cline.ApiProvider) (string, error) {
 	var apiKey string
 	config := GetBYOAPIKeyFieldConfig(provider)
 
@@ -157,11 +149,11 @@ func PromptForAPIKey(provider cline.ApiProvider) (string, string, error) {
 	form := huh.NewForm(huh.NewGroup(apiKeyField))
 
 	if err := form.Run(); err != nil {
-		return "", "", fmt.Errorf("failed to get API key: %w", err)
+		return "", fmt.Errorf("failed to get API key: %w", err)
 	}
 
-	// For OpenAI (Compatible) provider, prompt for base URL
-	if provider == cline.ApiProvider_OPENAI {
+	// For OpenAI Native provider, also prompt for base URL
+	if provider == cline.ApiProvider_OPENAI_NATIVE {
 		var baseURL string
 		baseURLForm := huh.NewForm(
 			huh.NewGroup(
@@ -174,11 +166,12 @@ func PromptForAPIKey(provider cline.ApiProvider) (string, string, error) {
 		)
 
 		if err := baseURLForm.Run(); err != nil {
-			return "", "", fmt.Errorf("failed to get base URL: %w", err)
+			return "", fmt.Errorf("failed to get base URL: %w", err)
 		}
 
-		return apiKey, baseURL, nil
+		// TODO - connect baseURL
+		_ = baseURL
 	}
 
-	return apiKey, "", nil
+	return apiKey, nil
 }

cli/pkg/cli/auth/providers_list.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
-	"time"
 
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/task"
@@ -111,9 +110,6 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 		cline.ApiProvider_GEMINI,
 		cline.ApiProvider_OLLAMA,
 		cline.ApiProvider_CEREBRAS,
-		cline.ApiProvider_NOUSRESEARCH,
-		cline.ApiProvider_OCA,
-		cline.ApiProvider_HICAP,
 	}
 
 	// Check each provider to see if it's ready to use
@@ -124,23 +120,16 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 			continue
 		}
 
+		// Check if this provider has an API key
+		hasAPIKey := checkAPIKeyExists(r.apiConfig, provider)
+		if !hasAPIKey {
+			continue
+		}
+
 		// Check if this provider has a model configured
 		modelID := getProviderSpecificModelID(r.apiConfig, "plan", provider)
-
-		// Determine if credentials exist
-		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)
-			if state == nil || state.User == nil {
-				continue
-			}
-		} else {
-			// Provider is not ready unless it has credentials AND a model configured
-			if !hasCreds || modelID == "" {
-				continue
-			}
+		if modelID == "" {
+			continue
 		}
 
 		// Get base URL for Ollama
@@ -156,7 +145,7 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 			Mode:      "Ready",
 			Provider:  provider,
 			ModelID:   modelID,
-			HasAPIKey: checkAPIKeyExists(r.apiConfig, provider),
+			HasAPIKey: hasAPIKey,
 			BaseURL:   baseURL,
 		})
 		seenProviders[provider] = true
@@ -214,15 +203,13 @@ func extractProviderFromState(stateData map[string]interface{}, mode string) *Pr
 // mapProviderStringToEnum converts provider string from state to ApiProvider enum
 // Returns (provider, ok) where ok is false if the provider is unknown
 func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
-	normalizedStr := strings.ToLower(providerStr)
-	
 	// Map string values to enum values
-	switch normalizedStr {
+	switch providerStr {
 	case "anthropic":
 		return cline.ApiProvider_ANTHROPIC, true
-	case "openai", "openai-compatible": // internal name is 'openai', but this is actually the openai-compatible provider
+	case "openai":
 		return cline.ApiProvider_OPENAI, true
-	case "openai-native": // This is the native, official Open AI provider
+	case "openai-native":
 		return cline.ApiProvider_OPENAI_NATIVE, true
 	case "openrouter":
 		return cline.ApiProvider_OPENROUTER, true
@@ -238,12 +225,6 @@ func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
 		return cline.ApiProvider_CEREBRAS, true
 	case "cline":
 		return cline.ApiProvider_CLINE, true
-	case "oca":
-		return cline.ApiProvider_OCA, true
-	case "hicap":
-		return cline.ApiProvider_HICAP, true
-	case "nousResearch":
-		return cline.ApiProvider_NOUSRESEARCH, true
 	default:
 		return cline.ApiProvider_ANTHROPIC, false // Return 0 value with false
 	}
@@ -256,7 +237,7 @@ func GetProviderIDForEnum(provider cline.ApiProvider) string {
 	case cline.ApiProvider_ANTHROPIC:
 		return "anthropic"
 	case cline.ApiProvider_OPENAI:
-		return "openai-compatible"
+		return "openai"
 	case cline.ApiProvider_OPENAI_NATIVE:
 		return "openai-native"
 	case cline.ApiProvider_OPENROUTER:
@@ -273,12 +254,6 @@ func GetProviderIDForEnum(provider cline.ApiProvider) string {
 		return "cerebras"
 	case cline.ApiProvider_CLINE:
 		return "cline"
-	case cline.ApiProvider_OCA:
-		return "oca"
-	case cline.ApiProvider_HICAP:
-		return "hicap"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "nousResearch"
 	default:
 		return ""
 	}
@@ -337,9 +312,9 @@ func GetProviderDisplayName(provider cline.ApiProvider) string {
 	case cline.ApiProvider_ANTHROPIC:
 		return "Anthropic"
 	case cline.ApiProvider_OPENAI:
-		return "OpenAI Compatible"
+		return "OpenAI"
 	case cline.ApiProvider_OPENAI_NATIVE:
-		return "OpenAI (Official)"
+		return "OpenAI Native"
 	case cline.ApiProvider_OPENROUTER:
 		return "OpenRouter"
 	case cline.ApiProvider_XAI:
@@ -354,12 +329,6 @@ func GetProviderDisplayName(provider cline.ApiProvider) string {
 		return "Cerebras"
 	case cline.ApiProvider_CLINE:
 		return "Cline (Official)"
-	case cline.ApiProvider_OCA:
-		return "Oracle Code Assist"
-	case cline.ApiProvider_HICAP:
-		return "Hicap"
-	case cline.ApiProvider_NOUSRESEARCH:
-		return "NousResearch"
 	default:
 		return "Unknown"
 	}
@@ -409,7 +378,7 @@ func FormatProviderList(result *ProviderListResult) string {
 				} else {
 					output.WriteString("    Base URL: (default)\n")
 				}
-			} else if display.Provider == cline.ApiProvider_CLINE || display.Provider == cline.ApiProvider_OCA {
+			} else if display.Provider == cline.ApiProvider_CLINE {
 				output.WriteString("    Status:   Authenticated\n")
 			} else {
 				output.WriteString("    API Key:  Configured\n")
@@ -461,12 +430,6 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 		verboseLog("[DEBUG] Cline provider is authenticated")
 	}
 
-	// Check OCA provider via global auth subscription (state presence)
-	if state, _ := GetLatestOCAState(context.Background(), 2*time.Second); state != nil && state.User != nil {
-		configuredProviders = append(configuredProviders, cline.ApiProvider_OCA)
-		verboseLog("[DEBUG] OCA provider has active auth state")
-	}
-
 	// Check each BYO provider for API key presence
 	providersToCheck := []struct {
 		provider cline.ApiProvider
@@ -481,8 +444,6 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 		{cline.ApiProvider_GEMINI, "geminiApiKey"},
 		{cline.ApiProvider_OLLAMA, "ollamaBaseUrl"}, // Ollama uses baseUrl instead of API key
 		{cline.ApiProvider_CEREBRAS, "cerebrasApiKey"},
-		{cline.ApiProvider_HICAP, "hicapApiKey"},
-		{cline.ApiProvider_NOUSRESEARCH, "nousResearchApiKey"},
 	}
 
 	for _, providerCheck := range providersToCheck {
@@ -498,7 +459,6 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 		}
 	}
 
-
 	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

@@ -12,7 +12,7 @@ import (
 )
 
 // updateApiConfigurationPartial is a helper that calls the gRPC method with optional verbose logging.
-// This replaces the Manager.updateApiConfigurationPartial method to keep auth-specific code in the auth package.
+// This replaces the Manager.UpdateApiConfigurationPartial method to keep auth-specific code in the auth package.
 func updateApiConfigurationPartial(ctx context.Context, manager *task.Manager, request *cline.UpdateApiConfigurationPartialRequest) error {
 	if global.Config.Verbose {
 		fmt.Println("[DEBUG] Updating API configuration (partial)")
@@ -46,7 +46,6 @@ func updateApiConfigurationPartial(ctx context.Context, manager *task.Manager, r
 // ProviderFields defines all the field names associated with a specific provider
 type ProviderFields struct {
 	APIKeyField            string // API key field name (e.g., "apiKey", "openAiApiKey")
-	BaseURLField           string // Base URL field name (optional, empty if not applicable)
 	PlanModeModelIDField   string // Plan mode model ID field (e.g., "planModeApiModelId")
 	ActModeModelIDField    string // Act mode model ID field (e.g., "actModeApiModelId")
 	PlanModeModelInfoField string // Plan mode model info field (optional, empty if not applicable)
@@ -69,7 +68,6 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 	case cline.ApiProvider_OPENAI:
 		return ProviderFields{
 			APIKeyField:                          "openAiApiKey",
-			BaseURLField:                         "openAiBaseUrl",
 			PlanModeModelIDField:                 "planModeApiModelId",
 			ActModeModelIDField:                  "actModeApiModelId",
 			PlanModeProviderSpecificModelIDField: "planModeOpenAiModelId",
@@ -144,34 +142,6 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 			ActModeProviderSpecificModelIDField:  "actModeOpenRouterModelId",
 		}, nil
 
-	case cline.ApiProvider_OCA:
-		return ProviderFields{
-			APIKeyField:                          "ocaApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeModelInfoField:               "planModeOcaModelInfo",
-			ActModeModelInfoField:                "actModeOcaModelInfo",
-			PlanModeProviderSpecificModelIDField: "planModeOcaModelId",
-			ActModeProviderSpecificModelIDField:  "actModeOcaModelId",
-		}, nil
-	case cline.ApiProvider_HICAP:
-		return ProviderFields{
-			APIKeyField:                          "hicapApiKey",
-			PlanModeModelInfoField:               "planModeHicapModelInfo",
-			ActModeModelInfoField:                "actModeHicapModelInfo",
-			PlanModeProviderSpecificModelIDField: "planModeHicapModelId",
-			ActModeProviderSpecificModelIDField:  "actModeHicapModelId",
-		}, nil
-
-	case cline.ApiProvider_NOUSRESEARCH:
-		return ProviderFields{
-			APIKeyField:                          "nousResearchApiKey",
-			PlanModeModelIDField:                 "planModeApiModelId",
-			ActModeModelIDField:                  "actModeApiModelId",
-			PlanModeProviderSpecificModelIDField: "planModeNousResearchModelId",
-			ActModeProviderSpecificModelIDField:  "actModeNousResearchModelId",
-		}, nil
-
 	default:
 		return ProviderFields{}, fmt.Errorf("unsupported provider: %v", provider)
 	}
@@ -180,12 +150,9 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 // ProviderUpdatesPartial defines optional fields for partial provider updates
 // Uses pointers to distinguish between "not provided" and "set to empty"
 type ProviderUpdatesPartial struct {
-	ModelID      *string     // New model ID (optional)
-	APIKey       *string     // New API key (optional)
-	ModelInfo    interface{} // New model info (optional, provider-specific)
-	BaseURL      *string     // New base URL (optional, e.g., for OCA, Ollama)
-	RefreshToken *string     // New refresh token (optional, e.g., for OCA)
-	Mode         *string     // New mode (optional, e.g., "internal" or "external" for OCA)
+	ModelID   *string     // New model ID (optional)
+	APIKey    *string     // New API key (optional)
+	ModelInfo interface{} // New model info (optional, provider-specific)
 }
 
 // GetModelIDFieldName returns the appropriate model ID field name for a provider and mode.
@@ -215,7 +182,7 @@ func GetModelIDFieldName(provider cline.ApiProvider, mode string) (string, error
 // buildProviderFieldMask builds a list of camelCase field paths for the field mask.
 // When includeProviderEnums is true, the provider enum fields are included (for setting active provider).
 // When false, only the data fields are included (for configuring without activating).
-func buildProviderFieldMask(fields ProviderFields, includeAPIKey bool, includeModelID bool, includeModelInfo bool, includeBaseURL bool, includeProviderEnums bool) []string {
+func buildProviderFieldMask(fields ProviderFields, includeAPIKey bool, includeModelID bool, includeModelInfo bool, includeProviderEnums bool) []string {
 	var fieldPaths []string
 
 	// Include provider enums if requested (used when setting active provider)
@@ -232,11 +199,6 @@ func buildProviderFieldMask(fields ProviderFields, includeAPIKey bool, includeMo
 		}
 	}
 
-	// Add base URL field if requested and applicable
-	if includeBaseURL && fields.BaseURLField != "" {
-		fieldPaths = append(fieldPaths, fields.BaseURLField)
-	}
-
 	// Add model ID fields if requested
 	if includeModelID {
 		// Only include provider-specific fields if they exist, otherwise use generic fields
@@ -283,12 +245,6 @@ func setAPIKeyField(apiConfig *cline.ModelsApiConfiguration, fieldName string, v
 		apiConfig.CerebrasApiKey = value
 	case "clineApiKey":
 		apiConfig.ClineApiKey = value
-	case "ocaApiKey":
-		apiConfig.OcaApiKey = value
-	case "hicapApiKey":
-		apiConfig.HicapApiKey = value
-	case "nousResearchApiKey":
-		apiConfig.NousResearchApiKey = value
 	}
 }
 
@@ -307,20 +263,11 @@ func setProviderSpecificModelID(apiConfig *cline.ModelsApiConfiguration, fieldNa
 	case "planModeAwsBedrockCustomModelBaseId":
 		apiConfig.PlanModeAwsBedrockCustomModelBaseId = value
 		apiConfig.ActModeAwsBedrockCustomModelBaseId = value
-	case "planModeOcaModelId":
-		apiConfig.PlanModeOcaModelId = value
-		apiConfig.ActModeOcaModelId = value
-	case "planModeHicapModelId":
-		apiConfig.PlanModeHicapModelId = value
-		apiConfig.ActModeHicapModelId = value
-	case "planModeNousResearchModelId":
-		apiConfig.PlanModeNousResearchModelId = value
-		apiConfig.ActModeNousResearchModelId = value
 	}
 }
 
 // AddProviderPartial configures a new provider with all necessary fields using partial updates.
-func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID string, apiKey string, baseURL string, modelInfo interface{}) error {
+func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID string, apiKey string, modelInfo interface{}) error {
 	// Get field mapping for this provider
 	fields, err := GetProviderFields(provider)
 	if err != nil {
@@ -335,13 +282,6 @@ func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cli
 		setAPIKeyField(apiConfig, fields.APIKeyField, proto.String(apiKey))
 	}
 
-	// Set base URL field if provided and applicable
-	includeBaseURL := false
-	if baseURL != "" && fields.BaseURLField != "" {
-		setBaseURLField(apiConfig, fields.BaseURLField, proto.String(baseURL))
-		includeBaseURL = true
-	}
-
 	// Set model ID fields
 	apiConfig.PlanModeApiModelId = proto.String(modelID)
 	apiConfig.ActModeApiModelId = proto.String(modelID)
@@ -361,7 +301,7 @@ func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cli
 
 	// Build field mask including all fields we're setting (without provider enums)
 	includeModelInfo := fields.PlanModeModelInfoField != "" && modelInfo != nil
-	fieldPaths := buildProviderFieldMask(fields, true, true, includeModelInfo, includeBaseURL, false)
+	fieldPaths := buildProviderFieldMask(fields, true, true, includeModelInfo, false)
 
 	// Create field mask
 	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
@@ -428,7 +368,7 @@ func UpdateProviderPartial(ctx context.Context, manager *task.Manager, provider
 	}
 
 	// Build field mask for only the fields being updated
-	fieldPaths := buildProviderFieldMask(fields, includeAPIKey, includeModelID, includeModelInfo, false, setAsActive)
+	fieldPaths := buildProviderFieldMask(fields, includeAPIKey, includeModelID, includeModelInfo, setAsActive)
 
 	// Create field mask
 	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
@@ -481,46 +421,6 @@ func RemoveProviderPartial(ctx context.Context, manager *task.Manager, provider
 	return nil
 }
 
-// setBaseURLField sets the appropriate base URL field in the config based on the field name
-func setBaseURLField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
-	switch fieldName {
-	case "ocaBaseUrl":
-		apiConfig.OcaBaseUrl = value
-	case "ollamaBaseUrl":
-		apiConfig.OllamaBaseUrl = value
-	case "openAiBaseUrl":
-		apiConfig.OpenAiBaseUrl = value
-	case "geminiBaseUrl":
-		apiConfig.GeminiBaseUrl = value
-	case "liteLlmBaseUrl":
-		apiConfig.LiteLlmBaseUrl = value
-	case "anthropicBaseUrl":
-		apiConfig.AnthropicBaseUrl = value
-	case "requestyBaseUrl":
-		apiConfig.RequestyBaseUrl = value
-	case "lmStudioBaseUrl":
-		apiConfig.LmStudioBaseUrl = value
-	case "oca":
-		apiConfig.OcaBaseUrl = value
-	}
-}
-
-// setRefreshTokenField sets the appropriate refresh token field in the config
-func setRefreshTokenField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
-	switch fieldName {
-	case "ocaRefreshToken":
-		apiConfig.OcaRefreshToken = value
-	}
-}
-
-// setModeField sets the appropriate mode field in the config
-func setModeField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
-	switch fieldName {
-	case "ocaMode":
-		apiConfig.OcaMode = value
-	}
-}
-
 // BedrockOptionalFields holds optional configuration fields for AWS Bedrock
 type BedrockOptionalFields struct {
 	SessionToken            *string // Optional: AWS session token for temporary credentials
@@ -534,12 +434,6 @@ type BedrockOptionalFields struct {
 	Endpoint                *string // Optional: Custom endpoint URL
 }
 
-// OcaOptionalFields holds optional configuration fields for Oracle Code Assist
-type OcaOptionalFields struct {
-	BaseURL *string // Optional: Base URL
-	Mode    *string // Optional: Mode ("internal" or "external")
-}
-
 // setBedrockOptionalFields sets optional Bedrock-specific fields in the API configuration
 func setBedrockOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *BedrockOptionalFields) {
 	if fields == nil {
@@ -575,20 +469,6 @@ func setBedrockOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *B
 	}
 }
 
-// setOcaOptionalFields sets optional Oca-specific fields in the API configuration
-func setOcaOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *OcaOptionalFields) {
-	if fields == nil {
-		return
-	}
-
-	if fields.Mode != nil {
-		apiConfig.OcaMode = fields.Mode
-	}
-	if fields.BaseURL != nil {
-		apiConfig.OcaBaseUrl = fields.BaseURL
-	}
-}
-
 // buildBedrockOptionalFieldMask builds field mask paths for Bedrock optional fields that have values
 func buildBedrockOptionalFieldMask(fields *BedrockOptionalFields) []string {
 	if fields == nil {
@@ -627,21 +507,3 @@ func buildBedrockOptionalFieldMask(fields *BedrockOptionalFields) []string {
 
 	return fieldPaths
 }
-
-// buildOcaOptionalFieldMask builds field mask paths for Bedrock optional fields that have values
-func buildOcaOptionalFieldMask(fields *OcaOptionalFields) []string {
-	if fields == nil {
-		return nil
-	}
-
-	var fieldPaths []string
-
-	if fields.Mode != nil {
-		fieldPaths = append(fieldPaths, "ocaMode")
-	}
-	if fields.BaseURL != nil {
-		fieldPaths = append(fieldPaths, "ocaBaseUrl")
-	}
-
-	return fieldPaths
-}

cli/pkg/cli/auth/wizard_byo.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
-	"time"
 
 	"github.com/charmbracelet/huh"
 	"github.com/cline/cli/pkg/cli/global"
@@ -41,7 +40,7 @@ func (pw *ProviderWizard) showMainMenu() (string, error) {
 			huh.NewSelect[string]().
 				Title("What would you like to do?").
 				Options(
-					huh.NewOption("Add or change an API provider", "add"),
+					huh.NewOption("Configure a new provider", "add"),
 					huh.NewOption("Change model for API provider", "change-model"),
 					huh.NewOption("Remove a provider", "remove"),
 					huh.NewOption("List configured providers", "list"),
@@ -108,13 +107,8 @@ func (pw *ProviderWizard) handleAddProvider() error {
 		return pw.handleAddBedrockProvider()
 	}
 
-	// Step 2b: Special handling for OCA provider
-	if provider == cline.ApiProvider_OCA {
-		return pw.handleAddOcaProvider()
-	}
-
 	// Step 3: Get API key first (for non-Bedrock providers)
-	apiKey, baseURL, err := PromptForAPIKey(provider)
+	apiKey, err := PromptForAPIKey(provider)
 	if err != nil {
 		return fmt.Errorf("failed to get API key: %w", err)
 	}
@@ -126,7 +120,7 @@ func (pw *ProviderWizard) handleAddProvider() error {
 	}
 
 	// Step 5: Apply configuration using AddProviderPartial
-	if err := AddProviderPartial(pw.ctx, pw.manager, provider, modelID, apiKey, baseURL, modelInfo); err != nil {
+	if err := AddProviderPartial(pw.ctx, pw.manager, provider, modelID, apiKey, modelInfo); err != nil {
 		return fmt.Errorf("failed to save configuration: %w", err)
 	}
 
@@ -168,51 +162,6 @@ func (pw *ProviderWizard) handleAddBedrockProvider() error {
 	return nil
 }
 
-// handleAddOcaProvider handles adding Oracle Code Assist provider with optional settings and auth
-func (pw *ProviderWizard) handleAddOcaProvider() error {
-	// Step 1: Get OCA configuration (base URL and mode)
-	config, err := PromptForOcaConfig(pw.ctx, pw.manager)
-	if err != nil {
-		if strings.Contains(err.Error(), "user aborted") || strings.Contains(err.Error(), "cancelled") {
-			return nil
-		}
-		return fmt.Errorf("failed to get OCA configuration: %w", err)
-	}
-
-	// Apply OCA configuration (base URL and mode)
-	if err := ApplyOcaConfig(pw.ctx, pw.manager, config); err != nil {
-		return fmt.Errorf("failed to save OCA configuration: %w", err)
-	}
-
-	// Step 2: Ensure OCA authentication
-	if err := ensureOcaAuthenticated(pw.ctx); err != nil {
-		return fmt.Errorf("failed to authenticate with OCA: %w", err)
-	}
-
-	// Step 3: Select model
-	modelID, _, err := pw.selectModel(cline.ApiProvider_OCA, "")
-	if err != nil {
-		return fmt.Errorf("model selection failed: %w", err)
-	}
-
-	// Step 4: Apply the OCA model configuration and set as active
-	updates := ProviderUpdatesPartial{
-		ModelID:   &modelID,
-		ModelInfo: nil,
-	}
-
-	if err := UpdateProviderPartial(pw.ctx, pw.manager, cline.ApiProvider_OCA, updates, true); err != nil {
-		return fmt.Errorf("failed to save OCA configuration: %w", err)
-	}
-
-	if err := setWelcomeViewCompleted(pw.ctx, pw.manager); err != nil {
-		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
-	}
-
-	fmt.Println("✓ OCA provider configured successfully!")
-	return nil
-}
-
 // handleListProviders retrieves and displays configured providers
 func (pw *ProviderWizard) handleListProviders() error {
 	result, err := GetProviderConfigurations(pw.ctx, pw.manager)
@@ -310,15 +259,6 @@ func (pw *ProviderWizard) fetchModelsForProvider(provider cline.ApiProvider, api
 		}
 		// Ollama returns just model IDs without additional info, so modelInfo map is nil
 		return modelIDs, nil, nil
-
-	case cline.ApiProvider_OCA:
-		// OCA supports dynamic model fetching
-		models, err := FetchOcaModels(pw.ctx, pw.manager)
-		if err != nil {
-			return nil, nil, err
-		}
-		interfaceMap := ConvertOcaModelsToInterface(models)
-		return ConvertModelsMapToSlice(interfaceMap), interfaceMap, nil
 	}
 
 	// Fall back to static models for providers that don't support dynamic fetching
@@ -517,7 +457,7 @@ func (pw *ProviderWizard) applyModelChange(provider cline.ApiProvider, modelID s
 		ModelInfo: modelInfo,
 	}
 
-	return UpdateProviderPartial(pw.ctx, pw.manager, provider, updates, true)
+	return UpdateProviderPartial(pw.ctx, pw.manager, provider, updates, false)
 }
 
 // SwitchToBYOProvider switches to a BYO provider that's already configured.
@@ -585,17 +525,8 @@ func getProviderModelIDFromState(stateData map[string]interface{}, provider clin
 	return ""
 }
 
- // getProviderAPIKeyFromState retrieves the API key for a specific provider from state
+// getProviderAPIKeyFromState retrieves the API key for a specific provider from state
 func getProviderAPIKeyFromState(stateData map[string]interface{}, provider cline.ApiProvider) string {
-	// OCA uses account authentication, not API keys. Consider it "present" if authenticated.
-	if provider == cline.ApiProvider_OCA {
-		if state, _ := GetLatestOCAState(context.TODO(), 2 * time.Second); state != nil && state.User != nil {
-			// Return a sentinel non-empty string so upstream checks pass.
-			return "OCA_AUTH_VERIFIED"
-		}
-		return ""
-	}
-
 	fields, err := GetProviderFields(provider)
 	if err != nil {
 		return ""
@@ -725,16 +656,7 @@ func (pw *ProviderWizard) handleRemoveProvider() error {
 		return nil
 	}
 
-	// Step 7: If removing OCA, sign out first
-	if selectedProvider.Provider == cline.ApiProvider_OCA {
-		if err := signOutOca(pw.ctx); err != nil {
-			fmt.Printf("Warning: Failed to sign out of OCA: %v\n", err)
-		} else {
-			fmt.Println("Signed out of OCA.")
-		}
-	}
-
-	// Step 8: Clear the API key for the selected provider
+	// Step 7: Clear the API key for the selected provider
 	if err := pw.clearProviderAPIKey(selectedProvider.Provider); err != nil {
 		return fmt.Errorf("failed to remove provider: %w", err)
 	}
@@ -748,16 +670,6 @@ func (pw *ProviderWizard) clearProviderAPIKey(provider cline.ApiProvider) error
 	return RemoveProviderPartial(pw.ctx, pw.manager, provider)
 }
 
-
-func signOutOca(ctx context.Context) error {
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return err
-	}
-	_, err = client.Ocaaccount.OcaAccountLogoutClicked(ctx, &cline.EmptyRequest{})
-	return err
-}
-
 func setWelcomeViewCompleted(ctx context.Context, manager *task.Manager) error {
 	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
 	return err

cli/pkg/cli/auth/wizard_byo_oca.go

@@ -1,366 +0,0 @@
-package auth
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/charmbracelet/huh"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/task"
-	"github.com/cline/grpc-go/cline"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/fieldmaskpb"
-)
-
-// OcaConfig holds Oracle Code Assist (OCA) configuration fields
-type OcaConfig struct {
-	BaseURL string
-	Mode    string
-}
-
-// PromptForOcaConfig displays a form for OCA configuration (base URL and mode)
-func PromptForOcaConfig(ctx context.Context, manager *task.Manager) (*OcaConfig, error) {
-	config := &OcaConfig{}
-	var mode string
-
-	// Collect optional settings
-	configForm := huh.NewForm(
-		huh.NewGroup(
-			huh.NewInput().
-				Title("Base URL").
-				Value(&config.BaseURL).
-				Description("Leave empty to use default Base URL"),
-
-			huh.NewSelect[string]().
-				Title("Choose OCA mode (used for authentication)").
-				Description("Select 'Internal' to use Cline's internal OCA, or 'External' for your own OCA instance").
-				Options(
-					huh.NewOption("Internal", "internal"),
-					huh.NewOption("External", "external"),
-				).
-				Value(&mode),
-		),
-	)
-
-	if err := configForm.Run(); err != nil {
-		return nil, fmt.Errorf("failed to get OCA configuration: %w", err)
-	}
-
-	// Trim whitespace from string fields
-	config.BaseURL = strings.TrimSpace(config.BaseURL)
-	config.Mode = strings.TrimSpace(mode)
-
-	return config, nil
-}
-
-// ApplyOcaConfig applies OCA configuration using partial updates
-func ApplyOcaConfig(ctx context.Context, manager *task.Manager, config *OcaConfig) error {
-	// Build the API configuration with all OCA fields
-	apiConfig := &cline.ModelsApiConfiguration{}
-
-	// Set profile authentication fields (always required)
-	optionalFields := &OcaOptionalFields{}
-
-	// Set profile name (can be empty for default profile)
-	if config.BaseURL != "" {
-		optionalFields.BaseURL = proto.String(config.BaseURL)
-	}
-
-	// Set optional fields if provided
-	if config.Mode != "" {
-		optionalFields.Mode = proto.String(config.Mode)
-	}
-
-	// Apply all fields to the config
-	setOcaOptionalFields(apiConfig, optionalFields)
-
-	// Add profile authentication field paths
-	optionalPaths := buildOcaOptionalFieldMask(optionalFields)
-
-	// Create field mask
-	fieldMask := &fieldmaskpb.FieldMask{Paths: optionalPaths}
-
-	// Apply the partial update
-	request := &cline.UpdateApiConfigurationPartialRequest{
-		ApiConfiguration: apiConfig,
-		UpdateMask:       fieldMask,
-	}
-
-	if err := updateApiConfigurationPartial(ctx, manager, request); err != nil {
-		return fmt.Errorf("failed to apply OCA configuration: %w", err)
-	}
-
-	return nil
-}
-
-// ===========================
-// OCA Auth Listener Singleton
-// ===========================
-
-type ocaAuthStream interface {
-	Recv() (*cline.OcaAuthState, error)
-}
-
-// OcaAuthStatusListener manages subscription to OCA auth status updates
-type OcaAuthStatusListener struct {
-	stream        ocaAuthStream
-	updatesCh     chan *cline.OcaAuthState
-	errCh         chan error
-	ctx           context.Context
-	cancel        context.CancelFunc
-	mu            sync.RWMutex
-	lastState     *cline.OcaAuthState
-	firstEventCh  chan struct{}
-	firstEventOnce sync.Once
-}
-
-// NewOcaAuthStatusListener creates a new OCA auth status listener
-func NewOcaAuthStatusListener(parentCtx context.Context) (*OcaAuthStatusListener, error) {
-	client, err := global.GetDefaultClient(parentCtx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get client: %w", err)
-	}
-
-	// Keep the listener alive independently of short-lived caller contexts
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// Subscribe to OCA auth status updates
-	stream, err := client.Ocaaccount.OcaSubscribeToAuthStatusUpdate(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		cancel()
-		return nil, fmt.Errorf("failed to subscribe to OCA auth updates: %w", err)
-	}
-
-	return &OcaAuthStatusListener{
-		stream:       stream,
-		updatesCh:    make(chan *cline.OcaAuthState, 10),
-		errCh:        make(chan error, 1),
-		ctx:          ctx,
-		cancel:       cancel,
-		firstEventCh: make(chan struct{}),
-	}, nil
-}
-
-// Start begins listening to the auth status update stream
-func (l *OcaAuthStatusListener) Start() error {
-	go l.readStream()
-	return nil
-}
-
-func (l *OcaAuthStatusListener) readStream() {
-	defer close(l.updatesCh)
-	defer close(l.errCh)
-
-	for {
-		select {
-		case <-l.ctx.Done():
-			return
-		default:
-			state, err := l.stream.Recv()
-			if err != nil {
-				// Propagate error and exit
-				if err == io.EOF {
-					// Treat as error to notify waiters
-					err = fmt.Errorf("OCA auth status stream closed")
-				}
-				select {
-				case l.errCh <- err:
-				case <-l.ctx.Done():
-				}
-				return
-			}
-
-			l.mu.Lock()
-			l.lastState = state
-			l.mu.Unlock()
-
-			// Notify first event waiters
-			l.firstEventOnce.Do(func() { close(l.firstEventCh) })
-
-			select {
-			case l.updatesCh <- state:
-			case <-l.ctx.Done():
-				return
-			}
-		}
-	}
-}
-
-// WaitForFirstEvent blocks until the first event is received or timeout occurs
-func (l *OcaAuthStatusListener) WaitForFirstEvent(timeout time.Duration) error {
-	// Fast-path if already have a state
-	l.mu.RLock()
-	ready := l.lastState != nil
-	l.mu.RUnlock()
-	if ready {
-		return nil
-	}
-
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-
-	select {
-	case <-l.firstEventCh:
-		return nil
-	case <-timer.C:
-		return fmt.Errorf("timeout waiting for initial OCA auth event")
-	case <-l.ctx.Done():
-		return fmt.Errorf("OCA auth listener cancelled")
-	}
-}
-
-// IsAuthenticated returns true if the last known OCA auth state is authenticated
-func (l *OcaAuthStatusListener) IsAuthenticated() bool {
-	l.mu.RLock()
-	defer l.mu.RUnlock()
-	return isOCAStateAuthenticated(l.lastState)
-}
-
-// WaitForAuthentication waits until OCA authentication succeeds or timeout occurs
-func (l *OcaAuthStatusListener) WaitForAuthentication(timeout time.Duration) error {
-	timer := time.NewTimer(timeout)
-	defer timer.Stop()
-
-	// If already authenticated, return immediately
-	if l.IsAuthenticated() {
-		return nil
-	}
-
-	for {
-		select {
-		case <-timer.C:
-			return fmt.Errorf("OCA authentication timeout after %v - please try again", timeout)
-		case <-l.ctx.Done():
-			return fmt.Errorf("OCA authentication cancelled")
-		case err := <-l.errCh:
-			return fmt.Errorf("OCA authentication stream error: %w", err)
-		case state := <-l.updatesCh:
-			if isOCAStateAuthenticated(state) {
-				return nil
-			}
-		}
-	}
-}
-
-// Stop closes the stream and cleans up resources
-func (l *OcaAuthStatusListener) Stop() {
-	l.cancel()
-}
-
-func isOCAStateAuthenticated(state *cline.OcaAuthState) bool {
-	return state != nil && state.User != nil
-}
-
-// Singleton holder
-var (
-	ocaListener     *OcaAuthStatusListener
-	ocaListenerOnce sync.Once
-	ocaListenerErr  error
-)
-
-// GetOcaAuthListener returns the OCA auth listener singleton
-func GetOcaAuthListener(ctx context.Context) (*OcaAuthStatusListener, error) {
-	// Allow optional ctx: if nil, use context.TODO(). If already initialized, return singleton.
-	if ctx == nil {
-		ctx = context.TODO()
-	}
-
-	ocaListenerOnce.Do(func() {
-		l, err := NewOcaAuthStatusListener(ctx)
-		if err != nil {
-			ocaListenerErr = err
-			return
-		}
-		if err := l.Start(); err != nil {
-			ocaListenerErr = err
-			return
-		}
-		ocaListener = l
-	})
-	return ocaListener, ocaListenerErr
-}
-
-// IsOCAAuthenticated returns true if the global OCA auth status is authenticated.
-// It attempts a brief wait for the first event to avoid stale reads.
-func IsOCAAuthenticated(ctx context.Context) bool {
-	l, err := GetOcaAuthListener(ctx)
-	if err != nil {
-		return false
-	}
-	_ = l.WaitForFirstEvent(1 * time.Second) // best-effort
-	return l.IsAuthenticated()
-}
-
- // LatestState returns the last received OCA auth state (may be nil)
-func (l *OcaAuthStatusListener) LatestState() *cline.OcaAuthState {
-	l.mu.RLock()
-	defer l.mu.RUnlock()
-	return l.lastState
-}
-
-// GetLatestOCAState returns the latest known OCA auth state, optionally waiting for the first event
-func GetLatestOCAState(ctx context.Context, timeout time.Duration) (*cline.OcaAuthState, error) {
-	l, err := GetOcaAuthListener(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if timeout > 0 {
-		if err := l.WaitForFirstEvent(timeout); err != nil {
-			return nil, err
-		}
-	}
-	return l.LatestState(), nil
-}
-
-// ensureOcaAuthenticated initiates OCA login (if needed) and waits for success using the singleton listener
-func ensureOcaAuthenticated(ctx context.Context) error {
-	// Ensure listener exists
-	listener, err := GetOcaAuthListener(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to initialize OCA auth listener: %w", err)
-	}
-
-	// Briefly wait for first event to know current state
-	_ = listener.WaitForFirstEvent(1 * time.Second)
-
-	// If already authenticated, nothing to do
-	if listener.IsAuthenticated() {
-		fmt.Println("✓ OCA authentication already active.")
-		return nil
-	}
-
-	// Create gRPC client for initiating login
-	client, err := global.GetDefaultClient(ctx)
-	if err != nil {
-		return fmt.Errorf("failed to obtain client: %w", err)
-	}
-
-	// Start login and wait for authentication
-	waitCtx, cancel := context.WithTimeout(ctx, 5*time.Minute)
-	defer cancel()
-
-	// Initiate login (opens the browser with a callback URL from Cline Core)
-	response, err := client.Ocaaccount.OcaAccountLoginClicked(waitCtx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to initiate OCA login: %w", err)
-	}
-
-	fmt.Println("\nOpening browser for OCA authentication...")
-	if response != nil && response.Value != "" {
-		fmt.Printf("If the browser doesn't open automatically, visit this URL:\n%s\n\n", response.Value)
-	}
-	fmt.Println("Waiting for you to complete OCA authentication in your browser...")
-	fmt.Println("(This may take a few moments. Timeout: 5 minutes)")
-
-	// Block until authenticated or timeout
-	if err := listener.WaitForAuthentication(5 * time.Minute); err != nil {
-		return err
-	}
-
-	fmt.Println("✓ OCA authentication successful!")
-	return nil
-}

cli/pkg/cli/config.go

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

cli/pkg/cli/config/settings_renderer.go

@@ -189,7 +189,7 @@ func renderAutoApprovalSettings(value interface{}, censor bool) error {
 				}
 			}
 		} else {
-			// Print other fields normally (enabled, enableNotifications, favorites)
+			// Print other fields normally (enabled, maxRequests, enableNotifications, favorites)
 			fmt.Printf("  %s: %s\n", camelToKebab(key), formatValue(val, key, censor))
 		}
 	}

cli/pkg/cli/display/renderer.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/charmbracelet/lipgloss"
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/output"
 	"github.com/cline/cli/pkg/cli/types"
@@ -15,16 +14,6 @@ type Renderer struct {
 	typewriter   *TypewriterPrinter
 	mdRenderer   *MarkdownRenderer
 	outputFormat string
-
-	// Lipgloss styles that respect outputFormat
-	dimStyle     lipgloss.Style
-	greenStyle   lipgloss.Style
-	redStyle     lipgloss.Style
-	yellowStyle  lipgloss.Style
-	blueStyle    lipgloss.Style
-	whiteStyle   lipgloss.Style
-	boldStyle    lipgloss.Style
-	successStyle lipgloss.Style
 }
 
 func NewRenderer(outputFormat string) *Renderer {
@@ -33,23 +22,11 @@ func NewRenderer(outputFormat string) *Renderer {
 		mdRenderer = nil
 	}
 
-	r := &Renderer{
+	return &Renderer{
 		typewriter:   NewTypewriterPrinter(DefaultTypewriterConfig()),
 		mdRenderer:   mdRenderer,
 		outputFormat: outputFormat,
 	}
-
-	// Initialize lipgloss styles (will respect the global color profile)
-	r.dimStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
-	r.greenStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2"))
-	r.redStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1"))
-	r.yellowStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("3"))
-	r.blueStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("39"))
-	r.whiteStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("7"))
-	r.boldStyle = lipgloss.NewStyle().Bold(true)
-	r.successStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2")).Bold(true)
-
-	return r
 }
 
 func (r *Renderer) RenderMessage(prefix, text string, newline bool) error {
@@ -229,76 +206,21 @@ func (r *Renderer) GetMdRenderer() *MarkdownRenderer {
 
 // RenderMarkdown renders markdown text to terminal format with ANSI codes
 // Falls back to plaintext if markdown rendering is unavailable or fails
-// Respects output format - skips rendering in plain mode or non-TTY contexts
+// Respects output format - skips rendering in plain mode
 func (r *Renderer) RenderMarkdown(markdown string) string {
-	// Skip markdown rendering if:
-	// 1. Output format is explicitly "plain"
-	// 2. Not in a TTY (piped output, file redirect, CI, etc.)
-	if r.outputFormat == "plain" || !isTTY() {
+	// Skip markdown rendering in plain mode
+	if r.outputFormat == "plain" {
 		return markdown
 	}
-
+	
 	if r.mdRenderer == nil {
 		return markdown
 	}
-
+	
 	rendered, err := r.mdRenderer.Render(markdown)
 	if err != nil {
 		return markdown
 	}
-
+	
 	return rendered
 }
-
-// Lipgloss-based color rendering methods
-// These automatically respect the output format via lipgloss color profile
-
-// Dim renders text in dim gray (bright black)
-func (r *Renderer) Dim(text string) string {
-	return r.dimStyle.Render(text)
-}
-
-// Green renders text in green
-func (r *Renderer) Green(text string) string {
-	return r.greenStyle.Render(text)
-}
-
-// Red renders text in red
-func (r *Renderer) Red(text string) string {
-	return r.redStyle.Render(text)
-}
-
-// Yellow renders text in yellow
-func (r *Renderer) Yellow(text string) string {
-	return r.yellowStyle.Render(text)
-}
-
-// Blue renders text in 256-color blue (index 39)
-func (r *Renderer) Blue(text string) string {
-	return r.blueStyle.Render(text)
-}
-
-// White renders text in white
-func (r *Renderer) White(text string) string {
-	return r.whiteStyle.Render(text)
-}
-
-// Bold renders text in bold
-func (r *Renderer) Bold(text string) string {
-	return r.boldStyle.Render(text)
-}
-
-// Success renders text in green with bold
-func (r *Renderer) Success(text string) string {
-	return r.successStyle.Render(text)
-}
-
-// SuccessWithCheckmark renders text in green with bold and a checkmark prefix
-func (r *Renderer) SuccessWithCheckmark(text string) string {
-	return r.Success("✓ " + text)
-}
-
-// ErrorWithX renders text in red with an X prefix
-func (r *Renderer) ErrorWithX(text string) string {
-	return r.Red("✗ " + text)
-}

cli/pkg/cli/display/segment_streamer.go

@@ -36,8 +36,8 @@ func NewStreamingSegment(sayType, prefix string, mdRenderer *MarkdownRenderer, s
 		toolParser:     NewToolResultParser(mdRenderer),
 	}
 
-	// Render rich header immediately when creating segment (if in rich mode and TTY)
-	if shouldMarkdown && outputFormat != "plain" && isTTY() {
+	// Render rich header immediately when creating segment (if in rich mode)
+	if shouldMarkdown && outputFormat != "plain" {
 		header := ss.generateRichHeader()
 		rendered, _ := mdRenderer.Render(header)
 		output.Println("")
@@ -113,8 +113,8 @@ func (ss *StreamingSegment) renderFinal(currentBuffer string) {
 	} else if ss.sayType == string(types.SayTypeCommand) {
 		// Command output
 		bodyContent = "```shell\n" + currentBuffer + "\n```"
-		// Render markdown only in rich mode and TTY
-		if ss.shouldMarkdown && ss.outputFormat != "plain" && isTTY() {
+		// Render markdown
+		if ss.shouldMarkdown && ss.outputFormat != "plain" {
 			rendered, err := ss.mdRenderer.Render(bodyContent)
 			if err == nil {
 				bodyContent = rendered
@@ -122,7 +122,7 @@ func (ss *StreamingSegment) renderFinal(currentBuffer string) {
 		}
 	} else {
 		// For other types (reasoning, text, etc.), render markdown as-is
-		if ss.shouldMarkdown && ss.outputFormat != "plain" && isTTY() {
+		if ss.shouldMarkdown && ss.outputFormat != "plain" {
 			rendered, err := ss.mdRenderer.Render(currentBuffer)
 			if err == nil {
 				bodyContent = rendered

cli/pkg/cli/display/tool_renderer.go

@@ -106,14 +106,6 @@ func (tr *ToolRenderer) generateToolHeader(tool *types.ToolMessage, verbTense st
 		}
 		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
 
-	case string(types.ToolTypeFileDeleted):
-		if verbTense == "wants to" {
-			action = "wants to delete"
-		} else {
-			action = "is deleting"
-		}
-		return fmt.Sprintf("### Cline %s `%s`", action, tool.Path)
-
 	case string(types.ToolTypeListFilesTopLevel):
 		if verbTense == "wants to" {
 			action = "wants to list files in"
@@ -207,7 +199,7 @@ func (tr *ToolRenderer) GenerateToolContentPreview(tool *types.ToolMessage) stri
 		previewMd := fmt.Sprintf("```\n%s\n```", preview)
 		return tr.renderMarkdown(previewMd)
 
-	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch), string(types.ToolTypeFileDeleted):
+	case string(types.ToolTypeReadFile), string(types.ToolTypeWebFetch):
 		// No preview for read/fetch operations
 		return ""
 
@@ -234,8 +226,7 @@ func (tr *ToolRenderer) GenerateToolContentBody(tool *types.ToolMessage) string
 	toolParser := NewToolResultParser(tr.mdRenderer)
 
 	switch tool.Tool {
-	case string(types.ToolTypeReadFile),
-		string(types.ToolTypeFileDeleted):
+	case string(types.ToolTypeReadFile):
 		// readFile: show header only, no body
 		return ""
 
@@ -348,10 +339,9 @@ func (tr *ToolRenderer) RenderUserResponse(approved bool, feedback string) strin
 	return fmt.Sprintf("%s %s\n", symbol, status)
 }
 
-// renderMarkdown renders markdown if not in plain mode and in a TTY
+// renderMarkdown renders markdown if not in plain mode
 func (tr *ToolRenderer) renderMarkdown(markdown string) string {
-	// Skip markdown rendering if plain mode or not in TTY
-	if tr.outputFormat == "plain" || !isTTY() {
+	if tr.outputFormat == "plain" {
 		return markdown
 	}
 

cli/pkg/cli/display/tool_result_parser.go

@@ -221,7 +221,83 @@ func (p *ToolResultParser) ParseCodeDefinitions(content string) string {
 
 // ParseWebFetch formats webFetch tool results with content preview
 func (p *ToolResultParser) ParseWebFetch(content, url string) string {
-	return ""
+	if content == "" {
+		return fmt.Sprintf("*Fetched content from %s (empty response)*", url)
+	}
+
+	lines := strings.Split(content, "\n")
+	
+	var result strings.Builder
+	
+	// Try to extract title
+	var title string
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "#") && !strings.HasPrefix(trimmed, "##") {
+			title = strings.TrimSpace(strings.TrimPrefix(trimmed, "#"))
+			break
+		}
+	}
+
+	if title != "" {
+		result.WriteString(fmt.Sprintf("**Title:** %s\n\n", title))
+	}
+
+	// Show preview of content
+	result.WriteString("**Preview:**\n")
+	
+	charCount := 0
+	maxChars := 500
+	previewLines := []string{}
+	
+	for _, line := range lines {
+		// Skip markdown headers
+		if strings.HasPrefix(strings.TrimSpace(line), "#") {
+			continue
+		}
+		
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			continue
+		}
+		
+		if charCount+len(trimmed) > maxChars {
+			break
+		}
+		
+		previewLines = append(previewLines, trimmed)
+		charCount += len(trimmed)
+	}
+
+	result.WriteString(strings.Join(previewLines, " "))
+	result.WriteString("...\n\n")
+
+	// Extract sections
+	sections := []string{}
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "##") {
+			section := strings.TrimSpace(strings.TrimPrefix(trimmed, "##"))
+			sections = append(sections, section)
+			if len(sections) >= 5 {
+				break
+			}
+		}
+	}
+
+	if len(sections) > 0 {
+		result.WriteString("**Sections Found:**\n")
+		for _, section := range sections {
+			result.WriteString(fmt.Sprintf("- %s\n", section))
+		}
+		result.WriteString("\n")
+	}
+
+	// Word count estimate
+	wordCount := len(strings.Fields(content))
+	result.WriteString(fmt.Sprintf("*[Full content: ~%s]*", p.formatWordCount(wordCount)))
+
+	return result.String()
 }
 
 // detectLanguage returns syntax highlighting language based on file extension

cli/pkg/cli/doctor.go

@@ -1,65 +0,0 @@
-package cli
-
-import (
-	"fmt"
-
-	"github.com/cline/cli/pkg/cli/display"
-	"github.com/cline/cli/pkg/cli/global"
-	"github.com/cline/cli/pkg/cli/terminal"
-	"github.com/cline/cli/pkg/cli/updater"
-	"github.com/spf13/cobra"
-)
-
-// NewDoctorCommand creates the doctor command
-func NewDoctorCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "doctor",
-		Aliases: []string{"d"},
-		Short:   "Check system health and diagnose problems",
-		Long: `Check the health of your Cline CLI installation and diagnose problems.
-
-Currently this command performs the following checks and fixes:
-
-Terminal Configuration:
-  - Detects your terminal emulator (VS Code, Cursor, Ghostty, Kitty, WezTerm, Alacritty)
-  - Configures shift+enter to insert newlines in multiline input
-  - Creates backups before modifying configuration files
-  - Supported terminals: VS Code, Cursor, Ghostty, Kitty, WezTerm, Alacritty
-  - iTerm2 works by default, Terminal.app requires manual setup
-
-CLI Updates:
-  - Checks npm registry for the latest version
-  - Automatically installs updates via npm if available
-  - Respects NO_AUTO_UPDATE environment variable
-  - Skipped in CI environments
-
-Note: Future versions will include additional health checks for Node.js version,
-npm availability, Cline Core connectivity, database integrity, and more.`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return runDoctorChecks()
-		},
-	}
-
-	return cmd
-}
-
-// runDoctorChecks performs all doctor diagnostics and configuration
-func runDoctorChecks() error {
-	renderer := display.NewRenderer(global.Config.OutputFormat)
-
-	fmt.Printf("\n%s\n\n", renderer.Bold("Cline Doctor - System Health Check"))
-
-	// Configure terminal keybindings (terminal.go prints its own status)
-	fmt.Printf("%s\n\n", renderer.Dim("━━━ Terminal Configuration ━━━"))
-	terminal.SetupKeyboardSync()
-
-	// Check for updates (updater.go prints its own status)
-	fmt.Printf("\n%s\n\n", renderer.Dim("━━━ CLI Updates ━━━"))
-	updater.CheckAndUpdateSync(global.Config.Verbose, true)
-
-	// Summary
-	fmt.Printf("\n%s\n", renderer.Dim("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"))
-	fmt.Printf("\n%s\n\n", renderer.SuccessWithCheckmark("Health check complete"))
-
-	return nil
-}

cli/pkg/cli/global/global.go

@@ -6,10 +6,8 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/charmbracelet/lipgloss"
 	"github.com/cline/cli/pkg/common"
 	"github.com/cline/grpc-go/client"
-	"github.com/muesli/termenv"
 )
 
 type Port uint16
@@ -49,12 +47,6 @@ func InitializeGlobalConfig(cfg *GlobalConfig) error {
 		return fmt.Errorf("failed to create config directory: %w", err)
 	}
 
-	// Configure lipgloss color profile based on output format
-	if cfg.OutputFormat == "plain" {
-		lipgloss.SetColorProfile(termenv.Ascii) // NO COLOR mode
-	}
-	// Otherwise lipgloss auto-detects terminal capabilities (default behavior)
-
 	Config = cfg
 	Clients = NewClineClients(cfg.ConfigPath)
 

cli/pkg/cli/handlers/ask_handlers.go

@@ -52,6 +52,8 @@ func (h *AskHandler) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
 		return h.handleResumeCompletedTask(msg, dc)
 	case string(types.AskTypeMistakeLimitReached):
 		return h.handleMistakeLimitReached(msg, dc)
+	case string(types.AskTypeAutoApprovalMaxReached):
+		return h.handleAutoApprovalMaxReached(msg, dc)
 	case string(types.AskTypeBrowserActionLaunch):
 		return h.handleBrowserActionLaunch(msg, dc)
 	case string(types.AskTypeUseMcpServer):
@@ -69,25 +71,22 @@ func (h *AskHandler) Handle(msg *types.ClineMessage, dc *DisplayContext) error {
 
 // handleFollowup handles followup questions
 func (h *AskHandler) handleFollowup(msg *types.ClineMessage, dc *DisplayContext) error {
+	// Use ToolRenderer for unified rendering
+	header := dc.ToolRenderer.GenerateAskFollowupHeader()
 	body := dc.ToolRenderer.GenerateAskFollowupBody(msg.Text)
 
 	if body == "" {
 		return nil
 	}
 
-	if dc.IsStreamingMode {
-		// In streaming mode, header was already shown by partial stream
-		// Just render the body content
-		output.Print(body)
-	} else {
-		// Non-streaming mode: render header + body together
-		header := dc.ToolRenderer.GenerateAskFollowupHeader()
-		rendered := dc.Renderer.RenderMarkdown(header)
-		output.Print("\n")
-		output.Print(rendered)
-		output.Print("\n")
-		output.Print(body)
-	}
+	// Render header
+	rendered := dc.Renderer.RenderMarkdown(header)
+	output.Print("\n")
+	output.Print(rendered)
+	output.Print("\n")
+
+	// Render body
+	output.Print(body)
 
 	return nil
 }
@@ -126,8 +125,8 @@ func (h *AskHandler) handlePlanModeRespond(msg *types.ClineMessage, dc *DisplayC
 // showApprovalHint displays a hint in non-interactive mode about how to approve/deny
 func (h *AskHandler) showApprovalHint(dc *DisplayContext) {
 	if !dc.IsInteractive {
-		output.Printf("\n%s\n", dc.Renderer.Dim("Cline is requesting approval to use this tool"))
-		output.Printf("%s\n", dc.Renderer.Dim("Use cline task send --approve or --deny to respond"))
+		output.Printf("\n\033[90mCline is requesting approval to use this tool\033[0m\n")
+		output.Printf("\033[90mUse \033[0mcline task send --approve\033[90m or \033[0m--deny\033[90m to respond\033[0m\n")
 	}
 }
 
@@ -178,19 +177,9 @@ func (h *AskHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext) err
 		return dc.Renderer.RenderMessage("TOOL", msg.Text, true)
 	}
 
-	if dc.IsStreamingMode {
-		// In streaming mode, header was already shown by partial stream
-		// Just render the content preview
-		contentPreview := dc.ToolRenderer.GenerateToolContentPreview(&tool)
-		if contentPreview != "" {
-			output.Print("\n")
-			output.Print(contentPreview)
-		}
-	} else {
-		// Non-streaming mode: render full approval (header + preview)
-		rendered := dc.ToolRenderer.RenderToolApprovalRequest(&tool)
-		output.Print(rendered)
-	}
+	// Use unified ToolRenderer
+	rendered := dc.ToolRenderer.RenderToolApprovalRequest(&tool)
+	output.Print(rendered)
 
 	h.showApprovalHint(dc)
 	return nil
@@ -253,6 +242,25 @@ func (h *AskHandler) handleMistakeLimitReached(msg *types.ClineMessage, dc *Disp
 	return dc.Renderer.RenderMessage("ERROR", fmt.Sprintf("Mistake Limit Reached: %s. Approval required.", msg.Text), true)
 }
 
+// handleAutoApprovalMaxReached handles auto-approval max reached
+func (h *AskHandler) handleAutoApprovalMaxReached(msg *types.ClineMessage, dc *DisplayContext) error {
+	if dc.SystemRenderer != nil {
+		details := make(map[string]string)
+		if msg.Text != "" {
+			details["reason"] = msg.Text
+		}
+		dc.SystemRenderer.RenderError(
+			"warning",
+			"Auto-Approval Limit Reached",
+			"The maximum number of auto-approved requests has been reached. Manual approval is now required.",
+			details,
+		)
+		fmt.Printf("\n**Approval required to continue.**\n")
+		return nil
+	}
+	return dc.Renderer.RenderMessage("WARNING", fmt.Sprintf("Auto-approval limit reached: %s. Approval required.", msg.Text), true)
+}
+
 // handleBrowserActionLaunch handles browser action launch requests
 func (h *AskHandler) handleBrowserActionLaunch(msg *types.ClineMessage, dc *DisplayContext) error {
 	url := strings.TrimSpace(msg.Text)

cli/pkg/cli/instances.go

@@ -389,21 +389,20 @@ func newInstanceListCommand() *cobra.Command {
 				}
 
 				// Render the markdown table with terminal width for nice table layout
-				mdRenderer, err := display.NewMarkdownRendererForTerminal()
+				renderer, err := display.NewMarkdownRendererForTerminal()
 				if err != nil {
 					// Fallback to plain table if markdown renderer fails
 					fmt.Println(markdown.String())
 				} else {
-					rendered, err := mdRenderer.Render(markdown.String())
+					rendered, err := renderer.Render(markdown.String())
 					if err != nil {
 						fmt.Println(markdown.String())
 					} else {
 						// Post-process to colorize status values
-						colorRenderer := display.NewRenderer(global.Config.OutputFormat)
-						rendered = strings.ReplaceAll(rendered, "SERVING", colorRenderer.Green("SERVING"))
-						rendered = strings.ReplaceAll(rendered, "✓", colorRenderer.Green("✓"))
-						rendered = strings.ReplaceAll(rendered, "NOT_SERVING", colorRenderer.Red("NOT_SERVING"))
-						rendered = strings.ReplaceAll(rendered, "UNKNOWN", colorRenderer.Yellow("UNKNOWN"))
+						rendered = strings.ReplaceAll(rendered, "SERVING", "\033[32mSERVING\033[0m")         // Green
+						rendered = strings.ReplaceAll(rendered, "✓", "\033[32m✓\033[0m")                     // Green
+						rendered = strings.ReplaceAll(rendered, "NOT_SERVING", "\033[31mNOT_SERVING\033[0m") // Red
+						rendered = strings.ReplaceAll(rendered, "UNKNOWN", "\033[33mUNKNOWN\033[0m")         // Yellow
 
 						fmt.Print(strings.TrimLeft(rendered, "\n"))
 					}

cli/pkg/cli/logs.go

@@ -208,9 +208,9 @@ func listLogFiles(logsDir string) ([]logFileInfo, error) {
 		})
 	}
 
-	// Sort by created time (oldest first)
+	// Sort by created time (newest first)
 	sort.Slice(logs, func(i, j int) bool {
-		return logs[i].created.Before(logs[j].created)
+		return logs[i].created.After(logs[j].created)
 	})
 
 	return logs, nil
@@ -340,7 +340,6 @@ func renderLogsTable(logs []logFileInfo, markForDeletion bool) error {
 	}
 
 	// Use markdown table for rich output
-	colorRenderer := display.NewRenderer(global.Config.OutputFormat)
 	var markdown strings.Builder
 	markdown.WriteString("| **FILENAME** | **SIZE** | **CREATED** | **AGE** |\n")
 	markdown.WriteString("|--------------|----------|-------------|---------|")
@@ -353,9 +352,9 @@ func renderLogsTable(logs []logFileInfo, markForDeletion bool) error {
 			row.age,
 		)
 
-		// If marking for deletion, wrap in red
+		// If marking for deletion, wrap in red ANSI codes
 		if markForDeletion {
-			line = colorRenderer.Red(line)
+			line = "\033[31m" + line + "\033[0m"
 		}
 
 		markdown.WriteString(line)
@@ -379,4 +378,4 @@ func renderLogsTable(logs []logFileInfo, markForDeletion bool) error {
 	fmt.Println()
 
 	return nil
-}
+}

cli/pkg/cli/output/input_model.go

@@ -24,11 +24,10 @@ 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
 }
 
 // InputCancelMsg is sent when the user cancels input (Ctrl+C)
@@ -160,7 +159,8 @@ func NewInputModel(inputType InputType, title, placeholder, currentMode string)
 	if inputType == InputTypeApproval {
 		m.approvalOptions = []string{
 			"Yes",
-			"Yes, and don't ask again for this task",
+			"Yes, with feedback",
+			"No",
 			"No, with feedback",
 		}
 		m.selectedOption = 0
@@ -210,7 +210,8 @@ func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if msg.InputType == InputTypeApproval {
 			m.approvalOptions = []string{
 				"Yes",
-				"Yes, and don't ask again for this task",
+				"Yes, with feedback",
+				"No",
 				"No, with feedback",
 			}
 			m.selectedOption = 0
@@ -297,7 +298,6 @@ func (m *InputModel) handleSubmit() (tea.Model, tea.Cmd) {
 		selected := m.approvalOptions[m.selectedOption]
 		approved := strings.HasPrefix(selected, "Yes")
 		needsFeedback := strings.Contains(selected, "feedback")
-		noAskAgain := strings.Contains(selected, "don't ask again")
 
 		if needsFeedback {
 			// Store the approval decision before switching to feedback input
@@ -318,7 +318,6 @@ func (m *InputModel) handleSubmit() (tea.Model, tea.Cmd) {
 				InputType:     InputTypeApproval,
 				Approved:      approved,
 				NeedsFeedback: false,
-				NoAskAgain:    noAskAgain,
 			}
 		}
 

cli/pkg/cli/task.go

@@ -14,7 +14,6 @@ import (
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/task"
 	"github.com/cline/cli/pkg/cli/updater"
-	"github.com/cline/grpc-go/cline"
 	"github.com/spf13/cobra"
 )
 
@@ -394,7 +393,7 @@ func newTaskViewCommand() *cobra.Command {
 				return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), false)
 			} else if followComplete {
 				// Follow until completion
-				return taskManager.FollowConversationUntilCompletion(ctx, task.DefaultFollowOptions())
+				return taskManager.FollowConversationUntilCompletion(ctx)
 			} else {
 				// Default: show snapshot
 				return taskManager.ShowConversation(ctx)
@@ -477,34 +476,15 @@ func newTaskOpenCommand() *cobra.Command {
 					return fmt.Errorf("failed to parse settings: %w", err)
 				}
 
-				// Apply task-specific settings using UpdateTaskSettings RPC
-				if parsedSettings != nil {
-					_, err = taskManager.GetClient().State.UpdateTaskSettings(ctx, &cline.UpdateTaskSettingsRequest{
-						Settings: parsedSettings,
-						TaskId:   &taskID,
-					})
-					if err != nil {
-						return fmt.Errorf("failed to apply task settings: %w", err)
-					}
-					if global.Config.Verbose {
-						fmt.Println("Task-specific settings applied successfully")
-					}
+				// Create config manager to apply settings
+				configManager, err := config.NewManager(ctx, taskManager.GetCurrentInstance())
+				if err != nil {
+					return fmt.Errorf("failed to create config manager: %w", err)
 				}
 
-				// Handle secrets separately if provided (they must go to global config)
-				if secrets != nil {
-					// Secrets are always global, not task-specific
-					configManager, err := config.NewManager(ctx, taskManager.GetCurrentInstance())
-					if err != nil {
-						return fmt.Errorf("failed to create config manager: %w", err)
-					}
-
-					if err := configManager.UpdateSettings(ctx, nil, secrets); err != nil {
-						return fmt.Errorf("failed to apply secrets: %w", err)
-					}
-					if global.Config.Verbose {
-						fmt.Println("Global secrets applied successfully")
-					}
+				// Apply the settings to the instance
+				if err := configManager.UpdateSettings(ctx, parsedSettings, secrets); err != nil {
+					return fmt.Errorf("failed to apply settings: %w", err)
 				}
 			}
 
@@ -592,20 +572,17 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 
 	// Check if data is being piped to stdin
 	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		// Only try to read if there's actually data available
-		if stat.Size() > 0 {
-			stdinBytes, err := io.ReadAll(os.Stdin)
-			if err != nil {
-				return "", fmt.Errorf("failed to read from stdin: %w", err)
-			}
+		stdinBytes, err := io.ReadAll(os.Stdin)
+		if err != nil {
+			return "", fmt.Errorf("failed to read from stdin: %w", err)
+		}
 
-			stdinContent := strings.TrimSpace(string(stdinBytes))
-			if stdinContent != "" {
-				if content.Len() > 0 {
-					content.WriteString(" ")
-				}
-				content.WriteString(stdinContent)
+		stdinContent := strings.TrimSpace(string(stdinBytes))
+		if stdinContent != "" {
+			if content.Len() > 0 {
+				content.WriteString(" ")
 			}
+			content.WriteString(stdinContent)
 		}
 	}
 
@@ -668,11 +645,8 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 	// If yolo mode is enabled, follow until completion (non-interactive)
 	// Otherwise, follow in interactive mode
 	if opts.Yolo {
-		// Skip active task check since we just created the task
-		return taskManager.FollowConversationUntilCompletion(ctx, task.FollowOptions{
-			SkipActiveTaskCheck: true,
-		})
+		return taskManager.FollowConversationUntilCompletion(ctx)
 	} else {
 		return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
 	}
-}
+}

cli/pkg/cli/task/follow_options.go

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

cli/pkg/cli/task/input_handler.go

@@ -2,7 +2,6 @@ package task
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -10,7 +9,6 @@ import (
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/output"
 	"github.com/cline/cli/pkg/cli/types"
@@ -18,21 +16,20 @@ import (
 
 // InputHandler manages interactive user input during follow mode
 type InputHandler struct {
-	manager          *Manager
-	coordinator      *StreamCoordinator
-	cancelFunc       context.CancelFunc
-	mu               sync.RWMutex
-	isRunning        bool
-	pollTicker       *time.Ticker
-	program          *tea.Program
-	programRunning   bool
-	programDoneChan  chan struct{} // Signals when program actually exits
-	resultChan       chan output.InputSubmitMsg
-	cancelChan       chan struct{}
-	feedbackApproval bool                // Track if we're in feedback after approval
-	feedbackApproved bool                // Track the approval decision
-	approvalMessage  *types.ClineMessage // Store the approval message for determining action
-	ctx              context.Context     // Context for restart callback
+	manager         *Manager
+	coordinator     *StreamCoordinator
+	cancelFunc      context.CancelFunc
+	mu              sync.RWMutex
+	isRunning       bool
+	pollTicker      *time.Ticker
+	program         *tea.Program
+	programRunning  bool
+	programDoneChan chan struct{} // Signals when program actually exits
+	resultChan      chan output.InputSubmitMsg
+	cancelChan      chan struct{}
+	feedbackApproval bool // Track if we're in feedback after approval
+	feedbackApproved bool // Track the approval decision
+	ctx             context.Context // Context for restart callback
 }
 
 // NewInputHandler creates a new input handler
@@ -165,10 +162,6 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 				// Check for mode switch commands first
 				newMode, remainingMessage, isModeSwitch := ih.parseModeSwitch(message)
 				if isModeSwitch {
-					// Create styles for mode switch messages (respect global color profile)
-					actStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("39")).Bold(true)
-					planStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("3")).Bold(true)
-
 					if remainingMessage != "" {
 						// Switching with a message - behavior differs by mode
 						if newMode == "act" {
@@ -177,14 +170,16 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 								output.Printf("\nError switching to act mode with message: %v\n", err)
 								continue
 							}
-							output.Printf("\n%s\n", actStyle.Render("Switched to act mode"))
+							// 256-color index 39 for act mode (matches lipgloss color "39" in input form)
+							output.Printf("\n\033[38;5;39m\033[1mSwitched to act mode\033[0m\n")
 						} else {
 							// Plan mode: must switch first, then send message separately
 							if err := ih.manager.SetMode(ctx, newMode, nil, nil, nil); err != nil {
 								output.Printf("\nError switching to plan mode: %v\n", err)
 								continue
 							}
-							output.Printf("\n%s\n", planStyle.Render("Switched to plan mode"))
+							// Yellow color for plan mode (ANSI color 3)
+							output.Printf("\n\033[33m\033[1mSwitched to plan mode\033[0m\n")
 
 							// Now send the message separately
 							time.Sleep(500 * time.Millisecond) // Give mode switch time to process
@@ -201,9 +196,9 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 						}
 						// Color based on mode
 						if newMode == "act" {
-							output.Printf("\n%s\n", actStyle.Render("Switched to act mode"))
+							output.Printf("\n\033[38;5;39m\033[1mSwitched to act mode\033[0m\n")
 						} else {
-							output.Printf("\n%s\n", planStyle.Render("Switched to plan mode"))
+							output.Printf("\n\033[33m\033[1mSwitched to plan mode\033[0m\n")
 						}
 					}
 
@@ -234,48 +229,6 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 	}
 }
 
-// determineAutoApprovalAction determines which auto-approval action to enable based on the ask type
-func determineAutoApprovalAction(msg *types.ClineMessage) (string, error) {
-	switch types.AskType(msg.Ask) {
-	case types.AskTypeTool:
-		// Parse tool message to determine if it's a read or edit operation
-		var toolMsg types.ToolMessage
-		if err := json.Unmarshal([]byte(msg.Text), &toolMsg); err != nil {
-			return "", fmt.Errorf("failed to parse tool message: %w", err)
-		}
-
-		// Determine action based on tool type
-		switch types.ToolType(toolMsg.Tool) {
-		case types.ToolTypeReadFile,
-			types.ToolTypeListFilesTopLevel,
-			types.ToolTypeListFilesRecursive,
-			types.ToolTypeListCodeDefinitionNames,
-			types.ToolTypeSearchFiles,
-			types.ToolTypeWebFetch:
-			return "read_files", nil
-		case types.ToolTypeEditedExistingFile,
-			types.ToolTypeNewFileCreated:
-			return "edit_files", nil
-		case types.ToolTypeFileDeleted:
-			return "apply_patch", nil
-		default:
-			return "", fmt.Errorf("unsupported tool type: %s", toolMsg.Tool)
-		}
-
-	case types.AskTypeCommand:
-		return "execute_all_commands", nil
-
-	case types.AskTypeBrowserActionLaunch:
-		return "use_browser", nil
-
-	case types.AskTypeUseMcpServer:
-		return "use_mcp", nil
-
-	default:
-		return "", fmt.Errorf("unsupported ask type: %s", msg.Ask)
-	}
-}
-
 // promptForInput displays an interactive prompt and waits for user input
 func (ih *InputHandler) promptForInput(ctx context.Context) (string, bool, error) {
 	currentMode := ih.manager.GetCurrentMode()
@@ -292,9 +245,6 @@ func (ih *InputHandler) promptForInput(ctx context.Context) (string, bool, error
 
 // promptForApproval displays an approval prompt for tool/command requests
 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.NewInputModel(
 		output.InputTypeApproval,
 		"Let Cline use this tool?",
@@ -394,23 +344,6 @@ 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
-				action, err := determineAutoApprovalAction(ih.approvalMessage)
-				if err != nil {
-					output.Printf("\nWarning: Could not determine auto-approval action: %v\n", err)
-				} else {
-					// Enable the auto-approval action
-					if err := ih.manager.UpdateTaskAutoApprovalAction(ctx, action); err != nil {
-						output.Printf("\nWarning: Could not update auto-approval: %v\n", err)
-					} else {
-						output.Printf("\nAuto-approval enabled for %s\n", action)
-					}
-				}
-			}
-			
 			// Store approval state for when feedback comes back
 			ih.feedbackApproval = false
 			ih.feedbackApproved = result.Approved

cli/pkg/cli/task/manager.go

@@ -280,8 +280,9 @@ func (m *Manager) CheckSendEnabled(ctx context.Context) error {
 
 	// Error types which we allow sending on
 	errorTypes := []string{
-		string(types.AskTypeAPIReqFailed),        // "api_req_failed"
-		string(types.AskTypeMistakeLimitReached), // "mistake_limit_reached"
+		string(types.AskTypeAPIReqFailed),           // "api_req_failed"
+		string(types.AskTypeMistakeLimitReached),    // "mistake_limit_reached"
+		string(types.AskTypeAutoApprovalMaxReached), // "auto_approval_max_req_reached"
 	}
 
 	isError := false
@@ -753,21 +754,7 @@ func (m *Manager) FollowConversation(ctx context.Context, instanceAddress string
 }
 
 // FollowConversationUntilCompletion streams conversation updates until task completion
-func (m *Manager) FollowConversationUntilCompletion(ctx context.Context, opts FollowOptions) error {
-	// Check if there's an active task before entering follow mode
-	// Skip this check if we just created a task (to avoid race condition where task isn't active yet)
-	if !opts.SkipActiveTaskCheck {
-		err := m.CheckSendEnabled(ctx)
-		if err != nil {
-			if errors.Is(err, ErrNoActiveTask) {
-				fmt.Println("No task is currently running.")
-				return nil
-			}
-			// For other errors (like task busy), we can still enter follow mode
-			// as the user may want to observe the task
-		}
-	}
-
+func (m *Manager) FollowConversationUntilCompletion(ctx context.Context) error {
 	// Enable streaming mode
 	m.mu.Lock()
 	m.isStreamingMode = true
@@ -1017,18 +1004,26 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 
 		case msg.Ask == string(types.AskTypePlanModeRespond):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
-			// Non-streaming mode: render normally when message is complete
-			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				m.displayMessage(msg, false, false, i)
+			// In streaming mode, partial stream handles this message
+			// State stream should skip to avoid duplication
+			if m.isStreamingMode {
+				// Skip - partial stream already handled this
+			} else {
+				// Non-streaming mode: render normally when message is complete
+				if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
+					m.displayMessage(msg, false, false, i)
 
-				coordinator.MarkProcessedInCurrentTurn(msgKey)
+					coordinator.MarkProcessedInCurrentTurn(msgKey)
+				}
 			}
 
 		case msg.Type == types.MessageTypeAsk:
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			// Only render if not already handled by partial stream
-			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
+			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				fmt.Println()
 				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 		}
@@ -1250,48 +1245,10 @@ func (m *Manager) updateMode(stateJson string) {
 	m.mu.Unlock()
 }
 
-// UpdateTaskAutoApprovalAction enables a specific auto-approval action for the current task
-func (m *Manager) UpdateTaskAutoApprovalAction(ctx context.Context, actionKey string) error {
-	boolPtr := func(b bool) *bool { return &b }
-
-	settings := &cline.Settings{
-		AutoApprovalSettings: &cline.AutoApprovalSettings{
-			Actions: &cline.AutoApprovalActions{},
-		},
-	}
-
-	// Set the specific action to true based on actionKey
-	truePtr := boolPtr(true)
-
-	switch actionKey {
-	case "read_files":
-		settings.AutoApprovalSettings.Actions.ReadFiles = truePtr
-	case "edit_files":
-		settings.AutoApprovalSettings.Actions.EditFiles = truePtr
-	case "execute_all_commands":
-		settings.AutoApprovalSettings.Actions.ExecuteAllCommands = truePtr
-	case "use_browser":
-		settings.AutoApprovalSettings.Actions.UseBrowser = truePtr
-	case "use_mcp":
-		settings.AutoApprovalSettings.Actions.UseMcp = truePtr
-	default:
-		return fmt.Errorf("unknown auto-approval action: %s", actionKey)
-	}
-
-	_, err := m.client.State.UpdateTaskSettings(ctx, &cline.UpdateTaskSettingsRequest{
-		Settings: settings,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to update task settings: %w", err)
-	}
-
-	return nil
-}
-
 // Cleanup cleans up resources
 func (m *Manager) Cleanup() {
 	// Clean up streaming display resources if needed
 	if m.streamingDisplay != nil {
 		m.streamingDisplay.Cleanup()
 	}
-}
+}

cli/pkg/cli/task/settings_parser.go

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

cli/pkg/cli/terminal/keyboard.go

@@ -1,695 +0,0 @@
-package terminal
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-
-	"github.com/cline/cli/pkg/cli/display"
-	"github.com/cline/cli/pkg/cli/global"
-)
-
-// KeyboardProtocol manages enhanced keyboard protocol support for detecting
-// modified keys like shift+enter across all major terminals.
-type KeyboardProtocol struct {
-	enabled bool
-	mu      sync.Mutex
-}
-
-var globalProtocol = &KeyboardProtocol{}
-
-// EnableEnhancedKeyboard enables enhanced keyboard protocols to support
-// shift+enter and other modified keys across all major terminals:
-// - VS Code integrated terminal
-// - iTerm2
-// - Terminal.app
-// - Ghostty
-// - Kitty
-// - WezTerm
-// - Alacritty
-// - foot
-// - xterm
-//
-// This function is safe to call multiple times and handles cleanup automatically.
-// It enables both modifyOtherKeys (xterm protocol) and Kitty keyboard protocol
-// for maximum compatibility.
-func EnableEnhancedKeyboard() {
-	globalProtocol.mu.Lock()
-	defer globalProtocol.mu.Unlock()
-
-	if globalProtocol.enabled {
-		return // Already enabled
-	}
-
-	// Check if we're in a TTY (not piped/redirected)
-	if !isatty(os.Stdin.Fd()) {
-		return
-	}
-
-	// Enable modifyOtherKeys mode 2
-	// This tells xterm-compatible terminals (VS Code, iTerm2, Terminal.app, etc.)
-	// to send escape sequences for modified keys including shift+enter
-	// Format: CSI > 4 ; 2 m
-	// - Mode 2 enables for ALL keys including well-known ones
-	fmt.Print("\x1b[>4;2m")
-
-	// Also enable Kitty keyboard protocol for terminals that support it
-	// This is a more modern protocol supported by Kitty, Ghostty, WezTerm, foot, etc.
-	// Format: CSI = <flags> u where flags=1 means "disambiguate escape codes"
-	// This makes shift+enter distinguishable from plain enter
-	fmt.Print("\x1b[=1u")
-
-	globalProtocol.enabled = true
-}
-
-// DisableEnhancedKeyboard restores the terminal to its default keyboard mode.
-// This should be called on program exit to be a good citizen.
-func DisableEnhancedKeyboard() {
-	globalProtocol.mu.Lock()
-	defer globalProtocol.mu.Unlock()
-
-	if !globalProtocol.enabled {
-		return
-	}
-
-	// Disable modifyOtherKeys (restore to mode 0)
-	fmt.Print("\x1b[>4;0m")
-
-	// Disable Kitty keyboard protocol
-	fmt.Print("\x1b[<u")
-
-	globalProtocol.enabled = false
-}
-
-// isatty checks if a file descriptor is a terminal
-func isatty(fd uintptr) bool {
-	// Use the standard library's terminal package
-	// This works across all platforms (Unix, Windows, etc.)
-	fileInfo, err := os.Stdin.Stat()
-	if err != nil {
-		return false
-	}
-	return (fileInfo.Mode() & os.ModeCharDevice) != 0
-}
-
-// SetupKeyboard detects the current terminal and configures keybindings if needed.
-// Runs in background and doesn't block. Prints status when configs are modified.
-func SetupKeyboard() {
-	go func() {
-		renderer := display.NewRenderer(global.Config.OutputFormat)
-		setupKeyboardInternal(renderer)
-	}()
-}
-
-// SetupKeyboardSync is the synchronous version used by doctor command.
-// Blocks until complete and prints status for all terminals.
-func SetupKeyboardSync() {
-	renderer := display.NewRenderer(global.Config.OutputFormat)
-	setupKeyboardInternal(renderer)
-}
-
-func setupKeyboardInternal(renderer *display.Renderer) {
-	terminalName := DetectTerminal()
-
-	switch terminalName {
-	case "vscode":
-		// VS Code and Cursor use the same TERM_PROGRAM value
-		modified, path := SetupVSCodeKeybindings()
-		if modified {
-			fmt.Printf("%s VS Code %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ VS Code shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-		modified, path = SetupCursorKeybindings()
-		if modified {
-			fmt.Printf("%s Cursor %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ Cursor shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-	case "ghostty":
-		modified, path := SetupGhosttyKeybindings()
-		if modified {
-			fmt.Printf("%s Ghostty %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-			fmt.Printf("%s\n", renderer.Dim("  Fully restart Ghostty (quit all windows) for changes to take effect"))
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ Ghostty shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-	case "wezterm":
-		modified, path := SetupWezTermKeybindings()
-		if modified {
-			fmt.Printf("%s WezTerm %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ WezTerm shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-	case "alacritty":
-		modified, path := SetupAlacrittyKeybindings()
-		if modified {
-			fmt.Printf("%s Alacritty %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ Alacritty shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-	case "kitty":
-		modified, path := SetupKittyKeybindings()
-		if modified {
-			fmt.Printf("%s Kitty %s\n", renderer.Dim("Configured shift+enter for"), renderer.Dim("terminal"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		} else if path != "" {
-			fmt.Printf("%s\n", renderer.Dim("✓ Kitty shift+enter already configured"))
-			fmt.Printf("%s %s\n", renderer.Dim("  →"), path)
-		}
-
-	case "iterm2":
-		fmt.Printf("%s\n", renderer.Dim("✓ iTerm2 shift+enter works by default (maps to alt+enter)"))
-
-	case "terminal.app":
-		fmt.Printf("%s\n", renderer.Dim("⚠ Terminal.app requires manual configuration"))
-		fmt.Printf("%s\n", renderer.Dim("  See: Terminal → Preferences → Profiles → Keyboard"))
-
-	case "unknown":
-		fmt.Printf("%s\n", renderer.Dim("ℹ Terminal not detected - use alt+enter or ctrl+j for newlines"))
-	}
-}
-
-// getVSCodeConfigPath returns the platform-specific path to VS Code's User directory
-func getVSCodeConfigPath() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", err
-	}
-
-	switch runtime.GOOS {
-	case "darwin":
-		return filepath.Join(home, "Library", "Application Support", "Code", "User"), nil
-	case "windows":
-		appData := os.Getenv("APPDATA")
-		if appData == "" {
-			appData = filepath.Join(home, "AppData", "Roaming")
-		}
-		return filepath.Join(appData, "Code", "User"), nil
-	default: // linux, freebsd, etc.
-		return filepath.Join(home, ".config", "Code", "User"), nil
-	}
-}
-
-// getCursorConfigPath returns the platform-specific path to Cursor's User directory
-func getCursorConfigPath() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", err
-	}
-
-	switch runtime.GOOS {
-	case "darwin":
-		return filepath.Join(home, "Library", "Application Support", "Cursor", "User"), nil
-	case "windows":
-		appData := os.Getenv("APPDATA")
-		if appData == "" {
-			appData = filepath.Join(home, "AppData", "Roaming")
-		}
-		return filepath.Join(appData, "Cursor", "User"), nil
-	default: // linux, freebsd, etc.
-		return filepath.Join(home, ".config", "Cursor", "User"), nil
-	}
-}
-
-// DetectTerminal identifies which terminal emulator is currently running
-func DetectTerminal() string {
-	// Check TERM_PROGRAM (works for most terminals)
-	termProgram := os.Getenv("TERM_PROGRAM")
-	switch termProgram {
-	case "vscode":
-		return "vscode" // Also covers Cursor (uses same value)
-	case "WezTerm":
-		return "wezterm"
-	case "ghostty":
-		return "ghostty"
-	case "iTerm.app":
-		return "iterm2"
-	case "Apple_Terminal":
-		return "terminal.app"
-	}
-
-	// Kitty doesn't set TERM_PROGRAM, check KITTY_WINDOW_ID
-	if os.Getenv("KITTY_WINDOW_ID") != "" {
-		return "kitty"
-	}
-
-	// Alacritty doesn't set TERM_PROGRAM, check ALACRITTY_SOCKET
-	if os.Getenv("ALACRITTY_SOCKET") != "" {
-		return "alacritty"
-	}
-
-	// Ghostty fallback (cross-platform - more reliable than TERM_PROGRAM)
-	if os.Getenv("GHOSTTY_RESOURCES_DIR") != "" {
-		return "ghostty"
-	}
-
-	// Alacritty fallback
-	if os.Getenv("ALACRITTY_LOG") != "" {
-		return "alacritty"
-	}
-
-	// Check TERM variable as last resort
-	term := os.Getenv("TERM")
-	if strings.Contains(term, "kitty") {
-		return "kitty"
-	}
-	if term == "alacritty" {
-		return "alacritty"
-	}
-	if term == "xterm-ghostty" {
-		return "ghostty"
-	}
-
-	return "unknown"
-}
-
-// VSCodeKeybinding represents a VS Code keyboard shortcut
-type VSCodeKeybinding struct {
-	Key     string                 `json:"key"`
-	Command string                 `json:"command"`
-	Args    map[string]interface{} `json:"args,omitempty"`
-	When    string                 `json:"when,omitempty"`
-}
-
-// SetupVSCodeKeybindings adds shift+enter support to VS Code's integrated terminal
-// by modifying the user's keybindings.json file.
-// Returns (wasModified, configPath) to allow caller to log the change.
-func SetupVSCodeKeybindings() (bool, string) {
-	// Get platform-specific VS Code config path
-	configDir, err := getVSCodeConfigPath()
-	if err != nil {
-		return false, ""
-	}
-
-	keybindingsPath := filepath.Join(configDir, "keybindings.json")
-
-	// Check if VS Code is installed (keybindings file or parent dir exists)
-	if _, err := os.Stat(filepath.Dir(keybindingsPath)); os.IsNotExist(err) {
-		// VS Code not installed, skip silently
-		return false, ""
-	}
-
-	// Read existing keybindings
-	var keybindings []VSCodeKeybinding
-
-	data, err := os.ReadFile(keybindingsPath)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return false, ""
-		}
-		// File doesn't exist, start with empty array
-		keybindings = []VSCodeKeybinding{}
-	} else {
-		// Parse existing keybindings
-		if err := json.Unmarshal(data, &keybindings); err != nil {
-			// If parse fails, don't modify the file
-			return false, ""
-		}
-	}
-
-	// Check if shift+enter binding already exists
-	for _, kb := range keybindings {
-		if kb.Key == "shift+enter" && kb.Command == "workbench.action.terminal.sendSequence" {
-			// Already configured
-			return false, keybindingsPath
-		}
-	}
-
-	// Add shift+enter keybinding
-	newBinding := VSCodeKeybinding{
-		Key:     "shift+enter",
-		Command: "workbench.action.terminal.sendSequence",
-		Args: map[string]interface{}{
-			"text": "\u001b\n", // ESC + newline (alt+enter sequence)
-		},
-		When: "terminalFocus",
-	}
-
-	keybindings = append(keybindings, newBinding)
-
-	// Create backup
-	if data != nil {
-		backupPath := keybindingsPath + ".backup"
-		_ = os.WriteFile(backupPath, data, 0644)
-	}
-
-	// Write updated keybindings
-	updatedData, err := json.MarshalIndent(keybindings, "", "  ")
-	if err != nil {
-		return false, ""
-	}
-
-	// Ensure parent directory exists
-	if err := os.MkdirAll(filepath.Dir(keybindingsPath), 0755); err != nil {
-		return false, ""
-	}
-
-	if err := os.WriteFile(keybindingsPath, updatedData, 0644); err != nil {
-		return false, ""
-	}
-
-	return true, keybindingsPath
-}
-
-// SetupCursorKeybindings adds shift+enter support to Cursor's integrated terminal
-// by modifying the user's keybindings.json file.
-// Cursor is a fork of VS Code, so it uses the same keybinding format.
-// Returns (wasModified, configPath) to allow caller to log the change.
-func SetupCursorKeybindings() (bool, string) {
-	// Get platform-specific Cursor config path
-	configDir, err := getCursorConfigPath()
-	if err != nil {
-		return false, ""
-	}
-
-	keybindingsPath := filepath.Join(configDir, "keybindings.json")
-
-	// Check if Cursor is installed (keybindings file or parent dir exists)
-	if _, err := os.Stat(filepath.Dir(keybindingsPath)); os.IsNotExist(err) {
-		// Cursor not installed, skip silently
-		return false, ""
-	}
-
-	// Read existing keybindings
-	var keybindings []VSCodeKeybinding
-
-	data, err := os.ReadFile(keybindingsPath)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			return false, ""
-		}
-		// File doesn't exist, start with empty array
-		keybindings = []VSCodeKeybinding{}
-	} else {
-		// Parse existing keybindings
-		if err := json.Unmarshal(data, &keybindings); err != nil {
-			// If parse fails, don't modify the file
-			return false, ""
-		}
-	}
-
-	// Check if shift+enter binding already exists
-	for _, kb := range keybindings {
-		if kb.Key == "shift+enter" && kb.Command == "workbench.action.terminal.sendSequence" {
-			// Already configured
-			return false, keybindingsPath
-		}
-	}
-
-	// Add shift+enter keybinding
-	newBinding := VSCodeKeybinding{
-		Key:     "shift+enter",
-		Command: "workbench.action.terminal.sendSequence",
-		Args: map[string]interface{}{
-			"text": "\u001b\n", // ESC + newline (alt+enter sequence)
-		},
-		When: "terminalFocus",
-	}
-
-	keybindings = append(keybindings, newBinding)
-
-	// Create backup
-	if data != nil {
-		backupPath := keybindingsPath + ".backup"
-		_ = os.WriteFile(backupPath, data, 0644)
-	}
-
-	// Write updated keybindings
-	updatedData, err := json.MarshalIndent(keybindings, "", "  ")
-	if err != nil {
-		return false, ""
-	}
-
-	// Ensure parent directory exists
-	if err := os.MkdirAll(filepath.Dir(keybindingsPath), 0755); err != nil {
-		return false, ""
-	}
-
-	if err := os.WriteFile(keybindingsPath, updatedData, 0644); err != nil {
-		return false, ""
-	}
-
-	return true, keybindingsPath
-}
-
-// SetupGhosttyKeybindings adds shift+enter support to Ghostty terminal
-// by appending to the user's config file.
-// Returns (wasModified, configPath) to allow caller to log the change.
-func SetupGhosttyKeybindings() (bool, string) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return false, ""
-	}
-
-	// Ghostty config location: ~/.config/ghostty/config
-	configPath := filepath.Join(home, ".config", "ghostty", "config")
-
-	// Check if config directory exists
-	configDir := filepath.Dir(configPath)
-	if _, err := os.Stat(configDir); os.IsNotExist(err) {
-		// Ghostty not installed, skip silently
-		return false, ""
-	}
-
-	// Read existing config if it exists
-	var existingContent []byte
-	if data, err := os.ReadFile(configPath); err == nil {
-		existingContent = data
-		// Check if shift+enter already configured
-		if strings.Contains(string(data), "keybind = shift+enter") {
-			return false, configPath
-		}
-	}
-
-	// Keybinding to add - send newline character (0x0a)
-	// Ghostty requires \x0a hex escape syntax, verified working
-	keybinding := "keybind = shift+enter=text:\\x0a\n"
-
-	// Append to config
-	newContent := append(existingContent, []byte(keybinding)...)
-
-	// Ensure directory exists
-	if err := os.MkdirAll(configDir, 0755); err != nil {
-		return false, ""
-	}
-
-	// Create backup if file exists
-	if existingContent != nil {
-		backupPath := configPath + ".backup"
-		_ = os.WriteFile(backupPath, existingContent, 0644)
-	}
-
-	// Write updated config
-	if err := os.WriteFile(configPath, newContent, 0644); err != nil {
-		return false, ""
-	}
-
-	return true, configPath
-}
-
-// SetupWezTermKeybindings adds shift+enter support to WezTerm
-// by appending to the user's .wezterm.lua file.
-// Returns (wasModified, configPath)
-func SetupWezTermKeybindings() (bool, string) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return false, ""
-	}
-
-	configPath := filepath.Join(home, ".wezterm.lua")
-
-	// Check if WezTerm config exists
-	if _, err := os.Stat(configPath); os.IsNotExist(err) {
-		// WezTerm not configured, skip silently
-		return false, ""
-	}
-
-	// Read existing config
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		return false, ""
-	}
-
-	// Check if shift+enter already configured
-	if strings.Contains(string(data), "key = 'Enter'") && strings.Contains(string(data), "mods = 'SHIFT'") {
-		return false, configPath
-	}
-
-	// Create backup
-	backupPath := configPath + ".backup"
-	_ = os.WriteFile(backupPath, data, 0644)
-
-	// Keybinding to add (insert before final return statement)
-	keybinding := `
--- Shift+Enter for newlines (added by Cline CLI)
-config.keys = config.keys or {}
-table.insert(config.keys, {
-  key = 'Enter',
-  mods = 'SHIFT',
-  action = wezterm.action.SendString '\x1b\n',
-})
-`
-
-	content := string(data)
-	// Try to insert before the final return statement
-	if strings.Contains(content, "return config") {
-		content = strings.Replace(content, "return config", keybinding+"\nreturn config", 1)
-	} else {
-		// No return statement, append at end
-		content += keybinding
-	}
-
-	// Write updated config
-	if err := os.WriteFile(configPath, []byte(content), 0644); err != nil {
-		return false, ""
-	}
-
-	return true, configPath
-}
-
-// SetupAlacrittyKeybindings adds shift+enter support to Alacritty
-// by appending to the user's alacritty.yml file.
-// Returns (wasModified, configPath)
-func SetupAlacrittyKeybindings() (bool, string) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return false, ""
-	}
-
-	// Try both possible locations
-	configPaths := []string{
-		filepath.Join(home, ".config", "alacritty", "alacritty.yml"),
-		filepath.Join(home, ".config", "alacritty", "alacritty.toml"),
-		filepath.Join(home, ".alacritty.yml"),
-	}
-
-	var configPath string
-	for _, path := range configPaths {
-		if _, err := os.Stat(path); err == nil {
-			configPath = path
-			break
-		}
-	}
-
-	if configPath == "" {
-		// Alacritty not configured, skip silently
-		return false, ""
-	}
-
-	// Read existing config
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		return false, ""
-	}
-
-	// Check if shift+enter already configured
-	if strings.Contains(string(data), "key: Return") && strings.Contains(string(data), "mods: Shift") {
-		return false, configPath
-	}
-
-	// Create backup
-	backupPath := configPath + ".backup"
-	_ = os.WriteFile(backupPath, data, 0644)
-
-	// Keybinding to add
-	var keybinding string
-	if strings.HasSuffix(configPath, ".yml") || strings.HasSuffix(configPath, ".yaml") {
-		keybinding = `
-# Shift+Enter for newlines (added by Cline CLI)
-key_bindings:
-  - { key: Return, mods: Shift, chars: "\x1b\n" }
-`
-	} else {
-		// TOML format
-		keybinding = `
-# Shift+Enter for newlines (added by Cline CLI)
-[[keyboard.bindings]]
-key = "Return"
-mods = "Shift"
-chars = "\x1b\n"
-`
-	}
-
-	// Append to config
-	newContent := append(data, []byte(keybinding)...)
-
-	// Write updated config
-	if err := os.WriteFile(configPath, newContent, 0644); err != nil {
-		return false, ""
-	}
-
-	return true, configPath
-}
-
-// SetupKittyKeybindings adds shift+enter support to Kitty terminal
-// by appending to the user's kitty.conf file.
-// Returns (wasModified, configPath)
-func SetupKittyKeybindings() (bool, string) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return false, ""
-	}
-
-	configPath := filepath.Join(home, ".config", "kitty", "kitty.conf")
-
-	// Check if config directory exists
-	configDir := filepath.Dir(configPath)
-	if _, err := os.Stat(configDir); os.IsNotExist(err) {
-		// Kitty not installed, skip silently
-		return false, ""
-	}
-
-	// Read existing config if it exists
-	var existingContent []byte
-	if data, err := os.ReadFile(configPath); err == nil {
-		existingContent = data
-		// Check if shift+enter already configured
-		if strings.Contains(string(data), "map shift+enter") {
-			return false, configPath
-		}
-	}
-
-	// Keybinding to add
-	keybinding := "# Shift+Enter for newlines (added by Cline CLI)\nmap shift+enter send_text all \\x1b\\n\n"
-
-	// Append to config
-	newContent := append(existingContent, []byte(keybinding)...)
-
-	// Ensure directory exists
-	if err := os.MkdirAll(configDir, 0755); err != nil {
-		return false, ""
-	}
-
-	// Create backup if file exists
-	if existingContent != nil {
-		backupPath := configPath + ".backup"
-		_ = os.WriteFile(backupPath, existingContent, 0644)
-	}
-
-	// Write updated config
-	if err := os.WriteFile(configPath, newContent, 0644); err != nil {
-		return false, ""
-	}
-
-	return true, configPath
-}

cli/pkg/cli/types/messages.go

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

cli/pkg/cli/updater/updater.go

@@ -68,7 +68,7 @@ func CheckAndUpdate(isVerbose bool) {
 
 	// Run in background so we don't block CLI startup
 	go func() {
-		if err := checkAndUpdateInternal(false); err != nil {
+		if err := checkAndUpdateSync(); err != nil {
 			if verbose {
 				output.Printf("[updater] Update check failed: %v\n", err)
 			}
@@ -76,49 +76,15 @@ func CheckAndUpdate(isVerbose bool) {
 	}()
 }
 
-// CheckAndUpdateSync performs a synchronous update check (blocks until complete).
-// If bypassCache is true, ignores the 24-hour cache and always checks npm registry.
-// This is used by the doctor command.
-func CheckAndUpdateSync(isVerbose bool, bypassCache bool) {
-	verbose = isVerbose
-
-	// Skip in CI environments
-	if os.Getenv("CI") != "" {
-		if verbose {
-			output.Printf("[updater] Skipping update check (CI environment)\n")
-		}
-		return
-	}
-
-	// Skip if user disabled auto-updates
-	if os.Getenv("NO_AUTO_UPDATE") != "" {
-		if verbose {
-			output.Printf("[updater] Skipping update check (NO_AUTO_UPDATE set)\n")
-		}
-		return
-	}
-
-	if verbose {
-		output.Printf("[updater] Starting update check...\n")
-	}
-
-	// Run synchronously
-	if err := checkAndUpdateInternal(bypassCache); err != nil {
-		if verbose {
-			output.Printf("[updater] Update check failed: %v\n", err)
-		}
-	}
-}
-
-func checkAndUpdateInternal(bypassCache bool) error {
+func checkAndUpdateSync() error {
 	if verbose {
 		output.Printf("[updater] Loading update cache...\n")
 	}
 
 	// Load cache
 	cache, err := loadCache()
-	if !bypassCache && err == nil && time.Since(cache.LastCheck) < checkInterval {
-		// Checked recently, skip (unless cache is bypassed)
+	if err == nil && time.Since(cache.LastCheck) < checkInterval {
+		// Checked recently, skip
 		if verbose {
 			output.Printf("[updater] Cache is fresh (last checked %v ago), skipping\n", time.Since(cache.LastCheck))
 		}
@@ -375,7 +341,7 @@ func showFailureMessage(channel string) {
 
 func getCacheFilePath() string {
 	configDir := filepath.Join(os.Getenv("HOME"), ".cline", "data")
-	return filepath.Join(configDir, "cli-update-cache")
+	return filepath.Join(configDir, ".update-cache")
 }
 
 func loadCache() (cacheData, error) {
@@ -406,4 +372,4 @@ func saveCache(cache cacheData) error {
 	}
 
 	return os.WriteFile(cacheFile, data, 0644)
-}
+}

cli/pkg/common/utils.go

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

cli/pkg/generated/providers.go

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

docs/cline-cli/cli-reference.mdx

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

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

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

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

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

docs/cline-cli/samples/overview.mdx

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

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

@@ -113,20 +113,6 @@ cline instances kill -a
 Keep track of instance addresses returned by `cline instance new`. When scripting multiple agents, store these IDs and direct your tasks to the appropriate instance.
 </Tip>
 
-## Configuring context window for local providers
-
-For Ollama and LM Studio, you can configure the model context window via CLI:
-
-```bash
-# For Ollama
-cline config s ollama-api-options-ctx-num=32768
-
-# For LM Studio
-cline config s lm-studio-max-tokens=32768
-```
-
-For other providers (Anthropic, OpenRouter, etc.), the context window is defined per model in the model metadata and is not user-configurable—Cline uses each model's built-in context limits automatically.
-
 ## Choosing the right flow
 
 - **Interactive mode**: Best for exploring new problems, learning how Cline works, or when you want to review plans before execution

docs/docs.json

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

docs/enterprise-solutions/managing-members.mdx

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

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

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

docs/enterprise-solutions/members/overview.mdx

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

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

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

docs/enterprise-solutions/onboarding.mdx

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

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

@@ -1,127 +0,0 @@
----
-title: "Configure AWS Bedrock Provider (Admin)"
-sidebarTitle: "Configure AWS Bedrock (Admin)"
-description: "This guide explains how administrators configure AWS Bedrock as the organization-wide LLM provider for Cline."
----
-
-As an administrator, you can add AWS Bedrock as the organization-wide LLM provider for all Cline users. 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
-
-To get started with setting up AWS Bedrock as your organization's LLM provider, you'll need a few items in place. 
-
-**Administrator access to the Cline Admin console**  
-You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
-
-<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. 
-
-<Note>
-If you don't have direct AWS access, coordinate with your cloud team to get these permissions set up before proceeding.
-</Note>
-
-**Your preferred AWS region**  
-Choose your primary AWS region carefully since this will be enforced for all users.
-
-<Tip>
-Check which models are available in your region first. Some newer models might not be available in all regions yet.
-</Tip>
-
-<Frame>
-	<img
-		src="https://storage.googleapis.com/cline-static-assets-prod/assets/AWS%20Remote%20Config.gif"
-	/>
-</Frame>
-
-## Configuration Steps
-
-<Steps>
-<Step title="Access Cline Settings">
-Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
-
-<Info>
-You should see the provider configuration options if you have the correct admin access level.
-</Info>
-</Step>
-
-<Step title="Enable Remote Provider Configuration">
-Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
-</Step>
-
-<Step title="Select AWS Bedrock as the API Provider">
-Open the **API Provider** dropdown menu and select **Amazon Bedrock**. This will open the Bedrock configuration panel where you'll configure all your organization-wide settings.
-</Step>
-
-<Step title="Configure Bedrock Settings">
-The configuration panel includes several settings that control how Bedrock works for your organization. Configure what you need:
-
-<AccordionGroup>
-<Accordion title="Region (required)">
-Enter your preferred AWS region like `us-west-2` or `us-east-1`. This region will be enforced for all organization members.
-
-[View AWS Global Infrastructure](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/)
-
-<Tip>
-For most organizations, `us-east-1` or `us-west-2` are recommended as they have the best model availability.
-</Tip>
-</Accordion>
-
-<Accordion title="Custom VPC Endpoint (optional)">
-If your organization uses a private VPC endpoint for Bedrock, specify it here to ensure all API calls go through your network infrastructure.
-
-[Learn more about AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html)
-</Accordion>
-
-<Accordion title="Cross-region Inference (optional)">
-Enable this to let Bedrock automatically route requests to other regions when your primary region has capacity constraints. Useful for maintaining availability during high-demand periods.
-
-[Learn more about Inference Profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html)
-</Accordion>
-
-<Accordion title="Global Inference Profile (optional)">
-Turn this on to use AWS's global inference routing, which automatically directs requests to the optimal region based on availability and latency.
-</Accordion>
-
-<Accordion title="Prompt Caching (optional)">
-Enable prompt caching to reduce costs and latency. Bedrock caches portions of prompts that remain consistent across requests, making repeated interactions faster and cheaper.
-
-[Learn more about Prompt Caching](https://docs.aws.amazon.com/bedrock/latest/userguide/prompt-caching.html)
-</Accordion>
-</AccordionGroup>
-</Step>
-
-<Step title="Save Configuration">
-After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
-
-Once saved, all organization members signed into the Cline extension will automatically use AWS Bedrock with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
-
-<Warning>
-Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
-</Warning>
-</Step>
-</Steps>
-
-## Verification
-
-To verify the configuration:
-
-1. Check that the provider shows as "Amazon Bedrock" in the Enabled provider field
-2. Confirm the settings persist after refreshing the page
-3. Test with a member account to ensure they see only Bedrock as a provider
-
-## Troubleshooting
-
-**Members don't see the configured provider**  
-Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
-
-**Configuration changes don't persist**  
-Make sure to click the Save button on the main settings page, not just close the configuration panel.
-
-**Need to change regions later**  
-You can update the region at any time. Members will need to ensure their local AWS credentials have access to the new region. For more information, refer to the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html).
-
-For further details, consult the [AWS Bedrock Documentation](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) and coordinate with your internal cloud team.

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

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

docs/enterprise-solutions/security-concerns.mdx

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

docs/features/checkpoints.mdx

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

docs/features/cline-rules.mdx

@@ -81,20 +81,6 @@ your-project/
 
 Cline's system prompt, on the other hand, is not user-editable ([here's where you can find it](https://github.com/cline/cline/blob/main/src/core/prompts/system.ts)). For a broader look at prompt engineering best practices, check out [this resource](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview).
 
-### AGENTS.md Standard Support
-
-Cline also supports the [AGENTS.md](https://agents.md/) standard as a fallback 
-(in addition to Cline Rules) by automatically detecting `AGENTS.md` files in 
-your workspace root. This allows you to use the same rules file across different AI 
-coding tools.
-
-```
-your-project/
-├── AGENTS.md
-├── src/
-└── ...
-```
-
 ### Tips for Writing Effective Cline Rules
 
 -   Be Clear and Concise: Use simple language and avoid ambiguity.

docs/features/customization/opening-cline-in-sidebar.mdx

@@ -42,17 +42,17 @@ To open Cline in the right sidebar:
     4. Set the value to `vertical`
     5. Restart Cursor for the changes to take effect
   </Step>
-  <Step title="Open the AI Pane">
-    Click the Cursor cube icon button (AI Pane) that opens Cursor's agent (right side view panel)
+  <Step title="Open Agent Panel">
+    Click the Cursor cube icon button that opens Cursor's agent (right side view panel)
   </Step>
-  <Step title="Drag Cline to the AI Pane Sidebar">
-    Drag the Cline icon directly into the AI Pane sidebar.
+  <Step title="Drag to Three Dots">
+    Drag the Cline icon directly onto the three dots button - it doesn't work if you just drag it to the top, it has to be the three dots
   </Step>
 </Steps>
 
 <Frame>
 	<img
-		src="https://storage.googleapis.com/cline_public_images/Cursor-sidebar.gif"
+		src="https://storage.googleapis.com/cline_public_images/cursor-side-bar.gif"
 		alt="Cursor Right Sidebar Setup"
 	/>
 </Frame>

docs/features/dictation.mdx

@@ -3,7 +3,7 @@ title: "Dictation"
 description: "Communicate with Cline using your voice for faster, more natural AI collaboration"
 ---
 
-Dictation transforms how you work with AI. Instead of typing out complex thoughts, you speak naturally and share your complete intent. This isn't just about speed - though voice is faster - it's about enabling fluid collaboration that typing can't match.
+Dictation transforms how you work with AI. Instead of typing out complex thoughts, you speak naturally and share your complete intent. This isn't just about speed - though voice is faster - it's about unlocking the kind of fluid collaboration that typing can't match.
 
 ## Why Voice Changes Everything
 
@@ -35,14 +35,11 @@ Dictation works with any AI model you've configured. The transcription happens t
 
 ## System Requirements
 
-<Note>
-Dictation is currently not available on Windows. Support for Windows is planned for a future release.
-</Note>
-
 Dictation uses FFmpeg to capture your voice across all platforms:
 
 - **macOS**: FFmpeg (via Homebrew: `brew install ffmpeg`)
 - **Linux**: FFmpeg (via apt: `sudo apt-get install ffmpeg`)
+- **Windows**: FFmpeg (via winget: `winget install Gyan.FFmpeg`)
 
 If you don't have FFmpeg installed, Cline will automatically detect this and prompt you to install it with a single click.
 

docs/features/explain-changes.mdx

@@ -1,90 +0,0 @@
----
-title: "Explain Changes"
-sidebarTitle: "Explain Changes"
----
-
-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
-		autoPlay
-		loop
-		muted
-		playsInline
-		src="https://storage.googleapis.com/cline_public_images/explain-code-button.mp4"
-	/>
-</Frame>
-
-
-## How It Works
-
-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:
-
-1. Opens a multi-file diff view showing all changed files
-2. Streams AI-generated explanations as inline comments
-3. Places comments at relevant code locations to explain what changed and why
-
-The AI uses the full conversation context to provide meaningful explanations, not just describing what code does, but explaining the reasoning behind the changes.
-
-## Interactive Comment Threads
-
-One of the most powerful aspects of Explain Changes is that the comments are fully interactive. You can have conversations directly within each comment thread.
-
-### Asking Follow-up Questions
-
-Each explanation comment has a reply input where you can ask questions about that specific piece of code:
-
-- "Why did you use this approach instead of X?"
-- "Can you explain this pattern in more detail?"
-- "What would happen if we changed this to Y?"
-
-The AI will respond with context-aware answers, understanding both the code being discussed and the original task context.
-
-### Moving to Main Chat
-
-If a conversation in a comment thread becomes complex or you want to continue working on that code, click the title area of the comment thread to move the entire conversation into Cline's main chat input. This lets you:
-
-- Continue the discussion with full Cline capabilities
-- Have Cline make additional changes based on the discussion
-- Keep the context from your review conversation
-
-## When to Use Explain Changes
-
-### Learning and Onboarding
-
-When you're new to a codebase or working with unfamiliar patterns, Explain Changes helps you understand not just what Cline did, but why. The explanations cover:
-
-- Design decisions and trade-offs
-- Technical concepts and patterns used
-- Relationships between different changes
-
-### Code Review
-
-Use Explain Changes as part of your review process:
-
-- Understand complex changes before committing
-- Verify the AI's reasoning matches your expectations
-- Catch potential issues by understanding the full context
-
-### Knowledge Transfer
-
-The explanations serve as documentation for your changes. When other team members review your code, they can see the reasoning behind each modification.
-
-## Best Practices
-
-1. **Ask specific questions**: The more specific your follow-up questions, the more useful the AI's responses will be.
-
-2. **Use for complex changes**: Explain Changes is most valuable for multi-file changes or complex logic. For simple changes, the diff view alone may be sufficient.
-
-3. **Move important discussions to chat**: If a comment thread reveals something that needs more work, move it to main chat to take action.
-
-4. **Review before committing**: Use Explain Changes as a final check before committing changes to ensure you understand everything Cline did.
-
-## Related Features
-
-- [Checkpoints](/features/checkpoints) - Required for Explain Changes to work
-- [/explain-changes](/features/slash-commands/explain-changes) - Slash command to explain any git diff

docs/features/hooks.mdx

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

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

@@ -1,283 +0,0 @@
----
-title: "Explain Changes Command"
-sidebarTitle: "/explain-changes"
----
-
-`/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.
-
-
-	<video
-		src="https://storage.googleapis.com/cline_public_images/slash-code-explain.mp4"
-		autoPlay
-		loop
-		muted
-		playsInline
-	/>
-
-## Requirements
-
-<Note>
-The `/explain-changes` command requires a **git repository**. Make sure you're working in a directory that has been initialized with git.
-</Note>
-
-For PR explanations, you'll need the [GitHub CLI (gh)](https://cli.github.com/) installed and authenticated. For GitLab merge request explanations, you'll need the [GitLab CLI (glab)](https://gitlab.com/gitlab-org/cli) installed and authenticated.
-
-Unlike the Explain Changes button, this command does **not** require checkpoints to be enabled since it uses git references directly.
-
-
-## Using the Command
-
-Type `/explain-changes` in the chat input. Cline will:
-
-1. Analyze your git history to understand what changes exist
-2. Gather context by reading relevant files
-3. Determine appropriate git references to compare
-4. Generate a diff view with streaming inline explanations
-
-
-## How It Works
-
-When you use `/explain-changes`, Cline:
-
-1. **Gathers context**: Runs git commands to understand your repository state
-2. **Identifies changes**: Determines which files changed between references
-3. **Reads relevant files**: Builds context for better explanations
-4. **Calls generate_explanation**: Creates the diff view and streams explanations
-5. **Displays results**: Opens a multi-file diff with inline comments
-
-## Use Cases
-
-### Explain the Last Commit
-
-The most common use case - understand what changed in the most recent commit:
-
-```
-/explain-changes
-```
-
-Cline will examine HEAD and compare it to HEAD~1, explaining all the changes in that commit.
-
-**When to use:**
-- After pulling changes from a teammate
-- Reviewing your own work before pushing
-- Understanding what a merge commit brought in
-
-### Explain Uncommitted Changes
-
-Understand your work-in-progress changes before committing:
-
-```
-/explain-changes for my uncommitted work
-```
-
-Cline compares HEAD to your working directory, explaining all modified files.
-
-**When to use:**
-- Before staging changes to ensure they're complete
-- After a long coding session to remember what you changed
-- To verify changes before creating a commit
-
-### Explain Staged Changes
-
-Review exactly what you're about to commit:
-
-```
-/explain-changes for my staged changes
-```
-
-Cline examines only the changes you've staged with `git add`.
-
-**When to use:**
-- Final review before committing
-- When you've staged a subset of changes and want to verify
-- To ensure you haven't accidentally staged unintended files
-
-### Explain a Specific Commit
-
-Understand any commit in your history:
-
-```
-/explain-changes for commit abc123
-```
-
-Or by commit message:
-
-```
-/explain-changes for the commit that added authentication
-```
-
-Cline will find the commit and explain what it changed.
-
-**When to use:**
-- Investigating when a bug was introduced
-- Understanding historical decisions
-- Learning how a feature was implemented
-
-### Explain a Range of Commits
-
-Understand multiple commits at once:
-
-```
-/explain-changes for the last 3 commits
-```
-
-Or a specific range:
-
-```
-/explain-changes from v1.0.0 to v1.1.0
-```
-
-Cline compares the endpoints and explains all changes between them.
-
-**When to use:**
-- Understanding what changed in a release
-- Reviewing a series of related commits
-- Catching up after being away from the project
-
-### Explain a Pull Request
-
-Get AI explanations for any PR:
-
-```
-/explain-changes for PR #42
-```
-
-Cline uses the GitHub CLI to fetch PR details and explain the changes.
-
-**When to use:**
-- Reviewing someone else's PR
-- Understanding a PR before approving
-- Learning from PRs in open source projects
-- Preparing to give PR feedback
-
-### Explain Branch Differences
-
-Compare any two branches:
-
-```
-/explain-changes between main and feature-branch
-```
-
-Or see what's changed on a feature branch:
-
-```
-/explain-changes for everything on my-feature that's not in main
-```
-
-**When to use:**
-- Before merging a feature branch
-- Understanding divergence between branches
-- Planning a merge or rebase strategy
-- Reviewing what a colleague has been working on
-
-### Explain Changes to Specific Files
-
-Focus on particular files or directories:
-
-```
-/explain-changes for src/auth in the last 5 commits
-```
-
-Cline filters the diff to show only relevant changes.
-
-**When to use:**
-- Understanding changes to a specific module
-- Tracking modifications to critical files
-- Learning how a particular feature evolved
-
-### Explain Changes Since a Tag
-
-Understand what's changed since a release:
-
-```
-/explain-changes since v2.0.0
-```
-
-Cline compares the tag to HEAD and explains all subsequent changes.
-
-**When to use:**
-- Preparing release notes
-- Understanding what's new since a deployment
-- Identifying changes for a changelog
-
-### Explain a Merge Commit
-
-Understand what a merge brought in:
-
-```
-/explain-changes for the merge from feature-x
-```
-
-Cline explains all the changes that were merged.
-
-**When to use:**
-- After merging a large feature branch
-- Understanding what a merge conflict resolution changed
-- Reviewing what others merged into main
-
-### Explain Stashed Changes
-
-Review what's in your stash:
-
-```
-/explain-changes for my stashed changes
-```
-
-Cline examines stash@{0} and explains its contents.
-
-**When to use:**
-- Before applying a stash
-- Deciding whether to keep or drop a stash
-- Remembering what you stashed days ago
-
-## Interactive Comments
-
-Just like the [Explain Changes](/features/explain-changes) button, the generated comments are fully interactive:
-
-### Reply to Comments
-
-Ask follow-up questions directly in any comment thread:
-
-- "Why was this function refactored?"
-- "What's the purpose of this new parameter?"
-- "Could this cause any breaking changes?"
-- "Is this change backwards compatible?"
-
-The AI responds with context-aware explanations, understanding both the code and the broader changes.
-
-### Move to Main Chat
-
-Click the title area of any comment thread to move that conversation into Cline's main chat. This is useful when:
-
-- You want Cline to make additional changes
-- The discussion reveals something that needs more investigation
-- You want to continue working with full Cline capabilities
-- A review comment sparks an idea for improvements
-
-### The generate_explanation Tool
-
-Under the hood, `/explain-changes` uses the `generate_explanation` tool with these parameters:
-
-| Parameter | Description | Example |
-|-----------|-------------|---------|
-| `title` | Descriptive title for the diff view | "Changes in commit abc123" |
-| `from_ref` | Git reference for the "before" state | `HEAD~1`, `main`, `origin/main` |
-| `to_ref` | Git reference for the "after" state (optional) | `HEAD`, `develop` |
-
-If `to_ref` is omitted, the tool compares against the working directory.
-
-## Tips for Better Explanations
-
-1. **Be specific**: Instead of just `/explain-changes`, tell Cline what you want explained. "Explain the authentication changes in PR #42" gives better context than just "explain PR #42".
-
-2. **Ask about intent**: The AI can explain not just what changed but why. Ask follow-up questions like "What problem was this solving?"
-
-3. **Chain with other commands**: Use `/explain-changes` after investigating an issue to understand potential fixes, then continue with Cline to implement improvements.
-
-4. **Use for learning**: When onboarding to a new codebase, use `/explain-changes` on significant PRs or commits to understand how features were built.
-
-## Related Features
-
-- [Explain Changes](/features/explain-changes) - The button-based version for task completions
-- [Checkpoints](/features/checkpoints) - Enables the Explain Changes button
-- [@git mentions](/features/at-mentions/git-mentions) - Reference git diffs in your prompts

docs/features/slash-commands/workflows.mdx

@@ -0,0 +1,445 @@
+---
+title: "Workflows"
+sidebarTitle: "Workflows"
+---
+
+Workflows allow you to define a series of steps to guide Cline through a repetitive set of tasks, such as deploying a service or submitting a PR.
+
+To invoke a workflow, type `/[workflow-name.md]` in the chat.
+
+## How to Create and Use Workflows
+
+Workflows live alongside [Cline Rules](/features/cline-rules). Creating one is straightforward:
+
+<Frame>
+	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/workflows.png" alt="Workflows tab in Cline" />
+</Frame>
+
+1. Create a markdown file with clear instructions for the steps Cline should take
+2. Save it with a `.md` extension in your workflows directory
+3. To trigger a workflow, just type `/` followed by the workflow filename
+4. Provide any required parameters when prompted
+
+The real power comes from how you structure your workflow files. You can:
+
+-   Leverage Cline's [built-in tools](/exploring-clines-tools/cline-tools-guide) like `ask_followup_question`, `read_file`, `search_files`, and `new_task`
+-   Use command-line tools you already have installed like `gh` or `docker`
+-   Reference external [MCP tool calls](/mcp/mcp-overview) like Slack or Whatsapp
+-   Chain multiple actions together in a specific sequence
+
+## Real-world Example
+
+I created a PR Review workflow that's already saving me tons of time.
+
+````md pr-review.md [expandable]
+You have access to the `gh` terminal command. I already authenticated it for you. Please review it to use the PR that I asked you to review. You're already in the `cline` repo.
+
+<detailed_sequence_of_steps>
+
+# GitHub PR Review Process - Detailed Sequence of Steps
+
+## 1. Gather PR Information
+
+1. Get the PR title, description, and comments:
+
+    ```bash
+    gh pr view <PR-number> --json title,body,comments
+    ```
+
+2. Get the full diff of the PR:
+    ```bash
+    gh pr diff <PR-number>
+    ```
+
+## 2. Understand the Context
+
+1. Identify which files were modified in the PR:
+
+    ```bash
+    gh pr view <PR-number> --json files
+    ```
+
+2. Examine the original files in the main branch to understand the context:
+
+    ```xml
+    <read_file>
+    <path>path/to/file</path>
+    </read_file>
+    ```
+
+3. For specific sections of a file, you can use search_files:
+    ```xml
+    <search_files>
+    <path>path/to/directory</path>
+    <regex>search term</regex>
+    <file_pattern>*.ts</file_pattern>
+    </search_files>
+    ```
+
+## 3. Analyze the Changes
+
+1. For each modified file, understand:
+
+    - What was changed
+    - Why it was changed (based on PR description)
+    - How it affects the codebase
+    - Potential side effects
+
+2. Look for:
+    - Code quality issues
+    - Potential bugs
+    - Performance implications
+    - Security concerns
+    - Test coverage
+
+## 4. Ask for User Confirmation
+
+1. Before making a decision, ask the user if you should approve the PR, providing your assessment and justification:
+
+    ```xml
+    <ask_followup_question>
+    <question>Based on my review of PR #<PR-number>, I recommend [approving/requesting changes]. Here's my justification:
+
+    [Detailed justification with key points about the PR quality, implementation, and any concerns]
+
+    Would you like me to proceed with this recommendation?</question>
+    <options>["Yes, approve the PR", "Yes, request changes", "No, I'd like to discuss further"]</options>
+    </ask_followup_question>
+    ```
+
+## 5. Ask if User Wants a Comment Drafted
+
+1. After the user decides on approval/rejection, ask if they would like a comment drafted:
+
+    ```xml
+    <ask_followup_question>
+    <question>Would you like me to draft a comment for this PR that you can copy and paste?</question>
+    <options>["Yes, please draft a comment", "No, I'll handle the comment myself"]</options>
+    </ask_followup_question>
+    ```
+
+2. If the user wants a comment drafted, provide a well-structured comment they can copy:
+
+    ```
+    Thank you for this PR! Here's my assessment:
+
+    [Detailed assessment with key points about the PR quality, implementation, and any suggestions]
+
+    [Include specific feedback on code quality, functionality, and testing]
+    ```
+
+## 6. Make a Decision
+
+1. Approve the PR if it meets quality standards:
+
+    ```bash
+    # For single-line comments:
+    gh pr review <PR-number> --approve --body "Your approval message"
+
+    # For multi-line comments with proper whitespace formatting:
+    cat << EOF | gh pr review <PR-number> --approve --body-file -
+    Thanks @username for this PR! The implementation looks good.
+
+    I particularly like how you've handled X and Y.
+
+    Great work!
+    EOF
+    ```
+
+2. Request changes if improvements are needed:
+
+    ```bash
+    # For single-line comments:
+    gh pr review <PR-number> --request-changes --body "Your feedback message"
+
+    # For multi-line comments with proper whitespace formatting:
+    cat << EOF | gh pr review <PR-number> --request-changes --body-file -
+    Thanks @username for this PR!
+
+    The implementation looks promising, but there are a few things to address:
+
+    1. Issue one
+    2. Issue two
+
+    Please make these changes and we can merge this.
+    EOF
+    ```
+
+    Note: The `cat << EOF | ... --body-file -` approach preserves all whitespace and formatting without requiring temporary files. The `-` parameter tells the command to read from standard input.
+    </detailed_sequence_of_steps>
+
+<example_review_process>
+
+# Example PR Review Process
+
+Let's walk through a real example of reviewing PR #3627 which fixes the thinking mode calculation for Claude 3.7 models.
+
+## Step 1: Gather PR Information
+
+```bash
+# Get PR details
+gh pr view 3627 --json title,body,comments
+
+# Get the full diff
+gh pr diff 3627
+```
+
+## Step 2: Understand the Context
+
+```xml
+# Examine the original files to understand what's being changed
+<read_file>
+<path>src/shared/api.ts</path>
+</read_file>
+
+# Look at the ThinkingBudgetSlider component implementation
+<read_file>
+<path>webview-ui/src/components/settings/ThinkingBudgetSlider.tsx</path>
+</read_file>
+
+# Check how thinking mode is currently handled in API providers
+<search_files>
+<path>src/api/providers</path>
+<regex>reasoningOn</regex>
+<file_pattern>*.ts</file_pattern>
+</search_files>
+```
+
+## Step 3: Analyze the Changes
+
+From the PR information and code examination, we can see that:
+
+1. The PR fixes an issue with the thinking mode budget calculation for Claude 3.7 models
+2. Currently, the thinking budget is incorrectly calculated as 80% of maxTokens (8192), resulting in 6553 tokens
+3. Claude 3.7 actually supports a much larger thinking budget (up to 64000 tokens)
+4. The PR adds a `thinkingConfig` property with `maxBudget: 64000` to model definitions
+5. It updates API handlers to use this value when reasoning mode is enabled
+6. It enhances the slider component to calculate max values based on model-specific percentages
+7. Comprehensive tests were added to verify the calculations
+
+## Step 4: Ask for User Confirmation
+
+```xml
+<ask_followup_question>
+<question>Based on my review of PR #3627, I recommend approving this PR. Here's my justification:
+
+1. The PR correctly fixes the thinking mode budget calculation for Claude 3.7 models
+2. It properly implements the thinkingConfig.maxBudget property (64000) for Claude 3.7 models
+3. It applies the appropriate percentage (50%) for the slider calculation
+4. The changes are well-tested with comprehensive unit tests
+5. The implementation is clean and follows the project's coding standards
+6. The PR includes helpful screenshots demonstrating the fix
+
+Would you like me to proceed with approving this PR?</question>
+<options>["Yes, approve the PR", "No, I'd like to discuss further", "Let me review it myself first"]</options>
+</ask_followup_question>
+```
+
+## Step 5: Ask if User Wants a Comment Drafted
+
+```xml
+<ask_followup_question>
+<question>Would you like me to draft a comment for this PR that you can copy and paste?</question>
+<options>["Yes, please draft a comment", "No, I'll handle the comment myself"]</options>
+</ask_followup_question>
+```
+
+## Step 6: Make a Decision
+
+```bash
+# Option 1: Simple one-line comment
+gh pr review 3627 --approve --body "This PR looks good! It correctly fixes the thinking mode budget calculation for Claude 3.7 models."
+
+# Option 2: Multi-line comment with proper whitespace formatting
+cat << EOF | gh pr review 3627 --approve --body-file -
+This PR looks good! It correctly fixes the thinking mode budget calculation for Claude 3.7 models.
+
+I particularly like:
+1. The proper implementation of thinkingConfig.maxBudget property (64000)
+2. The appropriate percentage (50%) for the slider calculation
+3. The comprehensive unit tests
+4. The clean implementation that follows project coding standards
+
+Great work!
+EOF
+```
+
+</example_review_process>
+
+<common_gh_commands>
+
+# Common GitHub CLI Commands for PR Review
+
+## Basic PR Commands
+
+```bash
+# List open PRs
+gh pr list
+
+# View a specific PR
+gh pr view <PR-number>
+
+# View PR with specific fields
+gh pr view <PR-number> --json title,body,comments,files,commits
+
+# Check PR status
+gh pr status
+```
+
+## Diff and File Commands
+
+```bash
+# Get the full diff of a PR
+gh pr diff <PR-number>
+
+# List files changed in a PR
+gh pr view <PR-number> --json files
+
+# Check out a PR locally
+gh pr checkout <PR-number>
+```
+
+## Review Commands
+
+```bash
+# Approve a PR (single-line comment)
+gh pr review <PR-number> --approve --body "Your approval message"
+
+# Approve a PR (multi-line comment with proper whitespace)
+cat << EOF | gh pr review <PR-number> --approve --body-file -
+Your multi-line
+approval message with
+
+proper whitespace formatting
+EOF
+
+# Request changes on a PR (single-line comment)
+gh pr review <PR-number> --request-changes --body "Your feedback message"
+
+# Request changes on a PR (multi-line comment with proper whitespace)
+cat << EOF | gh pr review <PR-number> --request-changes --body-file -
+Your multi-line
+change request with
+
+proper whitespace formatting
+EOF
+
+# Add a comment review (without approval/rejection)
+gh pr review <PR-number> --comment --body "Your comment message"
+
+# Add a comment review with proper whitespace
+cat << EOF | gh pr review <PR-number> --comment --body-file -
+Your multi-line
+comment with
+
+proper whitespace formatting
+EOF
+```
+
+## Additional Commands
+
+```bash
+# View PR checks status
+gh pr checks <PR-number>
+
+# View PR commits
+gh pr view <PR-number> --json commits
+
+# Merge a PR (if you have permission)
+gh pr merge <PR-number> --merge
+```
+
+</common_gh_commands>
+
+<general_guidelines_for_commenting>
+When reviewing a PR, please talk normally and like a friendly reviwer. You should keep it short, and start out by thanking the author of the pr and @ mentioning them.
+
+Whether or not you approve the PR, you should then give a quick summary of the changes without being too verbose or definitive, staying humble like that this is your understanding of the changes. Kind of how I'm talking to you right now.
+
+If you have any suggestions, or things that need to be changed, request changes instead of approving the PR.
+
+Leaving inline comments in code is good, but only do so if you have something specific to say about the code. And make sure you leave those comments first, and then request changes in the PR with a short comment explaining the overall theme of what you're asking them to change.
+</general_guidelines_for_commenting>
+
+<example_comments_that_i_have_written_before>
+<brief_approve_comment>
+Looks good, though we should make this generic for all providers & models at some point
+</brief_approve_comment>
+<brief_approve_comment>
+Will this work for models that may not match across OR/Gemini? Like the thinking models?
+</brief_approve_comment>
+<approve_comment>
+This looks great! I like how you've handled the global endpoint support - adding it to the ModelInfo interface makes total sense since it's just another capability flag, similar to how we handle other model features.
+
+The filtered model list approach is clean and will be easier to maintain than hardcoding which models work with global endpoints. And bumping the genai library was obviously needed for this to work.
+
+Thanks for adding the docs about the limitations too - good for users to know they can't use context caches with global endpoints but might get fewer 429 errors.
+</approve_comment>
+<requesst_changes_comment>
+This is awesome. Thanks @scottsus.
+
+My main concern though - does this work for all the possible VS Code themes? We struggled with this initially which is why it's not super styled currently. Please test and share screenshots with the different themes to make sure before we can merge
+</request_changes_comment>
+<request_changes_comment>
+Hey, the PR looks good overall but I'm concerned about removing those timeouts. Those were probably there for a reason - VSCode's UI can be finicky with timing.
+
+Could you add back the timeouts after focusing the sidebar? Something like:
+
+```typescript
+await vscode.commands.executeCommand("claude-dev.SidebarProvider.focus")
+await setTimeoutPromise(100) // Give UI time to update
+visibleWebview = WebviewProvider.getSidebarInstance()
+```
+
+</request_changes_comment>
+<request_changes_comment>
+Heya @alejandropta thanks for working on this!
+
+A few notes:
+1 - Adding additional info to the environment variables is fairly problematic because env variables get appended to **every single message**. I don't think this is justifiable for a somewhat niche use case.
+2 - Adding this option to settings to include that could be an option, but we want our options to be simple and straightforward for new users
+3 - We're working on revisualizing the way our settings page is displayed/organized, and this could potentially be reconciled once that is in and our settings page is more clearly delineated.
+
+So until the settings page is update, and this is added to settings in a way that's clean and doesn't confuse new users, I don't think we can merge this. Please bear with us.
+</request_changes_comment>
+<request_changes_comment>
+Also, don't forget to add a changeset since this fixes a user-facing bug.
+
+The architectural change is solid - moving the focus logic to the command handlers makes sense. Just don't want to introduce subtle timing issues by removing those timeouts.
+</request_changes_comment>
+</example_comments_that_i_have_written_before>
+````
+
+When I get a new PR to review, I used to manually gather context: checking the PR description, examining the diff, looking at surrounding files, and finally forming an opinion. Now I just:
+
+1. Type `/pr-review.md` in chat
+2. Paste in the PR number
+3. Let Cline handle everything else
+
+My workflow uses the `gh` command-line tool and Cline's built in `ask_followup_question` to:
+
+-   Pull the PR description and comments
+-   Examine the diff
+-   Check surrounding files for context
+-   Analyze potential issues
+-   Asks me if it's cool approve it if everything looks good, with justification for why it should be approved
+-   If I say "yes," Cline automatically approves the PR with the `gh` command
+
+This has taken my PR review process from a manual, multi-step operation to a single command that gives me everything I need to make an informed decision.
+
+> This is just one example of a workflow file. You can find more in our [prompts repository](https://github.com/cline/prompts) for inspiration.
+
+## Building Your Own Workflows
+
+The beauty of workflows is they're completely customizable to your needs. You might create workflows for all kinds of repetitive tasks:
+
+-   For releases, you could have a workflow that grabs all merged PRs, builds a changelog, and handles version bumps.
+-   Setting up new projects is perfect for workflows. Just run one command to create your folder structure, install dependencies, and set up configs.
+-   Need to create a report? Create a workflow that grabs stats from different sources and formats them exactly how you like. You can even visualize them with a charting library and then make a presentation out of it with a library like [slidev](https://sli.dev/).
+-   You can even use workflows to draft messages to your team using an MCP server like Slack or Whatsapp after you submit a PR.
+
+With Workflows, your imagination is the limit. The true potential comes from spotting those annoying repetitive tasks you do all the time.
+
+If you can describe something as "first I do X, then Y, then Z" - that's a perfect workflow candidate.
+
+Start with something small that bugs you, turn it into a workflow, and keep refining it. You'll be shocked how much of your day can be automated this way.

docs/features/slash-commands/workflows/best-practices.mdx

@@ -1,135 +0,0 @@
----
-title: "Workflows Best Practices"
-sidebarTitle: "Best Practices"
-description: "Tips and strategies for creating effective and reliable Cline workflows."
----
-
-Creating effective workflows requires a balance of clear instructions, modular design, and intelligent tool usage. Follow these best practices to get the most out of Cline's automation capabilities.
-
-## Use Cline to Build Workflows
-
-We highly recommend using Cline to help you build your workflows. Since Cline understands your project's context and structure, it can be an invaluable partner in designing automation that fits your specific needs.
-
-### Building your own workflows
-
-Creating a workflow is simpler than you might think. There's actually a workflow for building workflows!
-
-First, **save the [create-new-workflow.md](https://github.com/cline/prompts/blob/main/workflows/create-new-workflow.md) file to your workspace** (e.g., in `.clinerules/workflows/`).
-
-Then, type `/create-new-workflow.md` and Cline guides you through it:
-
-1.  It asks for the purpose and a concise name.
-2.  You describe the objective and expected outputs.
-3.  You list the major steps (Cline can help determine details).
-4.  It generates the properly structured workflow file.
-
-<Tip>
-  **Automate Your History:** The best workflows come from tasks you've already done. After completing something you'll need to repeat, tell Cline: "Create a workflow for the process I just completed." It analyzes the conversation, identifies the steps, and generates the workflow file. Your accumulated context becomes reusable automation.
-</Tip>
-
-Workflows live in `.clinerules/workflows/` for project-specific ones or `~/Documents/Cline/Workflows/` for global ones you use across projects. Project workflows take precedence when names match.
-
-## Workflow Design
-
-<Tip>
-  **Start Simple:** Begin with small, single-task workflows. As you get comfortable, you can combine them or create more complex sequences.
-</Tip>
-
-### Be Modular
-Instead of creating one massive workflow file, break complex tasks into smaller, reusable workflows. This makes them easier to maintain and debug.
-
-### Use Clear Comments
-Just like with code, commenting your workflow steps is crucial. Explain *why* a step is happening, not just *what* is happening. This helps both you (the future maintainer) and Cline understand the intent.
-
-### Version Control
-Treat your workflows as part of your codebase. Store them in your Git repository (in `.clinerules/workflows/`) so they are versioned, reviewed, and shared with your team.
-
-## Prompt Engineering for Cline
-
-### Be Specific with Tool Use
-Don't just say "find the file." Be explicit about which tool Cline should use.
-
-*   **Bad:** "Find the user controller."
-*   **Good:** "Use `search_files` to look for `UserController` in the `src/controllers` directory."
-
-## Advanced Techniques
-
-### Available Tools
-
-Cline has a powerful set of tools you can use within your workflows. Here are the most common ones:
-
-#### execute_command
-Executes a CLI command on your system. Use this for running tests, builds, git commands, or any other terminal operation.
-
-```xml
-<execute_command>
-  <command>npm run test</command>
-  <requires_approval>false</requires_approval>
-</execute_command>
-```
-
-#### read_file
-Reads the contents of a file. Essential for analyzing code or configuration.
-
-```xml
-<read_file>
-  <path>src/config.json</path>
-</read_file>
-```
-
-#### write_to_file
-Creates or overwrites a file. Use this to generate boilerplate, config files, or documentation.
-
-```xml
-<write_to_file>
-  <path>src/components/Button.tsx</path>
-  <content>
-    // File content goes here...
-  </content>
-</write_to_file>
-```
-
-#### search_files
-Searches for a regex pattern across files in a directory. Great for finding TODOs, usage examples, or specific code patterns.
-
-```xml
-<search_files>
-  <path>src</path>
-  <regex>TODO</regex>
-  <file_pattern>*.ts</file_pattern>
-</search_files>
-```
-
-#### ask_followup_question
-Asks the user for input or confirmation. This makes your workflow interactive and allows for human-in-the-loop decision making.
-
-```xml
-<ask_followup_question>
-  <question>Do you want to deploy to production?</question>
-  <options>["Yes", "No"]</options>
-</ask_followup_question>
-```
-
-#### browser_action
-Controls a built-in browser to interact with websites or local servers. Useful for testing web UIs or scraping data.
-
-```xml
-<browser_action>
-  <action>launch</action>
-  <url>http://localhost:3000</url>
-</browser_action>
-```
-
-### Leverage MCP Tools
-You can use Model Context Protocol (MCP) tools within your workflows to interact with external services like GitHub, Slack, or databases. This allows you to create powerful end-to-end automations.
-
-### Manage Context Window
-Be mindful of Cline's context window. If a workflow is too long or processes too much data, it might exceed the token limit.
-*   **Break it down:** Split long workflows into smaller parts.
-*   **Be concise:** Keep instructions clear and to the point.
-
-## Learn More
-
-<Card title="Cline Learn" icon="lightbulb" href="https://cline.bot/learn">
-  Dive deeper into general prompt engineering strategies to write even better instructions for Cline.
-</Card>

docs/features/slash-commands/workflows/index.mdx

@@ -1,139 +0,0 @@
----
-title: "Workflows Overview"
-sidebarTitle: "Overview"
-description: "Learn what Cline workflows are, why they are useful, and how to structure them."
----
-
-Workflows in Cline are Markdown files that define a series of steps to guide Cline through repetitive or complex tasks. They are a powerful way to automate your development processes directly within your editor.
-
-To invoke a workflow, you simply type `/` followed by the workflow's filename in the chat (e.g., `/deploy.md`).
-
-## Why Use Cline Workflows?
-
-*   **Automation:** Automate repetitive tasks like setting up a new project, deploying a service, or running a specific test suite.
-*   **Consistency:** Ensure that tasks are performed the same way every time, reducing errors.
-*   **Reduced Cognitive Load:** Don't waste mental energy remembering complex sequences of commands or steps.
-*   **Contextual:** Workflows run within your project's context, so Cline has access to your files and can use its tools to interact with them.
-
-## How They Work
-
-A workflow file is a standard Markdown file with a `.md` extension. Cline reads this file and interprets the instructions step-by-step. The real power comes from Cline's ability to use its built-in tools and other capabilities within these instructions:
-
-*   **Cline Tools:** Use tools like `read_file`, `write_to_file`, `execute_command`, and `ask_followup_question`.
-*   **Command-Line Tools:** Instruct Cline to use any CLI tool installed on your machine (e.g., `git`, `gh`, `npm`, `docker`).
-*   **MCP Tools:** Reference tools from connected Model Context Protocol (MCP) servers.
-
-## Workflows vs. Rules
-
-It's important to understand the difference between Cline Workflows and Cline Rules, as they serve different purposes:
-
-| Feature | Purpose | When to Use |
-| :--- | :--- | :--- |
-| **Cline Rules** | Define *how* Cline should behave generally. They are always active (or contextually triggered) and set the "ground rules" for your project. | Enforcing coding standards, tech stack preferences, or project-specific constraints (e.g., "Always use TypeScript", "Never edit the `db` folder"). |
-| **Cline Workflows** | Define *what* specific task Cline should perform. They are sequences of steps invoked on-demand to automate a process. | Automating repetitive tasks like creating a component, running a release process, or generating a daily report. |
-
-Think of **Rules** as the *environment* Cline works in, and **Workflows** as the *scripts* you give Cline to execute.
-
-### Example: Automating a Release
-
-Imagine you need to prepare a new release for your library.
-
-**Without a workflow**, you might have to manually:
-1.  Open `package.json` and bump the version number.
-2.  Run your test suite to make sure everything is green.
-3.  Update `CHANGELOG.md` with the latest commits.
-4.  Run `git commit -am "v1.0.1"`.
-5.  Run `git tag v1.0.1`.
-6.  Run `git push origin main --tags`.
-
-This is tedious and easy to mess up. You might forget to run the tests or format the changelog correctly.
-
-**With a Cline workflow**, you define these steps once in a `release.md` file. Then, you just type:
-
-```bash
-/release.md
-```
-
-Cline will then meticulously follow your instructions: updating files, running tests, and executing git commands—pausing only if it encounters an error or needs your input.
-
-## Where are Workflows Stored?
-
-You can store workflows in two locations, depending on whether they are specific to a project or meant to be global.
-
-<Tabs>
-  <Tab title="Project-Specific Workflows">
-    Store workflows that are specific to a single project in a `.clinerules/workflows/` directory in your project's root.
-
-    1.  Create a `.clinerules` folder in your project's root directory (if it doesn't already exist).
-        <Note>
-          The `.clinerules` directory may be hidden by default on some systems. You might need to enable **Show Hidden Files** to see it.
-        </Note>
-    2.  Inside `.clinerules`, create a `workflows` folder.
-    3.  Create your Markdown workflow files (e.g., `deploy.md`) in this folder.
-
-    These workflows will only be available when you have this specific project open.
-  </Tab>
-  <Tab title="Global Workflows">
-    Store workflows that you want to use across all your projects in a global directory.
-
-    *   **macOS/Linux:** `~/Documents/Cline/Workflows/`
-    *   **Windows:** `C:\Users\USERNAME\Documents\Cline\Workflows\`
-
-    Create your Markdown workflow files directly in this directory. They will be available in any project you open with Cline.
-  </Tab>
-</Tabs>
-
-## Manage Workflows
-
-You can easily manage your workflows directly within the extension. This feature provides a unified interface to handle all your automation needs without leaving your editor or hunting through file directories. It consolidates both project-specific rules and global workflows into one view, giving you full control over your automation environment.
-
-1.  Click the **Manage Cline Rules and Workflows** button (<Icon icon="scale-balanced" />) at the bottom of the extension.
-2.  This opens an interface where you can:
-    *   **View all available workflows:** See a comprehensive list of both project-specific and global workflows.
-    *   **Control automation:** Toggle individual workflows on and off as needed for your current task.
-    *   **Create and Edit:** Add new workflows or modify existing ones directly within the interface.
-    *   **Clean up:** Delete workflows you no longer need.
-
-<Frame caption="Manage Workflows">
-  <img src="https://storage.googleapis.com/cline_public_images/workflow-menu.gif" alt="Manage Cline Rules and Workflows Interface" />
-</Frame>
-
-## Workflow Structure Example
-
-Here is a simple example of a workflow file (`daily-changelog.md`) that helps you create a daily changelog.
-
-````markdown daily-changelog.md
-# Daily Changelog Generator
-
-This workflow helps you create a changelog for your daily work.
-
-1.  **Check your recent git commits:**
-    I will run the following command to see your commits from today.
-    ```bash
-    git log --author="$(git config user.name)" --since="yesterday" --oneline
-    ```
-
-2.  **Summarize your work:**
-    I will present the commits to you and ask for a summary of your changes to be added to the `changelog.md` file.
-
-3.  **Create/Append to daily changelog:**
-    I will append to the `changelog.md` file. The content will include a header with the current date, the list of commits, and your summary.
-````
-
-### Breakdown of the Workflow
-
-This workflow demonstrates that you don't always need to provide specific tool calls (like XML blocks). Cline is smart enough to interpret your high-level instructions.
-
-1.  **Step 1: Check recent git commits**
-    *   We give Cline a specific command to run. This ensures it gets exactly the data we want (today's commits).
-    <Tip>
-      After Cline shows the git commit history, you may need to click the **Proceed While Running** button to allow the workflow to continue.
-    </Tip>
-
-2.  **Step 2: Summarize your work**
-    *   Instead of forcing a specific tool, we simply tell Cline what to do: "ask for a summary".
-    *   Cline knows it needs to use its capabilities to ask you a question.
-
-3.  **Step 3: Create/Append to daily changelog**
-    *   We describe the desired outcome: "append to the `changelog.md` file" with specific content.
-    *   Cline figures out how to format the file and use its file-writing tools to accomplish the task.

docs/features/slash-commands/workflows/quickstart.mdx

@@ -1,112 +0,0 @@
----
-title: "Workflows Quick Start"
-sidebarTitle: "Quick Start"
-description: "A step-by-step guide to creating your first Cline workflow."
----
-
-In this tutorial, you will create a powerful workflow that automates the process of reviewing a GitHub Pull Request. This example demonstrates how to combine CLI tools, file analysis, and user interaction into a seamless process.
-
-### Prerequisites
-
-*   You have Cline installed.
-*   You have the [GitHub CLI (`gh`)](https://cli.github.com/) installed and authenticated.
-*   You have a Git repository open with a Pull Request you want to test this on.
-
-## Creating a Pull Request Review Workflow
-
-This workflow will automate the process of fetching PR details, analyzing the code changes for issues, and drafting a review comment.
-
-<Steps>
-  <Step title="Create the Workflow File">
-    First, create the directory structure for your project-specific workflows.
-
-    1.  In the root of your project, create a new folder named `.clinerules`.
-    2.  Inside `.clinerules`, create another folder named `workflows`.
-    3.  Finally, create a new file named `pr-review.md` inside the `workflows` folder.
-  </Step>
-
-  <Step title="Write the Workflow Content">
-    Open the `pr-review.md` file and add the following content. This workflow will gather PR details, analyze the changes, and help you submit a review.
-
-    ````markdown pr-review.md
-    # Pull Request Reviewer
-
-    This workflow helps me review a pull request by analyzing the changes and drafting a review.
-
-    ## 1. Gather PR Information
-    First, I need to understand what this PR is about. I'll fetch the title, description, and list of changed files.
-
-    ```bash
-    gh pr view PR_NUMBER --json title,body,files
-    ```
-
-    ## 2. Examine Modified Files
-    Now I will examine the diff to understand the specific code changes.
-
-    ```bash
-    gh pr diff PR_NUMBER
-    ```
-
-    ## 3. Analyze Changes
-    I will analyze the code changes for:
-    *   **Bugs:** Logic errors or edge cases.
-    *   **Performance:** Inefficient loops or operations.
-    *   **Security:** Vulnerabilities or unsafe practices.
-
-    ## 4. Confirm Assessment
-    Based on my analysis, I will present my findings and ask how you want to proceed.
-
-    ```xml
-    <ask_followup_question>
-      <question>I've reviewed PR #PR_NUMBER. Here is my assessment:
-
-    [Insert Analysis Here]
-
-    Do you want me to approve this PR, request changes, or just leave a comment?</question>
-      <options>["Approve", "Request Changes", "Comment", "Do nothing"]</options>
-    </ask_followup_question>
-    ```
-
-    ## 5. Execute Review
-    Finally, I will execute the review command based on your decision.
-
-    ```bash
-    # If approving:
-    gh pr review PR_NUMBER --approve --body "Looks good to me! [Summary of analysis]"
-
-    # If requesting changes:
-    gh pr review PR_NUMBER --request-changes --body "Please address the following: [Issues list]"
-
-    # If commenting:
-    gh pr review PR_NUMBER --comment --body "[Comments]"
-    ```
-    ````
-
-    <Note>
-      When you run this workflow, you will replace `PR_NUMBER` with the actual number of the pull request you want to review (e.g., `/pr-review.md 123`).
-    </Note>
-  </Step>
-
-  <Step title="Run the Workflow">
-    Now you're ready to run your new workflow.
-
-    1.  Open the Cline chat panel.
-    2.  Type `/pr-review.md` followed by the PR number (e.g., `/pr-review.md 42`) and press Enter.
-    3.  Cline will fetch the PR details, analyze the code, and present you with its findings before submitting the review.
-
-    <Tip>
-      As Cline executes commands (like `gh pr view`), it may show you the output and pause. You will need to click the **Proceed While Running** button to allow Cline to analyze the content and continue with the workflow.
-    </Tip>
-  </Step>
-</Steps>
-
-### Other Common Use Cases
-
-This is just one example. You can create workflows for a wide variety of tasks, such as:
-
-*   **Creating Components:** Automate the boilerplate for new files (like React components or API endpoints).
-*   **Running Tests:** Create a workflow that runs your test suite and summarizes the results.
-*   **Deploying Your Application:** Automate your deployment pipeline using tools like `docker` and `kubectl`.
-*   **Refactoring Code:** Guide Cline through a complex refactoring process step-by-step.
-
-Explore Cline's capabilities and your own development processes to find repetitive tasks that can be turned into efficient workflows.

docs/getting-started/your-first-project.mdx

@@ -35,7 +35,7 @@ Create a simple website in a single HTML file. It should have:
 ```
 
 <Frame>
-  <img src="https://storage.googleapis.com/cline_public_images/chat-prompt.png" alt="Cline Chat Prompt"/>
+  <img src="/assets/installation/chat-prompt.png" alt="Cline Chat Prompt"/>
 </Frame>
 
 Press Enter and watch Cline work!

docs/mcp/connecting-to-a-remote-server.mdx

@@ -29,33 +29,11 @@ The "Remote Servers" tab allows you to connect to any MCP server that's accessib
 2. Fill in the required information:
     - **Server Name**: Provide a unique, descriptive name for the server
     - **Server URL**: Enter the complete URL endpoint of the MCP server (e.g., `https://example.com/mcp-sse`)
-    - **Transport Type**: Select the connection protocol (Streamable HTTP is recommended for modern servers)
 3. Click "Add Server" to initiate the connection
 4. Cline will attempt to connect to the server and display the connection status
 
 > **Note**: When connecting to a remote server, ensure you trust the source, as MCP servers can execute code in your environment.
 
-#### Transport Types
-
-Cline supports two transport protocols for remote MCP servers:
-
--   **Streamable HTTP (Recommended)**: The modern MCP transport protocol with better performance, reliability, and full OAuth 2.1 authentication support. Use this for most remote servers.
--   **SSE (Legacy)**: Server-Sent Events transport. Use this only if the server specifically requires SSE or doesn't support Streamable HTTP.
-
-#### OAuth Authentication
-
-Some MCP servers (like Vercel's MCP) require OAuth authentication to access your data securely. When connecting to an OAuth-enabled server:
-
-1. Add the server as usual with its URL
-2. If the server requires authentication, you'll see an error message asking to authenticate.
-3. Click the **"Authenticate"** button that appears
-4. Your browser will open to the server's authorization page
-5. Sign in and grant permission
-6. You'll be redirected back to Cline automatically
-7. The server will connect and show a green status dot
-
-Once authenticated, your credentials are securely stored and the server will reconnect automatically when you reload Cline. You won't need to authenticate again unless you delete the server or your credentials expire.
-
 ### Remote Server Discovery
 
 If you're looking for MCP servers to connect to, several third-party marketplaces provide directories of available servers with various capabilities.
@@ -112,20 +90,9 @@ Toggle the switch next to each server to enable or disable it:
 If a server fails to connect:
 
 1. An error message will be displayed with details about the failure
-2. **For OAuth errors**: Click the "Authenticate" button to complete the authorization flow
-3. Check that the server URL is correct and the server is running
-4. Try selecting a different transport type (Streamable HTTP vs SSE)
-5. Use the "Restart Server" button to attempt reconnection
-6. If problems persist, you can delete the server and try adding it again
-
-#### OAuth-Specific Issues
-
-If you're having trouble authenticating with an OAuth-enabled server:
-
--   **"Authentication required" persists**: Make sure you completed the authorization flow in your browser and didn't cancel it
--   **Browser doesn't open**: Check your system's default browser settings and ensure external URLs can be opened
--   **Redirect errors**: Verify you're using the latest version of Cline - older versions may not support OAuth
--   **Reset authentication**: Delete the server and re-add it to start fresh with a new OAuth flow
+2. Check that the server URL is correct and the server is running
+3. Use the "Restart Server" button to attempt reconnection
+4. If problems persist, you can delete the server and try adding it again
 
 ### Advanced Configuration
 
@@ -138,11 +105,10 @@ For advanced users, Cline stores MCP server configurations in a JSON file that c
 {
 	"mcpServers": {
 		"exampleServer": {
-			"url": "https://example.com/mcp-server",
-			"type": "streamableHttp",
+			"url": "https://example.com/mcp-sse",
 			"disabled": false,
 			"autoApprove": ["tool1", "tool2"],
-			"timeout": 60
+			"timeout": 30
 		}
 	}
 }
@@ -151,10 +117,9 @@ For advanced users, Cline stores MCP server configurations in a JSON file that c
 Key configuration options:
 
 -   **url**: The endpoint URL (for remote servers)
--   **type**: Transport protocol - `"streamableHttp"` (recommended) or `"sse"` (legacy)
 -   **disabled**: Whether the server is currently enabled (true/false)
 -   **autoApprove**: List of tool names that don't require confirmation
--   **timeout**: Maximum time in seconds to wait for server responses (default: 60)
+-   **timeout**: Maximum time in seconds to wait for server responses
 
 For additional MCP settings, click the "Advanced MCP Settings" link to access VSCode settings.
 
@@ -165,20 +130,3 @@ Once connected, Cline can use the tools and resources provided by the MCP server
 1. A tool approval prompt will appear (unless auto-approved)
 2. Review the tool details and parameters before approving
 3. The tool will execute and return results to Cline
-
-### Example: Connecting to Vercel MCP
-
-[Vercel MCP](https://vercel.com/docs/mcp/vercel-mcp) is an OAuth-enabled server that provides tools for managing your Vercel projects and deployments:
-
-1. Click "Remote Servers" tab
-2. Enter:
-    - **Server Name**: `vercel`
-    - **Server URL**: `https://mcp.vercel.com`
-    - **Transport Type**: Streamable HTTP (pre-selected)
-3. Click "Add Server"
-4. You'll see "Authentication required" - click the **"Authenticate"** button
-5. Sign in to Vercel in your browser and authorize Cline
-6. Return to Cline - the server will automatically connect
-7. Vercel's tools (deploy, logs, projects) are now available to Cline!
-
-Your Vercel authentication persists across sessions, so you won't need to re-authenticate each time you use Cline.

docs/package-lock.json

@@ -5017,9 +5017,9 @@
 			}
 		},
 		"node_modules/glob": {
-			"version": "10.5.0",
-			"resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
-			"integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+			"version": "10.4.5",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz",
+			"integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==",
 			"license": "ISC",
 			"dependencies": {
 				"foreground-child": "^3.1.0",
@@ -5146,6 +5146,28 @@
 				"node": ">=6.0"
 			}
 		},
+		"node_modules/gray-matter/node_modules/argparse": {
+			"version": "1.0.10",
+			"resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+			"integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+			"license": "MIT",
+			"dependencies": {
+				"sprintf-js": "~1.0.2"
+			}
+		},
+		"node_modules/gray-matter/node_modules/js-yaml": {
+			"version": "3.14.1",
+			"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+			"integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
+			"license": "MIT",
+			"dependencies": {
+				"argparse": "^1.0.7",
+				"esprima": "^4.0.0"
+			},
+			"bin": {
+				"js-yaml": "bin/js-yaml.js"
+			}
+		},
 		"node_modules/has-bigints": {
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
@@ -6468,9 +6490,9 @@
 			"license": "MIT"
 		},
 		"node_modules/js-yaml": {
-			"version": "4.1.1",
-			"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-			"integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+			"integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
 			"license": "MIT",
 			"dependencies": {
 				"argparse": "^2.0.1"
@@ -10213,6 +10235,12 @@
 				"url": "https://github.com/sponsors/wooorm"
 			}
 		},
+		"node_modules/sprintf-js": {
+			"version": "1.0.3",
+			"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+			"integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+			"license": "BSD-3-Clause"
+		},
 		"node_modules/stack-utils": {
 			"version": "2.0.6",
 			"resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz",
@@ -10581,9 +10609,9 @@
 			}
 		},
 		"node_modules/tar-fs": {
-			"version": "3.1.1",
-			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
-			"integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.0.tgz",
+			"integrity": "sha512-5Mty5y/sOF1YWj1J6GiBodjlDc05CUR8PKXrsnFAiSG0xA+GHeWLovaZPYUDXkH/1iKRf2+M5+OrRgzC7O9b7w==",
 			"license": "MIT",
 			"dependencies": {
 				"pump": "^3.0.0",

docs/package.json

@@ -14,9 +14,5 @@
 	"description": "",
 	"dependencies": {
 		"mintlify": "^4.2.23"
-	},
-	"overrides": {
-		"tar-fs": "^3.1.1",
-		"js-yaml": "^4.1.1"
 	}
 }

docs/provider-config/anthropic.mdx

@@ -17,7 +17,6 @@ description: "Learn how to configure and use Anthropic Claude models with Cline.
 Cline supports the following Anthropic Claude models:
 
 -   `claude-haiku-4-5-20251001`
--   `claude-opus-4-5-20251101`
 -   `claude-opus-4-1-20250805`
 -   `claude-opus-4-20250514`
 -   `anthropic/claude-sonnet-4.5` (Recommended)

docs/provider-config/baseten.mdx

@@ -3,7 +3,7 @@ title: "Baseten"
 description: "Learn how to configure and use Baseten's Model APIs with Cline. Access frontier open-source models with enterprise-grade performance, reliability, and competitive pricing."
 ---
 
-Baseten provides on-demand frontier model APIs designed for production applications, not just experimentation. Built on the Baseten Inference Stack, these APIs deliver optimized inference for leading open-source models from OpenAI, DeepSeek, Moonshot AI, and Alibaba Cloud.
+Baseten provides on-demand frontier model APIs designed for production applications, not just experimentation. Built on the Baseten Inference Stack, these APIs deliver enterprise-grade performance and reliability with optimized inference for leading open-source models from OpenAI, DeepSeek, Meta, Moonshot AI, and Alibaba Cloud.
 
 **Website:** [https://www.baseten.co/products/model-apis/](https://www.baseten.co/products/model-apis/)
 
@@ -14,6 +14,27 @@ Baseten provides on-demand frontier model APIs designed for production applicati
 3.  **Create a Key:** Generate a new API key. Give it a descriptive name (e.g., "Cline").
 4.  **Copy the Key:** Copy the API key immediately and store it securely.
 
+### Supported Models
+
+Cline supports all current models under Baseten Model APIs, including:
+For the most updated pricing, please visit: https://www.baseten.co/products/model-apis/
+Note: Kimi K2 0711, Llama 4 Maverick, and Llama 4 Scout Model APIs have been deprecated at 5pm PT on October 8th.
+https://www.baseten.co/resources/changelog/model-api-deprecation-notice-kimi-k2-0711-scout-maverick/
+
+**Reasoning Models:**
+-   `deepseek-ai/DeepSeek-R1` - DeepSeek's first-generation reasoning model (163K context) - \$2.55/\$5.95 per 1M tokens
+-   `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
+
+**Flagship Models:**
+-   `openai/gpt-oss-120b` (OpenAI) - 120B MoE with strong reasoning capabilities (128K context) - \$0.10/\$0.50 per 1M tokens
+-   `moonshotai/Kimi-K2-Instruct-0905` (Moonshot AI) - September update with enhanced capabilities (262K context) - \$0.60/\$2.50 per 1M tokens
+
+**Coding Specialists:**
+-   `Qwen/Qwen3-Coder-480B-A35B-Instruct`- Advanced coding and reasoning (262K context) - \$0.38/\$1.53 per 1M tokens
+-   `Qwen/Qwen3-235B-A22B-Instruct-2507` - Math and reasoning expert (262K context) - \$0.22/\$0.80 per 1M tokens
+
 ### Configuration in Cline
 
 1.  **Open Cline Settings:** Click the settings icon (⚙️) in the Cline panel.
@@ -21,24 +42,6 @@ Baseten provides on-demand frontier model APIs designed for production applicati
 3.  **Enter API Key:** Paste your Baseten API key into the "Baseten API Key" field.
 4.  **Select Model:** Choose your desired model from the "Model" dropdown.
 
-**IMPORTANT: For Kimi K2 Thinking:** To use the `moonshotai/Kimi-K2-Thinking` model, you must enable **Native Tool Call (Experimental)** in Cline settings. This setting allows Cline to call tools through their native tool processor and is required for this reasoning model to function properly.
-
-### Supported Models
-
-Cline supports all current models under Baseten Model APIs, including:
-For the most updated pricing, please visit: https://www.baseten.co/products/model-apis/
-
--   `moonshotai/Kimi-K2-Thinking` (Moonshot AI) - Enhanced reasoning capabilities with step-by-step thought processes (262K context) - \$0.60/\$2.50 per 1M tokens
--   `zai-org/GLM-4.6` (Z AI) - Frontier open model with advanced agentic, reasoning and coding capabilities by Z AI (200k context) \$0.60/\$2.20 per 1M tokens
--   `moonshotai/Kimi-K2-Instruct-0905` (Moonshot AI) - September update with enhanced capabilities (262K context) - \$0.60/\$2.50 per 1M tokens
--   `openai/gpt-oss-120b` (OpenAI) - 120B MoE with strong reasoning capabilities (128K context) - \$0.10/\$0.50 per 1M tokens
--   `Qwen/Qwen3-Coder-480B-A35B-Instruct`- Advanced coding and reasoning (262K context) - \$0.38/\$1.53 per 1M tokens
--   `Qwen/Qwen3-235B-A22B-Instruct-2507` - Math and reasoning expert (262K context) - \$0.22/\$0.80 per 1M tokens
--   `deepseek-ai/DeepSeek-R1` - DeepSeek's first-generation reasoning model (163K context) - \$2.55/\$5.95 per 1M tokens
--   `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
-
 ### Production-First Architecture
 
 Baseten's Model APIs are built for production environments with several key advantages:
@@ -60,17 +63,47 @@ Baseten's Model APIs are built for production environments with several key adva
 
 #### Developer Experience
 - **OpenAI compatible API** - migrate by swapping a single URL
-- **Drop-in replacement** for closed models with comprehensive observability and analytics
+- **Drop-in replacement** for closed models with comprehensive observability
 - **Seamless scaling** from Model APIs to dedicated deployments
 
 ### Special Features
 
 #### Function Calling & Tool Use
-All Baseten models support structured outputs, function calling, and tool use as part of the Baseten Inference Stack, making them ideal for agentic applications and coding workflows.
+All Baseten models support structured outputs, function calling, and tool use as part of the Baseten Inference Stack, making them ideal for agentic applications.
+
+#### Reasoning Capabilities
+DeepSeek models offer enhanced reasoning with step-by-step thought processes, while maintaining production-ready performance.
+
+#### Long Context Support
+- **Up to 1 million tokens** for Llama 4 models (Maverick and Scout)
+- **262K tokens** for Qwen3 models
+- **163K tokens** for DeepSeek models
+- **Perfect for code repositories** and complex multi-turn conversations
+
+#### Quantization Optimizations
+Models are deployed with advanced quantization techniques (fp4, fp8, fp16) for optimal performance while maintaining quality.
+
+### Migration from Other Providers
+
+Baseten's OpenAI compatibility makes migration straightforward:
+
+**From OpenAI:**
+- Swap `api.openai.com` with `inference.baseten.co/v1`
+- Keep existing request/response formats
+- Benefit from significant cost savings
+
+**From Other Providers:**
+- Use standard OpenAI SDK format
+- Maintain existing prompting strategies
+- Access to newer open-source models
 
 ### Tips and Notes
 
--   **Dynamic Model Updates:** Cline automatically fetches the latest model list from Baseten, ensuring access to new models as they're released in real time.
+-   **Model Selection:** Choose models based on your specific use case - reasoning models for complex tasks, coding models for development work, and flagship models for general applications.
+-   **Cost Optimization:** Baseten offers some of the most competitive pricing in the market, especially for open-source models.
+-   **Context Windows:** Take advantage of large context windows (up to 1M tokens) for including substantial codebases and documentation.
+-   **Enterprise Ready:** Baseten is designed for production use with enterprise-grade security, compliance, and reliability.
+-   **Dynamic Model Updates:** Cline automatically fetches the latest model list from Baseten, ensuring access to new models as they're released.
 -   **Multi-Cloud Capacity Management (MCM):** Baseten's multi-cloud infrastructure ensures high availability and low latency globally.
 -   **Support:** Baseten provides dedicated support for production deployments and can work with you on dedicated resources as you scale.