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

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

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

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

.changeset/bitter-maps-leave.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added getCwdHash proto

.changeset/breezy-bushes-raise.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-add OpenTelemetry integration

.changeset/calm-experts-think.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-removed multi-root feature flag

.changeset/cli-version-injection.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add version information injection to CLI build script. The CLI binaries now include version, commit hash, build date, and builder information extracted from package.json and git, improving debugging and version tracking capabilities.

.changeset/dry-scissors-know.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Baseten Provider Model APIs Deprecation

.changeset/fruity-crabs-mate.md

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

.changeset/fruity-tigers-wait.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added updateApiConfigurationPartial with FieldMask to allow for partial ApiProvider updates

.changeset/lucky-mayflies-arrive.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add auto-retry with exponential backof for failed API requests

.changeset/short-carrots-tie.md

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

.changeset/silent-grapes-cough.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Added subscribeToCheckpoints proto

.changeset/smooth-items-hammer.md

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

.changeset/three-groups-grin.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add UserAgent to Bedrock Client

.changeset/three-humans-type.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-auto-cleanup stale default instance config

.changeset/wet-islands-film.md

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

.changeset/yellow-pens-behave.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Add interactive provider configuration wizard with add/list capabilities, support for 8 API providers (Anthropic, OpenAI, OpenAI Native, OpenRouter, X AI, AWS Bedrock, Google Gemini, Ollama), and UpdateSettings gRPC implementation for persisting configurations to Cline Core state.

.clinerules/hooks/PostToolUse.example.cmd

@@ -1,16 +0,0 @@
-@echo off
-REM PostToolUse Hook Example - Windows Batch Version
-REM 
-REM This hook runs AFTER a tool is executed. It can:
-REM 1. Observe tool results and outcomes
-REM 2. Add context for FUTURE tool uses via contextModification
-REM 3. Log or track tool usage patterns
-REM
-REM IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-REM The tool has already completed when this hook runs.
-
-REM Simple example: Always allow continuation
-echo {"shouldContinue": true}
-
-REM To add context based on results, use:
-REM echo {"shouldContinue": true, "contextModification": "TOOL_RESULT: Operation completed successfully"}

.clinerules/hooks/PreToolUse.advanced.example.cmd

@@ -1,38 +0,0 @@
-@echo off
-REM PreToolUse Hook - Advanced Example with Input Parsing
-REM This version reads and parses the JSON input from stdin using PowerShell
-
-setlocal enabledelayedexpansion
-
-REM Read all input from stdin using PowerShell
-for /f "usebackq delims=" %%i in (`powershell -NoProfile -Command "[Console]::In.ReadToEnd()"`) do set "INPUT=%%i"
-
-REM Parse JSON and make decisions using PowerShell
-REM Note: We use -replace to handle special characters in the input
-powershell -NoProfile -Command ^
-  "$input = '%INPUT%' -replace \"'\", \"''\"; ^
-   try { ^
-     $json = $input | ConvertFrom-Json; ^
-     $toolName = $json.preToolUse.toolName; ^
-     $shouldBlock = $false; ^
-     $errorMsg = ''; ^
-     $context = ''; ^
-     if ($toolName -eq 'write_to_file') { ^
-       $path = $json.preToolUse.parameters.path; ^
-       if ($path -match '\\.js$') { ^
-         $shouldBlock = $true; ^
-         $errorMsg = 'Cannot create .js files in TypeScript project'; ^
-         $context = 'WORKSPACE_RULES: Use .ts/.tsx extensions only'; ^
-       } ^
-     } ^
-     $output = @{ ^
-       shouldContinue = -not $shouldBlock; ^
-     }; ^
-     if ($errorMsg) { $output.errorMessage = $errorMsg }; ^
-     if ($context) { $output.contextModification = $context }; ^
-     $output | ConvertTo-Json -Compress; ^
-   } catch { ^
-     @{ shouldContinue = $true } | ConvertTo-Json -Compress; ^
-   }"
-
-endlocal

.clinerules/hooks/PreToolUse.example.cmd

@@ -1,15 +0,0 @@
-@echo off
-REM PreToolUse Hook Example - Windows Batch Version
-REM 
-REM This hook runs BEFORE a tool is executed. It can:
-REM 1. Block execution by returning {"shouldContinue": false}
-REM 2. Add context for FUTURE tool uses via contextModification
-REM 3. Validate tool parameters
-REM
-REM IMPORTANT: Context injection affects FUTURE AI decisions, not the current tool execution.
-
-REM Simple example: Always allow execution with workspace context
-echo {"shouldContinue": true, "contextModification": "WORKSPACE_RULES: This is a TypeScript project. Use .ts/.tsx extensions for new files."}
-
-REM To block execution, use:
-REM echo {"shouldContinue": false, "errorMessage": "Operation not allowed"}

.clinerules/hooks/README.md

@@ -2,7 +2,11 @@
 
 ## Overview
 
-Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks are placed in the `.clinerules/hooks/` directory and run automatically when enabled.
+Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks can be placed in either:
+- **Global hooks directory**: `~/Documents/Cline/Rules/Hooks/` (applies to all workspaces)
+- **Workspace hooks directory**: `.clinerules/hooks/` (applies to specific workspace)
+
+Hooks run automatically when enabled.
 
 ## Enabling Hooks
 
@@ -16,59 +20,53 @@ Cline hooks allow you to execute custom scripts at specific points in the agenti
 ### PreToolUse Hook
 - **When**: Runs BEFORE a tool is executed
 - **Purpose**: Validate parameters, block execution, or add context
-- **File**: `.clinerules/hooks/PreToolUse` (Unix/Linux/macOS) or `.clinerules/hooks/PreToolUse.bat/.cmd/.exe` (Windows)
+- **Global Location**: `~/Documents/Cline/Rules/Hooks/PreToolUse` (all platforms)
+- **Workspace Location**: `.clinerules/hooks/PreToolUse` (all platforms)
 
 ### PostToolUse Hook
 - **When**: Runs AFTER a tool completes
 - **Purpose**: Observe results, track patterns, or add context
-- **File**: `.clinerules/hooks/PostToolUse` (Unix/Linux/macOS) or `.clinerules/hooks/PostToolUse.bat/.cmd/.exe` (Windows)
+- **Global Location**: `~/Documents/Cline/Rules/Hooks/PostToolUse` (all platforms)
+- **Workspace Location**: `.clinerules/hooks/PostToolUse` (all platforms)
 
-## Platform-Specific Guidance
+## Cross-Platform Hook Format
 
-### Windows Hooks
+Cline uses a git-style approach for hooks that works consistently across all platforms:
 
-Windows hooks use different file extensions and syntax than Unix hooks. Cline automatically searches for hooks using your system's `PATHEXT` environment variable (typically `.COM;.EXE;.BAT;.CMD;.VBS;.JS;.WSF;.MSC`).
+### Hook Files (All Platforms)
+- **No file extensions**: Hooks are named exactly `PreToolUse` or `PostToolUse` (no `.bat`, `.cmd`, `.sh` etc.)
+- **Shebang required**: First line must be a shebang (e.g., `#!/usr/bin/env bash` or `#!/usr/bin/env node`)
+- **Executable on Unix**: On Unix/Linux/macOS, hooks must be executable: `chmod +x PreToolUse`
+- **Windows**: No special permissions needed - hooks are executed through the shell
 
-**Recommended approach for Windows:**
-- Use `.cmd` or `.bat` batch files (most compatible)
-- See `PreToolUse.example.cmd` and `PostToolUse.example.cmd` for simple examples
-- See `PreToolUse.advanced.example.cmd` for PowerShell-based JSON parsing
+### How It Works
 
-**Simple Windows Hook Example:**
-```batch
-@echo off
-REM Always allow execution with context
-echo {"shouldContinue": true, "contextModification": "WORKSPACE_RULES: TypeScript project"}
+Like git hooks, Cline executes hook files through a shell that interprets the shebang line:
+- On Unix/Linux/macOS: Native shell execution with shebang support
+- On Windows: Shell execution handles shebang interpretation
+
+This means:
+- ✅ Same hook script works on all platforms
+- ✅ Write once, run anywhere
+- ✅ Use any scripting language (bash, node, python, etc.)
+
+### Creating Hooks
+
+**On Unix/Linux/macOS:**
+```bash
+# Create hook file
+nano ~/Documents/Cline/Rules/Hooks/PreToolUse
+
+# Make executable
+chmod +x ~/Documents/Cline/Rules/Hooks/PreToolUse
 ```
 
-**Advanced Windows Hook with Input Parsing:**
+**On Windows:**
 ```batch
-@echo off
-setlocal enabledelayedexpansion
-
-REM Read stdin using PowerShell
-for /f "usebackq delims=" %%i in (`powershell -Command "[Console]::In.ReadToEnd()"`) do set "INPUT=%%i"
-
-REM Parse and process JSON
-powershell -Command ^
-  "$json = '%INPUT%' | ConvertFrom-Json; ^
-   $output = @{shouldContinue = $true}; ^
-   $output | ConvertTo-Json -Compress"
+REM Create hook file (note: no file extension)
+notepad %USERPROFILE%\Documents\Cline\Rules\Hooks\PreToolUse
 ```
 
-**Tips for Windows:**
-- Batch files don't require `chmod +x` - they're executable by default
-- Use `REM` for comments instead of `#`
-- PowerShell is available on all modern Windows systems
-- For complex logic, consider PowerShell scripts (`.ps1`) or compiled executables (`.exe`)
-
-### Unix/Linux/macOS Hooks
-
-Unix hooks are shell scripts without file extensions:
-- Must be executable: `chmod +x PreToolUse`
-- Must include shebang: `#!/usr/bin/env bash` or `#!/usr/bin/env node`
-- See `PreToolUse.example` and `PostToolUse.example` for bash examples
-
 ## Context Injection Timing
 
 **IMPORTANT**: Context injected by hooks affects **FUTURE AI decisions**, not the current tool execution.
@@ -244,14 +242,101 @@ echo "$input" >> ~/.cline/hook-logs/tool-usage.jsonl
 echo '{"shouldContinue": true}'
 ```
 
+## Global vs Workspace Hooks
+
+Cline supports two levels of hooks:
+
+### Global Hooks
+- **Location**: `~/Documents/Cline/Rules/Hooks/` (macOS/Linux) or `%USERPROFILE%\Documents\Cline\Rules\Hooks\` (Windows)
+- **Scope**: Apply to ALL workspaces and projects
+- **Use Case**: Organization-wide policies, personal preferences, universal validations
+- **Priority**: Execute FIRST, before workspace hooks
+
+### Workspace Hooks
+- **Location**: `.clinerules/hooks/` in each workspace root
+- **Scope**: Apply only to the specific workspace
+- **Use Case**: Project-specific rules, team conventions, repository requirements
+- **Priority**: Execute AFTER global hooks
+
+### Hook Execution
+
+When multiple hooks exist (global and/or workspace):
+- All hooks for a given step (PreToolUse or PostToolUse) are executed
+- **Execution order is not guaranteed** - hooks may run concurrently
+- If ALL hooks allow execution (`shouldContinue: true`), the tool proceeds
+- If ANY hook blocks (`shouldContinue: false`), execution is blocked
+
+**Result Combination:**
+- `shouldContinue`: Must be `true` from ALL hooks for execution to proceed
+- `contextModification`: All context strings are concatenated
+- `errorMessage`: All error messages are concatenated
+
+### Setting Up Global Hooks
+
+1. The global hooks directory is automatically created at:
+   - macOS/Linux: `~/Documents/Cline/Rules/Hooks/`
+   - Windows: `%USERPROFILE%\Documents\Cline\Rules\Hooks\`
+
+2. Add your hook script:
+   ```bash
+   # Unix/Linux/macOS
+   nano ~/Documents/Cline/Rules/Hooks/PreToolUse
+   chmod +x ~/Documents/Cline/Rules/Hooks/PreToolUse
+   
+   # Windows
+   notepad %USERPROFILE%\Documents\Cline\Rules\Hooks\PreToolUse
+   ```
+
+3. Enable hooks in Cline settings
+
+### Example: Global + Workspace Hooks
+
+**Global Hook** (applies to all projects):
+```bash
+#!/usr/bin/env bash
+# ~/Documents/Cline/Rules/Hooks/PreToolUse
+# Universal rule: Never delete package.json
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *"package.json"* ]]; then
+  echo '{"shouldContinue": false, "errorMessage": "Global policy: Cannot modify package.json"}'
+  exit 0
+fi
+
+echo '{"shouldContinue": true}'
+```
+
+**Workspace Hook** (applies to specific project):
+```bash
+#!/usr/bin/env bash
+# .clinerules/hooks/PreToolUse
+# Project rule: Only TypeScript files
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
+  echo '{"shouldContinue": false, "errorMessage": "Project rule: Use .ts files only"}'
+  exit 0
+fi
+
+echo '{"shouldContinue": true}'
+```
+
+**All hooks must allow execution for the tool to proceed.** Hooks may execute concurrently.
+
 ## Multi-Root Workspaces
 
-If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks will run and their results will be combined:
+If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks (global and workspace) may execute concurrently. Their results will be combined:
 
 - **shouldContinue**: If ANY hook returns false, execution is blocked
 - **contextModification**: All context modifications are concatenated
 - **errorMessage**: All error messages are concatenated
 
+**Note:** No execution order is guaranteed between hooks from different directories.
+
 ## Troubleshooting
 
 ### Hook Not Running

.env.example

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

.github/workflows/release-standalone.yml

@@ -1,183 +0,0 @@
-name: Release Standalone CLI
-
-on:
-  push:
-    tags:
-      - 'v*.*.*'
-  workflow_dispatch:
-    inputs:
-      version:
-        description: 'Version to release (e.g., v3.32.6)'
-        required: true
-        type: string
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    name: Build ${{ matrix.platform }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: macos-13
-            platform: darwin-x64
-            arch: x64
-          - os: macos-14
-            platform: darwin-arm64
-            arch: arm64
-          - os: ubuntu-latest
-            platform: linux-x64
-            arch: x64
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          cache: 'npm'
-      
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.24'
-          cache-dependency-path: cli/go.sum
-      
-      - name: Install dependencies
-        run: npm ci
-      
-      - name: Install webview dependencies
-        run: cd webview-ui && npm ci
-      
-      - name: Download Node.js binaries
-        run: npm run download-node
-
-      - name: Download ripgrep binaries
-        run: npm run download-ripgrep
-
-      - name: Build CLI binaries
-        run: npm run compile-cli
-      
-      - name: Build standalone CLI package
-        run: npm run compile-standalone-cli
-        env:
-          NODE_ENV: production
-      
-      - name: Get version
-        id: version
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT
-          else
-            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          fi
-      
-      - name: Rename package
-        run: |
-          cd dist-standalone
-          mv standalone-cli.zip cline-${{ steps.version.outputs.version }}-${{ matrix.platform }}.tar.gz
-      
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: cline-${{ matrix.platform }}
-          path: dist-standalone/cline-${{ steps.version.outputs.version }}-${{ matrix.platform }}.tar.gz
-          retention-days: 1
-
-  release:
-    name: Create Release
-    needs: build
-    runs-on: ubuntu-latest
-    environment: publish
-    
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: artifacts
-      
-      - name: Get version
-        id: version
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT
-          else
-            echo "version=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          fi
-      
-      - name: Display structure
-        run: ls -R artifacts/
-      
-      - name: Create Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ steps.version.outputs.version }}
-          name: Cline CLI ${{ steps.version.outputs.version }}
-          draft: false
-          prerelease: false
-          generate_release_notes: true
-          files: |
-            artifacts/cline-darwin-x64/cline-${{ steps.version.outputs.version }}-darwin-x64.tar.gz
-            artifacts/cline-darwin-arm64/cline-${{ steps.version.outputs.version }}-darwin-arm64.tar.gz
-            artifacts/cline-linux-x64/cline-${{ steps.version.outputs.version }}-linux-x64.tar.gz
-          body: |
-            ## Installation
-            
-            Install Cline CLI with a single command:
-            
-            ```bash
-            curl -fsSL https://raw.githubusercontent.com/cline/cline/main/scripts/install.sh | bash
-            ```
-            
-            ### Platform-Specific Downloads
-            
-            - **macOS (Intel)**: `cline-${{ steps.version.outputs.version }}-darwin-x64.tar.gz`
-            - **macOS (Apple Silicon)**: `cline-${{ steps.version.outputs.version }}-darwin-arm64.tar.gz`
-            - **Linux (x64)**: `cline-${{ steps.version.outputs.version }}-linux-x64.tar.gz`
-            
-            ### Manual Installation
-            
-            1. Download the appropriate package for your platform
-            2. Extract: `tar -xzf cline-*.tar.gz`
-            3. Move to installation directory: `mv cline-* ~/.cline`
-            4. Add to PATH: `export PATH="$HOME/.cline/bin:$PATH"`
-            
-            ### What's Included
-
-            - ✅ Node.js v22.15.0 (bundled)
-            - ✅ Cline CLI binary
-            - ✅ Cline Host bridge
-            - ✅ Cline Core (TypeScript compiled)
-            - ✅ Ripgrep v14.1.1 (for file searching)
-            - ✅ All dependencies
-            
-            ### Getting Started
-            
-            ```bash
-            # Verify installation
-            cline version
-            
-            # Sign in
-            cline auth login
-            
-            # Get help
-            cline --help
-            ```
-            
-            ### Documentation
-            
-            - [Installation Guide](https://docs.cline.bot/getting-started/installing-cline)
-            - [CLI Documentation](https://docs.cline.bot/exploring-clines-tools/cline-tools-guide)
-            - [GitHub Repository](https://github.com/cline/cline)
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
-          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
-          CLINE_ENVIRONMENT: production

.github/workflows/test.yml

@@ -193,17 +193,14 @@ jobs:
                   go-version: '1.24'
                   cache-dependency-path: cli/go.sum
 
-            - name: Download Node.js binaries
-              run: npm run download-node
-
             - name: Build CLI binaries
-              run: npm run compile-cli
+              run: npm run compile-cli-all-platforms
 
             - name: Download ripgrep binaries
               run: npm run download-ripgrep
 
-            - name: Compile standalone CLI
-              run: npm run compile-standalone-cli
+            - name: Compile NPM package
+              run: npm run compile-standalone-npm
 
             - name: Install testing platform dependencies
               if: steps.testing-platform-cache.outputs.cache-hit != 'true'

.vscodeignore

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

CHANGELOG.md

@@ -1,5 +1,25 @@
 # 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 Subagent support (Experimental)
+- Added Multi-Root Workspaces support (Enable in feature settings)
+- Add auto-retry with exponential backof for failed API requests
+
+## [3.32.8]
+
+- Add Claude Haiku 4.5 support
+
 ## [3.32.7]
 
 - Add JP and Global inference profile options to AWS Bedrock

cli/.gitignore

@@ -1,2 +1,2 @@
 cline-core-debug.log
-bin/*
+bin/*

cli/README.md

@@ -0,0 +1,72 @@
+# Cline CLI
+
+```
+/_____/\ /_/\      /_______/\/__/\ /__/\ /_____/\
+\:::__\/ \:\ \     \__.::._\/\::\_\\  \ \\::::_\/_
+ \:\ \  __\:\ \       \::\ \  \:. `-\  \ \\:\/___/\
+  \:\ \/_/\\:\ \____  _\::\ \__\:. _    \ \\::___\/_
+   \:\_\ \ \\:\/___/\/__\::\__/\\. \`-\  \ \\:\____/\
+    \_____\/ \_____\/\________\/ \__\/ \__\/ \_____\/
+```
+
+Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more.
+
+## Installation
+
+Install Cline globally using npm:
+
+```bash
+npm install -g cline
+```
+
+## Usage
+
+```bash
+cline
+```
+
+This will start the Cline CLI interface where you can interact with the autonomous coding agent.
+
+## Features
+
+-   **Autonomous Coding**: AI-powered code generation, editing, and refactoring
+-   **File Operations**: Create, read, update, and delete files and directories
+-   **Command Execution**: Run shell commands and scripts
+-   **Browser Automation**: Interact with web pages and applications
+-   **Multi-Model Support**: Works with Anthropic Claude, OpenAI GPT, and other AI models
+-   **MCP Integration**: Extensible through Model Context Protocol servers
+-   **Project Understanding**: Analyzes codebases to provide context-aware assistance
+
+## Requirements
+
+-   Node.js 18.0.0 or higher
+-   Supported platforms: macOS, Linux. Windows soon
+-   Supported architectures: x64, arm64
+
+## Configuration
+
+Cline can be configured through:
+
+-   Environment variables
+-   Configuration files
+-   Command-line arguments
+
+See the [main documentation](https://cline.bot) for detailed configuration options.
+
+## Links
+
+-   **Website**: [https://cline.bot](https://cline.bot)
+-   **Documentation**: [https://docs.cline.bot](https://docs.cline.bot)
+-   **GitHub**: [https://github.com/cline/cline](https://github.com/cline/cline)
+-   **VSCode Extension**: Available in the VSCode Marketplace
+-   **JetBrains Extension**: Available in the JetBrains Marketplace
+
+## License
+
+Apache-2.0 - see [LICENSE](https://github.com/cline/cline/blob/main/LICENSE) for details.
+
+## Support
+
+-   Report issues: [GitHub Issues](https://github.com/cline/cline/issues)
+-   Community: [GitHub Discussions](https://github.com/cline/cline/discussions)
+-   Documentation: [docs.cline.bot](https://docs.cline.bot)

cli/cline-text-logo.txt

@@ -1,6 +0,0 @@
-/_____/\ /_/\      /_______/\/__/\ /__/\ /_____/\     
-\:::__\/ \:\ \     \__.::._\/\::\_\\  \ \\::::_\/_    
- \:\ \  __\:\ \       \::\ \  \:. `-\  \ \\:\/___/\   
-  \:\ \/_/\\:\ \____  _\::\ \__\:. _    \ \\::___\/_  
-   \:\_\ \ \\:\/___/\/__\::\__/\\. \`-\  \ \\:\____/\ 
-    \_____\/ \_____\/\________\/ \__\/ \__\/ \_____\/ 

cli/cmd/cline/main.go

@@ -4,10 +4,12 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 
 	"github.com/charmbracelet/huh"
+	"github.com/charmbracelet/lipgloss"
 	"github.com/cline/cli/pkg/cli"
 	"github.com/cline/cli/pkg/cli/auth"
 	"github.com/cline/cli/pkg/cli/display"
@@ -23,12 +25,12 @@ var (
 	outputFormat string
 
 	// Task creation flags (for root command)
-	images     []string
-	files      []string
-	workspaces []string
-	mode       string
-	settings   []string
-	yolo       bool
+	images   []string
+	files    []string
+	mode     string
+	settings []string
+	yolo     bool
+	oneshot  bool
 )
 
 func main() {
@@ -40,10 +42,17 @@ func main() {
 Start a new task by providing a prompt:
   cline "Create a new Python script that prints hello world"
 
+Or pipe a prompt via stdin:
+  echo "Create a todo app" | cline
+  cat prompt.txt | cline --yolo
+
 Or run with no arguments to enter interactive mode:
   cline
 
-This CLI also provides task management, configuration, and monitoring capabilities.`,
+This CLI also provides task management, configuration, and monitoring capabilities.
+
+For detailed documentation including all commands, options, and examples,
+see the manual page: man cline`,
 		Args: cobra.ArbitraryArgs,
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
 			if outputFormat != "rich" && outputFormat != "json" && outputFormat != "plain" {
@@ -92,12 +101,13 @@ This CLI also provides task management, configuration, and monitoring capabiliti
 				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
+						if err == huh.ErrUserAborted {
+							return nil
+						}
 						return fmt.Errorf("auth setup failed: %w", err)
 					}
 
@@ -106,25 +116,28 @@ This CLI also provides task management, configuration, and monitoring capabiliti
 						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
 				instanceAddress = coreAddress
 			}
 
-			var prompt string
+			// Get content from both args and stdin
+			prompt, err := getContentFromStdinAndArgs(args)
+			if err != nil {
+				return fmt.Errorf("failed to read prompt: %w", err)
+			}
 
-			// If args provided, use as prompt
-			if len(args) > 0 {
-				prompt = strings.Join(args, " ")
-			} else {
-				// Show interactive input to get prompt
-				var err error
-				prompt, err = promptForInitialTask()
+			// If no prompt from args or stdin, show interactive input
+			if prompt == "" {
+				// Pass the mode flag to banner so it shows correct mode
+				prompt, err = promptForInitialTask(ctx, instanceAddress, mode)
 				if err != nil {
+					// Check if user cancelled - exit cleanly without error
+					if err == huh.ErrUserAborted {
+						return nil
+					}
 					return err
 				}
 				if prompt == "" {
@@ -132,46 +145,68 @@ This CLI also provides task management, configuration, and monitoring capabiliti
 				}
 			}
 
+			// If oneshot mode, force plan mode and yolo
+			if oneshot {
+				mode = "plan"
+				yolo = true
+			}
+
 			return cli.CreateAndFollowTask(ctx, prompt, cli.TaskOptions{
-				Images:     images,
-				Files:      files,
-				Workspaces: workspaces,
-				Mode:       mode,
-				Settings:   settings,
-				Yolo:       yolo,
-				Address:    instanceAddress,
+				Images:   images,
+				Files:    files,
+				Mode:     mode,
+				Settings: settings,
+				Yolo:     yolo,
+				Address:  instanceAddress,
+				Verbose:  verbose,
 			})
 		},
 	}
 
 	rootCmd.PersistentFlags().StringVar(&coreAddress, "address", fmt.Sprintf("localhost:%d", common.DEFAULT_CLINE_CORE_PORT), "Cline Core gRPC address")
 	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose output")
-	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "rich", "output format (rich|json|plain)")
+	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "F", "rich", "output format (rich|json|plain)")
 
 	// Task creation flags (only apply when using root command with prompt)
 	rootCmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
 	rootCmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	rootCmd.Flags().StringSliceVarP(&workspaces, "workdir", "w", nil, "workdir directory paths")
 	rootCmd.Flags().StringVarP(&mode, "mode", "m", "plan", "mode (act|plan) - defaults to plan")
 	rootCmd.Flags().StringSliceVarP(&settings, "setting", "s", nil, "task settings (key=value format)")
 	rootCmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
+	rootCmd.Flags().BoolVar(&yolo, "no-interactive", false, "enable yolo mode (non-interactive)")
+	rootCmd.Flags().BoolVarP(&oneshot, "oneshot", "o", false, "full autonomous mode")
 
 	rootCmd.AddCommand(cli.NewTaskCommand())
 	rootCmd.AddCommand(cli.NewInstanceCommand())
 	rootCmd.AddCommand(cli.NewConfigCommand())
 	rootCmd.AddCommand(cli.NewVersionCommand())
 	rootCmd.AddCommand(cli.NewAuthCommand())
-	rootCmd.AddCommand(cli.NewTaskSendCommand())
 	rootCmd.AddCommand(cli.NewLogsCommand())
+	rootCmd.AddCommand(cli.NewDoctorCommand())
 
 	if err := rootCmd.ExecuteContext(context.Background()); err != nil {
 		os.Exit(1)
 	}
 }
 
-func promptForInitialTask() (string, error) {
+func promptForInitialTask(ctx context.Context, instanceAddress, modeFlag string) (string, error) {
+	// Show session banner before the initial input
+	showSessionBanner(ctx, instanceAddress, modeFlag)
+
 	var prompt string
 
+	// Create custom theme with mode-colored cursor and title
+	theme := huh.ThemeCharm()
+
+	// Set cursor and title color based on mode
+	modeColor := lipgloss.Color("3") // Yellow for plan
+	if modeFlag == "act" {
+		modeColor = lipgloss.Color("39") // Blue for act
+	}
+
+	theme.Focused.TextInput.Cursor = theme.Focused.TextInput.Cursor.Foreground(modeColor)
+	theme.Focused.Title = theme.Focused.Title.Foreground(modeColor)
+
 	form := huh.NewForm(
 		huh.NewGroup(
 			huh.NewText().
@@ -181,16 +216,64 @@ func promptForInitialTask() (string, error) {
 				Lines(5).
 				Value(&prompt),
 		),
-	)
+	).WithWidth(48).WithTheme(theme)
 
 	err := form.Run()
 	if err != nil {
+		// Check if user cancelled with Control-C
+		if err == huh.ErrUserAborted {
+			// Return a special error that indicates clean cancellation
+			// This allows deferred cleanup to run
+			return "", huh.ErrUserAborted
+		}
 		return "", err
 	}
 
 	return strings.TrimSpace(prompt), nil
 }
 
+// showSessionBanner displays session info before initial prompt
+func showSessionBanner(ctx context.Context, instanceAddress, modeFlag string) {
+	bannerInfo := display.BannerInfo{
+		Version: global.CliVersion,
+		Mode:    modeFlag, // Use the mode from command flag, not state
+	}
+
+	// If mode is empty, default to "plan"
+	if bannerInfo.Mode == "" {
+		bannerInfo.Mode = "plan"
+	}
+
+	// Get current working directory (this is what Cline will use)
+	if cwd, err := os.Getwd(); err == nil {
+		bannerInfo.Workdir = cwd
+	}
+
+	// Get provider/model using auth functions (same logic as auth menu)
+	manager, err := cli.NewTaskManagerForAddress(ctx, instanceAddress)
+	if err == nil {
+		if providerList, err := auth.GetProviderConfigurations(ctx, manager); err == nil {
+			// Show provider/model for the mode we'll be using
+			var providerDisplay *auth.ProviderDisplay
+			if bannerInfo.Mode == "plan" && providerList.PlanProvider != nil {
+				providerDisplay = providerList.PlanProvider
+			} else if bannerInfo.Mode == "act" && providerList.ActProvider != nil {
+				providerDisplay = providerList.ActProvider
+			}
+
+			if providerDisplay != nil {
+				bannerInfo.Provider = auth.GetProviderIDForEnum(providerDisplay.Provider)
+				bannerInfo.ModelID = providerDisplay.ModelID
+			}
+		}
+	}
+
+	// Render and display banner
+	banner := display.RenderSessionBanner(bannerInfo)
+	fmt.Println(banner)
+	fmt.Println() // Extra spacing before form
+}
+
 // isUserReadyToUse checks if the user has completed initial setup
 // Returns true if welcomeViewCompleted flag is set OR user is authenticated
 // Matches extension logic: welcomeViewCompleted = Boolean(globalState.welcomeViewCompleted || user?.uid)
@@ -226,3 +309,40 @@ func isUserReadyToUse(ctx context.Context, instanceAddress string) bool {
 
 	return false
 }
+
+// getContentFromStdinAndArgs reads content from both command line args and stdin, and combines them
+func getContentFromStdinAndArgs(args []string) (string, error) {
+	var content strings.Builder
+
+	// Add command line args first (if any)
+	if len(args) > 0 {
+		content.WriteString(strings.Join(args, " "))
+	}
+
+	// Check if stdin has data
+	stat, err := os.Stdin.Stat()
+	if err != nil {
+		return "", fmt.Errorf("failed to stat stdin: %w", err)
+	}
+
+	// Check if data is being piped to stdin
+	if (stat.Mode() & os.ModeCharDevice) == 0 {
+		// Only try to read if there's actually data available
+		if stat.Size() > 0 {
+			stdinBytes, err := io.ReadAll(os.Stdin)
+			if err != nil {
+				return "", fmt.Errorf("failed to read from stdin: %w", err)
+			}
+
+			stdinContent := strings.TrimSpace(string(stdinBytes))
+			if stdinContent != "" {
+				if content.Len() > 0 {
+					content.WriteString(" ")
+				}
+				content.WriteString(stdinContent)
+			}
+		}
+	}
+
+	return content.String(), nil
+}

cli/e2e/sqlite_helper.go

@@ -10,7 +10,7 @@ import (
 	"time"
 
 	"github.com/cline/cli/pkg/common"
-	_ "github.com/mattn/go-sqlite3"
+	_ "github.com/glebarez/go-sqlite"
 	"google.golang.org/grpc/health/grpc_health_v1"
 )
 
@@ -25,7 +25,7 @@ func readInstancesFromSQLite(t *testing.T, clineDir string) []common.CoreInstanc
 		return []common.CoreInstanceInfo{}
 	}
 
-	db, err := sql.Open("sqlite3", dbPath)
+	db, err := sql.Open("sqlite", dbPath)
 	if err != nil {
 		t.Logf("Warning: Failed to open SQLite database: %v", err)
 		return []common.CoreInstanceInfo{}
@@ -97,7 +97,7 @@ func readDefaultInstanceFromSettings(t *testing.T, clineDir string) string {
 func insertRemoteInstanceIntoSQLite(t *testing.T, dbPath, address string, corePort, hostPort int) error {
 	t.Helper()
 
-	db, err := sql.Open("sqlite3", dbPath)
+	db, err := sql.Open("sqlite", dbPath)
 	if err != nil {
 		return err
 	}
@@ -142,7 +142,7 @@ func insertRemoteInstanceIntoSQLite(t *testing.T, dbPath, address string, corePo
 func verifyInstanceExistsInSQLite(t *testing.T, dbPath, address string) bool {
 	t.Helper()
 
-	db, err := sql.Open("sqlite3", dbPath)
+	db, err := sql.Open("sqlite", dbPath)
 	if err != nil {
 		t.Logf("Failed to open database: %v", err)
 		return false

cli/go.mod

@@ -4,10 +4,14 @@ go 1.23.0
 
 require (
 	github.com/atotto/clipboard v0.1.4
+	github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7
+	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/mattn/go-sqlite3 v1.14.24
+	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
@@ -21,10 +25,7 @@ require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
 	github.com/aymerick/douceur v0.2.0 // indirect
 	github.com/catppuccin/go v0.3.0 // indirect
-	github.com/charmbracelet/bubbles v0.21.1-0.20250623103423-23b8fd6302d7 // indirect
-	github.com/charmbracelet/bubbletea v1.3.6 // 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
@@ -33,6 +34,7 @@ require (
 	github.com/dlclark/regexp2 v1.11.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/css v1.0.1 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
@@ -44,7 +46,7 @@ require (
 	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/muesli/reflow v0.3.0 // indirect
-	github.com/muesli/termenv v0.16.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
@@ -55,4 +57,8 @@ require (
 	golang.org/x/sys v0.33.0 // indirect
 	golang.org/x/text v0.26.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20250707201910-8d1bb00bc6a7 // indirect
+	modernc.org/libc v1.37.6 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
+	modernc.org/sqlite v1.28.0 // indirect
 )

cli/go.sum

@@ -57,6 +57,8 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
+github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
@@ -65,6 +67,8 @@ github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
@@ -82,8 +86,6 @@ github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+Ei
 github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
-github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
 github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
 github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
@@ -96,6 +98,8 @@ github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
 github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
 github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
@@ -148,3 +152,11 @@ google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9x
 google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw=
+modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
+modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
+modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
+modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
+modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
+modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
+modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=

cli/man/cline.1

@@ -0,0 +1,331 @@
+.\" Automatically generated by Pandoc 3.8.2
+.\"
+.TH "CLINE" "1" "January 2025" "Cline CLI 1.0" "User Commands"
+.SH NAME
+cline \- orchestrate and interact with Cline AI coding agents
+.SH SYNOPSIS
+\f[B]cline\f[R] [\f[I]prompt\f[R]] [\f[I]options\f[R]]
+.PP
+\f[B]cline\f[R] \f[I]command\f[R] [\f[I]subcommand\f[R]]
+[\f[I]options\f[R]] [\f[I]arguments\f[R]]
+.SH DESCRIPTION
+Try: cat README.md | cline \(lqSummarize this for me:\(rq
+.PP
+\f[B]cline\f[R] 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 \f[B]Cline
+Core\f[R] runs as a standalone service, and the CLI acts as a scriptable
+interface for managing tasks, instances, and agent interactions.
+.PP
+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.
+.SH MODES OF OPERATION
+.TP
+\f[B]Instant Task Mode\f[R]
+The simplest invocation: \f[B]cline \(lqprompt here\(rq\f[R] immediately
+spawns an instance, creates a task, and enters chat mode.
+This is equivalent to running \f[B]cline instance new && cline task new
+&& cline task chat\f[R] in sequence.
+.TP
+\f[B]Subcommand Mode\f[R]
+Advanced usage with explicit control: \f[B]cline <command> [subcommand]
+[options]\f[R] provides fine\-grained control over instances, tasks,
+authentication, and configuration.
+.SH AGENT BEHAVIOR
+Cline operates in two primary modes:
+.TP
+\f[B]ACT MODE\f[R]
+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.
+.TP
+\f[B]PLAN MODE\f[R]
+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.
+.SH INSTANT TASK OPTIONS
+When using the instant task syntax \f[B]cline \(lqprompt\(rq\f[R] the
+following options are available:
+.TP
+\f[B]\-o\f[R], \f[B]\-\-oneshot\f[R]
+Full autonomous mode.
+Cline completes the task and stops following after completion.
+Example: cline \-o \(lqwhat\(cqs 6 + 8?\(rq
+.TP
+\f[B]\-s\f[R], \f[B]\-\-setting\f[R] \f[I]setting\f[R] \f[I]value\f[R]
+Override a setting for this task
+.TP
+\f[B]\-y\f[R], \f[B]\-\-no\-interactive\f[R], \f[B]\-\-yolo\f[R]
+Enable fully autonomous mode.
+Disables all interactivity:
+.RS
+.IP \(bu 2
+ask_followup_question tool is disabled
+.IP \(bu 2
+attempt_completion happens automatically
+.IP \(bu 2
+execute_command runs in non\-blocking mode with timeout
+.IP \(bu 2
+PLAN MODE automatically switches to ACT MODE
+.RE
+.TP
+\f[B]\-m\f[R], \f[B]\-\-mode\f[R] \f[I]mode\f[R]
+Starting mode.
+Options: \f[B]act\f[R] (default), \f[B]plan\f[R]
+.SH GLOBAL OPTIONS
+These options apply to all subcommands:
+.TP
+\f[B]\-F\f[R], \f[B]\-\-output\-format\f[R] \f[I]format\f[R]
+Output format.
+Options: \f[B]rich\f[R] (default), \f[B]json\f[R], \f[B]plain\f[R]
+.TP
+\f[B]\-h\f[R], \f[B]\-\-help\f[R]
+Display help information for the command.
+.TP
+\f[B]\-v\f[R], \f[B]\-\-verbose\f[R]
+Enable verbose output for debugging.
+.SH COMMANDS
+.SS Authentication
+\f[B]cline auth\f[R] [\f[I]provider\f[R]] [\f[I]key\f[R]]
+.TP
+\f[B]cline a\f[R] [\f[I]provider\f[R]] [\f[I]key\f[R]]
+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.
+.SS Instance Management
+Cline Core instances are independent agent processes that can run in the
+background.
+Multiple instances can run simultaneously, enabling parallel task
+execution.
+.PP
+\f[B]cline instance\f[R]
+.TP
+\f[B]cline i\f[R]
+Display instance management help.
+.PP
+\f[B]cline instance new\f[R] [\f[B]\-d\f[R]|\f[B]\-\-default\f[R]]
+.TP
+\f[B]cline i n\f[R] [\f[B]\-d\f[R]|\f[B]\-\-default\f[R]]
+Spawn a new Cline Core instance.
+Use \f[B]\-\-default\f[R] to set it as the default instance for
+subsequent commands.
+.PP
+\f[B]cline instance list\f[R]
+.TP
+\f[B]cline i l\f[R]
+List all running Cline Core instances with their addresses and status.
+.PP
+\f[B]cline instance default\f[R] \f[I]address\f[R]
+.TP
+\f[B]cline i d\f[R] \f[I]address\f[R]
+Set the default instance to avoid specifying \f[B]\-\-address\f[R] in
+task commands.
+.PP
+\f[B]cline instance kill\f[R] \f[I]address\f[R]
+[\f[B]\-a\f[R]|\f[B]\-\-all\f[R]]
+.TP
+\f[B]cline i k\f[R] \f[I]address\f[R] [\f[B]\-a\f[R]|\f[B]\-\-all\f[R]]
+Terminate a Cline Core instance.
+Use \f[B]\-\-all\f[R] to kill all running instances.
+.SS Task Management
+Tasks represent individual work items that Cline executes.
+Tasks maintain conversation history, checkpoints, and settings.
+.PP
+\f[B]cline task\f[R] [\f[B]\-a\f[R]|\f[B]\-\-address\f[R]
+\f[I]ADDR\f[R]]
+.TP
+\f[B]cline t\f[R] [\f[B]\-a\f[R]|\f[B]\-\-address\f[R] \f[I]ADDR\f[R]]
+Display task management help.
+The \f[B]\-\-address\f[R] flag specifies which Cline Core instance to
+use (e.g., localhost:50052).
+.PP
+\f[B]cline task new\f[R] \f[I]prompt\f[R] [\f[I]options\f[R]]
+.TP
+\f[B]cline t n\f[R] \f[I]prompt\f[R] [\f[I]options\f[R]]
+Create a new task in the default or specified instance.
+Options:
+.RS
+.TP
+\f[B]\-s\f[R], \f[B]\-\-setting\f[R] \f[I]setting\f[R] \f[I]value\f[R]
+Set task\-specific settings
+.TP
+\f[B]\-y\f[R], \f[B]\-\-no\-interactive\f[R], \f[B]\-\-yolo\f[R]
+Enable autonomous mode
+.TP
+\f[B]\-m\f[R], \f[B]\-\-mode\f[R] \f[I]mode\f[R]
+Starting mode (act or plan)
+.RE
+.PP
+\f[B]cline task open\f[R] \f[I]task\-id\f[R] [\f[I]options\f[R]]
+.TP
+\f[B]cline t o\f[R] \f[I]task\-id\f[R] [\f[I]options\f[R]]
+Resume a previous task from history.
+Accepts the same options as \f[B]task new\f[R].
+.PP
+\f[B]cline task list\f[R]
+.TP
+\f[B]cline t l\f[R]
+List all tasks in history with their id and snippet
+.PP
+\f[B]cline task chat\f[R]
+.TP
+\f[B]cline t c\f[R]
+Enter interactive chat mode for the current task.
+Allows back\-and\-forth conversation with Cline.
+.PP
+\f[B]cline task send\f[R] [\f[I]message\f[R]] [\f[I]options\f[R]]
+.TP
+\f[B]cline t s\f[R] [\f[I]message\f[R]] [\f[I]options\f[R]]
+Send a message to Cline.
+If no message is provided, reads from stdin.
+Options:
+.RS
+.TP
+\f[B]\-a\f[R], \f[B]\-\-approve\f[R]
+Approve Cline\(cqs proposed action
+.TP
+\f[B]\-d\f[R], \f[B]\-\-deny\f[R]
+Deny Cline\(cqs proposed action
+.TP
+\f[B]\-f\f[R], \f[B]\-\-file\f[R] \f[I]FILE\f[R]
+Attach a file to the message
+.TP
+\f[B]\-y\f[R], \f[B]\-\-no\-interactive\f[R], \f[B]\-\-yolo\f[R]
+Enable autonomous mode
+.TP
+\f[B]\-m\f[R], \f[B]\-\-mode\f[R] \f[I]mode\f[R]
+Switch mode (act or plan)
+.RE
+.PP
+\f[B]cline task view\f[R] [\f[B]\-f\f[R]|\f[B]\-\-follow\f[R]]
+[\f[B]\-c\f[R]|\f[B]\-\-follow\-complete\f[R]]
+.TP
+\f[B]cline t v\f[R] [\f[B]\-f\f[R]|\f[B]\-\-follow\f[R]] [\f[B]\-c\f[R]|\f[B]\-\-follow\-complete\f[R]]
+Display the current conversation.
+Use \f[B]\-\-follow\f[R] to stream updates in real\-time, or
+\f[B]\-\-follow\-complete\f[R] to follow until task completion.
+.PP
+\f[B]cline task restore\f[R] \f[I]checkpoint\f[R]
+.TP
+\f[B]cline t r\f[R] \f[I]checkpoint\f[R]
+Restore the task to a previous checkpoint state.
+.PP
+\f[B]cline task pause\f[R]
+.TP
+\f[B]cline t p\f[R]
+Pause task execution.
+.SS Configuration
+Configuration can be set globally.
+Override these global settings for a task using the
+\f[B]\-\-setting\f[R] flag
+.PP
+\f[B]cline config\f[R]
+.PP
+\f[B]cline c\f[R]
+.PP
+\f[B]cline config set\f[R] \f[I]key\f[R] \f[I]value\f[R]
+.TP
+\f[B]cline c s\f[R] \f[I]key\f[R] \f[I]value\f[R]
+Set a configuration variable.
+.PP
+\f[B]cline config get\f[R] \f[I]key\f[R]
+.TP
+\f[B]cline c g\f[R] \f[I]key\f[R]
+Read a configuration variable.
+.PP
+\f[B]cline config list\f[R]
+.TP
+\f[B]cline c l\f[R]
+List all configuration variables and their values.
+.SH TASK SETTINGS
+Task settings are persisted in the \f[I]\(ti/.cline/x/tasks\f[R]
+directory.
+When resuming a task with \f[B]cline task open\f[R], task settings are
+automatically restored.
+.PP
+Common settings include:
+.TP
+\f[B]yolo\f[R]
+Enable autonomous mode (true/false)
+.TP
+\f[B]mode\f[R]
+Starting mode (act/plan)
+.SH NOTES & EXAMPLES
+The \f[B]cline task send\f[R] and \f[B]cline task new\f[R] commands
+support reading from stdin, enabling powerful pipeline compositions:
+.IP
+.EX
+cat requirements.txt \f[B]|\f[R] cline task send
+echo \(dqRefactor this code\(dq \f[B]|\f[R] cline \-y
+.EE
+.SS Instance Management
+Manage multiple Cline instances:
+.IP
+.EX
+\f[I]# Start a new instance and make it default\f[R]
+cline instance new \-\-default
+
+\f[I]# List all running instances\f[R]
+cline instance list
+
+\f[I]# Kill a specific instance\f[R]
+cline instance kill localhost:50052
+
+\f[I]# Kill all CLI instances\f[R]
+cline instance kill \-\-all\-cli
+.EE
+.SS Task History
+Work with task history:
+.IP
+.EX
+\f[I]# List previous tasks\f[R]
+cline task list
+
+\f[I]# Resume a previous task\f[R]
+cline task open 1760501486669
+
+\f[I]# View conversation history\f[R]
+cline task view
+
+\f[I]# Start interactive chat with this task\f[R]
+cline task chat
+.EE
+.SH ARCHITECTURE
+Cline operates on a three\-layer architecture:
+.TP
+\f[B]Presentation Layer\f[R]
+User interfaces (CLI, VSCode, JetBrains) that connect to Cline Core via
+gRPC
+.TP
+\f[B]Cline Core\f[R]
+The autonomous agent service handling task management, AI model
+integration, state management, tool orchestration, and real\-time
+streaming updates
+.TP
+\f[B]Host Provider Layer\f[R]
+Environment\-specific integrations (VSCode APIs, JetBrains APIs, shell
+APIs) that Cline Core uses to interact with the host system
+.SH BUGS
+Report bugs at: \c
+.UR https://github.com/cline/cline/issues
+.UE \c
+.PP
+For real\-time help, join the Discord community at: \c
+.UR https://discord.gg/cline
+.UE \c
+.SH SEE ALSO
+Full documentation: \c
+.UR https://docs.cline.bot
+.UE \c
+.SH AUTHORS
+Cline is developed by the Cline Bot Inc.\ and the open source community.
+.SH COPYRIGHT
+Copyright © 2025 Cline Bot Inc.\ Licensed under the Apache License 2.0.

cli/man/cline.1.md

@@ -0,0 +1,332 @@
+---
+title: CLINE
+section: 1
+header: User Commands
+footer: Cline CLI 1.0
+date: January 2025
+---
+
+# 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:
+
+```bash
+cat requirements.txt | cline task send
+echo "Refactor this code" | cline -y
+```
+
+## Instance Management
+
+Manage multiple Cline instances:
+
+```bash
+# 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:
+
+```bash
+# 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.

cli/package.json

@@ -0,0 +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"
+	]
+}

cli/pkg/cli/auth.go

@@ -6,12 +6,38 @@ import (
 )
 
 func NewAuthCommand() *cobra.Command {
-	return &cobra.Command{
+	cmd := &cobra.Command{
 		Use:   "auth",
-		Short: "Sign in to Cline",
-		Long:  `Complete the authentication flow in browser to sign in to Cline.`,
+		Short: "Authenticate a provider and configure what model is used",
+		Long: `Authenticate a provider and configure what model is used
+
+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
+
+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_cline_provider.go

@@ -109,13 +109,16 @@ func signIn(ctx context.Context) error {
 		return fmt.Errorf("failed to obtain client: %w", err)
 	}
 
-	_, err = client.Account.AccountLoginClicked(ctx, &cline.EmptyRequest{})
+	response, err := client.Account.AccountLoginClicked(ctx, &cline.EmptyRequest{})
 	if err != nil {
 		verboseLog("Failed to initiate login: %v", err)
 		return fmt.Errorf("failed to initiate login: %w", err)
 	}
 
 	fmt.Println("\n  Opening browser for authentication...")
+	if response != nil && response.Value != "" {
+		fmt.Printf("  If the browser doesn't open automatically, visit this URL:\n  %s\n\n", response.Value)
+	}
 	fmt.Println("  Waiting for you to complete authentication in your browser...")
 	fmt.Println("   (This may take a few moments. Timeout: 5 minutes)")
 
@@ -279,4 +282,4 @@ func HandleSelectOrganization(ctx context.Context) error {
 	}
 
 	return HandleAuthMenuNoArgs(ctx)
-}
+}

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)")
 	}
 }
 
@@ -103,7 +111,7 @@ func HandleAuthMenuNoArgs(ctx context.Context) error {
 	if manager, err := createTaskManager(ctx); err == nil {
 		if providerList, err := GetProviderConfigurations(ctx, manager); err == nil {
 			if providerList.ActProvider != nil {
-				currentProvider = getProviderDisplayName(providerList.ActProvider.Provider)
+				currentProvider = GetProviderDisplayName(providerList.ActProvider.Provider)
 				currentModel = providerList.ActProvider.ModelID
 			}
 		}
@@ -121,6 +129,10 @@ func HandleAuthMenuNoArgs(ctx context.Context) error {
 
 	action, err := ShowAuthMenuWithStatus(isClineAuth, hasOrganizations, currentProvider, currentModel)
 	if err != nil {
+		// Check if user cancelled - propagate for clean exit
+		if err == huh.ErrUserAborted {
+			return huh.ErrUserAborted
+		}
 		return err
 	}
 
@@ -161,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?
@@ -202,6 +216,11 @@ func ShowAuthMenuWithStatus(isClineAuthenticated bool, hasOrganizations bool, cu
 	)
 
 	if err := form.Run(); err != nil {
+		// Check if user cancelled with Control-C
+		if err == huh.ErrUserAborted {
+			// Return the error to allow deferred cleanup to run
+			return "", huh.ErrUserAborted
+		}
 		return "", fmt.Errorf("failed to get menu choice: %w", err)
 	}
 
@@ -238,7 +257,7 @@ func HandleSelectProvider(ctx context.Context) error {
 
 	// Add each configured provider to the selection menu
 	for _, provider := range availableProviders {
-		providerName := getProviderDisplayName(provider)
+		providerName := GetProviderDisplayName(provider)
 		providerKey := fmt.Sprintf("provider_%d", provider)
 		providerOptions = append(providerOptions, huh.NewOption(providerName, providerKey))
 		providerMapping[providerKey] = provider
@@ -249,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
@@ -268,6 +282,10 @@ func HandleSelectProvider(ctx context.Context) error {
 	)
 
 	if err := form.Run(); err != nil {
+		// Check if user cancelled with Control-C
+		if err == huh.ErrUserAborted {
+			return huh.ErrUserAborted
+		}
 		return fmt.Errorf("failed to select provider: %w", err)
 	}
 

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

cli/pkg/cli/auth/providers_byo.go

@@ -18,14 +18,15 @@ 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},
 		{Name: "Google Gemini", Provider: cline.ApiProvider_GEMINI},
 		{Name: "Ollama", Provider: cline.ApiProvider_OLLAMA},
 		{Name: "Cerebras", Provider: cline.ApiProvider_CEREBRAS},
+		{Name: "Oracle Code Assist", Provider: cline.ApiProvider_OCA},
 	}
 }
 
@@ -71,6 +72,8 @@ func SupportsBYOModelFetching(provider cline.ApiProvider) bool {
 		return true
 	case cline.ApiProvider_OLLAMA:
 		return true
+	case cline.ApiProvider_OCA:
+		return true
 	}
 
 	return SupportsStaticModelList(provider)
@@ -82,9 +85,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:
@@ -97,6 +100,8 @@ func GetBYOProviderPlaceholder(provider cline.ApiProvider) string {
 		return "e.g., qwen3-coder:30b"
 	case cline.ApiProvider_CEREBRAS:
 		return "e.g., gpt-oss-120b"
+	case cline.ApiProvider_OCA:
+		return "e.g., oca/llama4"
 	default:
 		return "Enter model ID"
 	}
@@ -127,8 +132,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 +154,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 +171,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

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/cli/pkg/cli/task"
@@ -110,6 +111,7 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 		cline.ApiProvider_GEMINI,
 		cline.ApiProvider_OLLAMA,
 		cline.ApiProvider_CEREBRAS,
+		cline.ApiProvider_OCA,
 	}
 
 	// Check each provider to see if it's ready to use
@@ -120,16 +122,23 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 			continue
 		}
 
-		// Check if this provider has an API key
-		hasAPIKey := checkAPIKeyExists(r.apiConfig, provider)
-		if !hasAPIKey {
-			continue
-		}
-
 		// Check if this provider has a model configured
 		modelID := getProviderSpecificModelID(r.apiConfig, "plan", provider)
-		if modelID == "" {
-			continue
+
+		// Determine if credentials exist
+		hasCreds := checkAPIKeyExists(r.apiConfig, provider)
+
+		// Determine readiness: OCA uses auth state presence; others need creds and model
+		if provider == cline.ApiProvider_OCA {
+			state, _ := GetLatestOCAState(context.Background(), 2 *time.Second)
+			if state == nil || state.User == nil {
+				continue
+			}
+		} else {
+			// Provider is not ready unless it has credentials AND a model configured
+			if !hasCreds || modelID == "" {
+				continue
+			}
 		}
 
 		// Get base URL for Ollama
@@ -145,7 +154,7 @@ func (r *ProviderListResult) GetAllReadyProviders() []*ProviderDisplay {
 			Mode:      "Ready",
 			Provider:  provider,
 			ModelID:   modelID,
-			HasAPIKey: hasAPIKey,
+			HasAPIKey: checkAPIKeyExists(r.apiConfig, provider),
 			BaseURL:   baseURL,
 		})
 		seenProviders[provider] = true
@@ -207,9 +216,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
@@ -225,6 +234,8 @@ func mapProviderStringToEnum(providerStr string) (cline.ApiProvider, bool) {
 		return cline.ApiProvider_CEREBRAS, true
 	case "cline":
 		return cline.ApiProvider_CLINE, true
+	case "oca":
+		return cline.ApiProvider_OCA, true
 	default:
 		return cline.ApiProvider_ANTHROPIC, false // Return 0 value with false
 	}
@@ -237,7 +248,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:
@@ -254,6 +265,8 @@ func GetProviderIDForEnum(provider cline.ApiProvider) string {
 		return "cerebras"
 	case cline.ApiProvider_CLINE:
 		return "cline"
+	case cline.ApiProvider_OCA:
+		return "oca"
 	default:
 		return ""
 	}
@@ -306,15 +319,15 @@ func capitalizeMode(mode string) string {
 	return strings.ToUpper(mode[:1]) + mode[1:]
 }
 
-// getProviderDisplayName returns a user-friendly name for the provider
-func getProviderDisplayName(provider cline.ApiProvider) string {
+// GetProviderDisplayName returns a user-friendly name for the provider
+func GetProviderDisplayName(provider cline.ApiProvider) string {
 	switch provider {
 	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:
@@ -329,6 +342,8 @@ func getProviderDisplayName(provider cline.ApiProvider) string {
 		return "Cerebras"
 	case cline.ApiProvider_CLINE:
 		return "Cline (Official)"
+	case cline.ApiProvider_OCA:
+		return "Oracle Code Assist"
 	default:
 		return "Unknown"
 	}
@@ -364,9 +379,9 @@ func FormatProviderList(result *ProviderListResult) string {
 			isActive := activeProviderSet && display.Provider == activeProvider
 
 			if isActive {
-				output.WriteString(fmt.Sprintf("  ✓ %s (ACTIVE)\n", getProviderDisplayName(display.Provider)))
+				output.WriteString(fmt.Sprintf("  ✓ %s (ACTIVE)\n", GetProviderDisplayName(display.Provider)))
 			} else {
-				output.WriteString(fmt.Sprintf("  • %s\n", getProviderDisplayName(display.Provider)))
+				output.WriteString(fmt.Sprintf("  • %s\n", GetProviderDisplayName(display.Provider)))
 			}
 
 			output.WriteString(fmt.Sprintf("    Model:    %s\n", display.ModelID))
@@ -378,7 +393,7 @@ func FormatProviderList(result *ProviderListResult) string {
 				} else {
 					output.WriteString("    Base URL: (default)\n")
 				}
-			} else if display.Provider == cline.ApiProvider_CLINE {
+			} else if display.Provider == cline.ApiProvider_CLINE || display.Provider == cline.ApiProvider_OCA {
 				output.WriteString("    Status:   Authenticated\n")
 			} else {
 				output.WriteString("    API Key:  Configured\n")
@@ -430,6 +445,12 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 		verboseLog("[DEBUG] Cline provider is authenticated")
 	}
 
+	// Check OCA provider via global auth subscription (state presence)
+	if state, _ := GetLatestOCAState(context.Background(), 2*time.Second); state != nil && state.User != nil {
+		configuredProviders = append(configuredProviders, cline.ApiProvider_OCA)
+		verboseLog("[DEBUG] OCA provider has active auth state")
+	}
+
 	// Check each BYO provider for API key presence
 	providersToCheck := []struct {
 		provider cline.ApiProvider
@@ -447,21 +468,22 @@ func DetectAllConfiguredProviders(ctx context.Context, manager *task.Manager) ([
 	}
 
 	for _, providerCheck := range providersToCheck {
-		verboseLog("[DEBUG] Checking for %s key: %s", getProviderDisplayName(providerCheck.provider), providerCheck.keyField)
+		verboseLog("[DEBUG] Checking for %s key: %s", GetProviderDisplayName(providerCheck.provider), providerCheck.keyField)
 		if value, ok := apiConfig[providerCheck.keyField]; ok {
 			verboseLog("[DEBUG]   Found key, value type: %T, is empty: %v", value, value == "")
 			if str, ok := value.(string); ok && str != "" {
 				configuredProviders = append(configuredProviders, providerCheck.provider)
-				verboseLog("[DEBUG]   ✓ Provider %s is configured", getProviderDisplayName(providerCheck.provider))
+				verboseLog("[DEBUG]   ✓ Provider %s is configured", GetProviderDisplayName(providerCheck.provider))
 			}
 		} else {
 			verboseLog("[DEBUG]   Key %s not found", providerCheck.keyField)
 		}
 	}
 
+
 	verboseLog("[DEBUG] Total configured providers: %d", len(configuredProviders))
 	for _, p := range configuredProviders {
-		verboseLog("[DEBUG]   - %s", getProviderDisplayName(p))
+		verboseLog("[DEBUG]   - %s", GetProviderDisplayName(p))
 	}
 
 	return configuredProviders, nil

cli/pkg/cli/auth/update_api_configurations.go

@@ -12,7 +12,7 @@ import (
 )
 
 // updateApiConfigurationPartial is a helper that calls the gRPC method with optional verbose logging.
-// This replaces the Manager.UpdateApiConfigurationPartial method to keep auth-specific code in the auth package.
+// This replaces the Manager.updateApiConfigurationPartial method to keep auth-specific code in the auth package.
 func updateApiConfigurationPartial(ctx context.Context, manager *task.Manager, request *cline.UpdateApiConfigurationPartialRequest) error {
 	if global.Config.Verbose {
 		fmt.Println("[DEBUG] Updating API configuration (partial)")
@@ -46,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",
@@ -142,6 +144,17 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 			ActModeProviderSpecificModelIDField:  "actModeOpenRouterModelId",
 		}, nil
 
+	case cline.ApiProvider_OCA:
+		return ProviderFields{
+			APIKeyField:                          "ocaApiKey",
+			PlanModeModelIDField:                 "planModeApiModelId",
+			ActModeModelIDField:                  "actModeApiModelId",
+			PlanModeModelInfoField:               "planModeOcaModelInfo",
+			ActModeModelInfoField:                "actModeOcaModelInfo",
+			PlanModeProviderSpecificModelIDField: "planModeOcaModelId",
+			ActModeProviderSpecificModelIDField:  "actModeOcaModelId",
+		}, nil
+
 	default:
 		return ProviderFields{}, fmt.Errorf("unsupported provider: %v", provider)
 	}
@@ -150,9 +163,12 @@ func GetProviderFields(provider cline.ApiProvider) (ProviderFields, error) {
 // ProviderUpdatesPartial defines optional fields for partial provider updates
 // Uses pointers to distinguish between "not provided" and "set to empty"
 type ProviderUpdatesPartial struct {
-	ModelID   *string     // New model ID (optional)
-	APIKey    *string     // New API key (optional)
-	ModelInfo interface{} // New model info (optional, provider-specific)
+	ModelID      *string     // New model ID (optional)
+	APIKey       *string     // New API key (optional)
+	ModelInfo    interface{} // New model info (optional, provider-specific)
+	BaseURL      *string     // New base URL (optional, e.g., for OCA, Ollama)
+	RefreshToken *string     // New refresh token (optional, e.g., for OCA)
+	Mode         *string     // New mode (optional, e.g., "internal" or "external" for OCA)
 }
 
 // GetModelIDFieldName returns the appropriate model ID field name for a provider and mode.
@@ -182,7 +198,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 +215,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
@@ -245,6 +266,8 @@ func setAPIKeyField(apiConfig *cline.ModelsApiConfiguration, fieldName string, v
 		apiConfig.CerebrasApiKey = value
 	case "clineApiKey":
 		apiConfig.ClineApiKey = value
+	case "ocaApiKey":
+		apiConfig.OcaApiKey = value
 	}
 }
 
@@ -263,11 +286,14 @@ func setProviderSpecificModelID(apiConfig *cline.ModelsApiConfiguration, fieldNa
 	case "planModeAwsBedrockCustomModelBaseId":
 		apiConfig.PlanModeAwsBedrockCustomModelBaseId = value
 		apiConfig.ActModeAwsBedrockCustomModelBaseId = value
+	case "planModeOcaModelId":
+		apiConfig.PlanModeOcaModelId = value
+		apiConfig.ActModeOcaModelId = 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 +308,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 +334,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 +401,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}
@@ -421,6 +454,46 @@ func RemoveProviderPartial(ctx context.Context, manager *task.Manager, provider
 	return nil
 }
 
+// setBaseURLField sets the appropriate base URL field in the config based on the field name
+func setBaseURLField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
+	switch fieldName {
+	case "ocaBaseUrl":
+		apiConfig.OcaBaseUrl = value
+	case "ollamaBaseUrl":
+		apiConfig.OllamaBaseUrl = value
+	case "openAiBaseUrl":
+		apiConfig.OpenAiBaseUrl = value
+	case "geminiBaseUrl":
+		apiConfig.GeminiBaseUrl = value
+	case "liteLlmBaseUrl":
+		apiConfig.LiteLlmBaseUrl = value
+	case "anthropicBaseUrl":
+		apiConfig.AnthropicBaseUrl = value
+	case "requestyBaseUrl":
+		apiConfig.RequestyBaseUrl = value
+	case "lmStudioBaseUrl":
+		apiConfig.LmStudioBaseUrl = value
+	case "oca":
+		apiConfig.OcaBaseUrl = value
+	}
+}
+
+// setRefreshTokenField sets the appropriate refresh token field in the config
+func setRefreshTokenField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
+	switch fieldName {
+	case "ocaRefreshToken":
+		apiConfig.OcaRefreshToken = value
+	}
+}
+
+// setModeField sets the appropriate mode field in the config
+func setModeField(apiConfig *cline.ModelsApiConfiguration, fieldName string, value *string) {
+	switch fieldName {
+	case "ocaMode":
+		apiConfig.OcaMode = value
+	}
+}
+
 // BedrockOptionalFields holds optional configuration fields for AWS Bedrock
 type BedrockOptionalFields struct {
 	SessionToken            *string // Optional: AWS session token for temporary credentials
@@ -434,6 +507,12 @@ type BedrockOptionalFields struct {
 	Endpoint                *string // Optional: Custom endpoint URL
 }
 
+// OcaOptionalFields holds optional configuration fields for Oracle Code Assist
+type OcaOptionalFields struct {
+	BaseURL *string // Optional: Base URL
+	Mode    *string // Optional: Mode ("internal" or "external")
+}
+
 // setBedrockOptionalFields sets optional Bedrock-specific fields in the API configuration
 func setBedrockOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *BedrockOptionalFields) {
 	if fields == nil {
@@ -469,6 +548,20 @@ func setBedrockOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *B
 	}
 }
 
+// setOcaOptionalFields sets optional Oca-specific fields in the API configuration
+func setOcaOptionalFields(apiConfig *cline.ModelsApiConfiguration, fields *OcaOptionalFields) {
+	if fields == nil {
+		return
+	}
+
+	if fields.Mode != nil {
+		apiConfig.OcaMode = fields.Mode
+	}
+	if fields.BaseURL != nil {
+		apiConfig.OcaBaseUrl = fields.BaseURL
+	}
+}
+
 // buildBedrockOptionalFieldMask builds field mask paths for Bedrock optional fields that have values
 func buildBedrockOptionalFieldMask(fields *BedrockOptionalFields) []string {
 	if fields == nil {
@@ -507,3 +600,21 @@ func buildBedrockOptionalFieldMask(fields *BedrockOptionalFields) []string {
 
 	return fieldPaths
 }
+
+// buildOcaOptionalFieldMask builds field mask paths for Bedrock optional fields that have values
+func buildOcaOptionalFieldMask(fields *OcaOptionalFields) []string {
+	if fields == nil {
+		return nil
+	}
+
+	var fieldPaths []string
+
+	if fields.Mode != nil {
+		fieldPaths = append(fieldPaths, "ocaMode")
+	}
+	if fields.BaseURL != nil {
+		fieldPaths = append(fieldPaths, "ocaBaseUrl")
+	}
+
+	return fieldPaths
+}

cli/pkg/cli/auth/wizard_byo.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/charmbracelet/huh"
 	"github.com/cline/cli/pkg/cli/global"
@@ -40,7 +41,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 +108,13 @@ func (pw *ProviderWizard) handleAddProvider() error {
 		return pw.handleAddBedrockProvider()
 	}
 
+	// Step 2b: Special handling for OCA provider
+	if provider == cline.ApiProvider_OCA {
+		return pw.handleAddOcaProvider()
+	}
+
 	// Step 3: Get API key first (for non-Bedrock providers)
-	apiKey, err := PromptForAPIKey(provider)
+	apiKey, baseURL, err := PromptForAPIKey(provider)
 	if err != nil {
 		return fmt.Errorf("failed to get API key: %w", err)
 	}
@@ -120,7 +126,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)
 	}
 
@@ -162,6 +168,51 @@ func (pw *ProviderWizard) handleAddBedrockProvider() error {
 	return nil
 }
 
+// handleAddOcaProvider handles adding Oracle Code Assist provider with optional settings and auth
+func (pw *ProviderWizard) handleAddOcaProvider() error {
+	// Step 1: Get OCA configuration (base URL and mode)
+	config, err := PromptForOcaConfig(pw.ctx, pw.manager)
+	if err != nil {
+		if strings.Contains(err.Error(), "user aborted") || strings.Contains(err.Error(), "cancelled") {
+			return nil
+		}
+		return fmt.Errorf("failed to get OCA configuration: %w", err)
+	}
+
+	// Apply OCA configuration (base URL and mode)
+	if err := ApplyOcaConfig(pw.ctx, pw.manager, config); err != nil {
+		return fmt.Errorf("failed to save OCA configuration: %w", err)
+	}
+
+	// Step 2: Ensure OCA authentication
+	if err := ensureOcaAuthenticated(pw.ctx); err != nil {
+		return fmt.Errorf("failed to authenticate with OCA: %w", err)
+	}
+
+	// Step 3: Select model
+	modelID, _, err := pw.selectModel(cline.ApiProvider_OCA, "")
+	if err != nil {
+		return fmt.Errorf("model selection failed: %w", err)
+	}
+
+	// Step 4: Apply the OCA model configuration and set as active
+	updates := ProviderUpdatesPartial{
+		ModelID:   &modelID,
+		ModelInfo: nil,
+	}
+
+	if err := UpdateProviderPartial(pw.ctx, pw.manager, cline.ApiProvider_OCA, updates, true); err != nil {
+		return fmt.Errorf("failed to save OCA configuration: %w", err)
+	}
+
+	if err := setWelcomeViewCompleted(pw.ctx, pw.manager); err != nil {
+		verboseLog("Warning: Failed to mark welcome view as completed: %v", err)
+	}
+
+	fmt.Println("✓ OCA provider configured successfully!")
+	return nil
+}
+
 // handleListProviders retrieves and displays configured providers
 func (pw *ProviderWizard) handleListProviders() error {
 	result, err := GetProviderConfigurations(pw.ctx, pw.manager)
@@ -259,6 +310,15 @@ func (pw *ProviderWizard) fetchModelsForProvider(provider cline.ApiProvider, api
 		}
 		// Ollama returns just model IDs without additional info, so modelInfo map is nil
 		return modelIDs, nil, nil
+
+	case cline.ApiProvider_OCA:
+		// OCA supports dynamic model fetching
+		models, err := FetchOcaModels(pw.ctx, pw.manager)
+		if err != nil {
+			return nil, nil, err
+		}
+		interfaceMap := ConvertOcaModelsToInterface(models)
+		return ConvertModelsMapToSlice(interfaceMap), interfaceMap, nil
 	}
 
 	// Fall back to static models for providers that don't support dynamic fetching
@@ -381,7 +441,7 @@ func (pw *ProviderWizard) handleChangeModel() error {
 	options := make([]huh.Option[int], len(configurableProviders)+1)
 	for i, providerDisplay := range configurableProviders {
 		displayName := fmt.Sprintf("%s (current: %s)",
-			getProviderDisplayName(providerDisplay.Provider),
+			GetProviderDisplayName(providerDisplay.Provider),
 			providerDisplay.ModelID)
 		options[i] = huh.NewOption(displayName, i)
 	}
@@ -407,7 +467,7 @@ func (pw *ProviderWizard) handleChangeModel() error {
 	selectedProvider := configurableProviders[selectedIndex]
 	provider := selectedProvider.Provider
 
-	fmt.Printf("\nChanging model for %s\n", getProviderDisplayName(provider))
+	fmt.Printf("\nChanging model for %s\n", GetProviderDisplayName(provider))
 	fmt.Printf("Current model: %s\n\n", selectedProvider.ModelID)
 
 	// Step 5: Retrieve API key if needed for model fetching
@@ -431,7 +491,7 @@ func (pw *ProviderWizard) handleChangeModel() error {
 
 		apiKey = getProviderAPIKeyFromState(apiConfig, provider)
 		if apiKey == "" {
-			return fmt.Errorf("no API key found for provider %s", getProviderDisplayName(provider))
+			return fmt.Errorf("no API key found for provider %s", GetProviderDisplayName(provider))
 		}
 	}
 
@@ -484,7 +544,7 @@ func SwitchToBYOProvider(ctx context.Context, manager *task.Manager, provider cl
 	// Get the model ID for the selected provider
 	modelID := getProviderModelIDFromState(apiConfig, provider)
 	if modelID == "" {
-		return fmt.Errorf("no model configured for provider %s", getProviderDisplayName(provider))
+		return fmt.Errorf("no model configured for provider %s", GetProviderDisplayName(provider))
 	}
 
 	// Get model info if available (for OpenRouter/Cline)
@@ -505,7 +565,7 @@ func SwitchToBYOProvider(ctx context.Context, manager *task.Manager, provider cl
 		return fmt.Errorf("failed to switch provider: %w", err)
 	}
 
-	verboseLog("✓ Switched to %s\n", getProviderDisplayName(provider))
+	verboseLog("✓ Switched to %s\n", GetProviderDisplayName(provider))
 	verboseLog("  Using model: %s\n", modelID)
 
 	return HandleAuthMenuNoArgs(ctx)
@@ -525,8 +585,17 @@ func getProviderModelIDFromState(stateData map[string]interface{}, provider clin
 	return ""
 }
 
-// getProviderAPIKeyFromState retrieves the API key for a specific provider from state
+ // getProviderAPIKeyFromState retrieves the API key for a specific provider from state
 func getProviderAPIKeyFromState(stateData map[string]interface{}, provider cline.ApiProvider) string {
+	// OCA uses account authentication, not API keys. Consider it "present" if authenticated.
+	if provider == cline.ApiProvider_OCA {
+		if state, _ := GetLatestOCAState(context.TODO(), 2 * time.Second); state != nil && state.User != nil {
+			// Return a sentinel non-empty string so upstream checks pass.
+			return "OCA_AUTH_VERIFIED"
+		}
+		return ""
+	}
+
 	fields, err := GetProviderFields(provider)
 	if err != nil {
 		return ""
@@ -607,7 +676,7 @@ func (pw *ProviderWizard) handleRemoveProvider() error {
 	options := make([]huh.Option[int], len(removableProviders))
 	for i, provider := range removableProviders {
 		// Mark active provider
-		displayName := getProviderDisplayName(provider.Provider)
+		displayName := GetProviderDisplayName(provider.Provider)
 		if result.ActProvider != nil && provider.Provider == result.ActProvider.Provider {
 			displayName += " (ACTIVE)"
 		}
@@ -631,7 +700,7 @@ func (pw *ProviderWizard) handleRemoveProvider() error {
 
 	// Step 5: Check if trying to remove the active provider
 	if result.ActProvider != nil && selectedProvider.Provider == result.ActProvider.Provider {
-		fmt.Printf("\nCannot remove %s because it is currently active.\n", getProviderDisplayName(selectedProvider.Provider))
+		fmt.Printf("\nCannot remove %s because it is currently active.\n", GetProviderDisplayName(selectedProvider.Provider))
 		fmt.Println("Please switch to a different provider first, then try again.")
 		return nil
 	}
@@ -641,7 +710,7 @@ func (pw *ProviderWizard) handleRemoveProvider() error {
 	confirmForm := huh.NewForm(
 		huh.NewGroup(
 			huh.NewConfirm().
-				Title(fmt.Sprintf("Are you sure you want to remove %s?", getProviderDisplayName(selectedProvider.Provider))).
+				Title(fmt.Sprintf("Are you sure you want to remove %s?", GetProviderDisplayName(selectedProvider.Provider))).
 				Description("This will clear the API key but preserve the model configuration.").
 				Value(&confirm),
 		),
@@ -656,12 +725,21 @@ func (pw *ProviderWizard) handleRemoveProvider() error {
 		return nil
 	}
 
-	// Step 7: Clear the API key for the selected provider
+	// Step 7: If removing OCA, sign out first
+	if selectedProvider.Provider == cline.ApiProvider_OCA {
+		if err := signOutOca(pw.ctx); err != nil {
+			fmt.Printf("Warning: Failed to sign out of OCA: %v\n", err)
+		} else {
+			fmt.Println("Signed out of OCA.")
+		}
+	}
+
+	// Step 8: Clear the API key for the selected provider
 	if err := pw.clearProviderAPIKey(selectedProvider.Provider); err != nil {
 		return fmt.Errorf("failed to remove provider: %w", err)
 	}
 
-	fmt.Printf("\n✓ %s removed successfully\n", getProviderDisplayName(selectedProvider.Provider))
+	fmt.Printf("\n✓ %s removed successfully\n", GetProviderDisplayName(selectedProvider.Provider))
 	return nil
 }
 
@@ -670,6 +748,16 @@ func (pw *ProviderWizard) clearProviderAPIKey(provider cline.ApiProvider) error
 	return RemoveProviderPartial(pw.ctx, pw.manager, provider)
 }
 
+
+func signOutOca(ctx context.Context) error {
+	client, err := global.GetDefaultClient(ctx)
+	if err != nil {
+		return err
+	}
+	_, err = client.Ocaaccount.OcaAccountLogoutClicked(ctx, &cline.EmptyRequest{})
+	return err
+}
+
 func setWelcomeViewCompleted(ctx context.Context, manager *task.Manager) error {
 	_, err := manager.GetClient().State.SetWelcomeViewCompleted(ctx, &cline.BooleanRequest{Value: true})
 	return err

cli/pkg/cli/auth/wizard_byo_oca.go

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

cli/pkg/cli/display/banner.go

@@ -0,0 +1,211 @@
+package display
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// BannerInfo contains information to display in the session banner
+type BannerInfo struct {
+	Version    string
+	Provider   string
+	ModelID    string
+	Workdir    string
+	Mode       string
+}
+
+// RenderSessionBanner renders a nice banner showing version, model, and workspace info
+func RenderSessionBanner(info BannerInfo) string {
+	// Bright white for title
+	titleStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("15")). // Bright white
+		Bold(true)
+
+	// Dim gray for regular text (same as huh placeholder)
+	dimStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.AdaptiveColor{Light: "248", Dark: "238"})
+
+	// Border color matches mode
+	borderColor := lipgloss.Color("3") // Yellow for plan
+	if info.Mode == "act" {
+		borderColor = lipgloss.Color("39") // Blue for act
+	}
+
+	boxStyle := lipgloss.NewStyle().
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(borderColor).
+		Padding(1, 4)
+
+	var lines []string
+
+	// Format version with "v" prefix if it starts with a number
+	versionStr := info.Version
+	if len(versionStr) > 0 && versionStr[0] >= '0' && versionStr[0] <= '9' {
+		versionStr = "v" + versionStr
+	}
+
+	// First line: "cline cli vX.X.X" on left, "plan mode" on right
+	leftSide := titleStyle.Render("cline cli preview") + " " + dimStyle.Render(versionStr)
+
+	if info.Mode != "" {
+		modeColor := lipgloss.Color("3") // Yellow for plan
+		if info.Mode == "act" {
+			modeColor = lipgloss.Color("39") // Blue for act
+		}
+		modeStyle := lipgloss.NewStyle().Foreground(modeColor).Bold(true)
+		rightSide := modeStyle.Render(info.Mode + " mode")
+
+		// Calculate spacing to push mode to the right
+		// Assume a reasonable width (we'll adjust based on content)
+		lineWidth := 50
+		leftWidth := lipgloss.Width(leftSide)
+		rightWidth := lipgloss.Width(rightSide)
+		spacing := lineWidth - leftWidth - rightWidth
+
+		if spacing > 0 {
+			titleLine := leftSide + strings.Repeat(" ", spacing) + rightSide
+			lines = append(lines, titleLine)
+		} else {
+			// If too narrow, just put them on same line with a space
+			lines = append(lines, leftSide+" "+rightSide)
+		}
+	} else {
+		// No mode, just show title
+		lines = append(lines, leftSide)
+	}
+
+	// Model line - dim gray
+	if info.Provider != "" && info.ModelID != "" {
+		lines = append(lines, dimStyle.Render(info.Provider+"/"+shortenPath(info.ModelID, 30)))
+	}
+
+	// Workspace line - dim gray
+	if info.Workdir != "" {
+		lines = append(lines, dimStyle.Render(shortenPath(info.Workdir, 45)))
+	}
+
+	content := lipgloss.JoinVertical(lipgloss.Left, lines...)
+	return boxStyle.Render(content)
+}
+
+// shortenPath shortens a filesystem path to fit within maxLen
+func shortenPath(path string, maxLen int) string {
+	// Try to replace home directory with ~ (cross-platform)
+	if homeDir, err := os.UserHomeDir(); err == nil {
+		if strings.HasPrefix(path, homeDir) {
+			shortened := "~" + path[len(homeDir):]
+			// Always use ~ version if we can
+			path = shortened
+		}
+	}
+
+	if len(path) <= maxLen {
+		return path
+	}
+
+	// If still too long, show last few path components
+	if len(path) > maxLen {
+		parts := strings.Split(path, string(filepath.Separator))
+		if len(parts) > 2 {
+			// Show last 2-3 components
+			lastParts := parts[len(parts)-2:]
+			shortened := "..." + string(filepath.Separator) + strings.Join(lastParts, string(filepath.Separator))
+			if len(shortened) <= maxLen {
+				return shortened
+			}
+		}
+	}
+
+	// Last resort: truncate with ellipsis
+	if len(path) > maxLen {
+		return "..." + path[len(path)-maxLen+3:]
+	}
+
+	return path
+}
+
+// ExtractBannerInfoFromState extracts banner info from state JSON
+func ExtractBannerInfoFromState(stateJSON, version string) (BannerInfo, error) {
+	var state map[string]interface{}
+	if err := json.Unmarshal([]byte(stateJSON), &state); err != nil {
+		return BannerInfo{}, fmt.Errorf("failed to parse state JSON: %w", err)
+	}
+
+	info := BannerInfo{
+		Version: version,
+	}
+
+	// Extract mode
+	if mode, ok := state["mode"].(string); ok {
+		info.Mode = mode
+	}
+
+	// Extract workspace roots
+	if workspaceRoots, ok := state["workspaceRoots"].([]interface{}); ok && len(workspaceRoots) > 0 {
+		if root, ok := workspaceRoots[0].(map[string]interface{}); ok {
+			if path, ok := root["path"].(string); ok {
+				info.Workdir = path
+			}
+		}
+	}
+
+	// Extract API configuration to get provider/model
+	if apiConfig, ok := state["apiConfiguration"].(map[string]interface{}); ok {
+		// Try common keys for provider and model (both camelCase and lowercase variants)
+		providerKeys := []string{"apiProvider", "api_provider"}
+		modelKeys := []string{"apiModelId", "api_model_id"}
+
+		// Try to extract provider
+		for _, key := range providerKeys {
+			if provider, ok := apiConfig[key].(string); ok && provider != "" {
+				info.Provider = provider
+				break
+			}
+		}
+
+		// Try to extract model ID
+		for _, key := range modelKeys {
+			if modelID, ok := apiConfig[key].(string); ok && modelID != "" {
+				info.ModelID = shortenModelID(modelID)
+				break
+			}
+		}
+	}
+
+	return info, nil
+}
+
+// shortenModelID shortens long model IDs for display
+func shortenModelID(modelID string) string {
+	// Remove date suffixes only if they're at the end (e.g., -20241022)
+	// Check if the model ID ends with -YYYYMMDD pattern
+	if len(modelID) > 9 {
+		suffix := modelID[len(modelID)-9:] // Last 9 chars: -20241022
+		if suffix[0] == '-' &&
+		   (strings.HasPrefix(suffix[1:], "202") || strings.HasPrefix(suffix[1:], "201")) {
+			// Verify all remaining chars are digits
+			allDigits := true
+			for _, c := range suffix[1:] {
+				if c < '0' || c > '9' {
+					allDigits = false
+					break
+				}
+			}
+			if allDigits {
+				return modelID[:len(modelID)-9]
+			}
+		}
+	}
+
+	// If still too long, show first 40 chars
+	if len(modelID) > 40 {
+		return modelID[:37] + "..."
+	}
+
+	return modelID
+}

cli/pkg/cli/display/markdown_renderer.go

@@ -28,7 +28,7 @@ type MarkdownRenderer struct {
 // i figure we just make things as beautiful as possible 
 // and if you resize the terminal, you'll learn real quick.
 // anyway, you can set this to true or false to experiment
-const USETERMINALWORDWRAP = false
+const USETERMINALWORDWRAP = true
 
 
 // seems like a reliable way to check for terminals
@@ -38,12 +38,12 @@ const USETERMINALWORDWRAP = false
 func detectTerminalTheme() string {
 	switch os.Getenv("TERM_PROGRAM") {
 	case "iTerm.app", "Ghostty":
-		return "auto"
+		return "dark"
 	}
 	if os.Getenv("GHOSTTY_VERSION") != "" {
-		return "auto"
+		return "dark"
 	}
-	return "auto"
+	return "dark"
 }
 
 func glamourStyleJSON(terminalWrap bool) string {

cli/pkg/cli/display/renderer.go

@@ -4,7 +4,9 @@ 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"
 	"github.com/cline/grpc-go/cline"
 )
@@ -13,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 {
@@ -20,12 +32,24 @@ func NewRenderer(outputFormat string) *Renderer {
 	if err != nil {
 		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 {
@@ -39,9 +63,9 @@ func (r *Renderer) RenderMessage(prefix, text string, newline bool) error {
 	}
 
 	if newline {
-		fmt.Printf("%s: %s\n", prefix, clean)
+		output.Printf("%s: %s\n", prefix, clean)
 	} else {
-		fmt.Printf("%s: %s", prefix, clean)
+		output.Printf("%s: %s", prefix, clean)
 	}
 	return nil
 }
@@ -86,12 +110,12 @@ func (r *Renderer) RenderAPI(status string, apiInfo *types.APIRequestInfo) error
 		usageInfo := r.formatUsageInfo(apiInfo.TokensIn, apiInfo.TokensOut, apiInfo.CacheReads, apiInfo.CacheWrites, apiInfo.Cost)
 		markdown := fmt.Sprintf("## API %s `%s`", status, usageInfo)
 		rendered := r.RenderMarkdown(markdown)
-		fmt.Printf(rendered)
+		output.Print(rendered)
 	} else {
 		// honestly i see no point in showing "### API processing request" here...
 		// markdown := fmt.Sprintf("## API %s", status)
 		// rendered := r.RenderMarkdown(markdown)
-		// fmt.Printf("\n%s\n", rendered)
+		// output.Printf("\n%s\n", rendered)
 	}
 	return nil
 }
@@ -109,7 +133,7 @@ func (r *Renderer) RenderRetry(attempt, maxAttempts, delaySec int) error {
 func (r *Renderer) RenderTaskCancelled() error {
 	markdown := "## Task cancelled"
 	rendered := r.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
+	output.Printf("\n%s\n", rendered)
 	return nil
 }
 
@@ -126,16 +150,16 @@ func (r *Renderer) RenderTaskList(tasks []*cline.TaskItem) error {
 
 	r.typewriter.PrintfLn("=== Task History (showing last %d of %d total tasks) ===\n", len(recentTasks), len(tasks))
 
-	for i, task := range recentTasks {
-		r.typewriter.PrintfLn("Task ID: %s", task.Id)
+	for i, taskItem := range recentTasks {
+		r.typewriter.PrintfLn("Task ID: %s", taskItem.Id)
 
-		description := task.Task
+		description := taskItem.Task
 		if len(description) > 1000 {
 			description = description[:1000] + "..."
 		}
 		r.typewriter.PrintfLn("Message: %s", description)
 
-		usageInfo := r.formatUsageInfo(int(task.TokensIn), int(task.TokensOut), int(task.CacheReads), int(task.CacheWrites), task.TotalCost)
+		usageInfo := r.formatUsageInfo(int(taskItem.TokensIn), int(taskItem.TokensOut), int(taskItem.CacheReads), int(taskItem.CacheWrites), taskItem.TotalCost)
 		r.typewriter.PrintfLn("Usage  : %s", usageInfo)
 
 		// Single space between tasks (except last)
@@ -156,11 +180,11 @@ func (r *Renderer) RenderDebug(format string, args ...interface{}) error {
 }
 
 func (r *Renderer) ClearLine() {
-	fmt.Print("\r\033[K")
+	output.Print("\r\033[K")
 }
 
 func (r *Renderer) MoveCursorUp(n int) {
-	fmt.Printf("\033[%dA", n)
+	output.Printf("\033[%dA", n)
 }
 
 func (r *Renderer) sanitizeText(text string) string {
@@ -205,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

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/cline/cli/pkg/cli/output"
 	"github.com/cline/cli/pkg/cli/types"
 )
 
@@ -34,15 +35,15 @@ func NewStreamingSegment(sayType, prefix string, mdRenderer *MarkdownRenderer, s
 		msg:            msg,
 		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)
-		fmt.Println()
-		fmt.Print(rendered)
+		output.Println("")
+		output.Print(rendered)
 	}
-	
+
 	return ss
 }
 
@@ -112,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
@@ -121,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
@@ -136,10 +137,10 @@ func (ss *StreamingSegment) renderFinal(currentBuffer string) {
 	// Print the body content
 	if bodyContent != "" {
 		if !strings.HasSuffix(bodyContent, "\n") {
-			fmt.Print(bodyContent)
-			fmt.Println()
+			output.Print(bodyContent)
+			output.Println("")
 		} else {
-			fmt.Print(bodyContent)
+			output.Print(bodyContent)
 		}
 	}
 }

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/cline-clients.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path"
+	"path/filepath"
 	"syscall"
 	"time"
 
@@ -367,16 +368,68 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 		fmt.Printf("Starting cline-core on port %d (with hostbridge on %d)\n", corePort, hostPort)
 	}
 
-	// Get paths relative to the cline binary location
+	// Get the executable path and resolve symlinks (for npm global installs)
 	execPath, err := os.Executable()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get executable path: %w", err)
 	}
-	binDir := path.Dir(execPath)
+
+	// Resolve symlinks to get the real path
+	// For npm global installs, execPath might be a symlink like:
+	// /opt/homebrew/bin/cline -> /opt/homebrew/lib/node_modules/cline/bin/cline
+	realPath, err := filepath.EvalSymlinks(execPath)
+	if err != nil {
+		// If we can't resolve symlinks, fall back to the original path
+		realPath = execPath
+		if Config.Verbose {
+			fmt.Printf("Warning: Could not resolve symlinks for %s: %v\n", execPath, err)
+		}
+	}
+
+	binDir := path.Dir(realPath)
 	installDir := path.Dir(binDir)
-	nodePath := path.Join(binDir, "node")
 	clineCorePath := path.Join(installDir, "cline-core.js")
 
+	if Config.Verbose {
+		fmt.Printf("Executable path: %s\n", execPath)
+		if realPath != execPath {
+			fmt.Printf("Real path (after resolving symlinks): %s\n", realPath)
+		}
+		fmt.Printf("Bin directory: %s\n", binDir)
+		fmt.Printf("Install directory: %s\n", installDir)
+		fmt.Printf("Looking for cline-core.js at: %s\n", clineCorePath)
+	}
+
+	// Check if cline-core.js exists at the primary location
+	var finalClineCorePath string
+	var finalInstallDir string
+	if _, err := os.Stat(clineCorePath); os.IsNotExist(err) {
+		// Development mode: Try ../../dist-standalone/cline-core.js
+		// This handles the case where we're running from cli/bin/cline
+		devClineCorePath := path.Join(binDir, "..", "..", "dist-standalone", "cline-core.js")
+		devInstallDir := path.Join(binDir, "..", "..", "dist-standalone")
+		
+		if Config.Verbose {
+			fmt.Printf("Primary location not found, trying development path: %s\n", devClineCorePath)
+		}
+		
+		if _, err := os.Stat(devClineCorePath); os.IsNotExist(err) {
+			return nil, fmt.Errorf("cline-core.js not found at '%s' or '%s'. Please ensure you're running from the correct location or reinstall with 'npm install -g cline'", clineCorePath, devClineCorePath)
+		}
+		
+		finalClineCorePath = devClineCorePath
+		finalInstallDir = devInstallDir
+		if Config.Verbose {
+			fmt.Printf("Using development mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	} else {
+		finalClineCorePath = clineCorePath
+		finalInstallDir = installDir
+		if Config.Verbose {
+			fmt.Printf("Using production mode: cline-core.js found at %s\n", finalClineCorePath)
+		}
+	}
+
 	// Create logs directory in ~/.cline/logs
 	logsDir := path.Join(Config.ConfigPath, "logs")
 	if err := os.MkdirAll(logsDir, 0755); err != nil {
@@ -392,16 +445,20 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 		return nil, fmt.Errorf("failed to create log file: %w", err)
 	}
 
-	// Start the cline-core process with --config flag
-	args := []string{clineCorePath,
+	// Start the cline-core process with --config flag using system node
+	args := []string{finalClineCorePath,
 		"--port", fmt.Sprintf("%d", corePort),
 		"--host-bridge-port", fmt.Sprintf("%d", hostPort),
 		"--config", Config.ConfigPath}
 
-	cmd := exec.Command(nodePath, args...)
+	if Config.Verbose {
+		fmt.Printf("Using system node\n")
+	}
+
+	cmd := exec.Command("node", args...)
 
 	// Set working directory to installation root
-	cmd.Dir = installDir
+	cmd.Dir = finalInstallDir
 
 	// Redirect stdout and stderr to log file
 	cmd.Stdout = logFile
@@ -412,15 +469,24 @@ func startClineCore(corePort, hostPort int) (*exec.Cmd, error) {
 		Setpgid: true,
 	}
 
-	// Set environment variables with NODE_PATH for node_modules
+	// Set environment variables with NODE_PATH for both real and fake node_modules
+	// The fake node_modules contains the vscode stub that can't be in the real node_modules
 	env := os.Environ()
+	realNodeModules := path.Join(finalInstallDir, "node_modules")
+	fakeNodeModules := path.Join(finalInstallDir, "fake_node_modules")
+	nodePath := fmt.Sprintf("%s%c%s", realNodeModules, os.PathListSeparator, fakeNodeModules)
+	
 	env = append(env,
-		fmt.Sprintf("NODE_PATH=%s", path.Join(installDir, "node_modules")),
+		fmt.Sprintf("NODE_PATH=%s", nodePath),
 		"GRPC_TRACE=all",
 		"GRPC_VERBOSITY=DEBUG",
 		"NODE_ENV=development",
 	)
 	cmd.Env = env
+	
+	if Config.Verbose {
+		fmt.Printf("NODE_PATH set to: %s\n", nodePath)
+	}
 
 	if err := cmd.Start(); err != nil {
 		logFile.Close()

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
@@ -22,6 +24,15 @@ type GlobalConfig struct {
 var (
 	Config  *GlobalConfig
 	Clients *ClineClients
+
+	// Version info - set at build time via ldflags
+	// Version is the Cline Core version (from root package.json)
+	Version = "dev"
+	// CliVersion is the CLI package version (from cli/package.json)
+	CliVersion = "dev"
+	Commit     = "unknown"
+	Date       = "unknown"
+	BuiltBy    = "unknown"
 )
 
 func InitializeGlobalConfig(cfg *GlobalConfig) error {
@@ -38,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)
 
@@ -93,4 +110,4 @@ func EnsureDefaultInstance(ctx context.Context) error {
 	}
 
 	return nil
-}
+}

cli/pkg/cli/handlers/ask_handlers.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	"github.com/cline/cli/pkg/cli/clerror"
+	"github.com/cline/cli/pkg/cli/output"
 	"github.com/cline/cli/pkg/cli/types"
 )
 
@@ -70,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)
-	fmt.Print("\n")
-	fmt.Print(rendered)
-	fmt.Print("\n")
-
-	// Render body
-	fmt.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
 }
@@ -97,7 +101,7 @@ func (h *AskHandler) handlePlanModeRespond(msg *types.ClineMessage, dc *DisplayC
 		// Just render the body content
 		body := dc.ToolRenderer.GeneratePlanModeRespondBody(msg.Text)
 		if body != "" {
-			fmt.Print(body)
+			output.Print(body)
 		}
 	} else {
 		// In non-streaming mode, render header + body together
@@ -110,17 +114,25 @@ func (h *AskHandler) handlePlanModeRespond(msg *types.ClineMessage, dc *DisplayC
 
 		// Render header
 		rendered := dc.Renderer.RenderMarkdown(header)
-		fmt.Print("\n")
-		fmt.Print(rendered)
-		fmt.Print("\n")
+		output.Print("\n")
+		output.Print(rendered)
+		output.Print("\n")
 
 		// Render body
-		fmt.Print(body)
+		output.Print(body)
 	}
 
 	return nil
 }
 
+// showApprovalHint displays a hint in non-interactive mode about how to approve/deny
+func (h *AskHandler) showApprovalHint(dc *DisplayContext) {
+	if !dc.IsInteractive {
+		output.Printf("\n%s\n", dc.Renderer.Dim("Cline is requesting approval to use this tool"))
+		output.Printf("%s\n", dc.Renderer.Dim("Use cline task send --approve or --deny to respond"))
+	}
+}
+
 // handleCommand handles command execution requests
 func (h *AskHandler) handleCommand(msg *types.ClineMessage, dc *DisplayContext) error {
 	if msg.Text == "" {
@@ -131,9 +143,10 @@ func (h *AskHandler) handleCommand(msg *types.ClineMessage, dc *DisplayContext)
 	autoApprovalConflict := strings.HasSuffix(msg.Text, "REQ_APP")
 
 	// Use unified ToolRenderer
-	output := dc.ToolRenderer.RenderCommandApprovalRequest(msg.Text, autoApprovalConflict)
-	fmt.Print(output)
+	rendered := dc.ToolRenderer.RenderCommandApprovalRequest(msg.Text, autoApprovalConflict)
+	output.Print(rendered)
 
+	h.showApprovalHint(dc)
 	return nil
 }
 
@@ -167,10 +180,21 @@ func (h *AskHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext) err
 		return dc.Renderer.RenderMessage("TOOL", msg.Text, true)
 	}
 
-	// Use unified ToolRenderer
-	output := dc.ToolRenderer.RenderToolApprovalRequest(&tool)
-	fmt.Print(output)
+	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
 }
 
@@ -253,7 +277,9 @@ func (h *AskHandler) handleAutoApprovalMaxReached(msg *types.ClineMessage, dc *D
 // handleBrowserActionLaunch handles browser action launch requests
 func (h *AskHandler) handleBrowserActionLaunch(msg *types.ClineMessage, dc *DisplayContext) error {
 	url := strings.TrimSpace(msg.Text)
-	return dc.Renderer.RenderMessage("BROWSER", fmt.Sprintf("Cline wants to launch browser and navigate to: %s. Approval required.", url), true)
+	err := dc.Renderer.RenderMessage("BROWSER", fmt.Sprintf("Cline wants to launch browser and navigate to: %s. Approval required.", url), true)
+	h.showApprovalHint(dc)
+	return err
 }
 
 // handleUseMcpServer handles MCP server usage requests
@@ -282,8 +308,11 @@ func (h *AskHandler) handleUseMcpServer(msg *types.ClineMessage, dc *DisplayCont
 		}
 	}
 
-	return dc.Renderer.RenderMessage("MCP",
+	err := dc.Renderer.RenderMessage("MCP",
 		fmt.Sprintf("Cline wants to %s on the %s MCP server", operation, mcpReq.ServerName), true)
+
+	h.showApprovalHint(dc)
+	return err
 }
 
 // handleNewTask handles new task creation requests

cli/pkg/cli/handlers/say_handlers.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/cline/cli/pkg/cli/clerror"
 	"github.com/cline/cli/pkg/cli/types"
+	"github.com/cline/cli/pkg/cli/output"
 )
 
 // SayHandler handles SAY type messages
@@ -179,8 +180,8 @@ func (h *SayHandler) handleText(msg *types.ClineMessage, dc *DisplayContext) err
 	if dc.MessageIndex == 0 {
 		markdown := formatUserMessage(msg.Text)
 		rendered := dc.Renderer.RenderMarkdown(markdown)
-		fmt.Printf("%s", rendered)
-		fmt.Printf("\n")
+		output.Printf("%s", rendered)
+		output.Printf("\n")
 		return nil
 	}
 
@@ -189,12 +190,12 @@ func (h *SayHandler) handleText(msg *types.ClineMessage, dc *DisplayContext) err
 	if dc.IsStreamingMode {
 		// In streaming mode, header already shown by partial stream
 		rendered = dc.Renderer.RenderMarkdown(msg.Text)
-		fmt.Printf("%s\n", rendered)
+		output.Printf("%s\n", rendered)
 	} else {
 		// In non-streaming mode, render header + body together
 		markdown := fmt.Sprintf("### Cline responds\n\n%s", msg.Text)
 		rendered = dc.Renderer.RenderMarkdown(markdown)
-		fmt.Printf("\n%s\n", rendered)
+		output.Printf("\n%s\n", rendered)
 	}
 	return nil
 }
@@ -209,12 +210,12 @@ func (h *SayHandler) handleReasoning(msg *types.ClineMessage, dc *DisplayContext
 	if dc.IsStreamingMode {
 		// In streaming mode, header already shown by partial stream
 		rendered = dc.Renderer.RenderMarkdown(msg.Text)
-		fmt.Printf("%s\n", rendered)
+		output.Printf("%s\n", rendered)
 	} else {
 		// In non-streaming mode, render header + body together
 		markdown := fmt.Sprintf("### Cline is thinking\n\n%s", msg.Text)
 		rendered = dc.Renderer.RenderMarkdown(markdown)
-		fmt.Printf("\n%s\n", rendered)
+		output.Printf("\n%s\n", rendered)
 	}
 	return nil
 }
@@ -230,12 +231,12 @@ func (h *SayHandler) handleCompletionResult(msg *types.ClineMessage, dc *Display
 	if dc.IsStreamingMode {
 		// In streaming mode, header already shown by partial stream
 		rendered = dc.Renderer.RenderMarkdown(text)
-		fmt.Printf("%s\n", rendered)
+		output.Printf("%s\n", rendered)
 	} else {
 		// In non-streaming mode, render header + body together
 		markdown := fmt.Sprintf("### Task completed\n\n%s", text)
 		rendered = dc.Renderer.RenderMarkdown(markdown)
-		fmt.Printf("\n%s\n", rendered)
+		output.Printf("\n%s\n", rendered)
 	}
 	return nil
 }
@@ -259,7 +260,7 @@ func (h *SayHandler) handleUserFeedback(msg *types.ClineMessage, dc *DisplayCont
 	if msg.Text != "" {
 		markdown := formatUserMessage(msg.Text)
 		rendered := dc.Renderer.RenderMarkdown(markdown)
-		fmt.Printf("%s", rendered)
+		output.Printf("%s", rendered)
 		return nil
 	} else {
 		return dc.Renderer.RenderMessage("USER", "[Provided feedback without text]", true)
@@ -323,8 +324,8 @@ func (h *SayHandler) handleCommand(msg *types.ClineMessage, dc *DisplayContext)
 	}
 
 	// Use unified ToolRenderer
-	output := dc.ToolRenderer.RenderCommandExecution(msg.Text)
-	fmt.Print(output)
+	rendered := dc.ToolRenderer.RenderCommandExecution(msg.Text)
+	output.Print(rendered)
 
 	return nil
 }
@@ -336,8 +337,8 @@ func (h *SayHandler) handleCommandOutput(msg *types.ClineMessage, dc *DisplayCon
 	}
 
 	// Use unified ToolRenderer
-	output := dc.ToolRenderer.RenderCommandOutput(msg.Text)
-	fmt.Print(output)
+	rendered := dc.ToolRenderer.RenderCommandOutput(msg.Text)
+	output.Print(rendered)
 
 	return nil
 }
@@ -349,8 +350,8 @@ func (h *SayHandler) handleTool(msg *types.ClineMessage, dc *DisplayContext) err
 	}
 
 	// Use unified ToolRenderer
-	output := dc.ToolRenderer.RenderToolExecution(&tool)
-	fmt.Print(output)
+	rendered := dc.ToolRenderer.RenderToolExecution(&tool)
+	output.Print(rendered)
 
 	return nil
 }
@@ -485,7 +486,7 @@ func (h *SayHandler) handleCheckpointCreated(msg *types.ClineMessage, dc *Displa
 	// Fallback to basic renderer if SystemRenderer not available
 	markdown := fmt.Sprintf("## [%s] Checkpoint created `%d`", timestamp, msg.Timestamp)
 	rendered := dc.Renderer.RenderMarkdown(markdown)
-	fmt.Printf(rendered)
+	output.Print(rendered)
 	return nil
 }
 
@@ -510,7 +511,7 @@ func (h *SayHandler) handleTaskProgress(msg *types.ClineMessage, dc *DisplayCont
 
 	markdown := fmt.Sprintf("### Progress\n\n%s", msg.Text)
 	rendered := dc.Renderer.RenderMarkdown(markdown)
-	fmt.Printf("\n%s\n", rendered)
+	output.Printf("\n%s\n", rendered)
 	return nil
 }
 

cli/pkg/cli/instances.go

@@ -67,7 +67,7 @@ func NewInstanceCommand() *cobra.Command {
 	}
 
 	cmd.AddCommand(newInstanceListCommand())
-	cmd.AddCommand(newInstanceUseCommand())
+	cmd.AddCommand(newInstanceDefaultCommand())
 	cmd.AddCommand(newInstanceNewCommand())
 	cmd.AddCommand(newInstanceKillCommand())
 
@@ -156,6 +156,7 @@ func killAllCLIInstances(ctx context.Context, registry *global.ClientRegistry) e
 	}
 
 	var killResults []killResult
+	killedAddresses := make(map[string]bool)
 
 	// Kill all CLI instances
 	for _, instance := range cliInstances {
@@ -168,31 +169,42 @@ func killAllCLIInstances(ctx context.Context, registry *global.ClientRegistry) e
 			fmt.Printf("⚠ Instance %s appears to be already dead\n", instance.Address)
 		} else {
 			fmt.Printf("✓ Killed %s (PID %d)\n", instance.Address, result.pid)
+			killedAddresses[instance.Address] = true
 		}
 	}
 
-	// Wait for all instances to clean up their registry entries
-	fmt.Printf("Waiting for instances to clean up registry entries...\n")
+	// Wait for killed instances to clean up their registry entries
+	if len(killedAddresses) > 0 {
+		fmt.Printf("Waiting for instances to clean up registry entries...\n")
 
-	maxWaitTime := 10 // seconds
-	for i := 0; i < maxWaitTime; i++ {
-		time.Sleep(1 * time.Second)
+		maxWaitTime := 10 // seconds
+		for i := 0; i < maxWaitTime; i++ {
+			time.Sleep(1 * time.Second)
 
-		remainingInstances, err := registry.ListInstancesCleaned(ctx)
-		if err != nil {
-			fmt.Printf("Warning: failed to check registry status: %v\n", err)
-			continue
-		}
+			remainingInstances, err := registry.ListInstancesCleaned(ctx)
+			if err != nil {
+				fmt.Printf("Warning: failed to check registry status: %v\n", err)
+				continue
+			}
 
-		if len(remainingInstances) == 0 {
-			fmt.Printf("✓ All instances successfully removed from registry.\n")
-			break
-		}
-
-		if i == maxWaitTime-1 {
-			fmt.Printf("⚠ %d instances still in registry after %d seconds\n", len(remainingInstances), maxWaitTime)
+			// Check if any of the killed instances are still in the registry
+			stillPresent := []string{}
 			for _, remaining := range remainingInstances {
-				fmt.Printf("  - %s\n", remaining.Address)
+				if killedAddresses[remaining.Address] {
+					stillPresent = append(stillPresent, remaining.Address)
+				}
+			}
+
+			if len(stillPresent) == 0 {
+				fmt.Printf("✓ All killed instances successfully removed from registry.\n")
+				break
+			}
+
+			if i == maxWaitTime-1 {
+				fmt.Printf("⚠ %d killed instance(s) still in registry after %d seconds\n", len(stillPresent), maxWaitTime)
+				for _, addr := range stillPresent {
+					fmt.Printf("  - %s\n", addr)
+				}
 			}
 		}
 	}
@@ -286,12 +298,12 @@ func newInstanceListCommand() *cobra.Command {
 
 			// Build instance data
 			type instanceRow struct {
-				address  string
-				status   string
-				version  string
-				lastSeen string
-				pid      string
-				platform string
+				address   string
+				status    string
+				version   string
+				lastSeen  string
+				pid       string
+				platform  string
 				isDefault string
 			}
 
@@ -329,12 +341,12 @@ func newInstanceListCommand() *cobra.Command {
 				}
 
 				rows = append(rows, instanceRow{
-					address:  instance.Address,
-					status:   instance.Status.String(),
-					version:  instance.Version,
-					lastSeen: lastSeen,
-					pid:      pid,
-					platform: platform,
+					address:   instance.Address,
+					status:    instance.Status.String(),
+					version:   instance.Version,
+					lastSeen:  lastSeen,
+					pid:       pid,
+					platform:  platform,
 					isDefault: isDefault,
 				})
 			}
@@ -377,21 +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"))
 					}
@@ -406,10 +418,10 @@ func newInstanceListCommand() *cobra.Command {
 	return cmd
 }
 
-func newInstanceUseCommand() *cobra.Command {
+func newInstanceDefaultCommand() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:     "use <address>",
-		Aliases: []string{"u"},
+		Use:     "default <address>",
+		Aliases: []string{"d"},
 		Short:   "Set the default Cline instance",
 		Long:    `Set the default Cline instance to use for subsequent commands.`,
 		Args:    cobra.ExactArgs(1),
@@ -442,6 +454,8 @@ func newInstanceUseCommand() *cobra.Command {
 }
 
 func newInstanceNewCommand() *cobra.Command {
+	var setDefault bool
+
 	cmd := &cobra.Command{
 		Use:     "new",
 		Aliases: []string{"n"},
@@ -466,15 +480,27 @@ func newInstanceNewCommand() *cobra.Command {
 			fmt.Printf("  Core Port: %d\n", instance.CorePort())
 			fmt.Printf("  Host Bridge Port: %d\n", instance.HostPort())
 
-			// Check if this is now the default instance
 			registry := global.Clients.GetRegistry()
-			if registry.GetDefaultInstance() == instance.Address {
-				fmt.Printf("  Status: Default instance\n")
+
+			// If --default flag provided, set this instance as the default
+			if setDefault {
+				if err := registry.SetDefaultInstance(instance.Address); err != nil {
+					fmt.Printf("Warning: Failed to set as default: %v\n", err)
+				} else {
+					fmt.Printf("  Status: Set as default instance\n")
+				}
+			} else {
+				// Otherwise, check if EnsureDefaultInstance already set it as default
+				if registry.GetDefaultInstance() == instance.Address {
+					fmt.Printf("  Status: Default instance\n")
+				}
 			}
 
 			return nil
 		},
 	}
 
+	cmd.Flags().BoolVarP(&setDefault, "default", "d", false, "set as default instance")
+
 	return cmd
-}
+}

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/coordinator.go

@@ -0,0 +1,167 @@
+package output
+
+import (
+	"fmt"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// SuspendInputMsg tells the input model to suspend and hide
+type SuspendInputMsg struct{}
+
+// ResumeInputMsg tells the input model to resume and show
+type ResumeInputMsg struct{}
+
+// OutputCoordinator manages terminal output and coordinates with interactive input
+type OutputCoordinator struct {
+	mu              sync.Mutex
+	program         *tea.Program
+	inputVisible    atomic.Bool
+	inputModel      *InputModel      // Reference to current input model for state restoration
+	restartCallback func(*InputModel) // Callback to restart the program with preserved state
+}
+
+var (
+	globalCoordinator *OutputCoordinator
+	coordinatorMu     sync.Mutex
+)
+
+// GetCoordinator returns the global output coordinator instance
+func GetCoordinator() *OutputCoordinator {
+	coordinatorMu.Lock()
+	defer coordinatorMu.Unlock()
+
+	if globalCoordinator == nil {
+		globalCoordinator = &OutputCoordinator{}
+	}
+	return globalCoordinator
+}
+
+// SetProgram sets the bubbletea program for input coordination
+func (oc *OutputCoordinator) SetProgram(program *tea.Program) {
+	oc.mu.Lock()
+	defer oc.mu.Unlock()
+	oc.program = program
+}
+
+// SetInputModel sets the current input model reference for state preservation
+func (oc *OutputCoordinator) SetInputModel(model *InputModel) {
+	oc.mu.Lock()
+	defer oc.mu.Unlock()
+	oc.inputModel = model
+}
+
+// SetRestartCallback sets the callback for restarting the program
+func (oc *OutputCoordinator) SetRestartCallback(callback func(*InputModel)) {
+	oc.mu.Lock()
+	defer oc.mu.Unlock()
+	oc.restartCallback = callback
+}
+
+// SetInputVisible sets whether input is currently visible
+func (oc *OutputCoordinator) SetInputVisible(visible bool) {
+	oc.inputVisible.Store(visible)
+}
+
+// IsInputVisible returns whether input is currently visible
+func (oc *OutputCoordinator) IsInputVisible() bool {
+	return oc.inputVisible.Load()
+}
+
+// Printf prints formatted output, suspending input if necessary
+func (oc *OutputCoordinator) Printf(format string, args ...interface{}) {
+	oc.mu.Lock()
+	prog := oc.program
+	model := oc.inputModel
+	restart := oc.restartCallback
+	visible := oc.inputVisible.Load()
+	oc.mu.Unlock()
+
+	if visible && prog != nil && restart != nil && model != nil {
+		// Kill/restart approach: completely stop the program, print, restart with state
+
+		// 1. Save the current input state (text, cursor position, etc.)
+		savedModel := model.Clone()
+
+		// 2. Manually clear the form from terminal BEFORE quitting
+		clearCodes := model.ClearScreen()
+		if clearCodes != "" {
+			fmt.Print(clearCodes)
+		}
+
+		// 3. Quit the program
+		prog.Send(Quit())
+
+		// Small delay to let program actually quit
+		time.Sleep(20 * time.Millisecond)
+
+		// 4. Print the output
+		fmt.Printf(format, args...)
+
+		// 5. Restart with preserved state
+		restart(savedModel)
+	} else {
+		// No input showing, just print normally
+		fmt.Printf(format, args...)
+	}
+}
+
+// Println prints a line with newline, suspending input if necessary
+func (oc *OutputCoordinator) Println(args ...interface{}) {
+	oc.Printf("%s\n", fmt.Sprint(args...))
+}
+
+// Print prints output, suspending input if necessary
+func (oc *OutputCoordinator) Print(args ...interface{}) {
+	oc.Printf("%s", fmt.Sprint(args...))
+}
+
+// Package-level convenience functions
+
+// Printf prints formatted output via the global coordinator
+func Printf(format string, args ...interface{}) {
+	GetCoordinator().Printf(format, args...)
+}
+
+// Println prints a line with newline via the global coordinator
+func Println(args ...interface{}) {
+	GetCoordinator().Println(args...)
+}
+
+// Print prints output via the global coordinator
+func Print(args ...interface{}) {
+	GetCoordinator().Print(args...)
+}
+
+// SetProgram sets the bubbletea program on the global coordinator
+func SetProgram(program *tea.Program) {
+	GetCoordinator().SetProgram(program)
+}
+
+// SetInputVisible sets input visibility on the global coordinator
+func SetInputVisible(visible bool) {
+	GetCoordinator().SetInputVisible(visible)
+}
+
+// IsInputVisible checks input visibility on the global coordinator
+func IsInputVisible() bool {
+	return GetCoordinator().IsInputVisible()
+}
+
+// SetInputModel sets the input model on the global coordinator
+func SetInputModel(model *InputModel) {
+	GetCoordinator().SetInputModel(model)
+}
+
+// SetRestartCallback sets the restart callback on the global coordinator
+func SetRestartCallback(callback func(*InputModel)) {
+	GetCoordinator().SetRestartCallback(callback)
+}
+
+// Quit returns a Bubble Tea quit message
+func Quit() tea.Msg {
+	return tea.Quit()
+}

cli/pkg/cli/output/input_model.go

@@ -0,0 +1,497 @@
+package output
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/textarea"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// InputType represents the type of input being collected
+type InputType int
+
+const INPUT_WIDTH = 46 
+
+const (
+	InputTypeMessage InputType = iota
+	InputTypeApproval
+	InputTypeFeedback
+)
+
+// InputSubmitMsg is sent when the user submits input
+type InputSubmitMsg struct {
+	Value          string
+	InputType      InputType
+	Approved       bool // For approval type
+	NeedsFeedback  bool // For approval type
+	NoAskAgain     bool // For approval type - indicates "don't ask again" was selected
+}
+
+// InputCancelMsg is sent when the user cancels input (Ctrl+C)
+type InputCancelMsg struct{}
+
+// ChangeInputTypeMsg changes the current input type
+type ChangeInputTypeMsg struct {
+	InputType InputType
+	Title     string
+	Placeholder string
+}
+
+// editorFinishedMsg is sent when the external editor finishes
+type editorFinishedMsg struct {
+	content []byte
+	err     error
+}
+
+// InputModel is the bubbletea model for interactive input
+type InputModel struct {
+	textarea    textarea.Model
+	suspended   bool
+	savedValue  string
+	inputType   InputType
+	title       string
+	placeholder string
+	currentMode string // "plan" or "act"
+	width       int
+	lastHeight  int    // Track height for cleanup on submit
+
+	// For approval type
+	approvalOptions []string
+	selectedOption  int
+	pendingApproval bool // Stores approval decision when transitioning to feedback input
+
+	// Styles (huh-inspired theme)
+	styles fieldStyles
+}
+
+// fieldStyles holds the styling for the input field
+type fieldStyles struct {
+	base           lipgloss.Style
+	title          lipgloss.Style
+	textArea       lipgloss.Style
+	cursor         lipgloss.Style
+	placeholder    lipgloss.Style
+	selector       lipgloss.Style
+	selectedOption lipgloss.Style
+	option         lipgloss.Style
+}
+
+// newFieldStyles creates huh-inspired styles (Charm theme)
+func newFieldStyles() fieldStyles {
+	// Charm theme colors
+	indigo := lipgloss.AdaptiveColor{Light: "#5A56E0", Dark: "#7571F9"}
+	fuchsia := lipgloss.Color("#F780E2")
+	normalFg := lipgloss.AdaptiveColor{Light: "235", Dark: "252"}
+	green := lipgloss.AdaptiveColor{Light: "#02BA84", Dark: "#02BF87"}
+
+	return fieldStyles{
+		base: lipgloss.NewStyle().
+			PaddingLeft(1).
+			BorderStyle(lipgloss.ThickBorder()).
+			BorderLeft(true).
+			BorderForeground(lipgloss.Color("238")),
+		title: lipgloss.NewStyle().
+			Foreground(indigo).
+			Bold(true),
+		textArea: lipgloss.NewStyle().
+			Foreground(normalFg),
+		cursor: lipgloss.NewStyle().
+			Foreground(green),
+		placeholder: lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "248", Dark: "238"}),
+		selector: lipgloss.NewStyle().
+			Foreground(fuchsia).
+			SetString("> "),
+		selectedOption: lipgloss.NewStyle().
+			Foreground(normalFg),
+		option: lipgloss.NewStyle().
+			Foreground(normalFg),
+	}
+}
+
+// NewInputModel creates a new input model
+func NewInputModel(inputType InputType, title, placeholder, currentMode string) InputModel {
+	ta := textarea.New()
+	ta.Placeholder = placeholder
+	ta.Focus()
+	ta.CharLimit = 0
+	ta.ShowLineNumbers = false
+	ta.Prompt = ""  // Remove prompt prefix (this is what adds the inner border!)
+	ta.SetHeight(5)
+	// Don't set width here - let WindowSizeMsg handle it
+	ta.SetWidth(INPUT_WIDTH)
+
+	// Configure keybindings like huh does:
+	// alt+enter and ctrl+j for newlines (textarea will handle these)
+	ta.KeyMap.InsertNewline.SetKeys("alt+enter", "ctrl+j")
+
+	// Apply huh-like styling
+	styles := newFieldStyles()
+
+	// Set cursor color based on mode
+	cursorColor := lipgloss.Color("3") // Yellow for plan
+	if currentMode == "act" {
+		cursorColor = lipgloss.Color("39") // Blue for act
+	}
+
+	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()   // No cursor line highlighting
+	ta.FocusedStyle.EndOfBuffer = lipgloss.NewStyle()  // No end-of-buffer styling
+	ta.FocusedStyle.Placeholder = styles.placeholder
+	ta.FocusedStyle.Text = styles.textArea
+	ta.FocusedStyle.Prompt = lipgloss.NewStyle()       // No prompt styling
+	ta.Cursor.Style = lipgloss.NewStyle().Foreground(cursorColor)
+	ta.Cursor.TextStyle = styles.textArea
+
+	m := InputModel{
+		textarea:    ta,
+		inputType:   inputType,
+		title:       title,
+		placeholder: placeholder,
+		currentMode: currentMode,
+		width:       0, // Will be set by first WindowSizeMsg
+		styles:      styles,
+	}
+
+	// For approval type, set up options
+	if inputType == InputTypeApproval {
+		m.approvalOptions = []string{
+			"Yes",
+			"Yes, and don't ask again for this task",
+			"No, with feedback",
+		}
+		m.selectedOption = 0
+	}
+
+	return m
+}
+
+// Init initializes the model
+func (m *InputModel) Init() tea.Cmd {
+	return textarea.Blink
+}
+
+// Update handles messages
+func (m *InputModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case editorFinishedMsg:
+		// External editor finished
+		if msg.err == nil && len(msg.content) > 0 {
+			m.textarea.SetValue(string(msg.content))
+		}
+		return m, nil
+
+	case SuspendInputMsg:
+		// Save current value and suspend
+		m.savedValue = m.textarea.Value()
+		m.suspended = true
+		return m, tea.ClearScreen
+
+	case ResumeInputMsg:
+		// Restore value and resume
+		m.textarea.SetValue(m.savedValue)
+		m.suspended = false
+		return m, nil
+
+	case ChangeInputTypeMsg:
+		// Change input type (e.g., from approval to feedback)
+		m.inputType = msg.InputType
+		m.title = msg.Title
+		m.placeholder = msg.Placeholder
+		m.textarea.Placeholder = msg.Placeholder
+		m.textarea.SetValue("")
+		m.textarea.Focus()
+
+		if msg.InputType == InputTypeApproval {
+			m.approvalOptions = []string{
+				"Yes",
+				"Yes, and don't ask again for this task",
+				"No, with feedback",
+			}
+			m.selectedOption = 0
+		}
+		return m, nil
+
+	default:
+		// Forward all other messages to textarea (including blink ticks)
+		if !m.suspended && (m.inputType == InputTypeMessage || m.inputType == InputTypeFeedback) {
+			m.textarea, cmd = m.textarea.Update(msg)
+			return m, cmd
+		}
+
+	case tea.KeyMsg:
+		if m.suspended {
+			return m, nil
+		}
+
+		// Handle keys for text input types (Message/Feedback)
+		if m.inputType == InputTypeMessage || m.inputType == InputTypeFeedback {
+			switch msg.String() {
+			case "ctrl+c":
+				return m, func() tea.Msg { return InputCancelMsg{} }
+
+			case "ctrl+e":
+				// Open external editor (like huh does)
+				return m, m.openEditor()
+
+			case "enter":
+				// Intercept enter for submit (textarea handles alt+enter and ctrl+j for newlines)
+				return m.handleSubmit()
+
+			case "up", "down", "left", "right":
+				// Let textarea handle navigation
+				m.textarea, cmd = m.textarea.Update(msg)
+				return m, cmd
+			}
+
+			// Pass all other keys to textarea (including alt+enter, ctrl+j for newlines)
+			m.textarea, cmd = m.textarea.Update(msg)
+			return m, cmd
+		}
+
+		// Handle keys for approval type
+		if m.inputType == InputTypeApproval {
+			switch msg.String() {
+			case "ctrl+c":
+				return m, func() tea.Msg { return InputCancelMsg{} }
+
+			case "enter":
+				return m.handleSubmit()
+
+			case "up":
+				if m.selectedOption > 0 {
+					m.selectedOption--
+				}
+				return m, nil
+
+			case "down":
+				if m.selectedOption < len(m.approvalOptions)-1 {
+					m.selectedOption++
+				}
+				return m, nil
+			}
+		}
+	}
+
+	return m, nil
+}
+
+// handleSubmit handles submission based on input type
+func (m *InputModel) handleSubmit() (tea.Model, tea.Cmd) {
+	switch m.inputType {
+	case InputTypeMessage:
+		value := strings.TrimSpace(m.textarea.Value())
+		return m, func() tea.Msg {
+			return InputSubmitMsg{
+				Value:     value,
+				InputType: InputTypeMessage,
+			}
+		}
+
+	case InputTypeApproval:
+		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
+			m.pendingApproval = approved
+			// Switch to feedback input
+			return m, func() tea.Msg {
+				return ChangeInputTypeMsg{
+					InputType:   InputTypeFeedback,
+					Title:       "Your feedback",
+					Placeholder: "/plan or /act to switch modes\nctrl+e to open editor",
+				}
+			}
+		}
+
+		return m, func() tea.Msg {
+			return InputSubmitMsg{
+				Value:         "",
+				InputType:     InputTypeApproval,
+				Approved:      approved,
+				NeedsFeedback: false,
+				NoAskAgain:    noAskAgain,
+			}
+		}
+
+	case InputTypeFeedback:
+		value := strings.TrimSpace(m.textarea.Value())
+		return m, func() tea.Msg {
+			return InputSubmitMsg{
+				Value:     value,
+				InputType: InputTypeFeedback,
+				Approved:  m.pendingApproval, // Pass the stored approval decision
+			}
+		}
+	}
+
+	return m, nil
+}
+
+// View renders the model
+func (m *InputModel) View() string {
+	if m.suspended {
+		return ""
+	}
+
+	var parts []string
+
+	// Render title with mode indicator
+	yellow := lipgloss.Color("3")
+	blue := lipgloss.Color("39")
+
+	modeStyle := lipgloss.NewStyle().Bold(true)
+	if m.currentMode == "plan" {
+		modeStyle = modeStyle.Foreground(yellow)
+	} else {
+		modeStyle = modeStyle.Foreground(blue)
+	}
+
+	modeIndicator := modeStyle.Render(fmt.Sprintf("[%s mode]", m.currentMode))
+	titleText := m.styles.title.Render(m.title)
+	fullTitle := fmt.Sprintf("%s %s", modeIndicator, titleText)
+	parts = append(parts, fullTitle)
+
+	// Render based on input type
+	switch m.inputType {
+	case InputTypeMessage, InputTypeFeedback:
+		parts = append(parts, m.textarea.View())
+
+	case InputTypeApproval:
+		var options []string
+		for i, option := range m.approvalOptions {
+			if i == m.selectedOption {
+				options = append(options, m.styles.selector.Render("")+m.styles.selectedOption.Render(option))
+			} else {
+				options = append(options, "  "+m.styles.option.Render(option))
+			}
+		}
+		parts = append(parts, strings.Join(options, "\n"))
+	}
+
+	// Wrap everything in the base style with border
+	content := strings.Join(parts, "\n")
+	rendered := m.styles.base.Render(content)
+
+	// Add newline before the form (outside the border)
+	rendered = "\n" + rendered
+
+	// Track height for cleanup
+	m.lastHeight = lipgloss.Height(rendered)
+
+	return rendered
+}
+
+// ClearScreen returns the ANSI codes to clear the input from the terminal
+// This is used when submitting to remove the form cleanly
+func (m *InputModel) ClearScreen() string {
+	if m.lastHeight == 0 {
+		return ""
+	}
+
+	// Move cursor up by lastHeight lines and clear from cursor to end of screen
+	return fmt.Sprintf("\033[%dA\033[J", m.lastHeight)
+}
+
+// Clone creates a deep copy of the InputModel with all state preserved
+func (m *InputModel) Clone() *InputModel {
+	// Create new textarea with same configuration
+	ta := textarea.New()
+	ta.SetValue(m.textarea.Value())
+	ta.Placeholder = m.placeholder
+	ta.CharLimit = 0
+	ta.ShowLineNumbers = false
+	ta.Prompt = ""
+	ta.SetHeight(5)
+	ta.SetWidth(INPUT_WIDTH) 
+	ta.Focus()
+
+	// Configure keybindings
+	ta.KeyMap.InsertNewline.SetKeys("alt+enter", "ctrl+j")
+
+	// Apply styles (including mode-based cursor color)
+	cursorColor := lipgloss.Color("3") // Yellow for plan
+	if m.currentMode == "act" {
+		cursorColor = lipgloss.Color("39") // Blue for act
+	}
+
+	ta.FocusedStyle.CursorLine = lipgloss.NewStyle()
+	ta.FocusedStyle.EndOfBuffer = lipgloss.NewStyle()
+	ta.FocusedStyle.Placeholder = m.styles.placeholder
+	ta.FocusedStyle.Text = m.styles.textArea
+	ta.FocusedStyle.Prompt = lipgloss.NewStyle()
+	ta.Cursor.Style = lipgloss.NewStyle().Foreground(cursorColor)
+	ta.Cursor.TextStyle = m.styles.textArea
+
+	// Create cloned model
+	clone := &InputModel{
+		textarea:        ta,
+		suspended:       false, // New program starts unsuspended
+		savedValue:      m.savedValue,
+		inputType:       m.inputType,
+		title:           m.title,
+		placeholder:     m.placeholder,
+		currentMode:     m.currentMode,
+		width:           m.width,
+		lastHeight:      m.lastHeight,
+		approvalOptions: m.approvalOptions,
+		selectedOption:  m.selectedOption,
+		pendingApproval: m.pendingApproval, // Preserve approval decision
+		styles:          m.styles,
+	}
+
+	return clone
+}
+
+// openEditor opens an external editor for composing the message
+func (m *InputModel) openEditor() tea.Cmd {
+	// Get editor from environment or use nano as default
+	editorCmd := "nano"
+	editorArgs := []string{}
+
+	if editor := os.Getenv("EDITOR"); editor != "" {
+		editorFields := strings.Fields(editor)
+		if len(editorFields) > 0 {
+			editorCmd = editorFields[0]
+			if len(editorFields) > 1 {
+				editorArgs = editorFields[1:]
+			}
+		}
+	}
+
+	// Create temp file with current content
+	tmpFile, err := os.CreateTemp(os.TempDir(), "*.md")
+	if err != nil {
+		return func() tea.Msg {
+			return editorFinishedMsg{err: err}
+		}
+	}
+
+	// Write current textarea value to temp file
+	if err := os.WriteFile(tmpFile.Name(), []byte(m.textarea.Value()), 0o644); err != nil {
+		return func() tea.Msg {
+			return editorFinishedMsg{err: err}
+		}
+	}
+
+	// Open the editor
+	cmd := exec.Command(editorCmd, append(editorArgs, tmpFile.Name())...)
+	return tea.ExecProcess(cmd, func(err error) tea.Msg {
+		content, readErr := os.ReadFile(tmpFile.Name())
+		_ = os.Remove(tmpFile.Name())
+
+		if readErr != nil {
+			return editorFinishedMsg{err: readErr}
+		}
+
+		return editorFinishedMsg{content: content, err: err}
+	})
+}

cli/pkg/cli/sqlite/locks.go

@@ -11,7 +11,7 @@ import (
 	"time"
 
 	"github.com/cline/cli/pkg/common"
-	_ "github.com/mattn/go-sqlite3"
+	_ "github.com/glebarez/go-sqlite"
 	"google.golang.org/grpc/health/grpc_health_v1"
 )
 
@@ -60,7 +60,7 @@ func NewLockManager(clineDir string) (*LockManager, error) {
 	}
 
 	// Database exists - open it normally (no schema creation)
-	db, err := sql.Open("sqlite3", dbPath)
+	db, err := sql.Open("sqlite", dbPath)
 	if err != nil {
 		// If we can't open existing database, return nil db manager
 		return &LockManager{dbPath: dbPath, db: nil}, nil
@@ -92,7 +92,7 @@ func (lm *LockManager) ensureConnection() error {
 	}
 
 	// Database exists, try to connect
-	db, err := sql.Open("sqlite3", lm.dbPath)
+	db, err := sql.Open("sqlite", lm.dbPath)
 	if err != nil {
 		return fmt.Errorf("failed to connect to database: %w", err)
 	}

cli/pkg/cli/task.go

@@ -10,20 +10,23 @@ import (
 	"strconv"
 	"strings"
 
+	"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"
 )
 
 // TaskOptions contains options for creating a task
 type TaskOptions struct {
-	Images     []string
-	Files      []string
-	Workspaces []string
-	Mode       string
-	Settings   []string
-	Yolo       bool
-	Address    string
+	Images   []string
+	Files    []string
+	Mode     string
+	Settings []string
+	Yolo     bool
+	Address  string
+	Verbose  bool
 }
 
 func NewTaskCommand() *cobra.Command {
@@ -35,13 +38,12 @@ func NewTaskCommand() *cobra.Command {
 	}
 
 	cmd.AddCommand(newTaskNewCommand())
-	cmd.AddCommand(newTaskOneshotCommand())
-	cmd.AddCommand(newTaskCancelCommand())
-	cmd.AddCommand(newTaskFollowCommand())
-	cmd.AddCommand(NewTaskSendCommand())
+	cmd.AddCommand(newTaskPauseCommand())
+	cmd.AddCommand(newTaskChatCommand())
+	cmd.AddCommand(newTaskSendCommand())
 	cmd.AddCommand(newTaskViewCommand())
 	cmd.AddCommand(newTaskListCommand())
-	cmd.AddCommand(newTaskResumeCommand())
+	cmd.AddCommand(newTaskOpenCommand())
 	cmd.AddCommand(newTaskRestoreCommand())
 
 	return cmd
@@ -96,13 +98,12 @@ func ensureInstanceAtAddress(ctx context.Context, address string) error {
 
 func newTaskNewCommand() *cobra.Command {
 	var (
-		images     []string
-		files      []string
-		workspaces []string
-		address    string
-		mode       string
-		settings   []string
-		yolo       bool
+		images   []string
+		files    []string
+		address  string
+		mode     string
+		settings []string
+		yolo     bool
 	)
 
 	cmd := &cobra.Command{
@@ -114,6 +115,12 @@ func newTaskNewCommand() *cobra.Command {
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 
+			// Check if an instance exists when no address specified
+			if address == "" && global.Clients.GetRegistry().GetDefaultInstance() == "" {
+				fmt.Println("No instances available for creating tasks")
+				return nil
+			}
+
 			// Get content from both args and stdin
 			prompt, err := getContentFromStdinAndArgs(args)
 			if err != nil {
@@ -149,7 +156,7 @@ func newTaskNewCommand() *cobra.Command {
 			}
 
 			// Create the task
-			taskID, err := taskManager.CreateTask(ctx, prompt, images, files, workspaces, settings)
+			taskID, err := taskManager.CreateTask(ctx, prompt, images, files, settings)
 			if err != nil {
 				return fmt.Errorf("failed to create task: %w", err)
 			}
@@ -164,90 +171,22 @@ func newTaskNewCommand() *cobra.Command {
 
 	cmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
 	cmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	cmd.Flags().StringSliceVarP(&workspaces, "workdir", "w", nil, "workdir directory paths")
 	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
 	cmd.Flags().StringVarP(&mode, "mode", "m", "", "mode (act|plan)")
 	cmd.Flags().StringSliceVarP(&settings, "setting", "s", nil, "task settings (key=value format, e.g., -s aws-region=us-west-2 -s mode=act)")
 	cmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
+	cmd.Flags().BoolVar(&yolo, "no-interactive", false, "enable yolo mode (non-interactive)")
 
 	return cmd
 }
 
-func newTaskOneshotCommand() *cobra.Command {
-	var (
-		images     []string
-		files      []string
-		workspaces []string
-		address    string
-		settings   []string
-	)
-
-	cmd := &cobra.Command{
-		Use:     "oneshot <prompt>",
-		Aliases: []string{"o"},
-		Short:   "Create a task in yolo+plan mode and view until completion",
-		Long:    `Creates a new task in yolo mode (non-interactive) and plan mode, then streams the conversation until completion.`,
-		Args:    cobra.MinimumNArgs(0),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Get prompt from args/stdin
-			prompt, err := getContentFromStdinAndArgs(args)
-			if err != nil {
-				return fmt.Errorf("failed to read prompt: %w", err)
-			}
-
-			if prompt == "" {
-				return fmt.Errorf("prompt required: provide as argument or pipe via stdin")
-			}
-
-			// Ensure task manager
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			// Set mode to plan
-			if err := taskManager.SetMode(ctx, "plan", nil, nil, nil); err != nil {
-				return fmt.Errorf("failed to set plan mode: %w", err)
-			}
-
-			if global.Config.Verbose {
-				fmt.Println("Mode set to: plan")
-			}
-
-			// Inject yolo mode into settings
-			settings = append(settings, "yolo_mode_toggled=true")
-
-			// Create task
-			taskID, err := taskManager.CreateTask(ctx, prompt, images, files, workspaces, settings)
-			if err != nil {
-				return fmt.Errorf("failed to create task: %w", err)
-			}
-
-			fmt.Printf("Task created in yolo+plan mode (ID: %s)\n", taskID)
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			// Follow until completion
-			return taskManager.FollowConversationUntilCompletion(ctx)
-		},
-	}
-
-	cmd.Flags().StringSliceVarP(&images, "image", "i", nil, "attach image files")
-	cmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
-	cmd.Flags().StringSliceVarP(&workspaces, "workdir", "w", nil, "workdir directory paths")
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
-	cmd.Flags().StringSliceVarP(&settings, "setting", "s", nil, "task settings (key=value format, e.g., -s model=claude)")
-
-	return cmd
-}
-
-func newTaskCancelCommand() *cobra.Command {
+func newTaskPauseCommand() *cobra.Command {
 	var address string
 
 	cmd := &cobra.Command{
-		Use:     "cancel",
-		Aliases: []string{"c"},
-		Short:   "Cancel the current task",
+		Use:     "pause",
+		Aliases: []string{"p"},
+		Short:   "Pause the current task",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 
@@ -259,7 +198,7 @@ func newTaskCancelCommand() *cobra.Command {
 				return err
 			}
 
-			fmt.Println("Task cancelled successfully")
+			fmt.Println("Task paused successfully")
 			fmt.Printf("Instance: %s\n", taskManager.GetCurrentInstance())
 			return nil
 		},
@@ -269,13 +208,15 @@ func newTaskCancelCommand() *cobra.Command {
 	return cmd
 }
 
-func NewTaskSendCommand() *cobra.Command {
+func newTaskSendCommand() *cobra.Command {
 	var (
 		images  []string
 		files   []string
 		address string
 		mode    string
-		approve string
+		approve bool
+		deny    bool
+		yolo    bool
 	)
 
 	cmd := &cobra.Command{
@@ -287,22 +228,28 @@ func NewTaskSendCommand() *cobra.Command {
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
 
+			// Check if an instance exists when no address specified
+			if address == "" && global.Clients.GetRegistry().GetDefaultInstance() == "" {
+				fmt.Println("No instances available for sending messages")
+				return nil
+			}
+
 			// Get content from both args and stdin
 			message, err := getContentFromStdinAndArgs(args)
 			if err != nil {
 				return fmt.Errorf("failed to read message: %w", err)
 			}
 
-			if message == "" && len(images) == 0 && len(files) == 0 && mode == "" && approve == "" {
-				return fmt.Errorf("content (message, files, images) required unless using --mode or --approve flags")
+			if message == "" && len(images) == 0 && len(files) == 0 && mode == "" && !approve && !deny {
+				return fmt.Errorf("content (message, files, images) required unless using --mode, --approve, or --deny flags")
 			}
 
-			if approve != "" && approve != "true" && approve != "false" {
-				return fmt.Errorf("--approve must be 'true' or 'false'")
+			if approve && deny {
+				return fmt.Errorf("cannot use both --approve and --deny flags")
 			}
 
-			if approve != "" && mode != "" {
-				return fmt.Errorf("cannot use --approve and --mode together")
+			if (approve || deny) && mode != "" {
+				return fmt.Errorf("cannot use --approve/--deny and --mode together")
 			}
 
 			// Ensure task manager is initialized
@@ -326,6 +273,24 @@ func NewTaskSendCommand() *cobra.Command {
 				return fmt.Errorf("failed to check if message can be sent: %w", err)
 			}
 
+			// Process yolo flag and apply settings
+			if yolo {
+				settings := []string{"yolo_mode_toggled=true"}
+				parsedSettings, secrets, err := task.ParseTaskSettings(settings)
+				if err != nil {
+					return fmt.Errorf("failed to parse settings: %w", err)
+				}
+
+				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, parsedSettings, secrets); err != nil {
+					return fmt.Errorf("failed to apply settings: %w", err)
+				}
+			}
+
 			if mode != "" {
 				if err := taskManager.SetModeAndSendMessage(ctx, mode, message, images, files); err != nil {
 					return fmt.Errorf("failed to set mode and send message: %w", err)
@@ -333,7 +298,16 @@ func NewTaskSendCommand() *cobra.Command {
 				fmt.Printf("Mode set to %s and message sent successfully.\n", mode)
 
 			} else {
-				if err := taskManager.SendMessage(ctx, message, images, files, approve); err != nil {
+				// Convert approve/deny booleans to string
+				approveStr := ""
+				if approve {
+					approveStr = "true"
+				}
+				if deny {
+					approveStr = "false"
+				}
+
+				if err := taskManager.SendMessage(ctx, message, images, files, approveStr); err != nil {
 					return err
 				}
 				fmt.Printf("Message sent successfully.\n")
@@ -348,19 +322,22 @@ func NewTaskSendCommand() *cobra.Command {
 	cmd.Flags().StringSliceVarP(&files, "file", "f", nil, "attach files")
 	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
 	cmd.Flags().StringVarP(&mode, "mode", "m", "", "mode (act|plan)")
-	cmd.Flags().StringVarP(&approve, "approve", "a", "", "approve (true) or deny (false) pending request")
+	cmd.Flags().BoolVarP(&approve, "approve", "a", false, "approve pending request")
+	cmd.Flags().BoolVarP(&deny, "deny", "d", false, "deny pending request")
+	cmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
+	cmd.Flags().BoolVar(&yolo, "no-interactive", false, "enable yolo mode (non-interactive)")
 
 	return cmd
 }
 
-func newTaskFollowCommand() *cobra.Command {
+func newTaskChatCommand() *cobra.Command {
 	var address string
 
 	cmd := &cobra.Command{
-		Use:     "follow",
-		Aliases: []string{"f"},
-		Short:   "Follow current task conversation in real-time",
-		Long:    `Follow the current task conversation, displaying new messages as they arrive in real-time. Interactive input is enabled by default.`,
+		Use:     "chat",
+		Aliases: []string{"c"},
+		Short:   "Chat with the current task in interactive mode",
+		Long:    `Chat with the current task, displaying messages in real-time with interactive input enabled.`,
 		Args:    cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -369,6 +346,18 @@ func newTaskFollowCommand() *cobra.Command {
 				return err
 			}
 
+			// Check if there's an active task before entering follow mode
+			err := taskManager.CheckSendEnabled(ctx)
+			if err != nil {
+				// Handle specific error cases
+				if errors.Is(err, task.ErrNoActiveTask) {
+					fmt.Println("No active task found. Use 'cline task new' to create a task first.")
+					return nil
+				}
+				// For other errors (like task busy), we can still enter follow mode
+				// as the user may want to observe the task
+			}
+
 			return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
 		},
 	}
@@ -380,16 +369,16 @@ func newTaskFollowCommand() *cobra.Command {
 
 func newTaskViewCommand() *cobra.Command {
 	var (
-		current bool
-		summary bool
-		address string
+		follow         bool
+		followComplete bool
+		address        string
 	)
 
 	cmd := &cobra.Command{
 		Use:     "view",
 		Aliases: []string{"v"},
 		Short:   "View task conversation",
-		Long:    `Output conversation until next completion, with options for current state or summary only.`,
+		Long:    `Output conversation snapshot by default, or follow with flags.`,
 		Args:    cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -400,26 +389,27 @@ func newTaskViewCommand() *cobra.Command {
 
 			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
 
-			if current {
-				return taskManager.ShowConversation(ctx)
-			} else if summary {
-				return taskManager.GatherFinalSummary(ctx)
-			} else {
+			if follow {
+				// Follow conversation forever (non-interactive)
+				return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), false)
+			} else if followComplete {
+				// Follow until completion
 				return taskManager.FollowConversationUntilCompletion(ctx)
+			} else {
+				// Default: show snapshot
+				return taskManager.ShowConversation(ctx)
 			}
 		},
 	}
 
-	cmd.Flags().BoolVarP(&current, "current", "c", false, "output current conversation without following")
-	cmd.Flags().BoolVarP(&summary, "summary", "s", false, "outputs only the completion summary")
+	cmd.Flags().BoolVarP(&follow, "follow", "f", false, "follow conversation forever")
+	cmd.Flags().BoolVarP(&followComplete, "follow-complete", "c", false, "follow until completion")
 	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
 
 	return cmd
 }
 
 func newTaskListCommand() *cobra.Command {
-	var address string
-
 	cmd := &cobra.Command{
 		Use:     "list",
 		Aliases: []string{"l"},
@@ -427,31 +417,27 @@ func newTaskListCommand() *cobra.Command {
 		Long:    `Display recent tasks from task history.`,
 		Args:    cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx := cmd.Context()
-
-			// Ensure task manager is initialized
-			if err := ensureTaskManager(ctx, address); err != nil {
-				return err
-			}
-
-			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
-
-			return taskManager.ListTasks(ctx)
+			// Read directly from disk
+			return task.ListTasksFromDisk()
 		},
 	}
 
-	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
 	return cmd
 }
 
-func newTaskResumeCommand() *cobra.Command {
-	var address string
+func newTaskOpenCommand() *cobra.Command {
+	var (
+		address  string
+		mode     string
+		settings []string
+		yolo     bool
+	)
 
 	cmd := &cobra.Command{
-		Use:     "resume <task-id>",
-		Aliases: []string{"r"},
-		Short:   "Resume a task by ID",
-		Long:    `Resume an existing task by ID.`,
+		Use:     "open <task-id>",
+		Aliases: []string{"o"},
+		Short:   "Open a task by ID",
+		Long:    `Open an existing task by ID and optionally update settings or mode.`,
 		Args:    cobra.ExactArgs(1),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := cmd.Context()
@@ -464,11 +450,74 @@ func newTaskResumeCommand() *cobra.Command {
 
 			fmt.Printf("Using instance: %s\n", taskManager.GetCurrentInstance())
 
-			return taskManager.ResumeTask(ctx, taskID)
+			// Resume the task
+			if err := taskManager.ResumeTask(ctx, taskID); err != nil {
+				return err
+			}
+
+			// Apply mode if provided
+			if mode != "" {
+				if err := taskManager.SetMode(ctx, mode, nil, nil, nil); err != nil {
+					return fmt.Errorf("failed to set mode: %w", err)
+				}
+				if global.Config.Verbose {
+					fmt.Printf("Mode set to: %s\n", mode)
+				}
+			}
+
+			// Process yolo flag and apply settings
+			if yolo {
+				settings = append(settings, "yolo_mode_toggled=true")
+			}
+
+			if len(settings) > 0 {
+				// Parse settings using existing parser
+				parsedSettings, secrets, err := task.ParseTaskSettings(settings)
+				if err != nil {
+					return fmt.Errorf("failed to parse settings: %w", err)
+				}
+
+				// Apply task-specific settings using UpdateTaskSettings RPC
+				if parsedSettings != nil {
+					_, err = taskManager.GetClient().State.UpdateTaskSettings(ctx, &cline.UpdateTaskSettingsRequest{
+						Settings: parsedSettings,
+						TaskId:   &taskID,
+					})
+					if err != nil {
+						return fmt.Errorf("failed to apply task settings: %w", err)
+					}
+					if global.Config.Verbose {
+						fmt.Println("Task-specific settings applied successfully")
+					}
+				}
+
+				// 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")
+					}
+				}
+			}
+
+			return nil
 		},
 	}
 
 	cmd.Flags().StringVar(&address, "address", "", "specific Cline instance address to use")
+	cmd.Flags().StringVarP(&mode, "mode", "m", "", "mode (act|plan)")
+	cmd.Flags().StringSliceVarP(&settings, "setting", "s", nil, "task settings (key=value format, e.g., -s model=claude)")
+	cmd.Flags().BoolVarP(&yolo, "yolo", "y", false, "enable yolo mode (non-interactive)")
+	cmd.Flags().BoolVar(&yolo, "no-interactive", false, "enable yolo mode (non-interactive)")
+
 	return cmd
 }
 
@@ -543,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)
-		}
+		// 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(" ")
+			stdinContent := strings.TrimSpace(string(stdinBytes))
+			if stdinContent != "" {
+				if content.Len() > 0 {
+					content.WriteString(" ")
+				}
+				content.WriteString(stdinContent)
 			}
-			content.WriteString(stdinContent)
 		}
 	}
 
@@ -601,7 +653,7 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 	}
 
 	// Create the task
-	taskID, err := taskManager.CreateTask(ctx, prompt, opts.Images, opts.Files, opts.Workspaces, opts.Settings)
+	taskID, err := taskManager.CreateTask(ctx, prompt, opts.Images, opts.Files, opts.Settings)
 	if err != nil {
 		return fmt.Errorf("failed to create task: %w", err)
 	}
@@ -610,6 +662,14 @@ func CreateAndFollowTask(ctx context.Context, prompt string, opts TaskOptions) e
 		fmt.Printf("Task created successfully with ID: %s\n\n", taskID)
 	}
 
-	// Immediately follow the conversation in interactive mode
-	return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
+	// 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 {
+		return taskManager.FollowConversationUntilCompletion(ctx)
+	} else {
+		return taskManager.FollowConversation(ctx, taskManager.GetCurrentInstance(), true)
+	}
 }

cli/pkg/cli/task/history_handler.go

@@ -0,0 +1,72 @@
+package task
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/cline/cli/pkg/cli/display"
+	"github.com/cline/cli/pkg/cli/global"
+	"github.com/cline/cli/pkg/cli/types"
+	"github.com/cline/grpc-go/cline"
+)
+
+// ListTasksFromDisk reads task history directly from disk
+func ListTasksFromDisk() error {
+	// Get the task history file path
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return fmt.Errorf("failed to get home directory: %w", err)
+	}
+
+	filePath := filepath.Join(homeDir, ".cline", "data", "state", "taskHistory.json")
+
+	// Read the file
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			fmt.Println("No task history found.")
+			return nil
+		}
+		return fmt.Errorf("failed to read task history: %w", err)
+	}
+
+	// Parse JSON into intermediate struct
+	var historyItems []types.HistoryItem
+	if err := json.Unmarshal(data, &historyItems); err != nil {
+		return fmt.Errorf("failed to parse task history: %w", err)
+	}
+
+	if len(historyItems) == 0 {
+		fmt.Println("No task history found.")
+		return nil
+	}
+
+	// Sort by timestamp ascending (oldest first, newest last)
+	sort.Slice(historyItems, func(i, j int) bool {
+		return historyItems[i].Ts < historyItems[j].Ts
+	})
+
+	// Convert to protobuf TaskItem format for rendering
+	tasks := make([]*cline.TaskItem, len(historyItems))
+	for i, item := range historyItems {
+		tasks[i] = &cline.TaskItem{
+			Id:          item.Id,
+			Task:        item.Task,
+			Ts:          item.Ts,
+			IsFavorited: item.IsFavorited,
+			Size:        item.Size,
+			TotalCost:   item.TotalCost,
+			TokensIn:    item.TokensIn,
+			TokensOut:   item.TokensOut,
+			CacheWrites: item.CacheWrites,
+			CacheReads:  item.CacheReads,
+		}
+	}
+
+	// Use existing renderer
+	renderer := display.NewRenderer(global.Config.OutputFormat)
+	return renderer.RenderTaskList(tasks)
+}

cli/pkg/cli/task/input_handler.go

@@ -2,35 +2,49 @@ package task
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/charmbracelet/huh"
+	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"
 )
 
 // 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
+	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
 func NewInputHandler(manager *Manager, coordinator *StreamCoordinator, cancelFunc context.CancelFunc) *InputHandler {
 	return &InputHandler{
-		manager:     manager,
-		coordinator: coordinator,
-		cancelFunc:  cancelFunc,
-		isRunning:   false,
-		pollTicker:  time.NewTicker(500 * time.Millisecond),
+		manager:      manager,
+		coordinator:  coordinator,
+		cancelFunc:   cancelFunc,
+		isRunning:    false,
+		pollTicker:   time.NewTicker(500 * time.Millisecond),
+		resultChan:   make(chan output.InputSubmitMsg, 1),
+		cancelChan:   make(chan struct{}, 1),
 	}
 }
 
@@ -45,6 +59,9 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 		ih.isRunning = false
 		ih.mu.Unlock()
 		ih.pollTicker.Stop()
+		if ih.program != nil {
+			ih.program.Quit()
+		}
 	}()
 
 	for {
@@ -56,7 +73,7 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 			needsApproval, approvalMsg, err := ih.manager.CheckNeedsApproval(ctx)
 			if err != nil {
 				if global.Config.Verbose {
-					fmt.Printf("\nDebug: CheckNeedsApproval error: %v\n", err)
+					output.Printf("\nDebug: CheckNeedsApproval error: %v\n", err)
 				}
 				continue
 			}
@@ -64,24 +81,18 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 			if needsApproval {
 				ih.coordinator.SetInputAllowed(true)
 
-				// Lock output to prevent race with streaming display
-				ih.coordinator.LockOutput()
-
 				// Show approval prompt
 				approved, feedback, err := ih.promptForApproval(ctx, approvalMsg)
 
-				// Unlock output after form dismissed
-				ih.coordinator.UnlockOutput()
-
 				if err != nil {
 					// Check if the error is due to interrupt (Ctrl+C) or context cancellation
-					if err == huh.ErrUserAborted || ctx.Err() != nil {
+					if errors.Is(err, context.Canceled) || ctx.Err() != nil {
 						// User pressed Ctrl+C - cancel context to exit FollowConversation
 						ih.cancelFunc()
 						return
 					}
 					if global.Config.Verbose {
-						fmt.Printf("\nDebug: Approval prompt error: %v\n", err)
+						output.Printf("\nDebug: Approval prompt error: %v\n", err)
 					}
 					continue
 				}
@@ -95,12 +106,12 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 				}
 
 				if err := ih.manager.SendMessage(ctx, feedback, nil, nil, approveStr); err != nil {
-					fmt.Printf("\nError sending approval: %v\n", err)
+					output.Printf("\nError sending approval: %v\n", err)
 					continue
 				}
 
 				if global.Config.Verbose {
-					fmt.Printf("\nDebug: Approval sent (approved=%s, feedback=%q)\n", approveStr, feedback)
+					output.Printf("\nDebug: Approval sent (approved=%s, feedback=%q)\n", approveStr, feedback)
 				}
 
 				// Give the system a moment to process before re-polling
@@ -124,7 +135,7 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 				}
 				// Unexpected error
 				if global.Config.Verbose {
-					fmt.Printf("\nDebug: CheckSendEnabled error: %v\n", err)
+					output.Printf("\nDebug: CheckSendEnabled error: %v\n", err)
 				}
 				continue
 			}
@@ -132,24 +143,18 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 			// If we reach here, we can send a message
 			ih.coordinator.SetInputAllowed(true)
 
-			// Lock output to prevent race with streaming display
-			ih.coordinator.LockOutput()
-
 			// Show prompt and get input
 			message, shouldSend, err := ih.promptForInput(ctx)
 
-			// Unlock output after form dismissed
-			ih.coordinator.UnlockOutput()
-
 			if err != nil {
 				// Check if the error is due to interrupt (Ctrl+C) or context cancellation
-				if err == huh.ErrUserAborted || ctx.Err() != nil {
+				if errors.Is(err, context.Canceled) || ctx.Err() != nil {
 					// User pressed Ctrl+C - cancel context to exit FollowConversation
 					ih.cancelFunc()
 					return
 				}
 				if global.Config.Verbose {
-					fmt.Printf("\nDebug: Input prompt error: %v\n", err)
+					output.Printf("\nDebug: Input prompt error: %v\n", err)
 				}
 				continue
 			}
@@ -160,21 +165,51 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 				// Check for mode switch commands first
 				newMode, remainingMessage, isModeSwitch := ih.parseModeSwitch(message)
 				if isModeSwitch {
-					// Switch mode
-					if err := ih.manager.SetMode(ctx, newMode, nil, nil, nil); err != nil {
-						fmt.Printf("\nError switching to %s mode: %v\n", newMode, err)
-						continue
-					}
-					fmt.Printf("\nSwitched to %s mode\n", newMode)
+					// 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 there's remaining message, use it as the new message to send
 					if remainingMessage != "" {
-						message = remainingMessage
+						// Switching with a message - behavior differs by mode
+						if newMode == "act" {
+							// Act mode: can send mode + message in one call
+							if err := ih.manager.SetMode(ctx, newMode, &remainingMessage, nil, nil); err != nil {
+								output.Printf("\nError switching to act mode with message: %v\n", err)
+								continue
+							}
+							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
+							}
+							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
+							if err := ih.manager.SendMessage(ctx, remainingMessage, nil, nil, ""); err != nil {
+								output.Printf("\nError sending message after mode switch: %v\n", err)
+								continue
+							}
+						}
 					} else {
-						// No message to send, just mode switch
-						time.Sleep(1 * time.Second)
-						continue
+						// Just switch mode, no message
+						if err := ih.manager.SetMode(ctx, newMode, nil, nil, nil); err != nil {
+							output.Printf("\nError switching to %s mode: %v\n", newMode, err)
+							continue
+						}
+						// Color based on mode
+						if newMode == "act" {
+							output.Printf("\n%s\n", actStyle.Render("Switched to act mode"))
+						} else {
+							output.Printf("\n%s\n", planStyle.Render("Switched to plan mode"))
+						}
 					}
+
+					// Mode switch handled, continue to next poll
+					time.Sleep(1 * time.Second)
+					continue
 				}
 
 				// Handle special commands
@@ -184,12 +219,12 @@ func (ih *InputHandler) Start(ctx context.Context, errChan chan error) {
 
 				// Send the message
 				if err := ih.manager.SendMessage(ctx, message, nil, nil, ""); err != nil {
-					fmt.Printf("\nError sending message: %v\n", err)
+					output.Printf("\nError sending message: %v\n", err)
 					continue
 				}
 
 				if global.Config.Verbose {
-					fmt.Printf("\nDebug: Message sent successfully\n")
+					output.Printf("\nDebug: Message sent successfully\n")
 				}
 
 				// Give the system a moment to process before re-polling
@@ -199,131 +234,256 @@ 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) {
-	// Add visual separation before the form
-	fmt.Println()
-
-	var message string
-
-	// Get current mode and format title with color
 	currentMode := ih.manager.GetCurrentMode()
 
-	// ANSI color codes
-	yellow := "\033[33m"      // Yellow for plan mode
-	blue := "\033[34m"        // Blue for act mode
-	indigo := "\033[38;5;99m" // Indigo (huh default title color) - approximation of #7571F9
-	bold := "\033[1m"         // Bold
-	reset := "\033[0m"        // Reset
-
-	var coloredMode string
-	if currentMode == "plan" {
-		coloredMode = fmt.Sprintf("%s[plan mode]%s", yellow, reset)
-	} else {
-		coloredMode = fmt.Sprintf("%s[act mode]%s", blue, reset)
-	}
-
-	title := fmt.Sprintf("%s %s%sCline is ready for your message%s", coloredMode, bold, indigo, reset)
-
-	// Create multiline text area form using huh
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewText().
-				Title(title).
-				Placeholder("Type your message... (shift+enter for new line, enter to submit, /plan or /act to switch mode)").
-				Lines(5).
-				Value(&message),
-		),
+	model := output.NewInputModel(
+		output.InputTypeMessage,
+		"Cline is ready for your message...",
+		"/plan or /act to switch modes\nctrl+e to open editor",
+		currentMode,
 	)
 
-	// Run the form
-	err := form.Run()
-	if err != nil {
-		return "", false, err
-	}
-
-	// Trim whitespace
-	message = strings.TrimSpace(message)
-
-	// If empty, user just wants to keep watching
-	if message == "" {
-		return "", false, nil
-	}
-
-	return message, true, nil
+	return ih.runInputProgram(ctx, model)
 }
 
 // promptForApproval displays an approval prompt for tool/command requests
-// Returns (approved, message, error)
-// Note: The approval details are already shown by segment streamer / state stream
 func (ih *InputHandler) promptForApproval(ctx context.Context, msg *types.ClineMessage) (bool, string, error) {
-	// Add visual separation before the form
-	fmt.Println()
-
-	// Show selection menu (approval details already displayed by other handlers)
-	var choice string
-	form := huh.NewForm(
-		huh.NewGroup(
-			huh.NewSelect[string]().
-				Title("Let Cline use this tool?").
-				Options(
-					huh.NewOption("Yes", "yes"),
-					huh.NewOption("Yes, with feedback", "yes_feedback"),
-					huh.NewOption("No", "no"),
-					huh.NewOption("No, with feedback", "no_feedback"),
-				).
-				Value(&choice),
-		),
+	// 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?",
+		"",
+		ih.manager.GetCurrentMode(),
 	)
 
-	err := form.Run()
+	message, shouldSend, err := ih.runInputProgram(ctx, model)
 	if err != nil {
 		return false, "", err
 	}
 
-	// Check if feedback is needed
-	needsFeedback := choice == "yes_feedback" || choice == "no_feedback"
-	approved := choice == "yes" || choice == "yes_feedback"
-
-	var feedback string
-	if needsFeedback {
-		// Show multiline text area for feedback
-		feedbackForm := huh.NewForm(
-			huh.NewGroup(
-				huh.NewText().
-					Title("Your feedback").
-					Placeholder("Type your message... (shift+enter for new line, enter to submit, /plan or /act to switch mode)").
-					Lines(5).
-					Value(&feedback),
-			),
-		)
-
-		err := feedbackForm.Run()
-		if err != nil {
-			return false, "", err
-		}
-
-		feedback = strings.TrimSpace(feedback)
+	if !shouldSend {
+		return false, "", nil
 	}
 
-	return approved, feedback, nil
+	// The approval and feedback are handled via the model state
+	return ih.feedbackApproved, message, nil
+}
+
+// runInputProgram runs the bubbletea program and waits for result
+func (ih *InputHandler) runInputProgram(ctx context.Context, model output.InputModel) (string, bool, error) {
+	ih.mu.Lock()
+
+	// Create the program with custom update wrapper
+	wrappedModel := &inputProgramWrapper{
+		model:      &model,
+		resultChan: ih.resultChan,
+		cancelChan: ih.cancelChan,
+		handler:    ih,
+	}
+
+	ih.program = tea.NewProgram(wrappedModel)
+	ih.programDoneChan = make(chan struct{})
+	ih.ctx = ctx
+
+	// Set up coordinator references
+	output.SetProgram(ih.program)
+	output.SetInputModel(wrappedModel.model)
+	output.SetRestartCallback(ih.restartProgram)
+	output.SetInputVisible(true)
+	ih.programRunning = true
+	ih.mu.Unlock()
+
+	// Run program in goroutine
+	programErrChan := make(chan error, 1)
+	go func() {
+		if _, err := ih.program.Run(); err != nil {
+			programErrChan <- err
+		}
+		// Signal that program is done
+		close(ih.programDoneChan)
+	}()
+
+	// Wait for result, cancellation, or context done
+	select {
+	case <-ctx.Done():
+		ih.mu.Lock()
+		output.SetInputVisible(false)
+		if ih.program != nil {
+			ih.program.Quit()
+		}
+		ih.programRunning = false
+		ih.mu.Unlock()
+		return "", false, ctx.Err()
+
+	case <-ih.cancelChan:
+		ih.mu.Lock()
+		output.SetInputVisible(false)
+		ih.programRunning = false
+		ih.mu.Unlock()
+		return "", false, context.Canceled
+
+	case err := <-programErrChan:
+		ih.mu.Lock()
+		output.SetInputVisible(false)
+		ih.programRunning = false
+		ih.mu.Unlock()
+		return "", false, err
+
+	case result := <-ih.resultChan:
+		ih.mu.Lock()
+		output.SetInputVisible(false)
+		ih.programRunning = false
+		ih.mu.Unlock()
+
+		// Handle different input types
+		switch result.InputType {
+		case output.InputTypeMessage:
+			if result.Value == "" {
+				return "", false, nil
+			}
+			return result.Value, true, nil
+
+		case output.InputTypeApproval:
+			if result.NeedsFeedback {
+				// 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
+			return "", true, nil
+
+		case output.InputTypeFeedback:
+			// This came from approval flow
+			ih.feedbackApproval = true
+			ih.feedbackApproved = result.Approved // Use the approval decision from the feedback
+			return result.Value, true, nil
+		}
+
+		return "", false, nil
+	}
+}
+
+// inputProgramWrapper wraps the InputModel to handle message routing
+type inputProgramWrapper struct {
+	model      *output.InputModel
+	resultChan chan output.InputSubmitMsg
+	cancelChan chan struct{}
+	handler    *InputHandler
+}
+
+func (w *inputProgramWrapper) Init() tea.Cmd {
+	return w.model.Init()
+}
+
+func (w *inputProgramWrapper) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case output.InputSubmitMsg:
+		// Handle input submission - clear the screen before quitting
+		w.resultChan <- msg
+		clearCodes := w.model.ClearScreen()
+		if clearCodes != "" {
+			fmt.Print(clearCodes)
+		}
+		return w, tea.Quit
+
+	case output.InputCancelMsg:
+		// Handle cancellation - clear the screen before quitting
+		w.cancelChan <- struct{}{}
+		clearCodes := w.model.ClearScreen()
+		if clearCodes != "" {
+			fmt.Print(clearCodes)
+		}
+		return w, tea.Quit
+
+	case output.ChangeInputTypeMsg:
+		// Change input type (approval -> feedback)
+		_, cmd := w.model.Update(msg)
+		return w, cmd
+	}
+
+	// Forward to wrapped model
+	_, cmd := w.model.Update(msg)
+	return w, cmd
+}
+
+func (w *inputProgramWrapper) View() string {
+	return w.model.View()
 }
 
 // parseModeSwitch checks if message starts with /act or /plan and extracts the mode and remaining message
-// Returns: (newMode, remainingMessage, isModeSwitch)
 func (ih *InputHandler) parseModeSwitch(message string) (string, string, bool) {
 	trimmed := strings.TrimSpace(message)
 	lower := strings.ToLower(trimmed)
 
 	if strings.HasPrefix(lower, "/plan") {
-		// Extract remaining message after /plan
-		remaining := strings.TrimSpace(trimmed[5:]) // Remove "/plan"
+		remaining := strings.TrimSpace(trimmed[5:])
 		return "plan", remaining, true
 	}
 
 	if strings.HasPrefix(lower, "/act") {
-		// Extract remaining message after /act
-		remaining := strings.TrimSpace(trimmed[4:]) // Remove "/act"
+		remaining := strings.TrimSpace(trimmed[4:])
 		return "act", remaining, true
 	}
 
@@ -336,14 +496,13 @@ func (ih *InputHandler) handleSpecialCommand(ctx context.Context, message string
 	case "/cancel":
 		ih.manager.GetRenderer().RenderTaskCancelled()
 		if err := ih.manager.CancelTask(ctx); err != nil {
-			fmt.Printf("Error cancelling task: %v\n", err)
+			output.Printf("Error cancelling task: %v\n", err)
 		} else {
-			fmt.Println("Task cancelled successfully")
+			output.Println("Task cancelled successfully")
 		}
 		return true
 	case "/exit", "/quit":
-		fmt.Println("\nExiting follow mode...")
-		// This will be handled by context cancellation
+		output.Println("\nExiting follow mode...")
 		return true
 	default:
 		return false
@@ -357,6 +516,9 @@ func (ih *InputHandler) Stop() {
 	if ih.pollTicker != nil {
 		ih.pollTicker.Stop()
 	}
+	if ih.program != nil && ih.programRunning {
+		ih.program.Quit()
+	}
 	ih.isRunning = false
 }
 
@@ -366,3 +528,48 @@ func (ih *InputHandler) IsRunning() bool {
 	defer ih.mu.RUnlock()
 	return ih.isRunning
 }
+
+// restartProgram restarts the Bubble Tea program with preserved state
+func (ih *InputHandler) restartProgram(savedModel *output.InputModel) {
+	ih.mu.Lock()
+
+	// Wait for old program to actually quit
+	if ih.programDoneChan != nil {
+		select {
+		case <-ih.programDoneChan:
+			// Program quit successfully
+		case <-time.After(100 * time.Millisecond):
+			// Timeout - continue anyway
+		}
+	}
+
+	// Create new wrapper with the saved model
+	wrappedModel := &inputProgramWrapper{
+		model:      savedModel,
+		resultChan: ih.resultChan,
+		cancelChan: ih.cancelChan,
+		handler:    ih,
+	}
+
+	// Start new program
+	ih.program = tea.NewProgram(wrappedModel)
+	ih.programDoneChan = make(chan struct{})
+
+	// Update coordinator references
+	output.SetProgram(ih.program)
+	output.SetInputModel(savedModel)
+	output.SetInputVisible(true)
+	ih.programRunning = true
+	ih.mu.Unlock()
+
+	// Run in goroutine
+	go func() {
+		if _, err := ih.program.Run(); err != nil {
+			// Log error if needed
+			if global.Config.Verbose {
+				output.Printf("\nDebug: Program restart error: %v\n", err)
+			}
+		}
+		close(ih.programDoneChan)
+	}()
+}

cli/pkg/cli/task/manager.go

@@ -3,6 +3,7 @@ package task
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"os/signal"
@@ -125,7 +126,7 @@ func (m *Manager) GetCurrentInstance() string {
 }
 
 // CreateTask creates a new task
-func (m *Manager) CreateTask(ctx context.Context, prompt string, images, files []string, workspacePaths []string, settingsFlags []string) (string, error) {
+func (m *Manager) CreateTask(ctx context.Context, prompt string, images, files []string, settingsFlags []string) (string, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -137,9 +138,6 @@ func (m *Manager) CreateTask(ctx context.Context, prompt string, images, files [
 		if len(images) > 0 {
 			m.renderer.RenderDebug("Images: %v", images)
 		}
-		if len(workspacePaths) > 0 {
-			m.renderer.RenderDebug("Workspaces: %v", workspacePaths)
-		}
 		if len(settingsFlags) > 0 {
 			m.renderer.RenderDebug("Settings: %v", settingsFlags)
 		}
@@ -307,8 +305,18 @@ func (m *Manager) CheckSendEnabled(ctx context.Context) error {
 		return ErrTaskBusy
 	}
 
-	// All ask messages allow sending
+	// All ask messages allow sending, EXCEPT command_output
 	if lastMessage.Type == types.MessageTypeAsk {
+		// Special case: command_output means command is actively streaming
+		// In the CLI, we don't want to show input during streaming output (too messy)
+		// The webview can show "Proceed While Running" button, but CLI should wait
+		if lastMessage.Ask == string(types.AskTypeCommandOutput) {
+			if global.Config.Verbose {
+				m.renderer.RenderDebug("Send disabled: command output is streaming")
+			}
+			return ErrTaskBusy
+		}
+
 		if global.Config.Verbose {
 			m.renderer.RenderDebug("Send enabled: ask message")
 		}
@@ -598,60 +606,19 @@ func (m *Manager) CancelTask(ctx context.Context) error {
 	return nil
 }
 
-// ListTasks retrieves and displays task history
-func (m *Manager) ListTasks(ctx context.Context) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	req := &cline.GetTaskHistoryRequest{
-		FavoritesOnly:        false,
-		SearchQuery:          "",
-		SortBy:               "oldest",
-		CurrentWorkspaceOnly: false,
-	}
-
-	resp, err := m.client.Task.GetTaskHistory(ctx, req)
-	if err != nil {
-		return fmt.Errorf("failed to get task history: %w", err)
-	}
-
-	if len(resp.Tasks) == 0 {
-		fmt.Println("No task history found.")
-		return nil
-	}
-
-	return m.renderer.RenderTaskList(resp.Tasks)
-}
-
-// GatherFinalSummary attempts to gather the latest completion_result output and display it
-func (m *Manager) GatherFinalSummary(ctx context.Context) error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	state, err := m.client.State.GetLatestState(ctx, &cline.EmptyRequest{})
-	if err != nil {
-		return fmt.Errorf("failed to get state: %w", err)
-	}
-
-	messages, err := m.extractMessagesFromState(state.StateJson)
-	if err != nil {
-		return fmt.Errorf("failed to extract messages: %w", err)
-	}
-
-	for i := len(messages) - 1; i >= 0; i-- {
-		msg := messages[i]
-
-		// Check if this is a completion result SAY message
-		if msg.IsSay() && msg.Say == string(types.SayTypeCompletionResult) {
-			return m.displayMessage(msg, false, false, i)
-		}
-	}
-
-	return nil
-}
-
 // ShowConversation displays the current conversation
 func (m *Manager) ShowConversation(ctx context.Context) error {
+	// Check if there's an active task before showing conversation
+	err := m.CheckSendEnabled(ctx)
+	if err != nil {
+		// Handle specific error cases
+		if errors.Is(err, ErrNoActiveTask) {
+			fmt.Println("No active task found. Use 'cline task new' to create a task first.")
+			return nil
+		}
+		// For other errors (like task busy), we can still show the conversation
+	}
+
 	// Disable streaming mode for static view
 	m.mu.Lock()
 	m.isStreamingMode = false
@@ -741,21 +708,32 @@ func (m *Manager) FollowConversation(ctx context.Context, instanceAddress string
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 	go func() {
-		select {
-		case <-ctx.Done():
-			return
-		case <-sigChan:
-			// Check if input is currently being shown
-			if coordinator.IsInputAllowed() {
-				// Input form is showing - huh will handle the signal via ErrUserAborted
-				// Do nothing here, let the input handler deal with it
-			} else {
-				// Streaming mode - cancel the task and stay in follow mode
-				m.renderer.RenderTaskCancelled()
-				if err := m.CancelTask(context.Background()); err != nil {
-					fmt.Printf("Error cancelling task: %v\n", err)
+		defer signal.Stop(sigChan) // Clean up signal handler when goroutine exits
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-sigChan:
+				if interactive {
+					// Interactive mode (task chat)
+					// Check if input is currently being shown
+					if coordinator.IsInputAllowed() {
+						// Input form is showing - huh will handle the signal via ErrUserAborted
+						// Do nothing here, let the input handler deal with it
+					} else {
+						// Streaming mode - cancel the task and stay in follow mode
+						m.renderer.RenderTaskCancelled()
+						if err := m.CancelTask(context.Background()); err != nil {
+							fmt.Printf("Error cancelling task: %v\n", err)
+						}
+						// Don't cancel main context - stay in follow mode
+					}
+				} else {
+					// Non-interactive mode (task view --follow)
+					// Just exit without canceling the task
+					cancel()
+					return // Exit the loop after canceling in non-interactive mode
 				}
-				// Don't cancel main context - stay in follow mode
 			}
 		}
 	}()
@@ -907,9 +885,7 @@ func (m *Manager) processStateUpdateJsonMode(stateUpdate *cline.State, coordinat
 		// Display valid messages, exit as soon as we hit a non-valid message
 		if shouldDisplay {
 			coordinator.CompleteTurn(i + 1) // Mark the message as complete as soon as we print it
-			coordinator.WithOutputLock(func() {
-				m.displayMessage(msg, false, false, i)
-			})
+			m.displayMessage(msg, false, false, i)
 		} else {
 			break
 		}
@@ -955,59 +931,52 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 		case msg.Say == string(types.SayTypeUserFeedback):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		case msg.Say == string(types.SayTypeCommand):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		case msg.Say == string(types.SayTypeCommandOutput):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					m.displayMessage(msg, false, false, i)
-				})
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		case msg.Say == string(types.SayTypeBrowserActionLaunch):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		case msg.Say == string(types.SayTypeMcpServerRequestStarted):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		case msg.Say == string(types.SayTypeCheckpointCreated):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+				fmt.Println()
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
@@ -1016,10 +985,9 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 			apiInfo := types.APIRequestInfo{Cost: -1}
 			if err := json.Unmarshal([]byte(msg.Text), &apiInfo); err == nil && apiInfo.Cost >= 0 {
 				if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-					coordinator.WithOutputLock(func() {
-						fmt.Println() // adds a separator between cline message and usage message
-						m.displayMessage(msg, false, false, i)
-					})
+					fmt.Println() // adds a separator between cline message and usage message
+					m.displayMessage(msg, false, false, i)
+
 					coordinator.MarkProcessedInCurrentTurn(msgKey)
 					coordinator.CompleteTurn(len(messages))
 					displayedUsage = true
@@ -1029,36 +997,25 @@ func (m *Manager) processStateUpdate(stateUpdate *cline.State, coordinator *Stre
 		case msg.Ask == string(types.AskTypeCommandOutput):
 			msgKey := fmt.Sprintf("%d", msg.Timestamp)
 			if !coordinator.IsProcessedInCurrentTurn(msgKey) {
-				coordinator.WithOutputLock(func() {
-					m.displayMessage(msg, false, false, i)
-				})
+				m.displayMessage(msg, false, false, i)
+
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 
 		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) {
-					coordinator.WithOutputLock(func() {
-						m.displayMessage(msg, false, false, i)
-					})
-					coordinator.MarkProcessedInCurrentTurn(msgKey)
-				}
+			// Non-streaming mode: render normally when message is complete
+			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				m.displayMessage(msg, false, false, i)
+
+				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) {
-				coordinator.WithOutputLock(func() {
-					fmt.Println()
-					m.displayMessage(msg, false, false, i)
-				})
+			if !msg.Partial && !coordinator.IsProcessedInCurrentTurn(msgKey) {
+				m.displayMessage(msg, false, false, i)
 				coordinator.MarkProcessedInCurrentTurn(msgKey)
 			}
 		}
@@ -1117,15 +1074,12 @@ func (m *Manager) handleStreamingMessage(msg *types.ClineMessage, coordinator *S
 	m.renderer.RenderDebug("Processing message: timestamp=%d, partial=%v, type=%s, text_preview=%s",
 		msg.Timestamp, msg.Partial, msg.Type, m.truncateText(msg.Text, 50))
 
-	// Lock output to prevent race with input forms
-	coordinator.WithOutputLock(func() {
-		// Use streaming display which handles deduplication internally
-		if err := m.streamingDisplay.HandlePartialMessage(msg); err != nil {
-			m.renderer.RenderDebug("Streaming display failed, using fallback: %v", err)
-			// Fallback to regular display
-			m.displayMessage(msg, true, false, -1)
-		}
-	})
+	// Use streaming display which handles deduplication internally
+	if err := m.streamingDisplay.HandlePartialMessage(msg); err != nil {
+		m.renderer.RenderDebug("Streaming display failed, using fallback: %v", err)
+		// Fallback to regular display
+		m.displayMessage(msg, true, false, -1)
+	}
 
 	return nil
 }
@@ -1283,6 +1237,44 @@ 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

cli/pkg/cli/task/settings_parser.go

@@ -314,6 +314,12 @@ func setSimpleField(settings *cline.Settings, key, value string) error {
 			return err
 		}
 		settings.TerminalOutputLineLimit = int32Ptr(val)
+	case "max_consecutive_mistakes":
+		val, err := parseInt32(value)
+		if err != nil {
+			return err
+		}
+		settings.MaxConsecutiveMistakes = int32Ptr(val)
 	case "fireworks_model_max_completion_tokens":
 		val, err := parseInt32(value)
 		if err != nil {
@@ -458,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/task/stream_coordinator.go

@@ -8,7 +8,6 @@ type StreamCoordinator struct {
 	processedInCurrentTurn     map[string]bool // What we've handled in THIS turn
 	inputAllowed               bool            // Whether user input is currently allowed
 	mu                         sync.RWMutex    // Protects inputAllowed
-	outputMu                   sync.Mutex      // Protects terminal output (prevents interleaving with input forms)
 }
 
 // NewStreamCoordinator creates a new stream coordinator
@@ -59,23 +58,3 @@ func (sc *StreamCoordinator) IsInputAllowed() bool {
 	defer sc.mu.RUnlock()
 	return sc.inputAllowed
 }
-
-// LockOutput locks the output mutex to prevent interleaved terminal output
-// Should be called before displaying input forms
-func (sc *StreamCoordinator) LockOutput() {
-	sc.outputMu.Lock()
-}
-
-// UnlockOutput unlocks the output mutex
-// Should be called after input forms are dismissed
-func (sc *StreamCoordinator) UnlockOutput() {
-	sc.outputMu.Unlock()
-}
-
-// WithOutputLock executes a function while holding the output lock
-// This is a convenience method for wrapping output operations
-func (sc *StreamCoordinator) WithOutputLock(fn func()) {
-	sc.outputMu.Lock()
-	defer sc.outputMu.Unlock()
-	fn()
-}

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/types/history.go

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

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)
+}

cli/pkg/cli/version.go

@@ -4,17 +4,10 @@ import (
 	"fmt"
 	"runtime"
 
+	"github.com/cline/cli/pkg/cli/global"
 	"github.com/spf13/cobra"
 )
 
-var (
-	// These will be set at build time via ldflags
-	Version   = "dev"
-	Commit    = "unknown"
-	Date      = "unknown"
-	BuiltBy   = "unknown"
-)
-
 // NewVersionCommand creates the version command
 func NewVersionCommand() *cobra.Command {
 	var short bool
@@ -23,20 +16,22 @@ func NewVersionCommand() *cobra.Command {
 		Use:     "version",
 		Aliases: []string{"v"},
 		Short:   "Show version information",
-		Long:    `Display version information for the Cline Go host.`,
+		Long:    `Display version information for the Cline CLI.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			// Versions are injected at build time via ldflags
 			if short {
-				fmt.Println(Version)
+				fmt.Println(global.CliVersion)
 				return nil
 			}
 
-			fmt.Printf("Cline Go Host\n")
-			fmt.Printf("Version:    %s\n", Version)
-			fmt.Printf("Commit:     %s\n", Commit)
-			fmt.Printf("Built:      %s\n", Date)
-			fmt.Printf("Built by:   %s\n", BuiltBy)
-			fmt.Printf("Go version: %s\n", runtime.Version())
-			fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
+			fmt.Printf("Cline CLI\n")
+			fmt.Printf("Cline CLI Version:  %s\n", global.CliVersion)
+			fmt.Printf("Cline Core Version: %s\n", global.Version)
+			fmt.Printf("Commit:             %s\n", global.Commit)
+			fmt.Printf("Built:              %s\n", global.Date)
+			fmt.Printf("Built by:           %s\n", global.BuiltBy)
+			fmt.Printf("Go version:         %s\n", runtime.Version())
+			fmt.Printf("OS/Arch:            %s/%s\n", runtime.GOOS, runtime.GOARCH)
 
 			return nil
 		},
@@ -45,4 +40,4 @@ func NewVersionCommand() *cobra.Command {
 	cmd.Flags().BoolVar(&short, "short", false, "show only version number")
 
 	return cmd
-}
+}

cli/pkg/generated/providers.go

@@ -144,6 +144,7 @@ const (
 	OPENAI_NATIVE = "openai-native"
 	XAI = "xai"
 	CEREBRAS = "cerebras"
+	OCA = "oca"
 )
 
 // AllProviders returns a slice of enabled provider IDs for the CLI build.
@@ -159,6 +160,7 @@ var AllProviders = []string{
 	"openai-native",
 	"xai",
 	"cerebras",
+	"oca",
 }
 
 // ConfigField represents a configuration field requirement
@@ -467,6 +469,16 @@ var rawModelDefinitions = `	{
 	      "supportsImages": true,
 	      "supportsPromptCache": true
 	    },
+	    "claude-haiku-4-5-20251001": {
+	      "maxTokens": 8192,
+	      "contextWindow": 200000,
+	      "inputPrice": 1,
+	      "outputPrice": 5,
+	      "cacheWritesPrice": 1,
+	      "cacheReadsPrice": 0,
+	      "supportsImages": true,
+	      "supportsPromptCache": true
+	    },
 	    "claude-sonnet-4-20250514": {
 	      "maxTokens": 8192,
 	      "contextWindow": 200000,
@@ -579,6 +591,16 @@ var rawModelDefinitions = `	{
 	      "supportsImages": true,
 	      "supportsPromptCache": true
 	    },
+	    "anthropic.claude-haiku-4-5-20251001-v1:0": {
+	      "maxTokens": 8192,
+	      "contextWindow": 200000,
+	      "inputPrice": 1,
+	      "outputPrice": 5,
+	      "cacheWritesPrice": 1,
+	      "cacheReadsPrice": 0,
+	      "supportsImages": true,
+	      "supportsPromptCache": true
+	    },
 	    "anthropic.claude-sonnet-4-20250514-v1:0": {
 	      "maxTokens": 8192,
 	      "contextWindow": 200000,
@@ -1389,6 +1411,18 @@ func GetProviderDefinitions() (map[string]ProviderDefinition, error) {
 		HasDynamicModels: false,
 		SetupInstructions: `Get your API key from https://cloud.cerebras.ai/`,
 	}
+
+	// Oca
+	definitions["oca"] = ProviderDefinition{
+		ID:              "oca",
+		Name:            "Oca",
+		RequiredFields:  getFieldsByProvider("oca", configFields, true),
+		OptionalFields:  getFieldsByProvider("oca", configFields, false),
+		Models:          modelDefinitions["oca"],
+		DefaultModelID:  "",
+		HasDynamicModels: false,
+		SetupInstructions: `Configure Oca API credentials`,
+	}
 	
 	return definitions, nil
 }
@@ -1415,6 +1449,7 @@ func GetProviderDisplayName(providerID string) string {
 		"openai-native": "OpenAI",
 		"xai": "X AI (Grok)",
 		"cerebras": "Cerebras",
+		"oca": "Oca",
 	}
 	
 	if name, exists := displayNames[providerID]; exists {

cli/pkg/hostbridge/env.go

@@ -3,9 +3,10 @@ package hostbridge
 import (
 	"context"
 	"log"
+	"os"
 
 	"github.com/atotto/clipboard"
-	"github.com/cline/cli/pkg/cli"
+	"github.com/cline/cli/pkg/cli/global"
 	"github.com/cline/grpc-go/cline"
 	"github.com/cline/grpc-go/host"
 	"google.golang.org/protobuf/proto"
@@ -78,7 +79,7 @@ func (s *EnvService) GetHostVersion(ctx context.Context, req *cline.EmptyRequest
 		Platform:     proto.String("Cline CLI"),
 		Version:      proto.String(""),
 		ClineType:    proto.String("CLI"),
-		ClineVersion: proto.String(cli.Version),
+		ClineVersion: proto.String(global.CliVersion),
 	}, nil
 }
 
@@ -102,3 +103,64 @@ func (s *EnvService) Shutdown(ctx context.Context, req *cline.EmptyRequest) (*cl
 
 	return &cline.Empty{}, nil
 }
+
+// GetTelemetrySettings returns the telemetry settings for CLI mode
+func (s *EnvService) GetTelemetrySettings(ctx context.Context, req *cline.EmptyRequest) (*host.GetTelemetrySettingsResponse, error) {
+	if s.verbose {
+		log.Printf("GetTelemetrySettings called")
+	}
+
+	// In CLI mode, check the POSTHOG_TELEMETRY_ENABLED environment variable
+	telemetryEnabled := os.Getenv("POSTHOG_TELEMETRY_ENABLED") == "true"
+
+	var setting host.Setting
+	if telemetryEnabled {
+		setting = host.Setting_ENABLED
+	} else {
+		setting = host.Setting_DISABLED
+	}
+
+	return &host.GetTelemetrySettingsResponse{
+		IsEnabled: setting,
+	}, nil
+}
+
+// SubscribeToTelemetrySettings returns a stream of telemetry setting changes
+// In CLI mode, telemetry settings don't change at runtime, so we just send
+// the current state and keep the stream open
+func (s *EnvService) SubscribeToTelemetrySettings(req *cline.EmptyRequest, stream host.EnvService_SubscribeToTelemetrySettingsServer) error {
+	if s.verbose {
+		log.Printf("SubscribeToTelemetrySettings called")
+	}
+
+	// Send initial telemetry state
+	telemetryEnabled := os.Getenv("POSTHOG_TELEMETRY_ENABLED") == "true"
+
+	var setting host.Setting
+	if telemetryEnabled {
+		setting = host.Setting_ENABLED
+	} else {
+		setting = host.Setting_DISABLED
+	}
+
+	event := &host.TelemetrySettingsEvent{
+		IsEnabled: setting,
+	}
+
+	if err := stream.Send(event); err != nil {
+		if s.verbose {
+			log.Printf("Failed to send telemetry settings event: %v", err)
+		}
+		return err
+	}
+
+	// Keep stream open until context is cancelled
+	// (In CLI mode, settings don't change dynamically)
+	<-stream.Context().Done()
+
+	if s.verbose {
+		log.Printf("SubscribeToTelemetrySettings stream closed")
+	}
+
+	return nil
+}

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/multiroot-workspace.mdx

@@ -3,12 +3,27 @@ title: "Multiroot Workspace Support"
 sidebarTitle: "Multiroot Workspace"
 ---
 
-Cline's Multiroot feature _(experimental - Oct 1 2025)_ works seamlessly with VSCode's multi-root workspaces, letting you manage multiple project folders in a single workspace.
+Cline's Multiroot feature works seamlessly with VSCode's multi-root workspaces, letting you manage multiple project folders in a single workspace.
 
-## What is Multiroot Workspace Support?
+<Note>
+**Important:** Multi-root workspaces are currently an experimental feature and have the following limitations:
+- **Cline rules** only work in the first workspace folder
+- **Checkpoints** are automatically disabled with a warning message
+- Both features are restored when you return to a single-folder workspace
+</Note>
+
+## What is multiroot workspace support?
 
 Instead of being limited to one project folder, Cline can read files, write code, and run commands across all folders in your VSCode workspace. This is helpful when working with monorepos, microservices, or when you're working on related projects simultaneously.
 
+### How it works
+
+When you open multiple workspace folders in VSCode, Cline automatically:
+- Designates one folder as the **primary workspace** (typically the first folder added)
+- Tracks all workspace folders and their paths
+- Resolves file paths intelligently across workspaces
+- Displays workspace information in the environment details for each API request
+
 ## Getting Started
 
 ### Setting Up Multi-Root Workspaces
@@ -23,18 +38,25 @@ Instead of being limited to one project folder, Cline can read files, write code
 
 For detailed instructions on setting up multi-root workspaces in VS Code, see [Microsoft's official guide](https://code.visualstudio.com/docs/editing/workspaces/multi-root-workspaces).
 
-### How Cline Handles Multiple Workspaces
+### Technical behavior
 
-Once you have multiple folders, Cline automatically:
+**Workspace detection**
+- Cline detects all workspace folders when a task starts
+- The first workspace folder becomes the primary workspace by default
+- Each workspace can have its own VCS (Git, SVN, etc.)
 
-- Detects all your workspace folders
-- Works with files across different projects
-- Executes commands in the right context
-- Handles path resolution intelligently
+**Path resolution**
+- Relative paths are resolved relative to the primary workspace
+- You can use workspace hints to target specific workspaces: `@workspaceName:path/to/file`
+- Cline attempts to intelligently determine which workspace a file belongs to
 
-## Working Across Workspaces
+**Command execution**
+- Commands execute in the appropriate workspace context
+- The working directory is set based on where files are being accessed
 
-### Let Cline explore, or guide it precisely
+## Working across workspaces
+
+### Referencing specific workspaces
 
 You can reference different workspaces naturally in your prompts:
 
@@ -50,8 +72,19 @@ You can reference different workspaces naturally in your prompts:
 "Search for TODO comments across all my workspace folders"
 ```
 
+### Workspace hints
 
-## Common Use Cases
+Use workspace hints to explicitly reference files in specific workspaces:
+
+```
+@frontend:src/App.tsx
+@backend:server.ts
+```
+
+This syntax helps Cline resolve ambiguity when multiple workspaces contain similarly named files.
+
+
+## Common use cases
 
 ### Monorepo Development
 

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="https://storage.googleapis.com/cline_public_images/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>