migrate download MCP response to proto

* Add support for Gemini 2.5 Pro and Flash models

Signed-off-by: tjandy98 <3953059+tjandy98@users.noreply.github.com>

* Create calm-ads-glow.md

---------

Signed-off-by: tjandy98 <3953059+tjandy98@users.noreply.github.com>

.changeset/calm-ads-glow.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": minor
+---
+
+Add support for Gemini 2.5 Pro and Flash to SAP AI Core Provider

.changeset/young-bulldogs-raise.md

@@ -1,5 +0,0 @@
----
-"claude-dev": patch
----
-
-Refactor task class, moving auto approve

.gitignore

@@ -7,6 +7,7 @@ tmp
 *.vsix
 
 .DS_Store
+.idea
 
 pnpm-lock.yaml
 
@@ -37,4 +38,4 @@ src/hosts/vscode/*/methods.ts
 src/hosts/vscode/*/index.ts
 src/hosts/vscode/client/host-grpc-client.ts
 src/hosts/vscode/host-grpc-service-config.ts
-src/standalone/server-setup.ts
+src/standalone/server-setup.ts

.vscodeignore

@@ -37,10 +37,6 @@ docs/**
 !node_modules/@vscode/codicons/dist/codicon.css
 !node_modules/@vscode/codicons/dist/codicon.ttf
 
-# Include KaTeX CSS and fonts for LaTeX rendering
-!webview-ui/node_modules/katex/dist/katex.min.css
-!webview-ui/node_modules/katex/dist/fonts/**
-
 # Include default themes JSON files used in getTheme
 !src/integrations/theme/default-themes/**
 

CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [3.18.3]
+
+-   Improve Cerebras Qwen model performance by removing thinking tokens from model input (Thanks @kevint-cerebras!)
+-   Improve Claude Code provider with better error handling and performance optimizations (Thanks @BarreiroT!)
+
+## [3.18.2]
+
+-   Fix issue where terminal output would not be captured if shell integration fails by falling back to capturing the terminal content.
+-   Add confirmation popup when deleting tasks
+-   Add support for Claude Sonnet 4 and Opus 4 model in SAP AI Core provider (Thanks @lizzzcai!)
+-   Add support for `litellm_session_id` to group requests in a single session (Thanks @jorgegarciarey!)
+-   Add "Thinking Budget" customization for Claude Code (Thanks @BarreiroT!)
+-   Fix issue where the extension would use the user's environment variables for authentication when using Claude Code (Thanks @BarreiroT!)
+
+## [3.18.1]
+
+-   Add support for Claude 4 Sonnet in SAP AI Core provider (Thanks @GTxx!)
+-   Fix ENAMETOOLONG error when using Claude Code provider with long conversation histories (Thanks @BarreiroT!)
+-   Remove Gemini CLI provider because Google asked us to
+-   Fix bug with "Delete All Tasks" functionality
+
 ## [3.18.0]
 
 -   Optimized Cline to work with the Claude 4 family of models, resulting in improved performance, reliability, and new capabilities

docs/docs.json

@@ -170,6 +170,10 @@
 					"running-models-locally/ollama"
 				]
 			},
+			{
+				"group": "Troubleshooting",
+				"pages": ["troubleshooting/terminal-quick-fixes", "troubleshooting/terminal-integration-guide"]
+			},
 			{
 				"group": "More Info",
 				"pages": ["more-info/telemetry"]

docs/features/at-mentions/terminal-mentions.mdx

@@ -58,3 +58,16 @@ When you use the terminal mention in your message, here's what happens behind th
 6. The AI can now "see" the complete terminal output with all formatting preserved
 
 This process happens automatically whenever you use the terminal mention, giving the AI access to your command results, error messages, and other terminal output without you having to copy it manually.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal mentions or terminal integration in general (such as "Shell Integration Unavailable" or commands not showing output), please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+Common issues include:
+
+-   Terminal mentions not capturing output
+-   "Shell Integration Unavailable" messages in Cline chat
+-   Commands executing but output not visible to Cline
+-   Terminal integration working inconsistently
+
+The troubleshooting guide provides platform-specific solutions and detailed configuration steps to resolve these issues.

docs/features/commands-and-shortcuts/terminal-integration.mdx

@@ -74,8 +74,25 @@ This approach ensures that all terminal output, including colors and formatting,
 
 -   **Select specific output when needed**: By default, the integration captures all terminal content, but you can also select specific lines before right-clicking to focus on just the relevant output.
 
--   **Combine with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
+-   **Combine terminal outputs with file mentions**: After sending terminal output to Cline, you can enhance your question by mentioning relevant files using the @ mentions feature.
 
--   **Use for build and test output**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
+-   **Contextualize build & test outputs with the terminal**: Terminal integration is particularly useful for understanding complex build errors or test failures that span multiple lines.
 
 Next time you're staring at a cryptic error message in your terminal, try using Cline's terminal integration instead of copying and pasting. You'll get more accurate help because Cline can see the complete terminal context with proper formatting.
+
+## Troubleshooting Terminal Issues
+
+If you're experiencing issues with terminal integration, such as "Shell Integration Unavailable" or commands not showing output, please refer to our comprehensive [Terminal Integration Troubleshooting Guide](/troubleshooting/terminal-integration-guide).
+
+The troubleshooting guide covers:
+
+-   Common terminal integration issues and quick fixes
+-   Platform-specific solutions for Windows, macOS, and Linux
+-   Shell-specific configurations for zsh, bash, PowerShell, and more
+-   Advanced debugging techniques
+-   Terminal settings optimization
+
+<Tip>
+	**Quick Fix**: Most terminal issues can be resolved by switching to bash in the Cline settings and increasing the shell
+	integration timeout to 10 seconds.
+</Tip>

docs/more-info/telemetry.mdx

@@ -6,7 +6,7 @@ title: "Telemetry"
 
 To help make Cline better for everyone, we collect anonymous usage data that helps us understand how developers are using our open-source AI coding agent. This feedback loop is crucial for improving Cline's capabilities and user experience.
 
-We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see exactly what we track.
+We use PostHog, an open-source analytics platform, for data collection and analysis. Our telemetry implementation is fully transparent - you can review the [source code](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see exactly what we track.
 
 ### Tracking Policy
 
@@ -22,7 +22,7 @@ We collect basic anonymous usage data including:
 **System Context:** OS type and VS Code environment details\
 **UI Activity:** Navigation patterns and feature usage
 
-For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/telemetry/TelemetryService.ts) to see the exact events we track.
+For complete transparency, you can inspect our [telemetry implementation](https://github.com/cline/cline/blob/main/src/services/posthog/telemetry/TelemetryService.ts) to see the exact events we track.
 
 ### How to Opt Out
 

docs/troubleshooting/terminal-integration-guide.mdx

@@ -0,0 +1,399 @@
+---
+title: "Terminal Integration Troubleshooting Guide"
+sidebarTitle: "Terminal Troubleshooting"
+description: "Complete guide to resolving terminal integration issues in Cline"
+---
+
+This guide helps you resolve terminal integration issues in Cline. Terminal integration is crucial for Cline to execute commands and read their output, enabling it to understand errors, test results, and command responses.
+
+<Tip>
+	If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings, under "Terminal Settings"
+
+    This resolves most terminal integration problems.
+
+</Tip>
+
+## Quick Diagnosis Flowchart
+
+Follow this flowchart to quickly identify your issue:
+
+```mermaid
+graph TD
+    A[Terminal Issue] --> B{Can Cline execute commands?}
+    B -->|No| C[Shell Integration Unavailable]
+    B -->|Yes| D{Can Cline see the output?}
+    D -->|No| E[Output Capture Failed]
+    D -->|Yes| F{Is the output corrupted?}
+    F -->|Yes| G[Character Filtering Issue]
+    F -->|No| H{Does the command hang?}
+    H -->|Yes| I[Long-Running Command Issue]
+    H -->|No| J[Check Terminal Settings]
+
+    C --> K[Try Solution 1]
+    E --> L[Try Solution 2]
+    G --> M[Try Solution 3]
+    I --> N[Try Solution 4]
+
+    style A fill:#f9f,stroke:#333,stroke-width:2px
+    style K fill:#9f9,stroke:#333,stroke-width:2px
+    style L fill:#9f9,stroke:#333,stroke-width:2px
+    style M fill:#9f9,stroke:#333,stroke-width:2px
+    style N fill:#9f9,stroke:#333,stroke-width:2px
+```
+
+## Common Issues & Quick Solutions
+
+### 1. Shell Integration Unavailable
+
+**Symptoms:**
+
+-   Message: "Shell Integration Unavailable"
+-   Commands execute but Cline can't read output
+-   Terminal works fine manually but not with Cline
+
+**Quick Solutions:**
+
+#### macOS
+
+-   **Switch to bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Disable Oh-My-Zsh temporarily**:
+
+    1. If using zsh, enter `mv ~/.zshrc ~/.zshrc.backup` into the terminal
+    2. Restart VSCode
+
+-   **Set environment**:
+    1.a For Zsh users, use one of the following Zsh commands to edit your shell profile:
+
+          - `nano ~/.zshrc`
+          - `vim ~/.zshrc`
+          - `code ~/.zshrc`
+
+    1.b For Bash users
+
+          - nano ~/.bash_profile
+
+    2. Add the following to your shell config: `export TERM=xterm-256color`
+    3. Save your configuration
+
+#### Windows
+
+-   **Use PowerShell 7**
+
+    1. Install from Microsoft Store
+    2. Go to Cline Settings
+    3. Left-Click the **"Terminal Settings"** tab
+    4. Navigate to **"Default Terminal Profile"** and select **"PowerShell 7"** from the drop-down menu
+
+-   **Disable Windows ConPTY**
+
+    1. Navigate to your VSCode Settings
+    2. Enter "Integrated: Windows Enable Conpty" into the Settings searchbar
+    3. Uncheck the option
+
+-   **Try Command Prompt**
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"Command Prompt"** from the drop-down menu
+
+#### Linux
+
+-   **Use bash**
+
+    1. Go to Cline Settings
+    2. Left-Click the **"Terminal Settings"** tab
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down menu
+
+-   **Check permissions**
+
+    1. Ensure VSCode has terminal access permissions
+
+-   **Disable custom prompts**
+    1. Comment out prompt customizations in `.bashrc`
+
+### 2. Command Output Not Visible
+
+**Symptoms:**
+
+-   Cline states in chat: "[Command is running but producing no output]"
+-   Commands complete but Cline doesn't see results
+-   Commands work sometimes but not consistently
+
+**Solutions:**
+
+-   **Increase Shell Integration Timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable Terminal Reuse**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+-   **Check for interfering extensions**
+    1. Disable other terminal-related VSCode extensions
+
+### 3. Character Filtering Issues
+
+**Symptoms:**
+
+-   Commas missing from output (JSON appears corrupted)
+-   Special characters stripped from terminal output
+-   Syntax errors that don't appear when running manually
+
+**Solution:**
+This is a known bug in output processing. Workarounds:
+
+-   Recommend AI to use file output instead
+    1. Tell Cline in chat or Cline rules, to use `command > output.txt` before reading the file/s
+
+<Tip>
+	This family of issues is only partially solved in the latest Cline versions, so if you still face this, create a GitHub issue
+	if it is a persistent problem.
+</Tip>
+
+### 4. Long-Running Commands & Progress Bars
+
+**Symptoms:**
+
+-   Docker builds never complete in Cline
+-   Progress bars consume thousands of tokens
+-   The Cline button "Proceed while running" doesn't work properly in chat
+
+<Tip>
+	This family of issues has been solved in latest Cline versions but if you still face any issues, then create a GitHub issue
+	for this.
+</Tip>
+
+## Terminal Settings Explained
+
+Access these in Cline by clicking the settings icon, and navigating to the "Terminal Settings" section:
+
+### Default Terminal Profile
+
+-   **What it does**: Selects which shell Cline uses for commands
+-   **When to change**: If experiencing shell integration issues with your default shell
+-   **Recommended**: - macOS: bash (if zsh has issues) - Windows: PowerShell 7 - Linux: bash
+
+### Shell Integration Timeout
+
+-   **What it does**: How long Cline waits for the terminal to be ready
+-   **Default**: 4 seconds
+-   **When to increase**:
+    -   Slow shell startup (heavy .zshrc/.bashrc)
+    -   WSL environments
+    -   SSH connections
+-   **Recommended**: - Start with 10 seconds if having issues
+
+### Enable Aggressive Terminal Reuse
+
+-   **What it does**: Reuses existing terminals even if not in the correct directory
+-   **When to disable**:
+    -   Commands execute in wrong directory
+    -   Virtual environment issues
+    -   Terminal state corruption
+-   **Trade-off**: - Disabling creates more terminals but ensures clean state
+
+### Terminal Output Line Limit
+
+-   **What it does**: Limits how many lines Cline reads from terminal output
+-   **Default**: 500 lines
+-   **When to adjust**:
+    -   Increase for verbose build outputs
+    -   Decrease if hitting token limits
+    -   Set to 100 for commands with progress bars
+
+## Platform-Specific Solutions
+
+### macOS Issues
+
+#### Oh-My-Zsh Conflicts
+
+Oh-My-Zsh often interferes with shell integration. Solutions:
+
+1. Create a minimal `.zshrc` for VSCode:
+    ```bash
+    # ~/.zshrc-vscode
+    export TERM=xterm-256color
+    export PAGER=cat
+    # Minimal PATH and environment setup
+    ```
+2. Configure VSCode to use it:
+    ```json
+    {
+    	"terminal.integrated.env.osx": {
+    		"ZDOTDIR": "~/.zshrc-vscode"
+    	}
+    }
+    ```
+
+#### macOS 15+ Issues
+
+Recent macOS versions have stricter terminal permissions:
+
+1. System Preferences → Privacy & Security → Developer Tools
+2. Add Visual Studio Code
+3. Restart VSCode completely
+
+### Windows Issues
+
+#### PowerShell Execution Policy
+
+If commands fail silently:
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+#### WSL Integration
+
+For WSL issues:
+
+1. Use WSL extension for VSCode
+2. Open folder in WSL: `code .` from WSL terminal
+3. Select "WSL Bash" as terminal profile in Cline
+
+#### Path Issues
+
+Windows path problems:
+
+1. Use forward slashes in Cline: `C:/Users/...`
+2. Quote paths with spaces: `"C:/Program Files/..."`
+3. Avoid `~` - use full paths
+
+### Linux/SSH/Container Issues
+
+#### SSH Connections
+
+For remote development:
+
+1. Install Cline on the remote machine, not locally
+2. Use SSH extension's integrated terminal
+3. Increase timeout to 15+ seconds
+
+#### Docker Containers
+
+When developing in containers:
+
+1. Install Cline in the container
+2. Use Dev Containers extension
+3. Ensure shell integration scripts are available
+
+## Shell-Specific Fixes
+
+### Zsh
+
+```bash
+# Add to ~/.zshrc
+export TERM=xterm-256color
+export PAGER=cat
+# Disable fancy prompts for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1="%n@%m %1~ %# "
+fi
+```
+
+### Bash
+
+```bash
+# Add to ~/.bashrc
+export TERM=xterm-256color
+export PAGER=cat
+# Simple prompt for VSCode
+if [[ "$TERM_PROGRAM" == "vscode" ]]; then
+    PS1='\u@\h:\w\$ '
+fi
+```
+
+### Fish
+
+```fish
+# Add to ~/.config/fish/config.fish
+set -x TERM xterm-256color
+set -x PAGER cat
+# Disable fancy features in VSCode
+if test "$TERM_PROGRAM" = "vscode"
+    function fish_prompt
+        echo (whoami)'@'(hostname)':'(pwd)'> '
+    end
+end
+```
+
+### PowerShell
+
+```powershell
+# Add to $PROFILE
+$env:PAGER = "cat"
+# Disable progress bars
+$ProgressPreference = 'SilentlyContinue'
+```
+
+## Advanced Troubleshooting
+
+### Debug Mode
+
+Enable terminal debugging to see what's happening:
+
+1. Open VSCode Command Palette (Cmd/Ctrl+Shift+P)
+2. Run: "Developer: Set Log Level..."
+3. Choose "Trace"
+4. Check Output panel → "Cline" for terminal logs
+
+### Manual Shell Integration Test
+
+Test if shell integration works at all:
+
+```bash
+# In VSCode terminal
+echo $TERM_PROGRAM  # Should show "vscode"
+echo $VSCODE_SHELL_INTEGRATION  # Should be "1"
+```
+
+## FAQ
+
+### Why does Cline create so many terminals?
+
+When shell integration fails, Cline can't reuse terminals safely (they might be running long processes). Enable shell integration or adjust the terminal reuse setting.
+
+### Can I use my custom shell (nushell, xonsh, etc.)?
+
+Cline officially supports bash, zsh, fish, and PowerShell. Custom shells may work but aren't guaranteed. Use bash as a fallback.
+
+### Why do some commands work but others don't?
+
+Commands that use interactive features (pagers, progress bars, curses) often fail. Set `PAGER=cat` and use non-interactive flags.
+
+### How do I know if shell integration is working?
+
+Working integration shows command output in Cline's chat. Failed integration shows "Shell Integration Unavailable" or "[Command is running but producing no output]".
+
+## Still Having Issues?
+
+If you've tried everything:
+
+1. **Collect Debug Info**:
+
+    ```bash
+    echo "Shell: $SHELL"
+    echo "Term: $TERM"
+    echo "VSCode: $TERM_PROGRAM"
+    which bash
+    bash --version
+    ```
+
+2. **Report the Issue**:
+    - Use `/reportbug` in Cline github issues
+    - Include your debug info
+    - Mention which solutions you tried
+
+<Tip>
+	Remember: Most terminal issues are resolved by switching to bash and increasing the timeout. Start there before trying complex
+	solutions.
+</Tip>

docs/troubleshooting/terminal-quick-fixes.mdx

@@ -0,0 +1,51 @@
+---
+title: "Terminal Quick Fixes"
+sidebarTitle: "Terminal Quick Fixes"
+description: "Quick solutions for common terminal issues"
+---
+
+**Here is a list of common fixes, starting with the most applicable:**
+
+-   **Switch to bash** (solves most instances)
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down
+
+-   **Increase timeout**
+
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+
+-   **Disable terminal reuse**
+    1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
+    2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
+    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+
+## Platform-Specific Fixes
+
+### macOS + Oh-My-Zsh
+
+```bash
+# Create minimal config for VSCode
+echo 'export TERM=xterm-256color' > ~/.zshrc-vscode
+echo 'export PAGER=cat' >> ~/.zshrc-vscode
+```
+
+### Windows PowerShell
+
+```powershell
+# Run as Administrator
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+
+### WSL
+
+-   Open folder from WSL: `code .`
+-   Select **"WSL Bash"** in Cline settings, under **"Terminal Settings"**
+-   Increase **"Shell integration timeout (seconds)"** to **15**
+
+## Full Guide
+
+For detailed troubleshooting, see the [Complete Terminal Troubleshooting Guide](/troubleshooting/terminal-integration-guide).

evals/cli/src/commands/runDiffEval.ts

@@ -6,6 +6,7 @@ interface RunDiffEvalOptions {
 	modelIds: string
 	systemPromptName: string
 	validAttemptsPerCase: number
+	maxAttemptsPerCase?: number
 	parsingFunction: string
 	diffEditFunction: string
 	thinkingBudget: number
@@ -16,6 +17,7 @@ interface RunDiffEvalOptions {
 	replay: boolean
 	replayRunId?: string
 	diffApplyFile?: string
+	saveLocally: boolean
 	maxCases?: number
 }
 
@@ -70,10 +72,18 @@ export async function runDiffEvalHandler(options: RunDiffEvalOptions) {
 		args.push("--verbose")
 	}
 
+	if (options.maxAttemptsPerCase) {
+		args.push("--max-attempts-per-case", String(options.maxAttemptsPerCase))
+	}
+
 	if (options.maxCases) {
 		args.push("--max-cases", String(options.maxCases))
 	}
 
+	if (options.saveLocally) {
+		args.push("--save-locally")
+	}
+
 	try {
 		console.log(chalk.gray(`Executing: npx tsx ${scriptPath} ${args.join(" ")}`))
 

evals/cli/src/index.ts

@@ -87,6 +87,7 @@ program
 	.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 	.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 	.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+	.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 	.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 	.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
 	.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
@@ -95,12 +96,14 @@ program
 	.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
 	.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
 	.option("--diff-apply-file <filename>", "The name of the diff apply file to use for the replay")
+	.option("--save-locally", "Save results to local JSON files in addition to database", false)
 	.option("-v, --verbose", "Enable verbose logging", false)
 	.action(async (options) => {
 		try {
 			const fullOptions = {
 				...options,
 				validAttemptsPerCase: parseInt(options.validAttemptsPerCase, 10),
+				maxAttemptsPerCase: options.maxAttemptsPerCase ? parseInt(options.maxAttemptsPerCase, 10) : undefined,
 				thinkingBudget: parseInt(options.thinkingBudget, 10),
 				maxCases: options.maxCases ? parseInt(options.maxCases, 10) : undefined,
 			}

evals/diff-edits/ClineWrapper.ts

@@ -11,9 +11,10 @@ import {
 import { constructNewFileContent as constructNewFileContent_06_06_25 } from "./diff-apply/diff-06-06-25"
 import { constructNewFileContent as constructNewFileContent_06_23_25 } from "./diff-apply/diff-06-23-25"
 import { constructNewFileContent as constructNewFileContent_06_25_25 } from "./diff-apply/diff-06-25-25"
+import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./diff-apply/diff-06-26-25"
 
 type ParseAssistantMessageFn = (message: string) => AssistantMessageContent[]
-type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string>
+type ConstructNewFileContentFn = (diff: string, original: string, strict: boolean) => Promise<string | any>
 
 const parsingFunctions: Record<string, ParseAssistantMessageFn> = {
 	parseAssistantMessageV1: parseAssistantMessageV1,
@@ -25,9 +26,11 @@ const diffEditingFunctions: Record<string, ConstructNewFileContentFn> = {
 	"diff-06-06-25": constructNewFileContent_06_06_25,
 	"diff-06-23-25": constructNewFileContent_06_23_25,
 	"diff-06-25-25": constructNewFileContent_06_25_25,
+	"diff-06-26-25": constructNewFileContent_06_26_25,
 }
 
 import { TestInput, TestResult, ExtractedToolCall } from "./types"
+import { log } from "./helpers"
 export { TestInput, TestResult, ExtractedToolCall }
 
 interface StreamResult {
@@ -282,21 +285,21 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 		}
 
 		// check that we are editing the correct file path
-		console.log(`Expected file path: "${originalFilePath}"`);
-		console.log(`Actual file path used: "${diffToolPath}"`);
+		log(input.isVerbose, `Expected file path: "${originalFilePath}"`)
+		log(input.isVerbose, `Actual file path used: "${diffToolPath}"`)
 		if (diffToolPath !== originalFilePath) {
-			console.log(`❌ File path mismatch detected!`);
+			log(input.isVerbose, `❌ File path mismatch detected!`)
 			// Enhanced logging:
 			if (streamResult?.assistantMessage) {
-				console.log(`   Full model output (assistantMessage):`);
-				console.log(`   -----------------------------------------`);
-				console.log(`   ${streamResult.assistantMessage}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Full model output (assistantMessage):`)
+				log(input.isVerbose, `   -----------------------------------------`)
+				log(input.isVerbose, `   ${streamResult.assistantMessage}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			if (toolCall) {
-				console.log(`   Parsed tool call that caused mismatch:`);
-				console.log(`   ${JSON.stringify(toolCall, null, 2)}`);
-				console.log(`   -----------------------------------------`);
+				log(input.isVerbose, `   Parsed tool call that caused mismatch:`)
+				log(input.isVerbose, `   ${JSON.stringify(toolCall, null, 2)}`)
+				log(input.isVerbose, `   -----------------------------------------`)
 			}
 			return {
 				success: false,
@@ -308,10 +311,18 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 
 		// checking if the diff edit succeeds, if it failed it will throw an error
 		let diffSuccess = true
+		let replacementData: any = undefined
 		try {
-			await constructNewFileContent(diffToolContent, originalFile, true)
+			const result = await constructNewFileContent(diffToolContent, originalFile, true)
+			
+			// Check if result is an object with replacements (new format)
+			if (typeof result === 'object' && result !== null && 'replacements' in result) {
+				replacementData = result.replacements
+			}
+			// If it's just a string, diffSuccess stays true and replacementData stays undefined
 		} catch (error: any) {
 			diffSuccess = false
+			log(input.isVerbose, `ERROR: ${error}`)
 		}
 
 		return {
@@ -320,6 +331,7 @@ export async function runSingleEvaluation(input: TestInput): Promise<TestResult>
 			toolCalls: detectedToolCalls,
 			diffEdit: diffToolContent,
 			diffEditSuccess: diffSuccess,
+			replacementData: replacementData,
 		}
 	} catch (error: any) {
 		return {

evals/diff-edits/TestRunner.ts

@@ -3,10 +3,11 @@ import { parseAssistantMessageV2, AssistantMessageContent } from "./parsing/pars
 import { constructNewFileContent as constructNewFileContent_06_06_25 } from "./diff-apply/diff-06-06-25"
 import { constructNewFileContent as constructNewFileContent_06_23_25 } from "./diff-apply/diff-06-23-25"
 import { constructNewFileContent as constructNewFileContent_06_25_25 } from "./diff-apply/diff-06-25-25"
+import { constructNewFileContent as constructNewFileContent_06_26_25 } from "./diff-apply/diff-06-26-25"
 import { constructNewFileContent as constructNewFileContentV3 } from "../../src/core/assistant-message/diff"
 import { basicSystemPrompt } from "./prompts/basicSystemPrompt-06-06-25"
 import { claude4SystemPrompt } from "./prompts/claude4SystemPrompt-06-06-25"
-import { formatResponse } from "./helpers"
+import { formatResponse, log } from "./helpers"
 import { Anthropic } from "@anthropic-ai/sdk"
 import * as fs from "fs"
 import * as path from "path"
@@ -39,12 +40,6 @@ const encoding = get_encoding("cl100k_base");
 
 let openRouterModelDataGlobal: Record<string, EvalOpenRouterModelInfo> = {}; // Global to store fetched data
 
-function log(isVerbose: boolean, message: string) {
-	if (isVerbose) {
-		console.log(message)
-	}
-}
-
 const systemPromptGeneratorLookup: Record<string, ConstructSystemPromptFn> = {
 	basicSystemPrompt: basicSystemPrompt,
 	claude4SystemPrompt: claude4SystemPrompt,
@@ -484,6 +479,7 @@ class NodeTestRunner {
 			"diff-06-06-25": constructNewFileContent_06_06_25,
 			"diff-06-23-25": constructNewFileContent_06_23_25,
 			"diff-06-25-25": constructNewFileContent_06_25_25,
+			"diff-06-26-25": constructNewFileContent_06_26_25,
 			constructNewFileContentV3: constructNewFileContentV3,
 		}
 		const constructNewFileContent = diffEditingFunctions[diffApplyFile]
@@ -639,6 +635,7 @@ class NodeTestRunner {
 			thinkingBudgetTokens: testConfig.thinking_tokens_budget,
 			originalDiffEditToolCallMessage: testConfig.replay ? testCase.original_diff_edit_tool_call_message : undefined,
 			diffApplyFile: testConfig.diff_apply_file,
+			isVerbose: isVerbose,
 		}
 
 		if (isVerbose) {
@@ -805,8 +802,8 @@ class NodeTestRunner {
 					log(isVerbose, `Warning: Failed to store result in database: ${error}`);
 				}
 				
-				// Safety check to prevent infinite loops - limit to 10 attempts per valid attempt requested
-				if (totalAttempts >= testConfig.number_of_runs * 10) {
+				// Safety check to prevent infinite loops - use configurable max attempts limit
+				if (totalAttempts >= testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts (${totalAttempts}) for test case ${testCase.test_id}. Only got ${validAttempts}/${testConfig.number_of_runs} valid attempts.`);
 					break;
 				}
@@ -925,14 +922,16 @@ async function main() {
 		.option("--model-ids <model_ids>", "Comma-separated list of model IDs to test")
 		.option("--system-prompt-name <name>", "The name of the system prompt to use", "basicSystemPrompt")
 		.option("-n, --valid-attempts-per-case <number>", "Number of valid attempts per test case per model (will retry until this many valid attempts are collected)", "1")
+		.option("--max-attempts-per-case <number>", "Maximum total attempts per test case (default: 10x valid attempts)")
 		.option("--max-cases <number>", "Maximum number of test cases to run (limits total cases loaded)")
 		.option("--parsing-function <name>", "The parsing function to use", "parseAssistantMessageV2")
-		.option("--diff-edit-function <name>", "The diff editing function to use", "constructNewFileContentV2")
+		.option("--diff-edit-function <name>", "The diff editing function to use", "diff-06-25-25")
 		.option("--thinking-budget <tokens>", "Set the thinking tokens budget", "0")
 		.option("--parallel", "Run tests in parallel", false)
 		.option("--replay", "Run evaluation from a pre-recorded LLM output, skipping the API call", false)
 		.option("--replay-run-id <run_id>", "The ID of the run to replay from the database")
 		.option("--diff-apply-file <filename>", "The name of the diff apply file to use for the replay")
+		.option("--save-locally", "Save results to local JSON files in addition to database", false)
 		.option("-v, --verbose", "Enable verbose logging", false)
 		.option("--max-concurrency <number>", "Maximum number of parallel requests", "80")
 
@@ -943,6 +942,7 @@ async function main() {
 	const isVerbose = options.verbose
 	const testPath = options.testPath
 	const outputPath = options.outputPath
+	const saveLocally = options.saveLocally
 	const maxConcurrency = parseInt(options.maxConcurrency, 10);
 
 	// Parse model IDs from comma-separated string
@@ -953,6 +953,11 @@ async function main() {
 	}
 
 	const validAttemptsPerCase = parseInt(options.validAttemptsPerCase, 10);
+	
+	// Compute dynamic default for max attempts: 10x valid attempts if not specified
+	const maxAttemptsPerCase = options.maxAttemptsPerCase 
+		? parseInt(options.maxAttemptsPerCase, 10)
+		: validAttemptsPerCase * 10;
 
 	const runner = new NodeTestRunner(options.replay || !!options.replayRunId)
 
@@ -1058,6 +1063,7 @@ async function main() {
 					model_id: modelId,
 					system_prompt_name: options.systemPromptName,
 					number_of_runs: validAttemptsPerCase,
+					max_attempts_per_case: maxAttemptsPerCase,
 					parsing_function: options.parsingFunction,
 					diff_edit_function: options.diffEditFunction,
 					thinking_tokens_budget: parseInt(options.thinkingBudget, 10),
@@ -1125,7 +1131,7 @@ async function main() {
 
 			remainingTasks = remainingTasks.filter(task => {
 				const taskId = `${task.modelId}-${task.testCase.test_id}`;
-				if (taskStates[taskId].total >= validAttemptsPerCase * 10) {
+				if (taskStates[taskId].total >= task.testConfig.max_attempts_per_case) {
 					log(isVerbose, `  ⚠️ Reached maximum attempts for ${task.testCase.test_id} with ${task.modelId}.`);
 					return false;
 				}
@@ -1150,6 +1156,12 @@ async function main() {
 		const durationSeconds = ((endTime - startTime) / 1000).toFixed(2)
 		log(isVerbose, `\n-Total execution time: ${durationSeconds} seconds`)
 
+		// Save results locally if requested
+		if (saveLocally) {
+			runner.saveTestResults(results, outputPath);
+			log(isVerbose, `✓ Results also saved to JSON files in ${outputPath}`);
+		}
+
 		log(isVerbose, `\n✓ All results stored in database. Use the dashboard to view results.`)
 	} catch (error) {
 		console.error("\nError running tests:", error)

evals/diff-edits/diff-apply/diff-06-26-25.ts

@@ -0,0 +1,960 @@
+const SEARCH_BLOCK_START = "------- SEARCH"
+const SEARCH_BLOCK_END = "======="
+const REPLACE_BLOCK_END = "+++++++ REPLACE"
+
+const SEARCH_BLOCK_CHAR = "-"
+const REPLACE_BLOCK_CHAR = "+"
+const LEGACY_SEARCH_BLOCK_CHAR = "<"
+const LEGACY_REPLACE_BLOCK_CHAR = ">"
+
+// Replace the exact string constants with flexible regex patterns
+const SEARCH_BLOCK_START_REGEX = /^[-]{3,} SEARCH>?$/
+const LEGACY_SEARCH_BLOCK_START_REGEX = /^[<]{3,} SEARCH>?$/
+
+const SEARCH_BLOCK_END_REGEX = /^[=]{3,}$/
+
+const REPLACE_BLOCK_END_REGEX = /^[+]{3,} REPLACE>?$/
+const LEGACY_REPLACE_BLOCK_END_REGEX = /^[>]{3,} REPLACE>?$/
+
+// Similarity thresholds for block anchor fallback matching
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.0
+
+/**
+ * Levenshtein distance algorithm implementation
+ */
+function levenshtein(a: string, b: string): number {
+	// Handle empty strings
+	if (a === "" || b === "") {
+		return Math.max(a.length, b.length)
+	}
+	const matrix = Array.from({ length: a.length + 1 }, (_, i) =>
+		Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),
+	)
+
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1
+			matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost)
+		}
+	}
+	return matrix[a.length][b.length]
+}
+
+// Helper functions to check if a line matches the flexible patterns
+function isSearchBlockStart(line: string): boolean {
+	return SEARCH_BLOCK_START_REGEX.test(line) || LEGACY_SEARCH_BLOCK_START_REGEX.test(line)
+}
+
+function isSearchBlockEnd(line: string): boolean {
+	return SEARCH_BLOCK_END_REGEX.test(line)
+}
+
+function isReplaceBlockEnd(line: string): boolean {
+	return REPLACE_BLOCK_END_REGEX.test(line) || LEGACY_REPLACE_BLOCK_END_REGEX.test(line)
+}
+
+/**
+ * Attempts a line-trimmed fallback match for the given search content in the original content.
+ * It tries to match `searchContent` lines against a block of lines in `originalContent` starting
+ * from `lastProcessedIndex`. Lines are matched by trimming leading/trailing whitespace and ensuring
+ * they are identical afterwards.
+ *
+ * Returns [matchIndexStart, matchIndexEnd] if found, or false if not found.
+ */
+function lineTrimmedFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number] | false {
+	// Split both contents into lines
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Trim trailing empty line if exists (from the trailing \n in searchContent)
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1 // +1 for \n
+		startLineNum++
+	}
+
+	// For each possible starting position in original content
+	for (let i = startLineNum; i <= originalLines.length - searchLines.length; i++) {
+		let matches = true
+
+		// Try to match all search lines from this position
+		for (let j = 0; j < searchLines.length; j++) {
+			const originalTrimmed = originalLines[i + j].trim()
+			const searchTrimmed = searchLines[j].trim()
+
+			if (originalTrimmed !== searchTrimmed) {
+				matches = false
+				break
+			}
+		}
+
+		// If we found a match, calculate the exact character positions
+		if (matches) {
+			// Find start character index
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1 // +1 for \n
+			}
+
+			// Find end character index
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchLines.length; k++) {
+				matchEndIndex += originalLines[i + k].length + 1 // +1 for \n
+			}
+
+			return [matchStartIndex, matchEndIndex]
+		}
+	}
+
+	return false
+}
+
+/**
+ * Attempts to match blocks of code by using the first and last lines as anchors,
+ * with similarity checking to prevent false positives.
+ * This is a third-tier fallback strategy that helps match blocks where we can identify
+ * the correct location by matching the beginning and end, even if the exact content
+ * differs slightly.
+ *
+ * The matching strategy:
+ * 1. Only attempts to match blocks of 3 or more lines to avoid false positives
+ * 2. Extracts from the search content:
+ *    - First line as the "start anchor"
+ *    - Last line as the "end anchor"
+ * 3. Collects all candidate positions where both anchors match
+ * 4. Uses levenshtein distance to calculate similarity of middle lines
+ * 5. Returns match only if similarity meets threshold requirements
+ *
+ * This approach is particularly useful for matching blocks of code where:
+ * - The exact content might have minor differences
+ * - The beginning and end of the block are distinctive enough to serve as anchors
+ * - The overall structure (number of lines) remains the same
+ * - The middle content is reasonably similar (prevents false positives)
+ *
+ * @param originalContent - The full content of the original file
+ * @param searchContent - The content we're trying to find in the original file
+ * @param startIndex - The character index in originalContent where to start searching
+ * @returns A tuple of [startIndex, endIndex] if a match is found, false otherwise
+ */
+function blockAnchorFallbackMatch(originalContent: string, searchContent: string, startIndex: number): [number, number, number] | false {
+	const originalLines = originalContent.split("\n")
+	const searchLines = searchContent.split("\n")
+
+	// Only use this approach for blocks of 3+ lines
+	if (searchLines.length < 3) {
+		return false
+	}
+
+	// Trim trailing empty line if exists
+	if (searchLines[searchLines.length - 1] === "") {
+		searchLines.pop()
+	}
+
+	const firstLineSearch = searchLines[0].trim()
+	const lastLineSearch = searchLines[searchLines.length - 1].trim()
+	const searchBlockSize = searchLines.length
+
+	// Find the line number where startIndex falls
+	let startLineNum = 0
+	let currentIndex = 0
+	while (currentIndex < startIndex && startLineNum < originalLines.length) {
+		currentIndex += originalLines[startLineNum].length + 1
+		startLineNum++
+	}
+
+	// Collect all candidate positions
+	const candidates: number[] = []
+	for (let i = startLineNum; i <= originalLines.length - searchBlockSize; i++) {
+		if (originalLines[i].trim() === firstLineSearch && originalLines[i + searchBlockSize - 1].trim() === lastLineSearch) {
+			candidates.push(i)
+		}
+	}
+
+	// Return immediately if no candidates
+	if (candidates.length === 0) {
+		return false
+	}
+
+	// Handle single candidate scenario (using relaxed threshold)
+	if (candidates.length === 1) {
+		const i = candidates[0]
+		let similarity = 0
+		let linesToCheck = searchBlockSize - 2
+
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += (1 - distance / maxLen) / linesToCheck
+
+			// Exit early when threshold is reached
+			if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+				break
+			}
+		}
+
+		if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+			let matchStartIndex = 0
+			for (let k = 0; k < i; k++) {
+				matchStartIndex += originalLines[k].length + 1
+			}
+			let matchEndIndex = matchStartIndex
+			for (let k = 0; k < searchBlockSize; k++) {
+				matchEndIndex += originalLines[i + k].length + 1
+			}
+			return [matchStartIndex, matchEndIndex, similarity]
+		}
+		return false
+	}
+
+	// Calculate similarity for multiple candidates
+	let bestMatchIndex = -1
+	let maxSimilarity = -1
+
+	for (const i of candidates) {
+		let similarity = 0
+		for (let j = 1; j < searchBlockSize - 1; j++) {
+			const originalLine = originalLines[i + j].trim()
+			const searchLine = searchLines[j].trim()
+			const maxLen = Math.max(originalLine.length, searchLine.length)
+			if (maxLen === 0) {
+				continue
+			}
+			const distance = levenshtein(originalLine, searchLine)
+			similarity += 1 - distance / maxLen
+		}
+		similarity /= searchBlockSize - 2 // Average similarity
+
+		if (similarity > maxSimilarity) {
+			maxSimilarity = similarity
+			bestMatchIndex = i
+		}
+	}
+
+	// Threshold judgment
+	if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD) {
+		const i = bestMatchIndex
+		let matchStartIndex = 0
+		for (let k = 0; k < i; k++) {
+			matchStartIndex += originalLines[k].length + 1
+		}
+		let matchEndIndex = matchStartIndex
+		for (let k = 0; k < searchBlockSize; k++) {
+			matchEndIndex += originalLines[i + k].length + 1
+		}
+		return [matchStartIndex, matchEndIndex, maxSimilarity]
+	}
+
+	return false
+}
+
+/**
+ * This function reconstructs the file content by applying a streamed diff (in a
+ * specialized SEARCH/REPLACE block format) to the original file content. It is designed
+ * to handle both incremental updates and the final resulting file after all chunks have
+ * been processed.
+ *
+ * The diff format is a custom structure that uses three markers to define changes:
+ *
+ *   ------- SEARCH
+ *   [Exact content to find in the original file]
+ *   =======
+ *   [Content to replace with]
+ *   +++++++ REPLACE
+ *
+ * Behavior and Assumptions:
+ * 1. The file is processed chunk-by-chunk. Each chunk of `diffContent` may contain
+ *    partial or complete SEARCH/REPLACE blocks. By calling this function with each
+ *    incremental chunk (with `isFinal` indicating the last chunk), the final reconstructed
+ *    file content is produced.
+ *
+ * 2. Matching Strategy (in order of attempt):
+ *    a. Exact Match: First attempts to find the exact SEARCH block text in the original file
+ *    b. Line-Trimmed Match: Falls back to line-by-line comparison ignoring leading/trailing whitespace
+ *    c. Block Anchor Match: For blocks of 3+ lines, tries to match using first/last lines as anchors
+ *    If all matching strategies fail, an error is thrown.
+ *
+ * 3. Empty SEARCH Section:
+ *    - If SEARCH is empty and the original file is empty, this indicates creating a new file
+ *      (pure insertion).
+ *    - If SEARCH is empty and the original file is not empty, this indicates a complete
+ *      file replacement (the entire original content is considered matched and replaced).
+ *
+ * 4. Applying Changes:
+ *    - Before encountering the "=======" marker, lines are accumulated as search content.
+ *    - After "=======" and before ">>>>>>> REPLACE", lines are accumulated as replacement content.
+ *    - Once the block is complete (">>>>>>> REPLACE"), the matched section in the original
+ *      file is replaced with the accumulated replacement lines, and the position in the original
+ *      file is advanced.
+ *
+ * 5. Incremental Output:
+ *    - As soon as the match location is found and we are in the REPLACE section, each new
+ *      replacement line is appended to the result so that partial updates can be viewed
+ *      incrementally.
+ *
+ * 6. Partial Markers:
+ *    - If the final line of the chunk looks like it might be part of a marker but is not one
+ *      of the known markers, it is removed. This prevents incomplete or partial markers
+ *      from corrupting the output.
+ *
+ * 7. Finalization:
+ *    - Once all chunks have been processed (when `isFinal` is true), any remaining original
+ *      content after the last replaced section is appended to the result.
+ *    - Trailing newlines are not forcibly added. The code tries to output exactly what is specified.
+ *
+ * Errors:
+ * - If the search block cannot be matched using any of the available matching strategies,
+ *   an error is thrown.
+ */
+export async function constructNewFileContent(
+	diffContent: string,
+	originalContent: string,
+	isFinal: boolean,
+	version: "v1" | "v2" = "v1",
+): Promise<any> {
+	const constructor = constructNewFileContentVersionMapping[version]
+	if (!constructor) {
+		throw new Error(`Invalid version '${version}' for file content constructor`)
+	}
+	return constructor(diffContent, originalContent, isFinal)
+}
+
+const constructNewFileContentVersionMapping: Record<
+	string,
+	(diffContent: string, originalContent: string, isFinal: boolean) => Promise<any>
+> = {
+	v1: constructNewFileContentV1,
+	v2: constructNewFileContentV2,
+} as const
+
+async function constructNewFileContentV1(diffContent: string, originalContent: string, isFinal: boolean): Promise<{
+	content: string;
+	replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}>;
+}> {
+	let result = ""
+	let lastProcessedIndex = 0
+
+	let currentSearchContent = ""
+	let currentReplaceContent = ""
+	let inSearch = false
+	let inReplace = false
+
+	let searchMatchIndex = -1
+	let searchEndIndex = -1
+	let matchMethod = ""
+	let similarityScore = -1.0
+
+	// Track all replacements to handle out-of-order edits
+	let replacements: Array<{ 
+		start: number; 
+		end: number; 
+		content: string;
+		method: string;
+		similarity: number;
+		searchContent: string;
+		matchedText: string;
+	}> = []
+	let pendingOutOfOrderReplacement = false
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		!isSearchBlockStart(lastLine) &&
+		!isSearchBlockEnd(lastLine) &&
+		!isReplaceBlockEnd(lastLine)
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		if (isSearchBlockStart(line)) {
+			inSearch = true
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			continue
+		}
+
+		if (isSearchBlockEnd(line)) {
+			inSearch = false
+			inReplace = true
+
+			// Remove trailing linebreak for adding the === marker
+			// if (currentSearchContent.endsWith("\r\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -2)
+			// } else if (currentSearchContent.endsWith("\n")) {
+			// 	currentSearchContent = currentSearchContent.slice(0, -1)
+			// }
+
+			if (!currentSearchContent) {
+				// Empty search block
+				if (originalContent.length === 0) {
+					// New file scenario: nothing to match, just start inserting
+					searchMatchIndex = 0
+					searchEndIndex = 0
+					matchMethod = "empty_new_file"
+				} else {
+					// ERROR: Empty search block with non-empty file indicates malformed SEARCH marker
+					throw new Error(
+						"Empty SEARCH block detected with non-empty file. This usually indicates a malformed SEARCH marker.\n" +
+							"Please ensure your SEARCH marker follows the correct format:\n" +
+							"- Use '------- SEARCH' (7+ dashes + space + SEARCH)\n",
+					)
+				}
+			} else {
+				// Add check for inefficient full-file search
+				// if (currentSearchContent.trim() === originalContent.trim()) {
+				// 	throw new Error(
+				// 		"The SEARCH block contains the entire file content. Please either:\n" +
+				// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+				// 			"2. Make focused changes to specific parts of the file that need modification.",
+				// 	)
+				// }
+
+				// Exact search match scenario
+				const exactIndex = originalContent.indexOf(currentSearchContent, lastProcessedIndex)
+				if (exactIndex !== -1) {
+					searchMatchIndex = exactIndex
+					searchEndIndex = exactIndex + currentSearchContent.length
+					matchMethod = "exact_match"
+				} else {
+					// Attempt fallback line-trimmed matching
+					const lineMatch = lineTrimmedFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+					if (lineMatch) {
+						;[searchMatchIndex, searchEndIndex] = lineMatch
+						matchMethod = "line_trimmed_fallback"
+					} else {
+						// Try block anchor fallback for larger blocks
+						const blockMatch = blockAnchorFallbackMatch(originalContent, currentSearchContent, lastProcessedIndex)
+						if (blockMatch) {
+							;[searchMatchIndex, searchEndIndex, similarityScore] = blockMatch
+							matchMethod = "block_anchor_fallback"
+						} else {
+							// Last resort: search the entire file from the beginning
+							const fullFileIndex = originalContent.indexOf(currentSearchContent, 0)
+							if (fullFileIndex !== -1) {
+								// Found in the file - could be out of order
+								searchMatchIndex = fullFileIndex
+								searchEndIndex = fullFileIndex + currentSearchContent.length
+								matchMethod = "full_file_search"
+								if (searchMatchIndex < lastProcessedIndex) {
+									pendingOutOfOrderReplacement = true
+								}
+							} else {
+								throw new Error(
+									`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+								)
+							}
+						}
+					}
+				}
+			}
+
+			// Check if this is an out-of-order replacement
+			if (searchMatchIndex < lastProcessedIndex) {
+				pendingOutOfOrderReplacement = true
+			}
+
+			// For in-order replacements, output everything up to the match location
+			if (!pendingOutOfOrderReplacement) {
+				result += originalContent.slice(lastProcessedIndex, searchMatchIndex)
+			}
+			continue
+		}
+
+		if (isReplaceBlockEnd(line)) {
+			// Finished one replace block
+
+			if (searchMatchIndex === -1) {
+				throw new Error(
+					`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`,
+				)
+			}
+
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset for next block
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			similarityScore = -1.0
+			pendingOutOfOrderReplacement = false
+			continue
+		}
+
+		// Accumulate content for search or replace
+		// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+		// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+		// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+		if (inSearch) {
+			currentSearchContent += line + "\n"
+		} else if (inReplace) {
+			currentReplaceContent += line + "\n"
+			// Only output replacement lines immediately for in-order replacements
+			if (searchMatchIndex !== -1 && !pendingOutOfOrderReplacement) {
+				result += line + "\n"
+			}
+		}
+	}
+
+	// If this is the final chunk, we need to apply all replacements and build the final result
+	if (isFinal) {
+		// Handle the case where we're still in replace mode when processing ends
+		// and this is the final chunk - treat it as if we encountered the REPLACE marker
+		if (inReplace && searchMatchIndex !== -1) {
+			// Store this replacement
+			replacements.push({
+				start: searchMatchIndex,
+				end: searchEndIndex,
+				content: currentReplaceContent,
+				method: matchMethod,
+				similarity: similarityScore,
+				searchContent: currentSearchContent,
+				matchedText: originalContent.slice(searchMatchIndex, searchEndIndex),
+			})
+
+			// If this was an in-order replacement, advance lastProcessedIndex
+			if (!pendingOutOfOrderReplacement) {
+				lastProcessedIndex = searchEndIndex
+			}
+
+			// Reset state
+			inSearch = false
+			inReplace = false
+			currentSearchContent = ""
+			currentReplaceContent = ""
+			searchMatchIndex = -1
+			searchEndIndex = -1
+			pendingOutOfOrderReplacement = false
+		}
+		// end of handling missing replace marker
+
+		// Sort replacements by start position
+		replacements.sort((a, b) => a.start - b.start)
+
+		// Rebuild the entire result by applying all replacements
+		result = ""
+		let currentPos = 0
+
+		for (const replacement of replacements) {
+			// Add original content up to this replacement
+			result += originalContent.slice(currentPos, replacement.start)
+			// Add the replacement content
+			result += replacement.content
+			// Move position to after the replaced section
+			currentPos = replacement.end
+		}
+
+		// Add any remaining original content
+		result += originalContent.slice(currentPos)
+	}
+
+	// For testing - return debug info
+	return {
+		content: result,
+		replacements: replacements
+	}
+}
+
+enum ProcessingState {
+	Idle = 0,
+	StateSearch = 1 << 0,
+	StateReplace = 1 << 1,
+}
+
+class NewFileContentConstructor {
+	private originalContent: string
+	private isFinal: boolean
+	private state: number
+	private pendingNonStandardLines: string[]
+	private result: string
+	private lastProcessedIndex: number
+	private currentSearchContent: string
+	private currentReplaceContent: string
+	private searchMatchIndex: number
+	private searchEndIndex: number
+
+	constructor(originalContent: string, isFinal: boolean) {
+		this.originalContent = originalContent
+		this.isFinal = isFinal
+		this.pendingNonStandardLines = []
+		this.result = ""
+		this.lastProcessedIndex = 0
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private resetForNextBlock() {
+		// Reset for next block
+		this.state = ProcessingState.Idle
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+		this.searchMatchIndex = -1
+		this.searchEndIndex = -1
+	}
+
+	private findLastMatchingLineIndex(regx: RegExp, lineLimit: number) {
+		for (let i = lineLimit; i > 0; ) {
+			i--
+			if (this.pendingNonStandardLines[i].match(regx)) {
+				return i
+			}
+		}
+		return -1
+	}
+
+	private updateProcessingState(newState: ProcessingState) {
+		const isValidTransition =
+			(this.state === ProcessingState.Idle && newState === ProcessingState.StateSearch) ||
+			(this.state === ProcessingState.StateSearch && newState === ProcessingState.StateReplace)
+
+		if (!isValidTransition) {
+			throw new Error(
+				`Invalid state transition.\n` +
+					"Valid transitions are:\n" +
+					"- Idle → StateSearch\n" +
+					"- StateSearch → StateReplace",
+			)
+		}
+
+		this.state |= newState
+	}
+
+	private isStateActive(state: ProcessingState): boolean {
+		return (this.state & state) === state
+	}
+
+	private activateReplaceState() {
+		this.updateProcessingState(ProcessingState.StateReplace)
+	}
+
+	private activateSearchState() {
+		this.updateProcessingState(ProcessingState.StateSearch)
+		this.currentSearchContent = ""
+		this.currentReplaceContent = ""
+	}
+
+	private isSearchingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateSearch)
+	}
+
+	private isReplacingActive(): boolean {
+		return this.isStateActive(ProcessingState.StateReplace)
+	}
+
+	private hasPendingNonStandardLines(pendingNonStandardLineLimit: number): boolean {
+		return this.pendingNonStandardLines.length - pendingNonStandardLineLimit < this.pendingNonStandardLines.length
+	}
+
+	public processLine(line: string) {
+		this.internalProcessLine(line, true, this.pendingNonStandardLines.length)
+	}
+
+	public getResult() {
+		// If this is the final chunk, append any remaining original content
+		if (this.isFinal && this.lastProcessedIndex < this.originalContent.length) {
+			this.result += this.originalContent.slice(this.lastProcessedIndex)
+		}
+		if (this.isFinal && this.state !== ProcessingState.Idle) {
+			throw new Error("File processing incomplete - SEARCH/REPLACE operations still active during finalization")
+		}
+		return this.result
+	}
+
+	private internalProcessLine(
+		line: string,
+		canWritependingNonStandardLines: boolean,
+		pendingNonStandardLineLimit: number,
+	): number {
+		let removeLineCount = 0
+		if (isSearchBlockStart(line)) {
+			removeLineCount = this.trimPendingNonStandardTrailingEmptyLines(pendingNonStandardLineLimit)
+			if (removeLineCount > 0) {
+				pendingNonStandardLineLimit = pendingNonStandardLineLimit - removeLineCount
+			}
+			if (this.hasPendingNonStandardLines(pendingNonStandardLineLimit)) {
+				this.tryFixSearchReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateSearchState()
+		} else if (isSearchBlockEnd(line)) {
+			// 校验非标内容
+			if (!this.isSearchingActive()) {
+				this.tryFixSearchBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.activateReplaceState()
+			this.beforeReplace()
+		} else if (isReplaceBlockEnd(line)) {
+			if (!this.isReplacingActive()) {
+				this.tryFixReplaceBlock(pendingNonStandardLineLimit)
+				canWritependingNonStandardLines && (this.pendingNonStandardLines.length = 0)
+			}
+			this.lastProcessedIndex = this.searchEndIndex
+			this.resetForNextBlock()
+		} else {
+			// Accumulate content for search or replace
+			// (currentReplaceContent is not being used for anything right now since we directly append to result.)
+			// (We artificially add a linebreak since we split on \n at the beginning. In order to not include a trailing linebreak in the final search/result blocks we need to remove it before using them. This allows for partial line matches to be correctly identified.)
+			// NOTE: search/replace blocks must be arranged in the order they appear in the file due to how we build the content using lastProcessedIndex. We also cannot strip the trailing newline since for non-partial lines it would remove the linebreak from the original content. (If we remove end linebreak from search, then we'd also have to remove it from replace but we can't know if it's a partial line or not since the model may be using the line break to indicate the end of the block rather than as part of the search content.) We require the model to output full lines in order for our fallbacks to work as well.
+			if (this.isReplacingActive()) {
+				this.currentReplaceContent += line + "\n"
+				// Output replacement lines immediately if we know the insertion point
+				if (this.searchMatchIndex !== -1) {
+					this.result += line + "\n"
+				}
+			} else if (this.isSearchingActive()) {
+				this.currentSearchContent += line + "\n"
+			} else {
+				let appendToPendingNonStandardLines = canWritependingNonStandardLines
+				if (appendToPendingNonStandardLines) {
+					// 处理非标内容
+					this.pendingNonStandardLines.push(line)
+				}
+			}
+		}
+		return removeLineCount
+	}
+
+	private beforeReplace() {
+		// Remove trailing linebreak for adding the === marker
+		// if (currentSearchContent.endsWith("\r\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -2)
+		// } else if (currentSearchContent.endsWith("\n")) {
+		// 	currentSearchContent = currentSearchContent.slice(0, -1)
+		// }
+
+		if (!this.currentSearchContent) {
+			// Empty search block
+			if (this.originalContent.length === 0) {
+				// New file scenario: nothing to match, just start inserting
+				this.searchMatchIndex = 0
+				this.searchEndIndex = 0
+			} else {
+				// Complete file replacement scenario: treat the entire file as matched
+				this.searchMatchIndex = 0
+				this.searchEndIndex = this.originalContent.length
+			}
+		} else {
+			// Add check for inefficient full-file search
+			// if (currentSearchContent.trim() === originalContent.trim()) {
+			// 	throw new Error(
+			// 		"The SEARCH block contains the entire file content. Please either:\n" +
+			// 			"1. Use an empty SEARCH block to replace the entire file, or\n" +
+			// 			"2. Make focused changes to specific parts of the file that need modification.",
+			// 	)
+			// }
+			// Exact search match scenario
+			const exactIndex = this.originalContent.indexOf(this.currentSearchContent, this.lastProcessedIndex)
+			if (exactIndex !== -1) {
+				this.searchMatchIndex = exactIndex
+				this.searchEndIndex = exactIndex + this.currentSearchContent.length
+			} else {
+				// Attempt fallback line-trimmed matching
+				const lineMatch = lineTrimmedFallbackMatch(
+					this.originalContent,
+					this.currentSearchContent,
+					this.lastProcessedIndex,
+				)
+				if (lineMatch) {
+					;[this.searchMatchIndex, this.searchEndIndex] = lineMatch
+				} else {
+					// Try block anchor fallback for larger blocks
+					const blockMatch = blockAnchorFallbackMatch(
+						this.originalContent,
+						this.currentSearchContent,
+						this.lastProcessedIndex,
+					)
+					if (blockMatch) {
+						;[this.searchMatchIndex, this.searchEndIndex, /* ignore similarity */] = blockMatch
+					} else {
+						throw new Error(
+							`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...does not match anything in the file.`,
+						)
+					}
+				}
+			}
+		}
+		if (this.searchMatchIndex < this.lastProcessedIndex) {
+			throw new Error(
+				`The SEARCH block:\n${this.currentSearchContent.trimEnd()}\n...matched an incorrect content in the file.`,
+			)
+		}
+		// Output everything up to the match location
+		this.result += this.originalContent.slice(this.lastProcessedIndex, this.searchMatchIndex)
+	}
+
+	private tryFixSearchBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error("Invalid SEARCH/REPLACE block structure - no lines available to process")
+		}
+		let searchTagRegexp = /^([-]{3,}|[<]{3,}) SEARCH$/
+		const searchTagIndex = this.findLastMatchingLineIndex(searchTagRegexp, lineLimit)
+		if (searchTagIndex !== -1) {
+			let fixLines = this.pendingNonStandardLines.slice(searchTagIndex, lineLimit)
+			fixLines[0] = SEARCH_BLOCK_START
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, searchTagIndex)
+			}
+		} else {
+			throw new Error(
+				`Invalid REPLACE marker detected - could not find matching SEARCH block starting from line ${searchTagIndex + 1}`,
+			)
+		}
+		return removeLineCount
+	}
+
+	private tryFixReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+		let replaceBeginTagRegexp = /^[=]{3,}$/
+		const replaceBeginTagIndex = this.findLastMatchingLineIndex(replaceBeginTagRegexp, lineLimit)
+		if (replaceBeginTagIndex !== -1) {
+			// // 校验非标内容
+			// if (!this.isSearchingActive()) {
+			// 	removeLineCount += this.tryFixSearchBlock(replaceBeginTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceBeginTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[0] = SEARCH_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceBeginTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error(`Malformed REPLACE block - missing valid separator after line ${replaceBeginTagIndex + 1}`)
+		}
+		return removeLineCount
+	}
+
+	private tryFixSearchReplaceBlock(lineLimit: number): number {
+		let removeLineCount = 0
+		if (lineLimit < 0) {
+			lineLimit = this.pendingNonStandardLines.length
+		}
+		if (!lineLimit) {
+			throw new Error()
+		}
+
+		let replaceEndTagRegexp = /^([+]{3,}|[>]{3,}) REPLACE$/
+		const replaceEndTagIndex = this.findLastMatchingLineIndex(replaceEndTagRegexp, lineLimit)
+		const likeReplaceEndTag = replaceEndTagIndex === lineLimit - 1
+		if (likeReplaceEndTag) {
+			// // 校验非标内容
+			// if (!this.isReplacingActive()) {
+			// 	removeLineCount += this.tryFixReplaceBlock(replaceEndTagIndex)
+			// }
+			let fixLines = this.pendingNonStandardLines.slice(replaceEndTagIndex - removeLineCount, lineLimit - removeLineCount)
+			fixLines[fixLines.length - 1] = REPLACE_BLOCK_END
+			for (const line of fixLines) {
+				removeLineCount += this.internalProcessLine(line, false, replaceEndTagIndex - removeLineCount)
+			}
+		} else {
+			throw new Error("Malformed SEARCH/REPLACE block structure: Missing valid closing REPLACE marker")
+		}
+		return removeLineCount
+	}
+
+	/**
+	 * Removes trailing empty lines from the pendingNonStandardLines array
+	 * @param lineLimit - The index to start checking from (exclusive).
+	 *                    Removes empty lines from lineLimit-1 backwards.
+	 * @returns The number of empty lines removed
+	 */
+	private trimPendingNonStandardTrailingEmptyLines(lineLimit: number): number {
+		let removedCount = 0
+		let i = Math.min(lineLimit, this.pendingNonStandardLines.length) - 1
+
+		while (i >= 0 && this.pendingNonStandardLines[i].trim() === "") {
+			this.pendingNonStandardLines.pop()
+			removedCount++
+			i--
+		}
+
+		return removedCount
+	}
+}
+
+export async function constructNewFileContentV2(diffContent: string, originalContent: string, isFinal: boolean): Promise<string> {
+	let newFileContentConstructor = new NewFileContentConstructor(originalContent, isFinal)
+
+	let lines = diffContent.split("\n")
+
+	// If the last line looks like a partial marker but isn't recognized,
+	// remove it because it might be incomplete.
+	const lastLine = lines[lines.length - 1]
+	if (
+		lines.length > 0 &&
+		(lastLine.startsWith(SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_SEARCH_BLOCK_CHAR) ||
+			lastLine.startsWith("=") ||
+			lastLine.startsWith(REPLACE_BLOCK_CHAR) ||
+			lastLine.startsWith(LEGACY_REPLACE_BLOCK_CHAR)) &&
+		lastLine !== SEARCH_BLOCK_START &&
+		lastLine !== SEARCH_BLOCK_END &&
+		lastLine !== REPLACE_BLOCK_END
+	) {
+		lines.pop()
+	}
+
+	for (const line of lines) {
+		newFileContentConstructor.processLine(line)
+	}
+
+	let result = newFileContentConstructor.getResult()
+	return result
+}

evals/diff-edits/helpers.ts

@@ -23,3 +23,9 @@ export const formatResponse = {
 		return formatImagesIntoBlocks(images)
 	},
 }
+
+export function log(isVerbose: boolean, message: string) {
+	if (isVerbose) {
+		console.log(message)
+	}
+}

evals/diff-edits/types.ts

@@ -29,6 +29,7 @@ export interface TestConfig {
 	model_id: string
 	system_prompt_name: string
 	number_of_runs: number
+	max_attempts_per_case: number
 	parsing_function: string
 	diff_edit_function: string
 	thinking_tokens_budget: number
@@ -81,6 +82,7 @@ export interface TestResult {
 	diffEdit?: string
 	toolCalls?: ExtractedToolCall[]
 	diffEditSuccess?: boolean
+	replacementData?: any
 	error?: string
 	errorString?: string
 }
@@ -102,4 +104,5 @@ export interface TestInput {
 	thinkingBudgetTokens: number
 	originalDiffEditToolCallMessage?: string
 	diffApplyFile?: string
+	isVerbose: boolean
 }

package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "claude-dev",
-	"version": "3.18.0",
+	"version": "3.18.3",
 	"lockfileVersion": 2,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "claude-dev",
-			"version": "3.18.0",
+			"version": "3.18.3",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"@anthropic-ai/sdk": "^0.37.0",
@@ -45,7 +45,6 @@
 				"fzf": "^0.5.2",
 				"get-folder-size": "^5.0.0",
 				"globby": "^14.0.2",
-				"google-auth-library": "^10.1.0",
 				"grpc-health-check": "^2.0.2",
 				"iconv-lite": "^0.6.3",
 				"ignore": "^7.0.3",
@@ -202,75 +201,6 @@
 				"undici-types": "~5.26.4"
 			}
 		},
-		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gaxios": {
-			"version": "6.7.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"extend": "^3.0.2",
-				"https-proxy-agent": "^7.0.1",
-				"is-stream": "^2.0.0",
-				"node-fetch": "^2.6.9",
-				"uuid": "^9.0.1"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gcp-metadata": {
-			"version": "6.1.1",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"gaxios": "^6.1.1",
-				"google-logging-utils": "^0.0.2",
-				"json-bigint": "^1.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@anthropic-ai/vertex-sdk/node_modules/google-auth-library": {
-			"version": "9.15.1",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"base64-js": "^1.3.0",
-				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^6.1.1",
-				"gcp-metadata": "^6.1.0",
-				"gtoken": "^7.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@anthropic-ai/vertex-sdk/node_modules/google-logging-utils": {
-			"version": "0.0.2",
-			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
-			"license": "Apache-2.0",
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@anthropic-ai/vertex-sdk/node_modules/gtoken": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-			"license": "MIT",
-			"dependencies": {
-				"gaxios": "^6.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			}
-		},
 		"node_modules/@asyncapi/parser": {
 			"version": "3.4.0",
 			"resolved": "https://registry.npmjs.org/@asyncapi/parser/-/parser-3.4.0.tgz",
@@ -2938,75 +2868,6 @@
 				"node": ">=18.0.0"
 			}
 		},
-		"node_modules/@google-cloud/vertexai/node_modules/gaxios": {
-			"version": "6.7.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"extend": "^3.0.2",
-				"https-proxy-agent": "^7.0.1",
-				"is-stream": "^2.0.0",
-				"node-fetch": "^2.6.9",
-				"uuid": "^9.0.1"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google-cloud/vertexai/node_modules/gcp-metadata": {
-			"version": "6.1.1",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"gaxios": "^6.1.1",
-				"google-logging-utils": "^0.0.2",
-				"json-bigint": "^1.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google-cloud/vertexai/node_modules/google-auth-library": {
-			"version": "9.15.1",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"base64-js": "^1.3.0",
-				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^6.1.1",
-				"gcp-metadata": "^6.1.0",
-				"gtoken": "^7.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google-cloud/vertexai/node_modules/google-logging-utils": {
-			"version": "0.0.2",
-			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
-			"license": "Apache-2.0",
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google-cloud/vertexai/node_modules/gtoken": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-			"license": "MIT",
-			"dependencies": {
-				"gaxios": "^6.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			}
-		},
 		"node_modules/@google/genai": {
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/@google/genai/-/genai-1.0.0.tgz",
@@ -3025,75 +2886,6 @@
 				"@modelcontextprotocol/sdk": "^1.11.0"
 			}
 		},
-		"node_modules/@google/genai/node_modules/gaxios": {
-			"version": "6.7.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"extend": "^3.0.2",
-				"https-proxy-agent": "^7.0.1",
-				"is-stream": "^2.0.0",
-				"node-fetch": "^2.6.9",
-				"uuid": "^9.0.1"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google/genai/node_modules/gcp-metadata": {
-			"version": "6.1.1",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-			"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"gaxios": "^6.1.1",
-				"google-logging-utils": "^0.0.2",
-				"json-bigint": "^1.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google/genai/node_modules/google-auth-library": {
-			"version": "9.15.1",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-			"license": "Apache-2.0",
-			"dependencies": {
-				"base64-js": "^1.3.0",
-				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^6.1.1",
-				"gcp-metadata": "^6.1.0",
-				"gtoken": "^7.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google/genai/node_modules/google-logging-utils": {
-			"version": "0.0.2",
-			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-			"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==",
-			"license": "Apache-2.0",
-			"engines": {
-				"node": ">=14"
-			}
-		},
-		"node_modules/@google/genai/node_modules/gtoken": {
-			"version": "7.1.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-			"license": "MIT",
-			"dependencies": {
-				"gaxios": "^6.0.0",
-				"jws": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=14.0.0"
-			}
-		},
 		"node_modules/@grpc/grpc-js": {
 			"version": "1.9.15",
 			"resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.9.15.tgz",
@@ -9810,10 +9602,9 @@
 			}
 		},
 		"node_modules/bignumber.js": {
-			"version": "9.3.0",
-			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.0.tgz",
-			"integrity": "sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA==",
-			"license": "MIT",
+			"version": "9.1.2",
+			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz",
+			"integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==",
 			"engines": {
 				"node": "*"
 			}
@@ -9999,8 +9790,7 @@
 		"node_modules/buffer-equal-constant-time": {
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
-			"integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
-			"license": "BSD-3-Clause"
+			"integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="
 		},
 		"node_modules/buffer-indexof-polyfill": {
 			"version": "1.0.2",
@@ -11658,7 +11448,6 @@
 			"version": "1.0.11",
 			"resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
 			"integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
-			"license": "Apache-2.0",
 			"dependencies": {
 				"safe-buffer": "^5.0.1"
 			}
@@ -13297,29 +13086,6 @@
 				"pend": "~1.2.0"
 			}
 		},
-		"node_modules/fetch-blob": {
-			"version": "3.2.0",
-			"resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
-			"integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
-			"funding": [
-				{
-					"type": "github",
-					"url": "https://github.com/sponsors/jimmywarting"
-				},
-				{
-					"type": "paypal",
-					"url": "https://paypal.me/jimmywarting"
-				}
-			],
-			"license": "MIT",
-			"dependencies": {
-				"node-domexception": "^1.0.0",
-				"web-streams-polyfill": "^3.0.3"
-			},
-			"engines": {
-				"node": "^12.20 || >= 14.13"
-			}
-		},
 		"node_modules/figures": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
@@ -13656,18 +13422,6 @@
 				"node": ">= 14"
 			}
 		},
-		"node_modules/formdata-polyfill": {
-			"version": "4.0.10",
-			"resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
-			"integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
-			"license": "MIT",
-			"dependencies": {
-				"fetch-blob": "^3.1.2"
-			},
-			"engines": {
-				"node": ">=12.20.0"
-			}
-		},
 		"node_modules/forwarded": {
 			"version": "0.2.0",
 			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -13934,44 +13688,18 @@
 			}
 		},
 		"node_modules/gaxios": {
-			"version": "7.1.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.1.tgz",
-			"integrity": "sha512-Odju3uBUJyVCkW64nLD4wKLhbh93bh6vIg/ZIXkWiLPBrdgtc65+tls/qml+un3pr6JqYVFDZbbmLDQT68rTOQ==",
-			"license": "Apache-2.0",
+			"version": "6.7.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
 			"dependencies": {
 				"extend": "^3.0.2",
 				"https-proxy-agent": "^7.0.1",
-				"node-fetch": "^3.3.2"
+				"is-stream": "^2.0.0",
+				"node-fetch": "^2.6.9",
+				"uuid": "^9.0.1"
 			},
 			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/gaxios/node_modules/data-uri-to-buffer": {
-			"version": "4.0.1",
-			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
-			"integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
-			"license": "MIT",
-			"engines": {
-				"node": ">= 12"
-			}
-		},
-		"node_modules/gaxios/node_modules/node-fetch": {
-			"version": "3.3.2",
-			"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
-			"integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
-			"license": "MIT",
-			"dependencies": {
-				"data-uri-to-buffer": "^4.0.0",
-				"fetch-blob": "^3.1.4",
-				"formdata-polyfill": "^4.0.10"
-			},
-			"engines": {
-				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-			},
-			"funding": {
-				"type": "opencollective",
-				"url": "https://opencollective.com/node-fetch"
+				"node": ">=14"
 			}
 		},
 		"node_modules/gcd": {
@@ -13981,17 +13709,15 @@
 			"dev": true
 		},
 		"node_modules/gcp-metadata": {
-			"version": "7.0.1",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-7.0.1.tgz",
-			"integrity": "sha512-UcO3kefx6dCcZkgcTGgVOTFb7b1LlQ02hY1omMjjrrBzkajRMCFgYOjs7J71WqnuG1k2b+9ppGL7FsOfhZMQKQ==",
-			"license": "Apache-2.0",
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.0.tgz",
+			"integrity": "sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==",
 			"dependencies": {
-				"gaxios": "^7.0.0",
-				"google-logging-utils": "^1.0.0",
+				"gaxios": "^6.0.0",
 				"json-bigint": "^1.0.0"
 			},
 			"engines": {
-				"node": ">=18"
+				"node": ">=14"
 			}
 		},
 		"node_modules/get-caller-file": {
@@ -14264,28 +13990,18 @@
 			}
 		},
 		"node_modules/google-auth-library": {
-			"version": "10.1.0",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.1.0.tgz",
-			"integrity": "sha512-GspVjZj1RbyRWpQ9FbAXMKjFGzZwDKnUHi66JJ+tcjcu5/xYAP1pdlWotCuIkMwjfVsxxDvsGZXGLzRt72D0sQ==",
+			"version": "9.15.1",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"base64-js": "^1.3.0",
 				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^7.0.0",
-				"gcp-metadata": "^7.0.0",
-				"google-logging-utils": "^1.0.0",
-				"gtoken": "^8.0.0",
+				"gaxios": "^6.1.1",
+				"gcp-metadata": "^6.1.0",
+				"gtoken": "^7.0.0",
 				"jws": "^4.0.0"
 			},
-			"engines": {
-				"node": ">=18"
-			}
-		},
-		"node_modules/google-logging-utils": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.1.tgz",
-			"integrity": "sha512-rcX58I7nqpu4mbKztFeOAObbomBbHU2oIb/d3tJfF3dizGSApqtSwYJigGCooHdnMyQBIw8BrWyK96w3YXgr6A==",
-			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=14"
 			}
@@ -14422,16 +14138,15 @@
 			}
 		},
 		"node_modules/gtoken": {
-			"version": "8.0.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-8.0.0.tgz",
-			"integrity": "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==",
-			"license": "MIT",
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
 			"dependencies": {
-				"gaxios": "^7.0.0",
+				"gaxios": "^6.0.0",
 				"jws": "^4.0.0"
 			},
 			"engines": {
-				"node": ">=18"
+				"node": ">=14.0.0"
 			}
 		},
 		"node_modules/has-bigints": {
@@ -16030,7 +15745,6 @@
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz",
 			"integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==",
-			"license": "MIT",
 			"dependencies": {
 				"bignumber.js": "^9.0.0"
 			}
@@ -16144,12 +15858,11 @@
 			"license": "MIT"
 		},
 		"node_modules/jwa": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
-			"integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
-			"license": "MIT",
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
+			"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
 			"dependencies": {
-				"buffer-equal-constant-time": "^1.0.1",
+				"buffer-equal-constant-time": "1.0.1",
 				"ecdsa-sig-formatter": "1.0.11",
 				"safe-buffer": "^5.0.1"
 			}
@@ -16158,7 +15871,6 @@
 			"version": "4.0.0",
 			"resolved": "https://registry.npmjs.org/jws/-/jws-4.0.0.tgz",
 			"integrity": "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==",
-			"license": "MIT",
 			"dependencies": {
 				"jwa": "^2.0.0",
 				"safe-buffer": "^5.0.1"
@@ -23688,15 +23400,6 @@
 				"url": "https://github.com/sponsors/wooorm"
 			}
 		},
-		"node_modules/web-streams-polyfill": {
-			"version": "3.3.3",
-			"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
-			"integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
-			"license": "MIT",
-			"engines": {
-				"node": ">= 8"
-			}
-		},
 		"node_modules/web-tree-sitter": {
 			"version": "0.22.6",
 			"resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.22.6.tgz",
@@ -24457,55 +24160,6 @@
 					"requires": {
 						"undici-types": "~5.26.4"
 					}
-				},
-				"gaxios": {
-					"version": "6.7.1",
-					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-					"requires": {
-						"extend": "^3.0.2",
-						"https-proxy-agent": "^7.0.1",
-						"is-stream": "^2.0.0",
-						"node-fetch": "^2.6.9",
-						"uuid": "^9.0.1"
-					}
-				},
-				"gcp-metadata": {
-					"version": "6.1.1",
-					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-					"requires": {
-						"gaxios": "^6.1.1",
-						"google-logging-utils": "^0.0.2",
-						"json-bigint": "^1.0.0"
-					}
-				},
-				"google-auth-library": {
-					"version": "9.15.1",
-					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-					"requires": {
-						"base64-js": "^1.3.0",
-						"ecdsa-sig-formatter": "^1.0.11",
-						"gaxios": "^6.1.1",
-						"gcp-metadata": "^6.1.0",
-						"gtoken": "^7.0.0",
-						"jws": "^4.0.0"
-					}
-				},
-				"google-logging-utils": {
-					"version": "0.0.2",
-					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
-				},
-				"gtoken": {
-					"version": "7.1.0",
-					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-					"requires": {
-						"gaxios": "^6.0.0",
-						"jws": "^4.0.0"
-					}
 				}
 			}
 		},
@@ -26762,57 +26416,6 @@
 			"integrity": "sha512-35o5tIEMLW3JeFJOaaMNR2e5sq+6rpnhrF97PuAxeOm0GlqVTESKhkGj7a5B5mmJSSSU3hUfIhcQCRRsw4Ipzg==",
 			"requires": {
 				"google-auth-library": "^9.1.0"
-			},
-			"dependencies": {
-				"gaxios": {
-					"version": "6.7.1",
-					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-					"requires": {
-						"extend": "^3.0.2",
-						"https-proxy-agent": "^7.0.1",
-						"is-stream": "^2.0.0",
-						"node-fetch": "^2.6.9",
-						"uuid": "^9.0.1"
-					}
-				},
-				"gcp-metadata": {
-					"version": "6.1.1",
-					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-					"requires": {
-						"gaxios": "^6.1.1",
-						"google-logging-utils": "^0.0.2",
-						"json-bigint": "^1.0.0"
-					}
-				},
-				"google-auth-library": {
-					"version": "9.15.1",
-					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-					"requires": {
-						"base64-js": "^1.3.0",
-						"ecdsa-sig-formatter": "^1.0.11",
-						"gaxios": "^6.1.1",
-						"gcp-metadata": "^6.1.0",
-						"gtoken": "^7.0.0",
-						"jws": "^4.0.0"
-					}
-				},
-				"google-logging-utils": {
-					"version": "0.0.2",
-					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
-				},
-				"gtoken": {
-					"version": "7.1.0",
-					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-					"requires": {
-						"gaxios": "^6.0.0",
-						"jws": "^4.0.0"
-					}
-				}
 			}
 		},
 		"@google/genai": {
@@ -26824,57 +26427,6 @@
 				"ws": "^8.18.0",
 				"zod": "^3.22.4",
 				"zod-to-json-schema": "^3.22.4"
-			},
-			"dependencies": {
-				"gaxios": {
-					"version": "6.7.1",
-					"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
-					"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
-					"requires": {
-						"extend": "^3.0.2",
-						"https-proxy-agent": "^7.0.1",
-						"is-stream": "^2.0.0",
-						"node-fetch": "^2.6.9",
-						"uuid": "^9.0.1"
-					}
-				},
-				"gcp-metadata": {
-					"version": "6.1.1",
-					"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz",
-					"integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==",
-					"requires": {
-						"gaxios": "^6.1.1",
-						"google-logging-utils": "^0.0.2",
-						"json-bigint": "^1.0.0"
-					}
-				},
-				"google-auth-library": {
-					"version": "9.15.1",
-					"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
-					"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
-					"requires": {
-						"base64-js": "^1.3.0",
-						"ecdsa-sig-formatter": "^1.0.11",
-						"gaxios": "^6.1.1",
-						"gcp-metadata": "^6.1.0",
-						"gtoken": "^7.0.0",
-						"jws": "^4.0.0"
-					}
-				},
-				"google-logging-utils": {
-					"version": "0.0.2",
-					"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz",
-					"integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="
-				},
-				"gtoken": {
-					"version": "7.1.0",
-					"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
-					"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
-					"requires": {
-						"gaxios": "^6.0.0",
-						"jws": "^4.0.0"
-					}
-				}
 			}
 		},
 		"@grpc/grpc-js": {
@@ -31658,9 +31210,9 @@
 			"integrity": "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="
 		},
 		"bignumber.js": {
-			"version": "9.3.0",
-			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.0.tgz",
-			"integrity": "sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA=="
+			"version": "9.1.2",
+			"resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.2.tgz",
+			"integrity": "sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug=="
 		},
 		"binary": {
 			"version": "0.3.0",
@@ -34012,15 +33564,6 @@
 				"pend": "~1.2.0"
 			}
 		},
-		"fetch-blob": {
-			"version": "3.2.0",
-			"resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
-			"integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
-			"requires": {
-				"node-domexception": "^1.0.0",
-				"web-streams-polyfill": "^3.0.3"
-			}
-		},
 		"figures": {
 			"version": "6.1.0",
 			"resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
@@ -34256,14 +33799,6 @@
 				}
 			}
 		},
-		"formdata-polyfill": {
-			"version": "4.0.10",
-			"resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
-			"integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
-			"requires": {
-				"fetch-blob": "^3.1.2"
-			}
-		},
 		"forwarded": {
 			"version": "0.2.0",
 			"resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
@@ -34449,30 +33984,15 @@
 			}
 		},
 		"gaxios": {
-			"version": "7.1.1",
-			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-7.1.1.tgz",
-			"integrity": "sha512-Odju3uBUJyVCkW64nLD4wKLhbh93bh6vIg/ZIXkWiLPBrdgtc65+tls/qml+un3pr6JqYVFDZbbmLDQT68rTOQ==",
+			"version": "6.7.1",
+			"resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz",
+			"integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==",
 			"requires": {
 				"extend": "^3.0.2",
 				"https-proxy-agent": "^7.0.1",
-				"node-fetch": "^3.3.2"
-			},
-			"dependencies": {
-				"data-uri-to-buffer": {
-					"version": "4.0.1",
-					"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
-					"integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A=="
-				},
-				"node-fetch": {
-					"version": "3.3.2",
-					"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
-					"integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
-					"requires": {
-						"data-uri-to-buffer": "^4.0.0",
-						"fetch-blob": "^3.1.4",
-						"formdata-polyfill": "^4.0.10"
-					}
-				}
+				"is-stream": "^2.0.0",
+				"node-fetch": "^2.6.9",
+				"uuid": "^9.0.1"
 			}
 		},
 		"gcd": {
@@ -34482,12 +34002,11 @@
 			"dev": true
 		},
 		"gcp-metadata": {
-			"version": "7.0.1",
-			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-7.0.1.tgz",
-			"integrity": "sha512-UcO3kefx6dCcZkgcTGgVOTFb7b1LlQ02hY1omMjjrrBzkajRMCFgYOjs7J71WqnuG1k2b+9ppGL7FsOfhZMQKQ==",
+			"version": "6.1.0",
+			"resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.0.tgz",
+			"integrity": "sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==",
 			"requires": {
-				"gaxios": "^7.0.0",
-				"google-logging-utils": "^1.0.0",
+				"gaxios": "^6.0.0",
 				"json-bigint": "^1.0.0"
 			}
 		},
@@ -34661,24 +34180,18 @@
 			}
 		},
 		"google-auth-library": {
-			"version": "10.1.0",
-			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-10.1.0.tgz",
-			"integrity": "sha512-GspVjZj1RbyRWpQ9FbAXMKjFGzZwDKnUHi66JJ+tcjcu5/xYAP1pdlWotCuIkMwjfVsxxDvsGZXGLzRt72D0sQ==",
+			"version": "9.15.1",
+			"resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz",
+			"integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==",
 			"requires": {
 				"base64-js": "^1.3.0",
 				"ecdsa-sig-formatter": "^1.0.11",
-				"gaxios": "^7.0.0",
-				"gcp-metadata": "^7.0.0",
-				"google-logging-utils": "^1.0.0",
-				"gtoken": "^8.0.0",
+				"gaxios": "^6.1.1",
+				"gcp-metadata": "^6.1.0",
+				"gtoken": "^7.0.0",
 				"jws": "^4.0.0"
 			}
 		},
-		"google-logging-utils": {
-			"version": "1.1.1",
-			"resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-1.1.1.tgz",
-			"integrity": "sha512-rcX58I7nqpu4mbKztFeOAObbomBbHU2oIb/d3tJfF3dizGSApqtSwYJigGCooHdnMyQBIw8BrWyK96w3YXgr6A=="
-		},
 		"gopd": {
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
@@ -34779,11 +34292,11 @@
 			}
 		},
 		"gtoken": {
-			"version": "8.0.0",
-			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-8.0.0.tgz",
-			"integrity": "sha512-+CqsMbHPiSTdtSO14O51eMNlrp9N79gmeqmXeouJOhfucAedHw9noVe/n5uJk3tbKE6a+6ZCQg3RPhVhHByAIw==",
+			"version": "7.1.0",
+			"resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz",
+			"integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==",
 			"requires": {
-				"gaxios": "^7.0.0",
+				"gaxios": "^6.0.0",
 				"jws": "^4.0.0"
 			}
 		},
@@ -35923,11 +35436,11 @@
 			"dev": true
 		},
 		"jwa": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
-			"integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.0.tgz",
+			"integrity": "sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==",
 			"requires": {
-				"buffer-equal-constant-time": "^1.0.1",
+				"buffer-equal-constant-time": "1.0.1",
 				"ecdsa-sig-formatter": "1.0.11",
 				"safe-buffer": "^5.0.1"
 			}
@@ -41118,11 +40631,6 @@
 			"integrity": "sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==",
 			"dev": true
 		},
-		"web-streams-polyfill": {
-			"version": "3.3.3",
-			"resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
-			"integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw=="
-		},
 		"web-tree-sitter": {
 			"version": "0.22.6",
 			"resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.22.6.tgz",

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.18.0",
+	"version": "3.18.3",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -332,14 +332,14 @@
 		"package": "npm run check-types && npm run build:webview && npm run lint && node esbuild.js --production",
 		"protos": "node proto/build-proto.js && node scripts/generate-server-setup.mjs && node scripts/generate-host-bridge-client.mjs",
 		"postprotos": "prettier src/shared/proto src/core/controller src/hosts/ webview-ui/src/services src/generated --write --log-level warn",
-		"clean": "rimraf dist dist-standalone webview-ui/build src/generated",
+		"clean": "rimraf dist dist-standalone webview-ui/build src/generated out/",
 		"compile-tests": "node ./scripts/build-tests.js",
 		"watch-tests": "tsc -p . -w --outDir out",
-		"pretest": "npm run compile-tests && npm run compile && npm run compile-standalone && npm run lint",
 		"check-types": "npm run protos && tsc --noEmit",
 		"lint": "eslint src --ext ts && eslint webview-ui/src --ext ts && buf lint && cd webview-ui && npm run lint",
 		"format": "prettier . --check",
 		"format:fix": "prettier . --write",
+		"pretest": "npm run compile && npm run compile-tests && npm run compile-standalone && npm run lint",
 		"test": "npm-run-all test:unit test:integration",
 		"test:ci": "node scripts/test-ci.js",
 		"test:integration": "vscode-test",
@@ -442,7 +442,6 @@
 		"fzf": "^0.5.2",
 		"get-folder-size": "^5.0.0",
 		"globby": "^14.0.2",
-		"google-auth-library": "^10.1.0",
 		"grpc-health-check": "^2.0.2",
 		"iconv-lite": "^0.6.3",
 		"ignore": "^7.0.3",

proto/build-proto-config.js

@@ -0,0 +1,31 @@
+// Configuration file for protocol buffer build scripts
+// Contains service name mappings used by both build-proto.js and build-go-proto.js
+
+// List of gRPC services
+// To add a new service, simply add it to this map and run the build scripts
+// The service handler will be automatically discovered and used by grpc-handler.ts
+export const serviceNameMap = {
+	account: "cline.AccountService",
+	browser: "cline.BrowserService",
+	checkpoints: "cline.CheckpointsService",
+	file: "cline.FileService",
+	mcp: "cline.McpService",
+	state: "cline.StateService",
+	task: "cline.TaskService",
+	web: "cline.WebService",
+	models: "cline.ModelsService",
+	slash: "cline.SlashService",
+	ui: "cline.UiService",
+	// Add new services here - no other code changes needed!
+}
+
+// List of host gRPC services (IDE API bridge)
+// These services are implemented in the IDE extension and called by the standalone Cline Core
+export const hostServiceNameMap = {
+	uri: "host.UriService",
+	watch: "host.WatchService",
+	workspace: "host.WorkspaceService",
+	env: "host.EnvService",
+	window: "host.WindowService",
+	// Add new host services here
+}

proto/build-proto.js

@@ -9,16 +9,18 @@ import chalk from "chalk"
 import os from "os"
 
 import { createRequire } from "module"
+import { serviceNameMap, hostServiceNameMap } from "./build-proto-config.js"
+
 const require = createRequire(import.meta.url)
 const PROTOC = path.join(require.resolve("grpc-tools"), "../bin/protoc")
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url))
 const ROOT_DIR = path.resolve(SCRIPT_DIR, "..")
 
-const TS_OUT_DIR = path.join(ROOT_DIR, "src/shared/proto")
-const GRPC_JS_OUT_DIR = path.join(ROOT_DIR, "src/generated/grpc-js")
-const NICE_JS_OUT_DIR = path.join(ROOT_DIR, "src/generated/nice-grpc")
-const DESCRIPTOR_OUT_DIR = path.join(ROOT_DIR, "dist-standalone/proto")
+const TS_OUT_DIR = path.join(ROOT_DIR, "src", "shared", "proto")
+const GRPC_JS_OUT_DIR = path.join(ROOT_DIR, "src", "generated", "grpc-js")
+const NICE_JS_OUT_DIR = path.join(ROOT_DIR, "src", "generated", "nice-grpc")
+const DESCRIPTOR_OUT_DIR = path.join(ROOT_DIR, "dist-standalone", "proto")
 
 const isWindows = process.platform === "win32"
 const TS_PROTO_PLUGIN = isWindows
@@ -34,34 +36,13 @@ const TS_PROTO_OPTIONS = [
 	"useDate=false", // Timestamp fields will not be automatically converted to Date.
 ]
 
-// List of gRPC services
-// To add a new service, simply add it to this map and run this script
-// The service handler will be automatically discovered and used by grpc-handler.ts
-const serviceNameMap = {
-	account: "cline.AccountService",
-	browser: "cline.BrowserService",
-	checkpoints: "cline.CheckpointsService",
-	file: "cline.FileService",
-	mcp: "cline.McpService",
-	state: "cline.StateService",
-	task: "cline.TaskService",
-	web: "cline.WebService",
-	models: "cline.ModelsService",
-	slash: "cline.SlashService",
-	ui: "cline.UiService",
-	// Add new services here - no other code changes needed!
-}
-const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src/core/controller", serviceKey))
+// Service directories derived from imported serviceNameMap
+const serviceDirs = Object.keys(serviceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src", "core", "controller", serviceKey))
 
-// List of host gRPC services (IDE API bridge)
-// These services are implemented in the IDE extension and called by the standalone Cline Core
-const hostServiceNameMap = {
-	uri: "host.UriService",
-	watch: "host.WatchService",
-	workspace: "host.WorkspaceService",
-	// Add new host services here
-}
-const hostServiceDirs = Object.keys(hostServiceNameMap).map((serviceKey) => path.join(ROOT_DIR, "src/hosts/vscode", serviceKey))
+// Host service directories derived from imported hostServiceNameMap
+const hostServiceDirs = Object.keys(hostServiceNameMap).map((serviceKey) =>
+	path.join(ROOT_DIR, "src", "hosts", "vscode", serviceKey),
+)
 
 async function main() {
 	console.log(chalk.bold.blue("Starting Protocol Buffer code generation..."))
@@ -177,7 +158,7 @@ export {
 	${serviceExports.join(",\n\t")}
 }`
 
-	const filePath = path.join(ROOT_DIR, "webview-ui/src/services/grpc-client.ts")
+	const filePath = path.join(ROOT_DIR, "webview-ui", "src", "services", "grpc-client.ts")
 	await writeFileWithMkdirs(filePath, content)
 	log_verbose(chalk.green(`Generated gRPC client at ${filePath}`))
 }
@@ -386,7 +367,7 @@ export interface ServiceHandlerConfig {
 export const serviceHandlers: Record<string, ServiceHandlerConfig> = {${serviceConfigs.join(",")}
 };`
 
-	const configPath = path.join(ROOT_DIR, "src/core/controller/grpc-service-config.ts")
+	const configPath = path.join(ROOT_DIR, "src", "core", "controller", "grpc-service-config.ts")
 	await writeFileWithMkdirs(configPath, content)
 	log_verbose(chalk.green(`Generated service configuration at ${configPath}`))
 }
@@ -602,13 +583,12 @@ async function cleanup() {
 	for (const file of existingFiles) {
 		await fs.unlink(path.join(TS_OUT_DIR, file))
 	}
-	await rmdir(path.join(ROOT_DIR, "src/generated"))
+	await rmdir(path.join(ROOT_DIR, "src", "generated"))
 
 	// Clean up generated files that were moved.
-	await fs.rm(path.join(ROOT_DIR, "src/standalone/services/host-grpc-client.ts"), { force: true })
-	await rmdir(path.join(ROOT_DIR, "src/standalone/services"))
-
-	await fs.rm(path.join(ROOT_DIR, "hosts/vscode"), { force: true, recursive: true })
+	await fs.rm(path.join(ROOT_DIR, "src", "standalone", "services", "host-grpc-client.ts"), { force: true })
+	await rmdir(path.join(ROOT_DIR, "src", "standalone", "services"))
+	await fs.rm(path.join(ROOT_DIR, "hosts", "vscode"), { force: true, recursive: true })
 	await rmdir(path.join(ROOT_DIR, "hosts"))
 
 	await fs.rm(path.join(ROOT_DIR, "src/standalone/server-setup.ts"), { force: true })
@@ -636,13 +616,6 @@ async function rmdir(path) {
 	}
 }
 
-function serviceNameWithoutPackage(fullServiceName) {
-	return fullServiceName.replace(/.*\./, "")
-}
-function lowercaseFirstChar(str) {
-	return str.charAt(0).toLowerCase() + str.slice(1)
-}
-
 // Check for Apple Silicon compatibility
 function checkAppleSiliconCompatibility() {
 	// Only run check on macOS

proto/host/env.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+// Provides methods for working with the user's environment.
+service EnvService {
+  // Writes text to the system clipboard.
+  rpc clipboardWriteText(cline.StringRequest) returns (cline.Empty);
+
+  // Reads text from the system clipboard.
+  rpc clipboardReadText(cline.EmptyRequest) returns (cline.String);
+}

proto/host/window.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package host;
+option java_package = "bot.cline.host.proto";
+option java_multiple_files = true;
+
+import "common.proto";
+
+// Provides methods for working with IDE windows and editors.
+service WindowService {
+  // Opens a text document in the editor and returns editor information.
+  rpc showTextDocument(ShowTextDocumentRequest) returns (TextEditorInfo);
+  rpc showOpenDialogue(ShowOpenDialogueRequest) returns (SelectedResources);
+}
+
+message ShowTextDocumentRequest {
+  cline.Metadata metadata = 1;
+  string path = 2;
+  optional ShowTextDocumentOptions options = 3;
+}
+
+// See https://code.visualstudio.com/api/references/vscode-api#TextDocumentShowOptions
+message ShowTextDocumentOptions {
+  optional bool preview = 1;
+  optional bool preserve_focus = 2;
+  optional int32 view_column = 3;
+}
+
+message TextEditorInfo {
+  string document_path = 1;
+  optional int32 view_column = 2;
+  bool is_active = 3;
+}
+
+message ShowOpenDialogueRequest {
+  cline.Metadata metadata = 1;
+  optional bool can_select_many = 2;
+  optional string open_label = 3;
+  optional ShowOpenDialogueFilterOption filters = 4;
+}
+
+message ShowOpenDialogueFilterOption {
+  repeated string files = 1;
+}
+
+message SelectedResources {
+  repeated string paths = 1;
+}

proto/mcp.proto

@@ -10,7 +10,7 @@ service McpService {
   rpc toggleMcpServer(ToggleMcpServerRequest) returns (McpServers);
   rpc updateMcpTimeout(UpdateMcpTimeoutRequest) returns (McpServers);
   rpc addRemoteMcpServer(AddRemoteMcpServerRequest) returns (McpServers);
-  rpc downloadMcp(StringRequest) returns (Empty);
+  rpc downloadMcp(StringRequest) returns (McpDownloadResponse);
   rpc restartMcpServer(StringRequest) returns (McpServers);
   rpc deleteMcpServer(StringRequest) returns (McpServers);
   rpc toggleToolAutoApprove(ToggleToolAutoApproveRequest) returns (McpServers);
@@ -119,3 +119,15 @@ message McpMarketplaceItem {
 message McpMarketplaceCatalog {
   repeated McpMarketplaceItem items = 1;
 }
+
+message McpDownloadResponse {
+  string mcp_id = 1;
+  string github_url = 2;
+  string name = 3;
+  string author = 4;
+  string description = 5;
+  string readme_content = 6;
+  string llms_installation_content = 7;
+  bool requires_api_key = 8;
+  optional string error = 9;
+}

proto/models.proto

@@ -105,25 +105,24 @@ enum ApiProvider {
   OLLAMA = 5;
   LMSTUDIO = 6;
   GEMINI = 7;
-  GEMINI_CLI = 8;
-  OPENAI_NATIVE = 9;
-  REQUESTY = 10;
-  TOGETHER = 11;
-  DEEPSEEK = 12;
-  QWEN = 13;
-  DOUBAO = 14;
-  MISTRAL = 15;
-  VSCODE_LM = 16;
-  CLINE = 17;
-  LITELLM = 18;
-  NEBIUS = 19;
-  FIREWORKS = 20;
-  ASKSAGE = 21;
-  XAI = 22;
-  SAMBANOVA = 23;
-  CEREBRAS = 24;
-  SAPAICORE = 25;
-  CLAUDE_CODE = 26;
+  OPENAI_NATIVE = 8;
+  REQUESTY = 9;
+  TOGETHER = 10;
+  DEEPSEEK = 11;
+  QWEN = 12;
+  DOUBAO = 13;
+  MISTRAL = 14;
+  VSCODE_LM = 15;
+  CLINE = 16;
+  LITELLM = 17;
+  NEBIUS = 18;
+  FIREWORKS = 19;
+  ASKSAGE = 20;
+  XAI = 21;
+  SAMBANOVA = 22;
+  CEREBRAS = 23;
+  SAPAICORE = 24;
+  CLAUDE_CODE = 25;
 }
 
 // Model info for OpenAI-compatible models
@@ -237,6 +236,4 @@ message ModelsApiConfiguration {
   optional string sap_ai_core_token_url = 71;
   optional string sap_ai_core_base_url = 72;
   optional string claude_code_path = 73;
-  optional string gemini_cli_oauth_path = 74;
-  optional string gemini_cli_project_id = 75;
-}
+}

proto/state.proto

@@ -18,6 +18,7 @@ service StateService {
   rpc updateAutoApprovalSettings(AutoApprovalSettingsRequest) returns (Empty);
   rpc updateSettings(UpdateSettingsRequest) returns (Empty);
   rpc updateTelemetrySetting(TelemetrySettingRequest) returns (Empty);
+  rpc setWelcomeViewCompleted(BooleanRequest) returns (Empty);
 }
 
 message State {

proto/task.proto

@@ -23,8 +23,6 @@ service TaskService {
   rpc exportTaskWithId(StringRequest) returns (Empty);
   // Toggles the favorite status of a task
   rpc toggleTaskFavorite(TaskFavoriteRequest) returns (Empty);
-  // Deletes all non-favorited tasks
-  rpc deleteNonFavoritedTasks(EmptyRequest) returns (DeleteNonFavoritedTasksResults);
   // Gets filtered task history
   rpc getTaskHistory(GetTaskHistoryRequest) returns (TaskHistoryArray);
   // Sends a response to a previous ask operation
@@ -36,7 +34,7 @@ service TaskService {
   // Executes a quick win task with command and title
   rpc executeQuickWin(ExecuteQuickWinRequest) returns (Empty);
   // Deletes all task history
-  rpc deleteAllTaskHistory(BooleanRequest) returns (DeleteAllTaskHistoryCount);
+  rpc deleteAllTaskHistory(EmptyRequest) returns (DeleteAllTaskHistoryCount);
 }
 
 // Request message for creating a new task
@@ -68,12 +66,6 @@ message TaskResponse {
   int32 cache_reads = 10;
 }
 
-// Results returned when deleting non-favorited tasks
-message DeleteNonFavoritedTasksResults {
-  int32 tasks_preserved = 1;
-  int32 tasks_deleted = 2;
-}
-
 // Request for getting task history with filtering
 message GetTaskHistoryRequest {
   Metadata metadata = 1;

src/api/index.ts

@@ -8,7 +8,6 @@ import { OpenAiHandler } from "./providers/openai"
 import { OllamaHandler } from "./providers/ollama"
 import { LmStudioHandler } from "./providers/lmstudio"
 import { GeminiHandler } from "./providers/gemini"
-import { GeminiCliHandler } from "./providers/gemini-cli"
 import { OpenAiNativeHandler } from "./providers/openai-native"
 import { ApiStream, ApiStreamUsageChunk } from "./transform/stream"
 import { DeepSeekHandler } from "./providers/deepseek"
@@ -57,8 +56,6 @@ function createHandlerForProvider(apiProvider: string | undefined, options: any)
 			return new LmStudioHandler(options)
 		case "gemini":
 			return new GeminiHandler(options)
-		case "gemini-cli":
-			return new GeminiCliHandler(options)
 		case "openai-native":
 			return new OpenAiNativeHandler(options)
 		case "deepseek":

src/api/providers/cerebras.ts

@@ -33,6 +33,15 @@ export class CerebrasHandler implements ApiHandler {
 			content: string
 		}> = [{ role: "system", content: systemPrompt }]
 
+		// Helper function to strip thinking tags from content
+		const stripThinkingTags = (content: string): string => {
+			return content.replace(/<think>[\s\S]*?<\/think>/g, "").trim()
+		}
+
+		// Check if this is a reasoning model that uses thinking tags
+		const modelId = this.getModel().id
+		const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
+
 		// Convert Anthropic messages to Cerebras format
 		for (const message of messages) {
 			if (message.role === "user") {
@@ -50,7 +59,7 @@ export class CerebrasHandler implements ApiHandler {
 					: message.content
 				cerebrasMessages.push({ role: "user", content })
 			} else if (message.role === "assistant") {
-				const content = Array.isArray(message.content)
+				let content = Array.isArray(message.content)
 					? message.content
 							.map((block) => {
 								if (block.type === "text") {
@@ -60,6 +69,13 @@ export class CerebrasHandler implements ApiHandler {
 							})
 							.join("\n")
 					: message.content || ""
+
+				// Strip thinking tags from assistant messages for reasoning models
+				// so the model doesn't see its own thinking in the conversation history
+				if (isReasoningModel) {
+					content = stripThinkingTags(content)
+				}
+
 				cerebrasMessages.push({ role: "assistant", content })
 			}
 		}
@@ -74,8 +90,6 @@ export class CerebrasHandler implements ApiHandler {
 
 			// Handle streaming response
 			let reasoning: string | null = null // Track reasoning content for models that support thinking
-			const modelId = this.getModel().id
-			const isReasoningModel = modelId.includes("qwen") || modelId.includes("deepseek-r1-distill")
 
 			for await (const chunk of stream as any) {
 				// Type assertion for the streaming chunk

src/api/providers/claude-code.ts

@@ -27,6 +27,7 @@ export class ClaudeCodeHandler implements ApiHandler {
 			messages: filteredMessages,
 			path: this.options.claudeCodePath,
 			modelId: this.getModel().id,
+			thinkingBudgetTokens: this.options.thinkingBudgetTokens,
 		})
 
 		// Usage is included with assistant messages,

src/api/providers/gemini-cli.ts

@@ -1,418 +0,0 @@
-/**
- * Gemini CLI Provider - OAuth-based API Handler
- *
- * This implementation provides access to Google's Gemini models through OAuth authentication,
- * leveraging the same authentication mechanism as the official Gemini CLI tool.
- *
- * Attribution: This implementation is inspired by and uses concepts from the Google Gemini CLI,
- * which is licensed under the Apache License 2.0.
- * Original project: https://github.com/google-gemini/gemini-cli
- *
- * Copyright 2025 Google LLC
- * Licensed under the Apache License, Version 2.0
- *
- * Key features:
- * - OAuth2 authentication (no API keys required)
- * - Auto-discovery of Google Cloud project IDs
- * - Real-time streaming via Server-Sent Events
- * - Free tier access through Google's Code Assist API
- * - Compatible with personal Google accounts only
- */
-
-import type { Anthropic } from "@anthropic-ai/sdk"
-import { OAuth2Client } from "google-auth-library"
-import fs from "fs/promises"
-import path from "path"
-import os from "os"
-import * as readline from "readline"
-import { Readable } from "stream"
-import { ApiHandler } from "../"
-import { ApiHandlerOptions, GeminiCliModelId, geminiCliModels, ModelInfo, geminiCliDefaultModelId } from "@shared/api"
-import { convertAnthropicMessageToGemini } from "../transform/gemini-format"
-import { ApiStream } from "../transform/stream"
-import { withRetry } from "../retry"
-
-const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com"
-const CODE_ASSIST_API_VERSION = "v1internal"
-
-// OAuth configuration
-const OAUTH_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com"
-// Change this line in setup.js:
-const OAUTH_CLIENT_SECRET = "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"
-
-const OAUTH_REDIRECT_URI = "http://localhost:45289"
-
-interface OAuthCredentials {
-	access_token: string
-	refresh_token: string
-	scope: string
-	token_type: string
-	expiry_date: number
-}
-
-interface GeminiCliHandlerOptions extends ApiHandlerOptions {
-	geminiCliOAuthPath?: string
-	geminiCliProjectId?: string
-}
-
-/**
- * Handler for Google's Gemini API via OAuth (Gemini CLI style).
- *
- * This provider uses OAuth authentication instead of API keys, making it suitable
- * for users who have already authenticated with the Gemini CLI tool.
- * It automatically discovers project IDs and works with the free tier.
- */
-export class GeminiCliHandler implements ApiHandler {
-	private options: GeminiCliHandlerOptions
-	private authClient: OAuth2Client
-	private projectId: string | null = null
-	private authInitialized: boolean = false
-
-	constructor(options: GeminiCliHandlerOptions) {
-		this.options = options
-		this.authClient = new OAuth2Client(OAUTH_CLIENT_ID, OAUTH_CLIENT_SECRET, OAUTH_REDIRECT_URI)
-	}
-
-	/**
-	 * Load OAuth credentials from the file system
-	 */
-	private async loadOAuthCredentials(): Promise<OAuthCredentials> {
-		const credPath = this.options.geminiCliOAuthPath || path.join(os.homedir(), ".gemini", "oauth_creds.json")
-		try {
-			const data = await fs.readFile(credPath, "utf8")
-			return JSON.parse(data)
-		} catch (err) {
-			throw new Error(`Failed to load OAuth credentials from ${credPath}. Please authenticate with 'gemini auth' first.`)
-		}
-	}
-
-	/**
-	 * Call a Code Assist API endpoint
-	 */
-	private async callEndpoint(method: string, body: any, retryAuth: boolean = true): Promise<any> {
-		console.log(`[GeminiCLI] Calling endpoint: ${method}`)
-		console.log(`[GeminiCLI] Request body:`, JSON.stringify(body, null, 2))
-
-		try {
-			const res = await this.authClient.request({
-				url: `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:${method}`,
-				method: "POST",
-				headers: {
-					"Content-Type": "application/json",
-				},
-				responseType: "json",
-				body: JSON.stringify(body),
-			})
-			console.log(`[GeminiCLI] Response status:`, res.status)
-			console.log(`[GeminiCLI] Response data:`, JSON.stringify(res.data, null, 2))
-			return res.data
-		} catch (error: any) {
-			console.error(`[GeminiCLI] Error calling ${method}:`, error)
-			console.error(`[GeminiCLI] Error response:`, error.response?.data)
-			console.error(`[GeminiCLI] Error status:`, error.response?.status)
-			console.error(`[GeminiCLI] Error message:`, error.message)
-
-			// If we get a 401 and haven't retried yet, try refreshing auth
-			if (error.response?.status === 401 && retryAuth) {
-				console.log(`[GeminiCLI] Got 401, attempting to refresh authentication...`)
-				await this.initializeAuth(true) // Force refresh
-				return this.callEndpoint(method, body, false) // Retry without further auth retries
-			}
-
-			throw error
-		}
-	}
-
-	/**
-	 * Discover or retrieve the project ID
-	 */
-	private async discoverProjectId(): Promise<string> {
-		// If we already have a project ID, use it
-		if (this.options.geminiCliProjectId) {
-			return this.options.geminiCliProjectId
-		}
-
-		// If we've already discovered it, return it
-		if (this.projectId) {
-			return this.projectId
-		}
-
-		// Start with a default project ID (can be anything for personal OAuth)
-		const initialProjectId = "default"
-
-		// Prepare client metadata
-		const clientMetadata = {
-			ideType: "IDE_UNSPECIFIED",
-			platform: "PLATFORM_UNSPECIFIED",
-			pluginType: "GEMINI",
-			duetProject: initialProjectId,
-		}
-
-		try {
-			// Call loadCodeAssist to discover the actual project ID
-			const loadRequest = {
-				cloudaicompanionProject: initialProjectId,
-				metadata: clientMetadata,
-			}
-
-			const loadResponse = await this.callEndpoint("loadCodeAssist", loadRequest)
-
-			// Check if we already have a project ID from the response
-			if (loadResponse.cloudaicompanionProject) {
-				this.projectId = loadResponse.cloudaicompanionProject
-				return this.projectId as string
-			}
-
-			// If no existing project, we need to onboard
-			const defaultTier = loadResponse.allowedTiers?.find((tier: any) => tier.isDefault)
-			const tierId = defaultTier?.id || "free-tier"
-
-			const onboardRequest = {
-				tierId: tierId,
-				cloudaicompanionProject: initialProjectId,
-				metadata: clientMetadata,
-			}
-
-			let lroResponse = await this.callEndpoint("onboardUser", onboardRequest)
-
-			// Poll until operation is complete
-			while (!lroResponse.done) {
-				await new Promise((resolve) => setTimeout(resolve, 2000))
-				lroResponse = await this.callEndpoint("onboardUser", onboardRequest)
-			}
-
-			const discoveredProjectId = lroResponse.response?.cloudaicompanionProject?.id || initialProjectId
-			this.projectId = discoveredProjectId
-			return this.projectId as string
-		} catch (error: any) {
-			console.error("Failed to discover project ID:", error.response?.data || error.message)
-			throw new Error("Could not discover project ID. Make sure you're authenticated with 'gemini auth'.")
-		}
-	}
-
-	/**
-	 * Initialize the OAuth client with credentials
-	 */
-	private async initializeAuth(forceRefresh: boolean = false): Promise<void> {
-		// Check if we need to initialize or refresh
-		if (this.authInitialized && !forceRefresh) {
-			// Check if token is still valid
-			const credentials = this.authClient.credentials
-			if (credentials && credentials.expiry_date && Date.now() < credentials.expiry_date) {
-				console.log(`[GeminiCLI] Auth already initialized and token still valid`)
-				return
-			}
-		}
-
-		console.log(`[GeminiCLI] Initializing OAuth authentication...`)
-		const credentials = await this.loadOAuthCredentials()
-		const isExpired = credentials.expiry_date ? Date.now() > credentials.expiry_date : false
-
-		console.log(`[GeminiCLI] Loaded credentials:`, {
-			hasAccessToken: !!credentials.access_token,
-			hasRefreshToken: !!credentials.refresh_token,
-			tokenType: credentials.token_type,
-			expiryDate: credentials.expiry_date,
-			isExpired: isExpired,
-		})
-
-		this.authClient.setCredentials(credentials)
-
-		// If token is expired and we have a refresh token, try to refresh
-		if (isExpired && credentials.refresh_token) {
-			console.log(`[GeminiCLI] Token expired, attempting to refresh...`)
-			try {
-				const { credentials: newCredentials } = await this.authClient.refreshAccessToken()
-				console.log(`[GeminiCLI] Token refreshed successfully`)
-				// Note: In a real implementation, you'd want to save the new credentials back to the file
-				// For now, we'll just use them in memory
-			} catch (error) {
-				console.error(`[GeminiCLI] Failed to refresh token:`, error)
-				// Continue with the expired token - the API might still accept it
-			}
-		}
-
-		this.authInitialized = true
-		console.log(`[GeminiCLI] OAuth client configured`)
-	}
-
-	/**
-	 * Parse Server-Sent Events from a stream
-	 */
-	private async *parseSSEStream(stream: Readable): AsyncGenerator<any> {
-		const rl = readline.createInterface({
-			input: stream,
-			crlfDelay: Infinity,
-		})
-
-		let bufferedLines: string[] = []
-
-		for await (const line of rl) {
-			// Blank lines separate JSON objects in the stream
-			if (line === "") {
-				if (bufferedLines.length === 0) {
-					continue
-				}
-
-				try {
-					const jsonData = JSON.parse(bufferedLines.join("\n"))
-					yield jsonData
-				} catch (parseError) {
-					console.error("Error parsing JSON chunk:", parseError)
-				}
-
-				bufferedLines = []
-			} else if (line.startsWith("data: ")) {
-				bufferedLines.push(line.slice(6).trim())
-			}
-		}
-
-		// Process any remaining buffered content
-		if (bufferedLines.length > 0) {
-			try {
-				const jsonData = JSON.parse(bufferedLines.join("\n"))
-				yield jsonData
-			} catch (parseError) {
-				console.error("Error parsing final buffered content:", parseError)
-			}
-		}
-	}
-
-	/**
-	 * Create a message using the Gemini CLI OAuth API
-	 */
-	@withRetry({
-		maxRetries: 2,
-		baseDelay: 2000,
-		maxDelay: 10000,
-	})
-	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-		// Initialize auth if not already done
-		await this.initializeAuth()
-		// Discover project ID if needed
-		const projectId = await this.discoverProjectId()
-
-		// Convert messages to Gemini format
-		const contents = messages.map(convertAnthropicMessageToGemini)
-
-		// Get the selected model
-		const { id: modelId, info: modelInfo } = this.getModel()
-
-		// Build the request
-		const streamRequest = {
-			model: modelId,
-			project: projectId,
-			request: {
-				contents: [
-					{
-						role: "user",
-						parts: [{ text: systemPrompt }],
-					},
-					...contents,
-				],
-				generationConfig: {
-					temperature: 0.7,
-					maxOutputTokens: modelInfo.maxTokens || 8192,
-				},
-			},
-		}
-
-		let totalContent = ""
-		let promptTokens = 0
-		let outputTokens = 0
-		let lastUsageMetadata: any = null
-
-		try {
-			// Make the streaming request
-			const response = await this.authClient.request({
-				url: `${CODE_ASSIST_ENDPOINT}/${CODE_ASSIST_API_VERSION}:streamGenerateContent`,
-				method: "POST",
-				params: { alt: "sse" },
-				headers: {
-					"Content-Type": "application/json",
-				},
-				responseType: "stream",
-				body: JSON.stringify(streamRequest),
-			})
-
-			// Process the SSE stream
-			for await (const jsonData of this.parseSSEStream(response.data as Readable)) {
-				// Extract content from the response
-				const candidate = jsonData.response?.candidates?.[0]
-				if (candidate?.content?.parts?.[0]?.text) {
-					const content = candidate.content.parts[0].text
-					totalContent += content
-
-					// Yield text chunk
-					yield {
-						type: "text",
-						text: content,
-					}
-				}
-
-				// Store usage metadata for final reporting
-				if (jsonData.response?.usageMetadata) {
-					lastUsageMetadata = jsonData.response.usageMetadata
-					promptTokens = lastUsageMetadata.promptTokenCount || promptTokens
-					outputTokens = lastUsageMetadata.candidatesTokenCount || outputTokens
-				}
-
-				// Check if this is the final chunk
-				if (candidate?.finishReason) {
-					break
-				}
-			}
-
-			// Yield usage information
-			if (lastUsageMetadata) {
-				yield {
-					type: "usage",
-					inputTokens: promptTokens,
-					outputTokens: outputTokens,
-					totalCost: 0, // Free tier
-				}
-			}
-		} catch (error) {
-			// Handle rate limit errors similar to the Gemini provider
-			if (error instanceof Error) {
-				// Check for rate limit patterns in the error message
-				const rateLimitPatterns = [
-					/got status: 429/i,
-					/429 Too Many Requests/i,
-					/rate limit exceeded/i,
-					/too many requests/i,
-					/quota exceeded/i,
-					/resource exhausted/i,
-					/code 429/i,
-				]
-
-				const isRateLimit = rateLimitPatterns.some((pattern) => pattern.test(error.message))
-
-				if (isRateLimit) {
-					const rateLimitError = Object.assign(new Error(error.message), {
-						...error,
-						status: 429,
-					})
-					throw rateLimitError
-				}
-			}
-
-			// Re-throw the original error if it's not a rate limit error
-			throw error
-		}
-	}
-
-	/**
-	 * Get the model ID and info
-	 */
-	getModel(): { id: GeminiCliModelId; info: ModelInfo } {
-		const modelId = this.options.apiModelId as GeminiCliModelId
-		if (modelId && modelId in geminiCliModels) {
-			return { id: modelId, info: geminiCliModels[modelId] }
-		}
-		return {
-			id: geminiCliDefaultModelId,
-			info: geminiCliModels[geminiCliDefaultModelId],
-		}
-	}
-}

src/api/providers/litellm.ts

@@ -101,21 +101,15 @@ export class LiteLlmHandler implements ApiHandler {
 			return message
 		})
 
-		const requestPayload: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming & {
-			metadata?: { cline_task_id: string }
-		} = {
+		const stream = await this.client.chat.completions.create({
 			model: this.options.liteLlmModelId || liteLlmDefaultModelId,
 			messages: [enhancedSystemMessage, ...enhancedMessages],
 			temperature,
 			stream: true,
 			stream_options: { include_usage: true },
 			...(thinkingConfig && { thinking: thinkingConfig }), // Add thinking configuration when applicable
-			...(this.options.taskId && {
-				metadata: { cline_task_id: this.options.taskId },
-			}),
-		}
-
-		const stream = await this.client.chat.completions.create(requestPayload)
+			...(this.options.taskId && { litellm_session_id: `cline-${this.options.taskId}` }), // Add session ID for LiteLLM tracking
+		})
 
 		const inputCost = (await this.calculateCost(1e6, 0)) || 0
 		const outputCost = (await this.calculateCost(0, 1e6)) || 0

src/api/providers/sapaicore.ts

@@ -122,6 +122,8 @@ export class SapAiCoreHandler implements ApiHandler {
 		const deploymentId = await this.getDeploymentForModel(model.id)
 
 		const anthropicModels = [
+			"anthropic--claude-4-sonnet",
+			"anthropic--claude-4-opus",
 			"anthropic--claude-3.7-sonnet",
 			"anthropic--claude-3.5-sonnet",
 			"anthropic--claude-3-sonnet",
@@ -131,12 +133,18 @@ export class SapAiCoreHandler implements ApiHandler {
 
 		const openAIModels = ["gpt-4o", "gpt-4", "gpt-4o-mini", "o1", "gpt-4.1", "gpt-4.1-nano", "o3-mini", "o3", "o4-mini"]
 
+		const geminiModels = ["gemini-2.5-flash", "gemini-2.5-pro"]
+
 		let url: string
 		let payload: any
 		if (anthropicModels.includes(model.id)) {
 			url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/invoke-with-response-stream`
 
-			if (model.id === "anthropic--claude-3.7-sonnet") {
+			if (
+				model.id === "anthropic--claude-4-sonnet" ||
+				model.id === "anthropic--claude-4-opus" ||
+				model.id === "anthropic--claude-3.7-sonnet"
+			) {
 				url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/converse-stream`
 				payload = {
 					inferenceConfig: {
@@ -181,6 +189,9 @@ export class SapAiCoreHandler implements ApiHandler {
 				delete payload.stream
 				delete payload.stream_options
 			}
+		} else if (geminiModels.includes(model.id)) {
+			url = `${this.options.sapAiCoreBaseUrl}/v2/inference/deployments/${deploymentId}/models/${model.id}:streamGenerateContent`
+			payload = this.convertToGeminiFormat(systemPrompt, messages)
 		} else {
 			throw new Error(`Unsupported model: ${model.id}`)
 		}
@@ -221,8 +232,14 @@ export class SapAiCoreHandler implements ApiHandler {
 				}
 			} else if (openAIModels.includes(model.id)) {
 				yield* this.streamCompletionGPT(response.data, model)
-			} else if (model.id === "anthropic--claude-3.7-sonnet") {
+			} else if (
+				model.id === "anthropic--claude-4-sonnet" ||
+				model.id === "anthropic--claude-4-opus" ||
+				model.id === "anthropic--claude-3.7-sonnet"
+			) {
 				yield* this.streamCompletionSonnet37(response.data, model)
+			} else if (geminiModels.includes(model.id)) {
+				yield* this.streamCompletionGemini(response.data, model)
 			} else {
 				yield* this.streamCompletion(response.data, model)
 			}
@@ -451,6 +468,88 @@ export class SapAiCoreHandler implements ApiHandler {
 		}
 	}
 
+	private async *streamCompletionGemini(
+		stream: any,
+		model: { id: SapAiCoreModelId; info: ModelInfo },
+	): AsyncGenerator<any, void, unknown> {
+		let promptTokens = 0
+		let outputTokens = 0
+		let cacheReadTokens = 0
+		let thoughtsTokenCount = 0
+
+		try {
+			for await (const chunk of stream) {
+				const lines = chunk.toString().split("\n").filter(Boolean)
+				for (const line of lines) {
+					if (line.startsWith("data: ")) {
+						const jsonData = line.slice(6)
+						try {
+							const data = JSON.parse(jsonData)
+							const candidateForThoughts = data?.candidates?.[0]
+							const partsForThoughts = candidateForThoughts?.content?.parts
+							let thoughts = ""
+
+							if (partsForThoughts) {
+								for (const part of partsForThoughts) {
+									const { thought, text } = part
+									if (thought && text) {
+										thoughts += text + "\n"
+									}
+								}
+							}
+
+							if (thoughts.trim() !== "") {
+								yield {
+									type: "reasoning",
+									reasoning: thoughts.trim(),
+								}
+							}
+
+							if (data.text) {
+								yield {
+									type: "text",
+									text: data.text,
+								}
+							}
+
+							if (data.candidates && data.candidates[0]?.content?.parts) {
+								for (const part of data.candidates[0].content.parts) {
+									if (part.text && !part.thought) {
+										// Only non-thought text
+										yield {
+											type: "text",
+											text: part.text,
+										}
+									}
+								}
+							}
+
+							if (data.usageMetadata) {
+								promptTokens = data.usageMetadata.promptTokenCount ?? promptTokens
+								outputTokens = data.usageMetadata.candidatesTokenCount ?? outputTokens
+								thoughtsTokenCount = data.usageMetadata.thoughtsTokenCount ?? thoughtsTokenCount
+								cacheReadTokens = data.usageMetadata.cachedContentTokenCount ?? cacheReadTokens
+
+								yield {
+									type: "usage",
+									inputTokens: promptTokens - cacheReadTokens,
+									outputTokens,
+									thoughtsTokenCount,
+									cacheReadTokens,
+								}
+							}
+						} catch (error) {
+							console.error("Failed to parse Gemini JSON data:", error)
+						}
+					}
+				}
+			}
+		} catch (error) {
+			console.error("Error streaming Gemini completion:", error)
+			throw error
+		}
+	}
+
 	createUserReadableRequest(
 		userContent: Array<
 			Anthropic.TextBlockParam | Anthropic.ImageBlockParam | Anthropic.ToolUseBlockParam | Anthropic.ToolResultBlockParam
@@ -485,6 +584,50 @@ export class SapAiCoreHandler implements ApiHandler {
 		throw new Error(`Unsupported image format: ${format}`)
 	}
 
+	private convertToGeminiFormat(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]) {
+		const contents = messages.map(this.convertAnthropicMessageToGemini)
+
+		const payload = {
+			contents,
+			systemInstruction: {
+				parts: [
+					{
+						text: systemPrompt,
+					},
+				],
+			},
+			generationConfig: {
+				maxOutputTokens: this.getModel().info.maxTokens,
+				temperature: 0.0,
+			},
+		}
+
+		return payload
+	}
+
+	private convertAnthropicMessageToGemini(message: Anthropic.Messages.MessageParam) {
+		const role = message.role === "assistant" ? "model" : "user"
+		const parts = []
+
+		if (typeof message.content === "string") {
+			parts.push({ text: message.content })
+		} else if (Array.isArray(message.content)) {
+			for (const block of message.content) {
+				if (block.type === "text") {
+					parts.push({ text: block.text })
+				} else if (block.type === "image") {
+					parts.push({
+						inlineData: {
+							mimeType: block.source.media_type,
+							data: block.source.data,
+						},
+					})
+				}
+			}
+		}
+
+		return { role, parts }
+	}
 	private formatAnthropicMessages(messages: Anthropic.Messages.MessageParam[]): any[] {
 		return messages.map((m) => {
 			const contentBlocks: any[] = []

src/core/assistant-message/diff.test.ts

@@ -156,6 +156,45 @@ replaced
 			expected: "line2\nreplaced\nline4",
 			isFinal: true,
 		},
+		{
+			name: "malformed diff - missing separator",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
++++++++ REPLACE
+replaced`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - trailing space on separator",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
+======= 
+replaced
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - double replace markers",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
++++++++ REPLACE
+first replacement
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
+		{
+			name: "malformed diff - malformed separator with dashes",
+			original: "line1\nline2\nline3",
+			diff: `------- SEARCH
+line2
+------- =======
+replaced
++++++++ REPLACE`,
+			shouldThrow: true,
+		},
 	]
 	//.filter(({name}) => name === "multiple ordered replacements")
 	//.filter(({name}) => name === "delete then replace")

src/core/assistant-message/diff.ts

@@ -380,6 +380,10 @@ async function constructNewFileContentV1(diffContent: string, originalContent: s
 		if (isReplaceBlockEnd(line)) {
 			// Finished one replace block
 
+			if (searchMatchIndex === -1) {
+				throw new Error(`The SEARCH block:\n${currentSearchContent.trimEnd()}\n...is malformatted.`)
+			}
+
 			// Store this replacement
 			replacements.push({
 				start: searchMatchIndex,

src/core/context/context-tracking/FileContextTracker.test.ts

@@ -6,6 +6,9 @@ import * as path from "path"
 import { FileContextTracker } from "./FileContextTracker"
 import * as diskModule from "@core/storage/disk"
 import type { TaskMetadata, FileMetadataEntry } from "./ContextTrackerTypes"
+import type { WebviewProviderCreator } from "@/hosts/host-providers"
+import * as hostProviders from "@hosts/host-providers"
+import { vscodeHostBridgeClient } from "@/hosts/vscode/client/host-grpc-client"
 
 describe("FileContextTracker", () => {
 	let sandbox: sinon.SinonSandbox
@@ -37,7 +40,6 @@ describe("FileContextTracker", () => {
 		}
 
 		// Use a function replacement instead of a direct stub
-		const originalCreateFileSystemWatcher = vscode.workspace.createFileSystemWatcher
 		vscode.workspace.createFileSystemWatcher = function () {
 			return mockFileSystemWatcher
 		}
@@ -51,6 +53,7 @@ describe("FileContextTracker", () => {
 		mockTaskMetadata = { files_in_context: [], model_usage: [] }
 		getTaskMetadataStub = sandbox.stub(diskModule, "getTaskMetadata").resolves(mockTaskMetadata)
 		saveTaskMetadataStub = sandbox.stub(diskModule, "saveTaskMetadata").resolves()
+		hostProviders.initializeHostProviders(((_) => {}) as WebviewProviderCreator, vscodeHostBridgeClient)
 
 		// Create tracker instance
 		taskId = "test-task-id"

src/core/context/context-tracking/FileContextTracker.ts

@@ -5,6 +5,8 @@ import { getWorkspaceState, updateWorkspaceState } from "@core/storage/state"
 import { getGlobalState } from "@core/storage/state"
 import type { FileMetadataEntry } from "./ContextTrackerTypes"
 import type { ClineMessage } from "@shared/ExtensionMessage"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { getCwd } from "@/utils/path"
 
 // This class is responsible for tracking file operations that may result in stale context.
 // If a user modifies a file outside of Cline, the context may become stale and need to be updated.
@@ -34,17 +36,6 @@ export class FileContextTracker {
 		this.taskId = taskId
 	}
 
-	/**
-	 * Gets the current working directory or returns undefined if it cannot be determined
-	 */
-	private getCwd(): string | undefined {
-		const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
-		if (!cwd) {
-			console.info("No workspace folder available - cannot determine current working directory")
-		}
-		return cwd
-	}
-
 	/**
 	 * File watchers are set up for each file that is tracked in the task metadata.
 	 */
@@ -54,8 +45,9 @@ export class FileContextTracker {
 			return
 		}
 
-		const cwd = this.getCwd()
+		const cwd = await getCwd()
 		if (!cwd) {
+			console.info("No workspace folder available - cannot determine current working directory")
 			return
 		}
 
@@ -85,8 +77,9 @@ export class FileContextTracker {
 	 */
 	async trackFileContext(filePath: string, operation: "read_tool" | "user_edited" | "cline_edited" | "file_mentioned") {
 		try {
-			const cwd = this.getCwd()
+			const cwd = await getCwd()
 			if (!cwd) {
+				console.info("No workspace folder available - cannot determine current working directory")
 				return
 			}
 
@@ -242,7 +235,9 @@ export class FileContextTracker {
 	async storePendingFileContextWarning(files: string[]): Promise<void> {
 		try {
 			const key = `pendingFileContextWarning_${this.taskId}`
-			await updateWorkspaceState(this.context, key, files)
+			// NOTE: Using 'as any' because dynamic keys like pendingFileContextWarning_${taskId}
+			// are legitimate workspace state keys but don't fit the strict LocalStateKey type system
+			await updateWorkspaceState(this.context, key as any, files)
 		} catch (error) {
 			console.error("Error storing pending file context warning:", error)
 		}
@@ -254,7 +249,7 @@ export class FileContextTracker {
 	async retrievePendingFileContextWarning(): Promise<string[] | undefined> {
 		try {
 			const key = `pendingFileContextWarning_${this.taskId}`
-			const files = (await getWorkspaceState(this.context, key)) as string[]
+			const files = (await getWorkspaceState(this.context, key as any)) as string[]
 			return files
 		} catch (error) {
 			console.error("Error retrieving pending file context warning:", error)
@@ -269,7 +264,7 @@ export class FileContextTracker {
 		try {
 			const files = await this.retrievePendingFileContextWarning()
 			if (files) {
-				await updateWorkspaceState(this.context, `pendingFileContextWarning_${this.taskId}`, undefined)
+				await updateWorkspaceState(this.context, `pendingFileContextWarning_${this.taskId}` as any, undefined)
 				return files
 			}
 		} catch (error) {
@@ -300,7 +295,7 @@ export class FileContextTracker {
 
 			if (orphanedPendingContextTasks.length > 0) {
 				for (const key of orphanedPendingContextTasks) {
-					await updateWorkspaceState(context, key, undefined)
+					await updateWorkspaceState(context, key as any, undefined)
 				}
 			}
 

src/core/controller/file/copyToClipboard.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode"
 import { Controller } from ".."
 import { Empty, StringRequest } from "../../../shared/proto/common"
+import { writeTextToClipboard } from "@/utils/env"
 
 /**
  * Copies text to the system clipboard
@@ -11,7 +12,7 @@ import { Empty, StringRequest } from "../../../shared/proto/common"
 export async function copyToClipboard(controller: Controller, request: StringRequest): Promise<Empty> {
 	try {
 		if (request.value) {
-			await vscode.env.clipboard.writeText(request.value)
+			await writeTextToClipboard(request.value)
 		}
 	} catch (error) {
 		console.error("Error copying to clipboard:", error)

src/core/controller/file/createRuleFile.ts

@@ -6,8 +6,8 @@ import { createRuleFile as createRuleFileImpl } from "@core/context/instructions
 import * as vscode from "vscode"
 import * as path from "path"
 import { handleFileServiceRequest } from "./index"
-import { cwd } from "@core/task"
 import { refreshWorkflowToggles } from "@/core/context/instructions/user-instructions/workflows"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 /**
  * Creates a rule file in either global or workspace rules directory
@@ -32,6 +32,7 @@ export const createRuleFile: FileMethodHandler = async (controller: Controller,
 		throw new Error("Missing or invalid parameters")
 	}
 
+	const cwd = await getCwd(getDesktopDir())
 	const { filePath, fileExists } = await createRuleFileImpl(request.isGlobal, request.filename, cwd, request.type)
 
 	if (!filePath) {

src/core/controller/file/deleteRuleFile.ts

@@ -1,13 +1,9 @@
-import { Controller } from ".."
-import { RuleFileRequest, RuleFile } from "@shared/proto/file"
-import { FileMethodHandler } from "./index"
-import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
 import { deleteRuleFile as deleteRuleFileImpl } from "@core/context/instructions/user-instructions/rule-helpers"
-import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
-import { refreshWorkflowToggles } from "@core/context/instructions/user-instructions/workflows"
-import * as vscode from "vscode"
+import { RuleFile, RuleFileRequest } from "@shared/proto/file"
 import * as path from "path"
-import { cwd } from "@core/task"
+import * as vscode from "vscode"
+import { Controller } from ".."
+import { FileMethodHandler } from "./index"
 
 /**
  * Deletes a rule file from either global or workspace rules directory

src/core/controller/file/getRelativePaths.ts

@@ -3,7 +3,7 @@ import { RelativePathsRequest, RelativePaths } from "@shared/proto/file"
 import { FileMethodHandler } from "./index"
 import * as vscode from "vscode"
 import * as path from "path"
-import { Metadata, StringRequest } from "@shared/proto/common"
+import { StringRequest } from "@shared/proto/common"
 import { getHostBridgeProvider } from "@hosts/host-providers"
 
 /**
@@ -22,7 +22,6 @@ export const getRelativePaths: FileMethodHandler = async (
 				// Use the host URI service client instead of directly using vscode.Uri.parse
 				const parseResponse = await getHostBridgeProvider().uriServiceClient.parse(
 					StringRequest.create({
-						metadata: Metadata.create({}),
 						value: uriString,
 					}),
 				)

src/core/controller/file/openMention.ts

@@ -8,7 +8,7 @@ import { openMention as coreOpenMention } from "../../mentions"
  * @param request The string request containing the mention text
  * @returns Empty response
  */
-export async function openMention(controller: Controller, request: StringRequest): Promise<Empty> {
+export async function openMention(_controller: Controller, request: StringRequest): Promise<Empty> {
 	coreOpenMention(request.value)
 	return Empty.create()
 }

src/core/controller/file/refreshRules.ts

@@ -4,7 +4,7 @@ import type { Controller } from "../index"
 import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
 import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
 import { refreshWorkflowToggles } from "@core/context/instructions/user-instructions/workflows"
-import { cwd } from "@core/task"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 /**
  * Refreshes all rule toggles (Cline, External, and Workflows)
@@ -14,6 +14,7 @@ import { cwd } from "@core/task"
  */
 export async function refreshRules(controller: Controller, _request: EmptyRequest): Promise<RefreshedRules> {
 	try {
+		const cwd = await getCwd(getDesktopDir())
 		const { globalToggles, localToggles } = await refreshClineRulesToggles(controller.context, cwd)
 		const { cursorLocalToggles, windsurfLocalToggles } = await refreshExternalRulesToggles(controller.context, cwd)
 		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(controller.context, cwd)

src/core/controller/file/searchCommits.ts

@@ -13,7 +13,7 @@ import { convertGitCommitsToProtoGitCommits } from "@shared/proto-conversions/fi
  * @returns GitCommits containing the matching commits
  */
 export const searchCommits: FileMethodHandler = async (controller: Controller, request: StringRequest): Promise<GitCommits> => {
-	const cwd = getWorkspacePath()
+	const cwd = await getWorkspacePath()
 	if (!cwd) {
 		return GitCommits.create({ commits: [] })
 	}

src/core/controller/file/searchFiles.ts

@@ -12,10 +12,10 @@ import { convertSearchResultsToProtoFileInfos } from "@shared/proto-conversions/
  * @returns Results containing matching files/folders
  */
 export const searchFiles: FileMethodHandler = async (
-	controller: Controller,
+	_controller: Controller,
 	request: FileSearchRequest,
 ): Promise<FileSearchResults> => {
-	const workspacePath = getWorkspacePath()
+	const workspacePath = await getWorkspacePath()
 
 	if (!workspacePath) {
 		// Handle case where workspace path is not available

src/core/controller/grpc-service.ts

@@ -37,6 +37,7 @@ export class ServiceRegistry {
 	 * @param serviceName The name of the service (used for logging)
 	 */
 	constructor(serviceName: string) {
+		console.log(`Registering Protobus service: ${serviceName}...`)
 		this.serviceName = serviceName
 	}
 
@@ -56,7 +57,6 @@ export class ServiceRegistry {
 		}
 
 		this.methodMetadata[methodName] = { isStreaming, ...metadata }
-		console.log(`Registered ${this.serviceName} method: ${methodName}${isStreaming ? " (streaming)" : ""}`)
 	}
 
 	/**

src/core/controller/index.ts

@@ -1,31 +1,31 @@
+import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
+import { getCwd, getDesktopDir } from "@/utils/path"
 import { Anthropic } from "@anthropic-ai/sdk"
+import { buildApiHandler } from "@api/index"
+import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
+import { extractCommitMessage } from "@integrations/git/commit-message-generator"
+import { downloadTask } from "@integrations/misc/export-markdown"
+import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
+import { ClineAccountService } from "@services/account/ClineAccountService"
+import { McpHub } from "@services/mcp/McpHub"
+import { ApiProvider, ModelInfo } from "@shared/api"
+import { ChatContent } from "@shared/ChatContent"
+import { ChatSettings, StoredChatSettings } from "@shared/ChatSettings"
+import { ClineRulesToggles } from "@shared/cline-rules"
+import { ExtensionMessage, ExtensionState, Platform } from "@shared/ExtensionMessage"
+import { HistoryItem } from "@shared/HistoryItem"
+import { McpMarketplaceCatalog } from "@shared/mcp"
+import { TelemetrySetting } from "@shared/TelemetrySetting"
+import { UserInfo } from "@shared/UserInfo"
+import { WebviewMessage } from "@shared/WebviewMessage"
+import { fileExistsAtPath } from "@utils/fs"
+import { getWorkingState } from "@utils/git"
 import axios from "axios"
-import { v4 as uuidv4 } from "uuid"
 import fs from "fs/promises"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
 import pWaitFor from "p-wait-for"
 import * as path from "path"
 import * as vscode from "vscode"
-import { handleGrpcRequest, handleGrpcRequestCancel } from "./grpc-handler"
-import { buildApiHandler } from "@api/index"
-import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
-import { downloadTask } from "@integrations/misc/export-markdown"
-import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
-import { ClineAccountService } from "@services/account/ClineAccountService"
-import { McpHub } from "@services/mcp/McpHub"
-import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
-import { ApiProvider, ModelInfo } from "@shared/api"
-import { ChatContent } from "@shared/ChatContent"
-import { ChatSettings, StoredChatSettings } from "@shared/ChatSettings"
-import { ExtensionMessage, ExtensionState, Platform } from "@shared/ExtensionMessage"
-import { HistoryItem } from "@shared/HistoryItem"
-import { McpMarketplaceCatalog } from "@shared/mcp"
-import { UserInfo } from "@shared/UserInfo"
-import { TelemetrySetting } from "@shared/TelemetrySetting"
-import { WebviewMessage } from "@shared/WebviewMessage"
-import { fileExistsAtPath } from "@utils/fs"
-import { getWorkingState } from "@utils/git"
-import { extractCommitMessage } from "@integrations/git/commit-message-generator"
 import { ensureMcpServersDirectoryExists, ensureSettingsDirectoryExists, GlobalFileNames } from "../storage/disk"
 import {
 	getAllExtensionState,
@@ -33,19 +33,15 @@ import {
 	getSecret,
 	getWorkspaceState,
 	storeSecret,
-	updateApiConfiguration,
 	updateGlobalState,
 	updateWorkspaceState,
 } from "../storage/state"
 import { Task } from "../task"
-import { ClineRulesToggles } from "@shared/cline-rules"
+import { sendAuthCallbackEvent } from "./account/subscribeToAuthCallback"
+import { handleGrpcRequest, handleGrpcRequestCancel } from "./grpc-handler"
+import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
 import { sendStateUpdate } from "./state/subscribeToState"
 import { sendAddToInputEvent } from "./ui/subscribeToAddToInput"
-import { sendAuthCallbackEvent } from "./account/subscribeToAuthCallback"
-import { sendMcpMarketplaceCatalogEvent } from "./mcp/subscribeToMcpMarketplaceCatalog"
-import { sendRelinquishControlEvent } from "./ui/subscribeToRelinquishControl"
-import { handleTaskServiceRequest } from "./task"
-import { BooleanRequest } from "@shared/proto/common"
 
 /*
 https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/default/weather-webview/src/providers/WeatherViewProvider.ts
@@ -82,13 +78,10 @@ export class Controller {
 			(msg) => this.postMessageToWebview(msg),
 			this.context.extension?.packageJSON?.version ?? "1.0.0",
 		)
-		this.accountService = new ClineAccountService(
-			(msg) => this.postMessageToWebview(msg),
-			async () => {
-				const { apiConfiguration } = await this.getStateToPostToWebview()
-				return apiConfiguration?.clineApiKey
-			},
-		)
+		this.accountService = new ClineAccountService(async () => {
+			const { apiConfiguration } = await this.getStateToPostToWebview()
+			return apiConfiguration?.clineApiKey
+		})
 
 		// Clean up legacy checkpoints
 		cleanupLegacyCheckpoints(this.context.globalStorageUri.fsPath, this.outputChannel).catch((error) => {
@@ -120,7 +113,7 @@ export class Controller {
 		try {
 			await storeSecret(this.context, "clineApiKey", undefined)
 			await updateGlobalState(this.context, "userInfo", undefined)
-			await updateWorkspaceState(this.context, "apiProvider", "openrouter")
+			await updateGlobalState(this.context, "apiProvider", "openrouter")
 			await this.postStateToWebview()
 			vscode.window.showInformationMessage("Successfully logged out of Cline")
 		} catch (error) {
@@ -175,7 +168,6 @@ export class Controller {
 			this.workspaceTracker,
 			(historyItem) => this.updateTaskHistory(historyItem),
 			() => this.postStateToWebview(),
-			(message) => this.postMessageToWebview(message),
 			(taskId) => this.reinitExistingTaskFromId(taskId),
 			() => this.cancelTask(),
 			apiConfiguration,
@@ -187,6 +179,7 @@ export class Controller {
 			terminalOutputLineLimit ?? 500,
 			defaultTerminalProfile ?? "default",
 			enableCheckpointsSetting ?? true,
+			await getCwd(getDesktopDir()),
 			task,
 			images,
 			files,
@@ -240,6 +233,7 @@ export class Controller {
 		await updateGlobalState(this.context, "telemetrySetting", telemetrySetting)
 		const isOptedIn = telemetrySetting !== "disabled"
 		telemetryService.updateTelemetryState(isOptedIn)
+		await this.postStateToWebview()
 	}
 
 	async togglePlanActModeWithChatSettings(chatSettings: ChatSettings, chatContent?: ChatContent): Promise<boolean> {
@@ -262,11 +256,6 @@ export class Controller {
 			previousModeReasoningEffort: newReasoningEffort,
 			previousModeAwsBedrockCustomSelected: newAwsBedrockCustomSelected,
 			previousModeAwsBedrockCustomModelBaseId: newAwsBedrockCustomModelBaseId,
-			previousModeSapAiCoreClientId: newSapAiCoreClientId,
-			previousModeSapAiCoreClientSecret: newSapAiCoreClientSecret,
-			previousModeSapAiCoreBaseUrl: newSapAiCoreBaseUrl,
-			previousModeSapAiCoreTokenUrl: newSapAiCoreTokenUrl,
-			previousModeSapAiCoreResourceGroup: newSapAiResourceGroup,
 			previousModeSapAiCoreModelId: newSapAiCoreModelId,
 			planActSeparateModelsSetting,
 		} = await getAllExtensionState(this.context)
@@ -275,9 +264,9 @@ export class Controller {
 
 		if (shouldSwitchModel) {
 			// Save the last model used in this mode
-			await updateWorkspaceState(this.context, "previousModeApiProvider", apiConfiguration.apiProvider)
-			await updateWorkspaceState(this.context, "previousModeThinkingBudgetTokens", apiConfiguration.thinkingBudgetTokens)
-			await updateWorkspaceState(this.context, "previousModeReasoningEffort", apiConfiguration.reasoningEffort)
+			await updateGlobalState(this.context, "previousModeApiProvider", apiConfiguration.apiProvider)
+			await updateGlobalState(this.context, "previousModeThinkingBudgetTokens", apiConfiguration.thinkingBudgetTokens)
+			await updateGlobalState(this.context, "previousModeReasoningEffort", apiConfiguration.reasoningEffort)
 			switch (apiConfiguration.apiProvider) {
 				case "anthropic":
 				case "vertex":
@@ -287,16 +276,16 @@ export class Controller {
 				case "qwen":
 				case "deepseek":
 				case "xai":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
 					break
 				case "bedrock":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateWorkspaceState(
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(
 						this.context,
 						"previousModeAwsBedrockCustomSelected",
 						apiConfiguration.awsBedrockCustomSelected,
 					)
-					await updateWorkspaceState(
+					await updateGlobalState(
 						this.context,
 						"previousModeAwsBedrockCustomModelBaseId",
 						apiConfiguration.awsBedrockCustomModelBaseId,
@@ -304,51 +293,38 @@ export class Controller {
 					break
 				case "openrouter":
 				case "cline":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.openRouterModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openRouterModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.openRouterModelInfo)
 					break
 				case "vscode-lm":
 					// Important we don't set modelId to this, as it's an object not string (webview expects model id to be a string)
-					await updateWorkspaceState(
+					await updateGlobalState(
 						this.context,
 						"previousModeVsCodeLmModelSelector",
 						apiConfiguration.vsCodeLmModelSelector,
 					)
 					break
 				case "openai":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.openAiModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.openAiModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.openAiModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.openAiModelInfo)
 					break
 				case "ollama":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.ollamaModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.ollamaModelId)
 					break
 				case "lmstudio":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.lmStudioModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.lmStudioModelId)
 					break
 				case "litellm":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.liteLlmModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.liteLlmModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.liteLlmModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.liteLlmModelInfo)
 					break
 				case "requesty":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.requestyModelId)
-					await updateWorkspaceState(this.context, "previousModeModelInfo", apiConfiguration.requestyModelInfo)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.requestyModelId)
+					await updateGlobalState(this.context, "previousModeModelInfo", apiConfiguration.requestyModelInfo)
 					break
 				case "sapaicore":
-					await updateWorkspaceState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreClientId", apiConfiguration.sapAiCoreClientId)
-					await updateWorkspaceState(
-						this.context,
-						"previousModeSapAiCoreClientSecret",
-						apiConfiguration.sapAiCoreClientSecret,
-					)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreBaseUrl", apiConfiguration.sapAiCoreBaseUrl)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreTokenUrl", apiConfiguration.sapAiCoreTokenUrl)
-					await updateWorkspaceState(
-						this.context,
-						"previousModeSapAiCoreResourceGroup",
-						apiConfiguration.sapAiResourceGroup,
-					)
-					await updateWorkspaceState(this.context, "previousModeSapAiCoreModelId", apiConfiguration.sapAiCoreModelId)
+					await updateGlobalState(this.context, "previousModeModelId", apiConfiguration.apiModelId)
+					await updateGlobalState(this.context, "previousModeSapAiCoreModelId", apiConfiguration.sapAiCoreModelId)
 					break
 			}
 
@@ -360,9 +336,9 @@ export class Controller {
 				newReasoningEffort ||
 				newVsCodeLmModelSelector
 			) {
-				await updateWorkspaceState(this.context, "apiProvider", newApiProvider)
-				await updateWorkspaceState(this.context, "thinkingBudgetTokens", newThinkingBudgetTokens)
-				await updateWorkspaceState(this.context, "reasoningEffort", newReasoningEffort)
+				await updateGlobalState(this.context, "apiProvider", newApiProvider)
+				await updateGlobalState(this.context, "thinkingBudgetTokens", newThinkingBudgetTokens)
+				await updateGlobalState(this.context, "reasoningEffort", newReasoningEffort)
 				switch (newApiProvider) {
 					case "anthropic":
 					case "vertex":
@@ -372,41 +348,42 @@ export class Controller {
 					case "qwen":
 					case "deepseek":
 					case "xai":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
 						break
 					case "bedrock":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
-						await updateWorkspaceState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
-						await updateWorkspaceState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "awsBedrockCustomSelected", newAwsBedrockCustomSelected)
+						await updateGlobalState(this.context, "awsBedrockCustomModelBaseId", newAwsBedrockCustomModelBaseId)
 						break
 					case "openrouter":
 					case "cline":
-						await updateWorkspaceState(this.context, "openRouterModelId", newModelId)
-						await updateWorkspaceState(this.context, "openRouterModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "openRouterModelId", newModelId)
+						await updateGlobalState(this.context, "openRouterModelInfo", newModelInfo)
 						break
 					case "vscode-lm":
-						await updateWorkspaceState(this.context, "vsCodeLmModelSelector", newVsCodeLmModelSelector)
+						await updateGlobalState(this.context, "vsCodeLmModelSelector", newVsCodeLmModelSelector)
 						break
 					case "openai":
-						await updateWorkspaceState(this.context, "openAiModelId", newModelId)
-						await updateWorkspaceState(this.context, "openAiModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "openAiModelId", newModelId)
+						await updateGlobalState(this.context, "openAiModelInfo", newModelInfo)
 						break
 					case "ollama":
-						await updateWorkspaceState(this.context, "ollamaModelId", newModelId)
+						await updateGlobalState(this.context, "ollamaModelId", newModelId)
 						break
 					case "lmstudio":
-						await updateWorkspaceState(this.context, "lmStudioModelId", newModelId)
+						await updateGlobalState(this.context, "lmStudioModelId", newModelId)
 						break
 					case "litellm":
-						await updateWorkspaceState(this.context, "liteLlmModelId", newModelId)
-						await updateWorkspaceState(this.context, "liteLlmModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "liteLlmModelId", newModelId)
+						await updateGlobalState(this.context, "liteLlmModelInfo", newModelInfo)
 						break
 					case "requesty":
-						await updateWorkspaceState(this.context, "requestyModelId", newModelId)
-						await updateWorkspaceState(this.context, "requestyModelInfo", newModelInfo)
+						await updateGlobalState(this.context, "requestyModelId", newModelId)
+						await updateGlobalState(this.context, "requestyModelInfo", newModelInfo)
 						break
 					case "sapaicore":
-						await updateWorkspaceState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "apiModelId", newModelId)
+						await updateGlobalState(this.context, "sapAiCoreModelId", newSapAiCoreModelId)
 						break
 				}
 
@@ -419,7 +396,7 @@ export class Controller {
 
 		// Save only non-mode properties to workspace storage
 		const { mode, ...persistentChatSettings }: { mode: string } & StoredChatSettings = chatSettings
-		await updateWorkspaceState(this.context, "chatSettings", persistentChatSettings)
+		await updateGlobalState(this.context, "chatSettings", persistentChatSettings)
 		await this.postStateToWebview()
 
 		if (this.task) {
@@ -493,7 +470,7 @@ export class Controller {
 			await sendAuthCallbackEvent(customToken)
 
 			const clineProvider: ApiProvider = "cline"
-			await updateWorkspaceState(this.context, "apiProvider", clineProvider)
+			await updateGlobalState(this.context, "apiProvider", clineProvider)
 
 			// Update API configuration with the new provider and API key
 			const { apiConfiguration } = await getAllExtensionState(this.context)
@@ -652,7 +629,7 @@ export class Controller {
 		}
 
 		const openrouter: ApiProvider = "openrouter"
-		await updateWorkspaceState(this.context, "apiProvider", openrouter)
+		await updateGlobalState(this.context, "apiProvider", openrouter)
 		await storeSecret(this.context, "openRouterApiKey", apiKey)
 		await this.postStateToWebview()
 		if (this.task) {
@@ -683,8 +660,8 @@ export class Controller {
 
 	// Context menus and code actions
 
-	getFileMentionFromPath(filePath: string) {
-		const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
+	async getFileMentionFromPath(filePath: string) {
+		const cwd = await getCwd()
 		if (!cwd) {
 			return "@/" + filePath
 		}
@@ -699,7 +676,7 @@ export class Controller {
 		await setTimeoutPromise(100)
 
 		// Post message to webview with the selected code
-		const fileMention = this.getFileMentionFromPath(filePath)
+		const fileMention = await this.getFileMentionFromPath(filePath)
 
 		let input = `${fileMention}\n\`\`\`\n${code}\n\`\`\``
 		if (diagnostics) {
@@ -736,7 +713,7 @@ export class Controller {
 		await vscode.commands.executeCommand("claude-dev.SidebarProvider.focus")
 		await setTimeoutPromise(100)
 
-		const fileMention = this.getFileMentionFromPath(filePath)
+		const fileMention = await this.getFileMentionFromPath(filePath)
 		const problemsString = this.convertDiagnosticsToProblemsString(diagnostics)
 		await this.initTask(`Fix the following code in ${fileMention}\n\`\`\`\n${code}\n\`\`\`\n\nProblems:\n${problemsString}`)
 
@@ -852,6 +829,7 @@ export class Controller {
 			terminalReuseEnabled,
 			defaultTerminalProfile,
 			isNewUser,
+			welcomeViewCompleted,
 			mcpResponsesCollapsed,
 			terminalOutputLineLimit,
 		} = await getAllExtensionState(this.context)
@@ -906,6 +884,7 @@ export class Controller {
 			terminalReuseEnabled,
 			defaultTerminalProfile,
 			isNewUser,
+			welcomeViewCompleted: welcomeViewCompleted as boolean, // Can be undefined but is set to either true or false by the migration that runs on extension launch in extension.ts
 			mcpResponsesCollapsed,
 			terminalOutputLineLimit,
 		}
@@ -915,7 +894,7 @@ export class Controller {
 		if (this.task) {
 			await telemetryService.sendCollectedEvents(this.task.taskId)
 		}
-		this.task?.abortTask()
+		await this.task?.abortTask()
 		this.task = undefined // removes reference to it, so once promises end it will be garbage collected
 	}
 
@@ -988,7 +967,7 @@ export class Controller {
 	async generateGitCommitMessage() {
 		try {
 			// Check if there's a workspace folder open
-			const cwd = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+			const cwd = await getCwd()
 			if (!cwd) {
 				vscode.window.showErrorMessage("No workspace folder open")
 				return

src/core/controller/mcp/downloadMcp.ts

@@ -1,6 +1,7 @@
 import { Controller } from ".."
-import { Empty, StringRequest } from "../../../shared/proto/common"
-import { McpServer, McpDownloadResponse } from "@shared/mcp"
+import { StringRequest } from "../../../shared/proto/common"
+import { McpDownloadResponse } from "../../../shared/proto/mcp"
+import { McpServer } from "@shared/mcp"
 import axios from "axios"
 import * as vscode from "vscode"
 import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
@@ -9,9 +10,9 @@ import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
  * Download an MCP server from the marketplace
  * @param controller The controller instance
  * @param request The request containing the MCP ID
- * @returns Empty response
+ * @returns MCP download response with details or error
  */
-export async function downloadMcp(controller: Controller, request: StringRequest): Promise<Empty> {
+export async function downloadMcp(controller: Controller, request: StringRequest): Promise<McpDownloadResponse> {
 	try {
 		// Check if mcpId is provided
 		if (!request.value) {
@@ -54,12 +55,6 @@ export async function downloadMcp(controller: Controller, request: StringRequest
 			throw new Error("Missing README content in MCP download response")
 		}
 
-		// Send details to webview
-		await controller.postMessageToWebview({
-			type: "mcpDownloadDetails",
-			mcpDownloadDetails: mcpDetails,
-		})
-
 		// Create task with context from README and added guidelines for MCP server installation
 		const task = `Set up the MCP server from ${mcpDetails.githubUrl} while adhering to these MCP server installation rules:
 - Start by loading the MCP documentation.
@@ -80,8 +75,17 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 		await controller.initTask(task)
 		await sendChatButtonClickedEvent(controller.id)
 
-		// Return an empty response - the client only cares if the call succeeded
-		return Empty.create()
+		// Return the download details directly
+		return McpDownloadResponse.create({
+			mcpId: mcpDetails.mcpId,
+			githubUrl: mcpDetails.githubUrl,
+			name: mcpDetails.name,
+			author: mcpDetails.author,
+			description: mcpDetails.description,
+			readmeContent: mcpDetails.readmeContent,
+			llmsInstallationContent: mcpDetails.llmsInstallationContent,
+			requiresApiKey: mcpDetails.requiresApiKey,
+		})
 	} catch (error) {
 		console.error("Failed to download MCP:", error)
 		let errorMessage = "Failed to download MCP"
@@ -100,13 +104,17 @@ Here is the project's README to help you get started:\n\n${mcpDetails.readmeCont
 			errorMessage = error.message
 		}
 
-		// Show error in both notification and marketplace UI
-		vscode.window.showErrorMessage(errorMessage)
-		await controller.postMessageToWebview({
-			type: "mcpDownloadDetails",
+		// Return error in the response instead of throwing
+		return McpDownloadResponse.create({
+			mcpId: "",
+			githubUrl: "",
+			name: "",
+			author: "",
+			description: "",
+			readmeContent: "",
+			llmsInstallationContent: "",
+			requiresApiKey: false,
 			error: errorMessage,
 		})
-
-		throw error
 	}
 }

src/core/controller/state/setWelcomeViewCompleted.ts

@@ -0,0 +1,25 @@
+import type { BooleanRequest } from "../../../shared/proto/common"
+import { Empty } from "../../../shared/proto/common"
+import type { Controller } from "../index"
+import { updateGlobalState } from "../../storage/state"
+
+/**
+ * Sets the welcomeViewCompleted flag to the specified boolean value
+ * @param controller The controller instance
+ * @param request The boolean request containing the value to set
+ * @returns Empty response
+ */
+export async function setWelcomeViewCompleted(controller: Controller, request: BooleanRequest): Promise<Empty> {
+	try {
+		// Update the global state to set welcomeViewCompleted to the requested value
+		await updateGlobalState(controller.context, "welcomeViewCompleted", request.value)
+
+		await controller.postStateToWebview()
+
+		console.log(`Welcome view completed set to: ${request.value}`)
+		return Empty.create({})
+	} catch (error) {
+		console.error("Failed to set welcome view completed:", error)
+		throw error
+	}
+}

src/core/controller/task/deleteAllTaskHistory.ts

@@ -2,7 +2,6 @@ import path from "path"
 import fs from "fs/promises"
 import { Controller } from ".."
 import { DeleteAllTaskHistoryCount } from "../../../shared/proto/task"
-import { BooleanRequest } from "../../../shared/proto/common"
 import { getGlobalState, updateGlobalState } from "../../storage/state"
 import { fileExistsAtPath } from "../../../utils/fs"
 import vscode from "vscode"
@@ -13,7 +12,7 @@ import vscode from "vscode"
  * @param request Request with option to preserve favorites
  * @returns Results with count of deleted tasks
  */
-export async function deleteAllTaskHistory(controller: Controller, request: BooleanRequest): Promise<DeleteAllTaskHistoryCount> {
+export async function deleteAllTaskHistory(controller: Controller): Promise<DeleteAllTaskHistoryCount> {
 	try {
 		// Clear current task first
 		await controller.clearTask()
@@ -22,8 +21,22 @@ export async function deleteAllTaskHistory(controller: Controller, request: Bool
 		const taskHistory = ((await getGlobalState(controller.context, "taskHistory")) as any[]) || []
 		const totalTasks = taskHistory.length
 
+		const userChoice = await vscode.window.showWarningMessage(
+			"What would you like to delete?",
+			{ modal: true },
+			"Delete All Except Favorites",
+			"Delete Everything",
+		)
+
+		// Default VS Code Cancel button returns `undefined` - don't delete anything
+		if (userChoice === undefined) {
+			return DeleteAllTaskHistoryCount.create({
+				tasksDeleted: 0,
+			})
+		}
+
 		// If preserving favorites, filter out non-favorites
-		if (request.value) {
+		if (userChoice === "Delete All Except Favorites") {
 			const favoritedTasks = taskHistory.filter((task) => task.isFavorited === true)
 
 			// If there are favorited tasks, update state
@@ -45,9 +58,20 @@ export async function deleteAllTaskHistory(controller: Controller, request: Bool
 					tasksDeleted: totalTasks - favoritedTasks.length,
 				})
 			} else {
-				return DeleteAllTaskHistoryCount.create({
-					tasksDeleted: 0,
-				})
+				// No favorited tasks found - show warning and ask user what to do
+				const answer = await vscode.window.showWarningMessage(
+					"No favorited tasks found. Would you like to delete all tasks anyway?",
+					{ modal: true },
+					"Delete All Tasks",
+				)
+
+				// User cancelled - don't delete anything
+				if (answer === undefined) {
+					return DeleteAllTaskHistoryCount.create({
+						tasksDeleted: 0,
+					})
+				}
+				// If user chose "Delete All Tasks", fall through to the `delete everything` section below
 			}
 		}
 

src/core/controller/task/deleteNonFavoritedTasks.ts

@@ -1,88 +0,0 @@
-import path from "path"
-import fs from "fs/promises"
-import { Controller } from ".."
-import { EmptyRequest } from "../../../shared/proto/common"
-import { DeleteNonFavoritedTasksResults } from "../../../shared/proto/task"
-import { getGlobalState, updateGlobalState } from "../../storage/state"
-import { fileExistsAtPath } from "../../../utils/fs"
-
-/**
- * Deletes all non-favorited tasks, preserving only favorited ones
- * @param controller The controller instance
- * @param request Empty request
- * @returns DeleteNonFavoritedTasksResults with counts of preserved and deleted tasks
- */
-export async function deleteNonFavoritedTasks(
-	controller: Controller,
-	_request: EmptyRequest,
-): Promise<DeleteNonFavoritedTasksResults> {
-	try {
-		// Clear current task first
-		await controller.clearTask()
-
-		// Get existing task history
-		const taskHistory = ((await getGlobalState(controller.context, "taskHistory")) as any[]) || []
-
-		// Filter out non-favorited tasks
-		const favoritedTasks = taskHistory.filter((task) => task.isFavorited === true)
-		const deletedCount = taskHistory.length - favoritedTasks.length
-
-		console.log(`[deleteNonFavoritedTasks] Found ${favoritedTasks.length} favorited tasks to preserve`)
-
-		// Update global state
-		if (favoritedTasks.length > 0) {
-			await updateGlobalState(controller.context, "taskHistory", favoritedTasks)
-		} else {
-			await updateGlobalState(controller.context, "taskHistory", undefined)
-		}
-
-		// Handle file system cleanup for deleted tasks
-		const preserveTaskIds = favoritedTasks.map((task) => task.id)
-		await cleanupTaskFiles(controller, preserveTaskIds)
-
-		// Update webview
-		try {
-			await controller.postStateToWebview()
-		} catch (webviewErr) {
-			console.error("Error posting to webview:", webviewErr)
-		}
-
-		return DeleteNonFavoritedTasksResults.create({
-			tasksPreserved: favoritedTasks.length,
-			tasksDeleted: deletedCount,
-		})
-	} catch (error) {
-		console.error("Error in deleteNonFavoritedTasks:", error)
-		throw error
-	}
-}
-
-/**
- * Helper function to cleanup task files while preserving specified tasks
- */
-async function cleanupTaskFiles(controller: Controller, preserveTaskIds: string[]) {
-	const taskDirPath = path.join(controller.context.globalStorageUri.fsPath, "tasks")
-
-	try {
-		if (await fileExistsAtPath(taskDirPath)) {
-			if (preserveTaskIds.length > 0) {
-				const taskDirs = await fs.readdir(taskDirPath)
-				console.debug(`[cleanupTaskFiles] Found ${taskDirs.length} task directories`)
-
-				// Delete only non-preserved task directories
-				for (const dir of taskDirs) {
-					if (!preserveTaskIds.includes(dir)) {
-						await fs.rm(path.join(taskDirPath, dir), { recursive: true, force: true })
-					}
-				}
-			} else {
-				// No tasks to preserve, delete everything
-				await fs.rm(taskDirPath, { recursive: true, force: true })
-			}
-		}
-	} catch (error) {
-		console.error("Error cleaning up task files:", error)
-	}
-
-	return true
-}

src/core/controller/task/deleteTasksWithIds.ts

@@ -1,5 +1,6 @@
 import path from "path"
 import fs from "fs/promises"
+import vscode from "vscode"
 import { Controller } from ".."
 import { Empty, StringArrayRequest, BooleanRequest } from "../../../shared/proto/common"
 import { TaskMethodHandler } from "./index"
@@ -20,6 +21,18 @@ export const deleteTasksWithIds: TaskMethodHandler = async (
 		throw new Error("Missing task IDs")
 	}
 
+	const taskCount = request.value.length
+	const message =
+		taskCount === 1
+			? "Are you sure you want to delete this task? This action cannot be undone."
+			: `Are you sure you want to delete these ${taskCount} tasks? This action cannot be undone.`
+
+	const userChoice = await vscode.window.showWarningMessage(message, { modal: true }, "Delete")
+
+	if (userChoice === undefined) {
+		return Empty.create()
+	}
+
 	for (const id of request.value) {
 		await deleteTaskWithId(controller, id)
 	}

src/core/controller/task/getTaskHistory.ts

@@ -15,7 +15,7 @@ export async function getTaskHistory(controller: Controller, request: GetTaskHis
 
 		// Get task history from global state
 		const taskHistory = ((await getGlobalState(controller.context, "taskHistory")) as any[]) || []
-		const workspacePath = getWorkspacePath()
+		const workspacePath = await getWorkspacePath()
 
 		// Apply filters
 		let filteredTasks = taskHistory.filter((item) => {

src/core/controller/ui/initializeWebview.ts

@@ -1,7 +1,7 @@
 import type { Controller } from "../index"
 import { EmptyRequest, Empty } from "@shared/proto/common"
 import { handleModelsServiceRequest } from "../models"
-import { getAllExtensionState, getGlobalState, updateWorkspaceState } from "../../storage/state"
+import { getAllExtensionState, getGlobalState, updateGlobalState } from "../../storage/state"
 import { sendOpenRouterModelsEvent } from "../models/subscribeToOpenRouterModels"
 import { sendMcpMarketplaceCatalogEvent } from "../mcp/subscribeToMcpMarketplaceCatalog"
 import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
@@ -32,7 +32,7 @@ export async function initializeWebview(controller: Controller, request: EmptyRe
 				// Update model info in state (this needs to be done here since we don't want to update state while settings is open, and we may refresh models there)
 				const { apiConfiguration } = await getAllExtensionState(controller.context)
 				if (apiConfiguration.openRouterModelId && response.models[apiConfiguration.openRouterModelId]) {
-					await updateWorkspaceState(
+					await updateGlobalState(
 						controller.context,
 						"openRouterModelInfo",
 						response.models[apiConfiguration.openRouterModelId],

src/core/mentions/index.ts

@@ -11,13 +11,14 @@ import { getLatestTerminalOutput } from "@integrations/terminal/get-latest-outpu
 import { getCommitInfo } from "@utils/git"
 import { getWorkingState } from "@utils/git"
 import { FileContextTracker } from "../context/context-tracking/FileContextTracker"
+import { getCwd } from "@/utils/path"
 
-export function openMention(mention?: string): void {
+export async function openMention(mention?: string): Promise<void> {
 	if (!mention) {
 		return
 	}
 
-	const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
+	const cwd = await getCwd()
 	if (!cwd) {
 		return
 	}

src/core/prompts/model_prompts/claude4-experimental.ts

@@ -234,10 +234,9 @@ In each user message, the environment_details will specify the current mode. The
 ## What is PLAN MODE?
 
 - While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
-- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using ${readTool.name} or ${grepToolDefinition.name} to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
-- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well.
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using ${readTool.name} or ${grepToolDefinition.name} to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task.
 - Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
-- If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
 - Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
 
 ====
@@ -257,7 +256,6 @@ CAPABILITIES
 			: ""
 	}
 - You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
-- You can use LaTeX syntax in your responses to render mathematical expressions
 
 ====
 

src/core/prompts/model_prompts/claude4.ts

@@ -574,10 +574,9 @@ In each user message, the environment_details will specify the current mode. The
 ## What is PLAN MODE?
 
 - While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
-- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
-- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well. Present the plan to the user using the plan_mode_respond tool.
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions with ask_followup_question to get a better understanding of the task.
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Present the plan to the user using the plan_mode_respond tool.
 - Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
-- If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
 - Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
 
 ====
@@ -597,7 +596,6 @@ CAPABILITIES
         : ""
 }
 - You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
-- You can use LaTeX syntax in your responses to render mathematical expressions
 
 ====
 

src/core/prompts/responses.ts

@@ -35,6 +35,9 @@ Otherwise, if you have not completed the task and do not need additional informa
 	tooManyMistakes: (feedback?: string) =>
 		`You seem to be having trouble proceeding. The user has provided the following feedback to help guide you:\n<feedback>\n${feedback}\n</feedback>`,
 
+	autoApprovalMaxReached: (feedback?: string) =>
+		`Auto-approval limit reached. The user has provided the following feedback to help guide you:\n<feedback>\n${feedback}\n</feedback>`,
+
 	missingToolParameterError: (paramName: string) =>
 		`Missing value for required parameter '${paramName}'. Please retry with complete response.\n\n${toolUseInstructionsReminder}`,
 

src/core/prompts/system.ts

@@ -568,10 +568,9 @@ In each user message, the environment_details will specify the current mode. The
 ## What is PLAN MODE?
 
 - While you are usually in ACT MODE, the user may switch to PLAN MODE in order to have a back and forth with you to plan how to best accomplish the task. 
-- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. You may return mermaid diagrams to visually display your understanding.
-- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. Returning mermaid diagrams may be helpful here as well.
+- When starting in PLAN MODE, depending on the user's request, you may need to do some information gathering e.g. using read_file or search_files to get more context about the task. You may also ask the user clarifying questions to get a better understanding of the task. 
+- Once you've gained more context about the user's request, you should architect a detailed plan for how you will accomplish the task. 
 - Then you might ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and plan the best way to accomplish it.
-- If at any point a mermaid diagram would make your plan clearer to help the user quickly see the structure, you are encouraged to include a Mermaid code block in the response. (Note: if you use colors in your mermaid diagrams, be sure to use high contrast colors so the text is readable.)
 - Finally once it seems like you've reached a good plan, ask the user to switch you back to ACT MODE to implement the solution.
 
 ====
@@ -591,7 +590,6 @@ CAPABILITIES
 		: ""
 }
 - You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
-- You can use LaTeX syntax in your responses to render mathematical expressions
 
 ====
 

src/core/storage/state-keys.ts

@@ -71,18 +71,14 @@ export type GlobalStateKey =
 	| "terminalReuseEnabled"
 	| "defaultTerminalProfile"
 	| "isNewUser"
+	| "welcomeViewCompleted"
 	| "terminalOutputLineLimit"
 	| "mcpRichDisplayEnabled"
 	| "sapAiCoreTokenUrl"
 	| "sapAiCoreBaseUrl"
 	| "sapAiResourceGroup"
-	| "sapAiCoreClientId"
-	| "sapAiCoreClientSecret"
-	| "sapAiCoreModelId"
 	| "claudeCodePath"
-
-export type LocalStateKey =
-	| "localClineRulesToggles"
+	// Settings around plan/act and ephemeral model configuration
 	| "chatSettings"
 	// Current active model configuration (per workspace)
 	| "apiProvider"
@@ -104,6 +100,7 @@ export type LocalStateKey =
 	| "requestyModelInfo"
 	| "togetherModelId"
 	| "fireworksModelId"
+	| "sapAiCoreModelId"
 	// Previous mode saved configurations (per workspace)
 	| "previousModeApiProvider"
 	| "previousModeModelId"
@@ -113,9 +110,6 @@ export type LocalStateKey =
 	| "previousModeReasoningEffort"
 	| "previousModeAwsBedrockCustomSelected"
 	| "previousModeAwsBedrockCustomModelBaseId"
-	| "previousModeSapAiCoreClientId"
-	| "previousModeSapAiCoreClientSecret"
-	| "previousModeSapAiCoreBaseUrl"
-	| "previousModeSapAiCoreTokenUrl"
-	| "previousModeSapAiCoreResourceGroup"
 	| "previousModeSapAiCoreModelId"
+
+export type LocalStateKey = "localClineRulesToggles" | "localCursorRulesToggles" | "localWindsurfRulesToggles" | "workflowToggles"

src/core/storage/state-migrations.ts

@@ -2,11 +2,11 @@ import * as vscode from "vscode"
 import { ensureRulesDirectoryExists } from "./disk"
 import fs from "fs/promises"
 import path from "path"
-import { getGlobalState, getWorkspaceState, updateGlobalState, updateWorkspaceState } from "./state"
+import { updateGlobalState, getAllExtensionState, getGlobalState } from "./state"
 import { GlobalStateKey } from "./state-keys"
 
-export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.ExtensionContext) {
-	// Keys that were migrated from global storage to workspace storage
+export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionContext) {
+	// Keys to migrate from workspace storage back to global storage
 	const keysToMigrate = [
 		// Core settings
 		"apiProvider",
@@ -31,6 +31,7 @@ export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.Ext
 		"requestyModelInfo",
 		"togetherModelId",
 		"fireworksModelId",
+		"sapAiCoreModelId",
 
 		// Previous mode settings
 		"previousModeApiProvider",
@@ -41,17 +42,24 @@ export async function migratePlanActGlobalToWorkspaceStorage(context: vscode.Ext
 		"previousModeReasoningEffort",
 		"previousModeAwsBedrockCustomSelected",
 		"previousModeAwsBedrockCustomModelBaseId",
+		"previousModeSapAiCoreModelId",
 	]
 
 	for (const key of keysToMigrate) {
-		const globalValue = await getGlobalState(context, key as GlobalStateKey)
-		if (globalValue !== undefined) {
-			const workspaceValue = await getWorkspaceState(context, key)
-			if (workspaceValue === undefined) {
-				await updateWorkspaceState(context, key, globalValue)
-			}
-			// Delete from global storage regardless of whether we copied it
-			await updateGlobalState(context, key as GlobalStateKey, undefined)
+		// Use raw workspace state since these keys shouldn't be in workspace storage
+		const workspaceValue = await context.workspaceState.get(key)
+		const globalValue = await context.globalState.get(key)
+
+		if (workspaceValue !== undefined && globalValue === undefined) {
+			console.log(`[Storage Migration] migrating key: ${key} to global storage. Current value: ${workspaceValue}`)
+
+			// Move to global storage
+			await updateGlobalState(context, key as GlobalStateKey, workspaceValue)
+			// Remove from workspace storage
+			await context.workspaceState.update(key, undefined)
+			const newWorkspaceValue = await context.workspaceState.get(key)
+
+			console.log(`[Storage Migration] migrated key: ${key} to global storage. Current value: ${newWorkspaceValue}`)
 		}
 	}
 }
@@ -126,22 +134,89 @@ export async function migrateCustomInstructionsToGlobalRules(context: vscode.Ext
 
 export async function migrateModeFromWorkspaceStorageToControllerState(context: vscode.ExtensionContext) {
 	try {
-		// Get current chatSettings from workspace storage
-		const chatSettings = (await getWorkspaceState(context, "chatSettings")) as any
+		// Check legacy workspace storage (use raw methods since chatSettings is now global)
+		const workspaceChatSettings = (await context.workspaceState.get("chatSettings")) as any
 
-		if (chatSettings && typeof chatSettings === "object" && "mode" in chatSettings) {
-			console.log("Cleaning up mode from workspace storage...")
+		if (workspaceChatSettings && typeof workspaceChatSettings === "object" && "mode" in workspaceChatSettings) {
+			console.log("Cleaning up mode from legacy workspace storage...")
 
 			// Remove mode property from chatSettings
-			const { mode, ...cleanedChatSettings } = chatSettings
+			const { mode, ...cleanedChatSettings } = workspaceChatSettings
 
-			// Save cleaned chatSettings back to workspace storage
-			await updateWorkspaceState(context, "chatSettings", cleanedChatSettings)
+			// Save cleaned chatSettings back to workspace storage (will be migrated later)
+			await context.workspaceState.update("chatSettings", cleanedChatSettings)
 
-			console.log("Successfully removed mode from workspace storage chatSettings")
+			console.log("Successfully removed mode from legacy workspace storage chatSettings")
+		}
+
+		// Also check global storage for any mode cleanup needed
+		const globalChatSettings = (await context.globalState.get("chatSettings")) as any
+
+		if (globalChatSettings && typeof globalChatSettings === "object" && "mode" in globalChatSettings) {
+			console.log("Cleaning up mode from global storage...")
+
+			// Remove mode property from chatSettings
+			const { mode, ...cleanedChatSettings } = globalChatSettings
+
+			// Save cleaned chatSettings back to global storage
+			await updateGlobalState(context, "chatSettings", cleanedChatSettings)
+
+			console.log("Successfully removed mode from global storage chatSettings")
 		}
 	} catch (error) {
-		console.error("Failed to cleanup mode from workspace storage:", error)
+		console.error("Failed to cleanup mode from storage:", error)
+		// Continue execution - migration failure shouldn't break extension startup
+	}
+}
+
+export async function migrateWelcomeViewCompleted(context: vscode.ExtensionContext) {
+	try {
+		// Check if welcomeViewCompleted is already set
+		const welcomeViewCompleted = await getGlobalState(context, "welcomeViewCompleted")
+
+		if (welcomeViewCompleted === undefined) {
+			console.log("Migrating welcomeViewCompleted setting...")
+
+			// Get all extension state to check for existing API keys
+			const extensionState = await getAllExtensionState(context)
+			const config = extensionState.apiConfiguration
+
+			// This is the original logic used for checking is the welcome view should be shown
+			// It was located in the ExtensionStateContextProvider
+			const hasKey = config
+				? [
+						config.apiKey,
+						config.openRouterApiKey,
+						config.awsRegion,
+						config.vertexProjectId,
+						config.openAiApiKey,
+						config.ollamaModelId,
+						config.lmStudioModelId,
+						config.liteLlmApiKey,
+						config.geminiApiKey,
+						config.openAiNativeApiKey,
+						config.deepSeekApiKey,
+						config.requestyApiKey,
+						config.togetherApiKey,
+						config.qwenApiKey,
+						config.doubaoApiKey,
+						config.mistralApiKey,
+						config.vsCodeLmModelSelector,
+						config.clineApiKey,
+						config.asksageApiKey,
+						config.xaiApiKey,
+						config.sambanovaApiKey,
+						config.sapAiCoreClientId,
+					].some((key) => key !== undefined)
+				: false
+
+			// Set welcomeViewCompleted based on whether user has keys
+			await updateGlobalState(context, "welcomeViewCompleted", hasKey)
+
+			console.log(`Migration: Set welcomeViewCompleted to ${hasKey} based on existing API keys`)
+		}
+	} catch (error) {
+		console.error("Failed to migrate welcomeViewCompleted:", error)
 		// Continue execution - migration failure shouldn't break extension startup
 	}
 }

src/core/storage/state.ts

@@ -2,7 +2,7 @@ import * as vscode from "vscode"
 import { DEFAULT_CHAT_SETTINGS } from "@shared/ChatSettings"
 import { DEFAULT_BROWSER_SETTINGS } from "@shared/BrowserSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
-import { GlobalStateKey, SecretKey } from "./state-keys"
+import { GlobalStateKey, LocalStateKey, SecretKey } from "./state-keys"
 import { ApiConfiguration, ApiProvider, BedrockModelId, ModelInfo } from "@shared/api"
 import { HistoryItem } from "@shared/HistoryItem"
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
@@ -44,17 +44,18 @@ export async function getSecret(context: vscode.ExtensionContext, key: SecretKey
 
 // workspace
 
-export async function updateWorkspaceState(context: vscode.ExtensionContext, key: string, value: any) {
+export async function updateWorkspaceState(context: vscode.ExtensionContext, key: LocalStateKey, value: any) {
 	await context.workspaceState.update(key, value)
 }
 
-export async function getWorkspaceState(context: vscode.ExtensionContext, key: string) {
+export async function getWorkspaceState(context: vscode.ExtensionContext, key: LocalStateKey) {
 	return await context.workspaceState.get(key)
 }
 
 export async function getAllExtensionState(context: vscode.ExtensionContext) {
 	const [
 		isNewUser,
+		welcomeViewCompleted,
 		apiKey,
 		openRouterApiKey,
 		clineApiKey,
@@ -124,10 +125,10 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		sapAiCoreBaseUrl,
 		sapAiCoreTokenUrl,
 		sapAiResourceGroup,
-		sapAiCoreModelId,
 		claudeCodePath,
 	] = await Promise.all([
 		getGlobalState(context, "isNewUser") as Promise<boolean | undefined>,
+		getGlobalState(context, "welcomeViewCompleted") as Promise<boolean | undefined>,
 		getSecret(context, "apiKey") as Promise<string | undefined>,
 		getSecret(context, "openRouterApiKey") as Promise<string | undefined>,
 		getSecret(context, "clineApiKey") as Promise<string | undefined>,
@@ -197,7 +198,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		getGlobalState(context, "sapAiCoreBaseUrl") as Promise<string | undefined>,
 		getGlobalState(context, "sapAiCoreTokenUrl") as Promise<string | undefined>,
 		getGlobalState(context, "sapAiResourceGroup") as Promise<string | undefined>,
-		getGlobalState(context, "sapAiCoreModelId") as Promise<string | undefined>,
 		getGlobalState(context, "claudeCodePath") as Promise<string | undefined>,
 	])
 
@@ -232,47 +232,39 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeReasoningEffort,
 		previousModeAwsBedrockCustomSelected,
 		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreClientId,
-		previousModeSapAiCoreClientSecret,
-		previousModeSapAiCoreBaseUrl,
-		previousModeSapAiCoreTokenUrl,
-		previousModeSapAiCoreResourceGroup,
 		previousModeSapAiCoreModelId,
+		sapAiCoreModelId,
 	] = await Promise.all([
-		getWorkspaceState(context, "chatSettings") as Promise<StoredChatSettings | undefined>,
-		getWorkspaceState(context, "apiProvider") as Promise<ApiProvider | undefined>,
-		getWorkspaceState(context, "apiModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "thinkingBudgetTokens") as Promise<number | undefined>,
-		getWorkspaceState(context, "reasoningEffort") as Promise<string | undefined>,
-		getWorkspaceState(context, "vsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
-		getWorkspaceState(context, "awsBedrockCustomSelected") as Promise<boolean | undefined>,
-		getWorkspaceState(context, "awsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
-		getWorkspaceState(context, "openRouterModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "openRouterModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "openAiModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "openAiModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "ollamaModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "lmStudioModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "liteLlmModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "liteLlmModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "requestyModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "requestyModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "togetherModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "fireworksModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeApiProvider") as Promise<ApiProvider | undefined>,
-		getWorkspaceState(context, "previousModeModelId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeModelInfo") as Promise<ModelInfo | undefined>,
-		getWorkspaceState(context, "previousModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
-		getWorkspaceState(context, "previousModeThinkingBudgetTokens") as Promise<number | undefined>,
-		getWorkspaceState(context, "previousModeReasoningEffort") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
-		getWorkspaceState(context, "previousModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreClientId") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreClientSecret") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreBaseUrl") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreTokenUrl") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreResourceGroup") as Promise<string | undefined>,
-		getWorkspaceState(context, "previousModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "chatSettings") as Promise<StoredChatSettings | undefined>,
+		getGlobalState(context, "apiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "apiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "thinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "reasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "vsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "awsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "awsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "openRouterModelId") as Promise<string | undefined>,
+		getGlobalState(context, "openRouterModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "openAiModelId") as Promise<string | undefined>,
+		getGlobalState(context, "openAiModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "ollamaModelId") as Promise<string | undefined>,
+		getGlobalState(context, "lmStudioModelId") as Promise<string | undefined>,
+		getGlobalState(context, "liteLlmModelId") as Promise<string | undefined>,
+		getGlobalState(context, "liteLlmModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "requestyModelId") as Promise<string | undefined>,
+		getGlobalState(context, "requestyModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "togetherModelId") as Promise<string | undefined>,
+		getGlobalState(context, "fireworksModelId") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeApiProvider") as Promise<ApiProvider | undefined>,
+		getGlobalState(context, "previousModeModelId") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeModelInfo") as Promise<ModelInfo | undefined>,
+		getGlobalState(context, "previousModeVsCodeLmModelSelector") as Promise<vscode.LanguageModelChatSelector | undefined>,
+		getGlobalState(context, "previousModeThinkingBudgetTokens") as Promise<number | undefined>,
+		getGlobalState(context, "previousModeReasoningEffort") as Promise<string | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomSelected") as Promise<boolean | undefined>,
+		getGlobalState(context, "previousModeAwsBedrockCustomModelBaseId") as Promise<BedrockModelId | undefined>,
+		getGlobalState(context, "previousModeSapAiCoreModelId") as Promise<string | undefined>,
+		getGlobalState(context, "sapAiCoreModelId") as Promise<string | undefined>,
 	])
 
 	let apiProvider: ApiProvider
@@ -388,6 +380,7 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 			sapAiCoreModelId,
 		},
 		isNewUser: isNewUser ?? true,
+		welcomeViewCompleted,
 		lastShownAnnouncementId,
 		taskHistory,
 		autoApprovalSettings: autoApprovalSettings || DEFAULT_AUTO_APPROVAL_SETTINGS, // default value can be 0 or empty string
@@ -407,11 +400,6 @@ export async function getAllExtensionState(context: vscode.ExtensionContext) {
 		previousModeReasoningEffort,
 		previousModeAwsBedrockCustomSelected,
 		previousModeAwsBedrockCustomModelBaseId,
-		previousModeSapAiCoreClientId,
-		previousModeSapAiCoreClientSecret,
-		previousModeSapAiCoreBaseUrl,
-		previousModeSapAiCoreTokenUrl,
-		previousModeSapAiCoreResourceGroup,
 		previousModeSapAiCoreModelId,
 		mcpMarketplaceEnabled: mcpMarketplaceEnabled,
 		mcpRichDisplayEnabled: mcpRichDisplayEnabled ?? true,
@@ -502,26 +490,28 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 		sapAiCoreModelId,
 		claudeCodePath,
 	} = apiConfiguration
-	// Workspace state updates
-	await updateWorkspaceState(context, "apiProvider", apiProvider)
-	await updateWorkspaceState(context, "apiModelId", apiModelId)
-	await updateWorkspaceState(context, "thinkingBudgetTokens", thinkingBudgetTokens)
-	await updateWorkspaceState(context, "reasoningEffort", reasoningEffort)
-	await updateWorkspaceState(context, "vsCodeLmModelSelector", vsCodeLmModelSelector)
-	await updateWorkspaceState(context, "awsBedrockCustomSelected", awsBedrockCustomSelected)
-	await updateWorkspaceState(context, "awsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
-	await updateWorkspaceState(context, "openRouterModelId", openRouterModelId)
-	await updateWorkspaceState(context, "openRouterModelInfo", openRouterModelInfo)
-	await updateWorkspaceState(context, "openAiModelId", openAiModelId)
-	await updateWorkspaceState(context, "openAiModelInfo", openAiModelInfo)
-	await updateWorkspaceState(context, "ollamaModelId", ollamaModelId)
-	await updateWorkspaceState(context, "lmStudioModelId", lmStudioModelId)
-	await updateWorkspaceState(context, "liteLlmModelId", liteLlmModelId)
-	await updateWorkspaceState(context, "liteLlmModelInfo", liteLlmModelInfo)
-	await updateWorkspaceState(context, "requestyModelId", requestyModelId)
-	await updateWorkspaceState(context, "requestyModelInfo", requestyModelInfo)
-	await updateWorkspaceState(context, "togetherModelId", togetherModelId)
-	await updateWorkspaceState(context, "fireworksModelId", fireworksModelId)
+
+	// Ephemeral model config updates
+	await updateGlobalState(context, "apiProvider", apiProvider)
+	await updateGlobalState(context, "apiModelId", apiModelId)
+	await updateGlobalState(context, "thinkingBudgetTokens", thinkingBudgetTokens)
+	await updateGlobalState(context, "reasoningEffort", reasoningEffort)
+	await updateGlobalState(context, "vsCodeLmModelSelector", vsCodeLmModelSelector)
+	await updateGlobalState(context, "awsBedrockCustomSelected", awsBedrockCustomSelected)
+	await updateGlobalState(context, "awsBedrockCustomModelBaseId", awsBedrockCustomModelBaseId)
+	await updateGlobalState(context, "openRouterModelId", openRouterModelId)
+	await updateGlobalState(context, "openRouterModelInfo", openRouterModelInfo)
+	await updateGlobalState(context, "openAiModelId", openAiModelId)
+	await updateGlobalState(context, "openAiModelInfo", openAiModelInfo)
+	await updateGlobalState(context, "ollamaModelId", ollamaModelId)
+	await updateGlobalState(context, "lmStudioModelId", lmStudioModelId)
+	await updateGlobalState(context, "liteLlmModelId", liteLlmModelId)
+	await updateGlobalState(context, "liteLlmModelInfo", liteLlmModelInfo)
+	await updateGlobalState(context, "requestyModelId", requestyModelId)
+	await updateGlobalState(context, "requestyModelInfo", requestyModelInfo)
+	await updateGlobalState(context, "togetherModelId", togetherModelId)
+	await updateGlobalState(context, "fireworksModelId", fireworksModelId)
+	await updateGlobalState(context, "sapAiCoreModelId", sapAiCoreModelId)
 
 	// Global state updates
 	await updateGlobalState(context, "awsRegion", awsRegion)
@@ -549,12 +539,9 @@ export async function updateApiConfiguration(context: vscode.ExtensionContext, a
 	await updateGlobalState(context, "requestTimeoutMs", apiConfiguration.requestTimeoutMs)
 	await updateGlobalState(context, "fireworksModelMaxCompletionTokens", fireworksModelMaxCompletionTokens)
 	await updateGlobalState(context, "fireworksModelMaxTokens", fireworksModelMaxTokens)
-	await updateGlobalState(context, "favoritedModelIds", favoritedModelIds)
-	await updateGlobalState(context, "requestTimeoutMs", apiConfiguration.requestTimeoutMs)
 	await updateGlobalState(context, "sapAiCoreBaseUrl", sapAiCoreBaseUrl)
 	await updateGlobalState(context, "sapAiCoreTokenUrl", sapAiCoreTokenUrl)
 	await updateGlobalState(context, "sapAiResourceGroup", sapAiResourceGroup)
-	await updateGlobalState(context, "sapAiCoreModelId", sapAiCoreModelId)
 	await updateGlobalState(context, "claudeCodePath", claudeCodePath)
 
 	// Secret updates

src/core/task/ToolExecutor.ts

@@ -1,17 +1,23 @@
-import * as vscode from "vscode"
-import { TaskState } from "./TaskState"
-import { MessageStateHandler } from "./message-state"
+import { showSystemNotification } from "@/integrations/notifications"
+import { listFiles } from "@/services/glob/list-files"
+import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
+import { regexSearchFiles } from "@/services/ripgrep"
+import { parseSourceCodeForDefinitionsTopLevel } from "@/services/tree-sitter"
+import { findLast, findLastIndex, parsePartialArrayString } from "@/shared/array"
+import { createAndOpenGitHubIssue } from "@/utils/github-url-utils"
+import { getReadablePath, isLocatedInWorkspace } from "@/utils/path"
+import Anthropic from "@anthropic-ai/sdk"
 import { ApiHandler } from "@api/index"
-import { TerminalManager } from "@integrations/terminal/TerminalManager"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { DiffViewProvider } from "@integrations/editor/DiffViewProvider"
-import { McpHub } from "@services/mcp/McpHub"
 import { FileContextTracker } from "@core/context/context-tracking/FileContextTracker"
 import { ClineIgnoreController } from "@core/ignore/ClineIgnoreController"
+import { DiffViewProvider } from "@integrations/editor/DiffViewProvider"
+import { extractTextFromFile, processFilesIntoText } from "@integrations/misc/extract-text"
+import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
+import { BrowserSession } from "@services/browser/BrowserSession"
+import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
+import { McpHub } from "@services/mcp/McpHub"
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
-import { ChatSettings } from "@shared/ChatSettings"
-import { ToolParamName, ToolUse, ToolUseName } from "../assistant-message"
-import { AutoApprove } from "./tools/autoApprove"
+import { BrowserSettings } from "@shared/BrowserSettings"
 import {
 	BrowserAction,
 	BrowserActionResult,
@@ -25,37 +31,29 @@ import {
 	ClineSayTool,
 	COMPLETION_RESULT_CHANGES_FLAG,
 } from "@shared/ExtensionMessage"
-import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
-import { BrowserSettings } from "@shared/BrowserSettings"
 import { ClineAskResponse } from "@shared/WebviewMessage"
-import { fixModelHtmlEscaping, removeInvalidChars } from "@utils/string"
-import { fileExistsAtPath } from "@utils/fs"
-import { formatResponse } from "../prompts/responses"
-import { isClaude4ModelFamily, isGemini2dot5ModelFamily } from "@utils/model-utils"
-import { ToolResponse, USE_EXPERIMENTAL_CLAUDE4_FEATURES } from "."
-import { serializeError } from "serialize-error"
-import * as path from "path"
-import { extractTextFromFile, processFilesIntoText } from "@integrations/misc/extract-text"
 import { COMMAND_REQ_APP_STRING } from "@shared/combineCommandSequences"
-import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
-import { constructNewFileContent } from "../assistant-message/diff"
-import { getReadablePath, isLocatedInWorkspace } from "@/utils/path"
-import { listFiles } from "@/services/glob/list-files"
-import { showNotificationForApprovalIfAutoApprovalEnabled } from "./utils"
-import { parseSourceCodeForDefinitionsTopLevel } from "@/services/tree-sitter"
-import { regexSearchFiles } from "@/services/ripgrep"
-import { showSystemNotification } from "@/integrations/notifications"
-import { findLast, findLastIndex, parsePartialArrayString } from "@/shared/array"
-import { ensureTaskDirectoryExists } from "../storage/disk"
-import { telemetryService } from "@/services/posthog/telemetry/TelemetryService"
-import { loadMcpDocumentation } from "../prompts/loadMcpDocumentation"
-import Anthropic from "@anthropic-ai/sdk"
-import { createAndOpenGitHubIssue } from "@/utils/github-url-utils"
-import { getWorkspaceState } from "../storage/state"
-import os from "os"
-import { ContextManager } from "../context/context-management/ContextManager"
+import { fileExistsAtPath } from "@utils/fs"
+import { isClaude4ModelFamily, isGemini2dot5ModelFamily } from "@utils/model-utils"
+import { fixModelHtmlEscaping, removeInvalidChars } from "@utils/string"
 import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+import os from "os"
+import * as path from "path"
+import { serializeError } from "serialize-error"
+import * as vscode from "vscode"
+import { ToolResponse, USE_EXPERIMENTAL_CLAUDE4_FEATURES } from "."
+import { ToolParamName, ToolUse, ToolUseName } from "../assistant-message"
+import { constructNewFileContent } from "../assistant-message/diff"
 import { ChangeLocation, StreamingJsonReplacer } from "../assistant-message/diff-json"
+import { ContextManager } from "../context/context-management/ContextManager"
+import { loadMcpDocumentation } from "../prompts/loadMcpDocumentation"
+import { formatResponse } from "../prompts/responses"
+import { ensureTaskDirectoryExists } from "../storage/disk"
+import { getGlobalState, getWorkspaceState } from "../storage/state"
+import { TaskState } from "./TaskState"
+import { MessageStateHandler } from "./message-state"
+import { AutoApprove } from "./tools/autoApprove"
+import { showNotificationForApprovalIfAutoApprovalEnabled } from "./utils"
 
 export class ToolExecutor {
 	private autoApprover: AutoApprove
@@ -65,7 +63,10 @@ export class ToolExecutor {
 		return this.autoApprover.shouldAutoApproveTool(toolName)
 	}
 
-	private shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): boolean {
+	private async shouldAutoApproveToolWithPath(
+		blockname: ToolUseName,
+		autoApproveActionpath: string | undefined,
+	): Promise<boolean> {
 		return this.autoApprover.shouldAutoApproveToolWithPath(blockname, autoApproveActionpath)
 	}
 
@@ -75,7 +76,6 @@ export class ToolExecutor {
 		private taskState: TaskState,
 		private messageStateHandler: MessageStateHandler,
 		private api: ApiHandler,
-		private terminalManager: TerminalManager,
 		private urlContentFetcher: UrlContentFetcher,
 		private browserSession: BrowserSession,
 		private diffViewProvider: DiffViewProvider,
@@ -88,7 +88,6 @@ export class ToolExecutor {
 		// Configuration & Settings
 		private autoApprovalSettings: AutoApprovalSettings,
 		private browserSettings: BrowserSettings,
-		private chatSettings: ChatSettings,
 		private cwd: string,
 		private taskId: string,
 
@@ -106,8 +105,6 @@ export class ToolExecutor {
 			partial?: boolean,
 		) => Promise<{ response: ClineAskResponse; text?: string; images?: string[]; files?: string[] }>,
 		private saveCheckpoint: (isAttemptCompletionMessage?: boolean) => Promise<void>,
-		private reinitExistingTaskFromId: (taskId: string) => Promise<void>,
-		private cancelTask: () => Promise<void>,
 		private sayAndCreateMissingParamError: (toolName: ToolUseName, paramName: string, relPath?: string) => Promise<any>,
 		private removeLastPartialMessageIfExistsWithType: (type: "ask" | "say", askOrSay: ClineAsk | ClineSay) => Promise<void>,
 		private executeCommandTool: (command: string) => Promise<[boolean, any]>,
@@ -336,8 +333,6 @@ export class ToolExecutor {
 					// Handle write error
 					return { shouldBreak: true, error: `Write error: ${e}` }
 				}
-
-				const newContentParsed = this.taskState.streamingJsonReplacer.getSuccessfullyParsedItems()
 			}
 
 			return { shouldBreak: true } // Wait for more chunks
@@ -574,14 +569,14 @@ export class ToolExecutor {
 						tool: fileExists ? "editedExistingFile" : "newFileCreated",
 						path: getReadablePath(this.cwd, this.removeClosingTag(block, "path", relPath)),
 						content: diff || content,
-						operationIsLocatedInWorkspace: isLocatedInWorkspace(relPath),
+						operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 					}
 
 					if (block.partial) {
 						// update gui message
 						const partialMessage = JSON.stringify(sharedMessageProps)
 
-						if (this.shouldAutoApproveToolWithPath(block.name, relPath)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, relPath)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool") // in case the user changes auto-approval settings mid stream
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -645,7 +640,7 @@ export class ToolExecutor {
 						const completeMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: diff || content,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(relPath),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 							// ? formatResponse.createPrettyPatch(
 							// 		relPath,
 							// 		this.diffViewProvider.originalContent,
@@ -653,7 +648,7 @@ export class ToolExecutor {
 							// 	)
 							// : undefined,
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, relPath)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, relPath)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -788,9 +783,9 @@ export class ToolExecutor {
 						const partialMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: undefined,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(relPath),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -819,9 +814,9 @@ export class ToolExecutor {
 						const completeMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: absolutePath,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(relPath),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(relPath),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false) // need to be sending partialValue bool, since undefined has its own purpose in that the message is treated neither as a partial or completion of a partial, but as a single complete message
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -870,9 +865,9 @@ export class ToolExecutor {
 						const partialMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: "",
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -902,9 +897,9 @@ export class ToolExecutor {
 						const completeMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: result,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -945,9 +940,9 @@ export class ToolExecutor {
 						const partialMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: "",
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -974,9 +969,9 @@ export class ToolExecutor {
 						const completeMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: result,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -1021,9 +1016,9 @@ export class ToolExecutor {
 						const partialMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: "",
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", partialMessage, undefined, undefined, block.partial)
 						} else {
@@ -1058,9 +1053,9 @@ export class ToolExecutor {
 						const completeMessage = JSON.stringify({
 							...sharedMessageProps,
 							content: results,
-							operationIsLocatedInWorkspace: isLocatedInWorkspace(block.params.path),
+							operationIsLocatedInWorkspace: await isLocatedInWorkspace(block.params.path),
 						} satisfies ClineSayTool)
-						if (this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
+						if (await this.shouldAutoApproveToolWithPath(block.name, block.params.path)) {
 							this.removeLastPartialMessageIfExistsWithType("ask", "tool")
 							await this.say("tool", completeMessage, undefined, undefined, false)
 							this.taskState.consecutiveAutoApprovedRequestsCount++
@@ -1922,7 +1917,7 @@ export class ToolExecutor {
 						const clineVersion =
 							vscode.extensions.getExtension("saoudrizwan.claude-dev")?.packageJSON.version || "Unknown"
 						const systemInfo = `VSCode: ${vscode.version}, Node.js: ${process.version}, Architecture: ${os.arch()}`
-						const providerAndModel = `${(await getWorkspaceState(this.context, "apiProvider")) as string} / ${this.api.getModel().id}`
+						const providerAndModel = `${await getGlobalState(this.context, "apiProvider")} / ${this.api.getModel().id}`
 
 						// Ask user for confirmation
 						const bugReportData = JSON.stringify({

src/core/task/index.ts

@@ -1,13 +1,4 @@
 import { Anthropic } from "@anthropic-ai/sdk"
-import cloneDeep from "clone-deep"
-import { execa } from "execa"
-import { setTimeout as setTimeoutPromise } from "node:timers/promises"
-import os from "os"
-import pTimeout from "p-timeout"
-import pWaitFor from "p-wait-for"
-import * as path from "path"
-import * as vscode from "vscode"
-import { Logger } from "@services/logging/Logger"
 import { ApiHandler, buildApiHandler } from "@api/index"
 import { AnthropicHandler } from "@api/providers/anthropic"
 import { ClineHandler } from "@api/providers/cline"
@@ -21,6 +12,7 @@ import { TerminalManager } from "@integrations/terminal/TerminalManager"
 import { BrowserSession } from "@services/browser/BrowserSession"
 import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
 import { listFiles } from "@services/glob/list-files"
+import { Logger } from "@services/logging/Logger"
 import { telemetryService } from "@services/posthog/telemetry/TelemetryService"
 import { ApiConfiguration } from "@shared/api"
 import { findLast, findLastIndex } from "@shared/array"
@@ -29,42 +21,47 @@ import { BrowserSettings } from "@shared/BrowserSettings"
 import { ChatSettings } from "@shared/ChatSettings"
 import { combineApiRequests } from "@shared/combineApiRequests"
 import { combineCommandSequences } from "@shared/combineCommandSequences"
-import {
-	ClineApiReqCancelReason,
-	ClineApiReqInfo,
-	ClineAsk,
-	ClineMessage,
-	ClineSay,
-	ExtensionMessage,
-} from "@shared/ExtensionMessage"
+import { ClineApiReqCancelReason, ClineApiReqInfo, ClineAsk, ClineMessage, ClineSay } from "@shared/ExtensionMessage"
 import { getApiMetrics } from "@shared/getApiMetrics"
 import { HistoryItem } from "@shared/HistoryItem"
 import { DEFAULT_LANGUAGE_SETTINGS, getLanguageKey, LanguageDisplay } from "@shared/Languages"
 import { ClineAskResponse, ClineCheckpointRestore } from "@shared/WebviewMessage"
-import { arePathsEqual } from "@utils/path"
+import { getGitRemoteUrls } from "@utils/git"
+import { arePathsEqual, getDesktopDir } from "@utils/path"
+import cloneDeep from "clone-deep"
+import { execa } from "execa"
+import { setTimeout as setTimeoutPromise } from "node:timers/promises"
+import pTimeout from "p-timeout"
+import pWaitFor from "p-wait-for"
+import * as path from "path"
+import * as vscode from "vscode"
 
-import {
-	AssistantMessageContent,
-	parseAssistantMessageV2,
-	parseAssistantMessageV3,
-	ToolParamName,
-	ToolUseName,
-} from "@core/assistant-message"
-import { ClineIgnoreController } from "@core/ignore/ClineIgnoreController"
-import { parseMentions } from "@core/mentions"
-import { formatResponse } from "@core/prompts/responses"
-import { addUserInstructions, SYSTEM_PROMPT } from "@core/prompts/system"
-import { sendPartialMessageEvent } from "@core/controller/ui/subscribeToPartialMessage"
-import { sendRelinquishControlEvent } from "@core/controller/ui/subscribeToRelinquishControl"
-import { convertClineMessageToProto } from "@shared/proto-conversions/cline-message"
-import { getContextWindowInfo } from "@core/context/context-management/context-window-utils"
-import { FileContextTracker } from "@core/context/context-tracking/FileContextTracker"
-import { ModelContextTracker } from "@core/context/context-tracking/ModelContextTracker"
+import { parseAssistantMessageV2, parseAssistantMessageV3, ToolUseName } from "@core/assistant-message"
 import {
 	checkIsAnthropicContextWindowError,
 	checkIsOpenRouterContextWindowError,
 } from "@core/context/context-management/context-error-handling"
+import { getContextWindowInfo } from "@core/context/context-management/context-window-utils"
 import { ContextManager } from "@core/context/context-management/ContextManager"
+import { FileContextTracker } from "@core/context/context-tracking/FileContextTracker"
+import { ModelContextTracker } from "@core/context/context-tracking/ModelContextTracker"
+import {
+	getGlobalClineRules,
+	getLocalClineRules,
+	refreshClineRulesToggles,
+} from "@core/context/instructions/user-instructions/cline-rules"
+import {
+	getLocalCursorRules,
+	getLocalWindsurfRules,
+	refreshExternalRulesToggles,
+} from "@core/context/instructions/user-instructions/external-rules"
+import { sendPartialMessageEvent } from "@core/controller/ui/subscribeToPartialMessage"
+import { sendRelinquishControlEvent } from "@core/controller/ui/subscribeToRelinquishControl"
+import { ClineIgnoreController } from "@core/ignore/ClineIgnoreController"
+import { parseMentions } from "@core/mentions"
+import { formatResponse } from "@core/prompts/responses"
+import { addUserInstructions, SYSTEM_PROMPT } from "@core/prompts/system"
+import { parseSlashCommands } from "@core/slash-commands"
 import {
 	ensureRulesDirectoryExists,
 	ensureTaskDirectoryExists,
@@ -72,35 +69,22 @@ import {
 	getSavedClineMessages,
 	GlobalFileNames,
 } from "@core/storage/disk"
-import {
-	getGlobalClineRules,
-	getLocalClineRules,
-	refreshClineRulesToggles,
-} from "@core/context/instructions/user-instructions/cline-rules"
-import { ensureLocalClineDirExists } from "../context/instructions/user-instructions/rule-helpers"
-import {
-	refreshExternalRulesToggles,
-	getLocalWindsurfRules,
-	getLocalCursorRules,
-} from "@core/context/instructions/user-instructions/external-rules"
-import { refreshWorkflowToggles } from "../context/instructions/user-instructions/workflows"
-import { getWorkspaceState } from "@core/storage/state"
-import { parseSlashCommands } from "@core/slash-commands"
+import { getGlobalState } from "@core/storage/state"
+import { processFilesIntoText } from "@integrations/misc/extract-text"
 import WorkspaceTracker from "@integrations/workspace/WorkspaceTracker"
 import { McpHub } from "@services/mcp/McpHub"
-import { isInTestMode } from "../../services/test/TestMode"
-import { processFilesIntoText } from "@integrations/misc/extract-text"
+import { convertClineMessageToProto } from "@shared/proto-conversions/cline-message"
 import { isClaude4ModelFamily, isGemini2dot5ModelFamily } from "@utils/model-utils"
+import { isInTestMode } from "../../services/test/TestMode"
+import { ensureLocalClineDirExists } from "../context/instructions/user-instructions/rule-helpers"
+import { refreshWorkflowToggles } from "../context/instructions/user-instructions/workflows"
 import { MessageStateHandler } from "./message-state"
-import { formatErrorWithStatusCode, updateApiReqMsg } from "./utils"
 import { TaskState } from "./TaskState"
 import { ToolExecutor } from "./ToolExecutor"
+import { formatErrorWithStatusCode, updateApiReqMsg } from "./utils"
 
 export const USE_EXPERIMENTAL_CLAUDE4_FEATURES = false
 
-export const cwd =
-	vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop") // may or may not exist but fs checking existence would immediately ask for permission which would be bad UX, need to come up with a better solution
-
 export type ToolResponse = string | Array<Anthropic.TextBlockParam | Anthropic.ImageBlockParam>
 type UserContent = Array<Anthropic.ContentBlockParam>
 
@@ -108,6 +92,7 @@ export class Task {
 	// Core task variables
 	readonly taskId: string
 	private taskIsFavorited?: boolean
+	private cwd: string
 
 	taskState: TaskState
 
@@ -137,7 +122,6 @@ export class Task {
 	// Callbacks
 	private updateTaskHistory: (historyItem: HistoryItem) => Promise<HistoryItem[]>
 	private postStateToWebview: () => Promise<void>
-	private postMessageToWebview: (message: ExtensionMessage) => Promise<void>
 	private reinitExistingTaskFromId: (taskId: string) => Promise<void>
 	private cancelTask: () => Promise<void>
 
@@ -154,7 +138,6 @@ export class Task {
 		workspaceTracker: WorkspaceTracker,
 		updateTaskHistory: (historyItem: HistoryItem) => Promise<HistoryItem[]>,
 		postStateToWebview: () => Promise<void>,
-		postMessageToWebview: (message: ExtensionMessage) => Promise<void>,
 		reinitExistingTaskFromId: (taskId: string) => Promise<void>,
 		cancelTask: () => Promise<void>,
 		apiConfiguration: ApiConfiguration,
@@ -166,6 +149,7 @@ export class Task {
 		terminalOutputLineLimit: number,
 		defaultTerminalProfile: string,
 		enableCheckpointsSetting: boolean,
+		cwd: string,
 		task?: string,
 		images?: string[],
 		files?: string[],
@@ -177,7 +161,6 @@ export class Task {
 		this.workspaceTracker = workspaceTracker
 		this.updateTaskHistory = updateTaskHistory
 		this.postStateToWebview = postStateToWebview
-		this.postMessageToWebview = postMessageToWebview
 		this.reinitExistingTaskFromId = reinitExistingTaskFromId
 		this.cancelTask = cancelTask
 		this.clineIgnoreController = new ClineIgnoreController(cwd)
@@ -196,6 +179,7 @@ export class Task {
 		this.browserSettings = browserSettings
 		this.chatSettings = chatSettings
 		this.enableCheckpoints = enableCheckpointsSetting
+		this.cwd = cwd
 
 		// Set up MCP notification callback for real-time notifications
 		this.mcpHub.setNotificationCallback(async (serverName: string, level: string, message: string) => {
@@ -295,7 +279,6 @@ export class Task {
 			this.taskState,
 			this.messageStateHandler,
 			this.api,
-			this.terminalManager,
 			this.urlContentFetcher,
 			this.browserSession,
 			this.diffViewProvider,
@@ -306,14 +289,11 @@ export class Task {
 			this.contextManager,
 			this.autoApprovalSettings,
 			this.browserSettings,
-			this.chatSettings,
 			cwd,
 			this.taskId,
 			this.say.bind(this),
 			this.ask.bind(this),
 			this.saveCheckpoint.bind(this),
-			this.reinitExistingTaskFromId.bind(this),
-			this.cancelTask.bind(this),
 			this.sayAndCreateMissingParamError.bind(this),
 			this.removeLastPartialMessageIfExistsWithType.bind(this),
 			this.executeCommandTool.bind(this),
@@ -1116,7 +1096,7 @@ export class Task {
 		const [taskResumptionMessage, userResponseMessage] = formatResponse.taskResumption(
 			this.chatSettings?.mode === "plan" ? "plan" : "act",
 			agoText,
-			cwd,
+			this.cwd,
 			wasRecent,
 			responseText,
 			hasPendingFileContextWarnings,
@@ -1347,7 +1327,7 @@ export class Task {
 			// Create a child process
 			const childProcess = execa(command, {
 				shell: true,
-				cwd,
+				cwd: this.cwd,
 				reject: false,
 				all: true, // Merge stdout and stderr
 			})
@@ -1424,7 +1404,7 @@ export class Task {
 		}
 		Logger.info("Executing command in VS code terminal: " + command)
 
-		const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd)
+		const terminalInfo = await this.terminalManager.getOrCreateTerminal(this.cwd)
 		terminalInfo.terminal.show() // weird visual bug when creating new terminals (even manually) where there's an empty space at the top.
 		const process = this.terminalManager.runCommand(terminalInfo, command)
 
@@ -1456,7 +1436,10 @@ export class Task {
 			try {
 				const { response, text, images, files } = await this.ask("command_output", chunk)
 				if (response === "yesButtonClicked") {
-					// proceed while running
+					// proceed while running - but still capture user feedback if provided
+					if (text || (images && images.length > 0) || (files && files.length > 0)) {
+						userFeedback = { text, images, files }
+					}
 				} else {
 					userFeedback = { text, images, files }
 				}
@@ -1597,7 +1580,7 @@ export class Task {
 		const supportsBrowserUse = modelSupportsBrowserUse && !disableBrowserTool // only enable browser use if the model supports it and the user hasn't disabled it
 
 		const isNextGenModel = isClaude4ModelFamily(this.api) || isGemini2dot5ModelFamily(this.api)
-		let systemPrompt = await SYSTEM_PROMPT(cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isNextGenModel)
+		let systemPrompt = await SYSTEM_PROMPT(this.cwd, supportsBrowserUse, this.mcpHub, this.browserSettings, isNextGenModel)
 
 		await this.migratePreferredLanguageToolSetting()
 		const preferredLanguage = getLanguageKey(this.chatSettings.preferredLanguage as LanguageDisplay)
@@ -1606,18 +1589,18 @@ export class Task {
 				? `# Preferred Language\n\nSpeak in ${preferredLanguage}.`
 				: ""
 
-		const { globalToggles, localToggles } = await refreshClineRulesToggles(this.getContext(), cwd)
-		const { windsurfLocalToggles, cursorLocalToggles } = await refreshExternalRulesToggles(this.getContext(), cwd)
+		const { globalToggles, localToggles } = await refreshClineRulesToggles(this.getContext(), this.cwd)
+		const { windsurfLocalToggles, cursorLocalToggles } = await refreshExternalRulesToggles(this.getContext(), this.cwd)
 
 		const globalClineRulesFilePath = await ensureRulesDirectoryExists()
 		const globalClineRulesFileInstructions = await getGlobalClineRules(globalClineRulesFilePath, globalToggles)
 
-		const localClineRulesFileInstructions = await getLocalClineRules(cwd, localToggles)
+		const localClineRulesFileInstructions = await getLocalClineRules(this.cwd, localToggles)
 		const [localCursorRulesFileInstructions, localCursorRulesDirInstructions] = await getLocalCursorRules(
-			cwd,
+			this.cwd,
 			cursorLocalToggles,
 		)
-		const localWindsurfRulesFileInstructions = await getLocalWindsurfRules(cwd, windsurfLocalToggles)
+		const localWindsurfRulesFileInstructions = await getLocalWindsurfRules(this.cwd, windsurfLocalToggles)
 
 		const clineIgnoreContent = this.clineIgnoreController.clineIgnoreContent
 		let clineIgnoreInstructions: string | undefined
@@ -1889,7 +1872,7 @@ export class Task {
 		}
 
 		// Used to know what models were used in the task if user wants to export metadata for error reporting purposes
-		const currentProviderId = (await getWorkspaceState(this.getContext(), "apiProvider")) as string
+		const currentProviderId = (await getGlobalState(this.getContext(), "apiProvider")) as string
 		if (currentProviderId && this.api.getModel().id) {
 			try {
 				await this.modelContextTracker.recordModelUsage(currentProviderId, this.api.getModel().id, this.chatSettings.mode)
@@ -1947,12 +1930,42 @@ export class Task {
 					message: `Cline has auto-approved ${this.autoApprovalSettings.maxRequests.toString()} API requests.`,
 				})
 			}
-			await this.ask(
+			const { response, text, images, files } = await this.ask(
 				"auto_approval_max_req_reached",
 				`Cline has auto-approved ${this.autoApprovalSettings.maxRequests.toString()} API requests. Would you like to reset the count and proceed with the task?`,
 			)
 			// if we get past the promise it means the user approved and did not start a new task
 			this.taskState.consecutiveAutoApprovedRequestsCount = 0
+
+			// Process user feedback if provided
+			if (response === "messageResponse") {
+				// Display the user's message in the chat UI
+				await this.say("user_feedback", text, images, files)
+
+				// This userContent is for the *next* API call.
+				const feedbackUserContent: UserContent = []
+				feedbackUserContent.push({
+					type: "text",
+					text: formatResponse.autoApprovalMaxReached(text),
+				})
+				if (images && images.length > 0) {
+					feedbackUserContent.push(...formatResponse.imageBlocks(images))
+				}
+
+				let fileContentString = ""
+				if (files && files.length > 0) {
+					fileContentString = await processFilesIntoText(files)
+				}
+
+				if (fileContentString) {
+					feedbackUserContent.push({
+						type: "text",
+						text: fileContentString,
+					})
+				}
+
+				userContent = feedbackUserContent
+			}
 		}
 
 		// get previous api req's index to check token usage and determine if we need to truncate conversation history
@@ -2343,7 +2356,7 @@ export class Task {
 		// Track if we need to check clinerulesFile
 		let needsClinerulesFileCheck = false
 
-		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(this.getContext(), cwd)
+		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(this.getContext(), this.cwd)
 
 		const processUserContent = async () => {
 			// This is a temporary solution to dynamically load context mentions from tool results. It checks for the presence of tags that indicate that the tool was rejected and feedback was provided (see formatToolDeniedFeedback, attemptCompletion, executeCommand, and consecutiveMistakeCount >= 3) or "<answer>" (see askFollowupQuestion), we place all user generated content in these tags so they can effectively be used as markers for when we should parse mentions). However if we allow multiple tools responses in the future, we will need to parse mentions specifically within the user content tags.
@@ -2361,7 +2374,7 @@ export class Task {
 						) {
 							const parsedText = await parseMentions(
 								block.text,
-								cwd,
+								this.cwd,
 								this.urlContentFetcher,
 								this.fileContextTracker,
 							)
@@ -2397,7 +2410,7 @@ export class Task {
 		// After processing content, check clinerulesData if needed
 		let clinerulesError = false
 		if (needsClinerulesFileCheck) {
-			clinerulesError = await ensureLocalClineDirExists(cwd, GlobalFileNames.clineRules)
+			clinerulesError = await ensureLocalClineDirExists(this.cwd, GlobalFileNames.clineRules)
 		}
 
 		// Return all results
@@ -2412,7 +2425,7 @@ export class Task {
 		const visibleFilePaths = vscode.window.visibleTextEditors
 			?.map((editor) => editor.document?.uri?.fsPath)
 			.filter(Boolean)
-			.map((absolutePath) => path.relative(cwd, absolutePath))
+			.map((absolutePath) => path.relative(this.cwd, absolutePath))
 
 		// Filter paths through clineIgnoreController
 		const allowedVisibleFiles = this.clineIgnoreController
@@ -2431,7 +2444,7 @@ export class Task {
 			.flatMap((group) => group.tabs)
 			.map((tab) => (tab.input as vscode.TabInputText)?.uri?.fsPath)
 			.filter(Boolean)
-			.map((absolutePath) => path.relative(cwd, absolutePath))
+			.map((absolutePath) => path.relative(this.cwd, absolutePath))
 
 		// Filter paths through clineIgnoreController
 		const allowedOpenTabs = this.clineIgnoreController
@@ -2557,16 +2570,22 @@ export class Task {
 		details += `\n\n# Current Time\n${formatter.format(now)} (${timeZone}, UTC${timeZoneOffsetStr})`
 
 		if (includeFileDetails) {
-			details += `\n\n# Current Working Directory (${cwd.toPosix()}) Files\n`
-			const isDesktop = arePathsEqual(cwd, path.join(os.homedir(), "Desktop"))
+			details += `\n\n# Current Working Directory (${this.cwd.toPosix()}) Files\n`
+			const isDesktop = arePathsEqual(this.cwd, getDesktopDir())
 			if (isDesktop) {
 				// don't want to immediately access desktop since it would show permission popup
 				details += "(Desktop files not shown automatically. Use list_files to explore if needed.)"
 			} else {
-				const [files, didHitLimit] = await listFiles(cwd, true, 200)
-				const result = formatResponse.formatFilesList(cwd, files, didHitLimit, this.clineIgnoreController)
+				const [files, didHitLimit] = await listFiles(this.cwd, true, 200)
+				const result = formatResponse.formatFilesList(this.cwd, files, didHitLimit, this.clineIgnoreController)
 				details += result
 			}
+
+			// Add git remote URLs section
+			const gitRemotes = await getGitRemoteUrls(this.cwd)
+			if (gitRemotes.length > 0) {
+				details += `\n\n# Git Remote URLs\n${gitRemotes.join("\n")}`
+			}
 		}
 
 		// Add context window usage information

src/core/task/message-state.ts

@@ -12,6 +12,7 @@ import CheckpointTracker from "@integrations/checkpoints/CheckpointTracker"
 import { HistoryItem } from "@/shared/HistoryItem"
 import Anthropic from "@anthropic-ai/sdk"
 import { TaskState } from "./TaskState"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 interface MessageStateHandlerParams {
 	context: vscode.ExtensionContext
@@ -21,8 +22,6 @@ interface MessageStateHandlerParams {
 	taskState: TaskState
 }
 
-const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop") // may or may not exist but fs checking existence would immediately ask for permission which would be bad UX, need to come up with a better solution
-
 export class MessageStateHandler {
 	private apiConversationHistory: Anthropic.MessageParam[] = []
 	private clineMessages: ClineMessage[] = []
@@ -84,6 +83,7 @@ export class MessageStateHandler {
 			} catch (error) {
 				console.error("Failed to get task directory size:", taskDir, error)
 			}
+			const cwd = await getCwd(getDesktopDir())
 			await this.updateTaskHistory({
 				id: this.taskId,
 				ts: lastRelevantMessage.ts,

src/core/task/tools/autoApprove.ts

@@ -1,11 +1,8 @@
 import { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
 import { ToolUseName } from "@core/assistant-message"
 import * as path from "path"
-import * as vscode from "vscode"
 import os from "os"
-
-export const cwd =
-	vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0) ?? path.join(os.homedir(), "Desktop")
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 export class AutoApprove {
 	autoApprovalSettings: AutoApprovalSettings
@@ -54,9 +51,10 @@ export class AutoApprove {
 	// Check if the tool should be auto-approved based on the settings
 	// and the path of the action. Returns true if the tool should be auto-approved
 	// based on the user's settings and the path of the action.
-	shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): boolean {
+	async shouldAutoApproveToolWithPath(blockname: ToolUseName, autoApproveActionpath: string | undefined): Promise<boolean> {
 		let isLocalRead: boolean = false
 		if (autoApproveActionpath) {
+			const cwd = await getCwd(getDesktopDir())
 			const absolutePath = path.resolve(cwd, autoApproveActionpath)
 			isLocalRead = absolutePath.startsWith(cwd)
 		} else {

src/core/webview/index.ts

@@ -165,8 +165,6 @@ export abstract class WebviewProvider {
 		// don't forget to add font-src ${webview.cspSource};
 		const codiconsUri = this.getExtensionUri("node_modules", "@vscode", "codicons", "dist", "codicon.css")
 
-		const katexCssUri = this.getExtensionUri("webview-ui", "node_modules", "katex", "dist", "katex.min.css")
-
 		// const scriptUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, "assets", "main.js"))
 
 		// const styleResetUri = webview.asWebviewUri(vscode.Uri.joinPath(this._extensionUri, "assets", "reset.css"))
@@ -198,7 +196,6 @@ export abstract class WebviewProvider {
 				<meta name="theme-color" content="#000000">
 				<link rel="stylesheet" type="text/css" href="${stylesUri}">
 				<link href="${codiconsUri}" rel="stylesheet" />
-				<link href="${katexCssUri}" rel="stylesheet" />
 				<meta http-equiv="Content-Security-Policy" content="default-src 'none';
 					connect-src https://*.posthog.com https://*.cline.bot https://*.firebaseauth.com https://*.firebaseio.com https://*.googleapis.com https://*.firebase.com; 
 					font-src ${this.getCspSource()} data:; 
@@ -274,9 +271,6 @@ export abstract class WebviewProvider {
 		const stylesUri = this.getExtensionUri("webview-ui", "build", "assets", "index.css")
 		const codiconsUri = this.getExtensionUri("node_modules", "@vscode", "codicons", "dist", "codicon.css")
 
-		// Get KaTeX resources
-		const katexCssUri = this.getExtensionUri("webview-ui", "node_modules", "katex", "dist", "katex.min.css")
-
 		const scriptEntrypoint = "src/main.tsx"
 		const scriptUri = `http://${localServerUrl}/${scriptEntrypoint}`
 
@@ -292,7 +286,7 @@ export abstract class WebviewProvider {
 
 		const csp = [
 			"default-src 'none'",
-			`font-src ${this.getCspSource()} data:`,
+			`font-src ${this.getCspSource()}`,
 			`style-src ${this.getCspSource()} 'unsafe-inline' https://* http://${localServerUrl} http://0.0.0.0:${localPort}`,
 			`img-src ${this.getCspSource()} https: data:`,
 			`script-src 'unsafe-eval' https://* http://${localServerUrl} http://0.0.0.0:${localPort} 'nonce-${nonce}'`,
@@ -309,7 +303,6 @@ export abstract class WebviewProvider {
 					<meta http-equiv="Content-Security-Policy" content="${csp.join("; ")}">
 					<link rel="stylesheet" type="text/css" href="${stylesUri}">
 					<link href="${codiconsUri}" rel="stylesheet" />
-					<link href="${katexCssUri}" rel="stylesheet" />
 					<title>Cline</title>
 				</head>
 				<body>

src/extension.ts

@@ -23,9 +23,10 @@ import { WebviewProviderType } from "./shared/webview/types"
 import { sendHistoryButtonClickedEvent } from "./core/controller/ui/subscribeToHistoryButtonClicked"
 import { sendAccountButtonClickedEvent } from "./core/controller/ui/subscribeToAccountButtonClicked"
 import {
-	migratePlanActGlobalToWorkspaceStorage,
+	migrateWorkspaceToGlobalStorage,
 	migrateCustomInstructionsToGlobalRules,
 	migrateModeFromWorkspaceStorageToControllerState,
+	migrateWelcomeViewCompleted,
 } from "./core/storage/state-migrations"
 
 import { sendFocusChatInputEvent } from "./core/controller/ui/subscribeToFocusChatInput"
@@ -34,6 +35,7 @@ import * as hostProviders from "@hosts/host-providers"
 import { vscodeHostBridgeClient } from "@/hosts/vscode/client/host-grpc-client"
 import { VscodeWebviewProvider } from "./core/webview/VscodeWebviewProvider"
 import { ExtensionContext } from "vscode"
+import { writeTextToClipboard, readTextFromClipboard } from "@/utils/env"
 
 /*
 Built using https://github.com/microsoft/vscode-webview-ui-toolkit
@@ -58,15 +60,18 @@ export async function activate(context: vscode.ExtensionContext) {
 
 	maybeSetupHostProviders(context)
 
-	// Migrate global storage values to workspace storage (one-time cleanup)
-	await migratePlanActGlobalToWorkspaceStorage(context)
-
 	// Migrate custom instructions to global Cline rules (one-time cleanup)
 	await migrateCustomInstructionsToGlobalRules(context)
 
 	// Migrate mode from workspace storage to controller state (one-time cleanup)
 	await migrateModeFromWorkspaceStorageToControllerState(context)
 
+	// Migrate welcomeViewCompleted setting based on existing API keys (one-time cleanup)
+	await migrateWelcomeViewCompleted(context)
+
+	// Migrate workspace storage values back to global storage (reverting previous migration)
+	await migrateWorkspaceToGlobalStorage(context)
+
 	// Clean up orphaned file context warnings (startup cleanup)
 	await FileContextTracker.cleanupOrphanedWarnings(context)
 
@@ -75,8 +80,9 @@ export async function activate(context: vscode.ExtensionContext) {
 	const previousVersion = context.globalState.get<string>("clineVersion")
 	const sidebarWebview = hostProviders.createWebviewProvider(WebviewProviderType.SIDEBAR)
 
+	const testModeWatchers = await initializeTestMode(sidebarWebview)
 	// Initialize test mode and add disposables to context
-	context.subscriptions.push(...initializeTestMode(context, sidebarWebview))
+	context.subscriptions.push(...testModeWatchers)
 
 	vscode.commands.executeCommand("setContext", "cline.isDevMode", IS_DEV && IS_DEV === "true")
 
@@ -369,17 +375,17 @@ export async function activate(context: vscode.ExtensionContext) {
 			}
 
 			// Save current clipboard content
-			const tempCopyBuffer = await vscode.env.clipboard.readText()
+			const tempCopyBuffer = await readTextFromClipboard()
 
 			try {
 				// Copy the *existing* terminal selection (without selecting all)
 				await vscode.commands.executeCommand("workbench.action.terminal.copySelection")
 
 				// Get copied content
-				let terminalContents = (await vscode.env.clipboard.readText()).trim()
+				let terminalContents = (await readTextFromClipboard()).trim()
 
 				// Restore original clipboard content
-				await vscode.env.clipboard.writeText(tempCopyBuffer)
+				await writeTextToClipboard(tempCopyBuffer)
 
 				if (!terminalContents) {
 					// No terminal content was copied (either nothing selected or some error)
@@ -405,7 +411,7 @@ export async function activate(context: vscode.ExtensionContext) {
 				await visibleWebview?.controller.addSelectedTerminalOutputToChat(terminalContents, terminal.name)
 			} catch (error) {
 				// Ensure clipboard is restored even if an error occurs
-				await vscode.env.clipboard.writeText(tempCopyBuffer)
+				await writeTextToClipboard(tempCopyBuffer)
 				console.error("Error getting terminal contents:", error)
 				vscode.window.showErrorMessage("Failed to get terminal contents")
 			}
@@ -638,6 +644,14 @@ export async function activate(context: vscode.ExtensionContext) {
 		}),
 	)
 
+	// Register the openWalkthrough command handler
+	context.subscriptions.push(
+		vscode.commands.registerCommand("cline.openWalkthrough", async () => {
+			await vscode.commands.executeCommand("workbench.action.openWalkthrough", "saoudrizwan.claude-dev#ClineWalkthrough")
+			telemetryService.captureButtonClick("command_openWalkthrough", undefined, true)
+		}),
+	)
+
 	// Register the generateGitCommitMessage command handler
 	context.subscriptions.push(
 		vscode.commands.registerCommand("cline.generateGitCommitMessage", async () => {

src/hosts/host-provider-types.ts

@@ -2,6 +2,8 @@ import {
 	UriServiceClientInterface,
 	WatchServiceClientInterface,
 	WorkspaceServiceClientInterface,
+	EnvServiceClientInterface,
+	WindowServiceClientInterface,
 } from "@generated/hosts/host-bridge-client-types"
 
 /**
@@ -11,6 +13,8 @@ export interface HostBridgeClientProvider {
 	uriServiceClient: UriServiceClientInterface
 	watchServiceClient: WatchServiceClientInterface
 	workspaceClient: WorkspaceServiceClientInterface
+	envClient: EnvServiceClientInterface
+	windowClient: WindowServiceClientInterface
 }
 
 /**

src/hosts/vscode/client/host-grpc-client.ts

@@ -6,4 +6,6 @@ export const vscodeHostBridgeClient: HostBridgeClientProvider = {
 	uriServiceClient: createGrpcClient(host.UriServiceDefinition),
 	watchServiceClient: createGrpcClient(host.WatchServiceDefinition),
 	workspaceClient: createGrpcClient(host.WorkspaceServiceDefinition),
+	envClient: createGrpcClient(host.EnvServiceDefinition),
+	windowClient: createGrpcClient(host.WindowServiceDefinition),
 }

src/hosts/vscode/env/clipboardReadText.ts

@@ -0,0 +1,7 @@
+import { EmptyRequest, String } from "@/shared/proto/common"
+import * as vscode from "vscode"
+
+export async function clipboardReadText(_: EmptyRequest): Promise<String> {
+	const text = await vscode.env.clipboard.readText()
+	return String.create({ value: text })
+}

src/hosts/vscode/env/clipboardWriteText.ts

@@ -0,0 +1,7 @@
+import { StringRequest, Empty } from "@/shared/proto/common"
+import * as vscode from "vscode"
+
+export async function clipboardWriteText(request: StringRequest): Promise<Empty> {
+	await vscode.env.clipboard.writeText(request.value)
+	return Empty.create({})
+}

src/hosts/vscode/window/showOpenDialogue.ts

@@ -0,0 +1,27 @@
+import * as vscode from "vscode"
+import { ShowOpenDialogueRequest, SelectedResources } from "@/shared/proto/host/window"
+
+export async function showOpenDialogue(request: ShowOpenDialogueRequest): Promise<SelectedResources> {
+	const options: vscode.OpenDialogOptions = {}
+
+	if (request.canSelectMany !== undefined) {
+		options.canSelectMany = request.canSelectMany
+	}
+
+	if (request.openLabel !== undefined) {
+		options.openLabel = request.openLabel
+	}
+
+	if (request.filters?.files) {
+		options.filters = {
+			Files: request.filters.files,
+		}
+	}
+
+	const selectedResources = await vscode.window.showOpenDialog(options)
+
+	// Convert back to path format
+	return SelectedResources.create({
+		paths: selectedResources ? selectedResources.map((uri) => uri.fsPath) : [],
+	})
+}

src/hosts/vscode/window/showTextDocument.ts

@@ -0,0 +1,26 @@
+import * as vscode from "vscode"
+import { ShowTextDocumentRequest, TextEditorInfo } from "@/shared/proto/host/window"
+
+export async function showTextDocument(request: ShowTextDocumentRequest): Promise<TextEditorInfo> {
+	// Convert file path to URI
+	const uri = vscode.Uri.file(request.path)
+	const options: vscode.TextDocumentShowOptions = {}
+
+	if (request.options?.preview !== undefined) {
+		options.preview = request.options.preview
+	}
+	if (request.options?.preserveFocus !== undefined) {
+		options.preserveFocus = request.options.preserveFocus
+	}
+	if (request.options?.viewColumn !== undefined) {
+		options.viewColumn = request.options.viewColumn
+	}
+
+	const editor = await vscode.window.showTextDocument(uri, options)
+
+	return TextEditorInfo.create({
+		documentPath: editor.document.uri.fsPath,
+		viewColumn: editor.viewColumn,
+		isActive: vscode.window.activeTextEditor === editor,
+	})
+}

src/integrations/checkpoints/Checkpoint-test-utils.ts.bak

@@ -1,73 +0,0 @@
-import * as vscode from "vscode"
-import fs from "fs/promises"
-import path from "path"
-import os from "os"
-import CheckpointTracker from "./CheckpointTracker"
-
-export async function createTestEnvironment() {
-    // Create temp directory structure
-    const tempDir = path.join(os.tmpdir(), `checkpoint-test-${Date.now()}`)
-    await fs.mkdir(tempDir, { recursive: true })
-
-    // Create storage path outside of working directory to avoid submodule issues
-    const globalStoragePath = path.join(os.tmpdir(), `storage-${Date.now()}`)
-    await fs.mkdir(globalStoragePath, { recursive: true })
-
-    // Create test file in a subdirectory
-    const testDir = path.join(tempDir, "src")
-    await fs.mkdir(testDir, { recursive: true })
-    const testFilePath = path.join(testDir, "test.txt")
-
-    // Create .gitignore to prevent git from treating directories as submodules
-    await fs.writeFile(path.join(tempDir, ".gitignore"), "storage/\n")
-
-    // Mock VS Code workspace
-    const mockWorkspaceFolders = [
-        {
-            uri: { fsPath: tempDir },
-            name: "test",
-            index: 0,
-        },
-    ]
-
-    const originalDescriptor = Object.getOwnPropertyDescriptor(vscode.workspace, "workspaceFolders")
-    Object.defineProperty(vscode.workspace, "workspaceFolders", {
-        get: () => mockWorkspaceFolders,
-    })
-
-    // Mock findFiles to return no nested git repos
-    const originalFindFiles = vscode.workspace.findFiles
-    vscode.workspace.findFiles = async () => []
-
-    // Mock VS Code configuration
-    const originalGetConfiguration = vscode.workspace.getConfiguration
-    vscode.workspace.getConfiguration = () =>
-        ({
-            get: (key: string) => (key === "enableCheckpoints" ? true : undefined),
-        }) as any
-
-    return {
-        tempDir,
-        globalStoragePath,
-        testFilePath,
-        originalDescriptor,
-        originalFindFiles,
-        originalGetConfiguration,
-        cleanup: async () => {
-            // Restore VS Code mocks
-            if (originalDescriptor) {
-                Object.defineProperty(vscode.workspace, "workspaceFolders", originalDescriptor)
-            }
-            vscode.workspace.getConfiguration = originalGetConfiguration
-            vscode.workspace.findFiles = originalFindFiles
-
-            // Clean up temp directories
-            await fs.rm(tempDir, { recursive: true, force: true })
-            await fs.rm(globalStoragePath, { recursive: true, force: true })
-        }
-    }
-}
-
-export async function createTestTracker(globalStoragePath?: string, taskId = "test-task-1") {
-    return await CheckpointTracker.create(taskId, globalStoragePath)
-}

src/integrations/checkpoints/CheckpointCommit.test.ts.bak

@@ -1,155 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import fs from "fs/promises"
-import path from "path"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-
-describe("Checkpoint Commit Operations", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-    })
-
-    it("should create commit with single file changes", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create initial file
-        await fs.writeFile(env.testFilePath, "initial content")
-
-        // Create first commit
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Modify file
-        await fs.writeFile(env.testFilePath, "modified content")
-
-        // Create second commit
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-        expect(secondCommit).to.not.equal(firstCommit)
-
-        // Verify commits are different
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].before).to.equal("initial content")
-        expect(diffSet[0].after).to.equal("modified content")
-    })
-
-    it("should create commit with multiple file changes", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create initial files with newlines
-        const testFile2Path = path.join(env.tempDir, "src", "test2.txt")
-        await fs.writeFile(env.testFilePath, "file1 initial\n")
-        await fs.writeFile(testFile2Path, "file2 initial\n")
-
-        // Create first commit
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Modify both files with newlines
-        await fs.writeFile(env.testFilePath, "file1 modified\n")
-        await fs.writeFile(testFile2Path, "file2 modified\n")
-
-        // Create second commit
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-        expect(secondCommit).to.not.equal(firstCommit)
-
-        // Get diff between commits
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(2)
-
-        // Sort diffSet by path for consistent ordering
-        const sortedDiffs = diffSet.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
-
-        // Verify file paths
-        expect(sortedDiffs[0].relativePath).to.equal("src/test.txt")
-        expect(sortedDiffs[1].relativePath).to.equal("src/test2.txt")
-
-        // Verify file contents
-        expect(sortedDiffs[0].before).to.equal("file1 initial\n")
-        expect(sortedDiffs[0].after).to.equal("file1 modified\n")
-        expect(sortedDiffs[1].before).to.equal("file2 initial\n")
-        expect(sortedDiffs[1].after).to.equal("file2 modified\n")
-    })
-
-    it("should create commit when files are deleted", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create and commit initial file
-        await fs.writeFile(env.testFilePath, "initial content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Delete file
-        await fs.unlink(env.testFilePath)
-
-        // Create second commit
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-        expect(secondCommit).to.not.equal(firstCommit)
-
-        // Verify file deletion was committed
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].before).to.equal("initial content")
-        expect(diffSet[0].after).to.equal("")
-    })
-
-    it("should create empty commit when no changes", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create and commit initial file
-        await fs.writeFile(env.testFilePath, "test content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Create commit without changes
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-        expect(secondCommit).to.not.equal(firstCommit)
-
-        // Verify no changes between commits
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(0)
-    })
-
-    it("should handle files in nested directories", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create nested directory structure
-        const nestedDir = path.join(env.tempDir, "src", "deep", "nested")
-        await fs.mkdir(nestedDir, { recursive: true })
-        const nestedFilePath = path.join(nestedDir, "nested.txt")
-
-        // Create and commit file in nested directory
-        await fs.writeFile(nestedFilePath, "nested content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Modify nested file
-        await fs.writeFile(nestedFilePath, "modified nested content")
-
-        // Create second commit
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-
-        // Verify changes were committed
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].relativePath).to.equal("src/deep/nested/nested.txt")
-        expect(diffSet[0].before).to.equal("nested content")
-        expect(diffSet[0].after).to.equal("modified nested content")
-    })
-})

src/integrations/checkpoints/CheckpointCreation.test.ts.bak

@@ -1,35 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-import CheckpointTracker from "./CheckpointTracker"
-
-describe("Checkpoint Creation", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-    })
-
-    it("should create a new checkpoint tracker", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        expect(tracker).to.not.be.undefined
-        expect(tracker).to.be.instanceOf(CheckpointTracker)
-
-        // Verify shadow git config
-        const configWorkTree = await tracker?.getShadowGitConfigWorkTree()
-        expect(configWorkTree).to.not.be.undefined
-    })
-
-    it("should throw error when globalStoragePath is missing", async () => {
-        try {
-            await createTestTracker(undefined)
-            expect.fail("Expected error was not thrown")
-        } catch (error: any) {
-            expect(error.message).to.equal("Global storage path is required to create a checkpoint tracker")
-        }
-    })
-})

src/integrations/checkpoints/CheckpointDiff.test.ts.bak

@@ -1,68 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import fs from "fs/promises"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-
-describe("Checkpoint Diff Operations", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-    })
-
-    it("should detect file changes between commits", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create initial file
-        await fs.writeFile(env.testFilePath, "initial content")
-
-        // Create first checkpoint
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.not.be.undefined
-
-        // Modify file
-        await fs.writeFile(env.testFilePath, "modified content")
-
-        // Create second checkpoint
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.not.be.undefined
-
-        // Get diff between commits
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-
-        // Verify diff results
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].relativePath).to.equal("src/test.txt")
-        expect(diffSet[0].before).to.equal("initial content")
-        expect(diffSet[0].after).to.equal("modified content")
-    })
-
-    it("should detect changes between commit and working directory", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create initial file
-        await fs.writeFile(env.testFilePath, "initial content")
-
-        // Create checkpoint
-        const commit = await tracker.commit()
-        expect(commit).to.not.be.undefined
-
-        // Modify file without committing
-        await fs.writeFile(env.testFilePath, "working directory changes")
-
-        // Get diff between commit and working directory
-        const diffSet = await tracker.getDiffSet(commit)
-
-        // Verify diff results
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].relativePath).to.equal("src/test.txt")
-        expect(diffSet[0].before).to.equal("initial content")
-        expect(diffSet[0].after).to.equal("working directory changes")
-    })
-})

src/integrations/checkpoints/CheckpointDisabled.test.ts.bak

@@ -1,94 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import fs from "fs/promises"
-import * as vscode from "vscode"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-
-describe("Checkpoint Disabled State", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-    let originalGetConfiguration: typeof vscode.workspace.getConfiguration
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-        originalGetConfiguration = vscode.workspace.getConfiguration
-
-        // Mock VS Code configuration to disable checkpoints
-        vscode.workspace.getConfiguration = () =>
-            ({
-                get: (key: string) => (key === "enableCheckpoints" ? false : undefined),
-            }) as any
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-        // Restore original configuration
-        vscode.workspace.getConfiguration = originalGetConfiguration
-    })
-
-    it("should return undefined when creating tracker", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        expect(tracker).to.be.undefined
-    })
-
-    it("should allow re-enabling checkpoints", async () => {
-        // First verify disabled state
-        const disabledTracker = await createTestTracker(env.globalStoragePath)
-        expect(disabledTracker).to.be.undefined
-
-        // Mock configuration to enable checkpoints
-        vscode.workspace.getConfiguration = () =>
-            ({
-                get: (key: string) => (key === "enableCheckpoints" ? true : undefined),
-            }) as any
-
-        // Verify tracker can be created when enabled
-        const enabledTracker = await createTestTracker(env.globalStoragePath)
-        expect(enabledTracker).to.not.be.undefined
-
-        // Verify operations work
-        if (!enabledTracker) {throw new Error("Failed to create tracker")}
-        await fs.writeFile(env.testFilePath, "test content")
-        const commit = await enabledTracker.commit()
-        expect(commit).to.be.a("string").and.not.empty
-    })
-
-    it("should prevent operations when disabled mid-session", async () => {
-        // Start with checkpoints enabled
-        vscode.workspace.getConfiguration = () =>
-            ({
-                get: (key: string) => (key === "enableCheckpoints" ? true : undefined),
-            }) as any
-
-        // Create tracker and initial commit
-        const tracker = await createTestTracker(env.globalStoragePath)
-        expect(tracker).to.not.be.undefined
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        await fs.writeFile(env.testFilePath, "initial content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.be.a("string").and.not.empty
-
-        // Disable checkpoints
-        vscode.workspace.getConfiguration = () =>
-            ({
-                get: (key: string) => (key === "enableCheckpoints" ? false : undefined),
-            }) as any
-
-        // Verify new tracker cannot be created
-        const disabledTracker = await createTestTracker(env.globalStoragePath)
-        expect(disabledTracker).to.be.undefined
-
-        // Verify existing tracker still works
-        // This is expected behavior since the tracker was created when enabled
-        await fs.writeFile(env.testFilePath, "modified content")
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.be.a("string").and.not.empty
-        expect(secondCommit).to.not.equal(firstCommit)
-
-        // Verify diffs still work on existing tracker
-        const diffSet = await tracker.getDiffSet(firstCommit, secondCommit)
-        expect(diffSet).to.have.lengthOf(1)
-        expect(diffSet[0].before).to.equal("initial content")
-        expect(diffSet[0].after).to.equal("modified content")
-    })
-})

src/integrations/checkpoints/CheckpointRevert.test.ts.bak

@@ -1,95 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import fs from "fs/promises"
-import path from "path"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-
-describe("Checkpoint Revert Operations", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-    })
-
-    it("should revert working directory to a previous checkpoint state", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create and commit initial state
-        await fs.writeFile(env.testFilePath, "initial content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.not.be.undefined
-
-        // Create and commit changes
-        await fs.writeFile(env.testFilePath, "modified content")
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.not.be.undefined
-
-        // Make more changes without committing
-        await fs.writeFile(env.testFilePath, "uncommitted changes")
-
-        // Revert to first commit
-        await tracker.resetHead(firstCommit!)
-
-        // Verify file content matches initial state
-        const resetContent = await fs.readFile(env.testFilePath, "utf8")
-        expect(resetContent).to.equal("initial content")
-    })
-
-    it("should handle reverting with multiple files", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create and commit initial state with multiple files
-        const testFile2Path = path.join(env.tempDir, "src", "test2.txt")
-        await fs.writeFile(env.testFilePath, "file1 initial")
-        await fs.writeFile(testFile2Path, "file2 initial")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.not.be.undefined
-
-        // Modify both files and commit
-        await fs.writeFile(env.testFilePath, "file1 modified")
-        await fs.writeFile(testFile2Path, "file2 modified")
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.not.be.undefined
-
-        // Make more changes
-        await fs.writeFile(env.testFilePath, "file1 uncommitted")
-        await fs.writeFile(testFile2Path, "file2 uncommitted")
-
-        // Reset to first commit
-        await tracker.resetHead(firstCommit!)
-
-        // Verify both files match initial state
-        const file1Content = await fs.readFile(env.testFilePath, "utf8")
-        const file2Content = await fs.readFile(testFile2Path, "utf8")
-        expect(file1Content).to.equal("file1 initial")
-        expect(file2Content).to.equal("file2 initial")
-    })
-
-    it("should handle reverting when files are deleted", async () => {
-        const tracker = await createTestTracker(env.globalStoragePath)
-        if (!tracker) {throw new Error("Failed to create tracker")}
-
-        // Create and commit initial state
-        await fs.writeFile(env.testFilePath, "initial content")
-        const firstCommit = await tracker.commit()
-        expect(firstCommit).to.not.be.undefined
-
-        // Delete file and commit
-        await fs.unlink(env.testFilePath)
-        const secondCommit = await tracker.commit()
-        expect(secondCommit).to.not.be.undefined
-
-        // Revert to first commit
-        await tracker.resetHead(firstCommit!)
-
-        // Verify file is restored with original content
-        const resetContent = await fs.readFile(env.testFilePath, "utf8")
-        expect(resetContent).to.equal("initial content")
-    })
-})

src/integrations/checkpoints/CheckpointTaskSwitch.test.ts.bak

@@ -1,120 +0,0 @@
-import { expect } from "chai"
-import { describe, it, beforeEach, afterEach } from "mocha"
-import fs from "fs/promises"
-import { createTestEnvironment, createTestTracker } from "./Checkpoint-test-utils"
-import { HistoryItem } from "../../shared/HistoryItem"
-import CheckpointTracker from "./CheckpointTracker"
-
-describe("Checkpoint Task Switching", () => {
-    let env: Awaited<ReturnType<typeof createTestEnvironment>>
-    let taskId1: string
-    let taskId2: string
-    let tracker1: CheckpointTracker | undefined
-    let tracker2: CheckpointTracker | undefined
-
-    beforeEach(async () => {
-        env = await createTestEnvironment()
-        taskId1 = "task-1"
-        taskId2 = "task-2"
-        tracker1 = await createTestTracker(env.globalStoragePath, taskId1)
-        if (!tracker1) {throw new Error("Failed to create tracker1")}
-    })
-
-    afterEach(async () => {
-        await env.cleanup()
-    })
-
-    it("should maintain separate history for each task", async () => {
-        if (!tracker1) {throw new Error("Failed to create tracker1")}
-        
-        // Create and commit file in first task
-        await fs.writeFile(env.testFilePath, "task1 initial")
-        const task1Commit1 = await tracker1.commit()
-        expect(task1Commit1).to.be.a("string").and.not.empty
-
-        // Modify and commit again in first task
-        await fs.writeFile(env.testFilePath, "task1 modified")
-        const task1Commit2 = await tracker1.commit()
-        expect(task1Commit2).to.be.a("string").and.not.empty
-
-        // Create second task tracker
-        tracker2 = await createTestTracker(env.globalStoragePath, taskId2)
-        if (!tracker2) {throw new Error("Failed to create tracker2")}
-
-        // Create and commit file in second task
-        await fs.writeFile(env.testFilePath, "task2 initial")
-        const task2Commit1 = await tracker2.commit()
-        expect(task2Commit1).to.be.a("string").and.not.empty
-
-        // Create another commit to establish history
-        await fs.writeFile(env.testFilePath, "task2 modified")
-        const task2Commit2 = await tracker2.commit()
-        expect(task2Commit2).to.be.a("string").and.not.empty
-
-        // Verify second task's history
-        const task2Diff = await tracker2.getDiffSet(task2Commit1, task2Commit2)
-        expect(task2Diff).to.have.lengthOf(1)
-        expect(task2Diff[0].before).to.equal("task2 initial")
-        expect(task2Diff[0].after).to.equal("task2 modified")
-
-        // Switch back to first task by creating new tracker
-        const tracker1Again = await createTestTracker(env.globalStoragePath, taskId1)
-        if (!tracker1Again) {throw new Error("Failed to create tracker1Again")}
-
-        // Verify first task's history is preserved
-        const task1Diff = await tracker1Again.getDiffSet(task1Commit1, task1Commit2)
-        expect(task1Diff[0].before).to.equal("task1 initial")
-        expect(task1Diff[0].after).to.equal("task1 modified")
-
-        // Reset first task to initial state
-        if (!task1Commit1) {throw new Error("Failed to create initial commit")}
-        await tracker1Again.resetHead(task1Commit1)
-        const resetContent = await fs.readFile(env.testFilePath, "utf8")
-        expect(resetContent).to.equal("task1 initial")
-    })
-
-    it("should handle task deletion and recreation", async () => {
-        if (!tracker1) {throw new Error("Failed to create tracker1")}
-
-        // Create and commit file in first task
-        await fs.writeFile(env.testFilePath, "task1 content")
-        const task1Commit = await tracker1.commit()
-        expect(task1Commit).to.be.a("string").and.not.empty
-
-        // Create second task
-        tracker2 = await createTestTracker(env.globalStoragePath, taskId2)
-        if (!tracker2) {throw new Error("Failed to create tracker2")}
-        await fs.writeFile(env.testFilePath, "task2 content")
-        const task2Commit = await tracker2.commit()
-        expect(task2Commit).to.be.a("string").and.not.empty
-
-        // Delete second task's checkpoints
-        const historyItem: HistoryItem = {
-            id: `test-${Date.now()}`,
-            ts: Date.now(),
-            task: taskId2,
-            shadowGitConfigWorkTree: env.tempDir,
-            tokensIn: 0,
-            tokensOut: 0,
-            totalCost: 0,
-        }
-        await CheckpointTracker.deleteCheckpoints(taskId2, historyItem, env.globalStoragePath)
-
-        // Recreate second task
-        const tracker2Again = await createTestTracker(env.globalStoragePath, taskId2)
-        if (!tracker2Again) {throw new Error("Failed to create tracker2Again")}
-
-        // Create new commit in recreated task
-        await fs.writeFile(env.testFilePath, "task2 new content")
-        const newCommit = await tracker2Again.commit()
-        expect(newCommit).to.be.a("string").and.not.empty
-
-        // Switch back to first task and verify its history is intact
-        const tracker1Again = await createTestTracker(env.globalStoragePath, taskId1)
-        if (!tracker1Again) {throw new Error("Failed to create tracker1Again")}
-        if (!task1Commit) {throw new Error("Failed to create initial commit")}
-        await tracker1Again.resetHead(task1Commit)
-        const resetContent = await fs.readFile(env.testFilePath, "utf8")
-        expect(resetContent).to.equal("task1 content")
-    })
-})

src/integrations/checkpoints/CheckpointTracker-old.ts

@@ -1,422 +0,0 @@
-import fs from "fs/promises"
-import os from "os"
-import * as path from "path"
-import simpleGit, { SimpleGit } from "simple-git"
-import * as vscode from "vscode"
-import { Controller as ClineProvider } from "@core/controller"
-import { fileExistsAtPath } from "@utils/fs"
-import { globby } from "globby"
-
-class CheckpointTracker {
-	private providerRef: WeakRef<ClineProvider>
-	private taskId: string
-	private disposables: vscode.Disposable[] = []
-	private cwd: string
-	private lastRetrievedShadowGitConfigWorkTree?: string
-	lastCheckpointHash?: string
-
-	private constructor(provider: ClineProvider, taskId: string, cwd: string) {
-		this.providerRef = new WeakRef(provider)
-		this.taskId = taskId
-		this.cwd = cwd
-	}
-
-	public static async create(
-		taskId: string,
-		enableCheckpointsSetting: boolean,
-		provider?: ClineProvider,
-	): Promise<CheckpointTracker | undefined> {
-		try {
-			if (!provider) {
-				throw new Error("Provider is required to create a checkpoint tracker")
-			}
-
-			if (!enableCheckpointsSetting) {
-				return undefined // Don't create tracker when disabled
-			}
-
-			// Check if git is installed by attempting to get version
-			try {
-				await simpleGit().version()
-			} catch (error) {
-				throw new Error("Git must be installed to use checkpoints.") // FIXME: must match what we check for in TaskHeader to show link
-			}
-
-			const cwd = await CheckpointTracker.getWorkingDirectory()
-			const newTracker = new CheckpointTracker(provider, taskId, cwd)
-			await newTracker.initShadowGit()
-			return newTracker
-		} catch (error) {
-			console.error("Failed to create CheckpointTracker:", error)
-			throw error
-		}
-	}
-
-	private static async getWorkingDirectory(): Promise<string> {
-		const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
-		if (!cwd) {
-			throw new Error("No workspace detected. Please open Cline in a workspace to use checkpoints.")
-		}
-		const homedir = os.homedir()
-		const desktopPath = path.join(homedir, "Desktop")
-		const documentsPath = path.join(homedir, "Documents")
-		const downloadsPath = path.join(homedir, "Downloads")
-
-		switch (cwd) {
-			case homedir:
-				throw new Error("Cannot use checkpoints in home directory")
-			case desktopPath:
-				throw new Error("Cannot use checkpoints in Desktop directory")
-			case documentsPath:
-				throw new Error("Cannot use checkpoints in Documents directory")
-			case downloadsPath:
-				throw new Error("Cannot use checkpoints in Downloads directory")
-			default:
-				return cwd
-		}
-	}
-
-	private async getShadowGitPath(): Promise<string> {
-		const globalStoragePath = this.providerRef.deref()?.context.globalStorageUri.fsPath
-		if (!globalStoragePath) {
-			throw new Error("Global storage uri is invalid")
-		}
-		const checkpointsDir = path.join(globalStoragePath, "tasks", this.taskId, "checkpoints")
-		await fs.mkdir(checkpointsDir, { recursive: true })
-		const gitPath = path.join(checkpointsDir, ".git")
-		return gitPath
-	}
-
-	public static async doesShadowGitExist(taskId: string, provider?: ClineProvider): Promise<boolean> {
-		const globalStoragePath = provider?.context.globalStorageUri.fsPath
-		if (!globalStoragePath) {
-			return false
-		}
-		const gitPath = path.join(globalStoragePath, "tasks", taskId, "checkpoints", ".git")
-		return await fileExistsAtPath(gitPath)
-	}
-
-	public async initShadowGit(): Promise<string> {
-		const gitPath = await this.getShadowGitPath()
-		if (await fileExistsAtPath(gitPath)) {
-			// Make sure it's the same cwd as the configured worktree
-			const worktree = await this.getShadowGitConfigWorkTree()
-			if (worktree !== this.cwd) {
-				throw new Error("Checkpoints can only be used in the original workspace: " + worktree)
-			}
-
-			return gitPath
-		} else {
-			const checkpointsDir = path.dirname(gitPath)
-			const git = simpleGit(checkpointsDir)
-			await git.init()
-
-			await git.addConfig("core.worktree", this.cwd) // sets the working tree to the current workspace
-
-			// Disable commit signing for shadow repo
-			await git.addConfig("commit.gpgSign", "false")
-
-			// Get LFS patterns from workspace if they exist
-			let lfsPatterns: string[] = []
-			try {
-				const attributesPath = path.join(this.cwd, ".gitattributes")
-				if (await fileExistsAtPath(attributesPath)) {
-					const attributesContent = await fs.readFile(attributesPath, "utf8")
-					lfsPatterns = attributesContent
-						.split("\n")
-						.filter((line) => line.includes("filter=lfs"))
-						.map((line) => line.split(" ")[0].trim())
-				}
-			} catch (error) {
-				console.warn("Failed to read .gitattributes:", error)
-			}
-
-			// Add basic excludes directly in git config, while respecting any .gitignore in the workspace
-			// .git/info/exclude is local to the shadow git repo, so it's not shared with the main repo - and won't conflict with user's .gitignore
-			// TODO: let user customize these
-			const excludesPath = path.join(gitPath, "info", "exclude")
-			await fs.mkdir(path.join(gitPath, "info"), { recursive: true })
-			await fs.writeFile(
-				excludesPath,
-				[
-					".git/", // ignore the user's .git
-					`.git${GIT_DISABLED_SUFFIX}/`, // ignore the disabled nested git repos
-					".DS_Store",
-					"*.log",
-					"node_modules/",
-					"__pycache__/",
-					"env/",
-					"venv/",
-					"target/dependency/",
-					"build/dependencies/",
-					"dist/",
-					"out/",
-					"bundle/",
-					"vendor/",
-					"tmp/",
-					"temp/",
-					"deps/",
-					"pkg/",
-					"Pods/",
-					// Media files
-					"*.jpg",
-					"*.jpeg",
-					"*.png",
-					"*.gif",
-					"*.bmp",
-					"*.ico",
-					// "*.svg",
-					"*.mp3",
-					"*.mp4",
-					"*.wav",
-					"*.avi",
-					"*.mov",
-					"*.wmv",
-					"*.webm",
-					"*.webp",
-					"*.m4a",
-					"*.flac",
-					// Build and dependency directories
-					"build/",
-					"bin/",
-					"obj/",
-					".gradle/",
-					".idea/",
-					".vscode/",
-					".vs/",
-					"coverage/",
-					".next/",
-					".nuxt/",
-					// Cache and temporary files
-					"*.cache",
-					"*.tmp",
-					"*.temp",
-					"*.swp",
-					"*.swo",
-					"*.pyc",
-					"*.pyo",
-					".pytest_cache/",
-					".eslintcache",
-					// Environment and config files
-					".env*",
-					"*.local",
-					"*.development",
-					"*.production",
-					// Large data files
-					"*.zip",
-					"*.tar",
-					"*.gz",
-					"*.rar",
-					"*.7z",
-					"*.iso",
-					"*.bin",
-					"*.exe",
-					"*.dll",
-					"*.so",
-					"*.dylib",
-					// Database files
-					"*.sqlite",
-					"*.db",
-					"*.sql",
-					// Log files
-					"*.logs",
-					"*.error",
-					"npm-debug.log*",
-					"yarn-debug.log*",
-					"yarn-error.log*",
-					...lfsPatterns,
-				].join("\n"),
-			)
-
-			// Set up git identity (git throws an error if user.name or user.email is not set)
-			await git.addConfig("user.name", "Cline Checkpoint")
-			await git.addConfig("user.email", "noreply@example.com")
-
-			await this.addAllFiles(git)
-			// Initial commit (--allow-empty ensures it works even with no files)
-			await git.commit("initial commit", { "--allow-empty": null })
-
-			return gitPath
-		}
-	}
-
-	public async getShadowGitConfigWorkTree(): Promise<string | undefined> {
-		if (this.lastRetrievedShadowGitConfigWorkTree) {
-			return this.lastRetrievedShadowGitConfigWorkTree
-		}
-		try {
-			const gitPath = await this.getShadowGitPath()
-			const git = simpleGit(path.dirname(gitPath))
-			const worktree = await git.getConfig("core.worktree")
-			this.lastRetrievedShadowGitConfigWorkTree = worktree.value || undefined
-			return this.lastRetrievedShadowGitConfigWorkTree
-		} catch (error) {
-			console.error("Failed to get shadow git config worktree:", error)
-			return undefined
-		}
-	}
-
-	public async commit(): Promise<string | undefined> {
-		try {
-			const gitPath = await this.getShadowGitPath()
-			const git = simpleGit(path.dirname(gitPath))
-			await this.addAllFiles(git)
-			const result = await git.commit("checkpoint", {
-				"--allow-empty": null,
-			})
-			const commitHash = result.commit || ""
-			this.lastCheckpointHash = commitHash
-			return commitHash
-		} catch (error) {
-			console.error("Failed to create checkpoint:", error)
-			return undefined
-		}
-	}
-
-	public async resetHead(commitHash: string): Promise<void> {
-		const gitPath = await this.getShadowGitPath()
-		const git = simpleGit(path.dirname(gitPath))
-
-		// Clean working directory and force reset
-		// This ensures that the operation will succeed regardless of:
-		// - Untracked files in the workspace
-		// - Staged changes
-		// - Unstaged changes
-		// - Partial commits
-		// - Merge conflicts
-		await git.clean("f", ["-d", "-f"]) // Remove untracked files and directories
-		await git.reset(["--hard", commitHash]) // Hard reset to target commit
-	}
-
-	/**
-	 * Return an array describing changed files between one commit and either:
-	 *   - another commit, or
-	 *   - the current working directory (including uncommitted changes).
-	 *
-	 * If `rhsHash` is omitted, compares `lhsHash` to the working directory.
-	 * If you want truly untracked files to appear, `git add` them first.
-	 *
-	 * @param lhsHash - The commit to compare from (older commit)
-	 * @param rhsHash - The commit to compare to (newer commit).
-	 *                  If omitted, we compare to the working directory.
-	 * @returns Array of file changes with before/after content
-	 */
-	public async getDiffSet(
-		lhsHash?: string,
-		rhsHash?: string,
-	): Promise<
-		Array<{
-			relativePath: string
-			absolutePath: string
-			before: string
-			after: string
-		}>
-	> {
-		const gitPath = await this.getShadowGitPath()
-		const git = simpleGit(path.dirname(gitPath))
-
-		// If lhsHash is missing, use the initial commit of the repo
-		let baseHash = lhsHash
-		if (!baseHash) {
-			const rootCommit = await git.raw(["rev-list", "--max-parents=0", "HEAD"])
-			baseHash = rootCommit.trim()
-		}
-
-		// Stage all changes so that untracked files appear in diff summary
-		await this.addAllFiles(git)
-
-		const diffSummary = rhsHash ? await git.diffSummary([`${baseHash}..${rhsHash}`]) : await git.diffSummary([baseHash])
-
-		// For each changed file, gather before/after content
-		const result = []
-		const cwdPath = (await this.getShadowGitConfigWorkTree()) || this.cwd || ""
-
-		for (const file of diffSummary.files) {
-			const filePath = file.file
-			const absolutePath = path.join(cwdPath, filePath)
-
-			let beforeContent = ""
-			try {
-				beforeContent = await git.show([`${baseHash}:${filePath}`])
-			} catch (_) {
-				// file didn't exist in older commit => remains empty
-			}
-
-			let afterContent = ""
-			if (rhsHash) {
-				// if user provided a newer commit, use git.show at that commit
-				try {
-					afterContent = await git.show([`${rhsHash}:${filePath}`])
-				} catch (_) {
-					// file didn't exist in newer commit => remains empty
-				}
-			} else {
-				// otherwise, read from disk (includes uncommitted changes)
-				try {
-					afterContent = await fs.readFile(absolutePath, "utf8")
-				} catch (_) {
-					// file might be deleted => remains empty
-				}
-			}
-
-			result.push({
-				relativePath: filePath,
-				absolutePath,
-				before: beforeContent,
-				after: afterContent,
-			})
-		}
-
-		return result
-	}
-
-	private async addAllFiles(git: SimpleGit) {
-		await this.renameNestedGitRepos(true)
-		try {
-			await git.add(".")
-		} catch (error) {
-			console.error("Failed to add files to git:", error)
-		} finally {
-			await this.renameNestedGitRepos(false)
-		}
-	}
-
-	// Since we use git to track checkpoints, we need to temporarily disable nested git repos to work around git's requirement of using submodules for nested repos.
-	private async renameNestedGitRepos(disable: boolean) {
-		// Find all .git directories that are not at the root level
-		const gitPaths = await globby("**/.git" + (disable ? "" : GIT_DISABLED_SUFFIX), {
-			cwd: this.cwd,
-			onlyDirectories: true,
-			ignore: [".git"], // Ignore root level .git
-			dot: true,
-			markDirectories: false,
-		})
-
-		// For each nested .git directory, rename it based on operation
-		for (const gitPath of gitPaths) {
-			const fullPath = path.join(this.cwd, gitPath)
-			let newPath: string
-			if (disable) {
-				newPath = fullPath + GIT_DISABLED_SUFFIX
-			} else {
-				newPath = fullPath.endsWith(GIT_DISABLED_SUFFIX) ? fullPath.slice(0, -GIT_DISABLED_SUFFIX.length) : fullPath
-			}
-
-			try {
-				await fs.rename(fullPath, newPath)
-				console.log(`CheckpointTracker ${disable ? "disabled" : "enabled"} nested git repo ${gitPath}`)
-			} catch (error) {
-				console.error(`CheckpointTracker failed to ${disable ? "disable" : "enable"} nested git repo ${gitPath}:`, error)
-			}
-		}
-	}
-
-	public dispose() {
-		this.disposables.forEach((d) => d.dispose())
-		this.disposables = []
-	}
-}
-
-const GIT_DISABLED_SUFFIX = "_disabled"
-
-export default CheckpointTracker

src/integrations/checkpoints/CheckpointUtils.ts

@@ -2,6 +2,7 @@ import { mkdir, access, constants } from "fs/promises"
 import * as path from "path"
 import * as vscode from "vscode"
 import os from "os"
+import { getCwd, getDesktopDir } from "@/utils/path"
 
 /**
  * Gets the path to the shadow Git repository in globalStorage.
@@ -45,7 +46,7 @@ export async function getShadowGitPath(globalStoragePath: string, taskId: string
  * @throws Error if no workspace is detected, if in a protected directory, or if no read access
  */
 export async function getWorkingDirectory(): Promise<string> {
-	const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
+	const cwd = await getCwd()
 	if (!cwd) {
 		throw new Error("No workspace detected. Please open Cline in a workspace to use checkpoints.")
 	}
@@ -60,7 +61,7 @@ export async function getWorkingDirectory(): Promise<string> {
 	}
 
 	const homedir = os.homedir()
-	const desktopPath = path.join(homedir, "Desktop")
+	const desktopPath = getDesktopDir()
 	const documentsPath = path.join(homedir, "Documents")
 	const downloadsPath = path.join(homedir, "Downloads")
 

src/integrations/claude-code/run.ts

@@ -1,16 +1,15 @@
-import * as vscode from "vscode"
+import { getCwd } from "@/utils/path"
 import type Anthropic from "@anthropic-ai/sdk"
 import { execa } from "execa"
-import { ClaudeCodeMessage } from "./types"
 import readline from "readline"
-
-const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
+import { ClaudeCodeMessage } from "./types"
 
 type ClaudeCodeOptions = {
 	systemPrompt: string
 	messages: Anthropic.Messages.MessageParam[]
 	path?: string
 	modelId?: string
+	thinkingBudgetTokens?: number
 }
 
 type ProcessState = {
@@ -21,7 +20,7 @@ type ProcessState = {
 }
 
 export async function* runClaudeCode(options: ClaudeCodeOptions): AsyncGenerator<ClaudeCodeMessage | string> {
-	const process = runProcess(options)
+	const process = runProcess(options, await getCwd())
 
 	const rl = readline.createInterface({
 		input: process.stdout,
@@ -76,6 +75,20 @@ export async function* runClaudeCode(options: ClaudeCodeOptions): AsyncGenerator
 				`Claude Code process exited with code ${exitCode}.${errorOutput ? ` Error output: ${errorOutput}` : ""}`,
 			)
 		}
+	} catch (err) {
+		// When the command fails, execa throws an error with the arguments, which include the whole system prompt.
+		// We want to log that, but not show it to the user.
+		console.error(`Error during Claude Code execution:`, err)
+		if (err instanceof Error) {
+			const startOfCommand = err.message.indexOf(": ")
+			if (startOfCommand !== -1) {
+				const messageWithoutCommand = err.message.slice(0, startOfCommand).trim()
+
+				throw new Error(messageWithoutCommand, { cause: err })
+			}
+		}
+
+		throw err
 	} finally {
 		rl.close()
 		if (!process.killed) {
@@ -106,13 +119,14 @@ const claudeCodeTools = [
 ].join(",")
 
 const CLAUDE_CODE_TIMEOUT = 600000 // 10 minutes
+// https://github.com/sindresorhus/execa/blob/main/docs/api.md#optionsmaxbuffer
+const BUFFER_SIZE = 20_000_000 // 20 MB
 
-function runProcess({ systemPrompt, messages, path, modelId }: ClaudeCodeOptions) {
-	const claudePath = path || "claude"
+function runProcess({ systemPrompt, messages, path, modelId, thinkingBudgetTokens }: ClaudeCodeOptions, cwd: string) {
+	const claudePath = path?.trim() || "claude"
 
 	const args = [
 		"-p",
-		JSON.stringify(messages),
 		"--system-prompt",
 		systemPrompt,
 		"--verbose",
@@ -129,19 +143,38 @@ function runProcess({ systemPrompt, messages, path, modelId }: ClaudeCodeOptions
 		args.push("--model", modelId)
 	}
 
-	return execa(claudePath, args, {
-		stdin: "ignore",
+	/**
+	 * @see {@link https://docs.anthropic.com/en/docs/claude-code/settings#environment-variables}
+	 */
+	const env: NodeJS.ProcessEnv = {
+		...process.env,
+		// Respect the user's environment variables but set defaults.
+		// The default is 32000. However, I've gotten larger responses.
+		CLAUDE_CODE_MAX_OUTPUT_TOKENS: process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS || "64000",
+		// Disable telemetry, auto-updater and error reporting.
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC || "1",
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: process.env.DISABLE_NON_ESSENTIAL_MODEL_CALLS || "1",
+		MAX_THINKING_TOKENS: (thinkingBudgetTokens || 0).toString(),
+	}
+
+	// We don't want to consume the user's ANTHROPIC_API_KEY,
+	// and will allow Claude Code to resolve auth by itself
+	delete env["ANTHROPIC_API_KEY"]
+
+	const claudeCodeProcess = execa(claudePath, args, {
+		stdin: "pipe",
 		stdout: "pipe",
 		stderr: "pipe",
-		env: {
-			...process.env,
-			// The default is 32000. However, I've gotten larger responses, so we increase it unless the user specified it.
-			CLAUDE_CODE_MAX_OUTPUT_TOKENS: process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS || "64000",
-		},
+		env,
 		cwd,
-		maxBuffer: 1024 * 1024 * 1000,
+		maxBuffer: BUFFER_SIZE,
 		timeout: CLAUDE_CODE_TIMEOUT,
 	})
+
+	claudeCodeProcess.stdin.write(JSON.stringify(messages))
+	claudeCodeProcess.stdin.end()
+
+	return claudeCodeProcess
 }
 
 function parseChunk(data: string, processState: ProcessState) {

src/integrations/editor/DiffViewProvider.ts

@@ -9,6 +9,8 @@ import * as diff from "diff"
 import { diagnosticsToProblemsString, getNewDiagnostics } from "../diagnostics"
 import { detectEncoding } from "../misc/extract-text"
 import * as iconv from "iconv-lite"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { ShowTextDocumentRequest, ShowTextDocumentOptions, TextEditorInfo } from "@/shared/proto/host/window"
 
 export const DIFF_VIEW_URI_SCHEME = "cline-diff"
 
@@ -236,10 +238,15 @@ export class DiffViewProvider {
 		// get text after save in case there is any auto-formatting done by the editor
 		const postSaveContent = updatedDocument.getText()
 
-		await vscode.window.showTextDocument(vscode.Uri.file(absolutePath), {
-			preview: false,
-			preserveFocus: true,
-		})
+		await getHostBridgeProvider().windowClient.showTextDocument(
+			ShowTextDocumentRequest.create({
+				path: absolutePath,
+				options: ShowTextDocumentOptions.create({
+					preview: false,
+					preserveFocus: true,
+				}),
+			}),
+		)
 		await this.closeAllDiffViews()
 
 		/*
@@ -337,10 +344,15 @@ export class DiffViewProvider {
 			await updatedDocument.save()
 			console.log(`File ${absolutePath} has been reverted to its original content.`)
 			if (this.documentWasOpen) {
-				await vscode.window.showTextDocument(vscode.Uri.file(absolutePath), {
-					preview: false,
-					preserveFocus: true,
-				})
+				await getHostBridgeProvider().windowClient.showTextDocument(
+					ShowTextDocumentRequest.create({
+						path: absolutePath,
+						options: ShowTextDocumentOptions.create({
+							preview: false,
+							preserveFocus: true,
+						}),
+					}),
+				)
 			}
 			await this.closeAllDiffViews()
 		}
@@ -376,9 +388,19 @@ export class DiffViewProvider {
 					arePathsEqual(tab.input.modified.fsPath, uri.fsPath),
 			)
 		if (diffTab && diffTab.input instanceof vscode.TabInputTextDiff) {
-			const editor = await vscode.window.showTextDocument(diffTab.input.modified, {
-				preserveFocus: true,
-			})
+			const editorInfo = await getHostBridgeProvider().windowClient.showTextDocument(
+				ShowTextDocumentRequest.create({
+					path: diffTab.input.modified.fsPath,
+					options: ShowTextDocumentOptions.create({
+						preserveFocus: true,
+					}),
+				}),
+			)
+			// Find the editor that matches the returned path
+			const editor = vscode.window.visibleTextEditors.find((e) => e.document.uri.fsPath === editorInfo.documentPath)
+			if (!editor) {
+				throw new Error("Failed to find opened text editor")
+			}
 			return editor
 		}
 		// Open new diff editor

src/integrations/git/commit-message-generator.ts

@@ -1,5 +1,8 @@
 import * as vscode from "vscode"
 import { getWorkingState } from "@utils/git"
+import { writeTextToClipboard } from "@utils/env"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { ShowTextDocumentRequest } from "@/shared/proto/host/window"
 
 /**
  * Formats the git diff into a prompt for the AI
@@ -57,7 +60,7 @@ export function extractCommitMessage(aiResponse: string): string {
  * @param message The commit message to copy
  */
 export async function copyCommitMessageToClipboard(message: string): Promise<void> {
-	await vscode.env.clipboard.writeText(message)
+	await writeTextToClipboard(message)
 	vscode.window.showInformationMessage("Commit message copied to clipboard")
 }
 
@@ -129,6 +132,10 @@ async function editCommitMessage(message: string): Promise<void> {
 		language: "markdown",
 	})
 
-	await vscode.window.showTextDocument(document)
+	await getHostBridgeProvider().windowClient.showTextDocument(
+		ShowTextDocumentRequest.create({
+			path: document.uri.fsPath,
+		}),
+	)
 	vscode.window.showInformationMessage("Edit the commit message and copy when ready")
 }

src/integrations/misc/export-markdown.ts

@@ -2,6 +2,8 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import os from "os"
 import * as path from "path"
 import * as vscode from "vscode"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { ShowTextDocumentRequest, ShowTextDocumentOptions } from "@/shared/proto/host/window"
 
 export async function downloadTask(dateTs: number, conversationHistory: Anthropic.MessageParam[]) {
 	// File name
@@ -38,7 +40,12 @@ export async function downloadTask(dateTs: number, conversationHistory: Anthropi
 		try {
 			// Write content to the selected location
 			await vscode.workspace.fs.writeFile(saveUri, new TextEncoder().encode(markdownContent))
-			vscode.window.showTextDocument(saveUri, { preview: true })
+			await getHostBridgeProvider().windowClient.showTextDocument(
+				ShowTextDocumentRequest.create({
+					path: saveUri.fsPath,
+					options: ShowTextDocumentOptions.create({ preview: true }),
+				}),
+			)
 		} catch (error) {
 			vscode.window.showErrorMessage(
 				`Failed to save markdown file: ${error instanceof Error ? error.message : String(error)}`,

src/integrations/misc/open-file.ts

@@ -2,6 +2,8 @@ import * as path from "path"
 import * as os from "os"
 import * as vscode from "vscode"
 import { arePathsEqual } from "@utils/path"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { ShowTextDocumentRequest, ShowTextDocumentOptions } from "@/shared/proto/host/window"
 
 export async function openImage(dataUri: string) {
 	const matches = dataUri.match(/^data:image\/([a-zA-Z]+);base64,(.+)$/)
@@ -42,7 +44,12 @@ export async function openFile(absolutePath: string) {
 		} catch {} // not essential, sometimes tab operations fail
 
 		const document = await vscode.workspace.openTextDocument(uri)
-		await vscode.window.showTextDocument(document, { preview: false })
+		await getHostBridgeProvider().windowClient.showTextDocument(
+			ShowTextDocumentRequest.create({
+				path: document.uri.fsPath,
+				options: ShowTextDocumentOptions.create({ preview: false }),
+			}),
+		)
 	} catch (error) {
 		vscode.window.showErrorMessage(`Could not open file!`)
 	}

src/integrations/misc/process-files.ts

@@ -2,6 +2,8 @@ import * as vscode from "vscode"
 import fs from "fs/promises"
 import * as path from "path"
 import sizeOf from "image-size"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
+import { ShowOpenDialogueRequest } from "@/shared/proto/host/window"
 
 /**
  * Supports processing of images and other file types
@@ -11,15 +13,17 @@ export async function selectFiles(imagesAllowed: boolean): Promise<{ images: str
 	const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "webp"] // supported by anthropic and openrouter
 	const OTHER_FILE_EXTENSIONS = ["xml", "json", "txt", "log", "md", "docx", "ipynb", "pdf", "xlsx", "csv"]
 
-	const options: vscode.OpenDialogOptions = {
-		canSelectMany: true,
-		openLabel: "Select",
-		filters: {
-			Files: imagesAllowed ? [...IMAGE_EXTENSIONS, ...OTHER_FILE_EXTENSIONS] : OTHER_FILE_EXTENSIONS,
-		},
-	}
+	const showDialogueResponse = await getHostBridgeProvider().windowClient.showOpenDialogue(
+		ShowOpenDialogueRequest.create({
+			canSelectMany: true,
+			openLabel: "Select",
+			filters: {
+				files: imagesAllowed ? [...IMAGE_EXTENSIONS, ...OTHER_FILE_EXTENSIONS] : OTHER_FILE_EXTENSIONS,
+			},
+		}),
+	)
 
-	const fileUris = await vscode.window.showOpenDialog(options)
+	const fileUris = showDialogueResponse.paths.map((path) => vscode.Uri.file(path))
 
 	if (!fileUris || fileUris.length === 0) {
 		return { images: [], files: [] }

src/integrations/notifications/index.ts

@@ -74,7 +74,7 @@ export async function showSystemNotification(options: NotificationOptions): Prom
 		const escapedOptions = {
 			...options,
 			title: title.replace(/"/g, '\\"'),
-			message: message.replace(/\\/g, "\\\\").replace(/"/g, '\\"'),
+			message: message.replace(/"/g, '\\"'),
 			subtitle: options.subtitle?.replace(/"/g, '\\"') || "",
 		}
 

src/integrations/terminal/TerminalProcess.test.ts

@@ -60,7 +60,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 			const emitSpy = sandbox.spy(process, "emit")
 
 			// Run a simple command
-			await process.run(terminal, "echo test")
+			const runPromise = process.run(terminal, "echo test")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
 
 			// Verify that the continue event was emitted
 			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
@@ -76,7 +83,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 			const emitSpy = sandbox.spy(process, "emit")
 
 			// Run a command that produces predictable output
-			await process.run(terminal, "echo 'Line 1' && echo 'Line 2'")
+			const runPromise = process.run(terminal, "echo 'Line 1' && echo 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
 
 			// Check that the events were emitted
 			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
@@ -92,7 +106,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 			const emitSpy = sandbox.spy(process, "emit")
 
 			// Run a command that lists files
-			await process.run(terminal, "ls -la")
+			const runPromise = process.run(terminal, "ls -la")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
 
 			// Verify that the continue event was emitted
 			;(emitSpy as sinon.SinonSpy).calledWith("continue").should.be.true()
@@ -130,7 +151,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 			const emitSpy = sandbox.spy(process, "emit")
 
 			// Run a command that produces predictable output
-			await process.run(terminal, "echo 'Line 1' 'Line 2'")
+			const runPromise = process.run(terminal, "echo 'Line 1' 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
 
 			// Check that the events were emitted
 			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
@@ -146,7 +174,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 			const emitSpy = sandbox.spy(process, "emit")
 
 			// Run a command that produces predictable output
-			await process.run(terminal, "echo \"Line 1\" && echo 'Line 2'")
+			const runPromise = process.run(terminal, "echo \"Line 1\" && echo 'Line 2'")
+
+			// If terminal doesn't have shell integration, advance timer
+			if (!terminal.shellIntegration) {
+				await sandbox.clock.tickAsync(3000)
+			}
+
+			await runPromise
 
 			// Check that the events were emitted
 			;(emitSpy as sinon.SinonSpy).calledWith("completed").should.be.true()
@@ -169,8 +204,14 @@ describe("TerminalProcess (Integration Tests)", () => {
 		// Spy on the emit function to verify events
 		const emitSpy = sandbox.spy(process, "emit")
 
-		// Run the command
-		await process.run(terminal, "test-command")
+		// Run the command - this returns a promise
+		const runPromise = process.run(terminal, "test-command")
+
+		// Advance the fake timer by 3 seconds to trigger the setTimeout
+		await sandbox.clock.tickAsync(3000)
+
+		// Now wait for the promise to resolve
+		await runPromise
 
 		// Check that the correct methods were called and events emitted
 		sendTextStub.calledWith("test-command", true).should.be.true()

src/integrations/terminal/TerminalProcess.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from "events"
 import { stripAnsi } from "./ansiUtils"
 import * as vscode from "vscode"
 import { Logger } from "@services/logging/Logger"
+import { getLatestTerminalOutput } from "./get-latest-output"
 
 export interface TerminalProcessEvents {
 	line: [line: string]
@@ -31,6 +32,19 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 	// 	super()
 
 	async run(terminal: vscode.Terminal, command: string) {
+		// When command does not produce any output, we can assume the shell integration API failed and as a fallback return the current terminal contents
+		const emitCurrentTerminalContents = async () => {
+			try {
+				const terminalSnapshot = await getLatestTerminalOutput()
+				if (terminalSnapshot && terminalSnapshot.trim()) {
+					const fallbackMessage = `The command's output could not be captured due to some technical issue, however it has been executed successfully. Here's the current terminal's content to help you get the command's output:\n\n${terminalSnapshot}`
+					this.emit("line", fallbackMessage)
+				}
+			} catch (error) {
+				console.error("Error capturing terminal output:", error)
+			}
+		}
+
 		// Clear any existing grace period timer from previous commands
 		if (this.gracePeriodTimer) {
 			clearTimeout(this.gracePeriodTimer)
@@ -249,7 +263,8 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 				if (!didEmitEmptyLine) {
 					console.log(`[TerminalProcess] Emitting fallback empty line for no-output command`)
 					this.emit("line", "") // empty line to show proceed button
-					this.emit("line", "[Command completed with no output]")
+					// this.emit("line", "[Command completed with no output]")
+					await emitCurrentTerminalContents()
 					didEmitEmptyLine = true
 				}
 			}
@@ -295,7 +310,8 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 				console.log(`[TerminalProcess] WARNING: Process completed but no output was captured`)
 				// Ensure we emit at least one line for UI feedback
 				if (!didEmitEmptyLine) {
-					this.emit("line", "[Command completed silently]")
+					// this.emit("line", "[Command completed silently]")
+					await emitCurrentTerminalContents()
 				}
 			}
 
@@ -314,7 +330,14 @@ export class TerminalProcess extends EventEmitter<TerminalProcessEvents> {
 				this.startGracePeriod()
 			}
 		} else {
+			// no shell integration detected, we'll fallback to running the command and capturing the terminal's output after some time
 			terminal.sendText(command, true)
+
+			// wait 3 seconds for the command to run
+			await new Promise((resolve) => setTimeout(resolve, 3000))
+
+			// For terminals without shell integration, also try to capture terminal content
+			await emitCurrentTerminalContents()
 			// For terminals without shell integration, we can't know when the command completes
 			// So we'll just emit the continue event after a delay
 			this.emit("completed")

src/integrations/terminal/get-latest-output.ts

@@ -1,4 +1,5 @@
 import * as vscode from "vscode"
+import { readTextFromClipboard, writeTextToClipboard } from "@utils/env"
 
 /**
  * Gets the contents of the active terminal
@@ -6,7 +7,7 @@ import * as vscode from "vscode"
  */
 export async function getLatestTerminalOutput(): Promise<string> {
 	// Store original clipboard content to restore later
-	const originalClipboard = await vscode.env.clipboard.readText()
+	const originalClipboard = await readTextFromClipboard()
 
 	try {
 		// Select terminal content
@@ -19,7 +20,7 @@ export async function getLatestTerminalOutput(): Promise<string> {
 		await vscode.commands.executeCommand("workbench.action.terminal.clearSelection")
 
 		// Get terminal contents from clipboard
-		let terminalContents = (await vscode.env.clipboard.readText()).trim()
+		let terminalContents = (await readTextFromClipboard()).trim()
 
 		// Check if there's actually a terminal open
 		if (terminalContents === originalClipboard) {
@@ -40,6 +41,6 @@ export async function getLatestTerminalOutput(): Promise<string> {
 		return terminalContents
 	} finally {
 		// Restore original clipboard content
-		await vscode.env.clipboard.writeText(originalClipboard)
+		await writeTextToClipboard(originalClipboard)
 	}
 }

src/integrations/workspace/WorkspaceTracker.ts

@@ -2,13 +2,22 @@ import * as vscode from "vscode"
 import * as path from "path"
 import { listFiles } from "@services/glob/list-files"
 import { sendWorkspaceUpdateEvent } from "@core/controller/file/subscribeToWorkspaceUpdates"
-
-const cwd = vscode.workspace.workspaceFolders?.map((folder) => folder.uri.fsPath).at(0)
+import { getCwd } from "@/utils/path"
 
 // Note: this is not a drop-in replacement for listFiles at the start of tasks, since that will be done for Desktops when there is no workspace selected
 class WorkspaceTracker {
 	private disposables: vscode.Disposable[] = []
 	private filePaths: Set<string> = new Set()
+	private cwd: string = ""
+
+	constructor() {
+		this.initializeCwd()
+		this.registerListeners()
+	}
+
+	private async initializeCwd() {
+		this.cwd = await getCwd()
+	}
 
 	private get activeFiles() {
 		return new Set(
@@ -18,16 +27,12 @@ class WorkspaceTracker {
 		)
 	}
 
-	constructor() {
-		this.registerListeners()
-	}
-
 	async populateFilePaths() {
 		// should not auto get filepaths for desktop since it would immediately show permission popup before cline ever creates a file
-		if (!cwd) {
+		if (!this.cwd) {
 			return
 		}
-		const [files, _] = await listFiles(cwd, true, 1_000)
+		const [files, _] = await listFiles(this.cwd, true, 1_000)
 		files.forEach((file) => this.filePaths.add(this.normalizeFilePath(file)))
 		this.workspaceDidUpdate()
 	}
@@ -91,18 +96,18 @@ class WorkspaceTracker {
 	}
 
 	private async workspaceDidUpdate() {
-		if (!cwd) {
+		if (!this.cwd) {
 			return
 		}
 		const filePaths = Array.from(new Set([...this.activeFiles, ...this.filePaths])).map((file) => {
-			const relativePath = path.relative(cwd, file).toPosix()
+			const relativePath = path.relative(this.cwd, file).toPosix()
 			return file.endsWith("/") ? relativePath + "/" : relativePath
 		})
 		await sendWorkspaceUpdateEvent(filePaths)
 	}
 
 	private normalizeFilePath(filePath: string): string {
-		const resolvedPath = cwd ? path.resolve(cwd, filePath) : path.resolve(filePath)
+		const resolvedPath = this.cwd ? path.resolve(this.cwd, filePath) : path.resolve(filePath)
 		return filePath.endsWith("/") ? resolvedPath + "/" : resolvedPath
 	}
 

src/integrations/workspace/get-python-env.ts

@@ -1,42 +0,0 @@
-import * as vscode from "vscode"
-
-/*
-Used to get user's current python environment (unnecessary now that we use the IDE's terminal)
-${await (async () => {
-		try {
-			const pythonEnvPath = await getPythonEnvPath()
-			if (pythonEnvPath) {
-				return `\nPython Environment: ${pythonEnvPath}`
-			}
-		} catch {}
-		return ""
-	})()}
-*/
-export async function getPythonEnvPath(): Promise<string | undefined> {
-	const pythonExtension = vscode.extensions.getExtension("ms-python.python")
-
-	if (!pythonExtension) {
-		return undefined
-	}
-
-	// Ensure the Python extension is activated
-	if (!pythonExtension.isActive) {
-		// if the python extension is not active, we can assume the project is not a python project
-		return undefined
-	}
-
-	// Access the Python extension API
-	const pythonApi = pythonExtension.exports
-	// Get the active environment path for the current workspace
-	const workspaceFolder = vscode.workspace.workspaceFolders?.[0]
-	if (!workspaceFolder) {
-		return undefined
-	}
-	// Get the active python environment path for the current workspace
-	const pythonEnv = await pythonApi?.environments?.getActiveEnvironmentPath(workspaceFolder.uri)
-	if (pythonEnv && pythonEnv.path) {
-		return pythonEnv.path
-	} else {
-		return undefined
-	}
-}

src/services/account/ClineAccountService.ts

@@ -4,14 +4,9 @@ import { ExtensionMessage } from "@shared/ExtensionMessage"
 
 export class ClineAccountService {
 	private readonly baseUrl = "https://api.cline.bot/v1"
-	private postMessageToWebview: (message: ExtensionMessage) => Promise<void>
 	private getClineApiKey: () => Promise<string | undefined>
 
-	constructor(
-		postMessageToWebview: (message: ExtensionMessage) => Promise<void>,
-		getClineApiKey: () => Promise<string | undefined>,
-	) {
-		this.postMessageToWebview = postMessageToWebview
+	constructor(getClineApiKey: () => Promise<string | undefined>) {
 		this.getClineApiKey = getClineApiKey
 	}
 

src/services/mcp/McpHub.ts

@@ -139,7 +139,6 @@ export class McpHub {
 		console.log("[DEBUG] subscribing to mcp file changes")
 		const cancelSubscription = getHostBridgeProvider().watchServiceClient.subscribeToFile(
 			SubscribeToFileRequest.create({
-				metadata: Metadata.create({}),
 				path: settingsPath,
 			}),
 			{

src/services/test/GitHelper.ts

@@ -1,33 +1,6 @@
 import * as path from "path"
-import * as vscode from "vscode"
 import { execa } from "execa"
 import { Logger } from "@services/logging/Logger"
-import { WebviewProvider } from "@core/webview"
-
-/**
- * Gets a valid workspace path for Git operations
- * @param visibleWebview The visible webview instance
- * @returns A valid workspace path
- */
-export function getWorkspacePath(visibleWebview: WebviewProvider): string {
-	// First try to get the path from the controller's state
-	let workspacePath = visibleWebview.controller.context.workspaceState.get<string>("cwd") || ""
-
-	// If workspace path is empty, try to get it from the active workspace folder
-	if (!workspacePath) {
-		const workspaceFolders = vscode.workspace.workspaceFolders
-		if (workspaceFolders && workspaceFolders.length > 0) {
-			workspacePath = workspaceFolders[0].uri.fsPath
-			Logger.log(`Using workspace folder path: ${workspacePath}`)
-		} else {
-			// If no workspace folder is open, use the extension directory as a fallback
-			workspacePath = path.join(__dirname, "..", "..", "..")
-			Logger.log(`No workspace folder found, using extension directory: ${workspacePath}`)
-		}
-	}
-
-	return workspacePath
-}
 
 /**
  * Validates that the workspace path is valid and writable for Git operations
@@ -42,7 +15,7 @@ export async function validateWorkspacePath(workspacePath: string): Promise<void
 
 	// Check if the directory exists
 	try {
-		const { stdout } = await execa("test", ["-d", workspacePath])
+		await execa("test", ["-d", workspacePath])
 	} catch (error) {
 		throw new Error(`Workspace path does not exist or is not a directory: ${workspacePath}`)
 	}

src/services/test/TestMode.ts

@@ -8,6 +8,7 @@ import * as fs from "fs"
 import * as path from "path"
 import { Logger } from "../logging/Logger"
 import { createTestServer, shutdownTestServer } from "./TestServer"
+import { getHostBridgeProvider } from "@/hosts/host-providers"
 
 // State variable
 let isTestMode = false
@@ -31,13 +32,13 @@ export function isInTestMode(): boolean {
 /**
  * Check if we're in test mode by looking for evals.env file in workspace folders
  */
-function checkForTestMode(): boolean {
+async function checkForTestMode(): Promise<boolean> {
 	// Get all workspace folders
-	const workspaceFolders = vscode.workspace.workspaceFolders || []
+	const workspaceFolders = await getHostBridgeProvider().workspaceClient.getWorkspacePaths({})
 
 	// Check each workspace folder for an evals.env file
-	for (const folder of workspaceFolders) {
-		const evalsEnvPath = path.join(folder.uri.fsPath, "evals.env")
+	for (const folder of workspaceFolders.paths) {
+		const evalsEnvPath = path.join(folder, "evals.env")
 		if (fs.existsSync(evalsEnvPath)) {
 			Logger.log(`Found evals.env file at ${evalsEnvPath}, activating test mode`)
 			return true
@@ -49,14 +50,13 @@ function checkForTestMode(): boolean {
 
 /**
  * Initialize test mode detection and setup file watchers
- * @param context VSCode extension context
  * @param webviewProvider The webview provider instance
  */
-export function initializeTestMode(context: vscode.ExtensionContext, webviewProvider?: any): vscode.Disposable[] {
+export async function initializeTestMode(webviewProvider?: any): Promise<vscode.Disposable[]> {
 	const disposables: vscode.Disposable[] = []
 
 	// Check if we're in test mode
-	const IS_TEST = checkForTestMode()
+	const IS_TEST = await checkForTestMode()
 
 	// Set test mode state for other parts of the code
 	if (IS_TEST) {