Changeset version bump (#7037)

* v3.34.0 Release Notes

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

* fix: Adding Fallbacks

* fix: Adding Fallbacks

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Arafatkatze <arafat.da.khan@gmail.com>

CHANGELOG.md

@@ -1,8 +1,17 @@
 # Changelog
 
+## [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

cli/cmd/cline/main.go

@@ -101,10 +101,7 @@ see the manual page: man cline`,
 				if !isUserReadyToUse(ctx, instanceAddress) {
 					// Create renderer for welcome messages
 					renderer := display.NewRenderer(global.Config.OutputFormat)
-
-					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)
+					fmt.Printf("\n%s\n\n", renderer.Dim("Hey there! Looks like you're new here. Let's get you set up"))
 
 					if err := auth.HandleAuthMenuNoArgs(ctx); err != nil {
 						// Check if user cancelled - exit cleanly
@@ -119,9 +116,7 @@ see the manual page: man cline`,
 						return fmt.Errorf("credentials still not configured - please run 'cline auth' to complete setup")
 					}
 
-					markdown = "## ✓ setup complete, you can now use the cline cli"
-					rendered = renderer.RenderMarkdown(markdown)
-					fmt.Printf("\n%s\n\n", rendered)
+					fmt.Printf("\n%s\n\n", renderer.Dim("✓ Setup complete, you can now use the Cline CLI"))
 				}
 			} else {
 				// User specified --address flag, use that
@@ -163,6 +158,7 @@ see the manual page: man cline`,
 				Settings: settings,
 				Yolo:     yolo,
 				Address:  instanceAddress,
+				Verbose:  verbose,
 			})
 		},
 	}
@@ -186,6 +182,7 @@ see the manual page: man cline`,
 	rootCmd.AddCommand(cli.NewVersionCommand())
 	rootCmd.AddCommand(cli.NewAuthCommand())
 	rootCmd.AddCommand(cli.NewLogsCommand())
+	rootCmd.AddCommand(cli.NewDoctorCommand())
 
 	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
 		os.Exit(1)
@@ -238,7 +235,7 @@ func promptForInitialTask(ctx context.Context, instanceAddress, modeFlag string)
 // showSessionBanner displays session info before initial prompt
 func showSessionBanner(ctx context.Context, instanceAddress, modeFlag string) {
 	bannerInfo := display.BannerInfo{
-		Version: global.Version,
+		Version: global.CliVersion,
 		Mode:    modeFlag, // Use the mode from command flag, not state
 	}
 
@@ -330,19 +327,22 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 
 	// Check if data is being piped to stdin
 	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		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(" ")
+		// 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)
+			}
+
+			stdinContent := strings.TrimSpace(string(stdinBytes))
+			if stdinContent != "" {
+				if content.Len() > 0 {
+					content.WriteString(" ")
+				}
+				content.WriteString(stdinContent)
 			}
-			content.WriteString(stdinContent)
 		}
 	}
 
 	return content.String(), nil
-}
+}

cli/go.mod

@@ -8,8 +8,10 @@ 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
@@ -24,7 +26,6 @@ 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
@@ -45,7 +46,6 @@ 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,62 +1,68 @@
 {
-    "name": "cline",
-    "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": {
-        "cline": "./bin/cline",
-        "cline-host": "./bin/cline-host"
-    },
-    "man": "./man/cline.1",
-    "scripts": {
-        "postinstall": "node postinstall.js"
-    },
-    "bundleDependencies": [
-        "@grpc/grpc-js",
-        "@grpc/reflection",
-        "better-sqlite3",
-        "grpc-health-check",
-        "open",
-        "vscode-uri"
-    ],
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "keywords": [
-        "cline",
-        "claude",
-        "dev",
-        "mcp",
-        "openrouter",
-        "coding",
-        "agent",
-        "autonomous",
-        "chatgpt",
-        "sonnet",
-        "ai",
-        "llama",
-        "cli"
-    ],
-    "author": {
-        "name": "Cline Bot Inc."
-    },
-    "license": "Apache-2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/cline/cline"
-    },
-    "homepage": "https://cline.bot",
-    "bugs": {
-        "url": "https://github.com/cline/cline/issues"
-    },
-    "dependencies": {
-        "@grpc/grpc-js": "^1.13.3",
-        "@grpc/reflection": "^1.0.4",
-        "better-sqlite3": "^12.2.0",
-        "grpc-health-check": "^2.0.2",
-        "open": "^10.1.2",
-        "vscode-uri": "^3.1.0"
-    },
-    "os": ["darwin", "linux"],
-    "cpu": ["x64", "arm64"]
+	"name": "cline",
+	"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": {
+		"cline": "./bin/cline",
+		"cline-host": "./bin/cline-host"
+	},
+	"man": "./man/cline.1",
+	"scripts": {
+		"postinstall": "node postinstall.js"
+	},
+	"bundleDependencies": [
+		"@grpc/grpc-js",
+		"@grpc/reflection",
+		"better-sqlite3",
+		"grpc-health-check",
+		"open",
+		"vscode-uri"
+	],
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"keywords": [
+		"cline",
+		"claude",
+		"dev",
+		"mcp",
+		"openrouter",
+		"coding",
+		"agent",
+		"autonomous",
+		"chatgpt",
+		"sonnet",
+		"ai",
+		"llama",
+		"cli"
+	],
+	"author": {
+		"name": "Cline Bot Inc."
+	},
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline"
+	},
+	"homepage": "https://cline.bot",
+	"bugs": {
+		"url": "https://github.com/cline/cline/issues"
+	},
+	"dependencies": {
+		"@grpc/grpc-js": "^1.13.3",
+		"@grpc/reflection": "^1.0.4",
+		"better-sqlite3": "^12.2.0",
+		"grpc-health-check": "^2.0.2",
+		"open": "^10.1.2",
+		"vscode-uri": "^3.1.0"
+	},
+	"os": [
+		"darwin",
+		"linux"
+	],
+	"cpu": [
+		"x64",
+		"arm64"
+	]
 }

cli/pkg/cli/auth.go

@@ -6,18 +6,38 @@ import (
 )
 
 func NewAuthCommand() *cobra.Command {
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "auth",
-		Short: "Authenticate a provider and configure model used",
-		Long: `Authenticate  a provider and configure model used
+		Short: "Authenticate a provider and configure what model is used",
+		Long: `Authenticate a provider and configure what model is used
 
-This command opens an interactive menu where you can:
+Interactive Mode:
+  Run without flags to open 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`,
+  - 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`,
 		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,6 +5,7 @@ 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"
@@ -38,7 +39,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 API provider									- always shown. Launches provider setup wizard
+//	┃   Configure BYO API providers								- 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
@@ -68,18 +69,25 @@ 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 menu (ShowAuthMenuNoArgs)
+		// No args: Show uth wizard
 		return HandleAuthMenuNoArgs(ctx)
-	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])
+	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
 	default:
-		return fmt.Errorf("quick BYO API setup is currently stubbed - not yet implemented")
+		return fmt.Errorf("too many arguments. Use flags for quick setup: --provider, --apikey, --modelid --baseurl(optional)")
 	}
 }
 
@@ -165,32 +173,34 @@ 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 API provider", AuthActionBYOSetup),
+			huh.NewOption("Configure BYO API providers", 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 API provider", AuthActionBYOSetup),
+			huh.NewOption("Configure BYO API providers", 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 = "Cline Account: \033[32m✓\033[0m Authenticated\n"
+		title = fmt.Sprintf("Cline Account: %s Authenticated\n", renderer.Green("✓"))
 	} else {
-		title = "Cline Account: \033[31m✗\033[0m Not authenticated\n"
+		title = fmt.Sprintf("Cline Account: %s Not authenticated\n", renderer.Red("✗"))
 	}
 
 	// 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: \033[22m\033[37m%s\033[0m\nActive Model: \033[22m\033[37m%s\033[0m\n", currentProvider, currentModel)
+		title += fmt.Sprintf("Active Provider: %s\nActive Model: %s\n",
+			renderer.White(currentProvider),
+			renderer.White(currentModel))
 	}
 
 	// Always end with a huh?
@@ -258,11 +268,6 @@ 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,13 +1,240 @@
 package auth
 
-import "fmt"
+import (
+	"context"
+	"fmt"
+	"strings"
 
-// 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>")
+	"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 := task.NewManagerForDefault(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)
+		}
+	}
+
+	// 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")
+		}
 	}
 	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,
+	}
+
+	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

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

cli/pkg/cli/auth/models_list_fetch.go

@@ -14,7 +14,7 @@ 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.RefreshOpenRouterModels(ctx, &cline.EmptyRequest{})
+	resp, err := manager.GetClient().Models.RefreshOpenRouterModelsRPC(ctx, &cline.EmptyRequest{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch OpenRouter models: %w", err)
 	}

cli/pkg/cli/auth/providers_byo.go

@@ -18,8 +18,8 @@ type BYOProviderOption struct {
 func GetBYOProviderList() []BYOProviderOption {
 	return []BYOProviderOption{
 		{Name: "Anthropic", Provider: cline.ApiProvider_ANTHROPIC},
-		{Name: "OpenAI", Provider: cline.ApiProvider_OPENAI},
-		{Name: "OpenAI Native", Provider: cline.ApiProvider_OPENAI_NATIVE},
+		{Name: "OpenAI Compatible", Provider: cline.ApiProvider_OPENAI},
+		{Name: "OpenAI (Official)", 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},
@@ -82,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., gpt-5-2025-08-07"
-	case cline.ApiProvider_OPENAI_NATIVE:
 		return "e.g., openai/gpt-oss-120b"
+	case cline.ApiProvider_OPENAI_NATIVE:
+		return "e.g., gpt-5-2025-08-07"
 	case cline.ApiProvider_OPENROUTER:
 		return "e.g., google/gemini-2.0-flash-exp:free"
 	case cline.ApiProvider_XAI:
@@ -127,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 Native provider, also prompts for an optional base URL.
-func PromptForAPIKey(provider cline.ApiProvider) (string, error) {
+// For OpenAI (Compatible) provider, also prompts for an optional base URL.
+func PromptForAPIKey(provider cline.ApiProvider) (string, string, error) {
 	var apiKey string
 	config := GetBYOAPIKeyFieldConfig(provider)
 
@@ -149,11 +149,11 @@ func PromptForAPIKey(provider cline.ApiProvider) (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 Native provider, also prompt for base URL
-	if provider == cline.ApiProvider_OPENAI_NATIVE {
+	// For OpenAI (Compatible) provider, prompt for base URL
+	if provider == cline.ApiProvider_OPENAI {
 		var baseURL string
 		baseURLForm := huh.NewForm(
 			huh.NewGroup(
@@ -166,12 +166,11 @@ func PromptForAPIKey(provider cline.ApiProvider) (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)
 		}
 
-		// TODO - connect baseURL
-		_ = baseURL
+		return apiKey, baseURL, nil
 	}
 
-	return apiKey, nil
+	return apiKey, "", nil
 }

cli/pkg/cli/auth/providers_list.go

@@ -207,9 +207,9 @@ func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
 	switch providerStr {
 	case "anthropic":
 		return cline.ApiProvider_ANTHROPIC, true
-	case "openai":
+	case "openai-compatible": // internal name is 'openai', but this is actually the openai-compatible provider
 		return cline.ApiProvider_OPENAI, true
-	case "openai-native":
+	case "openai", "openai-native": // This is the native, official Open AI provider
 		return cline.ApiProvider_OPENAI_NATIVE, true
 	case "openrouter":
 		return cline.ApiProvider_OPENROUTER, true
@@ -237,7 +237,7 @@ func GetProviderIDForEnum(provider cline.ApiProvider) string {
 	case cline.ApiProvider_ANTHROPIC:
 		return "anthropic"
 	case cline.ApiProvider_OPENAI:
-		return "openai"
+		return "openai-compatible"
 	case cline.ApiProvider_OPENAI_NATIVE:
 		return "openai-native"
 	case cline.ApiProvider_OPENROUTER:
@@ -312,9 +312,9 @@ func GetProviderDisplayName(provider cline.ApiProvider) string {
 	case cline.ApiProvider_ANTHROPIC:
 		return "Anthropic"
 	case cline.ApiProvider_OPENAI:
-		return "OpenAI"
+		return "OpenAI Compatible"
 	case cline.ApiProvider_OPENAI_NATIVE:
-		return "OpenAI Native"
+		return "OpenAI (Official)"
 	case cline.ApiProvider_OPENROUTER:
 		return "OpenRouter"
 	case cline.ApiProvider_XAI:

cli/pkg/cli/auth/update_api_configurations.go

@@ -46,6 +46,7 @@ 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)
@@ -68,6 +69,7 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 	case cline.ApiProvider_OPENAI:
 		return ProviderFields{
 			APIKeyField:                          "openAiApiKey",
+			BaseURLField:                         "openAiBaseUrl",
 			PlanModeModelIDField:                 "planModeApiModelId",
 			ActModeModelIDField:                  "actModeApiModelId",
 			PlanModeProviderSpecificModelIDField: "planModeOpenAiModelId",
@@ -182,7 +184,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, includeProviderEnums bool) []string {
+func buildProviderFieldMask(fields ProviderFields, includeAPIKey bool, includeModelID bool, includeModelInfo bool, includeBaseURL bool, includeProviderEnums bool) []string {
 	var fieldPaths []string
 
 	// Include provider enums if requested (used when setting active provider)
@@ -199,6 +201,11 @@ 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
@@ -266,8 +273,16 @@ func setProviderSpecificModelID(apiConfig *cline.ModelsApiConfiguration, fieldNa
 	}
 }
 
+// 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 "openAiBaseUrl":
+		apiConfig.OpenAiBaseUrl = 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, modelInfo interface{}) error {
+func AddProviderPartial(ctx context.Context, manager *task.Manager, provider cline.ApiProvider, modelID string, apiKey string, baseURL string, modelInfo interface{}) error {
 	// Get field mapping for this provider
 	fields, err := GetProviderFields(provider)
 	if err != nil {
@@ -282,6 +297,13 @@ 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)
@@ -301,7 +323,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, false)
+	fieldPaths := buildProviderFieldMask(fields, true, true, includeModelInfo, includeBaseURL, false)
 
 	// Create field mask
 	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}
@@ -368,7 +390,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, setAsActive)
+	fieldPaths := buildProviderFieldMask(fields, includeAPIKey, includeModelID, includeModelInfo, false, setAsActive)
 
 	// Create field mask
 	fieldMask := &fieldmaskpb.FieldMask{Paths: fieldPaths}

cli/pkg/cli/auth/wizard_byo.go

@@ -40,7 +40,7 @@ func (pw *ProviderWizard) showMainMenu() (string, error) {
 			huh.NewSelect[string]().
 				Title("What would you like to do?").
 				Options(
-					huh.NewOption("Configure a new provider", "add"),
+					huh.NewOption("Add or change an API provider", "add"),
 					huh.NewOption("Change model for API provider", "change-model"),
 					huh.NewOption("Remove a provider", "remove"),
 					huh.NewOption("List configured providers", "list"),
@@ -107,8 +107,8 @@ func (pw *ProviderWizard) handleAddProvider() error {
 		return pw.handleAddBedrockProvider()
 	}
 
-	// Step 3: Get API key first (for non-Bedrock providers)
-	apiKey, err := PromptForAPIKey(provider)
+	// Step 3: Get API key and optional baseURL (for non-Bedrock providers)
+	apiKey, baseURL, err := PromptForAPIKey(provider)
 	if err != nil {
 		return fmt.Errorf("failed to get API key: %w", err)
 	}
@@ -120,7 +120,7 @@ func (pw *ProviderWizard) handleAddProvider() error {
 	}
 
 	// Step 5: Apply configuration using AddProviderPartial
-	if err := AddProviderPartial(pw.ctx, pw.manager, provider, modelID, apiKey, modelInfo); err != nil {
+	if err := AddProviderPartial(pw.ctx, pw.manager, provider, modelID, apiKey, baseURL, modelInfo); err != nil {
 		return fmt.Errorf("failed to save configuration: %w", err)
 	}
 

cli/pkg/cli/display/renderer.go

@@ -4,6 +4,7 @@ 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"
@@ -14,6 +15,16 @@ 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 {
@@ -22,11 +33,23 @@ func NewRenderer(outputFormat string) *Renderer {
 		mdRenderer = nil
 	}
 
-	return &Renderer{
+	r := &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 {
@@ -206,21 +229,76 @@ 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
+// Respects output format - skips rendering in plain mode or non-TTY contexts
 func (r *Renderer) RenderMarkdown(markdown string) string {
-	// Skip markdown rendering in plain mode
-	if r.outputFormat == "plain" {
+	// 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() {
 		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)
-	if shouldMarkdown && outputFormat != "plain" {
+	// Render rich header immediately when creating segment (if in rich mode and TTY)
+	if shouldMarkdown && outputFormat != "plain" && isTTY() {
 		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
-		if ss.shouldMarkdown && ss.outputFormat != "plain" {
+		// Render markdown only in rich mode and TTY
+		if ss.shouldMarkdown && ss.outputFormat != "plain" && isTTY() {
 			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" {
+		if ss.shouldMarkdown && ss.outputFormat != "plain" && isTTY() {
 			rendered, err := ss.mdRenderer.Render(currentBuffer)
 			if err == nil {
 				bodyContent = rendered

cli/pkg/cli/display/tool_renderer.go

@@ -339,9 +339,10 @@ 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
+// renderMarkdown renders markdown if not in plain mode and in a TTY
 func (tr *ToolRenderer) renderMarkdown(markdown string) string {
-	if tr.outputFormat == "plain" {
+	// Skip markdown rendering if plain mode or not in TTY
+	if tr.outputFormat == "plain" || !isTTY() {
 		return markdown
 	}
 

cli/pkg/cli/doctor.go

@@ -0,0 +1,65 @@
+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,8 +6,10 @@ 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
@@ -47,6 +49,12 @@ 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

@@ -71,22 +71,25 @@ 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
 	}
 
-	// Render header
-	rendered := dc.Renderer.RenderMarkdown(header)
-	output.Print("\n")
-	output.Print(rendered)
-	output.Print("\n")
-
-	// Render body
-	output.Print(body)
+	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)
+	}
 
 	return nil
 }
@@ -125,8 +128,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\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")
+		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"))
 	}
 }
 
@@ -177,9 +180,19 @@ func (h *AskHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext) err
 		return dc.Renderer.RenderMessage("TOOL", msg.Text, true)
 	}
 
-	// Use unified ToolRenderer
-	rendered := dc.ToolRenderer.RenderToolApprovalRequest(&tool)
-	output.Print(rendered)
+	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)
+	}
 
 	h.showApprovalHint(dc)
 	return nil

cli/pkg/cli/instances.go

@@ -389,20 +389,21 @@ func newInstanceListCommand() *cobra.Command {
 				}
 
 				// Render the markdown table with terminal width for nice table layout
-				renderer, err := display.NewMarkdownRendererForTerminal()
+				mdRenderer, err := display.NewMarkdownRendererForTerminal()
 				if err != nil {
 					// Fallback to plain table if markdown renderer fails
 					fmt.Println(markdown.String())
 				} else {
-					rendered, err := renderer.Render(markdown.String())
+					rendered, err := mdRenderer.Render(markdown.String())
 					if err != nil {
 						fmt.Println(markdown.String())
 					} else {
 						// Post-process to colorize status values
-						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
+						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"))
 
 						fmt.Print(strings.TrimLeft(rendered, "\n"))
 					}

cli/pkg/cli/logs.go

@@ -340,6 +340,7 @@ 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("|--------------|----------|-------------|---------|")
@@ -352,9 +353,9 @@ func renderLogsTable(logs []logFileInfo, markForDeletion bool) error {
 			row.age,
 		)
 
-		// If marking for deletion, wrap in red ANSI codes
+		// If marking for deletion, wrap in red
 		if markForDeletion {
-			line = "\033[31m" + line + "\033[0m"
+			line = colorRenderer.Red(line)
 		}
 
 		markdown.WriteString(line)

cli/pkg/cli/output/input_model.go

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

cli/pkg/cli/task.go

@@ -13,6 +13,8 @@ import (
 	"github.com/cline/cli/pkg/cli/config"
 	"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"
 )
 
@@ -24,6 +26,7 @@ type TaskOptions struct {
 	Settings []string
 	Yolo     bool
 	Address  string
+	Verbose  bool
 }
 
 func NewTaskCommand() *cobra.Command {
@@ -474,15 +477,34 @@ func newTaskOpenCommand() *cobra.Command {
 					return fmt.Errorf("failed to parse settings: %w", err)
 				}
 
-				// 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)
+				// 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")
+					}
 				}
 
-				// Apply the settings to the instance
-				if err := configManager.UpdateSettings(ctx, parsedSettings, secrets); err != nil {
-					return fmt.Errorf("failed to apply settings: %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")
+					}
 				}
 			}
 
@@ -570,17 +592,20 @@ func getContentFromStdinAndArgs(args []string) (string, error) {
 
 	// Check if data is being piped to stdin
 	if (stat.Mode() & os.ModeCharDevice) == 0 {
-		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(" ")
+		// 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)
+			}
+
+			stdinContent := strings.TrimSpace(string(stdinBytes))
+			if stdinContent != "" {
+				if content.Len() > 0 {
+					content.WriteString(" ")
+				}
+				content.WriteString(stdinContent)
 			}
-			content.WriteString(stdinContent)
 		}
 	}
 
@@ -637,6 +662,9 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 		fmt.Printf("Task created successfully with ID: %s\n\n", taskID)
 	}
 
+	// Check for updates in background after task is created
+	updater.CheckAndUpdate(opts.Verbose)
+
 	// If yolo mode is enabled, follow until completion (non-interactive)
 	// Otherwise, follow in interactive mode
 	if opts.Yolo {
@@ -644,4 +672,4 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 	} else {
 		return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
 	}
-}
+}

cli/pkg/cli/task/input_handler.go

@@ -2,6 +2,7 @@ package task
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
@@ -9,6 +10,7 @@ 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"
@@ -16,20 +18,21 @@ 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
-	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
+	approvalMessage  *types.ClineMessage // Store the approval message for determining action
+	ctx              context.Context     // Context for restart callback
 }
 
 // NewInputHandler creates a new input handler
@@ -162,6 +165,10 @@ 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" {
@@ -170,16 +177,14 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 								output.Printf("\nError switching to act mode with message: %v\n", err)
 								continue
 							}
-							// 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")
+							output.Printf("\n%s\n", actStyle.Render("Switched to act mode"))
 						} 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
 							}
-							// Yellow color for plan mode (ANSI color 3)
-							output.Printf("\n\033[33m\033[1mSwitched to plan mode\033[0m\n")
+							output.Printf("\n%s\n", planStyle.Render("Switched to plan mode"))
 
 							// Now send the message separately
 							time.Sleep(500 * time.Millisecond) // Give mode switch time to process
@@ -196,9 +201,9 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 						}
 						// Color based on mode
 						if newMode == "act" {
-							output.Printf("\n\033[38;5;39m\033[1mSwitched to act mode\033[0m\n")
+							output.Printf("\n%s\n", actStyle.Render("Switched to act mode"))
 						} else {
-							output.Printf("\n\033[33m\033[1mSwitched to plan mode\033[0m\n")
+							output.Printf("\n%s\n", planStyle.Render("Switched to plan mode"))
 						}
 					}
 
@@ -229,6 +234,46 @@ 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
+		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()
@@ -245,6 +290,9 @@ 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?",
@@ -344,6 +392,23 @@ 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

@@ -1004,26 +1004,18 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 
 		case msg.Ask == string(types.AskTypePlanModeRespond):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
-			// 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)
+			// 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 !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				fmt.Println()
+			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
 				m.displayMessage(msg, false, false, i)
-
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 		}
@@ -1245,10 +1237,48 @@ 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 {
+	settings := &cline.Settings{
+		AutoApprovalSettings: &cline.AutoApprovalSettings{
+			Enabled:     true,
+			MaxRequests: 20, // Important: avoid maxRequests=0 bug
+			Actions:     &cline.AutoApprovalActions{},
+		},
+	}
+
+	// Set the specific action to true based on actionKey
+	truePtr := func() *bool { b := true; return &b }()
+	
+	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

@@ -464,21 +464,21 @@ func setAutoApprovalAction(actions *cline.AutoApprovalActions, key, value string
 
 	switch key {
 	case "read_files":
-		actions.ReadFiles = val
+		actions.ReadFiles = boolPtr(val)
 	case "read_files_externally":
-		actions.ReadFilesExternally = val
+		actions.ReadFilesExternally = boolPtr(val)
 	case "edit_files":
-		actions.EditFiles = val
+		actions.EditFiles = boolPtr(val)
 	case "edit_files_externally":
-		actions.EditFilesExternally = val
+		actions.EditFilesExternally = boolPtr(val)
 	case "execute_safe_commands":
-		actions.ExecuteSafeCommands = val
+		actions.ExecuteSafeCommands = boolPtr(val)
 	case "execute_all_commands":
-		actions.ExecuteAllCommands = val
+		actions.ExecuteAllCommands = boolPtr(val)
 	case "use_browser":
-		actions.UseBrowser = val
+		actions.UseBrowser = boolPtr(val)
 	case "use_mcp":
-		actions.UseMcp = val
+		actions.UseMcp = boolPtr(val)
 	default:
 		return fmt.Errorf("unsupported auto_approval_actions field '%s'", key)
 	}

cli/pkg/cli/terminal/keyboard.go

@@ -0,0 +1,695 @@
+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/updater/updater.go

@@ -0,0 +1,409 @@
+package updater
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/cli/pkg/cli/output"
+)
+
+type cacheData struct {
+	LastCheck     time.Time `json:"last_check"`
+	LatestVersion string    `json:"latest_version"`
+}
+
+type npmRegistryResponse struct {
+	DistTags struct {
+		Latest  string `json:"latest"`
+		Nightly string `json:"nightly"`
+	} `json:"dist-tags"`
+}
+
+const (
+	checkInterval = 24 * time.Hour
+	requestTimeout = 3 * time.Second
+)
+
+var (
+	successStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2")).Bold(true)
+	errorStyle   = lipgloss.NewStyle().Foreground(lipgloss.Color("1")).Bold(true)
+	dimStyle     = lipgloss.NewStyle().Foreground(lipgloss.Color("8"))
+)
+
+var verbose bool
+
+// CheckAndUpdate performs a background update check and attempts to auto-update if needed.
+// This is non-blocking and safe to call on CLI startup.
+func CheckAndUpdate(isVerbose 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 background update check...\n")
+	}
+
+	// Run in background so we don't block CLI startup
+	go func() {
+		if err := checkAndUpdateInternal(false); err != nil {
+			if verbose {
+				output.Printf("[updater] Update check failed: %v\n", err)
+			}
+		}
+	}()
+}
+
+// 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 {
+	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 verbose {
+			output.Printf("[updater] Cache is fresh (last checked %v ago), skipping\n", time.Since(cache.LastCheck))
+		}
+		return nil
+	}
+
+	if err != nil && verbose {
+		output.Printf("[updater] Cache load failed or doesn't exist: %v\n", err)
+	}
+
+	// Determine channel
+	distTag := "latest"
+	if strings.Contains(global.CliVersion, "nightly") {
+		distTag = "nightly"
+	}
+
+	if verbose {
+		output.Printf("[updater] Current version: %s (channel: %s)\n", global.CliVersion, distTag)
+		output.Printf("[updater] Fetching latest version from npm registry...\n")
+	}
+
+	// Fetch latest version from npm
+	latestVersion, err := fetchLatestVersion()
+	if err != nil {
+		if verbose {
+			output.Printf("[updater] Failed to fetch latest version: %v\n", err)
+		}
+		return err
+	}
+
+	if verbose {
+		output.Printf("[updater] Latest version on npm: %s\n", latestVersion)
+	}
+
+	// Update cache
+	cache = cacheData{
+		LastCheck:     time.Now(),
+		LatestVersion: latestVersion,
+	}
+	saveCache(cache)
+
+	if verbose {
+		output.Printf("[updater] Updated cache\n")
+	}
+
+	// Compare versions
+	currentVersion := strings.TrimPrefix(global.CliVersion, "v")
+	latestVersion = strings.TrimPrefix(latestVersion, "v")
+
+	if verbose {
+		output.Printf("[updater] Comparing versions: current=%s latest=%s\n", currentVersion, latestVersion)
+	}
+
+	if !isNewer(latestVersion, currentVersion) {
+		// Already up to date
+		if verbose {
+			output.Printf("[updater] Already on latest version, no update needed\n")
+		}
+		return nil
+	}
+
+	if verbose {
+		output.Printf("[updater] Update available! Attempting to install...\n")
+	}
+
+	// Determine channel for update command
+	channel := "latest"
+	if strings.Contains(global.CliVersion, "nightly") {
+		channel = "nightly"
+	}
+
+	// Attempt update
+	if verbose {
+		output.Printf("[updater] Running: npm install -g cline%s\n",
+			map[bool]string{true: "@"+channel, false: ""}[channel == "nightly"])
+	}
+
+	if err := attemptUpdate(channel); err != nil {
+		if verbose {
+			output.Printf("[updater] Update failed: %v\n", err)
+		}
+		showFailureMessage(channel)
+		return err
+	}
+
+	if verbose {
+		output.Printf("[updater] Update completed successfully!\n")
+	}
+
+	showSuccessMessage(latestVersion)
+	return nil
+}
+
+func fetchLatestVersion() (string, error) {
+	// Determine dist-tag from current version
+	distTag := "latest"
+	if strings.Contains(global.CliVersion, "nightly") {
+		distTag = "nightly"
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(ctx, "GET", "https://registry.npmjs.org/cline", nil)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("npm registry returned status %d", resp.StatusCode)
+	}
+
+	var data npmRegistryResponse
+	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return "", err
+	}
+
+	if distTag == "nightly" {
+		return data.DistTags.Nightly, nil
+	}
+	return data.DistTags.Latest, nil
+}
+
+func attemptUpdate(channel string) error {
+	packageName := "cline"
+	if channel == "nightly" {
+		packageName = "cline@nightly"
+	}
+
+	cmd := exec.Command("npm", "install", "-g", packageName)
+	cmd.Stdout = nil
+	cmd.Stderr = nil
+
+	return cmd.Run()
+}
+
+func isNewer(latest, current string) bool {
+	// Parse version strings (e.g., "1.0.0-nightly.19")
+	latestBase, latestSuffix := parseVersion(latest)
+	currentBase, currentSuffix := parseVersion(current)
+
+	// Compare base versions (1.0.0)
+	comparison := compareVersionParts(latestBase, currentBase)
+	if comparison != 0 {
+		return comparison > 0
+	}
+
+	// Base versions are equal, compare suffixes (nightly.19)
+	return compareSuffix(latestSuffix, currentSuffix) > 0
+}
+
+func parseVersion(version string) (string, string) {
+	parts := strings.SplitN(version, "-", 2)
+	if len(parts) == 2 {
+		return parts[0], parts[1]
+	}
+	return parts[0], ""
+}
+
+func compareVersionParts(v1, v2 string) int {
+	parts1 := strings.Split(v1, ".")
+	parts2 := strings.Split(v2, ".")
+
+	for i := 0; i < len(parts1) && i < len(parts2); i++ {
+		// Convert to int for proper numeric comparison
+		n1 := parseInt(parts1[i])
+		n2 := parseInt(parts2[i])
+
+		if n1 > n2 {
+			return 1
+		}
+		if n1 < n2 {
+			return -1
+		}
+	}
+
+	// If all parts are equal, longer version is newer
+	if len(parts1) > len(parts2) {
+		return 1
+	}
+	if len(parts1) < len(parts2) {
+		return -1
+	}
+	return 0
+}
+
+func compareSuffix(s1, s2 string) int {
+	// If one has no suffix, stable > prerelease
+	if s1 == "" && s2 == "" {
+		return 0
+	}
+	if s1 == "" {
+		return 1 // Stable is newer than prerelease
+	}
+	if s2 == "" {
+		return -1 // Prerelease is older than stable
+	}
+
+	// Both have suffixes (e.g., "nightly.19" vs "nightly.18")
+	// Extract the numeric part after the last dot
+	n1 := extractBuildNumber(s1)
+	n2 := extractBuildNumber(s2)
+
+	if n1 > n2 {
+		return 1
+	}
+	if n1 < n2 {
+		return -1
+	}
+	return 0
+}
+
+func extractBuildNumber(suffix string) int {
+	// Extract number from "nightly.19" -> 19
+	parts := strings.Split(suffix, ".")
+	if len(parts) > 1 {
+		return parseInt(parts[len(parts)-1])
+	}
+	return 0
+}
+
+func parseInt(s string) int {
+	var result int
+	fmt.Sscanf(s, "%d", &result)
+	return result
+}
+
+func showSuccessMessage(version string) {
+	output.Printf("\n%s Updated to %s %s Changes will take effect next session\n\n",
+		successStyle.Render("✓"),
+		successStyle.Render("v"+version),
+		dimStyle.Render("→"),
+	)
+}
+
+func showFailureMessage(channel string) {
+	packageName := "cline"
+	if channel == "nightly" {
+		packageName = "cline@nightly"
+	}
+
+	output.Printf("\n%s Auto-update failed %s Try: %s\n\n",
+		errorStyle.Render("✗"),
+		dimStyle.Render("·"),
+		"npm install -g "+packageName,
+	)
+}
+
+func getCacheFilePath() string {
+	configDir := filepath.Join(os.Getenv("HOME"), ".cline", "data")
+	return filepath.Join(configDir, ".update-cache")
+}
+
+func loadCache() (cacheData, error) {
+	var cache cacheData
+	cacheFile := getCacheFilePath()
+
+	data, err := os.ReadFile(cacheFile)
+	if err != nil {
+		return cache, err
+	}
+
+	err = json.Unmarshal(data, &cache)
+	return cache, err
+}
+
+func saveCache(cache cacheData) error {
+	cacheFile := getCacheFilePath()
+
+	// Ensure config directory exists
+	configDir := filepath.Dir(cacheFile)
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return err
+	}
+
+	data, err := json.Marshal(cache)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(cacheFile, data, 0644)
+}

docs/cline-cli/cli-reference.mdx

@@ -0,0 +1,403 @@
+---
+title: "CLI Reference"
+description: "Complete command reference for Cline CLI including configuration, instance management, and task commands"
+---
+
+Complete command reference for Cline CLI. Use this for detailed documentation on all commands, options, and configuration.
+
+For quick help in your terminal:
+
+```bash
+cline --help          # Show all commands
+cline task --help     # Show task-specific commands
+man cline            # View the full manual page
+```
+
+## Manual Page
+
+The complete manual page for the Cline CLI:
+
+```
+CLINE(1)                         User Commands                        CLINE(1)
+
+NAME
+       cline - orchestrate and interact with Cline AI coding agents
+
+SYNOPSIS
+       cline [prompt] [options]
+
+       cline command [subcommand] [options] [arguments]
+
+DESCRIPTION
+       Try: cat README.md | cline "Summarize this for me:"
+
+       cline is a command-line interface for orchestrating multiple Cline AI
+       coding agents.  Cline is an autonomous AI agent who can read, write,
+       and execute code across your projects.  He operates through a
+       client-server architecture where Cline Core runs as a standalone
+       service, and the CLI acts as a scriptable interface for managing tasks,
+       instances, and agent interactions.
+
+       The CLI is designed for both interactive use and automation, making it
+       ideal for CI/CD pipelines, parallel task execution, and terminal-based
+       workflows.  Multiple frontends (CLI, VSCode, JetBrains) can attach to
+       the same Cline Core instance, enabling seamless task handoff between
+       environments.
+
+MODES OF OPERATION
+       Instant Task Mode
+              The simplest invocation: cline "prompt here" immediately spawns
+              an instance, creates a task, and enters chat mode.  This is
+              equivalent to running cline instance new && cline task new &&
+              cline task chat in sequence.
+
+       Subcommand Mode
+              Advanced usage with explicit control: cline <command>
+              [subcommand] [options] provides fine-grained control over
+              instances, tasks, authentication, and configuration.
+
+AGENT BEHAVIOR
+       Cline operates in two primary modes:
+
+       ACT MODE
+              Cline actively uses tools to accomplish tasks.  He can read
+              files, write code, execute commands, use a headless browser, and
+              more.  This is the default mode for task execution.
+
+       PLAN MODE
+              Cline gathers information and creates a detailed plan before
+              implementation.  He explores the codebase, asks clarifying
+              questions, and presents a strategy for user approval before
+              switching to ACT MODE.
+
+INSTANT TASK OPTIONS
+       When using the instant task syntax cline "prompt" the following options
+       are available:
+
+       -o, --oneshot
+              Full autonomous mode.  Cline completes the task and stops
+              following after completion.  Example: cline -o "what's 6 + 8?"
+
+       -s, --setting setting value
+              Override a setting for this task
+
+       -y, --no-interactive, --yolo
+              Enable fully autonomous mode.  Disables all interactivity:
+
+              • ask_followup_question tool is disabled
+
+              • attempt_completion happens automatically
+
+              • execute_command runs in non-blocking mode with timeout
+
+              • PLAN MODE automatically switches to ACT MODE
+
+       -m, --mode mode
+              Starting mode.  Options: act (default), plan
+
+GLOBAL OPTIONS
+       These options apply to all subcommands:
+
+       -F, --output-format format
+              Output format.  Options: rich (default), json, plain
+
+       -h, --help
+              Display help information for the command.
+
+       -v, --verbose
+              Enable verbose output for debugging.
+
+COMMANDS
+   Authentication
+       cline auth [provider] [key]
+
+       cline a [provider] [key]
+              Configure authentication for AI model providers.  Launches an
+              interactive wizard if no arguments provided.  If provider is
+              specified without a key, prompts for the key or launches the
+              appropriate OAuth flow.
+
+   Instance Management
+       Cline Core instances are independent agent processes that can run in
+       the background.  Multiple instances can run simultaneously, enabling
+       parallel task execution.
+
+       cline instance
+
+       cline i
+              Display instance management help.
+
+       cline instance new [-d|--default]
+
+       cline i n [-d|--default]
+              Spawn a new Cline Core instance.  Use --default to set it as
+              the default instance for subsequent commands.
+
+       cline instance list
+
+       cline i l
+              List all running Cline Core instances with their addresses and
+              status.
+
+       cline instance default address
+
+       cline i d address
+              Set the default instance to avoid specifying --address in task
+              commands.
+
+       cline instance kill address [-a|--all]
+
+       cline i k address [-a|--all]
+              Terminate a Cline Core instance.  Use --all to kill all running
+              instances.
+
+   Task Management
+       Tasks represent individual work items that Cline executes.  Tasks
+       maintain conversation history, checkpoints, and settings.
+
+       cline task [-a|--address ADDR]
+
+       cline t [-a|--address ADDR]
+              Display task management help.  The --address flag specifies
+              which Cline Core instance to use (e.g., localhost:50052).
+
+       cline task new prompt [options]
+
+       cline t n prompt [options]
+              Create a new task in the default or specified instance.
+              Options:
+
+              -s, --setting setting value
+                     Set task-specific settings
+
+              -y, --no-interactive, --yolo
+                     Enable autonomous mode
+
+              -m, --mode mode
+                     Starting mode (act or plan)
+
+       cline task open task-id [options]
+
+       cline t o task-id [options]
+              Resume a previous task from history.  Accepts the same options
+              as task new.
+
+       cline task list
+
+       cline t l
+              List all tasks in history with their id and snippet
+
+       cline task chat
+
+       cline t c
+              Enter interactive chat mode for the current task.  Allows
+              back-and-forth conversation with Cline.
+
+       cline task send [message] [options]
+
+       cline t s [message] [options]
+              Send a message to Cline.  If no message is provided, reads from
+              stdin.  Options:
+
+              -a, --approve
+                     Approve Cline's proposed action
+
+              -d, --deny
+                     Deny Cline's proposed action
+
+              -f, --file FILE
+                     Attach a file to the message
+
+              -y, --no-interactive, --yolo
+                     Enable autonomous mode
+
+              -m, --mode mode
+                     Switch mode (act or plan)
+
+       cline task view [-f|--follow] [-c|--follow-complete]
+
+       cline t v [-f|--follow] [-c|--follow-complete]
+              Display the current conversation.  Use --follow to stream
+              updates in real-time, or --follow-complete to follow until task
+              completion.
+
+       cline task restore checkpoint
+
+       cline t r checkpoint
+              Restore the task to a previous checkpoint state.
+
+       cline task pause
+
+       cline t p
+              Pause task execution.
+
+   Configuration
+       Configuration can be set globally.  Override these global settings for
+       a task using the --setting flag
+
+       cline config
+
+       cline c
+
+       cline config set key value
+
+       cline c s key value
+              Set a configuration variable.
+
+       cline config get key
+
+       cline c g key
+              Read a configuration variable.
+
+       cline config list
+
+       cline c l
+              List all configuration variables and their values.
+
+TASK SETTINGS
+       Task settings are persisted in the ~/.cline/x/tasks directory.  When
+       resuming a task with cline task open, task settings are automatically
+       restored.
+
+       Common settings include:
+
+       yolo   Enable autonomous mode (true/false)
+
+       mode   Starting mode (act/plan)
+
+NOTES & EXAMPLES
+       The cline task send and cline task new commands support reading from
+       stdin, enabling powerful pipeline compositions:
+
+              cat requirements.txt | cline task send
+              echo "Refactor this code" | cline -y
+
+   Instance Management
+       Manage multiple Cline instances:
+
+              # Start a new instance and make it default
+              cline instance new --default
+
+              # List all running instances
+              cline instance list
+
+              # Kill a specific instance
+              cline instance kill localhost:50052
+
+              # Kill all CLI instances
+              cline instance kill --all-cli
+
+   Task History
+       Work with task history:
+
+              # List previous tasks
+              cline task list
+
+              # Resume a previous task
+              cline task open 1760501486669
+
+              # View conversation history
+              cline task view
+
+              # Start interactive chat with this task
+              cline task chat
+
+ARCHITECTURE
+       Cline operates on a three-layer architecture:
+
+       Presentation Layer
+              User interfaces (CLI, VSCode, JetBrains) that connect to Cline
+              Core via gRPC
+
+       Cline Core
+              The autonomous agent service handling task management, AI model
+              integration, state management, tool orchestration, and real-time
+              streaming updates
+
+       Host Provider Layer
+              Environment-specific integrations (VSCode APIs, JetBrains APIs,
+              shell APIs) that Cline Core uses to interact with the host
+              system
+
+BUGS
+       Report bugs at: <https://github.com/cline/cline/issues>
+
+       For real-time help, join the Discord community at:
+       <https://discord.gg/cline>
+
+SEE ALSO
+       Full documentation: <https://docs.cline.bot>
+
+AUTHORS
+       Cline is developed by the Cline Bot Inc. and the open source community.
+
+COPYRIGHT
+       Copyright © 2025 Cline Bot Inc. Licensed under the Apache License 2.0.
+```
+
+### Shell Completion
+
+Generate autocompletion scripts for various shells:
+
+#### Bash
+
+```bash
+# Generate bash completion
+cline completion bash > /etc/bash_completion.d/cline
+
+# Or for user-level installation
+cline completion bash > ~/.local/share/bash-completion/completions/cline
+```
+
+#### Zsh
+
+```bash
+# Generate zsh completion
+cline completion zsh > "${fpath[1]}/_cline"
+
+# Or add to your .zshrc
+echo 'source <(cline completion zsh)' >> ~/.zshrc
+```
+
+#### Fish
+
+```bash
+# Generate fish completion
+cline completion fish > ~/.config/fish/completions/cline.fish
+```
+
+#### PowerShell
+
+```powershell
+# Generate PowerShell completion
+cline completion powershell > cline.ps1
+
+# Add to your PowerShell profile
+Add-Content $PROFILE "cline completion powershell | Out-String | Invoke-Expression"
+```
+
+### Version Command
+
+```bash
+# Show version information
+cline version
+```
+
+### Environment Variables
+
+#### CLINE_DIR
+
+Override the default Cline directory location:
+
+```bash
+# Override default Cline directory
+export CLINE_DIR=/custom/path
+
+# Default: ~/.cline
+```
+
+This directory is used for:
+- Instance registry database
+- Configuration files
+- Task history
+- Checkpoints

docs/cline-cli/installation.mdx

@@ -0,0 +1,50 @@
+---
+title: "Installation"
+description: "Install Cline CLI and authenticate with your account"
+---
+
+## Prerequisites
+
+Cline CLI requires Node.js version 20 or higher. We recommend using Node.js 22 for the best experience.
+
+To check your Node.js version:
+
+```bash
+node --version
+```
+
+## Installation
+
+```bash
+npm install -g cline
+```
+
+After installation, authenticate with your Cline account:
+
+```bash
+cline auth
+```
+
+This starts an authentication wizard to sign you in and configure your preferred AI model provider.
+
+## Quick Start
+
+Get started with Cline in seconds:
+
+```bash
+cline
+```
+
+That's it! Running `cline` in any directory starts an interactive session where you can chat with the AI agent. Type your task, review the plan, and type `/act` when ready to execute.
+
+For even faster execution without interaction:
+
+```bash
+cline "Add unit tests to utils.js"
+```
+
+This runs Cline with a single command, perfect for quick tasks or automation.
+
+<Tip>
+New to Cline CLI? Start with interactive mode (`cline`) to see how it works. Once comfortable, explore [the three core flows](/cline-cli/three-core-flows) for advanced usage patterns.
+</Tip>

docs/cline-cli/overview.mdx

@@ -0,0 +1,70 @@
+---
+title: "Overview"
+description: "Install the CLI, run your first task, and learn to automate code reviews and integrate AI agents into your development workflow"
+---
+
+<Warning>
+**Preview Release - macOS and Linux Only**
+
+Cline CLI is currently in preview and only available for macOS and Linux users. Windows support is coming soon.
+</Warning>
+
+## What is Cline CLI?
+
+Cline CLI runs AI coding agents directly in your terminal. Pipe git diffs for automated code reviews in CI/CD, run multiple instances simultaneously for parallel development, or integrate Cline into your existing shell workflows.
+
+The CLI tracks instances across your system and outputs in formats designed for both humans and scripts—JSON, plain text, or rich terminal output.
+
+<Tip>
+Ready to get started? Check out the [installation guide](/cline-cli/installation) to install Cline CLI and run your first task.
+</Tip>
+
+## Supported Model Providers
+
+Cline CLI supports multiple AI model providers, giving you flexibility in choosing the best model for your needs:
+
+- **Anthropic**
+- **OpenAI**
+- **OpenAI Compatible**
+- **OpenRouter**
+- **X AI (Grok)**
+- **AWS Bedrock**
+- **Google Gemini**
+- **Ollama**
+- **Cerebras**
+
+During installation, you'll authenticate and configure your preferred provider using the `cline auth` command.
+
+## What you can build with this
+
+**Automated code maintenance**
+- Schedule daily runs to identify and fix linting issues across your codebase
+- Create tasks that scan for security vulnerabilities and automatically patch them
+- Build scripts that update deprecated dependencies and run tests
+
+**Multi-instance development**
+- Run separate Cline instances for frontend and backend simultaneously
+- Spawn instances for different feature branches, each with isolated state
+- Create parallel review processes for multiple PRs
+
+**Custom workflows**
+- Build shell scripts that combine Cline with git hooks for pre-commit analysis
+- Create custom commands that pipe complex data structures through Cline for processing
+- Integrate with your existing toolchain (jq, grep, awk) for sophisticated automation
+
+**CI/CD integration**
+- Add Cline to GitHub Actions for automatic code review on every PR
+- Create GitLab pipelines that generate migration scripts from schema changes
+- Build Jenkins jobs that use Cline to analyze test failures and suggest fixes
+
+## Learn more
+
+<Columns cols={2}>
+  <Card title="Installation" icon="download" href="/cline-cli/installation">
+    Install Cline CLI and authenticate with your account to get started.
+  </Card>
+  
+  <Card title="Three Core Flows" icon="route" href="/cline-cli/three-core-flows">
+    Master the three ways to use Cline CLI: interactive mode, headless automation, and multi-instance parallelization.
+  </Card>
+</Columns>

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

@@ -0,0 +1,144 @@
+---
+title: "Three Core Flows"
+description: "Learn the three ways to use Cline CLI: interactive mode, headless automation, and multi-instance parallelization"
+---
+
+Two concepts to understand:
+
+**Task** - A single job for Cline to complete ("add tests to utils.js"). You describe what you want, Cline plans how to do it, then executes the plan. Tasks run on instances.
+
+**Instance** - An independent Cline workspace. Each instance runs one task at a time. Create multiple instances to run multiple tasks that work on different parts of your project in parallel.
+
+## 1. Interactive mode: Plan first, then act
+
+Start here to see how Cline works. Interactive mode opens a chat session where you can review plans before execution.
+
+```bash
+cline
+```
+
+Cline opens an interactive session in your current directory. Type your task as a message. Cline enters Plan mode and proposes a step-by-step strategy.
+
+Review or edit the plan in chat. When you're ready, switch to execution:
+
+```bash
+/act
+```
+
+Cline executes the approved steps—reading files, writing code, running commands. You maintain control throughout the process.
+
+## 2. Headless single-shot: Complete a task without chat
+
+Use this for automation where you want a one-liner that just does the work.
+
+```bash
+cline instance new --default
+cline task new -y "Generate unit tests for all Go files"
+```
+
+With the `-y` (YOLO) flag, Cline plans and executes autonomously without interactive chat. Perfect for CI, cron jobs, or scripts.
+
+Examples:
+
+```bash
+# Create a complete feature
+cline task new -y "Create a REST API for user authentication"
+
+# Generate documentation
+cline task new -y "Add JSDoc comments to all functions in src/"
+
+# Refactor code
+cline task new -y "Convert all var declarations to const/let"
+```
+
+Monitor your task with:
+
+```bash
+# View task status
+cline task view
+
+# Follow task progress in real-time
+cline task view --follow
+```
+
+Press Ctrl+C to exit the view.
+
+<Note>
+Run YOLO mode with care on a directory or a clean Git branch. You get speed in exchange for oversight, so be ready to revert if needed.
+</Note>
+
+## 3. Multi-instance: Run parallel agents
+
+Multiple instances let you parallelize work on the same project without colliding contexts. Run frontend, backend, and infrastructure tasks simultaneously.
+
+Create your first instance:
+
+```bash
+cline instance new
+```
+
+This returns an instance address you'll use to target tasks. Attach a task to this instance:
+
+```bash
+# Frontend work on first instance
+cline task new -y "Build React components"
+```
+
+Create a second instance and set it as default in one command:
+
+```bash
+cline instance new --default
+```
+
+Now you can create tasks without specifying the address—they automatically use the default instance:
+
+```bash
+# Backend work on the new default instance
+cline task new -y "Implement API endpoints"
+```
+
+List all running instances:
+
+```bash
+cline instances list
+```
+
+Stop all instances when done:
+
+```bash
+cline instances kill -a
+```
+
+<Tip>
+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>
+
+## Choosing the right flow
+
+- **Interactive mode**: Best for exploring new problems, learning how Cline works, or when you want to review plans before execution
+- **Headless single-shot**: Perfect for automation, CI/CD, and tasks where you trust Cline to execute without supervision
+- **Multi-instance**: Use when you need to parallelize work or maintain separate contexts for different parts of your project
+
+<Tip>
+For in-depth commands and flags, check out the [CLI reference](/cline-cli/cli-reference) page for complete documentation on all available options.
+</Tip>
+
+## Next steps
+
+<Columns cols={2}>
+  <Card title="CLI reference" icon="terminal" href="/cline-cli/cli-reference">
+    Complete command documentation including configuration, instance management, and task commands.
+  </Card>
+  
+  <Card title="Plan and Act" icon="brain" href="/features/plan-and-act">
+    Deep dive into Plan and Act modes, including when to use each and how to switch between them.
+  </Card>
+  
+  <Card title="YOLO mode" icon="zap" href="/features/yolo-mode">
+    Understand how YOLO mode works and when to use full automation versus manual approval.
+  </Card>
+  
+  <Card title="Task management" icon="clipboard-check" href="/getting-started/task-management">
+    Learn how Cline tracks and manages tasks, including saving and restoring state from checkpoints.
+  </Card>
+</Columns>

docs/core-features/model-selection-guide.mdx

@@ -0,0 +1,202 @@
+---
+title: "Model Selection Guide"
+description: "Last updated: August 20, 2025."
+---
+
+New models drop constantly, so this guide focuses on what's working well with Cline right now. We'll keep it updated as the landscape shifts.
+
+<Callout type="tip">
+**New to model selection?** Start with [Module 2 of Cline's Learning Path](https://cline.bot/learn) for a comprehensive guide to choosing and configuring models.
+</Callout>
+
+## What is an AI Model?
+
+Think of an AI model as the "brain" that powers Cline. When you ask Cline to write code, fix bugs, or refactor your project, it's the model that actually understands your request and generates the response.
+
+**Key points:**
+- **Models are trained AI systems** that understand natural language and code
+- **Different models have different strengths** some excel at complex reasoning, others prioritize speed or cost
+- **You choose which model Cline uses** like picking between different experts for different tasks
+- **Models are accessed via API providers** - companies like Anthropic, OpenAI, and OpenRouter host these models
+
+**Why it matters:** The model you choose directly impacts Cline's capabilities, response quality, speed, and cost. A premium model might handle complex refactoring beautifully but cost more, while a budget model works great for routine tasks at a fraction of the price.
+
+## How to Select a Model in Cline
+
+Follow these 5 simple steps to get Cline up and running with your preferred AI model:
+
+### Step 1: Open Cline Settings
+
+First, you need to access Cline's configuration panel.
+
+**Two ways to open settings:**
+- **Quick method**: Click the **gear icon (⚙️)** in the top-right corner of Cline's chat interface
+- **Command palette**: Press **Cmd/Ctrl + Shift + P** → type "Cline: Open Settings"
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/step1-config.png" alt="Cline Settings Panel" />
+</Frame>
+
+The settings panel will open, showing configuration options with "API Provider" at the top.
+
+<Note>
+The settings panel remembers your last configuration, so you'll only need to set this up once.
+</Note>
+
+### Step 2: Select an API Provider
+
+Choose your preferred AI provider from the dropdown menu.
+
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/step2-provider.png" alt="Cline Settings Panel" />
+</Frame>
+
+**Popular providers at a glance:**
+
+| Provider | Best For | Notes |
+|----------|----------|-------|
+| **Cline** | Easiest setup | No API keys needed, access to multiple models including stealth models |
+| **OpenRouter** | Value seekers | Multiple models, competitive pricing |
+| **Anthropic** | Reliability | Claude models, most dependable tool usage |
+| **OpenAI** | Latest tech | GPT models |
+| **Google Gemini** | Large context | Google's AI models |
+| **AWS Bedrock** | Enterprise | Advanced features |
+| **Ollama** | Privacy | Run models locally |
+
+See the [full provider list](/provider-config) for more options including Cerebras, Vertex AI, Azure, and more.
+
+<Info>
+**Recommended for beginners:** Start with **Cline** as your provider - no API key management needed, instant access to multiple models, and occasional free inferencing through partner providers.
+</Info>
+
+### Step 3: Add Your API Key (or Sign In)
+
+The next step depends on which provider you selected.
+
+#### If you selected **Cline** as your provider:
+
+- **No API key needed!** Simply sign in with your Cline account
+- Click the **Sign In** button when prompted
+- You'll be redirected to [app.cline.bot](https://app.cline.bot) to authenticate
+- After signing in, return to your IDE
+
+#### If you selected any other provider:
+
+You'll need to get an API key from your chosen provider:
+
+1. **Visit your provider's website to get an API key:**
+   - **Anthropic**: [console.anthropic.com](https://console.anthropic.com/)
+   - **OpenRouter**: [openrouter.ai/keys](https://openrouter.ai/keys)
+   - **OpenAI**: [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
+   - **Google**: [aistudio.google.com/apikey](https://aistudio.google.com/apikey)
+   - **Others**: See [Provider Setup Guide](/provider-config)
+
+2. **Generate a new API key** on the provider's website
+
+3. **Copy the API key** to your clipboard
+
+4. **Paste your key** in the **"API Key"** field in Cline settings
+
+5. **Save automatically** - Your key is stored securely in your editor's secrets storage
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/step3-API.png" alt="Cline API Selection" />
+</Frame>
+
+<Warning>
+**Payment required for most providers**: Most providers need payment information before generating keys. You only pay for what you use (typically $0.01-$0.10 per coding task).
+</Warning>
+
+### Step 4: Choose Your Model
+
+Once your API key is added (or you've signed in), the **"Model"** dropdown becomes available.
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/step4-model.png" alt="Cline Model Selection" />
+</Frame>
+
+**Quick model selection guide:**
+
+| Your Priority | Choose This Model | Why |
+|---------------|-------------------|-----|
+| **Maximum reliability** | Claude Sonnet 4.5 | Most reliable tool usage, excellent at complex tasks |
+| **Best value** | DeepSeek V3 or Qwen3 Coder | Great performance at budget prices |
+| **Fastest speed** | Qwen3 Coder on Cerebras | Lightning-fast responses |
+| **Run locally** | Any Ollama model | Complete privacy, no internet needed |
+| **Latest features** | GPT-5 | OpenAI's newest capabilities |
+
+Not sure which to pick? Start with **Claude Sonnet 4.5** for reliability or **DeepSeek V3** for value.
+
+<Tip>
+You can switch models at any time without losing your conversation. Try different models to find what works best for your specific tasks.
+</Tip>
+
+See the [model comparison tables](#current-top-models) below for detailed specifications and pricing.
+
+### Step 5: Start Using Cline
+
+**Congratulations! You're all set up.** Here's how to start coding with Cline:
+
+1. **Type your request** in the Cline chat box
+   - Example: "Create a React component for a login form"
+   - Example: "Debug this TypeScript error"
+   - Example: "Refactor this function to be more efficient"
+
+2. **Press Enter** or click the send icon to submit
+
+## Choosing the Right Model
+
+Selecting the right model involves balancing several factors. Use this framework to find your ideal match:
+
+<Note>
+**Pro tips**: Configure separate models for Plan Mode and Act Mode. Make the most out the each model's strengths. For example, use a budget model for planning discussions and a premium model for implementation.
+</Note>
+
+### Key Selection Factors
+
+| Factor | What to Consider | Recommendation |
+|--------|------------------|----------------|
+| **Task Complexity** | Simple fixes vs complex refactoring | Budget models for routine tasks; Premium models for complex work |
+| **Budget** | Monthly spending capacity | \$10-\$30: Budget,  \$30-\$100: Mid-tier, \$100+: Premium |
+| **Context Window** | Project size and file count | Small: 32K-128K, Medium: 128K-200K, Large: 400K+ |
+| **Speed** | Response time requirements | Interactive: Fast models, Background: Reasoning models OK |
+| **Tool Reliability** | Complex operations | Claude excels at tool usage; Test others with your workflow |
+| **Provider** | Access and pricing needs | OpenRouter: Many options, Direct: Faster/reliable, Local: Privacy |
+
+
+
+## Model Comparison Resources
+
+For detailed model comparisons, pricing, and performance metrics, see:
+- [**Model Comparison & Pricing**](/model-config/model-comparison) - Complete pricing tables and performance benchmarks
+- [**Context Window Guide**](/model-config/context-windows) - Understanding and optimizing context usage
+
+## Open Source vs Closed Source
+
+### Open Source Advantages
+- **Multiple providers** compete to host them
+- **Cheaper pricing** due to competition  
+- **Provider choice** - switch if one goes down
+- **Faster innovation** cycles
+
+### Open Source Models Available
+- **Qwen3 Coder** (Apache 2.0)
+- **Z AI GLM 4.5** (MIT)
+- **Kimi K2** (Open source)
+- **DeepSeek series** (Various licenses)
+
+## Quick Decision Matrix
+
+| If you want... | Use this |
+|----------------|----------|
+| Something that just works | Claude Sonnet 4.5 |
+| To save money | DeepSeek V3 or Qwen3 variants |
+| Huge context windows | Gemini 2.5 Pro or Claude Sonnet 4.5 |
+| Open source | Qwen3 Coder, Z AI GLM 4.5, or Kimi K2 |
+| Latest tech | GPT-5 |
+| Speed | Qwen3 Coder on Cerebras (fastest available) |
+
+## What Others Are Using
+
+Check [OpenRouter's Cline usage stats](https://openrouter.ai/apps?url=https%3A%2F%2Fcline.bot%2F) to see real usage patterns from the community.

docs/docs.json

@@ -2,15 +2,15 @@
 	"$schema": "https://mintlify.com/docs.json",
 	"theme": "linden",
 	"name": "Cline",
-	"description": "AI-powered coding assistant for VSCode",
+	"description": "AI-powered coding agent for complex work",
 	"colors": {
 		"primary": "#9D4EDD",
 		"light": "#F0E6FF",
 		"dark": "#000000"
 	},
 	"logo": {
-		"light": "/assets/robot_panel_light.png",
-		"dark": "/assets/robot_panel_dark.png"
+		"light": "/assets/Cline_Logo-complete_black.png",
+		"dark": "/assets/Cline_Logo-complete_white.png"
 	},
 	"favicon": {
 		"light": "/assets/robot_panel_light.png",
@@ -18,10 +18,9 @@
 	},
 	"background": {
 		"color": {
-			"light": "#F0E6FF",
-			"dark": "#000000"
-		},
-		"decoration": "gradient"
+			"light": "#fafaf9",
+			"dark": "#0f0f0f"
+		}
 	},
 	"styling": {
 		"eyebrows": "breadcrumbs",
@@ -33,16 +32,18 @@
 		"strict": false
 	},
 	"fonts": {
-		"family": "Roboto"
+		"family": "Geist Sans"
 	},
 	"navbar": {
 		"links": [
 			{
 				"label": "GitHub",
+				"icon": "github",
 				"href": "https://github.com/cline/cline"
 			},
 			{
 				"label": "Discord",
+				"icon": "discord",
 				"href": "https://discord.gg/cline"
 			}
 		],
@@ -53,169 +54,210 @@
 		}
 	},
 	"navigation": {
-		"groups": [
+		"tabs": [
 			{
-				"group": "Getting Started",
-				"pages": [
-					"getting-started/what-is-cline",
-					"getting-started/installing-cline",
-					"getting-started/model-selection-guide",
-					"getting-started/task-management",
-					"getting-started/understanding-context-management",
+				"tab": "Docs",
+				"icon": "square-terminal",
+				"groups": [
 					{
-						"group": "For New Coders",
+						"group": "Introduction",
 						"pages": [
-							"getting-started/for-new-coders",
-							"getting-started/installing-dev-essentials"
+							"introduction/welcome",
+							"introduction/overview"
+						]
+					},
+					{
+						"group": "Getting Started",
+						"pages": [
+							"getting-started/installing-cline",
+							"getting-started/selecting-your-model",
+							"getting-started/your-first-project"
+						]
+					},
+					{
+						"group": "Best Practices",
+						"pages": [
+							"prompting/understanding-context-management",
+							"prompting/prompt-engineering-guide",
+							"prompting/cline-memory-bank"
+						]
+					},
+					{
+						"group": "CLI",
+						"pages": [
+							"cline-cli/overview",
+							"cline-cli/installation",
+							"cline-cli/three-core-flows",
+							"cline-cli/cli-reference"
+						]
+					},
+					{
+						"group": "Features",
+						"pages": [
+							{
+								"group": "@ Mentions",
+								"pages": [
+									"features/at-mentions/overview",
+									"features/at-mentions/file-mentions",
+									"features/at-mentions/terminal-mentions",
+									"features/at-mentions/problem-mentions",
+									"features/at-mentions/git-mentions",
+									"features/at-mentions/url-mentions"
+								]
+							},
+							"features/auto-approve",
+							"features/auto-compact",
+							"features/checkpoints",
+							"features/cline-rules",
+							{
+								"group": "Commands & Shortcuts",
+								"pages": [
+									"features/commands-and-shortcuts/overview",
+									"features/commands-and-shortcuts/code-commands",
+									"features/commands-and-shortcuts/terminal-integration",
+									"features/commands-and-shortcuts/git-integration",
+									"features/commands-and-shortcuts/keyboard-shortcuts"
+								]
+							},
+							{
+								"group": "Customization",
+								"pages": [
+									"features/customization/opening-cline-in-sidebar",
+									"features/customization/disable-terminal-pagers"
+								]
+							},
+							"features/dictation",
+							"features/drag-and-drop",
+							"features/editing-messages",
+							"features/focus-chain",
+							"features/multiroot-workspace",
+							"features/plan-and-act",
+							{
+								"group": "Slash Commands",
+								"pages": [
+									"features/slash-commands/new-task",
+									"features/slash-commands/new-rule",
+									"features/slash-commands/smol",
+									"features/slash-commands/report-bug",
+									"features/slash-commands/deep-planning"
+								]
+							},
+							"features/slash-commands/workflows",
+							{
+								"group": "Task Management",
+								"pages": [
+									"features/tasks/understanding-tasks",
+									"features/tasks/task-management"
+								]
+							},
+							"features/yolo-mode"
+						]
+					},
+					{
+						"group": "Model & Provider Configuration",
+						"pages": [
+							{
+								"group": "Model Selection",
+								"pages": [
+									"core-features/model-selection-guide",
+									"model-config/model-comparison",
+									"model-config/context-windows"
+								]
+							},
+							{
+								"group": "Cloud Providers",
+								"pages": [
+									"provider-config/anthropic",
+									"provider-config/claude-code",
+									"provider-config/openai",
+									"provider-config/openrouter",
+									"provider-config/cerebras",
+									"provider-config/deepseek",
+									"provider-config/groq",
+									"provider-config/xai-grok",
+									"provider-config/mistral-ai",
+									"provider-config/doubao",
+									"provider-config/fireworks",
+									"provider-config/zai",
+									"provider-config/gcp-vertex-ai",
+									{
+										"group": "AWS Bedrock",
+										"pages": [
+											"provider-config/aws-bedrock/api-key",
+											"provider-config/aws-bedrock/iam-credentials",
+											"provider-config/aws-bedrock/cli-profile"
+										]
+									}
+								]
+							},
+							{
+								"group": "Running Models Locally",
+								"pages": [
+									"running-models-locally/overview",
+									"running-models-locally/ollama",
+									"running-models-locally/lm-studio"
+								]
+							},
+							{
+								"group": "Advanced Configuration",
+								"pages": [
+									"provider-config/openai-compatible",
+									"provider-config/litellm-and-cline-using-codestral",
+									"provider-config/vscode-language-model-api",
+									"provider-config/sap-aicore",
+									"provider-config/vercel-ai-gateway",
+									"provider-config/requesty",
+									"provider-config/baseten"
+								]
+							}
+						]
+					},
+					{
+						"group": "MCP Integration",
+						"pages": [
+							"mcp/mcp-overview",
+							"mcp/adding-mcp-servers-from-github",
+							"mcp/configuring-mcp-servers",
+							"mcp/connecting-to-a-remote-server",
+							"mcp/mcp-marketplace",
+							"mcp/mcp-server-development-protocol",
+							"mcp/mcp-transport-mechanisms"
+						]
+					},
+					{
+						"group": "Cline Tools Reference",
+						"pages": [
+							"exploring-clines-tools/cline-tools-guide",
+							"exploring-clines-tools/new-task-tool",
+							"exploring-clines-tools/remote-browser-support"
+						]
+					},
+					{
+						"group": "Enterprise",
+						"pages": [
+							"enterprise-solutions/overview",
+							"enterprise-solutions/security-concerns"
+						]
+					},
+					{
+						"group": "Reference",
+						"pages": [
+							"troubleshooting/terminal-quick-fixes",
+							"troubleshooting/terminal-integration-guide",
+							"more-info/telemetry"
 						]
 					}
 				]
 			},
 			{
-				"group": "Improving Your Prompting Skills",
-				"pages": [
-					"prompting/prompt-engineering-guide",
-					"prompting/cline-memory-bank"
-				]
+				"tab": "Learn",
+				"icon": "graduation-cap",
+				"href": "https://cline.bot/learn"
 			},
 			{
-				"group": "Features",
-				"pages": [
-					{
-						"group": "@ Mentions",
-						"pages": [
-							"features/at-mentions/overview",
-							"features/at-mentions/file-mentions",
-							"features/at-mentions/terminal-mentions",
-							"features/at-mentions/problem-mentions",
-							"features/at-mentions/git-mentions",
-							"features/at-mentions/url-mentions"
-						]
-					},
-					"features/auto-approve",
-					"features/auto-compact",
-					"features/checkpoints",
-					"features/cline-rules",
-					{
-						"group": "Commands & Shortcuts",
-						"pages": [
-							"features/commands-and-shortcuts/overview",
-							"features/commands-and-shortcuts/code-commands",
-							"features/commands-and-shortcuts/terminal-integration",
-							"features/commands-and-shortcuts/git-integration",
-							"features/commands-and-shortcuts/keyboard-shortcuts"
-						]
-					},
-					{
-						"group": "Customization",
-						"pages": [
-							"features/customization/opening-cline-in-sidebar",
-							"features/customization/disable-terminal-pagers"
-						]
-					},
-					"features/dictation",
-					"features/drag-and-drop",
-					"features/editing-messages",
-					"features/focus-chain",
-					"features/multiroot-workspace",
-					"features/plan-and-act",
-					{
-						"group": "Slash Commands",
-						"pages": [
-							"features/slash-commands/new-task",
-							"features/slash-commands/new-rule",
-							"features/slash-commands/smol",
-							"features/slash-commands/report-bug",
-							"features/slash-commands/deep-planning"
-						]
-					},
-					"features/slash-commands/workflows",
-					"features/yolo-mode"
-				]
-			},
-			{
-				"group": "Exploring Cline's Tools",
-				"pages": [
-					"exploring-clines-tools/cline-tools-guide",
-					"exploring-clines-tools/new-task-tool",
-					"exploring-clines-tools/remote-browser-support"
-				]
-			},
-			{
-				"group": "Enterprise Solutions",
-				"pages": [
-					"enterprise-solutions/cloud-provider-integration",
-					"enterprise-solutions/custom-instructions",
-					"enterprise-solutions/mcp-servers",
-					"enterprise-solutions/security-concerns"
-				]
-			},
-			{
-				"group": "MCP Servers",
-				"pages": [
-					"mcp/mcp-overview",
-					"mcp/adding-mcp-servers-from-github",
-					"mcp/configuring-mcp-servers",
-					"mcp/connecting-to-a-remote-server",
-					"mcp/mcp-marketplace",
-					"mcp/mcp-server-development-protocol",
-					"mcp/mcp-transport-mechanisms"
-				]
-			},
-			{
-				"group": "Provider Configuration",
-				"pages": [
-					"provider-config/anthropic",
-					"provider-config/claude-code",
-					{
-						"group": "AWS Bedrock",
-						"pages": [
-							"provider-config/aws-bedrock/api-key",
-							"provider-config/aws-bedrock/iam-credentials",
-							"provider-config/aws-bedrock/cli-profile"
-						]
-					},
-					"provider-config/gcp-vertex-ai",
-					"provider-config/litellm-and-cline-using-codestral",
-					"provider-config/vscode-language-model-api",
-					"provider-config/xai-grok",
-					"provider-config/mistral-ai",
-					"provider-config/deepseek",
-					"provider-config/groq",
-					"provider-config/cerebras",
-					"provider-config/doubao",
-					"provider-config/fireworks",
-					"provider-config/zai",
-					"provider-config/ollama",
-					"provider-config/openai",
-					"provider-config/openai-compatible",
-					"provider-config/openrouter",
-					"provider-config/sap-aicore",
-					"provider-config/vercel-ai-gateway",
-					"provider-config/requesty",
-					"provider-config/baseten"
-				]
-			},
-			{
-				"group": "Running Models Locally",
-				"pages": [
-					"running-models-locally/read-me-first",
-					"running-models-locally/lm-studio",
-					"running-models-locally/ollama"
-				]
-			},
-			{
-				"group": "Troubleshooting",
-				"pages": [
-					"troubleshooting/terminal-quick-fixes",
-					"troubleshooting/terminal-integration-guide"
-				]
-			},
-			{
-				"group": "More Info",
-				"pages": [
-					"more-info/telemetry"
-				]
+				"tab": "Blog",
+				"icon": "newspaper",
+				"href": "https://cline.bot/blog"
 			}
 		]
 	},
@@ -228,23 +270,54 @@
 	},
 	"anchors": [
 		{
-			"name": "What is Cline",
+			"name": "Overview",
 			"icon": "house",
-			"url": "getting-started/what-is-cline"
+			"url": "introduction/overview"
 		}
 	],
 	"redirects": [
 		{
 			"source": "/getting-started/installing-cline-jetbrains",
 			"destination": "/getting-started/installing-cline"
+		},
+		{
+			"source": "/getting-started/what-is-cline",
+			"destination": "/introduction/overview"
+		},
+		{
+			"source": "/getting-started/overview",
+			"destination": "/introduction/overview"
+		},
+		{
+			"source": "/introduction",
+			"destination": "/introduction/welcome"
+		},
+		{
+			"source": "/getting-started/model-selection-guide",
+			"destination": "/core-features/model-selection-guide"
+		},
+		{
+			"source": "/provider-config/ollama",
+			"destination": "/running-models-locally/ollama"
+		},
+		{
+			"source": "/running-models-locally/read-me-first",
+			"destination": "/running-models-locally/overview"
+		},
+		{
+			"source": "/getting-started/understanding-context-management",
+			"destination": "/prompting/understanding-context-management"
+		},
+		{
+			"source": "/best-practices/understanding-context-management",
+			"destination": "/prompting/understanding-context-management"
+		},
+		{
+			"source": "/getting-started/your-first-task",
+			"destination": "/getting-started/your-first-project"
 		}
 	],
 	"search": {
 		"prompt": "Search Cline documentation..."
-	},
-	"contextual": {
-		"options": [
-			"copy"
-		]
 	}
 }

docs/enterprise-solutions/cloud-provider-integration.mdx

@@ -1,41 +0,0 @@
----
-title: "Cloud Provider Integration"
----
-
-Cline supports major cloud providers like AWS Bedrock and Google's Cloud Vertex; whichever your team currently uses is appropriate, and there's no need to change providers to utilize Cline's features.
-
-For the purpose of this document, we assume your organization will use cloud-based frontier models. Cloud inference providers offer cutting-edge capabilities and the flexibility to select models which best suit your needs.
-
-Certain scenarios may warrant using local models, including handling highly sensitive data, applications requiring consistent low-latency responses, or compliance with strict data sovereignty requirements. If your team needs to utilize local models, see [Running Local Models ](/running-models-locally/read-me-first.mdx)with Cline.
-
----
-
-## AWS Bedrock Setup Guides
-
-#### [IAM Security Best Practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) (For administrators)
-
-#### [AWS Bedrock setup for API Keys](/provider-config/aws-bedrock-with-apikey-authentication)
-
-#### [AWS Bedrock setup for Legacy IAM (AWS Credentials)](/provider-config/aws-bedrock-with-credentials-authentication)
-
-#### [AWS Bedrock setup for SSO token (AWS Profile)](/provider-config/aws-bedrock-with-profile-authentication)
-
-#### VPC Endpoint Setup
-
-To protect your team's data, Cline supports VPC (Virtual Private Cloud) endpoints, which create private connections between your data and AWS Bedrock. AWS VPCs enhance security by eliminating the need for public IP addresses, network gateways, or complex firewall rules—essentially creating a private highway for data that bypasses the public internet entirely. By keeping traffic within AWS's private network, teams also benefit from lower latency and more predictable performance when accessing services like AWS Bedrock or custom APIs. For those working with confidential information or operating in highly regulated industries like healthcare or finance, VPCs offers the perfect balance between the accessibility of cloud services and the security of private infrastructure.
-
----
-
-1. Consult the [AWS guide](https://docs.aws.amazon.com/bedrock/latest/userguide/vpc-interface-endpoints.html) to creating VPC endpoints. This document specifies pre-requisites and describes the syntax used for creating VPC endpoints.
-2. Follow the directions for [creating a VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) in the AWS console. The image below pertains to steps 4 and 5 of the AWS guide linked above.
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/vpc-console.png" alt="VPC Console" />
-</Frame>
-
-3. Note the IP address of your VPC endpoint, open Cline's settings menu, and select `AWS Bedrock`from the API Provider dropdown.
-4. Click the `Use Custom VPC endpoint`checkbox and enter the IP address of your VPC endpoint
-
-<Frame>
-	<img src="https://storage.googleapis.com/cline_public_images/docs/assets/vpc-settings-menu.png" alt="VPC Settings Menu" />
-</Frame>

docs/enterprise-solutions/custom-instructions.mdx

@@ -1,22 +0,0 @@
----
-title: "Custom Instructions"
----
-
-## Building Custom Instructions for Teams
-
-**Creating standardized project instructions ensures that all team members work within consistent guidelines. Start by documenting your project's technical foundation, then identify which information needs to be included in the instructions. The exact scope will vary depending on your team's needs, but generally it's best to provide as much information as possible. By creating comprehensive instructions that all team members follow, you establish a shared understanding of how code should be written, tested, and deployed across your project, resulting in more maintainable and consistent software.**
-
----
-
-Here are a few topics and examples to consider for your team's custom instructions:
-
-1. **Testing framework and specific commands**
-    - "All components must include Jest tests with at least 85% coverage. Run tests using `npm run test:coverage` before submitting any pull request."
-2. **Explicit library preferences**
-    - "Use React Query for data fetching and state management. Avoid Redux unless specifically required for complex global state. For styling, use Tailwind CSS with our custom theme configuration found in `src/styles/theme.js.`"
-3. **Where to find documentation**
-    - "All API documentation is available in our internal Notion workspace under 'Engineering > API Reference'. For component usage examples, refer to our Storybook instance at `https://storybook.internal.company.com`"
-4. **Which MCP servers to use, and for which purposes**
-    - "For database operations, use the Postgres MCP server with credentials stored in 1Password under 'Development > Database'. For deployments, use the AWS MCP server which requires the deployment role from IAM. Refer to `docs/mcp-setup.md` for configuration instructions."
-5. **Coding conventions specific to your project**
-    - "Name all React components using PascalCase and all helper functions using camelCase. Place components in the `src/components` directory organized by feature, not by type. Always use TypeScript interfaces for prop definitions."

docs/enterprise-solutions/mcp-servers.mdx

@@ -1,25 +0,0 @@
----
-title: "MCP Servers"
----
-
-**Model Context Protocol (MCP) servers expand Cline's capabilities by providing standardized access to external data sources and executable functions. By implementing MCP servers, LLM tools can dynamically retrieve and incorporate relevant information from both local and remote data sources. This capability ensures that the models operate with the most current and contextually appropriate data, improving the accuracy and relevance of their outputs.**
-
----
-
-### Secure Architecture Fundamentals
-
-MCP servers follow a client-server architecture where hosts (LLM applications like Cline) initiate connections through a transport layer to MCP servers. This architecture inherently provides security benefits as it maintains clear separation between components. Enterprise deployments should focus on the proper implementation of this architecture to ensure secure operations, particularly regarding the message exchange patterns and connection lifecycle management. For MCP architecture details, see [MCP Architecture](https://modelcontextprotocol.io/docs/concepts/architecture), and for latest specifications, see [MCP Specifications](https://spec.modelcontextprotocol.io/specification/2024-11-05/).
-
-### Transport Layer Security
-
-For enterprise environments, selecting the appropriate transport mechanism is crucial. While stdio transport works efficiently for local processes, HTTP with Server-Sent Events (SSE) transport requires additional security measures. TLS should be used for all remote connections whenever possible. This is especially important when MCP servers are deployed across different network segments within corporate infrastructure.
-
-### Message Validation and Access Control
-
-The MCP architecture defines standard error codes and message types (Requests, Results, Errors, and Notifications), providing a structured framework for secure communication. Security teams should consider message validation, sanitizing inputs, checking message size limits, and verifying JSON-RPC format. Additionally, implementing resource protection through access controls, path validation, and request rate limiting helps prevent potential abuse of MCP server capabilities.
-
-### Monitoring and Compliance
-
-For enterprise compliance requirements, implementing comprehensive logging of protocol events, message flows, and errors is essential. The MCP architecture supports diagnostic capabilities including health checks, connection state monitoring, and resource usage tracking. Organizations should extend these capabilities to meet their specific compliance needs, particularly for audit trails of all MCP server interactions and resource access patterns.
-
-By leveraging the client-server design of the MCP architecture and implementing appropriate security controls at each layer, enterprises can safely integrate MCP servers into their environments while maintaining their security posture and meeting regulatory requirements.

docs/enterprise-solutions/overview.mdx

@@ -0,0 +1,95 @@
+---
+title: "Cline Enterprise"
+sidebarTitle: "Overview"
+description: "Enterprise security, governance, and observability for the coding agent 3 million developers trust"
+---
+
+Cline Enterprise brings centralized governance to the same open-source architecture that millions of developers already use. Your code stays in your environment, you use your own inference at your negotiated rates, and you get the security and observability capabilities that platform teams need for org-wide deployment.
+
+<Card title="Learn More About Enterprise" icon="building" href="https://cline.bot/enterprise">
+  Visit our website for detailed information about enterprise features, pricing, and deployment options.
+</Card>
+
+## What You Get
+
+It delivers five core capabilities that platform teams need for production deployment. Each addresses a specific requirement for scaling AI coding across your organization.
+
+### Security by Design
+
+Your code never leaves your environment. Cline processes everything locally - no uploads, no indexing, no training on your data.
+
+<CardGroup cols={2}>
+  <Card title="Client-side execution" icon="computer">
+    All processing happens within your environment
+  </Card>
+
+  <Card title="No data exfiltration" icon="shield-check">
+    Code and context never transmitted externally
+  </Card>
+
+  <Card title="No codebase indexing" icon="database">
+    Repositories are never indexed or cached
+  </Card>
+
+  <Card title="No model training" icon="ban">
+    Your code and prompts aren't used for training
+  </Card>
+</CardGroup>
+
+### Bring Your Own Inference
+
+Use your existing cloud contracts and negotiated rates. Most AI tools force you to buy inference through them with markup. Cline connects directly to your providers.
+
+Connect to any inference provider:
+- AWS Bedrock
+- Google Vertex AI
+- Azure OpenAI
+- Anthropic direct
+- OpenAI direct
+- Cerebras
+- Any OpenAI-compatible endpoint
+
+Switch models instantly as new ones release. Use Claude Sonnet 4.5 as your daily driver, GPT-5 for complex refactoring, open-source models for simple tasks. Your existing cloud credits and startup program contracts now cover AI coding. We handle the agent loop. You handle the inference. No markup, no vendor lock-in.
+
+### Governance at Scale
+
+Platform teams need central control when thousands of developers use AI. Individual API keys scattered across laptops create security risks and cost overruns.
+
+Enterprise governance provides:
+- **SSO authentication**: Corporate credentials instead of personal API keys
+- **Role-based access control**: Fine-grained permissions per team and project
+- **Model and tool controls**: Govern which models and tools each team accesses
+- **Remote configuration**: Manage settings for all developers from one dashboard
+- **Full audit logging**: Every AI interaction tracked with detailed logs
+
+Configure once, deploy everywhere. Developers work how they prefer while you maintain control.
+
+### Complete Observability
+
+Export logs to your existing observability stack. Track usage, costs, and performance across all teams.
+
+- **OpenTelemetry export**: Direct integration with Datadog, Grafana, Splunk
+- **Real-time analytics**: Track adoption, performance, and patterns
+- **Cost breakdown**: See exactly what each team spends on which models
+- **JSON output**: Build custom dashboards in your existing tools
+
+The same observability standards you require for production systems.
+
+## Deployment
+
+Cline Enterprise connects securely to your infrastructure. Deploy in cloud environments, on-premises, or air-gapped networks. Configure to work with your existing security policies and compliance requirements.
+
+Rolling out to your organization:
+1. Configure Cline Core to connect to your infrastructure
+2. Set SSO, RBAC, and governance policies
+3. Deploy to developers via your existing software distribution
+4. Monitor usage through your observability tools
+
+## Next Steps
+
+- Review [security architecture](/enterprise-solutions/security-concerns)
+- Configure [cloud provider setup](/provider-config/aws-bedrock/api-key) (AWS Bedrock, Vertex AI, Azure)
+- Set up [MCP servers](/mcp/mcp-overview) for custom tooling
+- Add [custom instructions](/features/cline-rules) for your codebase
+
+Schedule a walkthrough to see how Cline Enterprise fits your infrastructure. We'll work with your security and compliance requirements to deploy in your environment.

docs/enterprise-solutions/security-concerns.mdx

@@ -4,9 +4,7 @@ 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.
-
----
+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
 

docs/exploring-clines-tools/remote-browser-support.mdx

@@ -1,7 +1,6 @@
 ---
 title: "Remote Browser Support"
 description: "Remote browser support allows Cline to utilize a remote Chrome instance, leveraging authentication tokens and session cookies relevant to certain web development test cases."
-icon: globe-pointer
 ---
 
 The Remote Browser feature in Cline allows the AI assistant to interact with web content directly through a controlled browser instance. This enables several powerful capabilities:

docs/features/tasks/task-management.mdx

@@ -0,0 +1,105 @@
+---
+title: "Task Management"
+description: "Learn how to organize, search, and manage your task history in Cline."
+---
+
+Cline provides tools to manage your task history, helping you organize, search, and maintain your workspace efficiently. As you accumulate tasks over time, these features become essential for productivity.
+
+## Accessing Task History
+
+Learn the different ways to open and navigate to your task history in Cline. Whether you prefer clicking buttons, using keyboard shortcuts, or the command palette, there are multiple convenient methods to access your past work.
+
+You can access your task history by:
+
+1. **Clicking the "History" button** in the Cline sidebar
+2. **Using Command Palette**: Search for "Cline: Show Task History"
+3. **Keyboard shortcut** (if configured in your VSCode settings)
+
+## Task History Interface
+
+Explore the main interface where all your tasks are displayed and managed. This section covers the layout, search capabilities, sorting options, and filtering tools that help you efficiently navigate through your accumulated tasks. The task history view provides a comprehensive interface for managing all your past and current tasks.
+
+### Search and Filter
+
+The history view includes search and filtering capabilities:
+
+#### Search Bar
+- **Fuzzy search** across all task content
+- Searches through prompts, responses, and code
+- Instantly filters results as you type
+- Highlights matching text in results
+
+#### Sort Options
+Sort your tasks by:
+- **Newest** (default) - Most recent tasks first
+- **Oldest** - Earliest tasks first
+- **Most Expensive** - Highest API cost tasks
+- **Most Tokens** - Highest token usage
+- **Most Relevant** - Best matches when searching
+
+#### Favorites Filter
+- Toggle to show only starred tasks
+- Quickly access your most important work
+- Combine with search for precise filtering
+
+## Task Actions
+
+Discover the various actions you can perform on individual tasks in your history. From reopening and resuming tasks to exporting and managing them, this section explains all the available operations for task manipulation.
+
+Each task in the history provides several actions:
+
+### Primary Actions
+
+- **Open**: Click on a task to reopen it in the Cline chat
+- **Resume**: Continue an interrupted task from where it left off
+- **Export**: Save the conversation to markdown for documentation
+
+### Management Actions
+
+- **Favorite** ⭐: Click the star icon to mark important tasks
+- **Delete** 🗑️: Remove individual tasks (favorites are protected)
+- **Duplicate**: Create a new task based on an existing one
+
+## ⭐ Task Favorites
+
+Master the favorites system to mark and protect your most valuable tasks. This feature allows you to star important work, preventing accidental deletion while providing quick access to reference implementations and successful patterns.
+
+The favorites system helps you preserve and quickly access important tasks.
+
+### Using Favorites
+
+**Marking Favorites**
+- Click the star icon next to any task
+- Star fills in when favorited
+- Click again to unfavorite
+
+**Protection Features**
+- Favorited tasks are protected from accidental deletion
+- Bulk delete operations skip favorites by default
+- Can override protection with explicit confirmation
+
+**Use Cases for Favorites**
+- Reference implementations you want to keep
+- Successful problem-solving patterns
+- Tasks with reusable code snippets
+- Important project milestones
+- Learning examples for team members
+
+## Task Metrics
+
+Gain insights into your Cline usage through task metrics. This section explains how to track token usage, API costs, and other metrics to help you optimize your workflow and manage resources effectively.
+
+Understanding your task metrics helps optimize usage:
+
+### Available Metrics
+
+- **Token Usage**: Total input/output tokens consumed
+- **API Cost**: Estimated cost based on model pricing
+- **Checkpoint Count**: Number of file snapshots created
+
+### Using Metrics
+
+- **Budget Tracking**: Monitor API costs across tasks
+- **Efficiency Analysis**: Identify expensive operations
+- **Model Comparison**: Compare costs between models
+- **Optimization**: Find tasks that could be more efficient

docs/features/tasks/understanding-tasks.mdx

@@ -0,0 +1,132 @@
+---
+title: "Understanding Tasks"
+description: "Learn what tasks are in Cline, how they work, and how to create effective prompts for better results."
+---
+
+## What are Tasks?
+
+Most users interact with Cline through **tasks** - the fundamental unit of work that drives every coding session. Whether you're building a new feature, fixing a bug, refactoring code, or exploring a codebase, every interaction with Cline happens within the context of a task. A task represents a complete conversation and work session between you and the AI agent, created through **prompts** - the instructions you provide to tell Cline what you want to accomplish. Tasks serve as self-contained work sessions that capture your entire conversation with Cline, including all the code changes, command executions, and decisions made along the way.
+
+This approach ensures that your work is organized, traceable, and resumable. Each task maintains its own isolated context, allowing you to work on multiple projects simultaneously without confusion. The beauty of Cline's task system lies in its flexibility and persistence, providing a collaborative coding session where you provide the direction through prompts, and Cline executes your vision with precision.
+
+### Key Characteristics
+
+Each task in Cline:
+
+- **Has a unique identifier**: Every task gets its own ID and dedicated storage directory
+- **Contains the full conversation**: All messages, tool uses, and results are preserved
+- **Tracks resources used**: Token usage, API costs, and execution time are monitored
+- **Can be interrupted and resumed**: Tasks maintain their state across VSCode sessions
+- **Creates checkpoints**: File changes are tracked through Git-based snapshots
+- **Enables documentation**: Tasks can be exported as markdown for team documentation
+- **Provides cost management**: Resource tracking helps monitor API usage and costs
+
+These features make Cline not just a coding tool, but a comprehensive development agent that understands the full lifecycle of your work.
+
+## Creating Tasks with Prompts
+
+Tasks begin with prompts - your instructions to Cline. The quality of your results depends heavily on how you describe what you want.
+
+### Prompt Components
+
+A well-structured prompt typically includes:
+
+- **Goal**: What you want to accomplish
+- **Context**: Background information and constraints
+- **Requirements**: Specific features or functionality needed
+- **Preferences**: Technology choices, coding style, etc.
+- **Examples**: References to guide the implementation
+
+<Note>
+**Want to master the art of prompting?** 
+
+Deep dive into **Module 1: "Prompting"** in [Cline Learn](https://clinelearn.com) to become an expert at creating effective prompts. The module covers:
+- Structured prompting techniques
+- Context optimization strategies
+- Common prompting patterns
+- Advanced prompt engineering
+- Real-world examples and exercises
+
+Good prompting skills lead to faster task completion, more accurate results, fewer iterations needed, and better code quality.
+</Note>
+
+## Task Execution Modes
+
+Cline operates in two distinct modes that help structure your workflow:
+
+- **Plan Mode**: For information gathering, discussing approaches, and creating strategies without making changes
+- **Act Mode**: For actual implementation where Cline executes file modifications, runs commands, and uses tools
+
+→ **[Learn more about Plan and Act modes](/features/plan-and-act)** to understand when and how to use each mode effectively.
+
+## Task Resources
+
+Each task consumes resources that are tracked:
+
+- **Tokens**: The amount of text processed (input and output)
+- **API Costs**: Monetary cost based on the model and token usage
+- **Time**: Duration from start to completion
+- **Checkpoints**: Number of file state snapshots created
+
+## Common Task Patterns
+
+### Code Generation
+```
+Create a TypeScript function that validates email addresses using regex. 
+Include unit tests using Jest and handle edge cases like international domains.
+```
+
+### Bug Fixing
+```
+@terminal The app crashes when clicking the submit button. 
+Fix the error and ensure proper error handling is in place.
+```
+
+### Refactoring
+```
+Refactor the authentication logic in @auth.ts to use async/await 
+instead of callbacks. Maintain all existing functionality.
+```
+
+### Feature Implementation
+```
+Add a dark mode toggle to the settings page. Use the existing theme 
+context and persist the preference to localStorage.
+```
+
+## Task Resumption
+
+One of Cline's powerful features is the ability to resume interrupted tasks:
+
+### When Tasks Get Interrupted
+
+- You stop a long-running task
+- An error occurs that needs intervention
+- You need to switch to another task
+
+### Resuming a Task
+
+1. Open the task from history
+2. Cline loads the complete conversation
+3. File states are checked against checkpoints
+4. The task continues with awareness of the interruption
+5. You can provide additional context if needed
+
+## Understanding Task Context
+
+Tasks maintain context throughout their lifecycle:
+
+- **Conversation History**: All previous messages and responses
+- **File Changes**: Tracked modifications and their order
+- **Tool Results**: Output from commands and operations
+- **Checkpoint States**: Snapshots of file states at key points
+
+This context allows Cline to:
+- Understand what has been done
+- Maintain consistency in approach
+- Resume work intelligently
+- Learn from previous attempts
+
+→ **[Learn more about Context Management](/getting-started/understanding-context-management)** to understand how Cline manages and optimizes context across tasks.
+
+Understanding how tasks work is fundamental to using Cline effectively. With well-crafted prompts and an understanding of the task lifecycle, you can leverage Cline's full potential to accelerate your development workflow.

docs/getting-started/for-new-coders.mdx

@@ -1,68 +0,0 @@
----
-title: "For New Coders"
-description: "Welcome to Cline, your AI-powered coding companion! This guide will help you quickly set up your development environment and begin your coding journey with ease."
----
-
-> **Tip:** If you're completely new to coding, take your time with each step. There's no rush — Cline is here to guide you!
-
-### Getting Started
-
-Before you jump into coding, make sure you have these essentials ready:
-
-#### 1. **VS Code**
-
-A popular, free, and powerful code editor.
-
--   [<u>Download VS Code</u>](https://code.visualstudio.com/)
-
-**Recommended YouTube Tutorial:** [<u>How to Install VS Code</u>](https://www.youtube.com/watch?v=MlIzFUI1QGA)
-
-> **Pro Tip:** Install VS Code in your Applications folder (macOS) or Program Files (Windows) for easy access from your dock or start menu.
-
-#### 2. **Organize Your Projects**
-
-Create a dedicated folder named `Cline` in your Documents folder for all your coding projects:
-
--   **macOS:** `/Users/[your-username]/Documents/Cline`
--   **Windows:** `C:\Users\[your-username]\Documents\Cline`
-
-Inside your `Cline` folder, structure projects clearly:
-
--   `Documents/Cline/workout-app` _(e.g., for a fitness tracking app)_
--   `Documents/Cline/portfolio-website` _(e.g., to showcase your work)_
-
-> **Tip:** Keeping your projects organized from the start will save you time and confusion later!
-
-#### 3. **Install the Cline VS Code Extension**
-
-Enhance your coding workflow by installing the Cline extension directly within VS Code:
-
--   Get Started with Cline Extension Tutorial
-
-**Recommended YouTube Tutorial:** [<u>How To Install Extensions in VS Code</u>](https://www.youtube.com/watch?v=E7trgwZa-mk)
-
-> **Pro Tip:** After installing, reload VS Code to ensure the extension is activated properly.
-
-#### 4. **Essential Development Tools**
-
-Basic software required for coding efficiently:
-
--   Homebrew (macOS)
--   Node.js
--   Git
-
-[<u>Follow our detailed guide on Installing Essential Development Tools with step-by-step help from Cline.</u>](https://docs.cline.bot/getting-started/installing-dev-essentials#installing-dev-essentials)
-
-**Recommended YouTube Tutorials for Manual Installation:**
-
--   **For macOS:**
-    -   [<u>Install Homebrew on Mac</u>](https://www.youtube.com/watch?v=hwGNgVbqasc)
-    -   [<u>Install Git on macOS 2024</u>](https://www.youtube.com/watch?v=B4qsvQ5IqWk)
-    -   [<u>Install Node.js on Mac (M1 | M2 | M3)</u>](https://www.youtube.com/watch?v=I8H4wolRFBk)
--   **For Windows:**
-    -   [<u>Install Git on Windows 10/11 (2024)</u>](https://www.youtube.com/watch?v=yjxv1HuRQy0)
-    -   [<u>Install Node.js in Windows 10/11</u>](https://www.youtube.com/watch?v=uCgAuOYpJd0)
-
-> **Note:** If you run into permission issues during installation, try running your terminal or command prompt as an administrator.
-
-You're all set! Dive in and start coding smarter and faster with **Cline**.

docs/getting-started/installing-cline.mdx

@@ -1,54 +1,89 @@
 ---
 title: "Installing Cline"
-description: "Get Cline set up in your editor and start building projects with AI assistance."
+description: "Get Cline up and running in your favorite IDE with these simple installation steps"
 ---
 
-## Prerequisites
+<Note>
+**Ready to get started?** Installation takes less than 2 minutes! Choose your editor below and follow the simple steps.
+</Note>
 
-Before installing Cline, make sure you have the following:
+## Before You Begin
 
-### Create a Cline Account
-
-Create a Cline account for the best experience. Creating a Cline account is completely free and you can [sign up here](https://app.cline.bot/signup). A Cline account provides:
-- Access to multiple AI models including stealth models
-- Seamless setup without needing to manage API keys
-- At times, we partner with model providers to offer inferencing at no cost through your Cline account
-
-### Compatible Editor
-
-Cline works with the following IDEs:
-- **VS Code** - Microsoft's popular code editor
-- **Cursor** - AI-powered code editor based on VS Code
-- **JetBrains IDEs** - IntelliJ IDEA, PyCharm, WebStorm, DataSpell, PhpStorm, and other JetBrains products
-- **VSCodium** - Open-source version of VS Code
-- **Windsurf** - VS Code-compatible editor
-
-Make sure you have one of these editors installed before proceeding with the Cline installation.
-
-## Choose Your Editor
-
-Cline works across multiple IDEs. Select your preferred editor below for installation instructions:
+<CardGroup cols={1}>
+  <Card title="Create Your Account" icon="user-plus" href="https://app.cline.bot/signup">
+    Sign up for a **free Cline account** to get:
+    - Access to multiple AI models including stealth models
+    - Seamless setup without managing API keys
+    - Occasional free inferencing through partner providers
+  </Card>
+  
+  <Card title="Have a Compatible Editor" icon="code">
+    Cline works with:
+    - **VS Code** / **Cursor**
+    - **JetBrains IDEs** (IntelliJ, PyCharm, WebStorm, etc.)
+    - **VSCodium** / **Windsurf**
+    
+    Install one before proceeding.
+  </Card>
+</CardGroup>
 
+## Installation Instructions
 <Tabs>
   <Tab title="VS Code/Cursor" icon="code">
-    ### Installation Steps
-
-    1. **Open VS Code** and navigate to the Extensions view (`Ctrl/Cmd + Shift + X`)
-    2. **Search for "Cline"** in the Extensions marketplace
-    3. **Click Install** on the Cline extension
-
-    <Frame caption="VS Code marketplace with Cline extension ready to install">
-    	<img
-    		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(20).png"
-    		alt="VS Code marketplace showing Cline extension"
-    	/>
+    <Frame>
+      <img
+      	src="https://storage.googleapis.com/cline_public_images/vscode.png"
+      	alt="VS Code logo"
+      	style={{ width: "100px", height: "auto", display: "block" }}
+      />
     </Frame>
+    <Steps>
+      <Step title="Open Extensions">
+        Launch VS Code and open the Extensions view:
+        - Press `Ctrl/Cmd + Shift + X`, or
+        - Click the Extensions icon in the Activity Bar
+      </Step>
 
-    4. **Access Cline** after installation:
-       - Click the Cline icon in the Activity Bar, or
-       - Use Command Palette (`Ctrl/Cmd + Shift + P`) → "Cline: Open In New Tab"
+      <Step title="Search for Cline">
+        Type **"Cline"** in the Extensions marketplace search bar
+        	<Frame>
+            <img src="https://storage.googleapis.com/cline_public_images/extension-installation.png" alt="VS Code marketplace showing Cline extension" 
+            />
+          </Frame>
+      </Step>
 
-    > **Note:** If VS Code shows "Running extensions might..." dialog, click "Allow". If you don't see the Cline icon, restart VS Code.
+      <Step title="Install">
+        Click the **Install** button on the Cline extension
+        
+        <Frame caption="VS Code marketplace with Cline extension ready to install">
+        	<img
+        		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(20).png"
+        		alt="VS Code marketplace showing Cline extension"
+        	/>
+        </Frame>
+      </Step>
+
+      <Step title="Access Cline">
+        After installation completes:
+        - Click the **Cline icon** in the Activity Bar, or
+        - Open Command Palette (`Ctrl/Cmd + Shift + P`) → type **"Cline: Open In New Tab"**
+
+        <Frame caption="Cline opened in VSCode">
+        	<img
+        		src="https://storage.googleapis.com/cline_public_images/after-installation.png"
+        		alt="Cline opened in VSCode"
+        	/>
+        </Frame>
+        
+        <Warning>
+        If VS Code shows "Running extensions might..." dialog, click **Allow**. If you don't see the Cline icon, restart VS Code.
+        </Warning>
+      </Step>
+    </Steps>
+
+    <Check>
+    **Installation Complete!** You should now see the Cline interface in your editor. Time to sign in!
+    </Check>
 
     <Accordion title="Troubleshooting">
 
@@ -96,57 +131,113 @@ Cline works across multiple IDEs. Select your preferred editor below for install
     	style={{ width: "200px", height: "auto", margin: "0 auto 20px auto", display: "block" }}
     />
 
-    Cline for JetBrains works almost identically to Cline in VSCode. All the core features work properly: diff editing, using tools, logging in with different providers, MCP servers, Cline rules and workflows, and more.
+    <Note>
+    Cline for JetBrains works almost identically to VS Code, with all core features: diff editing, tools, multiple API providers, MCP servers, Cline rules/workflows, and more.
+    </Note>
 
+    ### Choose Your Installation Method
 
-    ### Installation Steps
+    <Tabs>
+      <Tab title="From IDE (Recommended)">
+        <Steps>
+          <Step title="Open Settings">
+            In your JetBrains IDE, go to **Settings**:
+            - Windows/Linux: `Ctrl+Alt+S`
+            - macOS: `Cmd+,`
+          </Step>
 
-    **Method 1: From IDE (Recommended)**
-    1. Open your JetBrains IDE
-    2. Go to **Settings** (`Ctrl+Alt+S` on Windows/Linux, `Cmd+,` on macOS)
-    3. Navigate to **Plugins** → **Marketplace**
-    4. Search for "Cline" and click **Install**
-    5. Restart your IDE
+          <Step title="Navigate to Plugins">
+            Go to **Plugins** → **Marketplace** tab
+          </Step>
 
-    <Frame>
-    	<img
-    		src="https://storage.googleapis.com/cline_public_images/docs/assets/cline-jetbrains-marketplace-search.png"
-    		alt="JetBrains marketplace showing Cline plugin search results"
-    	/>
-    </Frame>
+          <Step title="Install Cline">
+            Search for **"Cline"** and click **Install**
+            
+            <Frame>
+            	<img
+            		src="https://storage.googleapis.com/cline_public_images/jetbrains-installation.png"
+            		alt="JetBrains marketplace showing Cline plugin search results"
+            	/>
+            </Frame>
+          </Step>
 
-    **Method 2: Browser Install**
-    
-    Visit the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/28247-cline) and click **Install to IDE**.
+          <Step title="Restart IDE">
+            Restart your IDE to complete the installation
+            <Frame>
+            	<img
+            		src="https://storage.googleapis.com/cline_public_images/jetbrains-post-installation.png"
+            		alt="JetBrains marketplace showing Cline plugin search results"
+            	/>
+            </Frame>
+          </Step>
+        </Steps>
+      </Tab>
 
-    <Accordion title="Method 3: Manual Installation">
+      <Tab title="Browser Install">
+        <Steps>
+          <Step title="Visit Marketplace">
+            Go to the [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/28247-cline)
+          </Step>
 
-    1. Download the plugin from the [marketplace page](https://plugins.jetbrains.com/plugin/28247-cline)
-    2. Go to **Settings** → **Plugins**
-    3. Click the gear icon → **Install Plugin from Disk**
-    4. Select the downloaded `.zip` file
-    5. Restart your IDE
+          <Step title="Click Install to IDE">
+            Click the **Install to IDE** button
+          </Step>
 
-    </Accordion>
+          <Step title="Confirm in IDE">
+            Your IDE will open and prompt you to confirm the installation
+          </Step>
 
-    ### Using the Plugin
+          <Step title="Restart IDE">
+            Restart to complete the installation
+          </Step>
+        </Steps>
+      </Tab>
 
-    After installation, you’ll find Cline in your IDE. Look for the Cline tool window (usually on the right side) or go to View → Tool Windows → Cline.
+      <Tab title="Manual Install">
+        <Steps>
+          <Step title="Download Plugin">
+            Download from the [marketplace page](https://plugins.jetbrains.com/plugin/28247-cline)
+          </Step>
 
-    ### Key Features
+          <Step title="Open Settings">
+            Go to **Settings** → **Plugins**
+          </Step>
 
-    Cline for JetBrains includes all core features:
-    - Diff editing and file modifications
-    - Multiple API providers (Anthropic, OpenAI, local models)
-    - MCP servers and custom tools
-    - Cline rules and workflows
-    - @ mentions for files, folders, and problems
-    - Drag & drop support
+          <Step title="Install from Disk">
+            Click the gear icon → **Install Plugin from Disk**
+          </Step>
 
-    > **Note:** Terminal output appears in collapsible sections rather than streaming directly to chat.
+          <Step title="Select File & Restart">
+            Select the downloaded `.zip` file and restart your IDE
+          </Step>
+        </Steps>
+      </Tab>
+    </Tabs>
 
-    ### Key Differences from VSCode
-    The terminal integration works differently in JetBrains. Unlike VSCode where terminal output streams directly to the chat, JetBrains shows command output in a collapsible section. Commands still execute successfully - you just need to expand the Command Output section to see results.
+    <Check>
+    **Installation Complete!** Find Cline in **View** → **Tool Windows** → **Cline** (usually on the right side).
+    </Check>
+
+    ### What Works in JetBrains
+
+    <AccordionGroup>
+      <Accordion title="✅ All Core Features" defaultOpen>
+        - Diff editing and file modifications
+        - Multiple API providers (Anthropic, OpenAI, local models)
+        - MCP servers and custom tools
+        - Cline rules and workflows
+        - @ mentions for files, folders, and problems
+        - Drag & drop support
+      </Accordion>
+
+      <Accordion title="📋 Terminal Integration Difference">
+        **JetBrains shows terminal output differently than VS Code:**
+        - VS Code: Output streams directly to chat
+        - JetBrains: Output appears in collapsible "Command Output" sections
+        
+        Commands execute successfully in both—just expand the section to see results in JetBrains.
+      </Accordion>
+    </AccordionGroup>
 
     <Accordion title="Troubleshooting">
 
@@ -188,17 +279,32 @@ Cline works across multiple IDEs. Select your preferred editor below for install
   </Tab>
   
   <Tab title="VSCodium/Windsurf" icon="terminal">
-    ### Installation Steps
+    <Note>
+    These editors use the **Open VSX Registry** instead of the VS Code Marketplace, but the installation process is nearly identical.
+    </Note>
 
-    For VS Code-compatible editors using Open VSX Registry:
+    <Steps>
+      <Step title="Open Extensions">
+        Launch your editor (VSCodium, Windsurf, etc.) and open Extensions view:
+        - Press `Ctrl/Cmd + Shift + X`
+      </Step>
 
-    1. **Open your editor** (VSCodium, Windsurf, etc.)
-    2. **Navigate to Extensions view** (`Ctrl/Cmd + Shift + X`)
-    3. **Search for "Cline"** in the marketplace
-    4. **Select "Cline" by saoudrizwan** and click **Install**
-    5. **Reload** if prompted
+      <Step title="Search for Cline">
+        Type **"Cline"** in the marketplace search bar
+      </Step>
 
-    > **Note:** These editors use the Open VSX Registry instead of the VS Code Marketplace.
+      <Step title="Install by Author">
+        Select **"Cline" by saoudrizwan** and click **Install**
+      </Step>
+
+      <Step title="Reload if Needed">
+        Reload your editor if prompted to complete installation
+      </Step>
+    </Steps>
+
+    <Check>
+    **Installation Complete!** Look for the Cline icon in your Activity Bar or use the Command Palette.
+    </Check>
 
     <Accordion title="Troubleshooting">
 
@@ -240,33 +346,64 @@ Cline works across multiple IDEs. Select your preferred editor below for install
   </Tab>
 </Tabs>
 
-### Sign In to Your Cline Account
+## Next Steps: Sign In & Start Building
 
-Now that you have Cline installed, sign in to access your account:
+<Steps>
+  <Step title="Open Cline">
+    Find and open Cline in your editor:
+    - **VS Code/Cursor/VSCodium/Windsurf:** Click the Cline icon in the Activity Bar
+    - **JetBrains:** Go to **View** → **Tool Windows** → **Cline**
+  </Step>
 
-1. **Open Cline** in your editor (click the Cline icon in the Activity Bar or Tool Windows)
-2. **Click "Sign In"** - you'll see this button in the Cline interface
-3. **Complete authentication** - you'll be redirected to [app.cline.bot](https://app.cline.bot) to sign in
-4. **Return to your editor** - once signed in, you'll be automatically redirected back
+  <Step title="Sign In">
+    Click the **Sign Up** button in the Cline interface
+    
+    <Info>
+    You'll be redirected to [app.cline.bot](https://app.cline.bot) to authenticate. After signing in, you'll automatically return to your editor.
+    </Info>
+    <Frame>
+            <img src="/assets/installation/login.png" alt="Cline sign up screen" 
+            />
+          </Frame>
+  </Step>
 
+  <Step title="You're All Set!">
+    <Check>
+    **Congratulations!** You're all set to start using Cline! 
+    
+    Cline is now ready to help you build projects. 
+    </Check>
+  </Step>
+</Steps>
 
-### Your First Interaction with Cline
+## Tips for Success
 
-You're ready to start building! Copy and paste this prompt into the Cline chat window:
+<CardGroup cols={2}>
+  <Card title="Ask Questions" icon="circle-question">
+    Don't know something? Ask in Plan Mode! Cline can explain concepts, debug errors, and guide you through tasks.
+  </Card>
+  
+  <Card title="Use Screenshots" icon="image">
+    Some models understand screenshots of what you're working on or errors you encounter.
+  </Card>
+  
+  <Card title="Share Error Messages" icon="triangle-exclamation">
+    Use @problems to share error messages for quick solutions and debugging help.
+  </Card>
+  
+  <Card title="Speak Naturally" icon="comments">
+    Use your own words—no need for technical jargon. Cline will translate your ideas into code.
+  </Card>
+</CardGroup>
 
-```
-Hey Cline! Could you help me create a new project folder called "hello-world" in my Cline directory and make a simple webpage that says "Hello World" in big blue text?
-```
+## Need Help?
 
-> **Pro Tip:** Cline will help you create the project folder and set up your first webpage!
-
-### Tips for Working with Cline
-
--   **Ask Questions:** If you're unsure about something, ask Cline!
--   **Use Screenshots:** Cline can understand images — show him what you're working on.
--   **Copy and Paste Errors:** Share error messages in the chat for solutions.
--   **Speak Plainly:** Use your own words — Cline will translate them into code.
-
-### Still Struggling?
-
-Join our [Discord community](https://discord.gg/cline) and engage with our team and other Cline users directly.
+<CardGroup cols={2}>
+  <Card title="Join Our Discord" icon="discord" href="https://discord.gg/cline">
+    Connect with our team and community for support, tips, and discussions.
+  </Card>
+  
+  <Card title="Read the Docs" icon="book-open" href="/getting-started/for-new-coders">
+    Explore guides for new coders, model selection, and advanced features.
+  </Card>
+</CardGroup>

docs/getting-started/installing-dev-essentials.mdx

@@ -1,111 +0,0 @@
----
-title: "Installing Dev Essentials"
-description: >-
-    When you start coding, you'll need some essential development tools installed
-    on your computer. Cline can help you install everything you need in a safe,
-    guided way.
----
-
-### The Essential Tools
-
-Here are the core tools you'll need for development:
-
--   **Node.js & npm:** Required for JavaScript and web development
--   **Git:** For tracking changes in your code and collaborating with others
--   **Package Managers:** Tools that make it easy to install other development tools
-    -   Homebrew for macOS
-    -   Chocolatey for Windows
-    -   apt/yum for Linux
-
-> **Tip:** These tools are the foundation of your developer toolkit. Installing them properly will set you up for success!
-
-### Let Cline Install Everything
-
-Copy one of these prompts based on your operating system and paste it into **Cline**:
-
-#### For macOS
-
-```
-Hello Cline! I need help setting up my Mac for software development. Could you please help me install the essential development tools like Homebrew, Node.js, Git, and any other core utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step.
-```
-
-#### For Windows
-
-```
-Hello Cline! I need help setting up my Windows PC for software development. Could you please help me install the essential development tools like Node.js, Git, and any other core utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step.
-```
-
-#### For Linux
-
-```
-Hello Cline! I need help setting up my Linux system for software development. Could you please help me install the essential development tools like Node.js, Git, and any other core utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step.
-```
-
-> **Pro Tip:** Cline will show you each command before running it. You stay in control the entire time!
-
-### What Will Happen
-
-Cline will guide you through the following steps:
-
-1. Installing the appropriate package manager for your system
-2. Using the package manager to install Node.js and Git
-3. Showing you the exact command before it runs (you approve each step!)
-4. Verifying each installation is successful
-
-> **Note:** You might need to enter your computer's password for some installations. This is normal!
-
-### Why These Tools Are Important
-
--   **Node.js & npm:**
-    -   Build websites with frameworks like React or Next.js
-    -   Run JavaScript code
-    -   Install JavaScript packages
--   **Git:**
-    -   Save different versions of your code
-    -   Collaborate with other developers
-    -   Back up your work
--   **Package Managers:**
-    -   Quickly install and update development tools
-    -   Keep your environment organized and up to date
-
-### Notes
-
-> **Tip:** The installation process is interactive — Cline will guide you step by step!
-
--   All commands are shown to you for approval before they run.
--   If you run into any issues, Cline will help troubleshoot them.
--   You may need to enter your computer's password for certain steps.
-
-### Additional Tips for New Coders
-
-#### Understanding the Terminal
-
-The Terminal is an application where you can type commands to interact with your computer.
-
--   **macOS:** Open it by searching for "Terminal" in Spotlight.
--   **Example:**
-
-```
-$ open -a Terminal
-```
-
-#### Understanding VS Code Features
-
--   **Terminal in VS Code:** Run commands directly from within VS Code!
-    -   Go to **View > Terminal** or press \`Ctrl + \`\`.
-    -   Example:
-
-```
-$ node -v
-v16.14.0
-```
-
--   **Document View:** Where you edit your code files.
-    -   Open files from the Explorer panel on the left.
--   **Problems Section:** View errors or warnings in your code.
-    -   Access it by clicking the lightbulb icon or **View > Problems**.
-
-#### Common Features
-
--   **Command Line Interface (CLI):** A powerful tool for running commands.
--   **Permissions:** You might need to grant permissions to certain commands — this keeps your system secure.

docs/getting-started/model-selection-guide.mdx

@@ -1,79 +0,0 @@
----
-title: "Model Selection Guide"
-description: "Last updated: August 20, 2025."
----
-
-New models drop constantly, so this guide focuses on what's working well with Cline right now. We'll keep it updated as the landscape shifts.
-
-## Current Top Models
-
-| Model | Context Window | Input Price* | Output Price* | Best For |
-|-------|---------------|--------------|---------------|----------|
-| **Claude Sonnet 4.5** | 1M tokens | $3-6 | $15-22.50 | Reliable tool usage, complex codebases |
-| **Qwen3 Coder** | 256K tokens | $0.20 | $0.80 | Coding tasks, open source flexibility |
-| **Gemini 2.5 Pro** | 1M+ tokens | TBD | TBD | Large codebases, document analysis |
-| **GPT-5** | 400K tokens | $1.25 | $10 | Latest OpenAI tech, three modes |
-
-*Per million tokens
-
-## Budget Options
-
-| Model | Context Window | Input Price* | Output Price* | Notes |
-|-------|---------------|--------------|---------------|-------|
-| **DeepSeek V3** | 128K tokens | $0.14 | $0.28 | Great value for daily coding |
-| **DeepSeek R1** | 128K tokens | $0.55 | $2.19 | Budget reasoning champion |
-| **Qwen3 32B** | 128K tokens | Varies | Varies | Open source, multiple providers |
-| **Z AI GLM 4.5** | 128K tokens | TBD | TBD | MIT licensed, hybrid reasoning |
-
-*Per million tokens
-
-
-## Context Window Guide
-
-| Size | Word Count | Use Case |
-|------|------------|----------|
-| 32K tokens | ~24,000 words | Single files, small projects |
-| 128K tokens | ~96,000 words | Most coding projects |
-| 200K tokens | ~150,000 words | Large codebases |
-| 400K+ tokens | ~300,000+ words | Entire applications |
-
-**Performance note**: Most models start dropping in quality around 400-500K tokens, even if they claim higher limits.
-
-## Open Source vs Closed Source
-
-### Open Source Advantages
-- **Multiple providers** compete to host them
-- **Cheaper pricing** due to competition  
-- **Provider choice** - switch if one goes down
-- **Faster innovation** cycles
-
-### Open Source Models Available
-- **Qwen3 Coder** (Apache 2.0)
-- **Z AI GLM 4.5** (MIT)
-- **Kimi K2** (Open source)
-- **DeepSeek series** (Various licenses)
-
-## Quick Decision Matrix
-
-| If you want... | Use this |
-|----------------|----------|
-| Something that just works | Claude Sonnet 4.5 |
-| To save money | DeepSeek V3 or Qwen3 variants |
-| Huge context windows | Gemini 2.5 Pro or Claude Sonnet 4.5 |
-| Open source | Qwen3 Coder, Z AI GLM 4.5, or Kimi K2 |
-| Latest tech | GPT-5 |
-| Speed | Qwen3 Coder on Cerebras (fastest available) |
-
-## What Others Are Using
-
-Check [OpenRouter's Cline usage stats](https://openrouter.ai/apps?url=https%3A%2F%2Fcline.bot%2F) to see real usage patterns from the community.
-
-## Context Management
-
-Cline automatically handles context limits with [auto-compact](/features/auto-compact). When you approach your model's limit, Cline summarizes the conversation to keep working. You don't need to micromanage this.
-
-## The Bottom Line
-
-Start with **Claude Sonnet 4.5** if you want reliability. Experiment with **open source options** once you're comfortable to find the best fit for your workflow and budget.
-
-The landscape moves fast - these recommendations reflect what's working now, but keep an eye on new releases.

docs/getting-started/selecting-your-model.mdx

@@ -0,0 +1,64 @@
+---
+title: "Selecting Your Model"
+description: "Get started with your first AI model in Cline"
+---
+
+Cline needs an AI model to understand your requests and write code. Think of it like choosing which expert to work with - different models have different strengths and costs.
+
+## Quick Start: Choose Your Provider
+
+The easiest way to get started is with **Cline** as your provider:
+
+1. **Open Cline Settings**: Click the gear icon (⚙️) in the top-right corner of Cline's chat
+2. **Select "Cline"** from the API Provider dropdown
+3. **Choose a model** from the dropdown - we recommend starting with **Claude Sonnet 4.5** or **DeepSeek V3**
+
+<Frame>
+  <img src="https://storage.googleapis.com/cline_public_images/step2-provider.png" alt="Select Cline Provider" />
+</Frame>
+
+**That's it!** No API keys to manage, and you'll get access to multiple models.
+
+<Tip>
+**Free models available**: Cline occasionally offers free inferencing through partner providers. When available, you'll see these options in your model dropdown.
+</Tip>
+
+## Alternative: Use Another Provider
+
+If you prefer to use your own API keys, you can select from providers like:
+
+- **OpenRouter** - Great value, multiple models
+- **Anthropic** - Direct access to Claude models  
+- **OpenAI** - Access to GPT models
+- **Google Gemini** - Google's AI models
+- **Ollama** - Run models locally on your computer
+
+After selecting a provider, you'll need to:
+1. Get an API key from their website
+2. Paste it into the API Key field in Cline settings
+3. Choose your model
+
+<Note>
+Most providers require payment information before generating API keys.
+</Note>
+
+## Which Model Should I Choose?
+
+If you're just getting started, we recommend:
+
+| Your Priority | Choose This Model | Why |
+|---------------|-------------------|-----|
+| **Reliability** | Claude Sonnet 4.5 | Most reliable for coding tasks |
+| **Value** | DeepSeek V3 | Great performance at low cost |
+| **Speed** | Qwen3 Coder | Fast responses |
+| **Privacy** | Any Ollama model | Runs on your computer |
+
+You can switch models anytime without losing your conversation.
+
+## Next Steps
+
+With your model configured, you're all set! In the next section, we'll walk you through completing your first task with Cline and show you how to interact with the AI to write, debug, and refactor code.
+
+<Card title="Deep Dive: Model Selection Guide" icon="graduation-cap" href="/core-features/model-selection-guide">
+  Want to understand model pricing, context windows, and advanced selection strategies? Check out our comprehensive Model Selection Guide.
+</Card>

docs/getting-started/task-management.mdx

@@ -1,67 +0,0 @@
----
-title: "Task Management in Cline"
-description: "Learn how to effectively manage your task history, use favorites, and organize your work in Cline."
----
-
-# Task Management
-
-As you use Cline, you'll accumulate many tasks over time. The task management system helps you organize, filter, search, and clean up your task history to keep your workspace efficient.
-
-## Accessing Task History
-
-You can access your task history by:
-
-1. Clicking on the "History" button in the Cline sidebar
-2. Using the command palette to search for "Cline: Show Task History"
-
-## Task History Features
-
-The task history view provides several powerful features:
-
-### Searching and Filtering
-
--   **Search Bar**: Use the fuzzy search at the top to quickly find tasks by content
--   **Sort Options**: Sort tasks by:
-    -   Newest (default)
-    -   Oldest
-    -   Most Expensive (highest API cost)
-    -   Most Tokens (highest token usage)
-    -   Most Relevant (when searching)
--   **Favorites Filter**: Toggle to show only favorited tasks
-
-### Task Actions
-
-Each task in the history view has several actions available:
-
--   **Open**: Click on a task to reopen it in the Cline chat
--   **Favorite**: Click the star icon to mark a task as a favorite
--   **Delete**: Remove individual tasks (favorites are protected from deletion)
--   **Export**: Export a task's conversation to markdown
-
-## ⭐ Task Favorites
-
-The favorites feature allows you to mark important tasks that you want to preserve and find quickly.
-
-### How Favorites Work
-
--   **Marking Favorites**: Click the star icon next to any task to toggle its favorite status
--   **Protection**: Favorited tasks are protected from individual and bulk deletion operations (can be overridden)
--   **Filtering**: Use the favorites filter to quickly access your important tasks
-
-## Batch Operations
-
-The task history view supports several batch operations:
-
--   **Select Multiple**: Use the checkboxes to select multiple tasks
--   **Select All/None**: Quickly select or deselect all tasks
--   **Delete Selected**: Remove all selected tasks
--   **Delete All**: Remove all tasks from history (favorites are preserved unless you choose to include them)
-
-## Best Practices
-
-1. **Favorite Important Tasks**: Mark reference tasks or frequently accessed conversations as favorites
-2. **Regular Cleanup**: Periodically remove old or unused tasks to improve performance
-3. **Use Search**: Leverage the fuzzy search to quickly find specific conversations
-4. **Export Valuable Tasks**: Export important tasks to markdown for external reference
-
-Task management helps you maintain an organized workflow when using Cline, allowing you to quickly find past conversations, preserve important work, and keep your history clean and efficient.

docs/getting-started/understanding-context-management.mdx

@@ -1,196 +0,0 @@
----
-title: "Context Management"
-description: "Context is key to getting the most out of Cline"
----
-
-> **Quick Reference**
->
-> -   Context = The information Cline knows about your project
-> -   Context Window = How much information Cline can hold at once
-> -   Use context files to maintain project knowledge
-> -   Reset when the context window gets full
-
-## Understanding Context & Context Windows
-
-<Frame caption="In a world of infinite context, the context window is what Cline currently has available">
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2).png"
-		alt="In a world of infinite context, the context window is what Cline currently has available"
-	/>
-</Frame>
-
-Think of working with Cline like collaborating with a thorough, proactive teammate:
-
-### How Context is Built
-
-Cline actively builds context in two ways:
-
-1. **Automatic Context Gathering (i.e. Cline-driven)**
-    - Proactively reads related files
-    - Explores project structure
-    - Analyzes patterns and relationships
-    - Maps dependencies and imports
-    - Asks clarifying questions
-2. **User-Guided Context**
-    - Share specific files
-    - Provide documentation
-    - Answer Cline's questions
-    - Guide focus areas
-    - Share design thoughts and requirements
-
-**Key Point**: Cline isn't passive - it actively seeks to understand your project. You can either let it explore or guide its focus, especially in [Plan Mode](/features/plan-and-act).
-
-### Context & Context Windows
-
-Think of context like a whiteboard you and Cline share:
-
--   **Context** is all the information available:
-    -   What Cline has discovered
-    -   What you've shared
-    -   Your conversation history
-    -   Project requirements
-    -   Previous decisions
--   **Context Window** is the size of the whiteboard itself:
-    -   Measured in tokens (1 token ≈ 3/4 of an English word)
-    -   Each model has a fixed size:
-        -   Claude Sonnet 4.5: 1,000,000 tokens
-        -   Qwen3 Coder: 256,000 tokens
-        -   Gemini 2.5 Pro: 1,000,000+ tokens
-        -   GPT-5: 400,000 tokens
-    -   When the whiteboard is full, Cline automatically summarizes the conversation to free up space
-
-**Important**: Having a large context window doesn't mean you should fill it completely. Models start degrading around 400-500K tokens even if they claim higher limits. Just like a cluttered whiteboard, too much information can make it harder to focus on what's important.
-
-## Understanding the Context Window Progress Bar
-
-Cline provides a visual way to monitor your context window usage through a progress bar:
-
-<Frame caption="Visual representation of the context window usage">
-	<img
-		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(1)%20(1).png"
-		alt="Context window progress bar"
-	/>
-</Frame>
-
-### Reading the Bar
-
--   ↑ shows input tokens (what you've sent to the LLM)
--   ↓ shows output tokens (what the LLM has generated)
--   The progress bar visualizes how much of your context window you've used
--   The total shows your model's maximum capacity (e.g., 1M for Claude Sonnet 4.5)
-
-### When to Watch the Bar
-
--   During long coding sessions
--   When working with multiple files
--   Before starting complex tasks
--   When Cline seems to lose context
-
-**Tip**: With [Auto Compact](/features/auto-compact), Cline can now handle long conversations automatically. When combined with [Focus Chain](/features/focus-chain), you can work on complex projects that span multiple context windows without losing progress.
-
-## Automatic Context Management
-
-Cline includes intelligent features to manage context automatically:
-
-### Default Settings You Should Keep On
-
-**Focus Chain** - Enabled by default in v3.25. Cline generates a todo list at task start and keeps it in context so the thread doesn't drift. You can edit the markdown to add or reorder steps and Cline will adapt. [Learn more about Focus Chain](/features/focus-chain).
-
-**Auto Compact** - Always on. As the context window reaches its limit, Cline creates a comprehensive summary, replaces the bloated history, and continues where it left off. Decisions, code changes, and state are preserved. [Learn more about Auto Compact](/features/auto-compact).
-
-## Advanced Context Tools
-
-When you need more control over context management:
-
-### Deep Planning (`/deep-planning`)
-For substantial features, refactors, or integrations. Cline investigates your codebase, asks targeted questions, then writes `implementation_plan.md`. It creates a fresh task with distilled, high-value context. [Learn more about Deep Planning](/features/slash-commands/deep-planning).
-
-### New Task (`/newtask`)
-At natural transition points, packages only what matters into a fresh task. Clean slate for implementation after research, or crisp handoff between teammates. [Learn more about New Task](/features/slash-commands/new-task).
-
-### Smol (`/smol`)
-Compress the conversation in place to keep momentum. Ideal during debugging or exploratory work when you don't want to break flow. [Learn more about Smol](/features/slash-commands/smol).
-
-### Memory Bank + .clinerules
-For non-trivial projects. The Memory Bank captures project knowledge as Markdown in your repo. `.clinerules` are version-controlled instructions that align Cline's behavior with your team. [Learn more about Memory Bank](/prompting/cline-memory-bank) and [Cline Rules](/features/cline-rules).
-
-## Working with Context Files
-
-Context files help maintain understanding across sessions. They serve as documentation specifically designed to help AI assistants understand your project.
-
-#### Approaches to Context Files
-
-1. **Evergreen Project Context (Memory Bank)**
-    - Living documentation that evolves with your project
-    - Updated as architecture and patterns emerge
-    - Example: The Memory Bank pattern maintains files like `techContext.md` and `systemPatterns.md`
-    - Useful for long-running projects and teams
-2. **Task-Specific Context**
-
-    - Created for specific implementation tasks
-    - Document requirements, constraints, and decisions
-    - Example:
-
-        ```markdown
-        # auth-system-implementation.md
-
-        ## Requirements
-
-        -   OAuth2 implementation
-        -   Support for Google and GitHub
-        -   Rate limiting on auth endpoints
-
-        ## Technical Decisions
-
-        -   Using Passport.js for provider integration
-        -   JWT for session management
-        -   Redis for rate limiting
-        ```
-
-3. **Knowledge Transfer Docs**
-    - Switch to plan mode and ask Cline to document everything you've accomplished so far, along with the remaining steps, in a markdown file.
-    - Copy the contents of the markdown file.
-    - Start a new task using that content as context.
-
-#### Using Context Files Effectively
-
-1. **Structure and Format**
-    - Use clear, consistent organization
-    - Include relevant examples
-    - Link related concepts
-    - Keep information focused
-2. **Maintenance**
-    - Update after significant changes
-    - Version control your context files
-    - Remove outdated information
-    - Document key decisions
-
-## Practical Tips
-
-1. **Starting New Projects**
-    - Let Cline explore the codebase
-    - Answer its questions about structure and patterns
-    - Consider setting up basic context files
-    - Document key design decisions
-2. **Ongoing Development**
-    - Update context files with significant changes
-    - Share relevant documentation
-    - Use Plan mode for complex discussions
-    - Start fresh sessions when needed
-3. **Team Projects**
-    - Share common context files (consider using [.clinerules](/features/cline-rules) files in project roots)
-    - Document architectural decisions
-    - Maintain consistent patterns
-    - Keep documentation current
-
-## Bonus Context Tips
-
-- You can @ links and have the webpage's context added to Cline (docs, blogs, etc.)
-- Utilize MCP servers to pull in context from your external knowledge bases
-- Screenshots can be used as context for models that support image inputs
-
-## The Bottom Line
-
-Cline already does a lot of context work for you - [Focus Chain](/features/focus-chain), [Auto Compact](/features/auto-compact), and the planning flow are designed to keep the thread intact across long horizons. The goal is to help Cline maintain consistent understanding of your project across sessions.
-
-Remember: The goal is to keep only what matters in view, at every step.

docs/getting-started/what-is-cline.mdx

@@ -1,72 +0,0 @@
----
-title: "What is Cline?"
-description: "An introduction to Cline, your AI-powered development assistant for modern IDEs."
----
-
-Cline is an open source AI coding agent that brings frontier AI models directly to your IDE. Unlike autocomplete tools, Cline is a true coding agent that can understand entire codebases, plan complex changes, and execute multi-step tasks.
-
-## Open Source AI Coding, Uncompromised
-
-Cline gives you direct, transparent access to frontier AI with no limits, no surprises, and no model ecosystem lock-in. See every decision. Choose any model. Control your costs.
-
-### Complete Transparency
-
-Watch in real-time as Cline reads files, considers approaches, and proposes changes. Every decision is visible, every edit reviewable before it's made. This isn't just "explainable AI" - it's complete transparency.
-
-### Your Models, Your Control
-
-Use Claude for complex reasoning, Gemini for massive contexts, or Qwen3 Coder for efficiency. Switch instantly as new models launch. Your API keys, your choice. No gatekeeping innovation.
-
-### Built for Real Engineering
-
-Cline can:
-- **Read and write files** across your entire codebase
-- **Execute terminal commands** and debug errors
-- **Plan complex features** before writing code
-- **Connect to external systems** through MCP servers
-- **Understand large codebases** with intelligent context management
-
-## Plan & Act Mode
-
-Cline explores your codebase and works with you to create comprehensive plans before writing a single line of code, ensuring it understands the full context of your project.
-
-**Plan Mode** for complex tasks - Cline explores, asks questions, and creates detailed implementation plans.
-
-**Act Mode** for execution - Cline implements the plan with full transparency and control.
-
-## Zero Trust by Design
-
-Your code never touches our servers. Cline runs entirely client-side with your API keys, making it the only option for enterprises with strict security requirements.
-
-**Open source** means your security team can review every line. See exactly how Cline works, what it sends to AI providers, and how decisions are made.
-
-## Key Features
-
-### Focus Chain
-Automatic todo list management with real-time progress tracking throughout your tasks. Keeps Cline on track across long projects.
-
-### Auto Compact
-When conversations get long, Cline automatically summarizes to preserve context while freeing up space to continue working.
-
-### Deep Planning
-For complex features, Cline investigates your codebase, asks clarifying questions, and creates comprehensive implementation plans.
-
-### MCP Integration
-Connect to databases, APIs, and documentation through the Model Context Protocol. Cline becomes your bridge to any external system.
-
-### .clinerules
-Define project-specific instructions that Cline follows including coding standards, architecture patterns, or team conventions.
-
-## Why Developers Choose Cline
-
-**100% Open Source** - Every line of code on GitHub. 48k+ stars from developers who've read it, improved it, and trust it with their work.
-
-**No Inference Games** - We don't profit from AI usage. While others limit context or route to cheaper models, we give you unrestricted access to any model's full capabilities.
-
-**Future-Proof by Design** - New model released? Use it immediately. Cline works with any AI provider, any model.
-
-**True Visibility** - See every file read, every decision considered, every token used.
-
-## Getting Started
-
-Ready to experience AI coding without limits? [Install Cline](/getting-started/installing-cline) for your preferred IDE and start with our [Model Selection Guide](/getting-started/model-selection-guide) to choose the right AI model for your needs.

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

@@ -0,0 +1,115 @@
+---
+title: "Build Your First Project"
+description: "Build your first project with Cline in under a minute."
+---
+
+Ready to see Cline in action? This hands-on tutorial will walk you through building a website in under a minute. You'll experience how Cline understands your requirements, creates files, and iterates on your feedback—all through natural conversation.
+
+By the end of this guide, you'll have built a working website and learned the fundamentals of working with Cline.
+
+## Prerequisites
+
+- **Cline installed** in your editor ([Install Guide](/getting-started/installing-cline))
+- **AI model selected** ([Model Setup](/getting-started/selecting-your-model))
+- **Any folder open** in your editor (or create a new empty folder)
+
+## Step 1: Open Cline
+
+Click the Cline icon in your editor's sidebar (left side). The chat panel will open.
+
+<Info>
+**Quick Tip:** You can also use `Cmd+Shift+P` (Mac) or `Ctrl+Shift+P` (Windows/Linux) and search for "Cline: Open In New Tab"
+</Info>
+
+## Step 2: Give Cline a Task
+
+Copy and paste this prompt into Cline's chat:
+
+```
+Create a simple website in a single HTML file. It should have:
+- A welcome message saying "Hello from Cline!"
+- A colorful gradient background
+- A button that cycles through different color themes when clicked
+- Modern, clean design
+- All CSS and JavaScript should be included in the same HTML file
+```
+
+<Frame>
+  <img src="/assets/installation/chat-prompt.png" alt="Cline Chat Prompt"/>
+</Frame>
+
+Press Enter and watch Cline work!
+
+## Step 3: What Happens Next
+
+Cline will:
+
+1. **Create a single file:**
+   - `index.html` - A complete webpage with embedded CSS and JavaScript
+
+2. **Ask for approval** (unless you've enabled auto-approve)
+   - Click "Approve" to let Cline create the file
+   - You can review what it plans to do first
+
+3. **Complete the task** within seconds
+
+## Step 4: View Your Website
+
+Once Cline finishes:
+
+1. **Find `index.html`** in your editor's file explorer
+2. **Right-click it** and select:
+   - "Reveal in Finder/Explorer" then double-click to open in your browser
+3. **Click the button** to see the color themes change!
+
+## Try Making Changes
+
+In the same chat, try asking:
+
+```
+Add a counter that shows how many times the button has been clicked
+```
+
+or
+
+```
+Make the welcome message fade in when the page loads
+```
+
+Cline understands the context from your previous conversation and will update the file accordingly.
+
+<Tip>
+**You now know how to:**
+- Give Cline a task with a clear prompt
+- Review and approve Cline's actions
+- Build a complete project in seconds
+- Iterate and improve on existing work
+</Tip>
+
+## Next Steps
+
+Now that you've experienced Cline's capabilities, explore more:
+
+<CardGroup cols={2}>
+<Card title="@ Mentions" href="/features/at-mentions/overview" icon="at">
+Reference specific files, folders, and URLs in your prompts
+</Card>
+
+<Card title="Plan & Act Modes" href="/features/plan-and-act" icon="diagram-project">
+Master planning vs. execution for complex tasks
+</Card>
+
+<Card title="Cline Rules" href="/features/cline-rules" icon="list-check">
+Set project-specific guidelines for consistent results
+</Card>
+
+<Card title="Prompting Guide" href="/prompting/prompt-engineering-guide" icon="wand-magic-sparkles">
+Learn to write prompts that get the best results
+</Card>
+</CardGroup>
+
+## Need Help?
+
+- **Stuck?** Try starting fresh with `/new` in the chat
+- **Found a bug?** Use `/reportbug` to help us improve
+- **Have questions?** Join our [Discord community](https://discord.gg/cline)

docs/introduction/overview.mdx

@@ -0,0 +1,147 @@
+---
+title: "Overview"
+description: "An introduction to Cline, your AI-powered coding agent for modern development."
+---
+
+## Open Source AI Coding, Uncompromised
+
+Cline gives you direct, transparent access to frontier AI with no limits, no surprises, and no model ecosystem lock-in. See every decision. Choose any model. Control your costs.
+
+<CardGroup cols={1}>
+  <Card title="Complete Transparency" icon="eye">
+    Watch in real-time as Cline reads files, considers approaches, and proposes changes. Every decision is visible, every edit reviewable before it's made.
+  </Card>
+
+  <Card title="Choose Your Inference" icon="sliders">
+    Use Claude for complex reasoning, Gemini for massive contexts, or Qwen3 Coder for efficiency. Switch instantly as new models launch. Bring your API keys, your choice.
+  </Card>
+
+  <Card title="Zero Trust by Design" icon="lock">
+    Your code never touches our servers. Cline runs entirely client-side with your API keys. Open source means your security team can review every line.
+  </Card>
+</CardGroup>
+
+## Built for Real Engineering
+
+<CardGroup cols={3}>
+  <Card title="Read & Write Files" icon="file-code">
+    Work across your entire codebase with intelligent file operations
+  </Card>
+
+  <Card title="Execute Commands" icon="terminal">
+    Run terminal commands and debug errors in real-time
+  </Card>
+
+  <Card title="Plan Complex Features" icon="brain">
+    Explore and plan before writing a single line of code
+  </Card>
+
+  <Card title="Connect External Systems" icon="plug">
+    Integrate with databases, APIs, and documentation through MCP servers
+  </Card>
+
+  <Card title="Understand Large Codebases" icon="magnifying-glass">
+    Intelligent context management for massive projects
+  </Card>
+
+  <Card title="Multi-Step Tasks" icon="list-check">
+    Execute complex workflows from start to finish
+  </Card>
+</CardGroup>
+
+## Plan & Act Mode
+
+Cline explores your codebase and works with you to create comprehensive plans before writing code, ensuring it understands the full context of your project.
+
+<Tabs>
+  <Tab title="Plan Mode" icon="lightbulb">
+    For complex tasks, Cline explores your codebase, asks clarifying questions, and creates detailed implementation plans before making changes.
+
+    - Information gathering and context building
+    - Asking clarifying questions
+    - Creating detailed execution plans
+    - Discussing approaches with you
+  </Tab>
+
+  <Tab title="Act Mode" icon="play">
+    Once you approve the plan, Cline implements the solution with full transparency and control.
+
+    - Executing planned actions
+    - Using tools to modify files and run commands
+    - Implementing the solution
+    - Providing results and completion feedback
+  </Tab>
+</Tabs>
+
+
+## Key Features
+
+<AccordionGroup>
+  <Accordion title="Intelligent Planning & Execution" icon="brain">
+    <div style={{ display: 'grid', gap: '1rem', marginTop: '0.5rem' }}>
+      <div>
+        <strong><a href="/features/plan-and-act">Plan & Act Mode</a></strong> • Plan complex features before writing code, then execute with full transparency
+      </div>
+      <div>
+        <strong><a href="/features/focus-chain">Focus Chain</a></strong> • Automatic todo list management with real-time progress tracking
+      </div>
+    </div>
+  </Accordion>
+
+  <Accordion title="Workflow Optimization" icon="bolt">
+    <div style={{ display: 'grid', gap: '1rem', marginTop: '0.5rem' }}>
+      <div>
+        <strong><a href="/features/auto-approve">Auto Approve</a></strong> • Streamline your workflow by automatically approving trusted operations
+      </div>
+      <div>
+        <strong><a href="/features/auto-compact">Auto Compact</a></strong> • Automatic conversation summarization to preserve context while freeing space
+      </div>
+      <div>
+        <strong><a href="/features/dictation">Dictation</a></strong> • Speak naturally to Cline for rapid planning and complex requirements
+      </div>
+    </div>
+  </Accordion>
+
+  <Accordion title="Extensions & Integrations" icon="plug">
+    <div style={{ display: 'grid', gap: '1rem', marginTop: '0.5rem' }}>
+      <div>
+        <strong><a href="/mcp/mcp-overview">MCP Integration</a></strong> • Connect to databases, APIs, and documentation through the Model Context Protocol
+      </div>
+      <div>
+        <strong><a href="/exploring-clines-tools/remote-browser-support">Remote Browser</a></strong> • Test and interact with web applications through browser automation
+      </div>
+    </div>
+  </Accordion>
+
+  <Accordion title="Customization & Control" icon="gear">
+    <div style={{ display: 'grid', gap: '1rem', marginTop: '0.5rem' }}>
+      <div>
+        <strong><a href="/features/cline-rules">.clinerules</a></strong> • Define project-specific instructions including coding standards and patterns
+      </div>
+      <div>
+        <strong><a href="/features/checkpoints">Checkpoints</a></strong> • Save and restore project states with Git-based checkpoints
+      </div>
+    </div>
+  </Accordion>
+</AccordionGroup>
+
+## Why Developers Choose Cline
+
+<CardGroup cols={2}>
+  <Card title="100% Open Source" icon="github">
+    Every line of code on GitHub. **50k+ stars** from developers who've used it, improved it, and trust it with their work.
+  </Card>
+
+  <Card title="No Inference Games" icon="ban">
+    We don't profit from AI usage. While others limit context or route to cheaper models, we give you unrestricted access to any model's full capabilities.
+  </Card>
+
+  <Card title="Future-Proof by Design" icon="rocket">
+    New model released? Use it immediately. Cline works with multiple AI providers.
+  </Card>
+
+  <Card title="True Visibility" icon="eye">
+    See every file read, every decision considered, every token used. No black box, no surprises.
+  </Card>
+</CardGroup>
+

docs/introduction/welcome.mdx

@@ -0,0 +1,54 @@
+---
+title: "Welcome to Cline"
+description: "Your guide to AI-powered development with complete transparency and control"
+---
+
+Cline is an open source AI coding agent that brings frontier AI models directly to your IDE. Unlike autocomplete tools, Cline is a true coding agent that can understand entire codebases, plan complex changes, and execute multi-step tasks.
+
+<Frame>
+  <video 
+    src="https://storage.googleapis.com/cline_public_images/cline-in-action.mp4" 
+    alt="Cline in action"
+    autoPlay
+    muted
+  />
+</Frame>
+
+## Navigate the Docs
+
+<CardGroup cols={2}>
+  <Card title="New to Cline" icon="rocket" href="/getting-started/installing-cline">
+    Start your journey with Cline - installation, setup, and first steps
+  </Card>
+
+  <Card title="Configuration" icon="sliders" href="/core-features/model-selection-guide">
+    Set up your AI models and providers 
+  </Card>
+
+  <Card title="Best Practices" icon="wrench" href="/prompting/understanding-context-management">
+    Master Cline's powerful features and optimize your workflow
+  </Card>
+
+  <Card title="Enterprise" icon="building" href="/enterprise-solutions/security-concerns">
+    Deploy Cline in your organization with confidence
+  </Card>
+</CardGroup>
+
+
+## Community & Support
+
+Join thousands of developers using Cline to build better software faster.
+
+<CardGroup cols={3}>
+  <Card title="Discord" icon="discord" href="https://discord.gg/cline">
+    Chat with the community and get help
+  </Card>
+
+  <Card title="GitHub" icon="github" href="https://github.com/cline/cline">
+    Contribute to the open source project
+  </Card>
+
+  <Card title="Report a Bug" icon="bug" href="https://github.com/cline/cline/issues">
+    Help us improve by reporting problems
+  </Card>
+</CardGroup>

docs/model-config/context-windows.mdx

@@ -0,0 +1,159 @@
+---
+title: "Context Window Guide"
+description: "Understanding and managing AI model context windows"
+---
+
+## What is a Context Window?
+
+A context window is the maximum amount of text an AI model can process at once. Think of it as the model's "working memory" - it determines how much of your conversation and code the model can consider when generating responses.
+
+<Note>
+**Key Point**: Larger context windows allow the model to understand more of your codebase at once, but may increase costs and response times.
+</Note>
+
+## Context Window Sizes
+
+### Quick Reference
+
+| Size | Tokens | Approximate Words | Use Case |
+|------|--------|------------------|----------|
+| **Small** | 8K-32K | 6,000-24,000 | Single files, quick fixes |
+| **Medium** | 128K | ~96,000 | Most coding projects |
+| **Large** | 200K | ~150,000 | Complex codebases |
+| **Extra Large** | 400K+ | ~300,000+ | Entire applications |
+| **Massive** | 1M+ | ~750,000+ | Multi-project analysis |
+
+### Model Context Windows
+
+| Model | Context Window | Effective Window* | Notes |
+|-------|---------------|------------------|-------|
+| **Claude Sonnet 4.5** | 1M tokens | ~500K tokens | Best quality at high context |
+| **GPT-5** | 400K tokens | ~300K tokens | Three modes affect performance |
+| **Gemini 2.5 Pro** | 1M+ tokens | ~600K tokens | Excellent for documents |
+| **DeepSeek V3** | 128K tokens | ~100K tokens | Optimal for most tasks |
+| **Qwen3 Coder** | 256K tokens | ~200K tokens | Good balance |
+
+*Effective window is where model maintains high quality
+
+## Managing Context Efficiently
+
+### What Counts Toward Context
+
+1. **Your current conversation** - All messages in the chat
+2. **File contents** - Any files you've shared or Cline has read
+3. **Tool outputs** - Results from executed commands
+4. **System prompts** - Cline's instructions (minimal impact)
+
+### Optimization Strategies
+
+#### 1. Start Fresh for New Features
+```
+/new - Creates a new task with clean context
+```
+Benefits:
+- Maximum context available
+- No irrelevant history
+- Better model focus
+
+#### 2. Use @ Mentions Strategically
+Instead of including entire files:
+- `@filename.ts` - Include only when needed
+- Use search instead of reading large files
+- Reference specific functions rather than whole files
+
+#### 3. Enable Auto-compact
+Cline can automatically summarize long conversations:
+- Settings → Features → Auto-compact
+- Preserves important context
+- Reduces token usage
+
+## Context Window Warnings
+
+### Signs You're Hitting Limits
+
+| Warning Sign | What It Means | Solution |
+|-------------|---------------|----------|
+| **"Context window exceeded"** | Hard limit reached | Start new task or enable auto-compact |
+| **Slower responses** | Model struggling with context | Reduce included files |
+| **Repetitive suggestions** | Context fragmentation | Summarize and start fresh |
+| **Missing recent changes** | Context overflow | Use checkpoints to track changes |
+
+### Best Practices by Project Size
+
+#### Small Projects (< 50 files)
+- Any model works well
+- Include relevant files freely
+- No special optimization needed
+
+#### Medium Projects (50-500 files)
+- Use 128K+ context models
+- Include only working set of files
+- Clear context between features
+
+#### Large Projects (500+ files)
+- Use 200K+ context models
+- Focus on specific modules
+- Use search instead of reading many files
+- Break work into smaller tasks
+
+## Advanced Context Management
+
+### Plan/Act Mode Optimization
+
+Leverage Plan/Act mode for better context usage:
+- **Plan Mode**: Use smaller context for discussion
+- **Act Mode**: Include necessary files for implementation
+
+Configuration:
+```
+Plan Mode: DeepSeek V3 (128K) - Lower cost planning
+Act Mode: Claude Sonnet (1M) - Maximum context for coding
+```
+
+### Context Pruning Strategies
+
+1. **Temporal Pruning**: Remove old conversation parts
+2. **Semantic Pruning**: Keep only relevant code sections
+3. **Hierarchical Pruning**: Maintain high-level structure, prune details
+
+### Token Counting Tips
+
+#### Rough Estimates
+- **1 token ≈ 0.75 words**
+- **1 token ≈ 4 characters**
+- **100 lines of code ≈ 500-1000 tokens**
+
+#### File Size Guidelines
+| File Type | Tokens per KB |
+|-----------|---------------|
+| **Code** | ~250-400 |
+| **JSON** | ~300-500 |
+| **Markdown** | ~200-300 |
+| **Plain text** | ~200-250 |
+
+## Context Window FAQ
+
+### Q: Why do responses get worse with very long conversations?
+**A:** Models can lose focus with too much context. The "effective window" is typically 50-70% of the advertised limit.
+
+### Q: Should I use the largest context window available?
+**A:** Not always. Larger contexts increase cost and can reduce response quality. Match the context to your task size.
+
+### Q: How can I tell how much context I'm using?
+**A:** Cline shows token usage in the interface. Watch for the context meter approaching limits.
+
+### Q: What happens when I exceed the context limit?
+**A:** Cline will either:
+- Automatically compact the conversation (if enabled)
+- Show an error and suggest starting a new task
+- Truncate older messages (with warning)
+
+## Recommendations by Use Case
+
+| Use Case | Recommended Context | Model Suggestion |
+|----------|-------------------|------------------|
+| **Quick fixes** | 32K-128K | DeepSeek V3 |
+| **Feature development** | 128K-200K | Qwen3 Coder |
+| **Large refactoring** | 400K+ | Claude Sonnet 4.5 |
+| **Code review** | 200K-400K | GPT-5 |
+| **Documentation** | 128K | Any budget model |

docs/model-config/model-comparison.mdx

@@ -0,0 +1,93 @@
+---
+title: "Model Comparison & Pricing"
+description: "Compare AI models by performance, features, and pricing"
+---
+
+## Model Comparison Table
+
+### Premium Models
+
+| Model | Provider | Context Window | Input Price* | Output Price* | Best For |
+|-------|----------|---------------|--------------|---------------|----------|
+| **Claude Sonnet 4.5** | Anthropic | 1M tokens | $3-6 | $15-22.50 | Reliable tool usage, complex codebases |
+| **GPT-5** | OpenAI | 400K tokens | $1.25 | $10 | Latest OpenAI tech, three modes |
+| **Gemini 2.5 Pro** | Google | 1M+ tokens | TBD | TBD | Large codebases, document analysis |
+| **Qwen3 Coder** | Multiple | 256K tokens | $0.20 | $0.80 | Coding tasks, open source flexibility |
+
+*Per million tokens
+
+### Budget Models
+
+| Model | Provider | Context Window | Input Price* | Output Price* | Notes |
+|-------|----------|---------------|--------------|---------------|-------|
+| **DeepSeek V3** | DeepSeek | 128K tokens | $0.14 | $0.28 | Great value for daily coding |
+| **DeepSeek R1** | DeepSeek | 128K tokens | $0.55 | $2.19 | Budget reasoning champion |
+| **Qwen3 32B** | Multiple | 128K tokens | Varies | Varies | Open source, multiple providers |
+| **Z AI GLM 4.5** | Z AI | 128K tokens | TBD | TBD | MIT licensed, hybrid reasoning |
+
+*Per million tokens
+
+## Performance Comparison
+
+### Speed vs Quality Trade-offs
+
+| Priority | Recommended Model | Why |
+|----------|------------------|-----|
+| **Speed** | Qwen3 Coder on Cerebras | Fastest inference available |
+| **Quality** | Claude Sonnet 4.5 | Most reliable for complex tasks |
+| **Balance** | DeepSeek V3 | Good quality at low cost |
+
+### Tool Reliability
+
+Models ranked by tool usage reliability:
+1. **Claude Sonnet 4.5** - Most reliable tool execution
+2. **GPT-5** - Excellent but occasional formatting issues
+3. **Gemini 2.5 Pro** - Good for standard tools
+4. **DeepSeek V3** - Reliable for basic tools
+5. **Qwen3 variants** - May need retry for complex tools
+
+## Cost Calculator
+
+### Typical Task Costs
+
+| Task Type | Token Usage (avg) | Claude Sonnet | DeepSeek V3 | Difference |
+|-----------|------------------|---------------|-------------|------------|
+| **Simple Bug Fix** | 5K tokens | $0.05 | $0.001 | 50x cheaper |
+| **Feature Implementation** | 50K tokens | $0.50 | $0.01 | 50x cheaper |
+| **Large Refactoring** | 200K tokens | $2.00 | $0.04 | 50x cheaper |
+
+### Monthly Budget Estimates
+
+| Budget | Claude Usage | DeepSeek Usage | Mixed Strategy |
+|--------|-------------|----------------|----------------|
+| **$10/month** | ~20 features | ~1000 features | Plan: DeepSeek, Act: Claude |
+| **$50/month** | ~100 features | ~5000 features | Critical: Claude, Rest: DeepSeek |
+| **$100/month** | ~200 features | ~10000 features | Complex: Claude, Simple: DeepSeek |
+
+## Provider Comparison
+
+### Provider Features
+
+| Provider | Models Available | Billing | API Stability | Support |
+|----------|-----------------|---------|---------------|---------|
+| **Cline** | Multiple | Credit-based | High | In-app |
+| **Anthropic** | Claude only | Usage-based | High | Email |
+| **OpenRouter** | 100+ models | Usage-based | High | Discord |
+| **OpenAI** | GPT only | Usage-based | High | Forum |
+| **Local (Ollama)** | Open source | Free | N/A | Community |
+
+### Provider Selection Guide
+
+Choose your provider based on:
+- **Simplicity**: Cline (no API key management)
+- **Variety**: OpenRouter (access to all models)
+- **Direct Access**: Individual providers (Anthropic, OpenAI)
+- **Privacy**: Ollama or LM Studio (local models)
+
+## Community Usage Stats
+
+Real-time usage data from the Cline community:
+- View current trends at [OpenRouter's Cline stats](https://openrouter.ai/apps?url=https%3A%2F%2Fcline.bot%2F)
+- Most popular: Claude Sonnet 4.5 (40%)
+- Rising star: DeepSeek V3 (25%)
+- Budget favorite: Qwen3 variants (20%)

docs/prompting/cline-memory-bank.mdx

@@ -8,10 +8,9 @@ title: "Cline Memory Bank"
 
 To get started with Cline Memory Bank:
 
-1. **Install or Open Cline**
-2. **Copy the Custom Instructions** - Use the code block below
-3. **Paste into Cline** - Add as custom instructions or in a .clinerules file
-4. **Initialize** - Ask Cline to "initialize memory bank"
+1. **Copy the Custom Instructions** - Use the code block below
+2. **Paste into Cline** - Add as custom instructions or in a .clinerules file
+3. **Initialize** - Ask Cline to "initialize memory bank"
 
 [See detailed setup instructions](#getting-started-with-memory-bank)
 

docs/prompting/understanding-context-management.mdx

@@ -0,0 +1,172 @@
+---
+title: "Context Management"
+description: "Master context management to unlock Cline's full potential"
+---
+
+<Info>
+**Quick Reference**
+
+- **Context** = All information Cline knows about your project
+- **Context Window** = Maximum information Cline can process at once (varies by model)
+- **Token** = Unit of text measurement (~3/4 of an English word)
+- **Auto-management** = Cline automatically handles context through Focus Chain & Auto Compact
+</Info>
+
+## What is Context Management?
+
+Context management is how Cline maintains understanding of your project throughout a conversation. Think of it as the shared memory between you and Cline - containing code, decisions, requirements, and progress.
+
+<Frame caption="Context is like a shared workspace where Cline builds understanding of your project">
+	<img
+		src="https://storage.googleapis.com/cline_public_images/docs/assets/image%20(2).png"
+		alt="Context visualization showing the relationship between total context and context window"
+	/>
+</Frame>
+
+### The Three Layers of Context
+
+1. **Immediate Context** - Current conversation and active files
+2. **Project Context** - Your codebase, structure, and patterns
+3. **Persistent Context** - Memory Bank, .clinerules, and documentation
+
+## Understanding Context Windows
+
+Every AI model has a **context window** - the maximum amount of information it can process in a single conversation. This is measured in tokens:
+
+### Token Limits by Model
+
+| Model | Context Window | Effective Limit* | Best For |
+|-------|---------------|-----------------|----------|
+| **Claude 3.5 Sonnet** | 200,000 tokens | 150,000 tokens | Complex tasks, large codebases |
+| **Claude 3.5 Haiku** | 200,000 tokens | 150,000 tokens | Faster responses, simpler tasks |
+| **GPT-4o** | 128,000 tokens | 100,000 tokens | General purpose development |
+| **Gemini 2.0 Flash** | 1,000,000+ tokens | 400,000 tokens | Very large contexts |
+| **DeepSeek v3** | 64,000 tokens | 50,000 tokens | Cost-effective coding |
+| **Qwen 2.5 Coder** | 128,000 tokens | 100,000 tokens | Specialized coding tasks |
+
+*Effective limit is ~75-80% of maximum for optimal performance
+
+<Tip>
+**Token Math Made Simple**
+- 1 token ≈ 3/4 of an English word
+- 100 tokens ≈ 75 words ≈ 3-5 lines of code
+- 10,000 tokens ≈ 7,500 words ≈ ~15 pages of text
+- A typical source file: 500-2,000 tokens
+</Tip>
+
+## How Cline Builds Context
+
+Building effective context is what makes Cline truly useful. When you start a task, Cline doesn't just passively wait for information - he actively gathers context about your project, asks clarifying questions when needed, and adapts to what's happening in real-time. This combination of automatic discovery, user guidance, and dynamic adaptation ensures Cline always has the right information to solve your problems effectively.
+
+### 1. Automatic Context Gathering
+
+When you start a task, Cline proactively:
+
+```mermaid
+graph LR
+    A[Task Start] --> B[Scan Project Structure]
+    B --> C[Identify Relevant Files]
+    C --> D[Read Key Components]
+    D --> E[Map Dependencies]
+    E --> F[Build Mental Model]
+```
+
+**What Cline automatically discovers:**
+- Project structure and file organization
+- Import relationships and dependencies
+- Code patterns and conventions
+- Configuration files and settings
+- Recent changes and git history (when using @git)
+
+### 2. User-Guided Context
+
+While automatic discovery handles much of the work, you control what Cline focuses on. The more specific and relevant context you provide, the better Cline can understand your needs and deliver accurate solutions.
+
+You enhance context by:
+- **@ Mentioning** files, folders, or URLs
+- **Providing requirements** in natural language
+- **Sharing screenshots** for UI context
+- **Adding documentation** through .clinerules or Memory Bank
+- **Answering questions** when Cline needs clarification
+
+### 3. Dynamic Context Adaptation
+
+Cline adapts context dynamically throughout your conversation. It considers the complexity of your request, available context window space, current task progress, error messages and feedback, plus previous decisions made during the conversation to determine what information matters most at each step.
+
+## The Context Window Progress Bar
+
+Monitor your context usage in real-time:
+
+<Frame caption="The context window bar shows input/output token usage">
+	<img
+		src="https://storage.googleapis.com/cline_public_images/context-bar.png"
+		alt="Context window progress bar showing token usage"
+	/>
+</Frame>
+
+### Understanding the Indicators
+
+- ⬆️ **Input Tokens**: Information sent to the model (your messages + context)
+- ⬇️ **Output Tokens**: Model's responses and generated code
+- ➡️ **Cache Tokens**: Previously processed tokens that's reused (reduces costs and improves speed)
+- **Progress Bar**: Visual representation of usage
+- **Percentage**: Current usage of total capacity
+
+## Automatic Context Management Features
+
+Cline includes intelligent systems that handle context for you:
+
+### Focus Chain (Default: ON)
+
+Focus Chain maintains task continuity through automatic todo lists. When you start a task, Cline generates actionable steps and updates them as work progresses. This keeps critical context visible even after Auto Compact runs, letting you track progress without scrolling through the entire conversation.
+
+[Learn more →](/features/focus-chain)
+
+### Auto Compact (Always ON)
+
+When context usage hits around 80%, Auto Compact automatically creates a comprehensive summary of the conversation. This preserves all decisions and code changes while freeing up space for continued work. You'll see a message when this happens. The task continues seamlessly - you don't need to do anything.
+
+[Learn more →](/features/auto-compact)
+
+### Context Truncation System
+
+If your conversation approaches the model's context window limit before Auto Compact runs, Cline's Context Manager automatically truncates older parts of the conversation to prevent errors.
+
+The system prioritizes what matters most:
+- Your original task description stays
+- Recent tool executions and their results remain intact
+- Current code state and active errors are preserved
+- The logical flow of user-assistant messages is maintained
+
+What gets removed first:
+- Redundant conversation history from earlier in the task
+- Completed tool outputs that are no longer relevant
+- Intermediate debugging steps
+- Verbose explanations that served their purpose
+
+This happens automatically. You'll keep working without interruption, and Cline maintains enough context to continue solving your problem effectively.
+
+## Best Practices
+
+- **Be specific** - Clear objectives help Cline understand your needs
+- **Use @ mentions strategically** - Reference specific files rather than entire folders
+- **Monitor the progress bar** - Yellow/red means consider using `/smol` or `/newtask`
+- **Trust auto-management** - Focus Chain and Auto Compact handle complexity automatically
+- **Use Memory Bank** - Document persistent patterns and conventions
+
+## Next Steps
+
+<CardGroup cols={2}>
+	<Card title="Focus Chain" icon="link" href="/features/focus-chain">
+		Learn how Focus Chain maintains task continuity
+	</Card>
+	<Card title="Auto Compact" icon="compress" href="/features/auto-compact">
+		Understand automatic conversation compression
+	</Card>
+	<Card title="Memory Bank" icon="brain" href="/prompting/cline-memory-bank">
+		Set up persistent project knowledge
+	</Card>
+	<Card title="Cline Rules" icon="gavel" href="/features/cline-rules">
+		Define project-specific conventions
+	</Card>
+</CardGroup>

docs/provider-config/baseten.mdx

@@ -21,20 +21,16 @@ For the most updated pricing, please visit: https://www.baseten.co/products/mode
 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:**
+-   `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
 
-**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.

docs/running-models-locally/overview.mdx

@@ -0,0 +1,226 @@
+---
+title: "Local Models Overview"
+---
+
+## Running Models Locally with Cline
+
+Run Cline completely offline with genuinely capable models on your own hardware. No API costs, no data leaving your machine, no internet dependency.
+
+Local models have reached a turning point where they're now practical for real development work. This guide covers everything you need to know about running Cline with local models.
+
+## Quick Start
+
+1. **Check your hardware** - 32GB+ RAM minimum
+2. **Choose your runtime** - [LM Studio](/running-models-locally/lm-studio) or [Ollama](/running-models-locally/ollama)
+3. **Download Qwen3 Coder 30B** - The recommended model
+4. **Configure settings** - Enable compact prompts, set max context
+5. **Start coding** - Completely offline
+
+## Hardware Requirements
+
+Your RAM determines which models you can run effectively:
+
+| RAM | Recommended Model | Quantization | Performance Level |
+| --- | --- | --- | --- |
+| 32GB | Qwen3 Coder 30B | 4-bit | Entry-level local coding |
+| 64GB | Qwen3 Coder 30B | 8-bit | Full Cline features |
+| 128GB+ | GLM-4.5-Air | 4-bit | Cloud-competitive performance |
+
+## Recommended Models
+
+### Primary Recommendation: Qwen3 Coder 30B
+
+After extensive testing, **Qwen3 Coder 30B** is the most reliable model under 70B parameters for Cline:
+
+- **256K native context window** - Handle entire repositories
+- **Strong tool-use capabilities** - Reliable command execution
+- **Repository-scale understanding** - Maintains context across files
+- **Proven reliability** - Consistent outputs with Cline's tool format
+
+Download sizes:
+- 4-bit: ~17GB (recommended for 32GB RAM)
+- 8-bit: ~32GB (recommended for 64GB RAM)
+- 16-bit: ~60GB (requires 128GB+ RAM)
+
+### Why Not Smaller Models?
+
+Most models under 30B parameters (7B-20B) fail with Cline because they:
+- Produce broken tool-use outputs
+- Refuse to execute commands
+- Can't maintain conversation context
+- Struggle with complex coding tasks
+
+## Runtime Options
+
+### LM Studio
+- **Pros**: User-friendly GUI, easy model management, built-in server
+- **Cons**: Memory overhead from UI, limited to single model at a time
+- **Best for**: Desktop users who want simplicity
+- [Setup Guide →](/running-models-locally/lm-studio)
+
+### Ollama
+- **Pros**: Command-line based, lower memory overhead, scriptable
+- **Cons**: Requires terminal comfort, manual model management
+- **Best for**: Power users and server deployments
+- [Setup Guide →](/running-models-locally/ollama)
+
+## Critical Configuration
+
+### Required Settings
+
+**In Cline:**
+- ✅ Enable "Use Compact Prompt" - Reduces prompt size by 90%
+- ✅ Set appropriate model in settings
+- ✅ Configure Base URL to match your server
+
+**In LM Studio:**
+- Context Length: `262144` (maximum)
+- KV Cache Quantization: `OFF` (critical for proper function)
+- Flash Attention: `ON` (if available on your hardware)
+
+**In Ollama:**
+- Set context window: `num_ctx 262144`
+- Enable flash attention if supported
+
+### Understanding Quantization
+
+Quantization reduces model precision to fit on consumer hardware:
+
+| Type | Size Reduction | Quality | Use Case |
+| --- | --- | --- | --- |
+| 4-bit | ~75% | Good | Most coding tasks, limited RAM |
+| 8-bit | ~50% | Better | Professional work, more nuance |
+| 16-bit | None | Best | Maximum quality, requires high RAM |
+
+### Model Formats
+
+**GGUF (Universal)**
+- Works on all platforms (Windows, Linux, Mac)
+- Extensive quantization options
+- Broader tool compatibility
+- Recommended for most users
+
+**MLX (Mac only)**
+- Optimized for Apple Silicon (M1/M2/M3)
+- Leverages Metal and AMX acceleration
+- Faster inference on Mac
+- Requires macOS 13+
+
+## Performance Expectations
+
+### What's Normal
+
+- **Initial load time**: 10-30 seconds for model warmup
+- **Token generation**: 5-20 tokens/second on consumer hardware
+- **Context processing**: Slower with large codebases
+- **Memory usage**: Close to your quantization size
+
+### Performance Tips
+
+1. **Use compact prompts** - Essential for local inference
+2. **Limit context when possible** - Start with smaller windows
+3. **Choose right quantization** - Balance quality vs speed
+4. **Close other applications** - Free up RAM for the model
+5. **Use SSD storage** - Faster model loading
+
+## Use Case Comparison
+
+### When to Use Local Models
+
+✅ **Perfect for:**
+- Offline development environments
+- Privacy-sensitive projects
+- Learning without API costs
+- Unlimited experimentation
+- Air-gapped environments
+- Cost-conscious development
+
+### When to Use Cloud Models
+
+☁️ **Better for:**
+- Very large codebases (>256K tokens)
+- Multi-hour refactoring sessions
+- Teams needing consistent performance
+- Latest model capabilities
+- Time-critical projects
+
+## Troubleshooting
+
+### Common Issues & Solutions
+
+**"Shell integration unavailable"**
+- Switch to bash in Cline Settings → Terminal → Default Terminal Profile
+- Resolves 90% of terminal integration problems
+
+**"No connection could be made"**
+- Verify server is running (LM Studio or Ollama)
+- Check Base URL matches server address
+- Ensure no firewall blocking connection
+- Default ports: LM Studio (1234), Ollama (11434)
+
+**Slow or incomplete responses**
+- Normal for local models (5-20 tokens/sec typical)
+- Try smaller quantization (4-bit instead of 8-bit)
+- Enable compact prompts if not already
+- Reduce context window size
+
+**Model confusion or errors**
+- Verify KV Cache Quantization is OFF (LM Studio)
+- Ensure compact prompts enabled
+- Check context length set to maximum
+- Confirm sufficient RAM for quantization
+
+### Performance Optimization
+
+**For faster inference:**
+1. Use 4-bit quantization
+2. Enable Flash Attention
+3. Reduce context window if not needed
+4. Close unnecessary applications
+5. Use NVMe SSD for model storage
+
+**For better quality:**
+1. Use 8-bit or higher quantization
+2. Maximize context window
+3. Ensure adequate cooling
+4. Allocate maximum RAM to model
+
+## Advanced Configuration
+
+### Multi-GPU Setup
+If you have multiple GPUs, you can split model layers:
+- LM Studio: Automatic GPU detection
+- Ollama: Set `num_gpu` parameter
+
+### Custom Models
+While Qwen3 Coder 30B is recommended, you can experiment with:
+- DeepSeek Coder V2
+- Codestral 22B
+- StarCoder2 15B
+
+Note: These may require additional configuration and testing.
+
+## Community & Support
+
+- **Discord**: [Join our community](https://discord.gg/cline) for real-time help
+- **Reddit**: [r/cline](https://www.reddit.com/r/CLine/) for discussions
+- **GitHub**: [Report issues](https://github.com/cline/cline/issues)
+
+## Next Steps
+
+Ready to get started? Choose your path:
+
+<CardGroup cols={2}>
+  <Card title="LM Studio Setup" icon="desktop" href="/running-models-locally/lm-studio">
+    User-friendly GUI approach with detailed configuration guide
+  </Card>
+  <Card title="Ollama Setup" icon="terminal" href="/running-models-locally/ollama">
+    Command-line setup for power users and automation
+  </Card>
+</CardGroup>
+
+## Summary
+
+Local models with Cline are now genuinely practical. While they won't match top-tier cloud APIs in speed, they offer complete privacy, zero costs, and offline capability. With proper configuration and the right hardware, Qwen3 Coder 30B can handle most coding tasks effectively.
+
+The key is proper setup: adequate RAM, correct configuration, and realistic expectations. Follow this guide, and you'll have a capable coding assistant running entirely on your hardware.

docs/running-models-locally/read-me-first.mdx

@@ -1,154 +0,0 @@
----
-title: "Read Me First"
----
-
-## Running Local Models with Cline
-
-Local models have reached a turning point. For the first time, you can run Cline completely offline with genuinely capable models. No API costs, no data leaving your machine, no internet dependency.
-
-The key is choosing the right model for your hardware and configuring it properly.
-
-## What You Need to Know
-
-### Hardware Requirements
-
-Your RAM determines which models you can run:
-
-| RAM Tier | Recommended Model | Quantization | What You Get |
-| --- | --- | --- | --- |
-| 32GB | Qwen3 Coder 30B | 4-bit | Entry-level local coding |
-| 64GB | Qwen3 Coder 30B | 8-bit | Full Cline features |
-| 128GB+ | GLM-4.5-Air | 4-bit | Cloud-competitive performance |
-
-### The Model That Works: Qwen3 Coder 30B
-
-After extensive testing, **Qwen3 Coder 30B** is the only model under 70B parameters that reliably works with Cline. It brings:
-
-- 256K native context window
-- Strong tool-use capabilities
-- Repository-scale understanding
-- Reliable command execution
-
-Most smaller models (7B-20B) fail with Cline. They produce broken outputs, refuse to execute commands, or can't handle tool use properly.
-
-### Critical Configuration
-
-Getting local models to work requires specific settings:
-
-**For LM Studio:**
-1. Context Length: 262,144 (maximum)
-2. KV Cache Quantization: OFF (critical)
-3. Flash Attention: ON (if available)
-
-**For All Local Models:**
-- Enable "Use Compact Prompt" in Cline settings
-- This reduces prompt size by 90% while maintaining core functionality
-- Essential for local inference performance
-
-### Quantization Explained
-
-Quantization reduces model precision to fit on consumer hardware. Think of it as compression:
-
-- **4-bit**: ~75% size reduction. Completely usable for coding tasks.
-- **8-bit**: ~50% size reduction. Better quality, more nuanced responses.
-- **16-bit**: Full precision. Matches cloud APIs but requires 4x the memory.
-
-For Qwen3 Coder 30B:
-- 4-bit: ~17GB download
-- 8-bit: ~32GB download
-- 16-bit: ~60GB download
-
-### Model Format
-
-Choose based on your platform:
-
-**MLX (Mac only)**
-- Optimized for Apple Silicon
-- Leverages Metal and AMX acceleration
-- Faster inference on M1/M2/M3 chips
-
-**GGUF (Universal)**
-- Works on Windows, Linux, and Mac
-- Extensive quantization options
-- Broader tool compatibility
-
-## Performance Characteristics
-
-Local models perform differently than cloud APIs:
-
-**Expect:**
-- Warmup time when first loading (normal, happens once)
-- Slower inference than cloud models
-- Context ingestion slows with very large repositories
-
-**Don't Expect:**
-- Instant responses like cloud APIs
-- Unlimited context processing speed
-- Zero configuration
-
-## When Local Models Excel
-
-Use local models for:
-
-- Offline development where internet is unreliable
-- Privacy-sensitive projects where code can't leave your environment
-- Cost-conscious development where API usage would be prohibitive
-- Learning and experimentation with unlimited usage
-
-## When to Use Cloud Models
-
-Cloud models still have advantages for:
-
-- Very large repositories exceeding local context limits
-- Multi-hour refactoring sessions needing maximum context
-- Teams requiring consistent performance across different hardware
-- Tasks requiring the absolute latest model capabilities
-
-## Common Issues
-
-**"Shell integration unavailable" or command execution fails**
-
-Switch to a simpler shell in Cline settings. Go to Cline Settings → Terminal → Default Terminal Profile and select "bash". This resolves 90% of terminal integration problems.
-
-**"No connection could be made"**
-
-Your local server (Ollama or LM Studio) isn't running, or is running on a different port. Check that:
-- The server is actually running
-- The Base URL in Cline settings matches your server's address
-- No firewall is blocking the connection
-
-**Slow or incomplete responses**
-
-This is normal for local models. They're significantly slower than cloud APIs. If it's too slow:
-- Try a smaller quantization (4-bit instead of 8-bit)
-- Reduce context window size
-- Enable compact prompts if you haven't already
-
-**Model seems confused or makes errors**
-
-Ensure you have:
-- Compact prompts enabled
-- KV Cache Quantization disabled (LM Studio)
-- Context length set to maximum
-- Sufficient RAM for your chosen quantization
-
-## Getting Started
-
-1. **Choose your runtime**: [LM Studio](/running-models-locally/lm-studio) or [Ollama](/running-models-locally/ollama)
-2. **Download Qwen3 Coder 30B** in the appropriate quantization for your RAM
-3. **Configure critical settings** as outlined above
-4. **Enable compact prompts** in Cline settings
-5. **Start coding** offline
-
-## The Reality of Local Models
-
-Local models are now genuinely useful for coding tasks, but they're not magic. You're trading some convenience and speed for privacy and cost savings. The setup requires attention to detail, and performance won't match top-tier cloud APIs.
-
-But for the first time, you can run a capable coding agent entirely on your laptop. That's a significant milestone.
-
-## Need Help?
-
-- Join our [Discord](https://discord.gg/cline) community
-- Visit [r/cline](https://www.reddit.com/r/CLine/) on Reddit
-- Check the [LM Studio guide](/running-models-locally/lm-studio) for detailed setup
-- See the [Ollama guide](/running-models-locally/ollama) for alternative setup

docs/styles.css

@@ -1,8 +1,48 @@
 /* Custom styles for Cline documentation */
 
+/* Import Geist Sans font from Google Fonts */
+@import url("https://fonts.googleapis.com/css2?family=Geist+Sans:wght@300;400;500;600;700&display=swap");
+
+/* Import Geist Mono font from Google Fonts */
+@import url("https://fonts.googleapis.com/css2?family=Geist+Mono:wght@300;400;500;600;700&display=swap");
+
+/* Apply Geist Sans to body text, but not headings or code */
+body,
+p,
+li,
+td,
+th,
+span:not(code *),
+div:not(code *):not(pre *) {
+	font-family:
+		"Geist Sans", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif !important;
+}
+
+/* Ensure code blocks use Geist Mono */
+code,
+pre,
+.code,
+pre code,
+code *,
+pre * {
+	font-family: "Geist Mono", "Monaco", "Courier New", monospace !important;
+}
+
 /* Make h1 titles lighter in font weight */
 h1 {
-	font-weight: 500 !important;
+	font-weight: 600 !important;
+}
+
+/* Keep headings and images at full opacity */
+h1,
+h2,
+h3,
+h4,
+h5,
+h6,
+img {
+	opacity: 1 !important;
+	font-family: "Geist Sans", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif !important;
 }
 
 /* Also apply to any h1 elements within content areas */

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "claude-dev",
-	"version": "3.33.0",
+	"version": "3.33.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "claude-dev",
-			"version": "3.33.0",
+			"version": "3.33.1",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.37.0",
@@ -40,7 +40,7 @@
 				"@opentelemetry/sdk-trace-base": "^2.1.0",
 				"@opentelemetry/sdk-trace-node": "^1.30.1",
 				"@opentelemetry/semantic-conventions": "^1.37.0",
-				"@playwright/test": "^1.53.2",
+				"@playwright/test": "^1.55.1",
 				"@sap-ai-sdk/ai-api": "^1.17.0",
 				"@sap-ai-sdk/orchestration": "^1.17.0",
 				"@sentry/browser": "^9.12.0",
@@ -71,7 +71,7 @@
 				"isbinaryfile": "^5.0.2",
 				"jschardet": "^3.1.4",
 				"jwt-decode": "^4.0.0",
-				"mammoth": "^1.8.0",
+				"mammoth": "^1.11.0",
 				"nice-grpc": "^2.1.12",
 				"node-machine-id": "^1.1.12",
 				"ollama": "^0.5.13",
@@ -1815,20 +1815,6 @@
 				"semver": "^7.5.3"
 			}
 		},
-		"node_modules/@changesets/apply-release-plan/node_modules/prettier": {
-			"version": "2.8.8",
-			"dev": true,
-			"license": "MIT",
-			"bin": {
-				"prettier": "bin-prettier.js"
-			},
-			"engines": {
-				"node": ">=10.13.0"
-			},
-			"funding": {
-				"url": "https://github.com/prettier/prettier?sponsor=1"
-			}
-		},
 		"node_modules/@changesets/assemble-release-plan": {
 			"version": "6.0.9",
 			"resolved": "https://registry.npmjs.org/@changesets/assemble-release-plan/-/assemble-release-plan-6.0.9.tgz",
@@ -4982,10 +4968,12 @@
 			}
 		},
 		"node_modules/@playwright/test": {
-			"version": "1.53.2",
+			"version": "1.56.1",
+			"resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.56.1.tgz",
+			"integrity": "sha512-vSMYtL/zOcFpvJCW71Q/OEGQb7KYBPAdKh35WNSkaZA75JlAO8ED8UN6GUNTm3drWomcbcqRPFqQbLae8yBTdg==",
 			"license": "Apache-2.0",
 			"dependencies": {
-				"playwright": "1.53.2"
+				"playwright": "1.56.1"
 			},
 			"bin": {
 				"playwright": "cli.js"
@@ -9031,6 +9019,8 @@
 		},
 		"node_modules/duck": {
 			"version": "0.1.12",
+			"resolved": "https://registry.npmjs.org/duck/-/duck-0.1.12.tgz",
+			"integrity": "sha512-wkctla1O6VfP89gQ+J/yDesM0S7B7XLXjKGzXxMDVFg7uEn706niAtyYovKbyq1oT9YwDcly721/iUWoc8MVRg==",
 			"license": "BSD",
 			"dependencies": {
 				"underscore": "^1.13.1"
@@ -12594,7 +12584,9 @@
 			"license": "Apache-2.0"
 		},
 		"node_modules/lop": {
-			"version": "0.4.1",
+			"version": "0.4.2",
+			"resolved": "https://registry.npmjs.org/lop/-/lop-0.4.2.tgz",
+			"integrity": "sha512-RefILVDQ4DKoRZsJ4Pj22TxE3omDO47yFpkIBoDKzkqPRISs5U1cnAdg/5583YPkWPaLIYHOKRMQSvjFsO26cw==",
 			"license": "BSD-2-Clause",
 			"dependencies": {
 				"duck": "^0.1.12",
@@ -12647,7 +12639,9 @@
 			"license": "ISC"
 		},
 		"node_modules/mammoth": {
-			"version": "1.8.0",
+			"version": "1.11.0",
+			"resolved": "https://registry.npmjs.org/mammoth/-/mammoth-1.11.0.tgz",
+			"integrity": "sha512-BcEqqY/BOwIcI1iR5tqyVlqc3KIaMRa4egSoK83YAVrBf6+yqdAAbtUcFDCWX8Zef8/fgNZ6rl4VUv+vVX8ddQ==",
 			"license": "BSD-2-Clause",
 			"dependencies": {
 				"@xmldom/xmldom": "^0.8.6",
@@ -12656,7 +12650,7 @@
 				"bluebird": "~3.4.0",
 				"dingbat-to-unicode": "^1.0.1",
 				"jszip": "^3.7.1",
-				"lop": "^0.4.1",
+				"lop": "^0.4.2",
 				"path-is-absolute": "^1.0.0",
 				"underscore": "^1.13.1",
 				"xmlbuilder": "^10.0.0"
@@ -14071,6 +14065,8 @@
 		},
 		"node_modules/option": {
 			"version": "0.2.4",
+			"resolved": "https://registry.npmjs.org/option/-/option-0.2.4.tgz",
+			"integrity": "sha512-pkEqbDyl8ou5cpq+VsnQbe/WlEy5qS7xPzMS1U55OCG9KPvwFD46zDbxQIj3egJSFc3D+XhYOPUzz49zQAVy7A==",
 			"license": "BSD-2-Clause"
 		},
 		"node_modules/ora": {
@@ -14661,10 +14657,12 @@
 			}
 		},
 		"node_modules/playwright": {
-			"version": "1.53.2",
+			"version": "1.56.1",
+			"resolved": "https://registry.npmjs.org/playwright/-/playwright-1.56.1.tgz",
+			"integrity": "sha512-aFi5B0WovBHTEvpM3DzXTUaeN6eN0qWnTkKx4NQaH4Wvcmc153PdaY2UBdSYKaGYw+UyWXSVyxDUg5DoPEttjw==",
 			"license": "Apache-2.0",
 			"dependencies": {
-				"playwright-core": "1.53.2"
+				"playwright-core": "1.56.1"
 			},
 			"bin": {
 				"playwright": "cli.js"
@@ -14677,7 +14675,9 @@
 			}
 		},
 		"node_modules/playwright-core": {
-			"version": "1.53.2",
+			"version": "1.56.1",
+			"resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.56.1.tgz",
+			"integrity": "sha512-hutraynyn31F+Bifme+Ps9Vq59hKuUCz7H1kDOcBs+2oGguKkWTU50bBWrtz34OUWmIwpBTWDxaRPXrIXkgvmQ==",
 			"license": "Apache-2.0",
 			"bin": {
 				"playwright-core": "cli.js"
@@ -14688,6 +14688,9 @@
 		},
 		"node_modules/playwright/node_modules/fsevents": {
 			"version": "2.3.2",
+			"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+			"integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+			"hasInstallScript": true,
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -14751,41 +14754,6 @@
 				"node": ">=10"
 			}
 		},
-		"node_modules/prebuild-install/node_modules/bl": {
-			"version": "4.1.0",
-			"license": "MIT",
-			"dependencies": {
-				"buffer": "^5.5.0",
-				"inherits": "^2.0.4",
-				"readable-stream": "^3.4.0"
-			}
-		},
-		"node_modules/prebuild-install/node_modules/buffer": {
-			"version": "5.7.1",
-			"funding": [
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/feross"
-				},
-				{
-					"type": "patreon",
-					"url": "https://www.patreon.com/feross"
-				},
-				{
-					"type": "consulting",
-					"url": "https://feross.org/support"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"base64-js": "^1.3.1",
-				"ieee754": "^1.1.13"
-			}
-		},
-		"node_modules/prebuild-install/node_modules/chownr": {
-			"version": "1.1.4",
-			"license": "ISC"
-		},
 		"node_modules/prebuild-install/node_modules/detect-libc": {
 			"version": "2.0.4",
 			"license": "Apache-2.0",
@@ -14793,42 +14761,6 @@
 				"node": ">=8"
 			}
 		},
-		"node_modules/prebuild-install/node_modules/readable-stream": {
-			"version": "3.6.2",
-			"license": "MIT",
-			"dependencies": {
-				"inherits": "^2.0.3",
-				"string_decoder": "^1.1.1",
-				"util-deprecate": "^1.0.1"
-			},
-			"engines": {
-				"node": ">= 6"
-			}
-		},
-		"node_modules/prebuild-install/node_modules/tar-fs": {
-			"version": "2.1.3",
-			"license": "MIT",
-			"dependencies": {
-				"chownr": "^1.1.1",
-				"mkdirp-classic": "^0.5.2",
-				"pump": "^3.0.0",
-				"tar-stream": "^2.1.4"
-			}
-		},
-		"node_modules/prebuild-install/node_modules/tar-stream": {
-			"version": "2.2.0",
-			"license": "MIT",
-			"dependencies": {
-				"bl": "^4.0.3",
-				"end-of-stream": "^1.4.1",
-				"fs-constants": "^1.0.0",
-				"inherits": "^2.0.3",
-				"readable-stream": "^3.1.1"
-			},
-			"engines": {
-				"node": ">=6"
-			}
-		},
 		"node_modules/prettier": {
 			"version": "2.8.8",
 			"resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
@@ -16719,7 +16651,9 @@
 			}
 		},
 		"node_modules/tar-fs": {
-			"version": "3.1.0",
+			"version": "3.1.1",
+			"resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-3.1.1.tgz",
+			"integrity": "sha512-LZA0oaPOc2fVo82Txf3gw+AkEd38szODlptMYejQUhndHMLQ9M059uXR+AfS7DNo0NpINvSqDsvyaCrBVkptWg==",
 			"license": "MIT",
 			"dependencies": {
 				"pump": "^3.0.0",

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.33.0",
+	"version": "3.34.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -432,7 +432,7 @@
 		"@opentelemetry/sdk-trace-base": "^2.1.0",
 		"@opentelemetry/sdk-trace-node": "^1.30.1",
 		"@opentelemetry/semantic-conventions": "^1.37.0",
-		"@playwright/test": "^1.53.2",
+		"@playwright/test": "^1.55.1",
 		"@sap-ai-sdk/ai-api": "^1.17.0",
 		"@sap-ai-sdk/orchestration": "^1.17.0",
 		"@sentry/browser": "^9.12.0",
@@ -463,7 +463,7 @@
 		"isbinaryfile": "^5.0.2",
 		"jschardet": "^3.1.4",
 		"jwt-decode": "^4.0.0",
-		"mammoth": "^1.8.0",
+		"mammoth": "^1.11.0",
 		"nice-grpc": "^2.1.12",
 		"node-machine-id": "^1.1.12",
 		"ollama": "^0.5.13",
@@ -490,6 +490,9 @@
 		"web-tree-sitter": "^0.22.6",
 		"zod": "^3.24.2"
 	},
+	"overrides": {
+		"tar-fs": ">=3.1.1"
+	},
 	"c8": {
 		"reporter": [
 			"lcov",

proto/cline/models.proto

@@ -16,13 +16,13 @@ service ModelsService {
   // Fetches available models from VS Code LM API
   rpc getVsCodeLmModels(EmptyRequest) returns (VsCodeLmModelsArray);
   // Refreshes and returns OpenRouter models
-  rpc refreshOpenRouterModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  rpc refreshOpenRouterModelsRPC(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns Hugging Face models
   rpc refreshHuggingFaceModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns OpenAI models
   rpc refreshOpenAiModels(OpenAiModelsRequest) returns (StringArray);
   // Refreshes and returns Vercel AI Gateway models
-  rpc refreshVercelAiGatewayModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  rpc refreshVercelAiGatewayModelsRPC(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns Requesty models
   rpc refreshRequestyModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Subscribe to OpenRouter models updates
@@ -32,9 +32,9 @@ service ModelsService {
   // Updates API configuration with partial values (only updates fields that are explicitly set)
   rpc updateApiConfigurationPartial(UpdateApiConfigurationPartialRequest) returns (Empty);
   // Refreshes and returns Groq models
-  rpc refreshGroqModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  rpc refreshGroqModelsRPC(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Refreshes and returns Baseten models
-  rpc refreshBasetenModels(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
+  rpc refreshBasetenModelsRPC(EmptyRequest) returns (OpenRouterCompatibleModelInfo);
   // Fetches available models from SAP AI Core
   rpc getSapAiCoreModels(SapAiCoreModelsRequest) returns (SapAiCoreModelsResponse);
   // Fetches available models from OCA

proto/cline/state.proto

@@ -31,14 +31,14 @@ service StateService {
 }
 
 message AutoApprovalActions {
-  bool read_files = 1;
-  bool read_files_externally = 2;
-  bool edit_files = 3;
-  bool edit_files_externally = 4;
-  bool execute_safe_commands = 5;
-  bool execute_all_commands = 6;
-  bool use_browser = 7;
-  bool use_mcp = 8;
+  optional bool read_files = 1;
+  optional bool read_files_externally = 2;
+  optional bool edit_files = 3;
+  optional bool edit_files_externally = 4;
+  optional bool execute_safe_commands = 5;
+  optional bool execute_all_commands = 6;
+  optional bool use_browser = 7;
+  optional bool use_mcp = 8;
 }
 
 // Auto approval settings for task execution
@@ -280,19 +280,9 @@ message ResetStateRequest {
 
 message AutoApprovalSettingsRequest {
   Metadata metadata = 1;
-  message Actions {
-    bool read_files = 1;
-    bool read_files_externally = 2;
-    bool edit_files = 3;
-    bool edit_files_externally = 4;
-    bool execute_safe_commands = 5;
-    bool execute_all_commands = 6;
-    bool use_browser = 7;
-    bool use_mcp = 8;
-  }
   int32 version = 2;
   bool enabled = 3;
-  Actions actions = 4;
+  AutoApprovalActions actions = 4;
   int32 max_requests = 5;
   bool enable_notifications = 6;
   repeated string favorites = 7;
@@ -323,17 +313,19 @@ message UpdateSettingsRequestCli {
   Metadata metadata = 1;
   optional Settings settings = 2;
   optional Secrets secrets = 3;
+  optional string environment = 4;
 }
 
 message UpdateTaskSettingsRequest {
   Metadata metadata = 1;
   optional Settings settings = 2;
+  optional string task_id = 3;
 }
 
 // Message for updating settings
 message UpdateSettingsRequest {
   Metadata metadata = 1;
-  optional ApiConfiguration api_configuration = 2;
+  optional ModelsApiConfiguration api_configuration = 2;
   optional string telemetry_setting = 3;
   optional bool plan_act_separate_models_setting = 4;
   optional bool enable_checkpoints_setting = 5;
@@ -361,143 +353,7 @@ message UpdateSettingsRequest {
   optional int32 max_consecutive_mistakes = 28;
   optional bool subagents_enabled = 29;
   optional int32 subagent_terminal_output_line_limit = 30;
-}
-
-// Complete API Configuration message
-message ApiConfiguration {
-  // Global configuration fields (not mode-specific)
-  optional string api_key = 1; // anthropic
-  optional string cline_api_key = 2;
-  optional string ulid = 3;
-  optional string lite_llm_base_url = 4;
-  optional string lite_llm_api_key = 5;
-  optional bool lite_llm_use_prompt_cache = 6;
-  map<string, string> open_ai_headers = 7;
-  optional string anthropic_base_url = 8;
-  optional string open_router_api_key = 9;
-  optional string open_router_provider_sorting = 10;
-  optional string aws_access_key = 11;
-  optional string aws_secret_key = 12;
-  optional string aws_session_token = 13;
-  optional string aws_region = 14;
-  optional bool aws_use_cross_region_inference = 15;
-  optional bool aws_bedrock_use_prompt_cache = 16;
-  optional bool aws_use_profile = 17;
-  optional string aws_profile = 18;
-  optional string aws_bedrock_endpoint = 19;
-  optional string claude_code_path = 20;
-  optional string vertex_project_id = 21;
-  optional string vertex_region = 22;
-  optional string open_ai_base_url = 23;
-  optional string open_ai_api_key = 24;
-  optional string ollama_base_url = 25;
-  optional string ollama_api_options_ctx_num = 26;
-  optional string lm_studio_base_url = 27;
-  optional string gemini_api_key = 28;
-  optional string gemini_base_url = 29;
-  optional string open_ai_native_api_key = 30;
-  optional string deep_seek_api_key = 31;
-  optional string requesty_api_key = 32;
-  optional string requesty_base_url = 33;
-  optional string together_api_key = 34;
-  optional string fireworks_api_key = 35;
-  optional int32 fireworks_model_max_completion_tokens = 36;
-  optional int32 fireworks_model_max_tokens = 37;
-  optional string qwen_api_key = 38;
-  optional string doubao_api_key = 39;
-  optional string mistral_api_key = 40;
-  optional string azure_api_version = 41;
-  optional string qwen_api_line = 42;
-  optional string nebius_api_key = 43;
-  optional string asksage_api_url = 44;
-  optional string asksage_api_key = 45;
-  optional string xai_api_key = 46;
-  optional string sambanova_api_key = 47;
-  optional string cerebras_api_key = 48;
-  optional int32 request_timeout_ms = 49;
-  optional string sap_ai_core_client_id = 50;
-  optional string sap_ai_core_client_secret = 51;
-  optional string sap_ai_resource_group = 52;
-  optional string sap_ai_core_token_url = 53;
-  optional string sap_ai_core_base_url = 54;
-  optional string moonshot_api_key = 55;
-  optional string moonshot_api_line = 56;
-  optional string huawei_cloud_maas_api_key = 57;
-  optional string ollama_api_key = 58;
-  optional string zai_api_key = 59;
-  optional string zai_api_line = 60;
-  optional string lm_studio_max_tokens = 61;
-  optional string vercel_ai_gateway_api_key = 62;
-  optional string qwen_code_oauth_path = 63;
-  optional string dify_api_key = 64;
-  optional string dify_base_url = 65;
-  optional string oca_base_url = 66;
-  optional string oca_api_key = 67;
-  optional string oca_refresh_token = 68;
-  optional string oca_mode = 69;
-  optional bool aws_use_global_inference = 70;
-  
-  // Plan mode configurations
-  optional ApiProvider plan_mode_api_provider = 100;
-  optional string plan_mode_api_model_id = 101;
-  optional int32 plan_mode_thinking_budget_tokens = 102;
-  optional string plan_mode_reasoning_effort = 103;
-  optional LanguageModelChatSelector plan_mode_vs_code_lm_model_selector = 104;
-  optional bool plan_mode_aws_bedrock_custom_selected = 105;
-  optional string plan_mode_aws_bedrock_custom_model_base_id = 106;
-  optional string plan_mode_open_router_model_id = 107;
-  optional OpenRouterModelInfo plan_mode_open_router_model_info = 108;
-  optional string plan_mode_open_ai_model_id = 109;
-  optional OpenAiCompatibleModelInfo plan_mode_open_ai_model_info = 110;
-  optional string plan_mode_ollama_model_id = 111;
-  optional string plan_mode_lm_studio_model_id = 112;
-  optional string plan_mode_lite_llm_model_id = 113;
-  optional LiteLLMModelInfo plan_mode_lite_llm_model_info = 114;
-  optional string plan_mode_requesty_model_id = 115;
-  optional OpenRouterModelInfo plan_mode_requesty_model_info = 116;
-  optional string plan_mode_together_model_id = 117;
-  optional string plan_mode_fireworks_model_id = 118;
-  optional string plan_mode_sap_ai_core_model_id = 119;
-  optional string plan_mode_huawei_cloud_maas_model_id = 120;
-  optional OpenRouterModelInfo plan_mode_huawei_cloud_maas_model_info = 121;
-  optional string plan_mode_vercel_ai_gateway_model_id = 122;
-  optional OpenRouterModelInfo plan_mode_vercel_ai_gateway_model_info = 123;
-  optional string plan_mode_oca_model_id = 124;
-  optional OcaModelInfo plan_mode_oca_model_info = 125;
-  
-  // Act mode configurations
-  optional ApiProvider act_mode_api_provider = 200;
-  optional string act_mode_api_model_id = 201;
-  optional int32 act_mode_thinking_budget_tokens = 202;
-  optional string act_mode_reasoning_effort = 203;
-  optional LanguageModelChatSelector act_mode_vs_code_lm_model_selector = 204;
-  optional bool act_mode_aws_bedrock_custom_selected = 205;
-  optional string act_mode_aws_bedrock_custom_model_base_id = 206;
-  optional string act_mode_open_router_model_id = 207;
-  optional OpenRouterModelInfo act_mode_open_router_model_info = 208;
-  optional string act_mode_open_ai_model_id = 209;
-  optional OpenAiCompatibleModelInfo act_mode_open_ai_model_info = 210;
-  optional string act_mode_ollama_model_id = 211;
-  optional string act_mode_lm_studio_model_id = 212;
-  optional string act_mode_lite_llm_model_id = 213;
-  optional LiteLLMModelInfo act_mode_lite_llm_model_info = 214;
-  optional string act_mode_requesty_model_id = 215;
-  optional OpenRouterModelInfo act_mode_requesty_model_info = 216;
-  optional string act_mode_together_model_id = 217;
-  optional string act_mode_fireworks_model_id = 218;
-  optional string act_mode_sap_ai_core_model_id = 219;
-  optional string act_mode_huawei_cloud_maas_model_id = 220;
-  optional OpenRouterModelInfo act_mode_huawei_cloud_maas_model_info = 221;
-  optional string act_mode_vercel_ai_gateway_model_id = 222;
-  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 223;
-  optional string act_mode_oca_model_id = 224;
-  optional OcaModelInfo act_mode_oca_model_info = 225;
-
-  // Extension fields for Bedrock Api Keys
-  optional string aws_authentication = 301;
-  optional string aws_bedrock_api_key = 302;
-
-  optional string cline_account_id = 303;
+  optional string cline_env = 31;
 }
 
 message UpdateTerminalConnectionTimeoutRequest {

scripts/package-standalone.mjs

@@ -126,31 +126,31 @@ async function copyCliBinaries() {
 	// Copy all platform-specific binaries
 	for (const { os, arch } of platforms) {
 		const platformSuffix = `${os}-${arch}`
-		
+
 		// Copy cline binary
 		const clineSource = path.join(CLI_BINARIES_DIR, `cline-${platformSuffix}`)
 		const clineDest = path.join(binDir, `cline-${platformSuffix}`)
-		
+
 		if (!fs.existsSync(clineSource)) {
 			console.error(`Error: CLI binary not found at ${clineSource}`)
 			console.error(`Please run: npm run compile-cli`)
 			process.exit(1)
 		}
-		
+
 		await cpr(clineSource, clineDest)
 		fs.chmodSync(clineDest, 0o755)
 		console.log(`✓ cline-${platformSuffix} copied`)
-		
+
 		// Copy cline-host binary
 		const hostSource = path.join(CLI_BINARIES_DIR, `cline-host-${platformSuffix}`)
 		const hostDest = path.join(binDir, `cline-host-${platformSuffix}`)
-		
+
 		if (!fs.existsSync(hostSource)) {
 			console.error(`Error: CLI binary not found at ${hostSource}`)
 			console.error(`Please run: npm run compile-cli`)
 			process.exit(1)
 		}
-		
+
 		await cpr(hostSource, hostDest)
 		fs.chmodSync(hostDest, 0o755)
 		console.log(`✓ cline-host-${platformSuffix} copied`)
@@ -212,7 +212,7 @@ async function copyRipgrepBinary() {
 			console.error(`Please run: npm run download-ripgrep`)
 			process.exit(1)
 		}
-		
+
 		// Check again after download
 		if (!fs.existsSync(ripgrepBinarySource)) {
 			console.error(`Error: Ripgrep binary still not found at ${ripgrepBinarySource}`)
@@ -263,7 +263,7 @@ async function createNpmPackageFiles() {
 	// Copy package.json from cli/ directory
 	const packageJsonSource = path.join("cli", "package.json")
 	const packageJsonDest = path.join(BUILD_DIR, "package.json")
-	
+
 	if (!fs.existsSync(packageJsonSource)) {
 		console.error(`Error: NPM package.json not found at ${packageJsonSource}`)
 		process.exit(1)
@@ -275,7 +275,7 @@ async function createNpmPackageFiles() {
 	// Copy README.md from cli/ directory
 	const readmeSource = path.join("cli", "README.md")
 	const readmeDest = path.join(BUILD_DIR, "README.md")
-	
+
 	if (!fs.existsSync(readmeSource)) {
 		console.error(`Error: NPM README.md not found at ${readmeSource}`)
 		process.exit(1)
@@ -288,7 +288,7 @@ async function createNpmPackageFiles() {
 	const manPageSource = path.join("cli", "man", "cline.1")
 	const manDir = path.join(BUILD_DIR, "man")
 	const manPageDest = path.join(manDir, "cline.1")
-	
+
 	if (!fs.existsSync(manPageSource)) {
 		console.error(`Error: Man page not found at ${manPageSource}`)
 		process.exit(1)
@@ -323,7 +323,7 @@ async function createFakeNodeModules() {
 
 	// Copy vscode stub into fake_node_modules
 	await cpr(vscodeSource, vscodeDest)
-	
+
 	console.log(`✓ fake_node_modules/vscode created at ${vscodeDest}`)
 }
 
@@ -347,7 +347,7 @@ node_modules/vscode
 
 	const npmignorePath = path.join(BUILD_DIR, ".npmignore")
 	fs.writeFileSync(npmignorePath, npmignoreContent)
-	
+
 	console.log(`✓ .npmignore created`)
 }
 
@@ -478,12 +478,12 @@ try {
 	console.error('Please report this issue at: https://github.com/cline/cline/issues');
 	process.exit(1);
 }
-`;
+`
 
 	const postinstallPath = path.join(BUILD_DIR, "postinstall.js")
 	fs.writeFileSync(postinstallPath, postinstallScript)
 	fs.chmodSync(postinstallPath, 0o755)
-	
+
 	console.log(`✓ postinstall.js created`)
 }
 
@@ -696,4 +696,4 @@ function log_verbose(...args) {
 	}
 }
 
-await main()
+await main()

src/config.ts

@@ -19,70 +19,94 @@ export interface EnvironmentConfig {
 	}
 }
 
-function getClineEnv(): Environment {
-	const _override = process?.env?.CLINE_ENVIRONMENT_OVERRIDE
-	if (_override && Object.values(Environment).includes(_override as Environment)) {
-		return _override as Environment
+class ClineEndpoint {
+	public static instance = new ClineEndpoint()
+	public static get config() {
+		return ClineEndpoint.instance.config()
 	}
 
-	const _env = process?.env?.CLINE_ENVIRONMENT
-	if (_env && Object.values(Environment).includes(_env as Environment)) {
-		return _env as Environment
-	}
-	return Environment.production
-}
+	private environment: Environment = Environment.production
 
-// Config getter function to avoid storing all configs in memory
-function getEnvironmentConfig(environment: Environment): EnvironmentConfig {
-	switch (environment) {
-		case Environment.staging:
-			return {
-				environment,
-				appBaseUrl: "https://staging-app.cline.bot",
-				apiBaseUrl: "https://core-api.staging.int.cline.bot",
-				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-				firebase: {
-					apiKey: "AIzaSyASSwkwX1kSO8vddjZkE5N19QU9cVQ0CIk",
-					authDomain: "cline-staging.firebaseapp.com",
-					projectId: "cline-staging",
-					storageBucket: "cline-staging.firebasestorage.app",
-					messagingSenderId: "853479478430",
-					appId: "1:853479478430:web:2de0dba1c63c3262d4578f",
-				},
-			}
-		case Environment.local:
-			return {
-				environment,
-				appBaseUrl: "http://localhost:3000",
-				apiBaseUrl: "http://localhost:7777",
-				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-				firebase: {
-					apiKey: "AIzaSyD8wtkd1I-EICuAg6xgAQpRdwYTvwxZG2w",
-					authDomain: "cline-preview.firebaseapp.com",
-					projectId: "cline-preview",
-				},
-			}
-		default:
-			return {
-				environment,
-				appBaseUrl: "https://app.cline.bot",
-				apiBaseUrl: "https://api.cline.bot",
-				mcpBaseUrl: "https://api.cline.bot/v1/mcp",
-				firebase: {
-					apiKey: "AIzaSyC5rx59Xt8UgwdU3PCfzUF7vCwmp9-K2vk",
-					authDomain: "cline-prod.firebaseapp.com",
-					projectId: "cline-prod",
-					storageBucket: "cline-prod.firebasestorage.app",
-					messagingSenderId: "941048379330",
-					appId: "1:941048379330:web:45058eedeefc5cdfcc485b",
-				},
-			}
+	private constructor() {
+		// Set environment at module load
+		const _env = process?.env?.CLINE_ENVIRONMENT
+		if (_env && Object.values(Environment).includes(_env as Environment)) {
+			this.environment = _env as Environment
+			return
+		}
+	}
+
+	public config(): EnvironmentConfig {
+		return this.getEnvironment()
+	}
+
+	public setEnvironment(env: string) {
+		switch (env.toLowerCase()) {
+			case "staging":
+				this.environment = Environment.staging
+				break
+			case "local":
+				this.environment = Environment.local
+				break
+			default:
+				this.environment = Environment.production
+				break
+		}
+		console.info("Cline environment updated: ", this.environment)
+	}
+
+	public getEnvironment(): EnvironmentConfig {
+		switch (this.environment) {
+			case Environment.staging:
+				return {
+					environment: Environment.staging,
+					appBaseUrl: "https://staging-app.cline.bot",
+					apiBaseUrl: "https://core-api.staging.int.cline.bot",
+					mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+					firebase: {
+						apiKey: "AIzaSyASSwkwX1kSO8vddjZkE5N19QU9cVQ0CIk",
+						authDomain: "cline-staging.firebaseapp.com",
+						projectId: "cline-staging",
+						storageBucket: "cline-staging.firebasestorage.app",
+						messagingSenderId: "853479478430",
+						appId: "1:853479478430:web:2de0dba1c63c3262d4578f",
+					},
+				}
+			case Environment.local:
+				return {
+					environment: Environment.local,
+					appBaseUrl: "http://localhost:3000",
+					apiBaseUrl: "http://localhost:7777",
+					mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+					firebase: {
+						apiKey: "AIzaSyD8wtkd1I-EICuAg6xgAQpRdwYTvwxZG2w",
+						authDomain: "cline-preview.firebaseapp.com",
+						projectId: "cline-preview",
+					},
+				}
+			default:
+				return {
+					environment: Environment.production,
+					appBaseUrl: "https://app.cline.bot",
+					apiBaseUrl: "https://api.cline.bot",
+					mcpBaseUrl: "https://api.cline.bot/v1/mcp",
+					firebase: {
+						apiKey: "AIzaSyC5rx59Xt8UgwdU3PCfzUF7vCwmp9-K2vk",
+						authDomain: "cline-prod.firebaseapp.com",
+						projectId: "cline-prod",
+						storageBucket: "cline-prod.firebasestorage.app",
+						messagingSenderId: "941048379330",
+						appId: "1:941048379330:web:45058eedeefc5cdfcc485b",
+					},
+				}
+		}
 	}
 }
 
-// Get environment once at module load
-const _configCache = getEnvironmentConfig(getClineEnv())
-
-console.info("Cline environment:", _configCache.environment)
-
-export const clineEnvConfig = _configCache
+/**
+ * Singleton instance to access the current environment configuration.
+ * Usage:
+ * - ClineEnv.config() to get the current config.
+ * - ClineEnv.setEnvironment(Environment.local) to change the environment.
+ */
+export const ClineEnv = ClineEndpoint.instance

src/core/api/providers/bedrock.ts

@@ -10,7 +10,7 @@ import {
 } from "@aws-sdk/client-bedrock-runtime"
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers"
 import { BedrockModelId, bedrockDefaultModelId, bedrockModels, CLAUDE_SONNET_1M_SUFFIX, ModelInfo } from "@shared/api"
-import { calculateApiCostOpenAI } from "@utils/cost"
+import { calculateApiCostOpenAI, calculateApiCostQwen } from "@utils/cost"
 import { ExtensionRegistryInfo } from "@/registry"
 import { ApiHandler, CommonApiHandlerOptions } from "../"
 import { withRetry } from "../retry"
@@ -150,6 +150,12 @@ export class AwsBedrockHandler implements ApiHandler {
 			return
 		}
 
+		// Check if this is a Qwen model
+		if (baseModelId.includes("qwen")) {
+			yield* this.createQwenMessage(systemPrompt, messages, modelId, model)
+			return
+		}
+
 		// Check if this is a Deepseek model
 		if (baseModelId.includes("deepseek")) {
 			yield* this.createDeepseekMessage(systemPrompt, messages, modelId, model)
@@ -1126,4 +1132,139 @@ export class AwsBedrockHandler implements ApiHandler {
 			}
 		}
 	}
+
+	/**
+	 * Creates a message using Qwen models through AWS Bedrock
+	 * Uses non-streaming Converse API and simulates streaming for models that don't support it
+	 */
+	private async *createQwenMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		modelId: string,
+		model: { id: string; info: ModelInfo },
+	): ApiStream {
+		// Get Bedrock client with proper credentials
+		const client = await this.getBedrockClient()
+
+		// Format messages for Converse API
+		const formattedMessages = this.formatMessagesForConverseAPI(messages)
+
+		// Prepare system message
+		const systemMessages = systemPrompt ? [{ text: systemPrompt }] : undefined
+
+		// Prepare the non-streaming Converse command
+		const command = new ConverseCommand({
+			modelId: modelId,
+			messages: formattedMessages,
+			system: systemMessages,
+			inferenceConfig: {
+				maxTokens: model.info.maxTokens || 8192,
+				temperature: 0,
+			},
+		})
+
+		try {
+			// Track token usage
+			const inputTokenEstimate = this.estimateInputTokens(systemPrompt, messages)
+			let outputTokens = 0
+
+			// Execute the non-streaming request
+			const response = await client.send(command)
+
+			// Extract the complete response text and reasoning content
+			let fullText = ""
+			let reasoningText = ""
+
+			if (response.output?.message?.content) {
+				for (const contentBlock of response.output.message.content) {
+					// Check for reasoning content first
+					if ("reasoningContent" in contentBlock && contentBlock.reasoningContent) {
+						// Handle nested reasoning structure
+						const reasoning = contentBlock.reasoningContent
+						if ("reasoningText" in reasoning && reasoning.reasoningText && "text" in reasoning.reasoningText) {
+							reasoningText += reasoning.reasoningText.text
+						}
+					}
+					// Handle regular text content
+					else if ("text" in contentBlock && contentBlock.text) {
+						fullText += contentBlock.text
+					}
+				}
+			}
+
+			// If we have actual usage data from the response, use it
+			if (response.usage) {
+				const actualInputTokens = response.usage.inputTokens || inputTokenEstimate
+				const actualOutputTokens = response.usage.outputTokens || this.estimateTokenCount(fullText + reasoningText)
+				outputTokens = actualOutputTokens
+
+				// Report actual usage after processing content
+				const actualCost = calculateApiCostQwen(model.info, actualInputTokens, actualOutputTokens, 0, 0)
+				yield {
+					type: "usage",
+					inputTokens: actualInputTokens,
+					outputTokens: actualOutputTokens,
+					totalCost: actualCost,
+				}
+			} else {
+				// Estimate output tokens if not provided (includes both regular text and reasoning)
+				outputTokens = this.estimateTokenCount(fullText + reasoningText)
+			}
+
+			// Yield reasoning content first if present
+			if (reasoningText) {
+				const reasoningChunkSize = 1000 // Characters per chunk
+				for (let i = 0; i < reasoningText.length; i += reasoningChunkSize) {
+					const chunk = reasoningText.slice(i, Math.min(i + reasoningChunkSize, reasoningText.length))
+
+					yield {
+						type: "reasoning",
+						reasoning: chunk,
+					}
+				}
+			}
+
+			// Simulate streaming by chunking the response text
+			if (fullText) {
+				const chunkSize = 1000 // Characters per chunk
+
+				for (let i = 0; i < fullText.length; i += chunkSize) {
+					const chunk = fullText.slice(i, Math.min(i + chunkSize, fullText.length))
+
+					yield {
+						type: "text",
+						text: chunk,
+					}
+				}
+			}
+
+			// Report final usage if we didn't have actual usage data earlier
+			if (!response.usage) {
+				const finalCost = calculateApiCostQwen(model.info, inputTokenEstimate, outputTokens, 0, 0)
+				yield {
+					type: "usage",
+					inputTokens: inputTokenEstimate,
+					outputTokens: outputTokens,
+					totalCost: finalCost,
+				}
+			}
+		} catch (error) {
+			console.error("Error with Qwen model via Converse API:", error)
+
+			// Try to extract more detailed error information
+			let errorMessage = "Failed to process Qwen model request"
+			if (error instanceof Error) {
+				errorMessage = error.message
+				// Check for specific AWS SDK errors
+				if ("name" in error) {
+					errorMessage = `${error.name}: ${error.message}`
+				}
+			}
+
+			yield {
+				type: "text",
+				text: `[ERROR] ${errorMessage}`,
+			}
+		}
+	}
 }

src/core/api/providers/cline.ts

@@ -3,7 +3,7 @@ import { ModelInfo, openRouterDefaultModelId, openRouterDefaultModelInfo } from
 import { shouldSkipReasoningForModel } from "@utils/model-utils"
 import axios from "axios"
 import OpenAI from "openai"
-import { clineEnvConfig } from "@/config"
+import { ClineEnv } from "@/config"
 import { ClineAccountService } from "@/services/account/ClineAccountService"
 import { AuthService } from "@/services/auth/AuthService"
 import { buildClineExtraHeaders } from "@/services/EnvUtils"
@@ -30,7 +30,7 @@ export class ClineHandler implements ApiHandler {
 	private clineAccountService = ClineAccountService.getInstance()
 	private _authService: AuthService
 	private client: OpenAI | undefined
-	private readonly _baseUrl = clineEnvConfig.apiBaseUrl
+	private readonly _baseUrl = ClineEnv.config().apiBaseUrl
 	lastGenerationId?: string
 	private lastRequestId?: string
 

src/core/api/transform/openrouter-stream.ts

@@ -2,6 +2,7 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import {
 	CLAUDE_SONNET_1M_SUFFIX,
 	ModelInfo,
+	OPENROUTER_PROVIDER_PREFERENCES,
 	openRouterClaudeSonnet41mModelId,
 	openRouterClaudeSonnet451mModelId,
 } from "@shared/api"
@@ -164,9 +165,10 @@ export async function createOpenRouterStream(
 			}
 	}
 
-	// hardcoded provider sorting for kimi-k2
-	const isKimiK2 = model.id === "moonshotai/kimi-k2"
-	openRouterProviderSorting = isKimiK2 ? undefined : openRouterProviderSorting
+	const providerPreferences = OPENROUTER_PROVIDER_PREFERENCES[model.id]
+	if (providerPreferences) {
+		openRouterProviderSorting = undefined
+	}
 
 	// @ts-ignore-next-line
 	const stream = await client.chat.completions.create({
@@ -180,12 +182,8 @@ export async function createOpenRouterStream(
 		include_reasoning: true,
 		...(model.id.startsWith("openai/o") ? { reasoning_effort: reasoningEffort || "medium" } : {}),
 		...(reasoning ? { reasoning } : {}),
-		...(openRouterProviderSorting ? { provider: { sort: openRouterProviderSorting } } : {}),
-		// limit providers to only those that support the 131k context window
-		...(isKimiK2
-			? { provider: { order: ["groq", "together", "baseten", "parasail", "novita", "deepinfra"], allow_fallbacks: false } }
-			: {}),
-		// limit providers to only those that support the 1m context window
+		...(openRouterProviderSorting && !providerPreferences ? { provider: { sort: openRouterProviderSorting } } : {}),
+		...(providerPreferences ? { provider: providerPreferences } : {}),
 		...(isClaudeSonnet1m ? { provider: { order: ["anthropic", "google-vertex/global"], allow_fallbacks: false } } : {}),
 	})
 

src/core/context/context-management/ContextManager.ts

@@ -513,7 +513,7 @@ export class ContextManager {
 				}
 
 				if (firstUserMessage) {
-					const processedFirstUserMessage = formatResponse.processFirstUserMessageForTruncation(firstUserMessage)
+					const processedFirstUserMessage = formatResponse.processFirstUserMessageForTruncation()
 
 					const innerMap = new Map<number, ContextUpdate[]>()
 					innerMap.set(0, [[timestamp, "text", [processedFirstUserMessage], []]])

src/core/controller/account/setUserOrganization.ts

@@ -14,17 +14,10 @@ export async function setUserOrganization(controller: Controller, request: UserO
 		if (!controller.accountService) {
 			throw new Error("Account service not available")
 		}
-
 		// Switch to the specified organization using the account service
 		await controller.accountService.switchAccount(request.organizationId)
-
-		try {
-			await fetchRemoteConfig(controller)
-		} catch (error) {
-			console.error("Failed to fetch remote config after org switch:", error)
-		}
-
-		return Empty.create({})
+		await fetchRemoteConfig(controller)
+		return {}
 	} catch (error) {
 		throw error
 	}

src/core/controller/index.ts

@@ -24,7 +24,7 @@ import pWaitFor from "p-wait-for"
 import * as path from "path"
 import type { FolderLockWithRetryResult } from "src/core/locks/types"
 import * as vscode from "vscode"
-import { clineEnvConfig } from "@/config"
+import { ClineEnv } from "@/config"
 import { HostProvider } from "@/hosts/host-provider"
 import { ExtensionRegistryInfo } from "@/registry"
 import { AuthService } from "@/services/auth/AuthService"
@@ -34,6 +34,7 @@ import { featureFlagsService } from "@/services/feature-flags"
 import { getDistinctId } from "@/services/logging/distinctId"
 import { telemetryService } from "@/services/telemetry"
 import { ShowMessageType } from "@/shared/proto/host/window"
+import { AuthState } from "@/shared/proto/index.cline"
 import { getLatestAnnouncementId } from "@/utils/announcements"
 import { getCwd, getDesktopDir } from "@/utils/path"
 import { PromptRegistry } from "../prompts/system-prompt"
@@ -47,6 +48,7 @@ import {
 import { fetchRemoteConfig } from "../storage/remote-config/fetch"
 import { PersistenceErrorEvent, StateManager } from "../storage/StateManager"
 import { Task } from "../task"
+import { StreamingResponseHandler } from "./grpc-handler"
 import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
 import { appendClineStealthModels } from "./models/refreshOpenRouterModels"
 import { checkCliInstallation } from "./state/checkCliInstallation"
@@ -108,16 +110,9 @@ export class Controller {
 	 */
 	private startRemoteConfigTimer() {
 		// Initial fetch
-		fetchRemoteConfig(this).catch((error) => {
-			console.error("Failed to fetch remote config:", error)
-		})
-
+		fetchRemoteConfig(this)
 		// Set up 30-second interval
-		this.remoteConfigTimer = setInterval(() => {
-			fetchRemoteConfig(this).catch((error) => {
-				console.error("Failed to fetch remote config:", error)
-			})
-		}, 30000) // 30 seconds
+		this.remoteConfigTimer = setInterval(() => fetchRemoteConfig(this), 30000) // 30 seconds
 	}
 
 	constructor(readonly context: vscode.ExtensionContext) {
@@ -150,6 +145,13 @@ export class Controller {
 		this.ocaAuthService = OcaAuthService.initialize(this)
 		this.accountService = ClineAccountService.getInstance()
 
+		const authStatusHandler: StreamingResponseHandler<AuthState> = async (response, _isLast, _seqNumber): Promise<void> => {
+			if (response.user) {
+				fetchRemoteConfig(this)
+			}
+		}
+		this.authService.subscribeToAuthStatusUpdate(this, {}, authStatusHandler, undefined)
+
 		this.authService.restoreRefreshTokenAndRetrieveAuthInfo().then(() => {
 			this.startRemoteConfigTimer()
 		})
@@ -244,11 +246,7 @@ export class Controller {
 		historyItem?: HistoryItem,
 		taskSettings?: Partial<Settings>,
 	) {
-		try {
-			await fetchRemoteConfig(this)
-		} catch (error) {
-			console.error("Failed to fetch remote config on task init:", error)
-		}
+		await fetchRemoteConfig(this)
 
 		await this.clearTask() // ensures that an existing task doesn't exist before starting a new one, although this shouldn't be possible since user must clear task before starting a new one
 
@@ -601,7 +599,7 @@ export class Controller {
 	// MCP Marketplace
 	private async fetchMcpMarketplaceFromApi(silent: boolean = false): Promise<McpMarketplaceCatalog | undefined> {
 		try {
-			const response = await axios.get(`${clineEnvConfig.mcpBaseUrl}/marketplace`, {
+			const response = await axios.get(`${ClineEnv.config().mcpBaseUrl}/marketplace`, {
 				headers: {
 					"Content-Type": "application/json",
 				},
@@ -638,7 +636,7 @@ export class Controller {
 
 	private async fetchMcpMarketplaceFromApiRPC(silent: boolean = false): Promise<McpMarketplaceCatalog | undefined> {
 		try {
-			const response = await axios.get(`${clineEnvConfig.mcpBaseUrl}/marketplace`, {
+			const response = await axios.get(`${ClineEnv.config().mcpBaseUrl}/marketplace`, {
 				headers: {
 					"Content-Type": "application/json",
 					"User-Agent": "cline-vscode-extension",
@@ -882,7 +880,7 @@ export class Controller {
 		const platform = process.platform as Platform
 		const distinctId = getDistinctId()
 		const version = ExtensionRegistryInfo.version
-		const environment = clineEnvConfig.environment
+		const environment = ClineEnv.config().environment
 
 		// Set feature flag in dictation settings based on platform
 		const updatedDictationSettings = {

src/core/controller/mcp/downloadMcp.ts

@@ -2,7 +2,7 @@ import { McpServer } from "@shared/mcp"
 import { StringRequest } from "@shared/proto/cline/common"
 import { McpDownloadResponse } from "@shared/proto/cline/mcp"
 import axios from "axios"
-import { clineEnvConfig } from "@/config"
+import { ClineEnv } from "@/config"
 import { Controller } from ".."
 import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
 
@@ -31,7 +31,7 @@ export async function downloadMcp(controller: Controller, request: StringRequest
 
 		// Fetch server details from marketplace
 		const response = await axios.post<McpDownloadResponse>(
-			`${clineEnvConfig.mcpBaseUrl}/download`,
+			`${ClineEnv.config().mcpBaseUrl}/download`,
 			{ mcpId },
 			{
 				headers: { "Content-Type": "application/json" },

src/core/controller/models/refreshBasetenModels.ts

@@ -1,6 +1,5 @@
 import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import { ModelInfo } from "@shared/api"
 import { fileExistsAtPath } from "@utils/fs"
 import { parsePrice } from "@utils/model-utils"
 import axios from "axios"
@@ -10,25 +9,19 @@ import { basetenModels } from "../../../shared/api"
 import { Controller } from ".."
 
 /**
- * Refreshes the Baseten models and returns the updated model list
+ * Core function: Refreshes the Baseten models and returns application types
  * @param controller The controller instance
- * @param request Empty request object
- * @returns Response containing the Baseten models
+ * @returns Record of model ID to ModelInfo (application types)
  */
-export async function refreshBasetenModels(
-	controller: Controller,
-	_request: EmptyRequest,
-): Promise<OpenRouterCompatibleModelInfo> {
-	console.log("=== refreshBasetenModels called ===")
+export async function refreshBasetenModels(controller: Controller): Promise<Record<string, ModelInfo>> {
 	const basetenModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.basetenModels)
 
 	// Get the Baseten API key from the controller's state
 	const basetenApiKey = controller.stateManager.getSecretKey("basetenApiKey")
 
-	const models: Record<string, Partial<OpenRouterModelInfo> & { supportedFeatures?: string[] }> = {}
+	const models: Record<string, Partial<ModelInfo> & { supportedFeatures?: string[] }> = {}
 	try {
 		if (!basetenApiKey) {
-			console.log("No Baseten API key found, using static models as fallback")
 			// Don't throw an error, just use static models, althought this might be slightly out of date
 			for (const [modelId, modelInfo] of Object.entries(basetenModels)) {
 				models[modelId] = {
@@ -50,8 +43,6 @@ export async function refreshBasetenModels(
 				throw new Error("Invalid Baseten API key format")
 			}
 
-			console.log("Fetching Baseten models with API key:", cleanApiKey.substring(0, 10) + "...")
-
 			const response = await axios.get("https://inference.baseten.co/v1/models", {
 				headers: {
 					Authorization: `Bearer ${cleanApiKey}`,
@@ -73,7 +64,7 @@ export async function refreshBasetenModels(
 					// Check if we have static pricing information for this model
 					const staticModelInfo = basetenModels[rawModel.id as keyof typeof basetenModels]
 
-					const modelInfo: Partial<OpenRouterModelInfo> & { supportedFeatures?: string[] } = {
+					const modelInfo: Partial<ModelInfo> & { supportedFeatures?: string[] } = {
 						maxTokens: rawModel.max_completion_tokens || staticModelInfo?.maxTokens,
 						contextWindow: rawModel.context_length || staticModelInfo?.contextWindow,
 						supportsImages: false, // Baseten model APIs does not support image input
@@ -92,7 +83,6 @@ export async function refreshBasetenModels(
 				console.error("Invalid response from Baseten API")
 			}
 			await fs.writeFile(basetenModelsFilePath, JSON.stringify(models))
-			console.log("Baseten models fetched and saved:", Object.keys(models))
 		}
 	} catch (error) {
 		console.error("Error fetching Baseten models:", error)
@@ -120,14 +110,12 @@ export async function refreshBasetenModels(
 		// If we failed to fetch models, try to read cached models first
 		const cachedModels = await readBasetenModels()
 		if (cachedModels && Object.keys(cachedModels).length > 0) {
-			console.log("Using cached Baseten models")
 			// Use all cached models (no filtering)
 			for (const [modelId, modelInfo] of Object.entries(cachedModels)) {
 				models[modelId] = modelInfo
 			}
 		} else {
 			// Fall back to static models from shared/api.ts
-			console.log("Using static Baseten models as fallback")
 			for (const [modelId, modelInfo] of Object.entries(basetenModels)) {
 				models[modelId] = {
 					maxTokens: modelInfo.maxTokens,
@@ -144,9 +132,9 @@ export async function refreshBasetenModels(
 		}
 	}
 
-	// Convert the Record<string, Partial<OpenRouterModelInfo>> to Record<string, OpenRouterModelInfo>
+	// Convert the Record<string, Partial<ModelInfo>> to Record<string, ModelInfo>
 	// by filling in any missing required fields with defaults
-	const typedModels: Record<string, OpenRouterModelInfo> = {}
+	const typedModels: Record<string, ModelInfo> = {}
 	for (const [key, model] of Object.entries(models)) {
 		typedModels[key] = {
 			maxTokens: model.maxTokens ?? 8192,
@@ -158,18 +146,17 @@ export async function refreshBasetenModels(
 			cacheWritesPrice: model.cacheWritesPrice ?? 0,
 			cacheReadsPrice: model.cacheReadsPrice ?? 0,
 			description: model.description ?? "",
-			tiers: model.tiers ?? [],
-			// Note: supportedFeatures is preserved as custom property but not part of OpenRouterModelInfo proto
+			tiers: model.tiers,
 		}
 	}
 
-	return OpenRouterCompatibleModelInfo.create({ models: typedModels })
+	return typedModels
 }
 
 /**
- * Reads cached Baseten models from disk
+ * Reads cached Baseten models from disk (application types)
  */
-async function readBasetenModels(): Promise<Record<string, Partial<OpenRouterModelInfo>> | undefined> {
+async function readBasetenModels(): Promise<Record<string, Partial<ModelInfo>> | undefined> {
 	const basetenModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.basetenModels)
 	const fileExists = await fileExistsAtPath(basetenModelsFilePath)
 	if (fileExists) {

src/core/controller/models/refreshBasetenModelsRPC.ts

@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshBasetenModels } from "./refreshBasetenModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Baseten models (protobuf types)
+ */
+export async function refreshBasetenModelsRPC(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshBasetenModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}

src/core/controller/models/refreshGroqModels.ts

@@ -1,6 +1,5 @@
 import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import { ModelInfo } from "@shared/api"
 import { fileExistsAtPath } from "@utils/fs"
 import axios from "axios"
 import fs from "fs/promises"
@@ -10,17 +9,16 @@ import { groqModels } from "../../../shared/api"
 import { Controller } from ".."
 
 /**
- * Refreshes the Groq models and returns the updated model list
+ * Core function: Refreshes the Groq models and returns application types
  * @param controller The controller instance
- * @param request Empty request object
- * @returns Response containing the Groq models
+ * @returns Record of model ID to ModelInfo (application types)
  */
-export async function refreshGroqModels(controller: Controller, _request: EmptyRequest): Promise<OpenRouterCompatibleModelInfo> {
+export async function refreshGroqModels(controller: Controller): Promise<Record<string, ModelInfo>> {
 	const groqModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.groqModels)
 
 	const groqApiKey = controller.stateManager.getSecretKey("groqApiKey")
 
-	let models: Record<string, Partial<OpenRouterModelInfo>> = {}
+	let models: Record<string, Partial<ModelInfo>> = {}
 	try {
 		if (!groqApiKey) {
 			console.log("No Groq API key found, using static models as fallback")
@@ -68,7 +66,7 @@ export async function refreshGroqModels(controller: Controller, _request: EmptyR
 					// Check if we have static pricing information for this model
 					const staticModelInfo = groqModels[rawModel.id as keyof typeof groqModels]
 
-					const modelInfo: Partial<OpenRouterModelInfo> = {
+					const modelInfo: Partial<ModelInfo> = {
 						maxTokens: rawModel.max_completion_tokens || staticModelInfo?.maxTokens || 8192,
 						contextWindow: rawModel.context_window || staticModelInfo?.contextWindow || 8192,
 						supportsImages: detectImageSupport(rawModel, staticModelInfo),
@@ -117,7 +115,7 @@ export async function refreshGroqModels(controller: Controller, _request: EmptyR
 		})
 
 		// If we failed to fetch models, try to read cached models first
-		const cachedModels = await readGroqModels(controller)
+		const cachedModels = await readGroqModels()
 		if (cachedModels && Object.keys(cachedModels).length > 0) {
 			console.log("Using cached Groq models")
 			models = cachedModels
@@ -140,9 +138,9 @@ export async function refreshGroqModels(controller: Controller, _request: EmptyR
 		}
 	}
 
-	// Convert the Record<string, Partial<OpenRouterModelInfo>> to Record<string, OpenRouterModelInfo>
+	// Convert the Record<string, Partial<ModelInfo>> to Record<string, ModelInfo>
 	// by filling in any missing required fields with defaults
-	const typedModels: Record<string, OpenRouterModelInfo> = {}
+	const typedModels: Record<string, ModelInfo> = {}
 	for (const [key, model] of Object.entries(models)) {
 		typedModels[key] = {
 			maxTokens: model.maxTokens ?? 8192,
@@ -154,17 +152,17 @@ export async function refreshGroqModels(controller: Controller, _request: EmptyR
 			cacheWritesPrice: model.cacheWritesPrice ?? 0,
 			cacheReadsPrice: model.cacheReadsPrice ?? 0,
 			description: model.description ?? "",
-			tiers: model.tiers ?? [],
+			tiers: model.tiers,
 		}
 	}
 
-	return OpenRouterCompatibleModelInfo.create({ models: typedModels })
+	return typedModels
 }
 
 /**
- * Reads cached Groq models from disk
+ * Reads cached Groq models from disk (application types)
  */
-async function readGroqModels(controller: Controller): Promise<Record<string, Partial<OpenRouterModelInfo>> | undefined> {
+async function readGroqModels(): Promise<Record<string, Partial<ModelInfo>> | undefined> {
 	const groqModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.groqModels)
 	const fileExists = await fileExistsAtPath(groqModelsFilePath)
 	if (fileExists) {

src/core/controller/models/refreshGroqModelsRPC.ts

@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshGroqModels } from "./refreshGroqModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Groq models (protobuf types)
+ */
+export async function refreshGroqModelsRPC(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshGroqModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}

src/core/controller/models/refreshOcaModels.ts

@@ -7,6 +7,7 @@ import { DEFAULT_EXTERNAL_OCA_BASE_URL, DEFAULT_INTERNAL_OCA_BASE_URL } from "@/
 import { createOcaHeaders, getAxiosSettings } from "@/services/auth/oca/utils/utils"
 import { Logger } from "@/services/logging/Logger"
 import { ShowMessageType } from "@/shared/proto/index.host"
+import { GlobalStateAndSettings } from "@/shared/storage/state-keys"
 import { Controller } from ".."
 
 /**
@@ -75,13 +76,11 @@ export async function refreshOcaModels(controller: Controller, request: StringRe
 			}
 			console.log("OCA models fetched", models)
 
-			// Fetch current config
+			// Fetch current config to determine existing model selections
 			const apiConfiguration = controller.stateManager.getApiConfiguration()
-			const updatedConfig = { ...apiConfiguration }
-
-			// Which mode(s) to update?
 			const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
 			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+
 			const planModeSelectedModelId =
 				apiConfiguration?.planModeOcaModelId && models[apiConfiguration.planModeOcaModelId]
 					? apiConfiguration.planModeOcaModelId
@@ -91,23 +90,26 @@ export async function refreshOcaModels(controller: Controller, request: StringRe
 					? apiConfiguration.actModeOcaModelId
 					: defaultModelId!
 
-			// Save new model selection(s) to configuration object, per plan/act mode setting
+			// Build updates object based on plan/act mode setting
+			const updates: Partial<GlobalStateAndSettings> = {}
+
 			if (planActSeparateModelsSetting) {
 				if (currentMode === "plan") {
-					updatedConfig.planModeOcaModelId = planModeSelectedModelId
-					updatedConfig.planModeOcaModelInfo = models[planModeSelectedModelId]
+					updates.planModeOcaModelId = planModeSelectedModelId
+					updates.planModeOcaModelInfo = models[planModeSelectedModelId]
 				} else {
-					updatedConfig.actModeOcaModelId = actModeSelectedModelId
-					updatedConfig.actModeOcaModelInfo = models[actModeSelectedModelId]
+					updates.actModeOcaModelId = actModeSelectedModelId
+					updates.actModeOcaModelInfo = models[actModeSelectedModelId]
 				}
 			} else {
-				updatedConfig.planModeOcaModelId = planModeSelectedModelId
-				updatedConfig.planModeOcaModelInfo = models[planModeSelectedModelId]
-				updatedConfig.actModeOcaModelId = actModeSelectedModelId
-				updatedConfig.actModeOcaModelInfo = models[actModeSelectedModelId]
+				updates.planModeOcaModelId = planModeSelectedModelId
+				updates.planModeOcaModelInfo = models[planModeSelectedModelId]
+				updates.actModeOcaModelId = actModeSelectedModelId
+				updates.actModeOcaModelInfo = models[actModeSelectedModelId]
 			}
 
-			controller.stateManager.setApiConfiguration(updatedConfig)
+			// Update state directly using batch method
+			controller.stateManager.setGlobalStateBatch(updates)
 
 			HostProvider.window.showMessage({
 				type: ShowMessageType.INFORMATION,

src/core/controller/models/refreshOpenRouterModels.ts

@@ -1,6 +1,5 @@
 import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import { ModelInfo } from "@shared/api"
 import axios from "axios"
 import cloneDeep from "clone-deep"
 import fs from "fs/promises"
@@ -72,18 +71,14 @@ interface OpenRouterRawModelInfo {
 }
 
 /**
- * Refreshes the OpenRouter models and returns the updated model listhttps://openrouter.ai/docs/overview/models
+ * Core function: Refreshes the OpenRouter models and returns application types
  * @param controller The controller instance
- * @param request Empty request object
- * @returns Response containing the OpenRouter models
+ * @returns Record of model ID to ModelInfo (application types)
  */
-export async function refreshOpenRouterModels(
-	controller: Controller,
-	_request: EmptyRequest,
-): Promise<OpenRouterCompatibleModelInfo> {
+export async function refreshOpenRouterModels(controller: Controller): Promise<Record<string, ModelInfo>> {
 	const openRouterModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.openRouterModels)
 
-	const models: Record<string, OpenRouterModelInfo> = {}
+	const models: Record<string, ModelInfo> = {}
 	try {
 		const response = await axios.get("https://openrouter.ai/api/v1/models")
 
@@ -97,7 +92,7 @@ export async function refreshOpenRouterModels(
 			}
 			for (const rawModel of rawModels as OpenRouterRawModelInfo[]) {
 				const supportThinking = rawModel.supported_parameters?.some((p) => p === "include_reasoning")
-				const modelInfo = OpenRouterModelInfo.create({
+				const modelInfo: ModelInfo = {
 					maxTokens: rawModel.top_provider?.max_completion_tokens ?? 0,
 					contextWindow: rawModel.context_length ?? 0,
 					supportsImages: rawModel.architecture?.modality?.includes("image") ?? false,
@@ -109,8 +104,8 @@ export async function refreshOpenRouterModels(
 					description: rawModel.description ?? "",
 					thinkingConfig: supportThinking ? (rawModel.thinking_config ?? {}) : undefined,
 					supportsGlobalEndpoint: rawModel.supports_global_endpoint ?? undefined,
-					tiers: rawModel.tiers ?? [],
-				})
+					tiers: rawModel.tiers ?? undefined,
+				}
 
 				switch (rawModel.id) {
 					case "anthropic/claude-sonnet-4.5":
@@ -243,18 +238,19 @@ export async function refreshOpenRouterModels(
 		// If we failed to fetch models, try to read cached models
 		const cachedModels = await controller.readOpenRouterModels()
 		if (cachedModels) {
-			return OpenRouterCompatibleModelInfo.create({ models: cachedModels })
+			// Cached models are already in application format (ModelInfo)
+			return appendClineStealthModels(cachedModels as Record<string, ModelInfo>)
 		}
 	}
 	// Append stealth models if any
-	return OpenRouterCompatibleModelInfo.create({ models: appendClineStealthModels(models) })
+	return appendClineStealthModels(models)
 }
 
 /**
  * Stealth models are models that are compatible with the OpenRouter API but not listed on the OpenRouter website or API.
  */
-const CLINE_STEALTH_MODELS: Record<string, OpenRouterModelInfo> = {
-	"cline/code-supernova-1-million": OpenRouterModelInfo.create({
+const CLINE_STEALTH_MODELS: Record<string, ModelInfo> = {
+	"cline/code-supernova-1-million": {
 		maxTokens: clineCodeSupernovaModelInfo.maxTokens ?? 0,
 		contextWindow: clineCodeSupernovaModelInfo.contextWindow ?? 0,
 		supportsImages: clineCodeSupernovaModelInfo.supportsImages ?? false,
@@ -266,14 +262,12 @@ const CLINE_STEALTH_MODELS: Record<string, OpenRouterModelInfo> = {
 		description: clineCodeSupernovaModelInfo.description ?? "",
 		thinkingConfig: clineCodeSupernovaModelInfo.thinkingConfig ?? undefined,
 		supportsGlobalEndpoint: clineCodeSupernovaModelInfo.supportsGlobalEndpoint ?? undefined,
-		tiers: clineCodeSupernovaModelInfo.tiers ?? [],
-	}),
+		tiers: clineCodeSupernovaModelInfo.tiers,
+	},
 	// Add more stealth models here as needed
 }
 
-export function appendClineStealthModels(
-	currentModels: Record<string, OpenRouterModelInfo>,
-): Record<string, OpenRouterModelInfo> {
+export function appendClineStealthModels(currentModels: Record<string, ModelInfo>): Record<string, ModelInfo> {
 	// Create a shallow clone of the current models to avoid mutating the original object
 	const cloned = { ...currentModels }
 	for (const [modelId, modelInfo] of Object.entries(CLINE_STEALTH_MODELS)) {

src/core/controller/models/refreshOpenRouterModelsRPC.ts

@@ -0,0 +1,21 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import type { Controller } from "../index"
+import { refreshOpenRouterModels } from "./refreshOpenRouterModels"
+
+/**
+ * Refreshes OpenRouter models and returns protobuf types for gRPC
+ * @param controller The controller instance
+ * @param request Empty request (unused but required for gRPC signature)
+ * @returns OpenRouterCompatibleModelInfo with protobuf types
+ */
+export async function refreshOpenRouterModelsRPC(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshOpenRouterModels(controller)
+	return OpenRouterCompatibleModelInfo.create({
+		models: toProtobufModels(models),
+	})
+}

src/core/controller/models/refreshVercelAiGatewayModels.ts

@@ -1,6 +1,5 @@
 import { ensureCacheDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { OpenRouterCompatibleModelInfo, OpenRouterModelInfo } from "@shared/proto/cline/models"
+import { ModelInfo } from "@shared/api"
 import { fileExistsAtPath } from "@utils/fs"
 import axios from "axios"
 import fs from "fs/promises"
@@ -8,18 +7,14 @@ import path from "path"
 import { Controller } from ".."
 
 /**
- * Refreshes Vercel AI Gateway models and returns updated model list
- * @param controller The controller instance
- * @param request Empty request object
- * @returns Response containing Vercel AI Gateway models
+ * Core function: Refreshes Vercel AI Gateway models and returns application types
+ * @param _controller The controller instance (unused)
+ * @returns Record of model ID to ModelInfo (application types)
  */
-export async function refreshVercelAiGatewayModels(
-	_controller: Controller,
-	_request: EmptyRequest,
-): Promise<OpenRouterCompatibleModelInfo> {
+export async function refreshVercelAiGatewayModels(_controller: Controller): Promise<Record<string, ModelInfo>> {
 	const vercelAiGatewayModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.vercelAiGatewayModels)
 
-	let models: Record<string, OpenRouterModelInfo> = {}
+	let models: Record<string, ModelInfo> = {}
 
 	try {
 		const response = await axios.get("https://ai-gateway.vercel.sh/v1/models")
@@ -38,7 +33,7 @@ export async function refreshVercelAiGatewayModels(
 					continue
 				}
 
-				const modelInfo = OpenRouterModelInfo.create({
+				const modelInfo: ModelInfo = {
 					maxTokens: rawModel.max_tokens ?? 0,
 					contextWindow: rawModel.context_window ?? 0,
 					inputPrice: parsePrice(rawModel.pricing?.input) ?? 0,
@@ -48,7 +43,7 @@ export async function refreshVercelAiGatewayModels(
 					supportsImages: true, // assume all models support images since vercel ai doesn't give this info
 					supportsPromptCache: !!(rawModel.pricing?.input_cache_read && rawModel.pricing?.input_cache_write),
 					description: rawModel.description ?? "",
-				})
+				}
 
 				models[rawModel.id] = modelInfo
 			}
@@ -68,13 +63,13 @@ export async function refreshVercelAiGatewayModels(
 		}
 	}
 
-	return OpenRouterCompatibleModelInfo.create({ models })
+	return models
 }
 
 /**
- * Reads cached Vercel AI Gateway models from disk
+ * Reads cached Vercel AI Gateway models from disk (application types)
  */
-async function readVercelAiGatewayModels(): Promise<Record<string, OpenRouterModelInfo> | undefined> {
+async function readVercelAiGatewayModels(): Promise<Record<string, ModelInfo> | undefined> {
 	const vercelAiGatewayModelsFilePath = path.join(await ensureCacheDirectoryExists(), GlobalFileNames.vercelAiGatewayModels)
 	const fileExists = await fileExistsAtPath(vercelAiGatewayModelsFilePath)
 	if (fileExists) {

src/core/controller/models/refreshVercelAiGatewayModelsRPC.ts

@@ -0,0 +1,19 @@
+import { EmptyRequest } from "@shared/proto/cline/common"
+import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
+import { toProtobufModels } from "../../../shared/proto-conversions/models/typeConversion"
+import { Controller } from ".."
+import { refreshVercelAiGatewayModels } from "./refreshVercelAiGatewayModels"
+
+/**
+ * Handles protobuf conversion for gRPC service
+ * @param controller The controller instance
+ * @param request Empty request object
+ * @returns Response containing Vercel AI Gateway models (protobuf types)
+ */
+export async function refreshVercelAiGatewayModelsRPC(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<OpenRouterCompatibleModelInfo> {
+	const models = await refreshVercelAiGatewayModels(controller)
+	return OpenRouterCompatibleModelInfo.create({ models: toProtobufModels(models) })
+}

src/core/controller/state/updateAutoApprovalSettings.ts

@@ -1,6 +1,5 @@
 import { Empty } from "@shared/proto/cline/common"
 import { AutoApprovalSettingsRequest } from "@shared/proto/cline/state"
-import { convertProtoToAutoApprovalSettings } from "../../../shared/proto-conversions/models/auto-approval-settings-conversion"
 import { Controller } from ".."
 
 /**
@@ -16,7 +15,21 @@ export async function updateAutoApprovalSettings(controller: Controller, request
 
 	// Only update if incoming version is higher
 	if (incomingVersion > currentVersion) {
-		const settings = convertProtoToAutoApprovalSettings(request)
+		// Merge with current settings to preserve unspecified fields
+		const settings = {
+			...currentSettings,
+			...(request.version !== undefined && { version: request.version }),
+			...(request.enabled !== undefined && { enabled: request.enabled }),
+			...(request.maxRequests !== undefined && { maxRequests: request.maxRequests }),
+			...(request.enableNotifications !== undefined && { enableNotifications: request.enableNotifications }),
+			...(request.favorites && request.favorites.length > 0 && { favorites: request.favorites }),
+			actions: {
+				...currentSettings.actions,
+				...(request.actions
+					? Object.fromEntries(Object.entries(request.actions).filter(([_, v]) => v !== undefined))
+					: {}),
+			},
+		}
 
 		if (controller.task) {
 			const maxRequestsChanged =

src/core/controller/state/updateSettings.test.ts

@@ -62,6 +62,25 @@ describe("updateSettings platform validation", () => {
 		)
 	})
 
+	it("should allow enabling subagents on Linux", async () => {
+		// Set platform to Linux
+		Object.defineProperty(process, "platform", { value: "linux" })
+
+		;(mockController.stateManager.getGlobalSettingsKey as sinon.SinonStub).returns(false)
+
+		const request = UpdateSettingsRequest.create({
+			subagentsEnabled: true,
+		})
+
+		// Should not throw
+		await updateSettings(mockController, request)
+
+		assert.ok(
+			(mockController.stateManager.setGlobalState as sinon.SinonStub).calledWith("subagentsEnabled", true),
+			"Should enable subagents on Linux",
+		)
+	})
+
 	it("should throw error when trying to enable subagents on Windows", async () => {
 		// Set platform to Windows
 		Object.defineProperty(process, "platform", { value: "win32" })
@@ -78,34 +97,7 @@ describe("updateSettings platform validation", () => {
 		} catch (error) {
 			assert.strictEqual(
 				(error as Error).message,
-				"CLI subagents are only supported on macOS platforms",
-				"Should throw platform restriction error",
-			)
-		}
-
-		assert.ok(
-			!(mockController.stateManager.setGlobalState as sinon.SinonStub).called,
-			"Should not call setGlobalState when platform validation fails",
-		)
-	})
-
-	it("should throw error when trying to enable subagents on Linux", async () => {
-		// Set platform to Linux
-		Object.defineProperty(process, "platform", { value: "linux" })
-
-		;(mockController.stateManager.getGlobalSettingsKey as sinon.SinonStub).returns(false)
-
-		const request = UpdateSettingsRequest.create({
-			subagentsEnabled: true,
-		})
-
-		try {
-			await updateSettings(mockController, request)
-			assert.fail("Should have thrown an error")
-		} catch (error) {
-			assert.strictEqual(
-				(error as Error).message,
-				"CLI subagents are only supported on macOS platforms",
+				"CLI subagents are only supported on macOS and Linux platforms",
 				"Should throw platform restriction error",
 			)
 		}

src/core/controller/state/updateSettings.ts

@@ -10,6 +10,7 @@ import {
 import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
 import { OpenaiReasoningEffort } from "@shared/storage/types"
 import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { ClineEnv } from "@/config"
 import { HostProvider } from "@/hosts/host-provider"
 import { TerminalInfo } from "@/integrations/terminal/TerminalRegistry"
 import { McpDisplayMode } from "@/shared/McpDisplayMode"
@@ -17,6 +18,7 @@ import { ShowMessageType } from "@/shared/proto/host/window"
 import { telemetryService } from "../../../services/telemetry"
 import { BrowserSettings as SharedBrowserSettings } from "../../../shared/BrowserSettings"
 import { Controller } from ".."
+import { accountLogoutClicked } from "../account/accountLogoutClicked"
 
 /**
  * Updates multiple extension settings in a single request
@@ -26,6 +28,11 @@ import { Controller } from ".."
  */
 export async function updateSettings(controller: Controller, request: UpdateSettingsRequest): Promise<Empty> {
 	try {
+		if (request.clineEnv !== undefined) {
+			ClineEnv.setEnvironment(request.clineEnv)
+			await accountLogoutClicked(controller, Empty.create())
+		}
+
 		if (request.apiConfiguration) {
 			const protoApiConfiguration = request.apiConfiguration
 
@@ -328,9 +335,9 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			const wasEnabled = currentSettings ?? false
 			const isEnabled = !!request.subagentsEnabled
 
-			// Platform validation: Only allow enabling subagents on macOS
-			if (isEnabled && process.platform !== "darwin") {
-				throw new Error("CLI subagents are only supported on macOS platforms")
+			// Platform validation: Only allow enabling subagents on macOS and Linux
+			if (isEnabled && process.platform !== "darwin" && process.platform !== "linux") {
+				throw new Error("CLI subagents are only supported on macOS and Linux platforms")
 			}
 
 			controller.stateManager.setGlobalState("subagentsEnabled", isEnabled)

src/core/controller/state/updateSettingsCli.ts

@@ -9,13 +9,14 @@ import {
 import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
 import { Settings } from "@shared/storage/state-keys"
 import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { ClineEnv } from "@/config"
 import { HostProvider } from "@/hosts/host-provider"
 import { TerminalInfo } from "@/integrations/terminal/TerminalRegistry"
 import { ShowMessageType } from "@/shared/proto/host/window"
-import { convertProtoToAutoApprovalSettings } from "@/shared/proto-conversions/models/auto-approval-settings-conversion"
 import { Mode, OpenaiReasoningEffort } from "@/shared/storage/types"
 import { telemetryService } from "../../../services/telemetry"
 import { Controller } from ".."
+import { accountLogoutClicked } from "../account/accountLogoutClicked"
 
 /**
  * Updates multiple extension settings in a single request
@@ -44,6 +45,11 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 	}
 
 	try {
+		if (request.environment !== undefined) {
+			ClineEnv.setEnvironment(request.environment)
+			await accountLogoutClicked(controller, Empty.create())
+		}
+
 		if (request.settings) {
 			// Extract all special case fields that need dedicated handlers
 			// These should NOT be included in the batch update
@@ -72,13 +78,31 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 
 			controller.stateManager.setGlobalStateBatch(filteredSettings)
 
+			console.log("autoApprovalSettings", controller.stateManager.getGlobalSettingsKey("autoApprovalSettings"))
+
 			// Handle fields requiring type conversion from generated protobuf types to application types
 			if (autoApprovalSettings) {
-				const converted = convertProtoToAutoApprovalSettings({
-					...autoApprovalSettings,
-					metadata: {},
-				})
-				controller.stateManager.setGlobalState("autoApprovalSettings", converted)
+				// Merge with current settings to preserve unspecified fields
+				const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+				const mergedSettings = {
+					...currentAutoApprovalSettings,
+					...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
+					...(autoApprovalSettings.enabled !== undefined && { enabled: autoApprovalSettings.enabled }),
+					...(autoApprovalSettings.maxRequests !== undefined && { maxRequests: autoApprovalSettings.maxRequests }),
+					...(autoApprovalSettings.enableNotifications !== undefined && {
+						enableNotifications: autoApprovalSettings.enableNotifications,
+					}),
+					...(autoApprovalSettings.favorites &&
+						autoApprovalSettings.favorites.length > 0 && { favorites: autoApprovalSettings.favorites }),
+					actions: {
+						...currentAutoApprovalSettings.actions,
+						...(autoApprovalSettings.actions
+							? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
+							: {}),
+					},
+				}
+
+				controller.stateManager.setGlobalState("autoApprovalSettings", mergedSettings)
 			}
 
 			if (openaiReasoningEffort !== undefined) {
@@ -227,7 +251,7 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 			}
 		}
 
-		// Handle secrets update
+		// Handle secrets updates
 		if (request.secrets) {
 			const filteredSecrets = Object.fromEntries(
 				Object.entries(request.secrets).filter(([_, value]) => value !== undefined),

src/core/controller/state/updateTaskSettings.ts

@@ -5,7 +5,6 @@ import {
 	UpdateTaskSettingsRequest,
 } from "@shared/proto/cline/state"
 import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-configuration-conversion"
-import { convertProtoToAutoApprovalSettings } from "@/shared/proto-conversions/models/auto-approval-settings-conversion"
 import { Mode, OpenaiReasoningEffort } from "@/shared/storage/types"
 import { Controller } from ".."
 
@@ -36,13 +35,18 @@ export async function updateTaskSettings(controller: Controller, request: Update
 	}
 
 	try {
-		// Ensure we have an active task
-		if (!controller.task) {
-			throw new Error("No active task to update settings for")
+		// Get taskId from request first, otherwise fall back to current task
+		let taskId: string
+		if (request.taskId) {
+			taskId = request.taskId
+		} else {
+			// Use current task if no taskId is provided
+			if (!controller.task) {
+				throw new Error("No active task to update settings for")
+			}
+			taskId = controller.task.taskId
 		}
 
-		const taskId = controller.task.ulid
-
 		if (request.settings) {
 			// Extract all special case fields that need dedicated handlers
 			const {
@@ -67,11 +71,26 @@ export async function updateTaskSettings(controller: Controller, request: Update
 
 			// Handle fields requiring type conversion from generated protobuf types to application types
 			if (autoApprovalSettings) {
-				const converted = convertProtoToAutoApprovalSettings({
-					...autoApprovalSettings,
-					metadata: {},
-				})
-				controller.stateManager.setTaskSettings(taskId, "autoApprovalSettings", converted)
+				// Merge with current settings to preserve unspecified fields
+				const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+				const mergedSettings = {
+					...currentAutoApprovalSettings,
+					...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
+					...(autoApprovalSettings.enabled !== undefined && { enabled: autoApprovalSettings.enabled }),
+					...(autoApprovalSettings.maxRequests !== undefined && { maxRequests: autoApprovalSettings.maxRequests }),
+					...(autoApprovalSettings.enableNotifications !== undefined && {
+						enableNotifications: autoApprovalSettings.enableNotifications,
+					}),
+					...(autoApprovalSettings.favorites &&
+						autoApprovalSettings.favorites.length > 0 && { favorites: autoApprovalSettings.favorites }),
+					actions: {
+						...currentAutoApprovalSettings.actions,
+						...(autoApprovalSettings.actions
+							? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
+							: {}),
+					},
+				}
+				controller.stateManager.setTaskSettings(taskId, "autoApprovalSettings", mergedSettings)
 			}
 
 			if (openaiReasoningEffort !== undefined) {

src/core/controller/task/newTask.ts

@@ -4,7 +4,6 @@ import { NewTaskRequest } from "@shared/proto/cline/task"
 import { Settings } from "@shared/storage/state-keys"
 import { convertProtoToApiProvider } from "@/shared/proto-conversions/models/api-configuration-conversion"
 import { DEFAULT_BROWSER_SETTINGS } from "../../../shared/BrowserSettings"
-import { convertProtoToAutoApprovalSettings } from "../../../shared/proto-conversions/models/auto-approval-settings-conversion"
 import { Controller } from ".."
 
 /**
@@ -37,10 +36,28 @@ export async function newTask(controller: Controller, request: NewTaskRequest):
 		Object.entries({
 			...request.taskSettings,
 			...(request.taskSettings?.autoApprovalSettings && {
-				autoApprovalSettings: convertProtoToAutoApprovalSettings({
-					...request.taskSettings.autoApprovalSettings,
-					metadata: {},
-				}),
+				autoApprovalSettings: (() => {
+					// Merge with global settings to ensure complete settings for new task
+					const globalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+					const incomingSettings = request.taskSettings.autoApprovalSettings
+					return {
+						...globalSettings,
+						...(incomingSettings.version !== undefined && { version: incomingSettings.version }),
+						...(incomingSettings.enabled !== undefined && { enabled: incomingSettings.enabled }),
+						...(incomingSettings.maxRequests !== undefined && { maxRequests: incomingSettings.maxRequests }),
+						...(incomingSettings.enableNotifications !== undefined && {
+							enableNotifications: incomingSettings.enableNotifications,
+						}),
+						...(incomingSettings.favorites &&
+							incomingSettings.favorites.length > 0 && { favorites: incomingSettings.favorites }),
+						actions: {
+							...globalSettings.actions,
+							...(incomingSettings.actions
+								? Object.fromEntries(Object.entries(incomingSettings.actions).filter(([_, v]) => v !== undefined))
+								: {}),
+						},
+					}
+				})(),
 			}),
 			...(request.taskSettings?.browserSettings && {
 				browserSettings: {

src/core/controller/ui/initializeWebview.ts

@@ -2,6 +2,7 @@ import { Empty, EmptyRequest } from "@shared/proto/cline/common"
 import { OpenRouterCompatibleModelInfo } from "@shared/proto/cline/models"
 import { readMcpMarketplaceCatalogFromCache } from "@/core/storage/disk"
 import { telemetryService } from "@/services/telemetry"
+import { GlobalStateAndSettings } from "@/shared/storage/state-keys"
 import type { Controller } from "../index"
 import { sendMcpMarketplaceCatalogEvent } from "../mcp/subscribeToMcpMarketplaceCatalog"
 import { refreshBasetenModels } from "../models/refreshBasetenModels"
@@ -25,8 +26,8 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 		}
 
 		// Refresh OpenRouter models from API
-		refreshOpenRouterModels(controller, EmptyRequest.create()).then(async (response) => {
-			if (response && response.models) {
+		refreshOpenRouterModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
 				// Update model info in state (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const apiConfiguration = controller.stateManager.getApiConfiguration()
 				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
@@ -38,41 +39,37 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 					const modelInfoField = currentMode === "plan" ? "planModeOpenRouterModelInfo" : "actModeOpenRouterModelInfo"
 					const modelId = apiConfiguration[modelIdField]
 
-					if (modelId && response.models[modelId]) {
-						const updatedConfig = {
-							...apiConfiguration,
-							[modelInfoField]: response.models[modelId],
-						}
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
 						await controller.postStateToWebview()
 					}
 				} else {
 					// Shared models: update both plan and act modes
 					const planModelId = apiConfiguration.planModeOpenRouterModelId
 					const actModelId = apiConfiguration.actModeOpenRouterModelId
-					const updatedConfig = { ...apiConfiguration }
+					const updates: Partial<GlobalStateAndSettings> = {}
 
 					// Update plan mode model info if we have a model ID
-					if (planModelId && response.models[planModelId]) {
-						updatedConfig.planModeOpenRouterModelInfo = response.models[planModelId]
+					if (planModelId && models[planModelId]) {
+						updates.planModeOpenRouterModelInfo = models[planModelId]
 					}
 
 					// Update act mode model info if we have a model ID
-					if (actModelId && response.models[actModelId]) {
-						updatedConfig.actModeOpenRouterModelInfo = response.models[actModelId]
+					if (actModelId && models[actModelId]) {
+						updates.actModeOpenRouterModelInfo = models[actModelId]
 					}
 
 					// Post state update if we updated any model info
-					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (Object.keys(updates).length > 0) {
+						controller.stateManager.setGlobalStateBatch(updates)
 						await controller.postStateToWebview()
 					}
 				}
 			}
 		})
 
-		refreshGroqModels(controller, EmptyRequest.create()).then(async (response) => {
-			if (response && response.models) {
+		refreshGroqModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
 				// Update model info in state for Groq (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const apiConfiguration = controller.stateManager.getApiConfiguration()
 				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
@@ -84,41 +81,37 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 					const modelInfoField = currentMode === "plan" ? "planModeGroqModelInfo" : "actModeGroqModelInfo"
 					const modelId = apiConfiguration[modelIdField]
 
-					if (modelId && response.models[modelId]) {
-						const updatedConfig = {
-							...apiConfiguration,
-							[modelInfoField]: response.models[modelId],
-						}
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
 						await controller.postStateToWebview()
 					}
 				} else {
 					// Shared models: update both plan and act modes
 					const planModelId = apiConfiguration.planModeGroqModelId
 					const actModelId = apiConfiguration.actModeGroqModelId
-					const updatedConfig = { ...apiConfiguration }
+					const updates: Partial<GlobalStateAndSettings> = {}
 
 					// Update plan mode model info if we have a model ID
-					if (planModelId && response.models[planModelId]) {
-						updatedConfig.planModeGroqModelInfo = response.models[planModelId]
+					if (planModelId && models[planModelId]) {
+						updates.planModeGroqModelInfo = models[planModelId]
 					}
 
 					// Update act mode model info if we have a model ID
-					if (actModelId && response.models[actModelId]) {
-						updatedConfig.actModeGroqModelInfo = response.models[actModelId]
+					if (actModelId && models[actModelId]) {
+						updates.actModeGroqModelInfo = models[actModelId]
 					}
 
 					// Post state update if we updated any model info
-					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (Object.keys(updates).length > 0) {
+						controller.stateManager.setGlobalStateBatch(updates)
 						await controller.postStateToWebview()
 					}
 				}
 			}
 		})
 
-		refreshBasetenModels(controller, EmptyRequest.create()).then(async (response) => {
-			if (response && response.models) {
+		refreshBasetenModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
 				// Update model info in state for Baseten (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const apiConfiguration = controller.stateManager.getApiConfiguration()
 				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
@@ -131,8 +124,8 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 					const modelInfoField = currentMode === "plan" ? "planModeBasetenModelInfo" : "actModeBasetenModelInfo"
 					const modelId = apiConfiguration[modelIdField]
 
-					if (modelId && response.models[modelId]) {
-						controller.stateManager.setGlobalState(modelInfoField, response.models[modelId])
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
 						await controller.postStateToWebview()
 					}
 				} else {
@@ -141,17 +134,17 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 					const actModelId = apiConfiguration.actModeBasetenModelId
 
 					// Update plan mode model info if we have a model ID
-					if (planModelId && response.models[planModelId]) {
-						controller.stateManager.setGlobalState("planModeBasetenModelInfo", response.models[planModelId])
+					if (planModelId && models[planModelId]) {
+						controller.stateManager.setGlobalState("planModeBasetenModelInfo", models[planModelId])
 					}
 
 					// Update act mode model info if we have a model ID
-					if (actModelId && response.models[actModelId]) {
-						controller.stateManager.setGlobalState("actModeBasetenModelInfo", response.models[actModelId])
+					if (actModelId && models[actModelId]) {
+						controller.stateManager.setGlobalState("actModeBasetenModelInfo", models[actModelId])
 					}
 
 					// Post state update if we updated any model info
-					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
+					if ((planModelId && models[planModelId]) || (actModelId && models[actModelId])) {
 						await controller.postStateToWebview()
 					}
 				}
@@ -159,8 +152,8 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 		})
 
 		// Refresh Vercel AI Gateway models from API
-		refreshVercelAiGatewayModels(controller, EmptyRequest.create()).then(async (response) => {
-			if (response && response.models) {
+		refreshVercelAiGatewayModels(controller).then(async (models) => {
+			if (models && Object.keys(models).length > 0) {
 				// Update model info in state for Vercel AI Gateway (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const apiConfiguration = controller.stateManager.getApiConfiguration()
 				const planActSeparateModelsSetting = controller.stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
@@ -174,33 +167,29 @@ export async function initializeWebview(controller: Controller, _request: EmptyR
 						currentMode === "plan" ? "planModeVercelAiGatewayModelInfo" : "actModeVercelAiGatewayModelInfo"
 					const modelId = apiConfiguration[modelIdField]
 
-					if (modelId && response.models[modelId]) {
-						const updatedConfig = {
-							...apiConfiguration,
-							[modelInfoField]: response.models[modelId],
-						}
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (modelId && models[modelId]) {
+						controller.stateManager.setGlobalState(modelInfoField, models[modelId])
 						await controller.postStateToWebview()
 					}
 				} else {
 					// Shared models: update both plan and act modes
 					const planModelId = apiConfiguration.planModeVercelAiGatewayModelId
 					const actModelId = apiConfiguration.actModeVercelAiGatewayModelId
-					const updatedConfig = { ...apiConfiguration }
+					const updates: Partial<GlobalStateAndSettings> = {}
 
 					// Update plan mode model info if we have a model ID
-					if (planModelId && response.models[planModelId]) {
-						updatedConfig.planModeVercelAiGatewayModelInfo = response.models[planModelId]
+					if (planModelId && models[planModelId]) {
+						updates.planModeVercelAiGatewayModelInfo = models[planModelId]
 					}
 
 					// Update act mode model info if we have a model ID
-					if (actModelId && response.models[actModelId]) {
-						updatedConfig.actModeVercelAiGatewayModelInfo = response.models[actModelId]
+					if (actModelId && models[actModelId]) {
+						updates.actModeVercelAiGatewayModelInfo = models[actModelId]
 					}
 
 					// Post state update if we updated any model info
-					if ((planModelId && response.models[planModelId]) || (actModelId && response.models[actModelId])) {
-						controller.stateManager.setApiConfiguration(updatedConfig)
+					if (Object.keys(updates).length > 0) {
+						controller.stateManager.setGlobalStateBatch(updates)
 						await controller.postStateToWebview()
 					}
 				}

src/core/hooks/__tests__/fixtures/README.md

@@ -118,6 +118,20 @@ For more control, you can also manually copy fixture files.
 - **Behavior**: Prints error to stderr and exits with code 1
 - **Use for**: Testing error handling in UserPromptSubmit
 
+### TaskStart Hooks
+
+#### `hooks/taskstart/success`
+- **Returns**: `{ shouldContinue: true, contextModification: "TaskStart hook executed successfully", errorMessage: "" }`
+- **Use for**: Testing TaskStart hook success path, allowing task to proceed
+
+#### `hooks/taskstart/blocking`
+- **Returns**: `{ shouldContinue: false, contextModification: "", errorMessage: "Task execution blocked by hook" }`
+- **Use for**: Testing task blocking at start (e.g., policy enforcement)
+
+#### `hooks/taskstart/error`
+- **Behavior**: Prints error to stderr and exits with code 1
+- **Use for**: Testing error handling in TaskStart hooks
+
 ## Platform Considerations
 
 These fixtures are designed for the embedded shell architecture (similar to git hooks). They work uniformly across all platforms once the embedded shell is implemented.

src/core/hooks/__tests__/fixtures/hooks/taskcancel/error/TaskCancel

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.error("Hook execution error");
+process.exit(1);

src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-no-error/TaskCancel

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  shouldContinue: false,
+  errorMessage: ""
+}));

src/core/hooks/__tests__/fixtures/hooks/taskcancel/false-with-error/TaskCancel

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  shouldContinue: false,
+  errorMessage: "some error happened"
+}));

src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-no-error/TaskCancel

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  shouldContinue: true,
+  errorMessage: ""
+}));

src/core/hooks/__tests__/fixtures/hooks/taskcancel/true-with-error/TaskCancel

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Note: For TaskCancel, contextModification is completely ignored.
+
+console.log(JSON.stringify({
+  shouldContinue: true,
+  errorMessage: "some error happened"
+}));

src/core/hooks/__tests__/fixtures/hooks/taskresume/context-deleted/TaskResume

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const deleted = input.taskResume?.previousState?.conversationHistoryDeleted === 'true';
+
+console.log(JSON.stringify({
+  shouldContinue: true,
+  contextModification: deleted
+    ? "TASK_CONTEXT: Some conversation history was truncated due to context window limits"
+    : "",
+  errorMessage: ""
+}));

src/core/hooks/__tests__/fixtures/hooks/taskresume/context-injection/TaskResume

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const input = JSON.parse(require('fs').readFileSync(0, 'utf-8'));
+const taskId = input.taskResume?.taskMetadata?.taskId || 'unknown';
+
+console.log(JSON.stringify({
+  shouldContinue: true,
+  contextModification: `WORKSPACE_RULES: Task ${taskId} resumed - review previous context`,
+  errorMessage: ""
+}));