return the clineenv api base url

* Dismiss onboarding after login

* add visual feedback when loading

* await the login

.clinerules/cli.md

@@ -1,33 +0,0 @@
-# CLI Development
-
-The CLI lives in `cli/` and uses React Ink for terminal UI.
-
-- If needed, look at `cli/src/constants/colors.ts` for re-used terminal colors, e.g. `COLORS.primaryBlue` highlight color (selections, spinners, success states).
-- Never use `dimColor` with gray (e.g. `<Text color="gray" dimColor>`) - it's too hard to read. Use `color="gray"` for secondary text and normal foreground (no color) for primary text.
-- When thinking about how to handle state or messages from core, look at webview for how it communicates with the vs code extension.
-- When updating the webview, consider and suggest to the user to update the CLI TUI since we want to provide a similar experience to our terminal users as we do our vs code extension users.
-
-## Adding New API Providers
-
-When adding a new API provider to the extension, you must also update the CLI:
-
-1. **Update `cli/src/components/ModelPicker.tsx`**: Add the provider to the `providerModels` map so `getDefaultModelId()` returns the correct default model. Import the models and default ID from `@shared/api`:
-   ```typescript
-   import { newProviderDefaultModelId, newProviderModels } from "@/shared/api"
-
-   export const providerModels = {
-     // ...existing providers
-     "new-provider": { models: newProviderModels, defaultId: newProviderDefaultModelId },
-   }
-   ```
-
-2. **Use `applyProviderConfig()` for auth flows**: When implementing OAuth or other auth flows for the provider, use the shared utility at `cli/src/utils/provider-config.ts`:
-   ```typescript
-   import { applyProviderConfig } from "../utils/provider-config"
-
-   // After successful auth:
-   await applyProviderConfig({ providerId: "new-provider", controller })
-   ```
-   This handles setting provider, default model, API key mapping, state persistence, and rebuilding the API handler.
-
-3. **Provider-specific auth**: If the provider uses OAuth (like `openai-codex`), add handling in `SettingsPanelContent.tsx`'s `handleProviderSelect` callback. See the existing Codex OAuth flow as a reference.

.clinerules/debug-harness.md

@@ -0,0 +1,121 @@
+# Debug Harness
+
+HTTP-controlled debugger for the VSCode extension at `src/dev/debug-harness/server.ts`.
+
+## Quick start
+
+```bash
+# Build extension first if needed (protos + esbuild):
+npm run protos && IS_DEV=true node esbuild.mjs
+
+# Launch (skip-build if already built):
+npx tsx src/dev/debug-harness/server.ts --skip-build --auto-launch
+
+# In another terminal:
+curl localhost:19229/api -d '{"method":"status"}'
+```
+
+## Data Isolation
+
+The debugee runs with `CLINE_DIR=~/.cline2` by default, separate from your real `~/.cline`.
+This prevents the debugee's logout from logging out the debugger, and vice versa.
+Override with `--cline-dir /tmp/test-dir`. Check with `status()` → `clineDir`.
+
+## Browser Capture & OAuth
+
+The debugee runs with `CLINE_CAPTURE_BROWSER=1`, which intercepts `openExternal()` in
+`src/utils/env.ts`. URLs are captured instead of opening a real browser:
+
+- Logged to `$CLINE_DIR/data/debug-captured-urls.jsonl`
+- POSTed in real-time to `/captured-url` on the harness server
+- Queryable via `oauth.captured_urls`
+
+### OAuth API
+
+- **`oauth.captured_urls`** `{clear?}` — URLs the debugee tried to open
+- **`oauth.read_stored_token`** — Check auth token presence in secrets.json
+- **`oauth.simulate_callback`** `{path, code?, state?, provider?, token?}` — Build vscode:// callback URI
+- **`oauth.read_captured_urls_file`** — Read on-disk JSONL of captured URLs
+
+### OAuth testing flow
+
+For **Cline OAuth** (SDK local callback): The SDK starts a local HTTP server, the auth URL
+is captured. To complete: open the captured URL in a real browser (it redirects back to the
+SDK's callback server), OR extract the callback port and `curl http://127.0.0.1:PORT/callback?code=...`.
+
+For **MCP/Provider OAuth** (vscode:// URI): The redirect goes to a vscode:// URI. Use
+`oauth.simulate_callback` to build it, then inject via `ext.evaluate` calling the URI handler.
+
+## Navigating Views — Use Commands, Not Clicks
+
+Don't try to find/click small sidebar icons. Use VSCode commands via command palette.
+Registered in `src/registry.ts`:
+
+| Command | View |
+|---------|------|
+| `cline.accountButtonClicked` | Account / sign-in |
+| `cline.historyButtonClicked` | Task history |
+| `cline.settingsButtonClicked` | Settings |
+| `cline.mcpButtonClicked` | MCP servers |
+| `cline.plusButtonClicked` | New task (chat) |
+| `cline.worktreesButtonClicked` | Worktrees |
+
+```bash
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+```
+
+## Key commands
+
+All via `POST localhost:19229/api` with `{"method":"...", "params":{...}}`:
+
+- **`launch`** / **`shutdown`** — lifecycle
+- **`ui.screenshot`** — screenshot to `/tmp/cline-debug/`; returns `{path}` — **use `read_file` on the path to examine, do NOT `open` the file** (Preview.app covers the VSCode window)
+- **`ui.open_sidebar`** — open the Cline sidebar
+- **`ext.set_breakpoint`** `{file, line, condition?}` — breakpoint by source file (sourcemap-resolved)
+- **`ext.evaluate`** `{expression, callFrameId?}` — eval in extension host
+- **`ext.resume`** / **`ext.step_over`** / **`ext.step_into`** — stepping
+- **`ext.call_stack`** — inspect when paused
+- **`web.evaluate`** `{expression}` — eval in webview
+- **`web.post_message`** `{message}` — send postMessage to extension host via exposed vsCodeApi
+- **`wait_for_pause`** `{timeout?}` — block until breakpoint hit
+- **`ui.locator`** `{role?, testId?, text?, frame?}` — Playwright locator (auto-retries on stale sidebar frame)
+- **`ui.react_input`** `{text, selector?, clear?, submit?}` — set React textarea value via `execCommand('insertText')`; works reliably across multiple tasks
+- **`ui.send_message`** `{text, images?, files?, responseType?}` — send chat message bypassing the textarea entirely (via gRPC postMessage)
+- **`ui.command_palette`** `{command}` — run VSCode command
+
+## Typical Session
+
+```bash
+# 1. Launch
+curl localhost:19229/api -d '{"method":"launch","params":{"skipBuild":true}}'
+
+# 2. Open sidebar + dismiss overlays (ALWAYS do this first)
+curl localhost:19229/api -d '{"method":"ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+
+# 3. Navigate to view
+curl localhost:19229/api -d '{"method":"ui.command_palette","params":{"command":"cline.accountButtonClicked"}}'
+
+# 4. Check captured OAuth URLs if testing auth
+curl localhost:19229/api -d '{"method":"oauth.captured_urls"}'
+
+# 5. Verify
+curl localhost:19229/api -d '{"method":"ui.screenshot"}'
+```
+
+## Caveats
+
+- **⚠️ Dismiss promotional overlays FIRST**: On fresh launches, full-screen promo overlays block the sidebar. **Dismiss immediately after `ui.open_sidebar`**, before any other interaction or screenshot. May need to run twice:
+  ```bash
+  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+  curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+  ```
+- **Screenshots — don't open the file**: `ui.screenshot` and `ui.sidebar_screenshot` save PNGs to `/tmp/cline-debug/` and return the `{path}`. Use `read_file` on that path to examine screenshots. Running `open <path>` launches Preview.app on macOS which covers the VSCode window.
+- **Scripts count = 0 after launch**: CDP connects after extension host starts, so scripts parsed during startup aren't tracked. Breakpoints still work via sourcemap resolution.
+- **Port 9230**: Extension host inspector. If another VSCode instance uses this port, the harness will fail to connect. Kill other debug instances first.
+- **macOS only** for now (Playwright Electron launch behavior).
+- **Webview CDP**: `connect_webview` may fail depending on Electron version. `web.evaluate` still works via Playwright's `frame.evaluate()` fallback.
+- **Sourcemap paths**: esbuild outputs relative paths like `../src/extension.ts` in the sourcemap. The resolver handles this, but if a file isn't found, use `ext.source_files` to see exact paths.
+- **OAuth with fake codes**: Browser capture intercepts the URL but doesn't provide a valid auth code. For real OAuth testing, open the captured URL in a browser. For unit testing, mock the token exchange.
+
+See `src/dev/debug-harness/README.md` for full API reference.

.clinerules/general.md

@@ -18,6 +18,49 @@ This file is the secret sauce for working effectively in this codebase. It captu
 - When adding new feature flags, see this PR as a reference https://github.com/cline/cline/pull/7566
 - Additional instructions about making requests: @.clinerules/network.md
 
+## Searching the Codebase — Avoiding Build Output
+
+Several directories contain build output or generated code that produces
+noisy or unusable results with `search_files` / `grep`:
+
+| Directory | What it is | Why it's a problem |
+|-----------|-----------|-------------------|
+| `out/` | esbuild bundle output | Mirrors `src/` structure as minified JS — every search gets duplicate hits on single-line files |
+| `dist/` | Packaged extension | Entire extension bundled into one minified `extension.js` (~1 long line) |
+| `dist-standalone/` | Standalone build output | Same minification issue |
+| `src/generated/` | Generated protobuf code | Auto-generated from `proto/`; not the source of truth |
+| `src/shared/proto/` | Generated proto type defs | Auto-generated from `proto/`; not the source of truth |
+| `node_modules/` | Dependencies | Huge, not project source |
+
+### How to skip build output
+
+**`search_files`** — Point at `src/` (not the project root) and use `file_pattern`:
+```
+search_files(path="src/core", regex="myFunction", file_pattern="*.ts")
+```
+The `file_pattern` parameter is the most effective filter — e.g. `"*.ts"`,
+`"*.tsx"`, `"*.proto"`.
+
+**`grep` directly** — Exclude build dirs and restrict to source extensions:
+```bash
+grep -rn "myFunction" src/ --include="*.ts" --exclude-dir={out,dist,node_modules,generated}
+```
+
+### When you must search minified files
+
+Sometimes you need to verify what got bundled (e.g., checking if a change
+made it into the build). Minified files are typically one long line, so
+normal `grep` shows the entire file as context. Use these approaches:
+
+- **`grep -oP`** to extract just the match with limited surrounding context:
+  ```bash
+  grep -oP '.{0,40}myFunction.{0,40}' dist/extension.js
+  ```
+- **`read_file`** on files in `out/src/` — these have source maps and are
+  more readable than `dist/extension.js` (which is the fully bundled output).
+- **Source maps** — `out/src/*.js.map` and `dist/extension.js.map` can be
+  used to trace minified output back to original source locations.
+
 ## gRPC/Protobuf Communication
 The extension and webview communicate via gRPC-like protocol over VS Code message passing.
 
@@ -48,93 +91,6 @@ The extension and webview communicate via gRPC-like protocol over VS Code messag
 - `src/core/controller/task/explainChanges.ts` - Handler implementation
 - `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
 
-## Adding a New API Provider
-When adding a new provider (e.g., "openai-codex"), you must update the proto conversion layer in THREE places or the provider will silently reset to Anthropic:
-
-1. `proto/cline/models.proto` - Add to the `ApiProvider` enum (e.g., `OPENAI_CODEX = 40;`)
-2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts` - Add case mapping string to proto enum
-3. `convertProtoToApiProvider()` in the same file - Add case mapping proto enum back to string
-
-**Why this matters:** Without these, the provider string hits the `default` case and returns `ANTHROPIC`. The webview, provider list, and handler all work fine, but the state silently resets when it round-trips through proto serialization. No error is thrown.
-
-**Other files to update when adding a provider:**
-- `src/shared/api.ts` - Add to `ApiProvider` union type, define models
-- `src/shared/providers/providers.json` - Add to provider list for dropdown
-- `src/core/api/index.ts` - Register handler in `createHandlerForProvider()`
-- `webview-ui/src/components/settings/utils/providerUtils.ts` - Add cases in `getModelsForProvider()` and `normalizeApiConfiguration()`
-- `webview-ui/src/utils/validate.ts` - Add validation case
-- `webview-ui/src/components/settings/ApiOptions.tsx` - Render provider component
-
-## Responses API Providers (OpenAI Codex, OpenAI Native)
-Providers using OpenAI's Responses API require native tool calling. XML tools don't work with the Responses API.
-
-**Symptoms of broken native tool calling:**
-- Tools get called multiple times (e.g., `ask_followup_question` asks the same question twice)
-- Tool arguments get duplicated or malformed
-- The model responds but tools aren't recognized
-
-**Root causes to check:**
-1. **Provider missing from `isNextGenModelProvider()`** in `src/utils/model-utils.ts`. The native variant matchers (e.g., `native-gpt-5/config.ts`) call this function. If your provider isn't in the list, the matcher returns false and falls back to XML tools.
-
-2. **Model missing `apiFormat: ApiFormat.OPENAI_RESPONSES`** in its model info (`src/shared/api.ts`). This property signals that the model requires native tool calling. The task runner in `src/core/task/index.ts` checks this and forces `enableNativeToolCalls: true` regardless of user settings.
-
-**When adding a new Responses API provider:**
-1. Add provider to `isNextGenModelProvider()` list in `src/utils/model-utils.ts`
-2. Set `apiFormat: ApiFormat.OPENAI_RESPONSES` on all models that use the Responses API
-3. The variant matcher and task runner will handle the rest automatically
-
-## Adding Tools to System Prompt
-This is tricky—multiple prompt variants and configs. **Always search for existing similar tools first and follow their pattern.** Look at the full chain from prompt definition → variant configs → handler → UI before implementing.
-
-1. **Add to `ClineDefaultTool` enum** in `src/shared/tools.ts`
-2. **Tool definition** in `src/core/prompts/system-prompt/tools/` (create file like `generate_explanation.ts`)
-   - Define variants for each `ModelFamily` (generic, next-gen, xs, etc.)
-   - Export variants array (e.g., `export const my_tool_variants = [GENERIC, NATIVE_NEXT_GEN, XS]`)
-   - **Fallback behavior**: If a variant isn't defined for a model family, `ClineToolSet.getToolByNameWithFallback()` automatically falls back to GENERIC. So you only need to export `[GENERIC]` unless the tool needs model-specific behavior.
-3. **Register in `src/core/prompts/system-prompt/tools/init.ts`** - Import and spread into `allToolVariants`
-4. **Add to variant configs** - Each model family has its own config in `src/core/prompts/system-prompt/variants/*/config.ts`. Add your tool's enum to the `.tools()` list:
-   - `generic/config.ts`, `next-gen/config.ts`, `gpt-5/config.ts`, `native-gpt-5/config.ts`, `native-gpt-5-1/config.ts`, `native-next-gen/config.ts`, `gemini-3/config.ts`, `glm/config.ts`, `hermes/config.ts`, `xs/config.ts`
-   - **Important**: If you add to a variant's config, make sure the tool spec exports a variant for that ModelFamily (or relies on GENERIC fallback)
-5. **Create handler** in `src/core/task/tools/handlers/`
-6. **Wire up in `ToolExecutor.ts`** if needed for execution flow
-7. **Add to tool parsing** in `src/core/assistant-message/index.ts` if needed
-8. **If tool has UI feedback**: add `ClineSay` enum in proto, update `src/shared/ExtensionMessage.ts`, update `src/shared/proto-conversions/cline-message.ts`, update `webview-ui/src/components/chat/ChatRow.tsx`
-
-## Modifying System Prompt
-**Read these first:** `src/core/prompts/system-prompt/README.md`, `tools/README.md`, `__tests__/README.md`
-
-System prompt is modular: **components** (reusable sections) + **variants** (model-specific configs) + **templates** (with `{{PLACEHOLDER}}` resolution).
-
-**Key directories:**
-- `components/` - Shared sections: `rules.ts`, `capabilities.ts`, `editing_files.ts`, etc.
-- `variants/` - Model-specific: `generic/`, `next-gen/`, `xs/`, `gpt-5/`, `gemini-3/`, `hermes/`, `glm/`, etc.
-- `templates/` - Template engine and placeholder definitions
-
-**Variant tiers (ask user which to modify):**
-- **Next-gen** (Claude 4, GPT-5, Gemini 2.5): `next-gen/`, `native-next-gen/`, `native-gpt-5/`, `native-gpt-5-1/`, `gemini-3/`, `gpt-5/`
-- **Standard** (default fallback): `generic/`
-- **Local/small models**: `xs/`, `hermes/`, `glm/`
-
-**How overrides work:** Variants can override components via `componentOverrides` in their `config.ts`, or provide a custom template in `template.ts` (e.g., `next-gen/template.ts` exports `rules_template`). If no override, the shared component from `components/` is used.
-
-**Example: Adding a rule to RULES section**
-1. Check if variant overrides rules: look for `rules_template` in `variants/*/template.ts` or `componentOverrides.RULES` in `config.ts`
-2. If shared: modify `components/rules.ts`
-3. If overridden: modify that variant's template
-4. XS variant is special—has heavily condensed inline content in `template.ts`
-
-**After any changes, regenerate snapshots:**
-```bash
-UPDATE_SNAPSHOTS=true npm run test:unit
-```
-Snapshots live in `__tests__/__snapshots__/`. Tests validate across model families and context variations (browser, MCP, focus chain).
-
-## Modifying Default Slash Commands
-Three places need updates:
-- `src/core/slash-commands/index.ts` - Command definitions
-- `src/core/prompts/commands.ts` - System prompt integration
-- `webview-ui/src/utils/slash-commands.ts` - Webview autocomplete
-
 ## Adding New Global State Keys
 Adding a new key to global state requires updates in multiple places. Missing any step causes silent failures.
 

.clinerules/network.md

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

.clinerules/sdk-migration.md

@@ -0,0 +1,29 @@
+# SDK Migration
+
+When working on the SDK migration (branch `sdk-migration-v3`), start by
+reading `sdk-migration/README.md` in full. It contains the step-by-step
+plan, core principles, and operational procedure.
+
+Key documents:
+- `sdk-migration/README.md` — Entry point, plan, steps
+- `sdk-migration/ARCHITECTURE.md` — Design decisions, features, SDK capabilities
+- `sdk-migration/SDK-REFERENCE/OAUTH.md` — SDK OAuth reference
+- `sdk-migration/SDK-REFERENCE/MCP.md` — SDK MCP reference
+- `sdk-migration/PROBLEMS.md` — Issue tracker with verification status
+- `src/dev/debug-harness/README.md` — Debug harness API
+
+## Critical Rules
+
+1. **Always use `kb_search(name="sdk", query="...")` before implementing**
+   SDK features. Don't guess at APIs.
+2. **Never mark a problem 🟢 without evidence.** Write the test first.
+3. **Delete and document.** When replacing a classic module, delete it
+   immediately and add `// Replaces classic src/core/... (see origin/main)`.
+   Use `kb_search(name="cline", commit="origin/main")` or
+   `git show origin/main:path` to reference the classic implementation.
+4. **Single entry point.** No `CLINE_SDK` env variable. There is one
+   codepath — the SDK adapter.
+5. **Use `{appBaseUrl}`**, never hardcode `app.cline.bot`.
+6. **Avoid `as` casts.** Use explicit conversion functions with tests.
+7. **Dismiss the Kanban overlay** before any debug harness interaction.
+8. **Use command palette** to navigate tabs in the debug harness.

CLAUDE.md

@@ -1,3 +1 @@
 @.clinerules/general.md
-@.clinerules/network.md
-@.clinerules/cli.md

biome.jsonc

@@ -179,9 +179,7 @@
 				"!!**/*.js",
 				"!!**/scripts/**",
 				"!!**/*.tsx",
-				"!!**/testing-platform/**",
-				// ACP mode must redirect console to stderr - this is intentional
-				"!!cli/src/acp/index.ts"
+				"!!**/testing-platform/**"
 			]
 		},
 		{

cli/package.json

@@ -32,7 +32,7 @@
 		"package": "npm pack --pack-destination ./dist",
 		"build": "npm run typecheck && npx tsx esbuild.mts && npm run build:types",
 		"build:production": "npm run typecheck && npx tsx esbuild.mts --production && npm run build:types",
-		"build:types": "(npx tsc -p tsconfig.lib.json || true) && cp dist/types/cli/src/exports.d.ts dist/lib.d.ts && mkdir -p dist/agent && cp dist/types/cli/src/agent/ClineAgent.d.ts dist/types/cli/src/agent/ClineSessionEmitter.d.ts dist/types/cli/src/agent/public-types.d.ts dist/agent/ && rm -rf dist/types",
+		"build:types": "(npx tsc -p tsconfig.lib.json || true) && cp dist/types/cli/src/exports.d.ts dist/lib.d.ts && rm -rf dist/types dist/agent",
 		"watch": "npx tsx esbuild.mts --watch",
 		"dev": "IS_DEV=true && npm run link && npm run watch ; npm run unlink",
 		"clean": "rimraf dist",
@@ -82,7 +82,6 @@
 		"vitest": "^4.0.17"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "^0.13.1",
 		"@vscode/ripgrep": "^1.15.9",
 		"aws4fetch": "^1.0.20",
 		"chalk": "^5.3.0",

cli/src/acp/ACPDiffViewProvider.ts

@@ -1,248 +0,0 @@
-/**
- * ACP-based implementation of DiffViewProvider that uses the ACP client's
- * filesystem capabilities for reading and writing files.
- *
- * This provider attempts to use the ACP client's fs/read_text_file and
- * fs/write_text_file methods when available, falling back to the
- * FileEditProvider's local filesystem implementation otherwise.
- *
- * @module acp
- */
-
-import type * as acp from "@agentclientprotocol/sdk"
-import { workspaceResolver } from "@core/workspace"
-import { createDirectoriesForFile } from "@utils/fs"
-import { getCwd } from "@utils/path"
-import * as fs from "fs/promises"
-import * as iconv from "iconv-lite"
-import { HostProvider } from "@/hosts/host-provider"
-import { FileEditProvider } from "@/integrations/editor/FileEditProvider"
-import { detectEncoding } from "@/integrations/misc/extract-text"
-import type { FileDiagnostics } from "@/shared/proto/index.cline"
-import { Logger } from "@/shared/services/Logger"
-
-/**
- * A function that resolves the current session ID.
- * This is used by ACPDiffViewProvider to get the session ID at runtime,
- * since the provider may be created before a session exists.
- */
-export type SessionIdResolver = () => string | undefined
-
-/**
- * A DiffViewProvider implementation that uses the ACP client's filesystem
- * capabilities when available, with fallback to local filesystem operations.
- *
- * This class extends FileEditProvider and overrides the file I/O methods to
- * use the ACP protocol's fs/read_text_file and fs/write_text_file requests
- * when the client supports these capabilities. This allows the editor (client)
- * to handle file operations, which enables features like:
- * - Reading unsaved editor state
- * - Tracking file modifications in the editor
- * - Proper integration with the client's undo/redo stack
- */
-export class ACPDiffViewProvider extends FileEditProvider {
-	private readonly connection: acp.AgentSideConnection
-	private readonly clientCapabilities: acp.ClientCapabilities | undefined
-	private readonly sessionIdResolver: SessionIdResolver
-
-	/**
-	 * Creates a new ACPDiffViewProvider.
-	 *
-	 * @param connection - The ACP agent-side connection for making requests
-	 * @param clientCapabilities - The client's advertised capabilities
-	 * @param sessionIdResolver - A function that returns the current session ID
-	 */
-	constructor(
-		connection: acp.AgentSideConnection,
-		clientCapabilities: acp.ClientCapabilities | undefined,
-		sessionIdResolver: SessionIdResolver,
-	) {
-		super()
-		this.connection = connection
-		this.clientCapabilities = clientCapabilities
-		this.sessionIdResolver = sessionIdResolver
-	}
-
-	/**
-	 * Gets the current session ID, or throws if no session is active.
-	 */
-	private getSessionId(): string {
-		const sessionId = this.sessionIdResolver()
-		if (!sessionId) {
-			throw new Error("No active ACP session. Cannot perform file operation.")
-		}
-		return sessionId
-	}
-
-	/**
-	 * Check if the client supports file read operations.
-	 */
-	private canReadFile(): boolean {
-		return this.clientCapabilities?.fs?.readTextFile === true
-	}
-
-	/**
-	 * Check if the client supports file write operations.
-	 */
-	private canWriteFile(): boolean {
-		return this.clientCapabilities?.fs?.writeTextFile === true
-	}
-
-	/**
-	 * Opens a file for editing, using ACP fs capabilities when available.
-	 *
-	 * If the client supports fs/read_text_file, this method will read the file
-	 * content via the ACP connection, which may include unsaved editor state.
-	 * Otherwise, it falls back to the FileEditProvider's local fs implementation.
-	 */
-	override async open(relPath: string, options?: { displayPath?: string }): Promise<void> {
-		// If we can't read files via ACP, fall back to FileEditProvider
-		if (!this.canReadFile()) {
-			Logger.debug("[ACPDiffViewProvider] Client does not support fs.readTextFile, falling back to local fs")
-			return super.open(relPath, options)
-		}
-
-		// Set up state - this replicates the DiffViewProvider.open() logic
-		// but uses ACP for file reading instead of local fs
-		this.isEditing = true
-		const cwd = await getCwd()
-		const absolutePathResolved = workspaceResolver.resolveWorkspacePath(cwd, relPath, "ACPDiffViewProvider.open.absolutePath")
-		this.absolutePath = typeof absolutePathResolved === "string" ? absolutePathResolved : absolutePathResolved.absolutePath
-		this.relPath = options?.displayPath ?? relPath
-		const fileExists = this.editType === "modify"
-
-		// Read file content
-		if (fileExists) {
-			// Try to save any dirty state in the editor first
-			try {
-				await HostProvider.workspace.saveOpenDocumentIfDirty({
-					filePath: this.absolutePath!,
-				})
-			} catch {
-				// Ignore errors - the host may not support this
-			}
-
-			// Read file content via ACP
-			try {
-				Logger.debug("[ACPDiffViewProvider] Reading file via ACP:", this.absolutePath)
-
-				const response = await this.connection.readTextFile({
-					sessionId: this.getSessionId(),
-					path: this.absolutePath!,
-				})
-
-				this.originalContent = response.content
-				// ACP always returns UTF-8 text content
-				this.fileEncoding = "utf8"
-
-				Logger.debug("[ACPDiffViewProvider] Read file successfully, length:", response.content.length)
-			} catch (error) {
-				// If ACP read fails, fall back to local fs
-				Logger.debug("[ACPDiffViewProvider] ACP read failed, falling back to local fs:", error)
-
-				const fileBuffer = await fs.readFile(this.absolutePath!)
-				this.fileEncoding = await detectEncoding(fileBuffer)
-				this.originalContent = iconv.decode(fileBuffer, this.fileEncoding)
-			}
-		} else {
-			this.originalContent = ""
-			this.fileEncoding = "utf8"
-		}
-
-		// Create directories for new files
-		const createdDirs = await createDirectoriesForFile(this.absolutePath!)
-		// Store for potential cleanup - access via the private field workaround
-		;(this as any).createdDirs = createdDirs
-
-		// Make sure the file exists before we proceed
-		if (!fileExists) {
-			// For new files, write via ACP if possible, otherwise local fs
-			if (this.canWriteFile()) {
-				try {
-					await this.connection.writeTextFile({
-						sessionId: this.getSessionId(),
-						path: this.absolutePath!,
-						content: "",
-					})
-				} catch {
-					// Fall back to local fs
-					await fs.writeFile(this.absolutePath!, "")
-				}
-			} else {
-				await fs.writeFile(this.absolutePath!, "")
-			}
-		}
-
-		// Get diagnostics before editing
-		let preDiagnostics: FileDiagnostics[] = []
-		try {
-			preDiagnostics = (await HostProvider.workspace.getDiagnostics({})).fileDiagnostics
-		} catch {
-			preDiagnostics = []
-		}
-		;(this as any).preDiagnostics = preDiagnostics
-
-		// Call the parent's openDiffEditor to set up in-memory document content
-		await this.openDiffEditor()
-		await this.scrollEditorToLine(0)
-		;(this as any).streamedLines = []
-	}
-
-	/**
-	 * Scrolls the editor to a specific line.
-	 * No-op for file-based providers, but needed for protected access.
-	 */
-	protected override async scrollEditorToLine(_line: number): Promise<void> {
-		// No-op: No visual editor to scroll
-	}
-
-	/**
-	 * Opens the diff editor.
-	 */
-	protected override async openDiffEditor(): Promise<void> {
-		// Set up in-memory document content from the original content
-		// no-op: No visual editor to open
-	}
-
-	/**
-	 * Saves the document content, using ACP fs capabilities when available.
-	 *
-	 * If the client supports fs/write_text_file, this method will write the file
-	 * content via the ACP connection. Otherwise, it falls back to the
-	 * FileEditProvider's local fs implementation.
-	 */
-	protected override async saveDocument(): Promise<Boolean> {
-		// If we can't write files via ACP, fall back to FileEditProvider
-		if (!this.canWriteFile()) {
-			Logger.debug("[ACPDiffViewProvider] Client does not support fs.writeTextFile, falling back to local fs")
-			return super.saveDocument()
-		}
-
-		const content = await this.getContent()
-		if (!this.absolutePath || content === undefined) {
-			return false
-		}
-
-		try {
-			Logger.debug("[ACPDiffViewProvider] Writing file via ACP:", {
-				path: this.absolutePath,
-				contentLength: content.length,
-			})
-
-			await this.connection.writeTextFile({
-				sessionId: this.getSessionId(),
-				path: this.absolutePath,
-				content: content,
-			})
-
-			Logger.debug("[ACPDiffViewProvider] Write file successfully")
-
-			return true
-		} catch (error) {
-			// If ACP write fails, fall back to local fs
-			Logger.debug("[ACPDiffViewProvider] ACP write failed, falling back to local fs:", error)
-
-			return super.saveDocument()
-		}
-	}
-}

cli/src/acp/ACPHostBridgeClientProvider.ts

@@ -1,408 +0,0 @@
-/**
- * ACP Host Bridge Client Provider
- *
- * Implements HostBridgeClientProvider for ACP mode, providing stub implementations
- * of the 4 required service clients. These clients conform to the interfaces in
- * host-bridge-client-types.ts and will use ACP connection capabilities where applicable.
- *
- * @module acp
- */
-
-import type * as acp from "@agentclientprotocol/sdk"
-import type {
-	DiffServiceClientInterface,
-	EnvServiceClientInterface,
-	WindowServiceClientInterface,
-	WorkspaceServiceClientInterface,
-} from "@generated/hosts/host-bridge-client-types"
-import type { HostBridgeClientProvider, StreamingCallbacks } from "@hosts/host-provider-types"
-import * as proto from "@shared/proto/index"
-import { ClineClient } from "@/shared/cline"
-import { Logger } from "@/shared/services/Logger"
-
-/**
- * Function type that resolves the current session ID.
- * Returns undefined if no session is active.
- */
-export type SessionIdResolver = () => string | undefined
-
-/**
- * Function type that resolves the current working directory.
- * Returns undefined if no cwd is available (will fall back to process.cwd()).
- */
-export type CwdResolver = () => string | undefined
-
-/**
- * ACP implementation of DiffService client.
- *
- * Handles diff operations for the ACP environment. Most operations are stubs
- * that will be implemented in the next phase using ACP extension methods or
- * the fs capabilities (readTextFile/writeTextFile).
- */
-class ACPDiffServiceClient implements DiffServiceClientInterface {
-	async openDiff(_request: proto.host.OpenDiffRequest): Promise<proto.host.OpenDiffResponse> {
-		// Next phase: Could use ACP client capabilities to open a diff view in the editor.
-		// This would involve sending an ACP extension notification/request to the client
-		// to display a side-by-side diff of the original vs modified content.
-		Logger.debug("[ACPDiffServiceClient] openDiff called (stub)")
-		return proto.host.OpenDiffResponse.create({})
-	}
-
-	async getDocumentText(request: proto.host.GetDocumentTextRequest): Promise<proto.host.GetDocumentTextResponse> {
-		// Next phase: Use connection.readTextFile if clientCapabilities.fs.readTextFile is available.
-		// This would read the current document content from the editor, including any unsaved changes.
-		// For now, return empty content.
-		Logger.debug("[ACPDiffServiceClient] getDocumentText called (stub)", { diffId: request.diffId })
-		return proto.host.GetDocumentTextResponse.create({ content: "" })
-	}
-
-	async replaceText(_request: proto.host.ReplaceTextRequest): Promise<proto.host.ReplaceTextResponse> {
-		// Next phase: Use connection.writeTextFile if clientCapabilities.fs.writeTextFile is available.
-		// This would replace text in the document at the specified range.
-		Logger.debug("[ACPDiffServiceClient] replaceText called (stub)")
-		return proto.host.ReplaceTextResponse.create({})
-	}
-
-	async scrollDiff(_request: proto.host.ScrollDiffRequest): Promise<proto.host.ScrollDiffResponse> {
-		// Next phase: Send ACP extension notification to scroll the diff view to a specific line.
-		// No visual editor in ACP mode by default, so this is a no-op.
-		Logger.debug("[ACPDiffServiceClient] scrollDiff called (stub)")
-		return proto.host.ScrollDiffResponse.create({})
-	}
-
-	async truncateDocument(_request: proto.host.TruncateDocumentRequest): Promise<proto.host.TruncateDocumentResponse> {
-		// Next phase: Read file using readTextFile, truncate content, write back using writeTextFile.
-		// This is used to truncate a document to a specific line count.
-		Logger.debug("[ACPDiffServiceClient] truncateDocument called (stub)")
-		return proto.host.TruncateDocumentResponse.create({})
-	}
-
-	async saveDocument(_request: proto.host.SaveDocumentRequest): Promise<proto.host.SaveDocumentResponse> {
-		// Next phase: Use connection.writeTextFile to persist the document to disk.
-		// This saves the current document content to the file system.
-		Logger.debug("[ACPDiffServiceClient] saveDocument called (stub)")
-		return proto.host.SaveDocumentResponse.create({})
-	}
-
-	async closeAllDiffs(_request: proto.host.CloseAllDiffsRequest): Promise<proto.host.CloseAllDiffsResponse> {
-		// Next phase: Send ACP extension notification to close all diff views in the editor.
-		// No visual diff views in ACP mode by default, so this is a no-op.
-		Logger.debug("[ACPDiffServiceClient] closeAllDiffs called (stub)")
-		return proto.host.CloseAllDiffsResponse.create({})
-	}
-
-	async openMultiFileDiff(_request: proto.host.OpenMultiFileDiffRequest): Promise<proto.host.OpenMultiFileDiffResponse> {
-		// Next phase: Send ACP extension notification to open a multi-file diff view.
-		// This would display changes across multiple files in the editor.
-		Logger.debug("[ACPDiffServiceClient] openMultiFileDiff called (stub)")
-		return proto.host.OpenMultiFileDiffResponse.create({})
-	}
-}
-
-/**
- * ACP implementation of EnvService client.
- *
- * Handles environment operations like clipboard access, version info, and telemetry.
- * Most operations are stubs that will be implemented using ACP extension methods.
- */
-class ACPEnvServiceClient implements EnvServiceClientInterface {
-	private readonly version: string
-
-	constructor(_clientCapabilities: acp.ClientCapabilities | undefined, _sessionIdResolver: SessionIdResolver, version: string) {
-		this.version = version
-	}
-
-	async debugLog(request: proto.cline.StringRequest): Promise<proto.cline.Empty> {
-		Logger.debug(request.value)
-		return proto.cline.Empty.create()
-	}
-
-	async clipboardWriteText(_request: proto.cline.StringRequest): Promise<proto.cline.Empty> {
-		Logger.debug("[ACPEnvServiceClient] clipboardWriteText called (stub)")
-		return proto.cline.Empty.create()
-	}
-
-	async clipboardReadText(_request: proto.cline.EmptyRequest): Promise<proto.cline.String> {
-		Logger.debug("[ACPEnvServiceClient] clipboardReadText called (stub)")
-		return proto.cline.String.create({ value: "" })
-	}
-
-	async getHostVersion(_request: proto.cline.EmptyRequest): Promise<proto.host.GetHostVersionResponse> {
-		// Return version info for the ACP agent.
-		return proto.host.GetHostVersionResponse.create({
-			version: this.version,
-			platform: "Cline ACP Agent",
-			clineType: ClineClient.Cli,
-		})
-	}
-
-	async getIdeRedirectUri(_request: proto.cline.EmptyRequest): Promise<proto.cline.String> {
-		Logger.debug("[ACPEnvServiceClient] getIdeRedirectUri called (stub)")
-		return proto.cline.String.create({ value: "" })
-	}
-
-	async getTelemetrySettings(_request: proto.cline.EmptyRequest): Promise<proto.host.GetTelemetrySettingsResponse> {
-		// Return telemetry as disabled by default in ACP mode.
-		return proto.host.GetTelemetrySettingsResponse.create({
-			isEnabled: proto.host.Setting.DISABLED,
-		})
-	}
-
-	subscribeToTelemetrySettings(
-		_request: proto.cline.EmptyRequest,
-		callbacks: StreamingCallbacks<proto.host.TelemetrySettingsEvent>,
-	): () => void {
-		// Send initial telemetry settings (disabled) and return unsubscribe function.
-		callbacks.onResponse(
-			proto.host.TelemetrySettingsEvent.create({
-				isEnabled: proto.host.Setting.DISABLED,
-			}),
-		)
-		// Return no-op unsubscribe function
-		return () => {}
-	}
-
-	async shutdown(_request: proto.cline.EmptyRequest): Promise<proto.cline.Empty> {
-		// Next phase: Graceful ACP connection shutdown.
-		// This would cleanly close the ACP connection and release resources.
-		Logger.debug("[ACPEnvServiceClient] shutdown called (stub)")
-		return proto.cline.Empty.create()
-	}
-
-	async openExternal(request: proto.cline.StringRequest): Promise<proto.cline.Empty> {
-		const url = request.value || ""
-		if (url) {
-			Logger.debug(`[ACPEnvServiceClient] openExternal: ${url}`)
-			const { openUrlInBrowser } = await import("../utils/browser")
-			await openUrlInBrowser(url)
-		}
-		return proto.cline.Empty.create()
-	}
-}
-
-/**
- * ACP implementation of WindowService client.
- *
- * Handles window/UI operations like showing documents, dialogs, and messages.
- * Most operations are stubs that will be implemented using ACP extension methods.
- */
-class ACPWindowServiceClient implements WindowServiceClientInterface {
-	constructor(_clientCapabilities: acp.ClientCapabilities | undefined, _sessionIdResolver: SessionIdResolver) {}
-
-	async showTextDocument(request: proto.host.ShowTextDocumentRequest): Promise<proto.host.TextEditorInfo> {
-		// Next phase: Send ACP extension request to open document in the editor.
-		// This would tell the ACP client to open the specified file.
-		Logger.debug("[ACPWindowServiceClient] showTextDocument called (stub)", { path: request.path })
-		return proto.host.TextEditorInfo.create({
-			documentPath: request.path,
-		})
-	}
-
-	async showOpenDialogue(_request: proto.host.ShowOpenDialogueRequest): Promise<proto.host.SelectedResources> {
-		// Next phase: Send ACP extension request for file picker dialog.
-		// This would display a file open dialog in the ACP client.
-		Logger.debug("[ACPWindowServiceClient] showOpenDialogue called (stub)")
-		return proto.host.SelectedResources.create({ paths: [] })
-	}
-
-	async showMessage(request: proto.host.ShowMessageRequest): Promise<proto.host.SelectedResponse> {
-		// Next phase: Send ACP extension notification to show message in the editor.
-		// This would display an information/warning/error message to the user.
-		Logger.debug("[ACPWindowServiceClient] showMessage called (stub)", {
-			message: request.message,
-			type: request.type,
-		})
-		return proto.host.SelectedResponse.create({})
-	}
-
-	async showInputBox(_request: proto.host.ShowInputBoxRequest): Promise<proto.host.ShowInputBoxResponse> {
-		// Next phase: Send ACP extension request for input dialog.
-		// This would display an input box for user text entry.
-		Logger.debug("[ACPWindowServiceClient] showInputBox called (stub)")
-		return proto.host.ShowInputBoxResponse.create({ response: "" })
-	}
-
-	async showSaveDialog(_request: proto.host.ShowSaveDialogRequest): Promise<proto.host.ShowSaveDialogResponse> {
-		// Next phase: Send ACP extension request for save dialog.
-		// This would display a file save dialog in the ACP client.
-		Logger.debug("[ACPWindowServiceClient] showSaveDialog called (stub)")
-		return proto.host.ShowSaveDialogResponse.create({ selectedPath: "" })
-	}
-
-	async openFile(request: proto.host.OpenFileRequest): Promise<proto.host.OpenFileResponse> {
-		// Next phase: Send ACP extension request to open file in the editor.
-		// This would open the specified file in the ACP client's editor.
-		Logger.debug("[ACPWindowServiceClient] openFile called (stub)", { filePath: request.filePath })
-		return proto.host.OpenFileResponse.create({})
-	}
-
-	async openSettings(_request: proto.host.OpenSettingsRequest): Promise<proto.host.OpenSettingsResponse> {
-		// Next phase: Send ACP extension request to open settings panel.
-		// This would open the settings/preferences in the ACP client.
-		Logger.debug("[ACPWindowServiceClient] openSettings called (stub)")
-		return proto.host.OpenSettingsResponse.create({})
-	}
-
-	async getOpenTabs(_request: proto.host.GetOpenTabsRequest): Promise<proto.host.GetOpenTabsResponse> {
-		// Next phase: Send ACP extension request to list open tabs/documents.
-		// This would return a list of currently open files in the editor.
-		Logger.debug("[ACPWindowServiceClient] getOpenTabs called (stub)")
-		return proto.host.GetOpenTabsResponse.create({ paths: [] })
-	}
-
-	async getVisibleTabs(_request: proto.host.GetVisibleTabsRequest): Promise<proto.host.GetVisibleTabsResponse> {
-		// Next phase: Send ACP extension request to list visible tabs.
-		// This would return a list of visible tabs/panes in the editor.
-		Logger.debug("[ACPWindowServiceClient] getVisibleTabs called (stub)")
-		return proto.host.GetVisibleTabsResponse.create({ paths: [] })
-	}
-
-	async getActiveEditor(_request: proto.host.GetActiveEditorRequest): Promise<proto.host.GetActiveEditorResponse> {
-		// Next phase: Send ACP extension request to get active editor info.
-		// This would return information about the currently focused editor.
-		Logger.debug("[ACPWindowServiceClient] getActiveEditor called (stub)")
-		return proto.host.GetActiveEditorResponse.create({})
-	}
-}
-
-/**
- * ACP implementation of WorkspaceService client.
- *
- * Handles workspace operations like getting paths, diagnostics, and terminal commands.
- * Uses the cwdResolver to get the current working directory, falling back to process.cwd().
- */
-class ACPWorkspaceServiceClient implements WorkspaceServiceClientInterface {
-	private readonly _clientCapabilities: acp.ClientCapabilities | undefined
-	private readonly cwdResolver: CwdResolver
-
-	constructor(
-		clientCapabilities: acp.ClientCapabilities | undefined,
-		_sessionIdResolver: SessionIdResolver,
-		cwdResolver: CwdResolver,
-	) {
-		this._clientCapabilities = clientCapabilities
-		this.cwdResolver = cwdResolver
-	}
-
-	/**
-	 * Get the current working directory, using the resolver if available,
-	 * otherwise falling back to process.cwd().
-	 */
-	private getCwd(): string {
-		return this.cwdResolver() ?? process.cwd()
-	}
-
-	async getWorkspacePaths(_request: proto.host.GetWorkspacePathsRequest): Promise<proto.host.GetWorkspacePathsResponse> {
-		// Return the current working directory from the resolver.
-		const cwd = this.getCwd()
-		Logger.debug("[ACPWorkspaceServiceClient] getWorkspacePaths called", { cwd })
-		return proto.host.GetWorkspacePathsResponse.create({
-			paths: [cwd],
-		})
-	}
-
-	async saveOpenDocumentIfDirty(
-		_request: proto.host.SaveOpenDocumentIfDirtyRequest,
-	): Promise<proto.host.SaveOpenDocumentIfDirtyResponse> {
-		// Next phase: Use ACP extension or fs.writeTextFile to save dirty documents.
-		// This would save any unsaved changes in the specified document.
-		Logger.debug("[ACPWorkspaceServiceClient] saveOpenDocumentIfDirty called (stub)")
-		return proto.host.SaveOpenDocumentIfDirtyResponse.create({})
-	}
-
-	async getDiagnostics(_request: proto.host.GetDiagnosticsRequest): Promise<proto.host.GetDiagnosticsResponse> {
-		// Next phase: Send ACP extension request for diagnostics (errors, warnings).
-		// This would return linting/compilation errors from the ACP client.
-		Logger.debug("[ACPWorkspaceServiceClient] getDiagnostics called (stub)")
-		return proto.host.GetDiagnosticsResponse.create({ fileDiagnostics: [] })
-	}
-
-	async openProblemsPanel(_request: proto.host.OpenProblemsPanelRequest): Promise<proto.host.OpenProblemsPanelResponse> {
-		// Next phase: Send ACP extension notification to open the problems panel.
-		// This would show the diagnostics/problems view in the editor.
-		Logger.debug("[ACPWorkspaceServiceClient] openProblemsPanel called (stub)")
-		return proto.host.OpenProblemsPanelResponse.create({})
-	}
-
-	async openInFileExplorerPanel(
-		request: proto.host.OpenInFileExplorerPanelRequest,
-	): Promise<proto.host.OpenInFileExplorerPanelResponse> {
-		// Next phase: Send ACP extension notification to reveal file in explorer.
-		// This would highlight/reveal the specified path in the file tree.
-		Logger.debug("[ACPWorkspaceServiceClient] openInFileExplorerPanel called (stub)", { path: request.path })
-		return proto.host.OpenInFileExplorerPanelResponse.create({})
-	}
-
-	async openClineSidebarPanel(
-		_request: proto.host.OpenClineSidebarPanelRequest,
-	): Promise<proto.host.OpenClineSidebarPanelResponse> {
-		// Next phase: Send ACP extension notification to open Cline sidebar.
-		// This would show the Cline panel/sidebar in the editor.
-		Logger.debug("[ACPWorkspaceServiceClient] openClineSidebarPanel called (stub)")
-		return proto.host.OpenClineSidebarPanelResponse.create({})
-	}
-
-	async openTerminalPanel(_request: proto.host.OpenTerminalRequest): Promise<proto.host.OpenTerminalResponse> {
-		// Next phase: Send ACP extension notification or use createTerminal capability.
-		// This would open/show the terminal panel in the editor.
-		Logger.debug("[ACPWorkspaceServiceClient] openTerminalPanel called (stub)")
-		return proto.host.OpenTerminalResponse.create({})
-	}
-
-	async executeCommandInTerminal(
-		request: proto.host.ExecuteCommandInTerminalRequest,
-	): Promise<proto.host.ExecuteCommandInTerminalResponse> {
-		// Next phase: Use connection.createTerminal if clientCapabilities.terminal is available.
-		// This would execute the specified command in a terminal via the ACP client.
-		// The ACP SDK provides createTerminal() which returns a TerminalHandle with
-		// methods like currentOutput(), waitForExit(), kill(), and release().
-		Logger.debug("[ACPWorkspaceServiceClient] executeCommandInTerminal called (stub)", {
-			command: request.command,
-			hasTerminalCapability: this._clientCapabilities?.terminal,
-		})
-		return proto.host.ExecuteCommandInTerminalResponse.create({})
-	}
-
-	async openFolder(request: proto.host.OpenFolderRequest): Promise<proto.host.OpenFolderResponse> {
-		// Next phase: Send ACP extension request to change workspace/folder.
-		// This would open a new folder/workspace in the ACP client.
-		Logger.debug("[ACPWorkspaceServiceClient] openFolder called (stub)", { path: request.path })
-		return proto.host.OpenFolderResponse.create({ success: true })
-	}
-}
-
-/**
- * ACP Host Bridge Client Provider
- *
- * Provides the 4 service clients required by HostBridgeClientProvider interface,
- * implemented for the ACP environment. Uses the ACP connection and client capabilities
- * to delegate operations to the ACP client where possible.
- */
-export class ACPHostBridgeClientProvider implements HostBridgeClientProvider {
-	workspaceClient: WorkspaceServiceClientInterface
-	envClient: EnvServiceClientInterface
-	windowClient: WindowServiceClientInterface
-	diffClient: DiffServiceClientInterface
-
-	/**
-	 * Creates a new ACPHostBridgeClientProvider.
-	 *
-	 * @param connection - The ACP agent-side connection for making requests
-	 * @param clientCapabilities - The client's advertised capabilities
-	 * @param sessionIdResolver - Function that returns the current session ID
-	 * @param cwdResolver - Function that returns the current working directory
-	 * @param debug - Whether to enable debug logging
-	 * @param version - Version string for getHostVersion (optional)
-	 */
-	constructor(
-		clientCapabilities: acp.ClientCapabilities | undefined,
-		sessionIdResolver: SessionIdResolver,
-		cwdResolver: CwdResolver,
-		version: string,
-	) {
-		this.workspaceClient = new ACPWorkspaceServiceClient(clientCapabilities, sessionIdResolver, cwdResolver)
-		this.envClient = new ACPEnvServiceClient(clientCapabilities, sessionIdResolver, version)
-		this.windowClient = new ACPWindowServiceClient(clientCapabilities, sessionIdResolver)
-		this.diffClient = new ACPDiffServiceClient()
-	}
-}

cli/src/acp/AcpAgent.ts

@@ -1,141 +0,0 @@
-/**
- * AcpAgent - Thin wrapper that bridges stdio connection to ClineAgent.
- *
- * This class wraps the ClineAgent and connects it to an ACP AgentSideConnection
- * for stdio-based communication. It:
- * - Wires up the permission handler to call connection.requestPermission()
- * - Subscribes to ClineAgent session events and forwards them to connection.sessionUpdate()
- * - Delegates all acp.Agent methods to the internal ClineAgent
- *
- * For programmatic usage without stdio, use ClineAgent directly.
- *
- * @module acp
- */
-
-import type * as acp from "@agentclientprotocol/sdk"
-import { Logger } from "@/shared/services/Logger.js"
-import { ClineAgent } from "../agent/ClineAgent.js"
-import { type AcpAgentOptions, type SessionUpdateType } from "../agent/types.js"
-
-/**
- * ACP Agent wrapper that bridges stdio connection to ClineAgent.
- *
- * This is the class used by runAcpMode() for stdio-based ACP communication.
- * It creates an internal ClineAgent and wires up the connection for:
- * - Permission requests (via connection.requestPermission)
- * - Session updates (via connection.sessionUpdate)
- */
-export class AcpAgent implements acp.Agent {
-	private readonly connection: acp.AgentSideConnection
-	private readonly clineAgent: ClineAgent
-
-	/** Track which sessions we've subscribed to for event forwarding */
-	private readonly subscribedSessions: Set<string> = new Set()
-
-	constructor(connection: acp.AgentSideConnection, options: AcpAgentOptions) {
-		this.connection = connection
-
-		// Create the internal ClineAgent
-		this.clineAgent = new ClineAgent(options)
-
-		// Wire up the permission handler to use the connection
-		this.clineAgent.setPermissionHandler(async (request) => {
-			try {
-				Logger.debug("[AcpAgent] Forwarding permission request to connection")
-				return await this.connection.requestPermission({
-					sessionId: request.sessionId,
-					toolCall: request.toolCall,
-					options: request.options,
-				})
-			} catch (error) {
-				Logger.debug("[AcpAgent] Error requesting permission:", error)
-				return { outcome: { outcome: "cancelled" } }
-			}
-		})
-	}
-
-	/**
-	 * Subscribe to session events and forward them to the connection.
-	 */
-	private subscribeToSessionEvents(sessionId: string): void {
-		if (this.subscribedSessions.has(sessionId)) {
-			return
-		}
-
-		const emitter = this.clineAgent.emitterForSession(sessionId)
-
-		// Forward session update by adding the sessionUpdate discriminator
-		const forwardSessionUpdate = <K extends SessionUpdateType>(eventName: K) => {
-			emitter.on(eventName, (payload: Record<string, unknown>) => {
-				const update = {
-					sessionUpdate: eventName,
-					...payload,
-				} as acp.SessionUpdate
-				this.connection.sessionUpdate({ sessionId, update }).catch((error) => {
-					Logger.error(`[AcpAgent] Error forwarding ${eventName}:`, error)
-				})
-			})
-		}
-
-		// Forward all standard session updates
-		forwardSessionUpdate("agent_message_chunk")
-		forwardSessionUpdate("agent_thought_chunk")
-		forwardSessionUpdate("tool_call")
-		forwardSessionUpdate("tool_call_update")
-		forwardSessionUpdate("available_commands_update")
-		forwardSessionUpdate("plan")
-		forwardSessionUpdate("current_mode_update")
-		forwardSessionUpdate("user_message_chunk")
-		forwardSessionUpdate("config_option_update")
-		forwardSessionUpdate("session_info_update")
-
-		// Handle errors specially (not part of ACP SessionUpdate)
-		emitter.on("error", (error) => {
-			Logger.error("[AcpAgent] Session error:", error)
-		})
-
-		this.subscribedSessions.add(sessionId)
-	}
-
-	// ============================================================
-	// acp.Agent Interface Implementation - Delegate to ClineAgent
-	// ============================================================
-
-	async initialize(params: acp.InitializeRequest): Promise<acp.InitializeResponse> {
-		return await this.clineAgent.initialize(params, this.connection)
-	}
-
-	async newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse> {
-		const response = await this.clineAgent.newSession(params)
-		// Subscribe to events for this new session
-		this.subscribeToSessionEvents(response.sessionId)
-		return response
-	}
-
-	async prompt(params: acp.PromptRequest): Promise<acp.PromptResponse> {
-		// Ensure we're subscribed to this session's events
-		this.subscribeToSessionEvents(params.sessionId)
-		return this.clineAgent.prompt(params)
-	}
-
-	async cancel(params: acp.CancelNotification): Promise<void> {
-		return this.clineAgent.cancel(params)
-	}
-
-	async setSessionMode(params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse> {
-		return this.clineAgent.setSessionMode(params)
-	}
-
-	async unstable_setSessionModel(params: acp.SetSessionModelRequest): Promise<acp.SetSessionModelResponse> {
-		return this.clineAgent.unstable_setSessionModel(params)
-	}
-
-	async authenticate(params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse> {
-		return this.clineAgent.authenticate(params)
-	}
-
-	async shutdown(): Promise<void> {
-		this.subscribedSessions.clear()
-		return this.clineAgent.shutdown()
-	}
-}

cli/src/acp/index.ts

@@ -1,141 +0,0 @@
-/**
- * Entry point for ACP (Agent Client Protocol) mode.
- *
- * When the CLI is invoked with `--acp`, this module sets up the ACP connection
- * and runs Cline as an ACP-compliant agent communicating over stdio.
- *
- * This module exports:
- * - `ClineAgent` - Decoupled agent for programmatic use (no stdio dependency)
- * - `AcpAgent` - Thin wrapper that bridges stdio connection to ClineAgent
- * - `ClineSessionEmitter` - Typed EventEmitter for per-session events
- * - `runAcpMode` - Function to run Cline in stdio-based ACP mode
- *
- * @module acp
- */
-
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
-import { Logger } from "@/shared/services/Logger"
-import { AcpAgent } from "./AcpAgent.js"
-import { nodeToWebReadable, nodeToWebWritable } from "./streamUtils.js"
-
-// Re-export classes for programmatic use
-export { ClineAgent } from "../agent/ClineAgent.js"
-export { ClineSessionEmitter } from "../agent/ClineSessionEmitter.js"
-export type {
-	AcpAgentOptions,
-	AcpSessionState,
-	ClineAgentOptions,
-	ClineSessionEvents,
-	PermissionHandler,
-} from "../agent/types.js"
-export { AcpAgent } from "./AcpAgent.js"
-
-/** Original console methods for restoration if needed */
-const originalConsole = {
-	log: console.log,
-	info: console.info,
-	warn: console.warn,
-	debug: console.debug,
-	error: console.error,
-}
-
-/**
- * Redirect all console output to stderr.
- *
- * In ACP mode, stdout is reserved exclusively for JSON-RPC communication.
- * All logging must go to stderr to avoid corrupting the protocol stream.
- */
-function redirectConsoleToStderr(): void {
-	console.log = (...args) => console.error(...args)
-	console.info = (...args) => console.error(...args)
-	console.warn = (...args) => console.error(...args)
-	console.debug = (...args) => console.error(...args)
-	// console.error already goes to stderr
-}
-
-/**
- * Restore console methods to their original behavior.
- */
-export function restoreConsole(): void {
-	console.log = originalConsole.log
-	console.info = originalConsole.info
-	console.warn = originalConsole.warn
-	console.debug = originalConsole.debug
-	console.error = originalConsole.error
-}
-
-export interface AcpModeOptions {
-	/** Path to Cline configuration directory */
-	config?: string
-	/** Working directory (default: process.cwd()) */
-	cwd?: string
-	/** Additional runtime hooks directory */
-	hooksDir?: string
-	/** Enable verbose/debug logging to stderr */
-	verbose?: boolean
-}
-
-/**
- * Run Cline in ACP mode.
- *
- * This function:
- * 1. Redirects console output to stderr (stdout reserved for JSON-RPC)
- * 2. Sets up the ndJsonStream for stdio communication
- * 3. Creates the AgentSideConnection with our AcpAgent factory
- * 4. Initializes the CLI infrastructure (StateManager, Controller, etc.)
- * 5. Keeps the process alive until the connection closes
- *
- * @param options - Configuration options for ACP mode
- */
-export async function runAcpMode(options: AcpModeOptions = {}): Promise<void> {
-	redirectConsoleToStderr()
-
-	const outputStream = nodeToWebWritable(process.stdout)
-	const inputStream = nodeToWebReadable(process.stdin)
-	const stream = ndJsonStream(outputStream, inputStream)
-	let agent: AcpAgent | null = null
-
-	new AgentSideConnection((conn) => {
-		agent = new AcpAgent(conn, {
-			debug: Boolean(options.verbose),
-			hooksDir: options.hooksDir,
-		})
-		return agent
-	}, stream)
-
-	let isShuttingDown = false
-	const shutdown = async () => {
-		if (isShuttingDown) {
-			// Force exit on second signal
-			process.exit(1)
-		}
-		isShuttingDown = true
-		try {
-			await agent?.shutdown()
-			restoreConsole()
-		} catch (error) {
-			Logger.error("[ACP] Error during shutdown:", error)
-		}
-
-		process.exit(0)
-	}
-
-	process.on("SIGINT", shutdown)
-	process.on("SIGTERM", shutdown)
-
-	// Keep the process alive
-	// The ndJsonStream will handle stdin events automatically.
-	// We need to ensure the process doesn't exit while waiting for input.
-	process.stdin.resume()
-
-	// Handle stdin end (client disconnected)
-	process.stdin.on("end", shutdown)
-
-	// Handle stdin errors
-	process.stdin.on("error", async (error) => {
-		Logger.error("[ACP] stdin error:", error)
-		await shutdown()
-	})
-
-	Logger.info("[ACP] Process is now listening for ACP requests on stdin")
-}

cli/src/acp/streamUtils.ts

@@ -1,54 +0,0 @@
-/**
- * Stream conversion utilities for ACP mode.
- *
- * The ACP SDK's ndJsonStream function expects Web Streams (ReadableStream/WritableStream),
- * but Node.js provides its own stream types. These utilities convert between them.
- *
- * @module acp/streamUtils
- */
-
-import type { Readable, Writable } from "node:stream"
-
-/**
- * Convert a Node.js Writable stream to a Web WritableStream.
- *
- * Used to convert process.stdout for ACP output.
- *
- * @param nodeStream - Node.js Writable stream (e.g., process.stdout)
- * @returns Web WritableStream compatible with ndJsonStream
- */
-export function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array> {
-	return new WritableStream<Uint8Array>({
-		write(chunk) {
-			return new Promise<void>((resolve, reject) => {
-				nodeStream.write(Buffer.from(chunk), (err) => {
-					if (err) {
-						reject(err)
-					} else {
-						resolve()
-					}
-				})
-			})
-		},
-	})
-}
-
-/**
- * Convert a Node.js Readable stream to a Web ReadableStream.
- *
- * Used to convert process.stdin for ACP input.
- *
- * @param nodeStream - Node.js Readable stream (e.g., process.stdin)
- * @returns Web ReadableStream compatible with ndJsonStream
- */
-export function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array> {
-	return new ReadableStream<Uint8Array>({
-		start(controller) {
-			nodeStream.on("data", (chunk: Buffer) => {
-				controller.enqueue(new Uint8Array(chunk))
-			})
-			nodeStream.on("end", () => controller.close())
-			nodeStream.on("error", (err) => controller.error(err))
-		},
-	})
-}

cli/src/agent/ClineSessionEmitter.test.ts

@@ -1,274 +0,0 @@
-/**
- * Tests for ClineSessionEmitter - Typed EventEmitter for per-session ACP events.
- */
-
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { ClineSessionEmitter } from "./ClineSessionEmitter.js"
-import type { SessionUpdatePayload } from "./types.js"
-
-describe("ClineSessionEmitter", () => {
-	let emitter: ClineSessionEmitter
-
-	beforeEach(() => {
-		emitter = new ClineSessionEmitter()
-	})
-
-	describe("on/emit", () => {
-		it("should emit and receive agent_message_chunk events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello, world!" },
-			}
-
-			emitter.on("agent_message_chunk", listener)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive agent_thought_chunk events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"agent_thought_chunk"> = {
-				content: { type: "text", text: "Thinking..." },
-			}
-
-			emitter.on("agent_thought_chunk", listener)
-			emitter.emit("agent_thought_chunk", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive tool_call events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"tool_call"> = {
-				toolCallId: "test-tool-call-id",
-				title: "Test Tool Call",
-				status: "in_progress",
-			}
-
-			emitter.on("tool_call", listener)
-			emitter.emit("tool_call", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive tool_call_update events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"tool_call_update"> = {
-				toolCallId: "test-tool-call-id",
-				status: "completed",
-				rawOutput: { result: "success" },
-			}
-
-			emitter.on("tool_call_update", listener)
-			emitter.emit("tool_call_update", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive available_commands_update events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"available_commands_update"> = {
-				availableCommands: [{ name: "test", description: "Test command" }],
-			}
-
-			emitter.on("available_commands_update", listener)
-			emitter.emit("available_commands_update", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive current_mode_update events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"current_mode_update"> = {
-				currentModeId: "act",
-			}
-
-			emitter.on("current_mode_update", listener)
-			emitter.emit("current_mode_update", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive plan events", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"plan"> = {
-				entries: [{ content: "Step 1", status: "pending", priority: "high" }],
-			}
-
-			emitter.on("plan", listener)
-			emitter.emit("plan", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(payload)
-		})
-
-		it("should emit and receive error events", () => {
-			const listener = vi.fn()
-			const error = new Error("Test error")
-
-			emitter.on("error", listener)
-			emitter.emit("error", error)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-			expect(listener).toHaveBeenCalledWith(error)
-		})
-	})
-
-	describe("multiple listeners", () => {
-		it("should support multiple listeners for the same event", () => {
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.on("agent_message_chunk", listener1)
-			emitter.on("agent_message_chunk", listener2)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener1).toHaveBeenCalledTimes(1)
-			expect(listener2).toHaveBeenCalledTimes(1)
-		})
-
-		it("should call listeners in order of registration", () => {
-			const order: number[] = []
-			const listener1 = vi.fn(() => order.push(1))
-			const listener2 = vi.fn(() => order.push(2))
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.on("agent_message_chunk", listener1)
-			emitter.on("agent_message_chunk", listener2)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(order).toEqual([1, 2])
-		})
-	})
-
-	describe("off", () => {
-		it("should remove a specific listener", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.on("agent_message_chunk", listener)
-			emitter.off("agent_message_chunk", listener)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener).not.toHaveBeenCalled()
-		})
-
-		it("should only remove the specified listener", () => {
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.on("agent_message_chunk", listener1)
-			emitter.on("agent_message_chunk", listener2)
-			emitter.off("agent_message_chunk", listener1)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener1).not.toHaveBeenCalled()
-			expect(listener2).toHaveBeenCalledTimes(1)
-		})
-	})
-
-	describe("once", () => {
-		it("should only call the listener once", () => {
-			const listener = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.once("agent_message_chunk", listener)
-			emitter.emit("agent_message_chunk", payload)
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener).toHaveBeenCalledTimes(1)
-		})
-	})
-
-	describe("removeAllListeners", () => {
-		it("should remove all listeners for a specific event", () => {
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-			const payload: SessionUpdatePayload<"agent_message_chunk"> = {
-				content: { type: "text", text: "Hello" },
-			}
-
-			emitter.on("agent_message_chunk", listener1)
-			emitter.on("agent_message_chunk", listener2)
-			emitter.removeAllListeners("agent_message_chunk")
-			emitter.emit("agent_message_chunk", payload)
-
-			expect(listener1).not.toHaveBeenCalled()
-			expect(listener2).not.toHaveBeenCalled()
-		})
-
-		it("should remove all listeners when no event is specified", () => {
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-
-			emitter.on("agent_message_chunk", listener1)
-			emitter.on("tool_call", listener2)
-			emitter.removeAllListeners()
-			emitter.emit("agent_message_chunk", { content: { type: "text", text: "Hello" } })
-			emitter.emit("tool_call", { toolCallId: "test", title: "Test" })
-
-			expect(listener1).not.toHaveBeenCalled()
-			expect(listener2).not.toHaveBeenCalled()
-		})
-	})
-
-	describe("listenerCount", () => {
-		it("should return the correct number of listeners", () => {
-			const listener1 = vi.fn()
-			const listener2 = vi.fn()
-
-			expect(emitter.listenerCount("agent_message_chunk")).toBe(0)
-
-			emitter.on("agent_message_chunk", listener1)
-			expect(emitter.listenerCount("agent_message_chunk")).toBe(1)
-
-			emitter.on("agent_message_chunk", listener2)
-			expect(emitter.listenerCount("agent_message_chunk")).toBe(2)
-
-			emitter.off("agent_message_chunk", listener1)
-			expect(emitter.listenerCount("agent_message_chunk")).toBe(1)
-		})
-	})
-
-	describe("chaining", () => {
-		it("should support method chaining", () => {
-			const listener = vi.fn()
-
-			const result = emitter.on("agent_message_chunk", listener).on("error", vi.fn()).off("error", vi.fn())
-
-			expect(result).toBe(emitter)
-		})
-	})
-
-	describe("emit return value", () => {
-		it("should return true when there are listeners", () => {
-			emitter.on("agent_message_chunk", vi.fn())
-			const result = emitter.emit("agent_message_chunk", { content: { type: "text", text: "Hello" } })
-			expect(result).toBe(true)
-		})
-
-		it("should return false when there are no listeners", () => {
-			const result = emitter.emit("agent_message_chunk", { content: { type: "text", text: "Hello" } })
-			expect(result).toBe(false)
-		})
-	})
-})

cli/src/agent/ClineSessionEmitter.ts

@@ -1,114 +0,0 @@
-/**
- * Typed EventEmitter for per-session ACP events.
- *
- * This class provides a type-safe wrapper around Node's EventEmitter
- * for emitting and subscribing to session-specific ACP events.
- *
- * @module acp
- */
-
-import { EventEmitter } from "events"
-import type { ClineSessionEvents } from "./public-types.js"
-
-/**
- * Type-safe EventEmitter for ClineAgent session events.
- *
- * Each session has its own emitter instance, allowing consumers to
- * subscribe to events for specific sessions without filtering.
- *
- * @example
- * ```typescript
- * const agent = new ClineAgent({ version: "1.0.0" })
- * const session = await agent.newSession({ cwd: "/path/to/project" })
- *
- * // Subscribe to session events
- * agent.session(session.sessionId).on("agent_message_chunk", (content) => {
- *   console.log("Agent says:", content.text)
- * })
- *
- * agent.session(session.sessionId).on("tool_call", (toolCall) => {
- *   console.log("Tool called:", toolCall.toolName)
- * })
- * ```
- */
-export class ClineSessionEmitter {
-	private readonly emitter: EventEmitter
-
-	constructor() {
-		this.emitter = new EventEmitter()
-		// Increase max listeners since we may have many event types
-		this.emitter.setMaxListeners(20)
-	}
-
-	/**
-	 * Subscribe to a session event.
-	 *
-	 * @param event - The event name to subscribe to
-	 * @param listener - The callback function to invoke when the event is emitted
-	 * @returns This emitter instance for chaining
-	 */
-	on<K extends keyof ClineSessionEvents>(event: K, listener: ClineSessionEvents[K]): this {
-		this.emitter.on(event, listener as (...args: unknown[]) => void)
-		return this
-	}
-
-	/**
-	 * Subscribe to a session event for a single invocation.
-	 *
-	 * @param event - The event name to subscribe to
-	 * @param listener - The callback function to invoke when the event is emitted
-	 * @returns This emitter instance for chaining
-	 */
-	once<K extends keyof ClineSessionEvents>(event: K, listener: ClineSessionEvents[K]): this {
-		this.emitter.once(event, listener as (...args: unknown[]) => void)
-		return this
-	}
-
-	/**
-	 * Unsubscribe from a session event.
-	 *
-	 * @param event - The event name to unsubscribe from
-	 * @param listener - The callback function to remove
-	 * @returns This emitter instance for chaining
-	 */
-	off<K extends keyof ClineSessionEvents>(event: K, listener: ClineSessionEvents[K]): this {
-		this.emitter.off(event, listener as (...args: unknown[]) => void)
-		return this
-	}
-
-	/**
-	 * Emit a session event.
-	 *
-	 * @param event - The event name to emit
-	 * @param args - The arguments to pass to the event listeners
-	 * @returns True if the event had listeners, false otherwise
-	 */
-	emit<K extends keyof ClineSessionEvents>(event: K, ...args: Parameters<ClineSessionEvents[K]>): boolean {
-		return this.emitter.emit(event, ...args)
-	}
-
-	/**
-	 * Remove all listeners for a specific event or all events.
-	 *
-	 * @param event - Optional event name to remove listeners for
-	 * @returns This emitter instance for chaining
-	 */
-	removeAllListeners<K extends keyof ClineSessionEvents>(event?: K): this {
-		if (event) {
-			this.emitter.removeAllListeners(event)
-		} else {
-			this.emitter.removeAllListeners()
-		}
-		return this
-	}
-
-	/**
-	 * Get the number of listeners for a specific event.
-	 *
-	 * @param event - The event name to count listeners for
-	 * @returns The number of listeners
-	 */
-	listenerCount<K extends keyof ClineSessionEvents>(event: K): number {
-		return this.emitter.listenerCount(event)
-	}
-}

cli/src/agent/permissionHandler.ts

@@ -1,356 +0,0 @@
-/**
- * Permission handling for ACP integration.
- *
- * This module handles the translation between ACP permission requests/responses
- * and Cline's internal permission system. It maps ClineAsk types to appropriate
- * ACP permission options and translates user responses back to Cline's format.
- *
- * @module acp/permissionHandler
- */
-
-import type * as acp from "@agentclientprotocol/sdk"
-import type { ClineAsk } from "@shared/ExtensionMessage"
-import type { ClineAskResponse } from "@shared/WebviewMessage"
-import { Logger } from "@/shared/services/Logger.js"
-import type { AcpSessionState, ClinePermissionOption } from "./types.js"
-
-/**
- * Standard permission options for operations that support "always allow".
- * Used for commands, tools, and MCP server operations.
- */
-const STANDARD_PERMISSION_OPTIONS: ClinePermissionOption[] = [
-	{ kind: "allow_once", optionId: "allow_once", name: "Allow Once" },
-	{ kind: "allow_always", optionId: "allow_always", name: "Always Allow" },
-	{ kind: "reject_once", optionId: "reject_once", name: "Reject" },
-]
-
-/**
- * Permission options for operations that don't support "always allow".
- * Used for browser actions and other one-time operations.
- */
-const RESTRICTED_PERMISSION_OPTIONS: ClinePermissionOption[] = [
-	{ kind: "allow_once", optionId: "allow_once", name: "Allow Once" },
-	{ kind: "reject_once", optionId: "reject_once", name: "Reject" },
-]
-
-/**
- * Mapping of ClineAsk types to their permission option sets.
- */
-const ASK_TYPE_PERMISSION_MAP: Partial<Record<ClineAsk, ClinePermissionOption[]>> = {
-	// Commands support "always allow" for auto-approval
-	command: STANDARD_PERMISSION_OPTIONS,
-
-	// Tool operations support "always allow"
-	tool: STANDARD_PERMISSION_OPTIONS,
-
-	// MCP server operations support "always allow"
-	use_mcp_server: STANDARD_PERMISSION_OPTIONS,
-
-	// Browser actions are one-time, no "always allow"
-	browser_action_launch: RESTRICTED_PERMISSION_OPTIONS,
-
-	// Command output continuation - simple allow/reject
-	command_output: RESTRICTED_PERMISSION_OPTIONS,
-}
-
-/**
- * ClineAsk types that require permission handling.
- * Other ask types (like followup, plan_mode_respond) don't need permission UI.
- */
-const PERMISSION_REQUIRING_ASK_TYPES: Set<ClineAsk> = new Set([
-	"command",
-	"tool",
-	"browser_action_launch",
-	"use_mcp_server",
-	"command_output",
-])
-
-/**
- * Result of handling a permission response.
- */
-export interface PermissionHandlerResult {
-	/** Cline's internal response type */
-	response: ClineAskResponse
-	/** Optional text to pass with the response */
-	text?: string
-	/** Whether "always allow" was selected (for auto-approval tracking) */
-	alwaysAllow?: boolean
-	/** Whether the request was cancelled */
-	cancelled?: boolean
-}
-
-/**
- * Check if a ClineAsk type requires permission handling.
- *
- * @param askType - The ClineAsk type to check
- * @returns True if the ask type requires permission UI
- */
-export function requiresPermission(askType: ClineAsk): boolean {
-	return PERMISSION_REQUIRING_ASK_TYPES.has(askType)
-}
-
-/**
- * Get the appropriate permission options for a ClineAsk type.
- *
- * @param askType - The ClineAsk type
- * @returns Array of permission options, or undefined if the ask type doesn't require permission
- */
-export function getPermissionOptionsForAskType(askType: ClineAsk): acp.PermissionOption[] | undefined {
-	const options = ASK_TYPE_PERMISSION_MAP[askType]
-	if (!options) {
-		return undefined
-	}
-
-	// Convert to ACP PermissionOption format
-	return options.map((opt) => ({
-		kind: opt.kind,
-		optionId: opt.optionId,
-		name: opt.name,
-	}))
-}
-
-/**
- * Handle an ACP permission response and translate it to Cline's format.
- *
- * @param response - The ACP permission response from the client
- * @param askType - The original ClineAsk type that triggered the permission request
- * @returns The translated result for Cline's handleWebviewAskResponse
- */
-export function handlePermissionResponse(response: acp.RequestPermissionResponse, askType: ClineAsk): PermissionHandlerResult {
-	// Check if cancelled
-	if (response.outcome.outcome === "cancelled") {
-		return {
-			response: "noButtonClicked",
-			cancelled: true,
-		}
-	}
-
-	// Get the selected option ID
-	const optionId = response.outcome.optionId
-
-	// Translate the option to Cline's response format
-	switch (optionId) {
-		case "allow_once":
-			return {
-				response: "yesButtonClicked",
-				alwaysAllow: false,
-			}
-
-		case "allow_always":
-			return {
-				response: "yesButtonClicked",
-				alwaysAllow: true,
-			}
-
-		case "reject_once":
-		case "reject_always":
-			return {
-				response: "noButtonClicked",
-				alwaysAllow: false,
-			}
-
-		default:
-			// Unknown option ID - treat as rejection for safety
-			Logger.error(`[permissionHandler] Unknown permission option: ${optionId}`)
-			return {
-				response: "noButtonClicked",
-			}
-	}
-}
-
-/**
- * Create a permission request for an ACP tool call.
- *
- * @param toolCall - The ACP tool call that needs permission
- * @param askType - The Cline ask type
- * @returns The permission request options, or null if no permission needed
- */
-export function createPermissionRequest(
-	toolCall: acp.ToolCall,
-	askType: ClineAsk,
-): { toolCall: acp.ToolCall; options: acp.PermissionOption[] } | null {
-	const options = getPermissionOptionsForAskType(askType)
-	if (!options) {
-		return null
-	}
-
-	return {
-		toolCall,
-		options,
-	}
-}
-
-/**
- * Track "always allow" decisions for auto-approval.
- * This maintains a set of tool/command patterns that have been auto-approved.
- */
-export class AutoApprovalTracker {
-	/** Set of auto-approved command prefixes */
-	private autoApprovedCommands: Set<string> = new Set()
-
-	/** Set of auto-approved tool names */
-	private autoApprovedTools: Set<string> = new Set()
-
-	/** Set of auto-approved MCP servers */
-	private autoApprovedMcpServers: Set<string> = new Set()
-
-	/**
-	 * Record an "always allow" decision for a permission request.
-	 *
-	 * @param askType - The Cline ask type that was auto-approved
-	 * @param identifier - The identifier for the operation (command, tool name, etc.)
-	 */
-	recordAlwaysAllow(askType: ClineAsk, identifier: string): void {
-		switch (askType) {
-			case "command":
-				// Store the first word of the command as the key
-				const commandPrefix = identifier.split(" ")[0]
-				this.autoApprovedCommands.add(commandPrefix)
-				break
-
-			case "tool":
-				this.autoApprovedTools.add(identifier)
-				break
-
-			case "use_mcp_server":
-				this.autoApprovedMcpServers.add(identifier)
-				break
-		}
-	}
-
-	/**
-	 * Check if an operation has been auto-approved.
-	 *
-	 * @param askType - The Cline ask type
-	 * @param identifier - The identifier for the operation
-	 * @returns True if the operation was previously auto-approved
-	 */
-	isAutoApproved(askType: ClineAsk, identifier: string): boolean {
-		switch (askType) {
-			case "command":
-				const commandPrefix = identifier.split(" ")[0]
-				return this.autoApprovedCommands.has(commandPrefix)
-
-			case "tool":
-				return this.autoApprovedTools.has(identifier)
-
-			case "use_mcp_server":
-				return this.autoApprovedMcpServers.has(identifier)
-
-			default:
-				return false
-		}
-	}
-
-	/**
-	 * Clear all auto-approval records.
-	 */
-	clear(): void {
-		this.autoApprovedCommands.clear()
-		this.autoApprovedTools.clear()
-		this.autoApprovedMcpServers.clear()
-	}
-}
-
-/**
- * Process a pending permission request for a session.
- *
- * This function coordinates the permission flow:
- * 1. Checks if the operation is already auto-approved
- * 2. If not, requests permission from the ACP client
- * 3. Tracks "always allow" decisions
- * 4. Returns the translated result for Cline
- *
- * @param requestPermission - Function to request permission from the ACP client
- * @param sessionId - The session ID
- * @param toolCall - The tool call requiring permission
- * @param askType - The Cline ask type
- * @param identifier - Identifier for auto-approval tracking
- * @param autoApprovalTracker - The auto-approval tracker
- * @returns The permission handler result
- */
-export async function processPermissionRequest(
-	requestPermission: (
-		sessionId: string,
-		toolCall: acp.ToolCall,
-		options: acp.PermissionOption[],
-	) => Promise<acp.RequestPermissionResponse>,
-	sessionId: string,
-	toolCall: acp.ToolCall,
-	askType: ClineAsk,
-	identifier: string,
-	autoApprovalTracker?: AutoApprovalTracker,
-): Promise<PermissionHandlerResult> {
-	// Check if already auto-approved
-	if (autoApprovalTracker?.isAutoApproved(askType, identifier)) {
-		return {
-			response: "yesButtonClicked",
-			alwaysAllow: true,
-		}
-	}
-
-	// Get permission options for this ask type
-	const options = getPermissionOptionsForAskType(askType)
-	if (!options) {
-		// No permission options defined - allow by default
-		return {
-			response: "yesButtonClicked",
-		}
-	}
-
-	// Request permission from the ACP client
-	const response = await requestPermission(sessionId, toolCall, options)
-
-	// Handle the response
-	const result = handlePermissionResponse(response, askType)
-
-	// Track "always allow" decisions
-	if (result.alwaysAllow && autoApprovalTracker) {
-		autoApprovalTracker.recordAlwaysAllow(askType, identifier)
-	}
-
-	return result
-}
-
-/**
- * Get the identifier for auto-approval tracking from a tool call.
- *
- * @param toolCall - The ACP tool call
- * @param askType - The Cline ask type
- * @returns The identifier string for auto-approval tracking
- */
-export function getAutoApprovalIdentifier(toolCall: acp.ToolCall, askType: ClineAsk): string {
-	const rawInput = toolCall.rawInput as Record<string, unknown> | undefined
-
-	switch (askType) {
-		case "command":
-			return (rawInput?.command as string) || toolCall.title
-
-		case "tool":
-			// Try to get tool name from raw input or title
-			return (rawInput?.tool as string) || toolCall.title
-
-		case "use_mcp_server":
-			return (rawInput?.serverName as string) || toolCall.title
-
-		default:
-			return toolCall.toolCallId
-	}
-}
-
-/**
- * Update the session state's pending tool call after permission is handled.
- *
- * @param sessionState - The session state to update
- * @param toolCallId - The tool call ID that was handled
- * @param approved - Whether the permission was approved
- */
-export function updateSessionStateAfterPermission(sessionState: AcpSessionState, toolCallId: string, approved: boolean): void {
-	// Remove from pending tool calls
-	sessionState.pendingToolCalls.delete(toolCallId)
-
-	// Clear current tool call ID if it matches
-	if (sessionState.currentToolCallId === toolCallId && !approved) {
-		sessionState.currentToolCallId = undefined
-	}
-}

cli/src/agent/public-types.ts

@@ -1,258 +0,0 @@
-/**
- * Public types for the Cline library API.
- *
- * This file contains types that are safe to export to library consumers.
- * It must NOT import any internal types (Controller, StateManager, etc.)
- * to keep the generated declaration files clean.
- *
- * Internal-only extensions of these types live in ./types.ts.
- */
-
-import type * as acp from "@agentclientprotocol/sdk"
-
-// ============================================================
-// Session Update Type Utilities
-// ============================================================
-
-/**
- * Different types of updates that can be sent during session processing.
- *
- * These updates provide real-time feedback about the agent's progress.
- *
- * See protocol docs: [Agent Reports Output](https://agentclientprotocol.com/protocol/prompt-turn#3-agent-reports-output)
- */
-export type SessionUpdateType = acp.SessionUpdate["sessionUpdate"]
-
-/**
- * Different types of update payloads that can be sent during session processing.
- *
- * Each update type has a corresponding payload structure defined in the ACP SessionUpdate union.
- */
-export type SessionUpdatePayload<T extends SessionUpdateType> = Omit<
-	Extract<acp.SessionUpdate, { sessionUpdate: T }>,
-	"sessionUpdate"
->
-
-// ============================================================
-// Permission Handler Callback Types
-// ============================================================
-
-/**
- * Handler function for permission requests.
- * Called when the agent needs permission for a tool call.
- * The handler should present the request to the user and call resolve() with their response.
- */
-export type PermissionHandler = (request: acp.RequestPermissionRequest) => Promise<acp.RequestPermissionResponse>
-
-// ============================================================
-// Session Event Emitter Types
-// ============================================================
-
-/**
- * Maps ACP SessionUpdate types to their event listener signatures.
- * Uses the sessionUpdate discriminator to derive event names and payload types.
- */
-export type ClineSessionEvents = {
-	[K in SessionUpdateType]: (payload: SessionUpdatePayload<K>) => void
-} & {
-	/** Error event for session-level errors (not part of ACP SessionUpdate) */
-	error: (error: Error) => void
-}
-
-// ============================================================
-// ClineAgent Options
-// ============================================================
-
-/**
- * Options for creating a ClineAgent instance.
- */
-export interface ClineAgentOptions {
-	/** Whether debug logging is enabled */
-	debug?: boolean
-	/** Cline Config Directory (defaults to ~/.cline) */
-	clineDir?: string
-	/** Additional runtime hooks directory */
-	hooksDir?: string
-}
-
-/**
- * Options for creating an ACP agent instance.
- */
-export interface AcpAgentOptions {
-	/** Whether debug logging is enabled */
-	debug?: boolean
-	/** Additional runtime hooks directory */
-	hooksDir?: string
-}
-
-// ============================================================
-// Session Types
-// ============================================================
-export type SessionID = string
-
-/**
- * Extended session data stored by Cline for ACP sessions.
- */
-export interface ClineAcpSession {
-	/** Unique session ID */
-	sessionId: SessionID
-	/** Working directory for the session */
-	cwd: string
-	/** Current mode (plan/act) */
-	mode: "plan" | "act"
-	/** MCP servers passed from the client */
-	mcpServers: acp.McpServer[]
-	/** Timestamp when session was created */
-	createdAt: number
-	/** Timestamp of last activity */
-	lastActivityAt: number
-	/** Whether this session was loaded from history (needs resume on first prompt) */
-	isLoadedFromHistory?: boolean
-	/** Model ID override for plan mode (format: "provider/modelId") */
-	planModeModelId?: string
-	/** Model ID override for act mode (format: "provider/modelId") */
-	actModeModelId?: string
-}
-
-/**
- * Lifecycle status of an ACP session.
- *
- * Represents the state machine:
- *   Idle → Processing → Idle       (normal completion)
- *   Idle → Processing → Cancelled  (cancellation, then back to Idle on next prompt)
- */
-export enum AcpSessionStatus {
-	/** Session is idle, waiting for a prompt */
-	Idle = "idle",
-	/** Session is actively processing a prompt */
-	Processing = "processing",
-	/** Session processing was cancelled */
-	Cancelled = "cancelled",
-}
-
-/**
- * State tracking for an active ACP session within Cline.
- */
-export interface AcpSessionState {
-	/** Session ID */
-	sessionId: SessionID
-	/** Current lifecycle status of the session */
-	status: AcpSessionStatus
-	/** Current tool call ID being executed (if any) */
-	currentToolCallId?: string
-	/** Accumulated tool calls for permission batching */
-	pendingToolCalls: Map<string, acp.ToolCall>
-}
-
-// ============================================================
-// Agent Capabilities
-// ============================================================
-
-/**
- * Cline-specific agent capabilities extending the ACP base capabilities.
- */
-export interface ClineAgentCapabilities {
-	/** Support for loading sessions from disk */
-	loadSession: boolean
-	/** Prompt capabilities for the agent */
-	promptCapabilities: {
-		/** Support for image inputs */
-		image: boolean
-		/** Support for audio inputs */
-		audio: boolean
-		/** Support for embedded context (file resources) */
-		embeddedContext: boolean
-	}
-	/** MCP server passthrough capabilities */
-	mcpCapabilities: {
-		/** Support for HTTP MCP servers */
-		http: boolean
-		/** Support for SSE MCP servers */
-		sse: boolean
-	}
-}
-
-/**
- * Cline agent info for ACP initialization response.
- */
-export interface ClineAgentInfo {
-	name: "cline"
-	title: "Cline"
-	version: string
-}
-
-// ============================================================
-// Permission Options
-// ============================================================
-
-/**
- * Permission option as presented to the ACP client.
- */
-export interface ClinePermissionOption {
-	kind: acp.PermissionOptionKind
-	name: string
-	optionId: string
-}
-
-// ============================================================
-// Message Translation
-// ============================================================
-
-/**
- * Result of translating a Cline message to ACP session update(s).
- * A single Cline message may produce multiple ACP updates.
- */
-export interface TranslatedMessage {
-	/** The session updates to send */
-	updates: acp.SessionUpdate[]
-	/** Whether this message requires a permission request */
-	requiresPermission?: boolean
-	/** Permission request details if required */
-	permissionRequest?: Omit<acp.RequestPermissionRequest, "sessionId">
-	/** The toolCallId that was created/used (for tracking across streaming updates) */
-	toolCallId?: string
-}
-
-// ============================================================
-// Re-exported ACP Types
-// ============================================================
-
-export type {
-	Agent,
-	AgentSideConnection,
-	AudioContent,
-	CancelNotification,
-	ClientCapabilities,
-	ContentBlock,
-	ImageContent,
-	InitializeRequest,
-	InitializeResponse,
-	LoadSessionRequest,
-	LoadSessionResponse,
-	McpServer,
-	ModelInfo,
-	NewSessionRequest,
-	NewSessionResponse,
-	PermissionOption,
-	PermissionOptionKind,
-	PromptRequest,
-	PromptResponse,
-	RequestPermissionRequest,
-	RequestPermissionResponse,
-	SessionConfigOption,
-	SessionModelState,
-	SessionNotification,
-	SessionUpdate,
-	SetSessionConfigOptionRequest,
-	SetSessionConfigOptionResponse,
-	SetSessionModelRequest,
-	SetSessionModelResponse,
-	SetSessionModeRequest,
-	SetSessionModeResponse,
-	StopReason,
-	TextContent,
-	ToolCall,
-	ToolCallStatus,
-	ToolCallUpdate,
-	ToolKind,
-} from "@agentclientprotocol/sdk"

cli/src/agent/types.ts

@@ -1,68 +0,0 @@
-/**
- * Internal types for ACP integration with Cline CLI.
- *
- * This file re-exports all public types from ./public-types.ts and adds
- * internal-only Types that reference core modules (Controller, etc.).
- *
- * Library consumers should never import from this file directly — they
- * get the public types via the library entrypoint (exports.ts).
- */
-
-export type {
-	Agent,
-	AgentSideConnection,
-	AudioContent,
-	CancelNotification,
-	ContentBlock,
-	ImageContent,
-	InitializeRequest,
-	InitializeResponse,
-	LoadSessionRequest,
-	LoadSessionResponse,
-	McpServer,
-	ModelInfo,
-	NewSessionRequest,
-	NewSessionResponse,
-	PermissionOption,
-	PermissionOptionKind,
-	PromptRequest,
-	PromptResponse,
-	ReadTextFileRequest,
-	ReadTextFileResponse,
-	RequestPermissionRequest,
-	RequestPermissionResponse,
-	SessionConfigOption,
-	SessionModelState,
-	SessionNotification,
-	SessionUpdate,
-	SetSessionConfigOptionRequest,
-	SetSessionConfigOptionResponse,
-	SetSessionModelRequest,
-	SetSessionModelResponse,
-	SetSessionModeRequest,
-	SetSessionModeResponse,
-	StopReason,
-	TextContent,
-	ToolCall,
-	ToolCallStatus,
-	ToolCallUpdate,
-	ToolKind,
-	WriteTextFileRequest,
-	WriteTextFileResponse,
-} from "@agentclientprotocol/sdk"
-
-export type {
-	AcpAgentOptions,
-	AcpSessionState,
-	ClineAgentCapabilities,
-	ClineAgentInfo,
-	ClineAgentOptions,
-	ClinePermissionOption,
-	ClineSessionEvents,
-	PermissionHandler,
-	SessionUpdatePayload,
-	SessionUpdateType,
-	TranslatedMessage,
-} from "./public-types.js"
-
-export { AcpSessionStatus } from "./public-types.js"

cli/src/components/ActionButtons.tsx

@@ -194,7 +194,7 @@ const errorTypes = ["api_req_failed", "mistake_limit_reached"]
 /**
  * Get button configuration based on message type and state
  */
-export function getButtonConfig(message: ClineMessage | undefined, isStreaming: boolean = false): ButtonConfig {
+export function getButtonConfig(message: ClineMessage | undefined, isStreaming = false): ButtonConfig {
 	if (!message) {
 		return BUTTON_CONFIGS.default
 	}
@@ -295,6 +295,7 @@ export function getVisibleButtons(config: ButtonConfig) {
  * Does not show cancel-only buttons (ThinkingIndicator handles that with esc)
  */
 export const ActionButtons: React.FC<ActionButtonsProps> = ({ config, mode = "act" }) => {
+	const { columns: terminalWidth } = useTerminalSize()
 	if (!config.enableButtons) {
 		return null
 	}
@@ -306,7 +307,6 @@ export const ActionButtons: React.FC<ActionButtonsProps> = ({ config, mode = "ac
 	}
 
 	// Calculate button widths based on terminal width
-	const { columns: terminalWidth } = useTerminalSize()
 	const buttonCount = (hasPrimary ? 1 : 0) + (hasSecondary ? 1 : 0)
 	const gapWidth = buttonCount > 1 ? 1 : 0 // 1 char gap between buttons
 	const availableWidth = terminalWidth - 2 - gapWidth // 1 space padding on each side
@@ -330,8 +330,8 @@ export const ActionButtons: React.FC<ActionButtonsProps> = ({ config, mode = "ac
 
 	return (
 		<Box flexDirection="row" gap={1} marginLeft={1} width="100%">
-			{hasPrimary && renderButton(config.primaryText!, "1")}
-			{hasSecondary && renderButton(config.secondaryText!, hasPrimary ? "2" : "1")}
+			{hasPrimary && config.primaryText && renderButton(config.primaryText, "1")}
+			{hasSecondary && config.secondaryText && renderButton(config.secondaryText, hasPrimary ? "2" : "1")}
 		</Box>
 	)
 }

cli/src/components/SettingsPanelContent.tsx

@@ -105,12 +105,6 @@ const FEATURE_SETTINGS = {
 		label: "Web tools",
 		description: "Enable web search and fetch tools",
 	},
-	strictPlanMode: {
-		stateKey: "strictPlanModeEnabled",
-		default: true,
-		label: "Strict plan mode",
-		description: "Require explicit mode switching",
-	},
 	nativeToolCall: {
 		stateKey: "nativeToolCallEnabled",
 		default: true,

cli/src/exports.ts

@@ -1,71 +1,10 @@
 /**
  * Cline Library Exports
  *
- * This file exports the public API for programmatic use of Cline.
- * Use these classes and types to embed Cline into your applications.
+ * The previous programmatic agent API has been removed.
+ * This module is intentionally empty for package compatibility.
  *
- * @example
- * ```typescript
- * import { ClineAgent } from "cline"
- *
- * const agent = new ClineAgent()
- * await agent.initialize({ clientCapabilities: {} })
- * const session = await agent.newSession({ cwd: process.cwd() })
- * ```
  * @module cline
  */
 
-export { ClineAgent } from "./agent/ClineAgent.js"
-export { ClineSessionEmitter } from "./agent/ClineSessionEmitter.js"
-export type {
-	AcpAgentOptions,
-	AcpSessionState,
-	AcpSessionStatus,
-	Agent,
-	AgentSideConnection,
-	AudioContent,
-	CancelNotification,
-	ClientCapabilities,
-	ClineAcpSession,
-	ClineAgentCapabilities,
-	ClineAgentInfo,
-	ClineAgentOptions,
-	ClinePermissionOption,
-	ClineSessionEvents,
-	ContentBlock,
-	ImageContent,
-	InitializeRequest,
-	InitializeResponse,
-	LoadSessionRequest,
-	LoadSessionResponse,
-	McpServer,
-	ModelInfo,
-	NewSessionRequest,
-	NewSessionResponse,
-	PermissionHandler,
-	PermissionOption,
-	PermissionOptionKind,
-	PromptRequest,
-	PromptResponse,
-	RequestPermissionRequest,
-	RequestPermissionResponse,
-	SessionConfigOption,
-	SessionModelState,
-	SessionNotification,
-	SessionUpdate,
-	SessionUpdatePayload,
-	SessionUpdateType,
-	SetSessionConfigOptionRequest,
-	SetSessionConfigOptionResponse,
-	SetSessionModelRequest,
-	SetSessionModelResponse,
-	SetSessionModeRequest,
-	SetSessionModeResponse,
-	StopReason,
-	TextContent,
-	ToolCall,
-	ToolCallStatus,
-	ToolCallUpdate,
-	ToolKind,
-	TranslatedMessage,
-} from "./agent/public-types.js"
+export {}

cli/src/index.ts

@@ -26,7 +26,6 @@ import { Session } from "@/shared/services/Session"
 import { getProviderModelIdKey } from "@/shared/storage"
 import { isOpenaiReasoningEffort, OPENAI_REASONING_EFFORT_OPTIONS, type OpenaiReasoningEffort } from "@/shared/storage/types"
 import { version as CLI_VERSION } from "../package.json"
-import { runAcpMode } from "./acp/index.js"
 import { App } from "./components/App"
 import { KanbanMigrationView } from "./components/KanbanMigrationView"
 import { checkRawModeSupport } from "./context/StdinContext"
@@ -1182,7 +1181,6 @@ program
 	.option("--double-check-completion", "Reject first completion attempt to force re-verification")
 	.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
 	.option("--hooks-dir <path>", "Path to additional hooks directory for runtime hook injection")
-	.option("--acp", "Run in ACP (Agent Client Protocol) mode for editor integration")
 	.option("--update", "Check for updates and install if available")
 	.option("--kanban", `Run ${KANBAN_LAUNCH_COMMAND}`)
 	.option("--tui", "Open the legacy terminal UI instead of the kanban experience")
@@ -1195,7 +1193,7 @@ program
 		}
 
 		if (options.update) {
-			if (prompt || options.taskId || options.continue || options.kanban || options.tui || options.acp) {
+			if (prompt || options.taskId || options.continue || options.kanban || options.tui) {
 				printWarning("Use --update without a prompt or task flags.")
 				exit(1)
 			}
@@ -1214,17 +1212,6 @@ program
 			return
 		}
 
-		// Check for ACP mode first - this takes precedence over everything else
-		if (options.acp) {
-			await runAcpMode({
-				config: options.config,
-				cwd: options.cwd,
-				hooksDir: options.hooksDir,
-				verbose: options.verbose,
-			})
-			return
-		}
-
 		// Always check for piped stdin content
 		const stdinInput = await readStdinIfPiped()
 

cli/tsconfig.lib.json

@@ -9,12 +9,6 @@
 		"outDir": "dist/types"
 	},
 	"include": [
-		"src/exports.ts",
-		"src/agent/public-types.ts",
-		"src/agent/ClineAgent.ts",
-		"src/agent/ClineSessionEmitter.ts",
-		"src/agent/types.ts",
-		"src/agent/messageTranslator.ts",
-		"src/agent/permissionHandler.ts"
+		"src/exports.ts"
 	]
 }

docs/cline-cli/acp-editor-integrations.mdx

@@ -1,216 +0,0 @@
----
-title: "ACP: Editor Integrations"
-description: "Use Cline in JetBrains, Neovim, Zed, and other editors via the Agent Client Protocol"
----
-
-
-Cline CLI supports the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/), an open standard that enables AI coding agents to work across different editors and IDEs. This means you can use the full Cline agent—with all its capabilities including Skills, Hooks, and MCP integrations—in your preferred development environment.
-
-## Why ACP?
-
-- **Editor flexibility**: Use Cline in JetBrains, Neovim, Zed, or any ACP-compatible editor
-- **No feature compromises**: Full access to Cline's capabilities regardless of editor
-- **Team consistency**: Same AI assistant across different developer workflows
-- **Open standard**: Built on Zed's open Agent Client Protocol specification
-
-## JetBrains IDEs
-
-[JetBrains](https://www.jetbrains.com) IDEs include IntelliJ IDEA, PyCharm, WebStorm, and more. They offer built-in AI Assistant with ACP support.
-
-<Note>
-**Recommended: Native JetBrains Plugin**
-
-For the best JetBrains experience, install the [native Cline plugin](/getting-started/installing-cline#jetbrains-ides) from the JetBrains Marketplace. It provides full IDE integration and the complete Cline experience.
-
-The ACP setup below is an alternative way to use Cline CLI features in JetBrains IDEs.
-</Note>
-
-Alternatively, you can run Cline CLI in IntelliJ IDEA, PyCharm, WebStorm, and all other JetBrains IDEs through their built-in AI Assistant with ACP support.
-
-<video
-  src="https://storage.googleapis.com/cline_public_images/cline-acp-jetbrains.mp4"
-  autoPlay
-  loop
-  muted
-  playsInline
-  style={{ width: "100%", borderRadius: "8px", marginTop: "16px", marginBottom: "16px" }}
-/>
-
-### Setup
-
-1. **Install Cline CLI** (if not already installed):
-   ```bash
-   npm i -g cline
-   ```
-
-2. **Authenticate with Cline**:
-   ```bash
-   cline auth
-   ```
-
-3. **Configure JetBrains AI Assistant**:
-   - Open your JetBrains IDE
-   - Navigate to `Settings | Tools | AI Assistant | Agents`
-   - Click "Add Custom Agent"
-   - This opens/creates `~/.jetbrains/acp.json`
-
-4. **Add Cline to `acp.json`**:
-   ```json
-   {
-     "agent_servers": {
-       "Cline": {
-         "command": "cline",
-         "args": ["--acp"],
-         "env": {}
-       }
-     }
-   }
-   ```
-
-5. **Use Cline**:
-   - Open the AI Chat tool window
-   - Select "Cline" from the agent dropdown
-   - Start coding with Cline in your JetBrains IDE!
-
-<Tip>
-JetBrains AI Assistant can expose its built-in MCP server to Cline, giving Cline access to IDE-specific tools and context.
-</Tip>
-
-## Neovim
-
-[Neovim](https://neovim.io) is a hyperextensible Vim-based text editor loved by developers for its speed and flexibility. Use Cline in Neovim through the [agentic.nvim](https://github.com/carlos-algms/agentic.nvim) or [avante.nvim](https://github.com/yetone/avante.nvim) plugins, which provide ACP integration.
-
-<video
-  src="https://storage.googleapis.com/cline_public_images/cline-acp-neovim-avante.mp4"
-  autoPlay
-  loop
-  muted
-  playsInline
-  style={{ width: "100%", borderRadius: "8px", marginTop: "16px", marginBottom: "16px" }}
-/>
-
-### Setup with agentic.nvim
-
-1. **Install Cline CLI** (if not already installed):
-   ```bash
-   npm i -g cline
-   ```
-
-2. **Authenticate with Cline**:
-   ```bash
-   cline auth
-   ```
-
-3. **Install agentic.nvim** using lazy.nvim:
-   ```lua
-   {
-     "carlos-algms/agentic.nvim",
-     opts = {
-       provider = "cline-acp",
-       acp_providers = {
-         ["cline-acp"] = {
-           command = "cline",
-           args = {"--acp"},
-         },
-       },
-     },
-     keys = {
-       {"<C-\\>", function() require("agentic").toggle() end, mode={"n","v","i"}, desc="Toggle Cline Chat"},
-     },
-   }
-   ```
-
-4. **Use Cline**:
-   - Press `<C-\>` to toggle Cline chat
-   - Start coding with Cline in Neovim!
-
-### Setup with avante.nvim
-
-Follow the [avante.nvim documentation](https://github.com/yetone/avante.nvim) for configuring external ACP agents and point it to `cline --acp`.
-
-## Zed
-
-[Zed](https://zed.dev) is a high-performance, multiplayer code editor built from the ground up for speed and collaboration. Zed's team created the Agent Client Protocol, making Cline a natural fit for this editor.
-
-### Setup
-
-1. **Install Cline CLI** (if not already installed):
-   ```bash
-   npm i -g cline
-   ```
-
-2. **Authenticate with Cline**:
-   ```bash
-   cline auth
-   ```
-
-3. **Configure Zed**:
-   - Open Zed settings (`Cmd/Ctrl + ,`)
-   - Add Cline to your `settings.json`:
-   ```json
-   {
-     "agent_servers": {
-       "Cline": {
-         "type": "custom",
-         "command": "cline",
-         "args": ["--acp"],
-         "env": {}
-       }
-     }
-   }
-   ```
-
-4. **Use Cline**:
-   - Open the AI assistant panel
-   - Select "Cline" from the agent dropdown
-   - Start coding with Cline in Zed!
-
-## Other Editors
-
-Any editor that supports the Agent Client Protocol can run Cline. Check your editor's documentation for ACP configuration instructions, then point it to:
-
-```bash
-cline --acp
-```
-
-## Troubleshooting
-
-### Agent not appearing
-
-- Ensure Cline CLI is installed globally: `npm i -g cline`
-- Verify authentication: `cline auth`
-- Check that `cline --acp` runs without errors
-- Restart your editor after configuration changes
-
-### Permission errors
-
-If Cline can't access files or run commands:
-- Check that your editor's ACP integration passes the correct working directory
-- Verify file permissions in your project
-- Ensure Cline has approval settings configured correctly
-
-### Connection issues
-
-- Make sure no other Cline instance is using the same configuration directory
-- Check editor logs for ACP-related errors
-- Try running `cline --acp` manually to test the connection
-
-## Learn More
-
-<Columns cols={2}>
-  <Card title="CLI Overview" icon="terminal" href="/cline-cli/overview">
-    Learn about Cline CLI's core capabilities and use cases.
-  </Card>
-  
-  <Card title="Headless Mode" icon="robot" href="/cline-cli/three-core-flows">
-    Run Cline autonomously in scripts, CI/CD pipelines, and automated workflows.
-  </Card>
-  
-  <Card title="Skills" icon="graduation-cap" href="/customization/skills">
-    Understand how Cline's Skills work across all editors via ACP.
-  </Card>
-  
-  <Card title="Hooks" icon="link" href="/customization/hooks">
-    Learn how to enforce policies with Hooks in any editor.
-  </Card>
-</Columns>

docs/cline-cli/overview.mdx

@@ -236,10 +236,6 @@ To use MCP servers with the CLI, add your server configuration to `~/.cline/data
     Configure settings, rules, workflows, and environment variables.
   </Card>
   
-  <Card title="Use in Other Editors" icon="code" href="/cline-cli/acp-editor-integrations">
-    Run Cline as an ACP agent in JetBrains, Neovim, Zed, and more.
-  </Card>
-  
   <Card title="CLI Samples" icon="flask" href="/cline-cli/samples/overview">
     Real-world examples of headless workflows and automation patterns.
   </Card>

docs/cline-sdk/overview.md

@@ -1,769 +0,0 @@
----
-title: "Cline SDK"
-sidebarTitle: "SDK (Programmatic Use)"
-description: "Embed Cline as a programmable coding agent in your Node.js applications using an ACP-compatible TypeScript API."
----
-
-# Cline SDK
-
-The Cline SDK lets you embed Cline as a programmable coding agent in your Node.js applications. It exposes the same capabilities as the Cline CLI and VS Code extension — file editing, command execution, browser use, MCP servers — through a TypeScript API that conforms to the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/protocol/schema).
-
-## Installation
-
-```bash
-npm install cline
-```
-
-If you want direct ACP type imports as well:
-
-```bash
-npm install @agentclientprotocol/sdk
-```
-
-Requires Node.js 20+.
-
-## Quick Start
-
-```typescript
-import { ClineAgent } from "cline";
-
-const CLINE_DIR = "/Users/username/.cline";
-const agent = new ClineAgent({ clineDir: CLINE_DIR });
-
-// 1. Initialize — negotiates capabilities
-const initializeResponse = await agent.initialize({
-    protocolVersion: 1,
-    // these are the capabilities that the client (you) supports
-    // The cline agent may or may not use them, but it needs to know about them to make informed decisions about what tools to use.
-    clientCapabilities: {
-        fs: { readTextFile: true, writeTextFile: true },
-        terminal: true,
-    },
-});
-
-const { agentInfo, authMethods } = initializeResponse;
-console.log("Agent info:", agentInfo); // contains things like agent name and version
-console.log("Auth methods:", authMethods); // contains a list of supported authentication methods. More auth methods coming soon
-
-// 2. Authenticate if needed
-// If you skip this step, ClineAgent will look in CLINE_DIR for any existing credentials and authenticate with those
-await agent.authenticate({ methodId: "cline-oauth" });
-
-// 3. Create a session.
-// A session represents a conversation or task with the agent. You can have multiple sessions for different tasks or conversations.
-const { sessionId } = await agent.newSession({
-    cwd: process.cwd(),
-    mcpServers: [], // mcpServers field not supported yet, but exposed here to maintain conformance with acp protocol
-});
-
-// 4. Agent updates are sent via events. You can subscribe to these events to get real-time updates on the agent's progress, tool calls, and more.
-const emitter = agent.emitterForSession(sessionId);
-
-emitter.on("agent_message_chunk", (payload) => {
-    process.stdout.write(
-        payload.content.type === "text"
-            ? payload.content.text
-            : `[${payload.content.type}]`,
-    );
-});
-emitter.on("agent_thought_chunk", (payload) => {
-    process.stdout.write(
-        payload.content.type === "text"
-            ? payload.content.text
-            : `[${payload.content.type}]`,
-    );
-});
-emitter.on("tool_call", (payload) => {
-    console.log(`[tool] ${payload.title}`);
-});
-emitter.on("error", (err) => {
-    console.error("[session error]", err);
-});
-
-// 5. Send a prompt and wait for completion
-const { stopReason } = await agent.prompt({
-    sessionId,
-    prompt: [{ type: "text", text: "Create a hello world Express server" }],
-});
-
-console.log("Done:", stopReason);
-
-// 6. Clean up
-await agent.shutdown();
-
-```
-
-## Core Concepts
-
-### Agent Lifecycle
-
-The SDK follows the ACP lifecycle:
-
-```
-initialize() → authenticate() → newSession() → prompt() ⇄ events → shutdown()
-```
-
-| Step | Method | Purpose |
-|------|--------|---------|
-| Init | `initialize()` | Exchange protocol version and capabilities |
-| Auth | `authenticate()` | OAuth flow for Cline or OpenAI Codex accounts. Optional step if cline config directory already has credentials |
-| Session | `newSession()` | Create an isolated conversation context |
-| Prompt | `prompt()` | Send user messages; blocks until the turn ends |
-| Cancel | `cancel()` | Abort an in-progress prompt turn |
-| Mode | `setSessionMode()` | Switch between `"plan"` and `"act"` modes |
-| Model | `unstable_setSessionModel()` | Change the backing LLM (experimental) |
-| Shutdown | `shutdown()` | Abort all tasks, flush state, release resources |
-
-### Sessions
-
-A session is an independent conversation with its own task history and working directory. You can run multiple sessions concurrently.
-
-```typescript
-const { sessionId, modes, models } = await agent.newSession({
-  cwd: "/path/to/project",
-  mcpServers: [], // mcpServers field not supported yet, but exposed here to maintain conformance with acp protocol
-})
-```
-
-The response includes:
-- `sessionId` — use this in all subsequent calls
-- `modes` — available modes (`plan`, `act`) and the current mode
-- `models` — available models and the current model ID
-
-Access session metadata via the read-only `sessions` map:
-
-```typescript
-const session = agent.sessions.get(sessionId)
-// { sessionId, cwd, mode, mcpServers, createdAt, lastActivityAt, ... }
-```
-
-### Prompting
-
-`prompt()` sends a user message and blocks until the agent finishes its turn. While the prompt is processing, the agent streams output via session events.
-
-```typescript
-const response = await agent.prompt({
-  sessionId,
-  prompt: [
-    { type: "text", text: "Refactor the auth module to use JWT" },
-  ],
-})
-```
-
-The prompt array accepts multiple content blocks:
-
-```typescript
-// Text + image + file context
-await agent.prompt({
-  sessionId,
-  prompt: [
-    { type: "text", text: "What's in this screenshot?" },
-    { type: "image", data: base64ImageData, mimeType: "image/png" },
-    {
-      type: "resource",
-      resource: {
-        uri: "file:///path/to/relevant-file.ts",
-        mimeType: "text/plain",
-        text: fileContents,
-      },
-    },
-  ],
-})
-```
-
-#### Content Block Types
-
-| Type | Fields | Description |
-|------|--------|-------------|
-| `TextContent` | `{ type: "text", text: string }` | Plain text message |
-| `ImageContent` | `{ type: "image", mimeType: string, data: string }` | Base64-encoded image |
-| `EmbeddedResource` | `{ type: "resource", resource: { uri: string, mimeType?: string, text?: string, blob?: string } }` | File or resource context |
-
-#### Stop Reasons
-
-`prompt()` resolves with a `stopReason`. The ACP `StopReason` type defines the full set of possible values:
-
-| Value | Meaning |
-|-------|---------|
-| `"end_turn"` | Agent finished normally (completed task or waiting for user input) |
-| `"error"` | An error occurred |
-
-> **Note:** Cline currently returns `"end_turn"` or `"error"`. Other `StopReason` values like `"max_tokens"` or `"cancelled"` are part of the ACP type but may not be produced by the current implementation.
-
-### Streaming Events
-
-Subscribe to real-time output via `ClineSessionEmitter`. Each session has its own emitter.
-
-```typescript
-const emitter = agent.emitterForSession(sessionId)
-```
-
-#### Event Types
-
-All events correspond to [ACP `SessionUpdate` types](https://agentclientprotocol.com/protocol/schema#SessionUpdate):
-
-| Event | Payload | Description |
-|-------|---------|-------------|
-| `agent_message_chunk` | `{ content: ContentBlock }` | Streamed text from the agent |
-| `agent_thought_chunk` | `{ content: ContentBlock }` | Internal reasoning / chain-of-thought |
-| `tool_call` | `ToolCall` | New tool invocation (file edit, command, etc.) |
-| `tool_call_update` | `ToolCallUpdate` | Progress/result update for an existing tool call |
-| `plan` | `{ entries: PlanEntry[] }` | Agent's execution plan |
-| `available_commands_update` | `{ availableCommands: AvailableCommand[] }` | Slash commands the agent supports |
-| `current_mode_update` | `{ currentModeId: string }` | Mode changed (plan/act) |
-| `user_message_chunk` | `{ content: ContentBlock }` | User message chunks (for multi-turn) |
-| `config_option_update` | `{ configOptions: SessionConfigOption[] }` | Configuration changed |
-| `session_info_update` | Session metadata | Session metadata changed |
-| `error` | `Error` | Session-level error (not an ACP update) |
-
-```typescript
-emitter.on("agent_message_chunk", (payload) => {
-  // payload.content is a ContentBlock — usually { type: "text", text: "..." }
-  process.stdout.write(payload.content.text)
-})
-
-emitter.on("agent_thought_chunk", (payload) => {
-  console.log("[thinking]", payload.content.text)
-})
-
-emitter.on("tool_call", (payload) => {
-  console.log(`[${payload.kind}] ${payload.title} (${payload.status})`)
-})
-
-emitter.on("tool_call_update", (payload) => {
-  console.log(`  → ${payload.toolCallId}: ${payload.status}`)
-})
-
-emitter.on("error", (err) => {
-  console.error("Session error:", err)
-})
-```
-
-The emitter supports `on`, `once`, `off`, and `removeAllListeners`.
-
-### Permission Handling
-
-When the agent wants to execute a tool (edit a file, run a command, etc.), it requests permission. You **must** set a permission handler or all tool calls will be auto-rejected.
-
-```typescript
-agent.setPermissionHandler(async (request) => {
-  // request.toolCall — details about what the agent wants to do
-  // request.options — available choices (allow_once, reject_once, etc.)
-
-  console.log(`Permission requested: ${request.toolCall.title}`)
-  console.log("Options:", request.options.map(o => `${o.optionId} (${o.kind})`))
-
-  // Auto-approve everything:
-  const allowOption = request.options.find(o => o.kind.includes("allow"))
-  if (allowOption) {
-    return { outcome: { outcome: "selected", optionId: allowOption.optionId } }
-  } else {
-    return { outcome: { outcome: "rejected" } }
-  }
-})
-```
-
-#### Permission Options
-
-Each permission request includes an array of `PermissionOption` objects:
-
-| `kind` | Meaning |
-|--------|---------|
-| `allow_once` | Approve this single operation |
-| `allow_always` | Approve and remember for future operations (sent for commands, tools, MCP servers) |
-| `reject_once` | Deny this single operation |
-
-**Important:** If no permission handler is set, all tool calls are rejected for safety.
-
-### Modes
-
-Cline supports two modes:
-
-- **`plan`** — The agent gathers information and creates a plan without executing actions
-- **`act`** — The agent executes actions (file edits, commands, etc.)
-
-```typescript
-// Switch to plan mode
-await agent.setSessionMode({ sessionId, modeId: "plan" })
-
-// Switch back to act mode
-await agent.setSessionMode({ sessionId, modeId: "act" })
-```
-
-The current mode is returned in `newSession()`
-
-### Model Selection
-
-Change the backing model with `unstable_setSessionModel()`. The model ID format is `"provider/modelId"`.
-
-```typescript
-await agent.unstable_setSessionModel({
-  sessionId,
-  modelId: "anthropic/claude-sonnet-4-20250514",
-})
-```
-
-This sets the model for both plan and act modes. Available providers include `anthropic`, `openai-native`, `gemini`, `bedrock`, `deepseek`, `mistral`, `groq`, `xai`, and others. Model Ids can be found in the NewSessionResponse object after calling `agent.newSession(..)`
-
-> **Note:** This API is experimental and may change. 
-
-### Authentication
-
-The SDK supports two OAuth flows:
-
-```typescript
-// Cline account (uses browser OAuth)
-await agent.authenticate({ methodId: "cline-oauth" })
-
-// OpenAI Codex / ChatGPT subscription
-await agent.authenticate({ methodId: "openai-codex-oauth" })
-```
-
-Both methods open a browser window for the OAuth flow and block until authentication completes (5-minute timeout for Cline OAuth).
-
-For BYO (bring-your-own) API key providers, you can pre-configure credentials using the Cline CLI before using the SDK:
-
-```bash
-# Configure an Anthropic API key (default directory: ~/.cline/data/)
-cline auth -p anthropic -k "sk-ant-..." -m anthropic/claude-sonnet-4-20250514
-
-# Configure an OpenRouter API key
-cline auth -p openrouter -k "sk-or-..." -m openrouter/anthropic/claude-sonnet-4
-```
-
-This writes credentials to `~/.cline/data/`. Once configured, the SDK will use these credentials automatically — no `authenticate()` call needed.
-
-**Using a custom directory:** If you specify a custom `clineDir` when creating `ClineAgent`, you must use the same path with `--config` when running `cline auth`:
-
-```typescript
-// SDK code using custom directory
-const agent = new ClineAgent({ clineDir: "/custom/path" })
-```
-
-```bash
-# CLI auth command must use the same path
-cline auth -p anthropic -k "sk-ant-..." -m anthropic/claude-sonnet-4-20250514 --config /custom/path
-```
-
-### Cancellation
-
-Cancel an in-progress prompt turn:
-
-```typescript
-await agent.cancel({ sessionId })
-```
-
-## API Reference
-
-### Constructor
-
-```typescript
-new ClineAgent(options: ClineAgentOptions)
-```
-
-```typescript
-interface ClineAgentOptions {
-  /** Enable debug logging (default: false) */
-  debug?: boolean
-  /** Custom Cline config directory (default: ~/.cline) */
-  clineDir?: string
-  /** Additional runtime hooks directory */
-  hooksDir?: string
-}
-```
-
-The `clineDir` option lets you isolate configuration and task history per-application:
-
-```typescript
-const agent = new ClineAgent({
-  clineDir: "/tmp/my-app-cline",
-})
-```
-
-### Methods
-
-#### `initialize(params): Promise<InitializeResponse>`
-
-Initialize the agent and negotiate protocol capabilities.
-
-```typescript
-const response = await agent.initialize({
-  clientCapabilities: {},
-  protocolVersion: 1,
-})
-
-// Response includes:
-{
-  protocolVersion: 1,
-  agentCapabilities: {
-    loadSession: true,
-    promptCapabilities: { image: true, audio: false, embeddedContext: true },
-    mcpCapabilities: { http: true, sse: false }
-  },
-  agentInfo: { name: "cline", version: "<installed_version>" },
-  authMethods: [
-    { id: "cline-oauth", name: "Sign in with Cline", description: "..." },
-    { id: "openai-codex-oauth", name: "Sign in with ChatGPT", description: "..." }
-  ]
-}
-```
-
-#### Client Capabilities
-
-The `clientCapabilities` object in `initialize()` declares what your environment supports. It is part of the ACP protocol handshake.
-
-| Capability | Type | Description |
-|------------|------|-------------|
-| `fs.readTextFile` | `boolean` | Client supports file read requests |
-| `fs.writeTextFile` | `boolean` | Client supports file write requests |
-| `terminal` | `boolean` | Client supports terminal command execution |
-
-**When using `ClineAgent` directly (SDK use)**, the agent always uses standalone providers for file operations and terminal commands — it reads/writes files and runs shell commands on the local machine regardless of what you pass here. Simply pass `{}`:
-
-```typescript
-await agent.initialize({ protocolVersion: 1, clientCapabilities: {} })
-```
-
-These capabilities only affect behavior when `ClineAgent` is used through the `AcpAgent` stdio wrapper (e.g., IDE integrations), where an ACP connection delegates operations back to the client.
-
-#### `newSession(params): Promise<NewSessionResponse>`
-
-Create a new conversation session.
-
-```typescript
-const session = await agent.newSession({
-  cwd: "/path/to/project",
-  mcpServers: [
-    {
-      type: "stdio",
-      name: "filesystem",
-      command: "npx",
-      args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"],
-      env: {},
-    },
-  ],
-})
-
-// Response includes:
-{
-  sessionId: "uuid-string",
-  modes: {
-    availableModes: [
-      { id: "plan", name: "Plan", description: "Gather information and create a detailed plan" },
-      { id: "act", name: "Act", description: "Execute actions to accomplish the task" }
-    ],
-    currentModeId: "act"
-  },
-  models: {
-    currentModelId: "anthropic/claude-sonnet-4-20250514",
-    availableModels: [{ modelId: "anthropic/claude-sonnet-4-20250514", name: "claude-sonnet-4-20250514" } /* ... */]
-  }
-}
-```
-
-> **Note:** `newSession()` may throw an auth-required error if credentials are not configured yet.
-
-#### `prompt(params): Promise<PromptResponse>`
-
-Send a user prompt to the agent. This is the main method for interacting with Cline. Blocks until the agent finishes its turn.
-
-```typescript
-const response = await agent.prompt({
-  sessionId: session.sessionId,
-  prompt: [
-    { type: "text", text: "Create a function that adds two numbers" },
-  ],
-})
-
-// Response: { stopReason: "end_turn" | "max_tokens" | "cancelled" | "error" }
-```
-
-#### `cancel(params): Promise<void>`
-
-Cancel an ongoing prompt operation.
-
-```typescript
-await agent.cancel({ sessionId: session.sessionId })
-```
-
-#### `setSessionMode(params): Promise<SetSessionModeResponse>`
-
-Switch between plan and act modes.
-
-```typescript
-await agent.setSessionMode({ sessionId, modeId: "plan" })
-```
-
-#### `unstable_setSessionModel(params): Promise<SetSessionModelResponse>`
-
-Change the model for the session. Model ID format depends on the inference provider. See NewSessionResponse object to get modelIds.
-
-```typescript
-await agent.unstable_setSessionModel({
-  sessionId,
-  modelId: "anthropic/claude-sonnet-4-20250514",
-})
-```
-
-#### `authenticate(params): Promise<AuthenticateResponse>`
-
-Authenticate with a provider. Opens a browser window for OAuth flow.
-
-```typescript
-await agent.authenticate({ methodId: "cline-oauth" })
-```
-
-Current methodIds we support:
-
-| methodId             | Description                   |
-| -------------------- | ----------------------------- |
-| `cline-oauth`        | use cline inference provider  |
-| `openai-codex-oauth` | use your chatgpt subscription |
-| more coming soon!... |                               |
-
-#### `shutdown(): Promise<void>`
-
-Clean up all resources. Call this when done.
-
-```typescript
-await agent.shutdown()
-```
-
-#### `setPermissionHandler(handler)`
-
-Set a callback to handle tool permission requests. The handler receives a `RequestPermissionRequest` and must return a `Promise<RequestPermissionResponse>`.
-
-```typescript
-agent.setPermissionHandler(async (request) => {
-  // request.toolCall — details about what the agent wants to do
-  // request.options — available choices (allow_once, reject_once, etc.)
-  const allow = request.options.find(o => o.kind === "allow_once")
-  return {
-    outcome: allow
-      ? { outcome: "selected", optionId: allow.optionId }
-      : { outcome: "cancelled" }
-  }
-})
-```
-
-#### `emitterForSession(sessionId): ClineSessionEmitter`
-
-Get the typed event emitter for a session.
-
-```typescript
-const emitter = agent.emitterForSession(session.sessionId)
-```
-
-#### `sessions` (read-only Map)
-
-Access active sessions:
-
-```typescript
-for (const [sessionId, session] of agent.sessions) {
-  console.log(sessionId, session.cwd, session.mode)
-}
-```
-
-## Error Handling
-
-SDK methods throw standard JavaScript errors. Key error scenarios:
-
-| Method | Error | Cause |
-|--------|-------|-------|
-| `newSession()` | `RequestError` (auth required) | No credentials configured — call `authenticate()` or pre-configure via CLI |
-| `prompt()` | `Error("Session not found")` | Invalid `sessionId` |
-| `prompt()` | `Error("already processing")` | Called `prompt()` while a previous prompt is still running on the same session |
-| `unstable_setSessionModel()` | `Error("Invalid modelId format")` | Model ID must be `"provider/modelId"` format (e.g., `"anthropic/claude-sonnet-4-20250514"`) |
-| `authenticate()` | `Error("Unknown authentication method")` | Invalid `methodId` — use `"cline-oauth"` or `"openai-codex-oauth"` |
-| `authenticate()` | `Error("Authentication timed out")` | OAuth flow not completed within 5 minutes |
-
-```typescript
-try {
-  const { sessionId } = await agent.newSession({ cwd: process.cwd(), mcpServers: [] })
-} catch (error) {
-  if (error.message?.includes("auth")) {
-    // Need to authenticate first
-    await agent.authenticate({ methodId: "cline-oauth" })
-  }
-}
-```
-
-Session-level errors during `prompt()` execution are emitted on the session emitter rather than thrown:
-
-```typescript
-emitter.on("error", (err) => {
-  console.error("Session error:", err.message)
-})
-```
-
-## Full Example: Auto-Approve Agent
-
-```typescript
-import { ClineAgent } from "cline";
-
-async function runTask(taskPrompt: string, cwd: string) {
-    const agent = new ClineAgent({ clineDir: "/path/to/.cline" });
-
-    await agent.initialize({
-        protocolVersion: 1,
-        clientCapabilities: {},
-    });
-
-    const { sessionId } = await agent.newSession({ cwd, mcpServers: [] });
-
-    // Auto-approve all tool calls
-    agent.setPermissionHandler(async (request) => {
-        const allow = request.options.find((o) => o.kind === "allow_once");
-        return {
-            outcome: allow
-                ? { outcome: "selected", optionId: allow.optionId }
-                : { outcome: "cancelled" },
-        };
-    });
-
-    // Collect output
-    const output: string[] = [];
-    const emitter = agent.emitterForSession(sessionId);
-
-    emitter.on("agent_message_chunk", (p) => {
-        if (p.content.type === "text") output.push(p.content.text);
-    });
-
-    emitter.on("tool_call", (p) => {
-        console.log(`[tool] ${p.title}`);
-    });
-
-    const { stopReason } = await agent.prompt({
-        sessionId,
-        prompt: [{ type: "text", text: taskPrompt }],
-    });
-
-    console.log("\n--- Agent Output ---");
-    console.log(output.join(""));
-    console.log(`\nStop reason: ${stopReason}`);
-
-    await agent.shutdown();
-}
-
-runTask("Create a README.md for this project", process.cwd());
-```
-
-## Full Example: Interactive Permission Flow
-
-```typescript
-import { ClineAgent, type PermissionHandler } from "cline";
-import * as readline from "readline";
-
-const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-});
-const ask = (q: string) => new Promise<string>((res) => rl.question(q, res));
-
-const interactivePermissions: PermissionHandler = async (request) => {
-    console.log(`\n⚠️  Permission: ${request.toolCall.title}`);
-
-    for (const [i, opt] of request.options.entries()) {
-        console.log(`  ${i + 1}. [${opt.kind}] ${opt.name}`);
-    }
-
-    const choice = await ask("Choose (number): ");
-    const idx = parseInt(choice, 10) - 1;
-    const selected = request.options[idx];
-
-    if (selected) {
-        return {
-            outcome: { outcome: "selected", optionId: selected.optionId },
-        };
-    } else {
-        return { outcome: { outcome: "cancelled" } };
-    }
-};
-
-async function main() {
-    const agent = new ClineAgent({});
-    await agent.initialize({ protocolVersion: 1, clientCapabilities: {} });
-
-    const { sessionId } = await agent.newSession({
-        cwd: process.cwd(),
-        mcpServers: [],
-    });
-
-    agent.setPermissionHandler(interactivePermissions);
-
-    const emitter = agent.emitterForSession(sessionId);
-    emitter.on("agent_message_chunk", (p) => {
-        if (p.content.type === "text") process.stdout.write(p.content.text);
-    });
-
-    // Multi-turn conversation
-    while (true) {
-        const userInput = await ask("\n> ");
-        if (userInput === "exit") break;
-
-        const { stopReason } = await agent.prompt({
-            sessionId,
-            prompt: [{ type: "text", text: userInput }],
-        });
-
-        console.log(`\n[${stopReason}]`);
-    }
-
-    await agent.shutdown();
-    rl.close();
-}
-
-main();
-
-```
-
-## Exported Types
-
-All types are re-exported from the `cline` package. Key types:
-
-| Type | Description |
-|------|-------------|
-| `ClineAgent` | Main agent class |
-| `ClineSessionEmitter` | Typed event emitter for session events |
-| `ClineAgentOptions` | Constructor options (`debug`, `clineDir`, `hooksDir`) |
-| `ClineAcpSession` | Session metadata (read-only) |
-| `ClineSessionEvents` | Event name → handler signature map |
-| `AcpSessionStatus` | Session lifecycle enum: `Idle`, `Processing`, `Cancelled` |
-| `AcpSessionState` | Session state tracking (status, pending tool calls) |
-| `PermissionHandler` | `(request: RequestPermissionRequest) => Promise<RequestPermissionResponse>` |
-| `RequestPermissionRequest` | Permission request details (sessionId, toolCall, options) |
-| `RequestPermissionResponse` | Permission response with outcome |
-| `PermissionOption` | Permission choice (`kind`, `optionId`, `name`) |
-| `SessionUpdate` | Union of all session update types |
-| `SessionUpdateType` | Discriminator values (`"agent_message_chunk"`, `"tool_call"`, etc.) |
-| `SessionUpdatePayload` | Typed payload for a given `SessionUpdateType` |
-| `SessionModelState` | Current model and available models |
-| `ToolCall` | Tool call details (id, title, kind, status, content) |
-| `ToolCallUpdate` | Partial update to an existing tool call |
-| `ToolCallStatus` | `"pending" \| "in_progress" \| "completed" \| "failed"` |
-| `ToolKind` | `"read" \| "edit" \| "delete" \| "execute" \| "search" \| ...` |
-| `StopReason` | `"end_turn" \| "cancelled" \| "error" \| "max_tokens" \| ...` |
-| `ContentBlock` | `TextContent \| ImageContent \| AudioContent \| ...` |
-| `TextContent` / `ImageContent` / `AudioContent` | Individual content block types |
-| `McpServer` | MCP server configuration (stdio, http) |
-| `ModelInfo` | Model metadata (`modelId`, `name`) |
-| `PromptRequest` / `PromptResponse` | Prompt call types |
-| `NewSessionRequest` / `NewSessionResponse` | Session creation types |
-| `InitializeRequest` / `InitializeResponse` | Initialization types |
-| `SetSessionModeRequest` / `SetSessionModeResponse` | Mode switching types |
-| `SetSessionModelRequest` / `SetSessionModelResponse` | Model switching types |
-| `TranslatedMessage` | Result of translating a Cline message to ACP updates |
-
-See the [ACP Schema](https://agentclientprotocol.com/protocol/schema) for the full type definitions.
-
-## Relationship to ACP
-
-The Cline SDK implements the [Agent Client Protocol](https://agentclientprotocol.com) `Agent` interface. The key difference from a standard ACP stdio agent is that the SDK uses an **event emitter pattern** instead of a transport connection:
-
-| ACP Stdio (via `AcpAgent`) | SDK (via `ClineAgent`) |
-|-----------------------------|------------------------|
-| Session updates sent over JSON-RPC stdio | Session updates emitted via `ClineSessionEmitter` |
-| Permissions requested via `connection.requestPermission()` | Permissions requested via `setPermissionHandler()` callback |
-| Single process, single connection | Embeddable, multiple concurrent sessions |
-
-If you need stdio-based ACP communication (e.g., for IDE integration), use the `cline` CLI binary directly. The SDK is for embedding Cline in your own Node.js processes.

docs/docs.json

@@ -101,7 +101,6 @@
 						"pages": [
 							"cline-cli/overview",
 							"cline-cli/installation",
-							"cline-sdk/overview",
 							"cline-cli/interactive-mode",
 							{
 								"group": "Headless Mode",
@@ -116,7 +115,6 @@
 								]
 							},
 							"cline-cli/configuration",
-							"cline-cli/acp-editor-integrations",
 							"cline-cli/cli-reference"
 						]
 					},

docs/getting-started/installing-cline.mdx

@@ -106,75 +106,6 @@ description: "Get Cline up and running in your favorite IDE or terminal with the
     Want to learn more? See the [Cline CLI documentation](/cline-cli/getting-started) for advanced usage patterns like multi-instance development and CI/CD integration.
     </Tip>
   </Tab>
-  <Tab title="Zed/Neovim (ACP via CLI)">
-    <Note>
-    **ACP (Agent Client Protocol)** lets you run Cline in any ACP-compatible editor via the CLI. This gives you full access to Cline's capabilities—including Skills, Hooks, and MCP integrations—in your preferred editor.
-    </Note>
-
-    <Steps>
-      <Step title="Install Node.js 20+">
-        Check your version with `node --version`. If needed, visit [nodejs.org](https://nodejs.org) or use nvm.
-      </Step>
-      <Step title="Install Cline CLI">
-        ```bash
-        npm install -g cline
-        ```
-      </Step>
-      <Step title="Authenticate">
-        ```bash
-        cline auth
-        ```
-      </Step>
-      <Step title="Configure your editor">
-        <Tabs>
-          <Tab title="Zed">
-            Open Zed settings (`Cmd/Ctrl + ,`) and add Cline to your `settings.json`:
-            ```json
-            {
-              "agent_servers": {
-                "Cline": {
-                  "type": "custom",
-                  "command": "cline",
-                  "args": ["--acp"],
-                  "env": {}
-                }
-              }
-            }
-            ```
-            Then open the AI assistant panel, select **Cline** from the agent dropdown, and start coding.
-          </Tab>
-          <Tab title="Neovim (agentic.nvim)">
-            Install [agentic.nvim](https://github.com/carlos-algms/agentic.nvim) using lazy.nvim:
-            ```lua
-            {
-              "carlos-algms/agentic.nvim",
-              opts = {
-                provider = "cline-acp",
-                acp_providers = {
-                  ["cline-acp"] = {
-                    command = "cline",
-                    args = {"--acp"},
-                  },
-                },
-              },
-              keys = {
-                {"<C-\\>", function() require("agentic").toggle() end, mode={"n","v","i"}, desc="Toggle Cline Chat"},
-              },
-            }
-            ```
-            Press `<C-\>` to toggle the Cline chat panel.
-          </Tab>
-          <Tab title="Neovim (avante.nvim)">
-            Follow the [avante.nvim documentation](https://github.com/yetone/avante.nvim) for configuring external ACP agents and point it to `cline --acp`.
-          </Tab>
-        </Tabs>
-      </Step>
-    </Steps>
-
-    <Tip>
-    For full details on ACP editor integrations—including JetBrains ACP setup and troubleshooting—see the [ACP Editor Integrations](/cline-cli/acp-editor-integrations) guide.
-    </Tip>
-  </Tab>
   <Tab title="VSCodium/Windsurf">
     <Note>
     These editors use the **Open VSX Registry** instead of the VS Code Marketplace, but the installation process is nearly identical.

package.json

@@ -506,6 +506,10 @@
 		"typescript": "^5.4.5"
 	},
 	"dependencies": {
+		"@clinebot/core": "^0.0.38",
+		"@clinebot/llms": "^0.0.38",
+		"@clinebot/shared": "^0.0.38",
+		"@clinebot/agents": "^0.0.38",
 		"@anthropic-ai/sdk": "^0.37.0",
 		"@anthropic-ai/vertex-sdk": "^0.6.4",
 		"@aws-sdk/client-bedrock-runtime": "^3.922.0",
@@ -600,7 +604,7 @@
 		"uuid": "^11.1.0",
 		"vscode-uri": "^3.1.0",
 		"web-tree-sitter": "^0.22.6",
-		"zod": "^3.24.2"
+		"zod": "^4.3.6"
 	},
 	"overrides": {
 		"tar-fs": ">=3.1.1",

proto/cline/state.proto

@@ -250,7 +250,6 @@ message Settings {
   optional string default_terminal_profile = 137;
   optional int32 terminal_output_line_limit = 138;
   optional int32 max_consecutive_mistakes = 139;
-  optional bool strict_plan_mode_enabled = 141;
   optional bool yolo_mode_toggled = 142;
   optional bool use_auto_condense = 143;
   optional bool cline_web_tools_enabled = 144;
@@ -286,7 +285,6 @@ message Settings {
   optional string act_mode_cline_model_id = 180;
   optional OpenRouterModelInfo act_mode_cline_model_info = 181;
   optional bool show_feature_tips = 182;
-  optional bool lazy_teammate_mode_enabled = 183;
 }
 
 message State {
@@ -391,6 +389,7 @@ message UpdateSettingsRequest {
   reserved 15; // was openai_reasoning_effort (moved to mode-scoped reasoning effort)
   reserved 23; // was dictation_settings (dictation removed)
   reserved 38; // was skills_enabled (removed - now always enabled)
+  reserved 43; // was lazy_teammate_mode_enabled (removed)
 
   Metadata metadata = 1;
   optional ModelsApiConfiguration api_configuration = 2;
@@ -405,7 +404,7 @@ message UpdateSettingsRequest {
   optional int32 terminal_output_line_limit = 12;
   optional PlanActMode mode = 13;
   optional string preferred_language = 14;
-  optional bool strict_plan_mode_enabled = 16;
+  reserved 16; // was strict_plan_mode_enabled (removed)
   optional FocusChainSettings focus_chain_settings = 17;
   optional bool use_auto_condense = 18;
   optional string custom_prompt = 19;
@@ -429,7 +428,6 @@ message UpdateSettingsRequest {
   optional bool worktrees_enabled = 40;
   optional bool double_check_completion_enabled = 41;
   optional bool show_feature_tips = 42;
-  optional bool lazy_teammate_mode_enabled = 43;
 }
 
 message UpdateTerminalConnectionTimeoutRequest {

proto/cline/task.proto

@@ -87,7 +87,7 @@ message GetTaskHistoryRequest {
 // Response for task history
 message TaskHistoryArray {
   repeated TaskItem tasks = 1;
-  int32 total_count = 2;
+  // int32 total_count = 2 [deprecated = true];
 }
 
 // Task item details for history list

sdk-migration/ARCHITECTURE.md

@@ -0,0 +1,265 @@
+# SDK Migration — Architecture & Design
+
+Evergreen reference for the Cline SDK migration project.
+This document describes what we're building and why.
+For the step-by-step plan, see [README.md](README.md).
+
+## Product Background
+
+There's a VSCode extension in `src/`. A large part of its UI is a
+React-based webview in `webview-ui/`. There's a JetBrains plugin
+that packages the core and communicates via protobufs. There's a
+CLI that uses the SDK separately.
+
+The Cline SDK (`@clinebot/core`, `@clinebot/llms`,
+`@clinebot/agents`, `@clinebot/shared`) provides session management,
+provider handling, tool execution, and MCP integration. Our goal is
+to replace the classic core with the SDK while keeping the webview
+mostly intact.
+
+## Architecture
+
+### Current (Classic)
+
+```
+VSCode Extension
+  WebviewProvider → Controller → Task → API providers (30+)
+                  → McpHub
+  Webview (React) ← gRPC/postMessage → Extension Host
+  proto/cline/*.proto defines message format
+```
+
+### Target (SDK-Backed)
+
+```
+VSCode Extension
+  WebviewProvider → SDK Adapter Layer → @clinebot/core
+                  → Custom MCP Manager
+  Webview (React) ← gRPC/postMessage → gRPC Thunk → SDK Adapter
+  (same proto messages — webview unchanged)
+```
+
+### Key Architectural Decision: gRPC Thunking
+
+The webview communicates with the extension host via gRPC-over-postMessage.
+We will **not** change this in the migration. Instead, we implement a
+thunking layer that:
+
+1. Receives gRPC-shaped requests from the webview
+2. Translates them to SDK calls
+3. Translates SDK responses back to gRPC shape
+4. Pushes streaming updates (state, auth, partial messages) as
+   gRPC streaming responses
+
+This means:
+- The webview code is **largely untouched**
+- Proto files stay until the final cleanup step
+- Each SDK feature is wired by implementing its gRPC handler
+
+### Key Architectural Decision: Single Entry Point
+
+There is one extension entry point (`src/extension.ts`), modified to
+use the SDK adapter. No `CLINE_SDK` environment variable, no dual
+codepaths. The classic implementation is always accessible via
+`origin/main` and `kb_search`.
+
+### Key Architectural Decision: Delete and Document
+
+When replacing a classic module with its SDK equivalent, we delete
+the classic code immediately and add a comment in the replacement:
+```
+// Replaces classic src/core/task/ (see origin/main)
+```
+This eliminates confusion about what code is active. The classic
+code is always recoverable from git.
+
+### Future Architecture (Post-Migration)
+
+```
+VSCode Extension
+  SDK Adapter Layer → @clinebot/core
+  Webview (React) ← typed JSON messages → SDK Adapter
+  (gRPC removed; simpler message protocol)
+
+JetBrains Plugin
+  Kotlin Plugin ← JSON-RPC/stdio → SDK Sidecar (Node.js)
+  JCEF Webview ← postMessage → SDK Sidecar
+  (shares SDK adapter layer with VSCode)
+```
+
+## Features
+
+### Features to Remove
+
+- **Browser automation** (Playwright) — replaced by MCP browser tools
+- **IDE terminal integration** — replaced by background terminal
+- **Shadow git checkpoints** — too slow; will be replaced later
+- **Memory bank / structured context** — removed
+- **Focus chain / task tracking** — removed
+- **Deep planning / `/deep-planning`** — plan/act mode replaces it
+- **Workflows** — skills (SKILL.md) replace them
+- **`/reportbug`** — removed
+
+### Core Features (Must Work)
+
+- File operations: read, write, search, replace, list files
+- Background terminal execution
+- Multi-provider AI models (30+ providers)
+- Auto-approve & YOLO mode
+- Auto-compaction
+- Subagents
+- Web search and web fetch
+- Worktrees
+- Workspaces
+- Jupyter Notebooks
+- Cline Rules
+- Skills
+- Hooks
+- .clineignore
+- MCP (stdio + SSE + streamableHTTP)
+
+### Core Workflows (Must Work)
+
+- Task lifecycle: create, resume, history, cost tracking
+- Plan & Act mode with optional separate model configs
+- File context (@-mentions)
+- Slash commands: /newtask, /smol, /newrule
+
+### Model Configuration
+
+- 30+ providers with seamless switching
+- **Critical**: Preserve existing credentials — never log users out
+- Support local models (Ollama, LM Studio)
+- Cline provider with unified auth, billing, org switching
+- VSCode LM API provider (Copilot) if possible
+
+### P1 Features (Can Follow Up)
+
+- Checkpoints (kanban-style git refs, not shadow git)
+- Diffing between checkpoints
+- Restore files/task to checkpoint
+- MCP Marketplace
+
+### P2 Features (Later)
+
+- Task favorites and grouping
+- File drag-and-drop context
+- `/explain-changes` slash command
+
+## Design Principles
+
+### Naming: "Sdk..." Considered Harmful
+
+Don't name types `SdkFoo` or folders `sdk`. The SDK backing is an
+implementation detail. Use simple noun phrases. During migration,
+`SdkFoo` as a temporary alias is OK, but rename before completion.
+
+### Proto Deprecation
+
+Protos for webview messages will eventually be replaced by shared
+TypeScript interfaces. But **not during this migration** — we keep
+the gRPC thunking layer and remove protos only in the final cleanup.
+
+Protos for persisted state (if any) can stay indefinitely.
+
+### Data Formats & Settings
+
+- **Must** pick up existing on-disk state
+- Never log users out of their providers
+- CLI, VSCode, and JetBrains share state on disk — continue that
+- Design migrations with breadcrumbs and downgrade robustness
+- Protect against corrupt JSON writes (atomic write-then-rename)
+
+### Webview UI
+
+- Reuse the existing webview — do NOT build from scratch
+- Familiar, not worse, preferably better
+- Simplify state management where the SDK enables it
+- Fix known defects (n² state updates, wrong keybindings) when
+  the opportunity arises
+
+## What the SDK Provides
+
+These capabilities exist in the SDK and do not need to be rebuilt:
+
+1. **Legacy provider settings migration** —
+   `migrateLegacyProviderSettings()` reads `globalState.json` +
+   `secrets.json`, writes to `providers.json`
+2. **30+ provider handlers** — Anthropic, OpenAI, Gemini, Bedrock,
+   Vertex, DeepSeek, Ollama, LM Studio, etc.
+3. **Custom handler registry** — `registerHandler(id, factory)` for
+   VSCode LM API and other host-specific providers
+4. **MCP management** — `InMemoryMcpManager` with stdio, SSE,
+   streamableHttp transports (but needs custom factory for non-stdio)
+5. **Tool framework** — 8 built-in tools, preset system, per-tool
+   policies, model-aware routing
+6. **Session lifecycle** — `ClineCore.create()` → `host.start()` /
+   `host.send()` / `host.abort()` / `host.subscribe()`
+7. **Telemetry** — `TelemetryService` with pluggable adapters
+8. **Rules & Skills** — Discovery from `.clinerules/`,
+   `~/Documents/Cline/Rules`, etc.
+9. **Hooks** — `HookEngine` with lifecycle events
+10. **Subagents/Teams** — `AgentTeamsRuntime`, spawn tools
+11. **System prompt generation** — `getClineDefaultSystemPrompt()`
+12. **OAuth token management** — `RuntimeOAuthTokenManager` for
+    automatic refresh
+13. **Storage isolation** — `CLINE_DIR`, `CLINE_DATA_DIR` env vars
+
+## SDK Gaps (Known)
+
+These features need custom implementation in the adapter layer:
+
+1. **MCP settings file watcher** — SDK doesn't watch for changes
+2. **MCP manager exposure** — Runtime builder encapsulates the
+   manager; clients can't call lifecycle methods on running sessions
+3. **SSE/StreamableHTTP client** — Default factory only creates
+   stdio clients; we need a custom factory
+4. **RPC endpoints for MCP** — No MCP management in the RPC layer
+5. **OAuth callback handling** — SDK provides the server and URL,
+   but the client must open the browser and persist tokens
+
+See `SDK-REFERENCE/MCP.md` and `SDK-REFERENCE/OAUTH.md` for details.
+
+## JetBrains IPC Design (Future)
+
+The target is JSON-RPC over stdio between the Kotlin plugin and a
+Node.js sidecar. See the original ARCHITECTURE.md for the full
+design. This is **not in scope** for the current migration —
+VSCode comes first.
+
+## Test Strategy
+
+### Unit Tests
+
+- **SDK adapter tests**: Vitest (no vscode mock needed)
+- **Extension unit tests**: Mocha with vscode mock (existing)
+- **Webview tests**: Vitest + React Testing Library (existing)
+
+### Integration Tests
+
+- **Debug harness**: Playwright-driven VSCode with CDP access
+- **QA scripts**: Curl-based test sequences for core flows
+
+### SDK Storage Isolation
+
+```typescript
+import { setClineDir, setHomeDir } from "@clinebot/shared/storage"
+const tempHome = mkdtempSync(join(tmpdir(), "test-home-"))
+process.env.HOME = tempHome
+process.env.CLINE_DIR = join(tempHome, ".cline")
+process.env.CLINE_DATA_DIR = join(tempHome, ".cline", "data")
+setHomeDir(tempHome)
+setClineDir(process.env.CLINE_DIR)
+```
+
+## Manual QA Risk Areas
+
+1. **Provider credentials** — Verify API keys survive upgrade/downgrade
+2. **Cline provider OAuth/SSO** — Sign-in, sign-out, refresh, org switch
+3. **Chat streaming** — Missing/duplicated messages, performance
+4. **Tool approval** — Auto-approve, YOLO, per-tool permissions
+5. **Plan/Act mode** — Toggle, separate models, persistence
+6. **Task history** — Old tasks appear, new tasks save, resume works
+7. **MCP servers** — Configs picked up, tools work
+8. **Settings UI** — All toggles persist
+9. **Webview performance** — Long conversations don't lag

sdk-migration/FOREGROUND-TERMINAL-DESIGN.md

@@ -0,0 +1,163 @@
+# Design Doc: Foreground Terminal Integration (SDK Port)
+
+> **⚠️ Remove this file before merging the final PR.**
+
+**Author:** AI-assisted design session  
+**Date:** 2026-05-01  
+**Status:** Approved for implementation  
+**Branch:** `sdk-migration-pt7`
+
+---
+
+## Background
+
+The Cline VSCode extension was reverted to include foreground terminals ([#10477](https://github.com/cline/cline/pull/10477), commit `beb3ad78d`) because users depend on them for:
+
+1. **Interactive CLI testing** — users need a real terminal to interact with
+2. **Long-running dev servers** — `npm run dev`, `cargo watch`, etc. that run indefinitely; users manage them with ctrl-C
+3. **Visibility** — users want to see what Cline is doing in the terminal
+
+The SDK migration branch (`sdk-migration-pt7`) replaced the classic `Controller` and `Task` system with the SDK's `ClineCore` / `VscodeSessionHost`. The rebase onto `origin/main` brought back the foreground terminal infrastructure (settings UI, `VscodeTerminalManager`, state keys), but the SDK controller doesn't wire any of it. This design doc describes how to integrate the foreground terminal as an **IDE feature built on top of the SDK**, not as part of the SDK itself.
+
+---
+
+## Problem: The SDK's Built-in `run_commands` Is Insufficient
+
+The SDK provides a `run_commands` tool backed by a `BashExecutor` (`child_process.spawn`). It has fundamental limitations:
+
+| Requirement | SDK's `run_commands` | Verdict |
+|---|---|---|
+| Long-running processes | ❌ `withTimeout()` kills after 30s (executor) / 60s (tool) | Blocker |
+| "Proceed While Running" | ❌ Tool blocks until executor returns `Promise<string>` | Blocker |
+| Interactive use (ctrl-C, prompts) | ❌ `child_process.spawn` is non-interactive | Blocker |
+| Visible terminal | ❌ Runs invisibly in background | Blocker |
+| Real-time output streaming | ❌ Collects all output, returns at end | Missing feature |
+
+**Key detail on timeouts:** The SDK's built-in tools apply their own `withTimeout()` inside `execute()`. The `timeoutMs` property on the `Tool` interface is metadata — the `AgentRuntime` does **NOT** enforce it externally (`agent-runtime.ts:948` calls `tool.execute()` directly). This means a custom tool that omits `withTimeout()` can run indefinitely.
+
+---
+
+## Solution: Replace `run_commands` With Our Own Tool
+
+### Architecture
+
+```
+suppress SDK's built-in run_commands
+    └── defaultToolExecutors: { bash: undefined }
+        → createDefaultTools() sees falsy bash → doesn't create run_commands
+
+provide custom run_commands via extraTools
+    └── src/sdk/vscode-run-commands-tool.ts (NEW)
+        ├── reads vscodeTerminalExecutionMode from StateManager on EVERY call
+        │
+        ├── foreground path ("vscodeTerminal"):
+        │   └── VscodeTerminalManager → VscodeTerminalProcess
+        │       • Visible VS Code terminal
+        │       • Shell integration output capture
+        │       • No timeout — runs until completion or cancellation
+        │       • onChange/emitUpdate for streaming output to chat
+        │
+        └── background path ("backgroundExec"):
+            └── createBashExecutor() from @clinebot/core
+                • Same implementation SDK would use
+                • Configurable timeout (default 5min)
+```
+
+### Suppression Mechanism
+
+In `VscodeSessionHost.create()`, pass `defaultToolExecutors: { bash: undefined }`. The SDK's `DefaultRuntimeBuilder.build()` does:
+```typescript
+const executors = { ...createDefaultExecutors(), ...(defaultToolExecutors ?? {}) }
+```
+The spread sets `bash` to `undefined`. Then `createDefaultTools()` checks `enableBash && executors.bash` — falsy bash means no `run_commands` tool is created.
+
+### Dynamic Foreground/Background Switching
+
+The tool reads the setting on every invocation — no session restart needed:
+```typescript
+execute: async (input, context, onChange) => {
+    const mode = stateManager.getGlobalStateKey("vscodeTerminalExecutionMode")
+    if (mode === "backgroundExec") {
+        return backgroundExecutor(command, cwd, context)
+    } else {
+        return foregroundExecute(command, cwd, context, onChange)
+    }
+}
+```
+
+For background mode, we reuse `createBashExecutor()` from `@clinebot/core` — the exact same proven `child_process.spawn` implementation the SDK uses internally.
+
+### Real-Time Output Streaming via `onChange`/`emitUpdate`
+
+The pipeline is fully wired:
+
+1. **Tool** calls `onChange({ type: "output", line: "..." })` as terminal output arrives
+2. **Adapter** (`toolToAgentTool`) passes `context.emitUpdate` as the `onChange` argument
+3. **AgentRuntime** emits `{ type: "tool-updated", toolCall, update }` event
+4. **Session event adapter** translates to `{ type: "content_update", contentType: "tool", toolName, toolCallId, update }`
+5. **Message translator** handles the event and produces visible chat messages
+6. **Webview** renders the output in real-time
+
+Current gap: The message translator ignores `content_update` for non-`spawn_agent` tools (line 866-869). This needs a small fix to handle `run_commands` updates.
+
+---
+
+## What We Reuse
+
+| Component | Status | Plan |
+|---|---|---|
+| `VscodeTerminalManager` | ✅ Present (from revert) | Use directly |
+| `VscodeTerminalProcess` | ✅ Present (from revert) | Use directly |
+| `VscodeTerminalRegistry` | ✅ Present (from revert) | Use directly |
+| `CommandOrchestrator` | ✅ Present | Adapt for "Proceed While Running" |
+| `CommandExecutor` | ✅ Present | Study patterns, don't reuse directly (classic Task callbacks) |
+| Terminal settings UI | ✅ Present (from revert) | Use as-is |
+| State keys | ✅ Present (from revert) | Use as-is |
+| `createBashExecutor` | ✅ SDK export | Use for background path |
+
+---
+
+## Implementation Plan
+
+### First Commit
+
+1. **Create `src/sdk/vscode-run-commands-tool.ts`** — Custom `run_commands` tool factory
+   - Parses all SDK input formats (string, array, `{commands:[...]}`)
+   - Dynamic foreground/background dispatch
+   - Foreground: `VscodeTerminalManager`, no timeout, `onChange` for output streaming
+   - Background: `createBashExecutor()` with configurable timeout
+   - Respects `context.signal` (AbortSignal) for cancellation
+
+2. **Modify `src/sdk/vscode-session-host.ts`** — Wire the new tool
+   - Pass `defaultToolExecutors: { bash: undefined }` to suppress SDK's `run_commands`
+   - Read terminal settings from StateManager
+   - Instantiate `VscodeTerminalManager` lazily
+   - Add custom tool to `extraTools` in `createVscodeExtraTools()`
+
+3. **Wire terminal settings RPC** — Ensure `setTerminalExecutionMode` and terminal settings work with SDK controller
+
+4. **Verify settings UI** — Confirm `TerminalSettingsSection` reads/writes settings
+
+### Follow-Up Work
+
+- "Proceed While Running" button (adapt `CommandOrchestrator` callbacks)
+- Message translator handling for `content_update` on `run_commands` → chat output rows
+- Background command tracking and environment details summary
+- Shell integration failure suggestion ("try background exec mode")
+- `attempt_completion` command execution in foreground terminal
+
+---
+
+## Alternatives Considered
+
+### ❌ Custom `BashExecutor` injected via `defaultToolExecutors.bash`
+
+Would reuse the SDK's `run_commands` tool wrapper, but that wrapper applies `withTimeout()` (30s/60s) that kills long-running processes. No way to disable it from outside. Also no mechanism for "Proceed While Running" or streaming since the tool blocks on the executor's `Promise<string>`.
+
+### ❌ Forking the SDK's `run_commands` tool definition
+
+Higher maintenance burden. Our tool needs fundamentally different execution semantics, not a minor tweak.
+
+### ✅ Suppress + Replace (chosen approach)
+
+Clean separation. The SDK owns its headless `run_commands` for CLI/non-IDE use. The VSCode extension provides its own terminal-aware replacement via the SDK's `extraTools` extension point. Dynamic switching between foreground/background happens inside our tool.

sdk-migration/PROBLEMS.md

@@ -0,0 +1,873 @@
+# SDK Migration — Known Issues & Verification Tracker
+
+This file tracks problems found during the migration. Each problem
+has a status and verification evidence. Problems are never marked
+🟢 without evidence.
+
+## Status Legend
+
+- 🔴 **Blocker** — prevents core functionality
+- 🟡 **Minor** — cosmetic or UX annoyance
+- 🔵 **Awaiting Verification** — fix attempted, not yet verified
+- 🟢 **Verified Fixed** — fix confirmed with evidence
+
+## Known Issues From Previous Attempt
+
+These issues were present in the second migration attempt. They
+are listed here as a reference for what to watch out for. They
+do not necessarily apply to this attempt's codebase, but the
+underlying patterns that caused them are relevant.
+
+### Auth & Account (Highest Risk Area)
+
+| ID | Description | Status |
+|----|-------------|--------|
+| A1 | Inference works when appearing logged out | Carried pattern |
+| A2 | Inference NOT working when appearing logged in | Carried pattern |
+| A3 | Login button does nothing or opens wrong URL | Carried pattern |
+| A4 | Logout button does nothing | Carried pattern |
+| A5 | Profile/credits/history not displayed when logged in | Carried pattern |
+| A6 | Error messages instead of login buttons when actually logged out | Carried pattern |
+| A7 | Hardcoded `app.cline.bot` instead of `{appBaseUrl}` | Carried pattern |
+| A8 | `workos:` prefix inconsistency on account IDs | Carried pattern |
+| A9 | Org switching doesn't update inference profile | Carried pattern |
+| A10 | Low credit balance persists after switching orgs | Carried pattern |
+
+### gRPC Thunking
+
+| ID | Description | Status |
+|----|-------------|--------|
+| G1 | Stubbed handlers return `{data:{}}` causing webview crashes | Carried pattern |
+| G2 | Proto field name mismatches (e.g., `taskId` vs `id`) | Carried pattern |
+| G3 | Streaming subscriptions race condition | Carried pattern |
+| G4 | "SDK mode" vs "classic mode" confusion | Addressed by design |
+
+### Feature Removal
+
+| ID | Description | Status |
+|----|-------------|--------|
+| F1 | Empty `if (request.type === "workflow") {}` blocks | Carried pattern |
+| F2 | Features marked "legacy" instead of actually removed | Carried pattern |
+| F3 | Workflows tab still in Cline Rules modal | Carried pattern |
+| F4 | Terminal settings show IDE terminal options | Carried pattern |
+
+### UI / Webview
+
+| ID | Description | Status |
+|----|-------------|--------|
+| U1 | Copy button obscured by code blocks | Carried pattern |
+| U2 | Token usage bar shows 0/0 | Carried pattern |
+| U3 | Input text not cleared immediately on send | Carried pattern |
+| U4 | Task history items not clickable | Carried pattern |
+| U5 | MCP server management buttons are no-ops | Carried pattern |
+| U6 | MCP Marketplace never loads | Carried pattern |
+| U7 | Tool output rectangles appear blank | Carried pattern |
+
+## New Issues
+
+### Step 1: Foundation & Cutover — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: SDK adapter layer created as single entry point. Extension compiles and builds.
+- **Verification**: `npx tsc --noEmit` returns 0 errors. `node esbuild.mjs` produces `dist/extension.js`.
+- **Evidence**: Commit `3dec59fe9` on `sdk-migration-v3` branch.
+
+### S1-1: SdkController stubs log warnings at runtime
+- **Status**: 🟡 Minor
+- **Description**: All unimplemented Controller methods log `[SdkController] STUB: <name> not yet implemented`. This is expected — functionality is added in Steps 4-8.
+- **Root cause**: By design — stub pattern for incremental migration.
+- **Fix**: Implement each method in its corresponding step.
+
+### S1-2: Services not initialized (mcpHub, authService, etc.)
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SdkController now initializes `authService`, `ocaAuthService`, `accountService` (Step 6), and `mcpHub` (Step 7). All core services are initialized.
+- **Root cause**: N/A — fixed incrementally in Steps 6 and 7.
+- **Fix**: Auth and account services wired in Step 6. MCP hub wired in Step 7 using classic McpHub (will be replaced by SDK's InMemoryMcpManager in Step 10).
+
+### S1-3: Extension loads but sidebar shows errors
+- **Status**: 🟢 Verified Fixed
+- **Description**: Extension loads, sidebar renders correctly with full UI (chat input, model selector, announcements, auto-approve settings). No error elements in the webview.
+- **Verification**: Debug harness launched with `--auto-launch`, sidebar opened, `document.querySelectorAll("[data-testid=error], .error, .codicon-error").length` returns 0. Sending a message via `ui.send_message` returns `{"sent": true, "method": "newTask"}` without crash. Task doesn't start (expected — `initTask` is a stub).
+- **Evidence**: Debug harness session on 2026-04-13, commit `3dec59fe9`.
+
+### Step 2: Legacy State Reader — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: `src/sdk/legacy-state-reader.ts` reads all existing on-disk state from the Cline data directory. Supports globalState.json, secrets.json, taskHistory.json, per-task data (api_conversation_history, ui_messages, context_history, task_metadata), MCP settings, and task directory listing.
+- **Verification**: 37 unit tests pass (`npx vitest run --config vitest.config.sdk.ts`). TypeScript compiles with 0 errors (`npx tsc --noEmit`). All reads are non-throwing — missing/corrupt files return typed defaults.
+- **Evidence**: All tests pass on 2026-04-13.
+
+### Step 3: Provider Migration — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: `src/sdk/provider-migration.ts` uses the SDK's `ProviderSettingsManager` to auto-migrate legacy provider credentials from `globalState.json` + `secrets.json` to the SDK's `providers.json` format. Supports all 30+ providers. Never overwrites existing entries. Tags migrated entries with `tokenSource: "migration"`. Idempotent.
+- **Verification**: 12 unit tests pass covering Anthropic, OpenAI, OpenRouter, Bedrock, Ollama, Cline providers, no-overwrite guarantee, idempotency, and missing state handling. TypeScript compiles with 0 errors.
+- **Evidence**: All tests pass on 2026-04-13.
+
+### Step 4: Session Lifecycle — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: Session lifecycle implemented in `src/sdk/cline-session-factory.ts`, `src/sdk/message-translator.ts`, and `src/sdk/SdkController.ts`. The SdkController now has working `initTask()`, `askResponse()`, `cancelTask()`, `clearTask()`, `showTaskWithId()`, and `reinitExistingTaskFromId()` methods that create SDK sessions via `ClineCore`, subscribe to events, translate them to `ClineMessage[]`, and emit to listeners. The message translator handles all SDK event types: `chunk`, `agent_event` (content_start/update/end, done, error, notice, iteration_start/end, usage), `ended`, `hook`, and `status`. Session factory builds `CoreSessionConfig` from legacy state via `ProviderSettingsManager` and creates `HistoryItem` records.
+- **Verification**: 91 unit tests pass across 4 test files (27 message-translator, 37 legacy-state-reader, 15 cline-session-factory, 12 provider-migration). TypeScript compiles with 0 errors in `src/sdk/`. Tests cover: streaming state tracking, all event type translations, full streaming flows (text→tool→text), history item CRUD, session input building, and provider config resolution.
+- **Evidence**: All tests pass on 2026-04-13. `npx tsc --noEmit` returns 0 errors in `src/sdk/`.
+
+### Step 5: gRPC Thunking Layer — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: gRPC thunking layer implemented in `src/sdk/task-proxy.ts` and `src/sdk/webview-grpc-bridge.ts`. The `TaskProxy` provides a classic Task-compatible interface that delegates to SDK session methods, allowing existing gRPC handlers to work without modification. The `WebviewGrpcBridge` translates SDK session events to proto ClineMessages and pushes them through the existing `subscribeToPartialMessage` and `subscribeToState` gRPC streams. The `MessageStateHandler` extends `EventEmitter` for CLI compatibility (on/off pattern). The SdkController wires everything together: session events → message translation → gRPC bridge → webview streams.
+- **Verification**: 114 unit tests pass across 6 test files (16 task-proxy, 7 webview-grpc-bridge, 27 message-translator, 37 legacy-state-reader, 15 cline-session-factory, 12 provider-migration). TypeScript compiles with 0 new errors (3 pre-existing errors in unrelated files). Tests cover: TaskProxy delegation, MessageStateHandler event emission, WebviewGrpcBridge message/state pushing, error handling.
+- **Evidence**: All tests pass on 2026-04-13. `npx tsc --noEmit` returns only 3 pre-existing errors (searchFiles.ts, commit-message-generator.ts).
+
+### S4-1: Session lifecycle not yet wired to gRPC handlers
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SdkController's session lifecycle methods are now wired to the gRPC handler layer via the TaskProxy. The webview's `newTask` and `askResponse` messages flow through: gRPC handler → TaskProxy → SdkController → SDK session. Session events flow back: SDK → message translator → WebviewGrpcBridge → gRPC streams → webview.
+- **Root cause**: N/A — fixed in Step 5.
+- **Fix**: TaskProxy delegates `handleWebviewAskResponse()` and `abortTask()` to SdkController callbacks. WebviewGrpcBridge pushes translated messages through `sendPartialMessageEvent()` and `sendStateUpdate()`.
+
+### S4-2: Task resumption uses new session instead of SDK resume API
+- **Status**: 🟢 Verified Fixed
+- **Description**: Resumption now works with preserved context. When a user opens a historical task and sends a follow-up, `SdkController.askResponse()` resumes by creating a session with the existing task ID and loading prior conversation as `initialMessages`.
+- **Root cause**: The old flow had no active SDK session for history-only tasks, so follow-up prompts had no session context.
+- **Fix applied**: Implemented `resumeSessionFromTask()` in `src/sdk/SdkController.ts` (commit `34afde1c5`). The flow reads persisted SDK messages (`readMessages(taskId)`) with fallback to classic `api_conversation_history`, starts a session with `config.sessionId = taskId`, posts the user follow-up immediately to chat, then sends the prompt to the resumed session.
+- **Verification**: Manual verification via resumed history task + follow-up message.
+- **Evidence**: Commit `34afde1c5` (“resume session working”).
+
+### S4-3: Workspace root not available from ClineExtensionContext
+- **Status**: 🟢 Verified Fixed
+- **Description**: `ClineExtensionContext` doesn't have a `workspaceRoot` property. The SdkController fell back to `process.cwd()` for the session's working directory, which in VSCode returns the extension host's directory — NOT the user's workspace.
+- **Root cause**: The shared context type doesn't include VSCode-specific workspace info.
+- **Fix applied**: Added `SdkController.getWorkspaceRoot()` private method that resolves the workspace root via `HostProvider.workspace.getWorkspacePaths()` (which calls `vscode.workspace.workspaceFolders[0].uri.fsPath` under the hood), falling back to `process.cwd()` only when no workspace folder is open. Replaced all 4 `process.cwd()` calls in SdkController (in `initTask()`, `reinitExistingTaskFromId()`, `resumeSessionFromTask()`, `restartSessionForMcpTools()`) with `await this.getWorkspaceRoot()`. Also added a defensive warning log in `buildSessionConfig()` for the `process.cwd()` fallback path. See S6-38 for the full fix entry.
+- **Verification**: TypeScript compiles with 0 new errors (5 pre-existing SDK type errors). All `process.cwd()` calls replaced with host-aware workspace resolution.
+- **Evidence**: Code review — `HostProvider.workspace.getWorkspacePaths()` delegates to the same `vscode.workspace.workspaceFolders` API used in `common.ts:131` and throughout the classic extension.
+
+### Step 6: Auth & Account Flows — Completed
+
+- **Status**: 🟢 Verified Fixed
+- **Description**: SDK-backed auth and account services implemented. `src/sdk/auth-service.ts` replaces classic `src/services/auth/AuthService.ts`, using `@clinebot/core` OAuth functions (`loginClineOAuth`, `loginOcaOAuth`, `loginOpenAICodex`, `refreshClineToken`) for login flows while maintaining compatibility with the existing gRPC handler interface. `src/sdk/account-service.ts` replaces classic `src/services/account/ClineAccountService.ts`, making authenticated API requests using the SDK-backed AuthService for token management. The SdkController now initializes `authService`, `ocaAuthService`, and `accountService` in its constructor and restores auth state from secrets on startup. gRPC handlers (`accountLoginClicked`, `accountLogoutClicked`, `subscribeToAuthStatusUpdate`, `openAiCodexSignIn`, `openAiCodexSignOut`) now import from `@/sdk/auth-service` instead of the classic `@/services/auth/AuthService`. The `extension.ts` secrets listener also imports from the new location.
+- **Key design decisions**:
+  - Auth info persisted in `secrets.json` under `cline:clineAccountId` (same key as classic)
+  - Tokens stored with `workos:` prefix for API compatibility
+  - Token refresh uses SDK's `refreshClineToken()` with automatic retry and error recovery
+  - Cross-window auth sync via secrets change listener preserved
+  - Codex credentials stored via SDK's `ProviderSettingsManager`
+  - `handleAuthCallback()` supports URI-handler-based OAuth flow (code exchange)
+  - Streaming subscriptions push initial auth state immediately (prevents race condition)
+- **Verification**: 20 unit tests pass in `src/sdk/auth-service.test.ts`. TypeScript compiles with 0 new errors. Tests cover: singleton pattern, auth state management, organization lookup, token persistence (read/write/clear), logout flow, workos: prefix handling, streaming subscriptions, and auth restoration on startup.
+- **Evidence**: All tests pass on 2026-04-14. `npx tsc --noEmit` returns only pre-existing errors (none in `src/sdk/`).
+
+### S6-1: Auth login flow not yet verified end-to-end
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SDK-backed `loginClineOAuth()` flow has not been tested with a real browser OAuth flow. The classic flow used Firebase custom token exchange; the SDK flow uses a local callback server. Need to verify: (1) browser opens correctly, (2) callback server receives the code, (3) tokens are exchanged and persisted, (4) webview shows authenticated state.
+- **Root cause**: Requires debug harness + real Cline account.
+- **Fix**: Test with debug harness using `ui.send_message` to trigger login flow.
+- **Verification**: Debug harness `ui.screenshot` after login should show user avatar/credits.
+
+### S6-2: OCA and Codex OAuth flows not yet verified
+- **Status**: 🔵 Awaiting Verification
+- **Description**: `ocaLogin()` and `openAiCodexLogin()` delegate to SDK functions but haven't been tested end-to-end. The Codex flow stores credentials via `ProviderSettingsManager` instead of the classic `openAiCodexOAuthManager`.
+- **Root cause**: Requires real OAuth providers.
+- **Fix**: Manual testing with debug harness.
+
+### S6-3: MCP OAuth callback stubbed
+- **Status**: 🟢 Verified Fixed
+- **Description**: MCP OAuth callback is now implemented.
+- **Root cause**: Previously delegated to stub path.
+- **Fix applied**: `SdkController.handleMcpOAuthCallback()` now calls `mcpHub.completeOAuth(serverHash, code, state)` and posts updated state to the webview, with error logging on failure.
+- **Verification**: Manual OAuth callback test with remote Notion MCP server.
+- **Evidence**: Commit `a8ac26e36` (“fix mcp oauth callback”).
+
+### S6-5: Sending messages creates history entry but doesn't switch to inference view
+- **Status**: 🟢 Verified Fixed
+- **Description**: Inference itself works (the SDK agent runs, produces output, and the session completes with tokens). However, the webview does NOT switch from the welcome/history view to the chat/inference view when a message is sent. A new entry appears in the task history sidebar, but the user stays on the welcome page and never sees the agent's output.
+- **Root cause**: The view transition depends on `clineMessages` having at least one message (the "task" message) in the state update. The webview's `ChatView.tsx` shows the chat view when `messages.at(0)` is truthy. Previously, the task message was only sent via the partial message stream but NOT included in the state's `clineMessages` (see S6-22). When the state update arrived with empty `clineMessages`, the webview saw no messages and stayed on the welcome view.
+- **Fix applied**: Same as S6-22 — the task message is now added to `messageStateHandler` before emitting, so the state update includes it in `clineMessages`. The webview receives `clineMessages` with the task message and switches to the chat view.
+- **Verification**: Send a message, verify the webview switches to the chat view showing the agent's streaming output.
+- **Evidence**: Manual verification on 2026-04-16 — new chats display and do inference.
+
+### S6-6: Clicking historical chat items does nothing (includes S6-15)
+- **Status**: 🔵 Awaiting Verification (three fixes applied)
+- **Description**: Clicking on a task in the history view now opens the chat view and stays there (no more flash-back to welcome). Previously, the chat view showed only "Thinking" with no messages displayed. The task's messages were loaded from disk but not rendering in the webview.
+- **Root cause (flash-back fixed)**: `showTaskWithId()` was rewritten to avoid `clearTask()` race condition. The view now stays on the chat view.
+- **Root cause (messages missing — fixed)**: Two issues:
+  1. The messages loaded from disk were added to `messageStateHandler` and included in the state update's `clineMessages`, but the webview relies on the partial message stream for rendering individual messages. The state update alone wasn't sufficient — messages also need to be pushed through the partial message stream (`subscribeToPartialMessage`).
+  2. **Path mismatch**: `showTaskWithId()` was using `readUiMessages()` from `legacy-state-reader.ts` which reads from `~/.cline/data/tasks/<id>/ui_messages.json`. But `saveClineMessages()` (from `disk.ts`) writes to `HostProvider.globalStorageFsPath/tasks/<id>/ui_messages.json` — a different path (e.g., VSCode's extension storage). The messages were being saved to one location and read from another, so `readUiMessages()` always returned an empty array.
+- **Fix applied**:
+  1. **(flash-back)**: Rewrote `showTaskWithId()` in `SdkController.ts` to avoid calling `clearTask()`. Instead: (1) unsubscribe from events FIRST, (2) clear `activeSession` reference, (3) fire-and-forget session stop/dispose, (4) create new task proxy with loaded messages BEFORE state push, (5) only then call `postStateToWebview()`.
+  2. **(messages — partial stream)**: In `showTaskWithId()`, after loading messages from disk and adding them to `messageStateHandler`, also push each message through the partial message stream via `pushMessageToWebview()`. The webview receives messages from two sources: state updates (bulk) and partial messages (individual). Pushing through both ensures the webview has messages regardless of timing. The webview deduplicates by timestamp, so duplicate pushes are harmless.
+  3. **(messages — path mismatch)**: Replaced `readUiMessages()` (from `legacy-state-reader.ts`) with `getSavedClineMessages()` (from `@core/storage/disk`) in `showTaskWithId()`. Both `saveClineMessages` and `getSavedClineMessages` use `HostProvider.globalStorageFsPath` as the base path, so they read/write from the same location. Removed the unused `readUiMessages` import.
+- **Verification**: Click a history item, verify the chat view loads with the task's messages visible.
+
+### S6-7: Credits/payment history don't load immediately on startup
+- **Status**: 🟡 Minor
+- **Description**: After login, the available tokens and payment history don't appear immediately. They show up after clicking refresh. This is a timing issue — the first `getStateToPostToWebview()` call may happen before the auth token is fully restored.
+- **Root cause**: Race condition between auth restoration and initial state push.
+- **Fix**: Ensure `restoreRefreshTokenAndRetrieveAuthInfo()` completes before the first state push, or trigger a re-fetch after auth restoration completes.
+
+### S6-4: Provider-specific OAuth callbacks (OpenRouter, Requesty, Hicap) stubbed
+- **Status**: 🟢 Verified Fixed
+- **Description**: Provider OAuth callbacks are now implemented for OpenRouter, Requesty, and Hicap.
+- **Root cause**: Previously low-priority stubs.
+- **Fix applied**:
+  - `SdkController` now routes all three callbacks to `authService` and posts state updates.
+  - `auth-service.ts` implements:
+    - `handleOpenRouterCallback(code)` via OpenRouter code→API key exchange (`/api/v1/auth/keys`), then persists config.
+    - `handleRequestyCallback(code)` and `handleHicapCallback(code)` by persisting provider API keys and switching plan/act providers.
+  - Added shared helper `setProviderApiKey()` for consistency.
+- **Verification**: Manual OpenRouter login flow tested end-to-end (provider selected, “get OpenRouter API key”, prompt sent successfully).
+- **Evidence**: Commits `d68e83981` and `69d500f87`.
+
+### S6-8: Debug harness loads extension in "local" environment (brown logo)
+- **Status**: 🟢 Verified Fixed
+- **Description**: When run via the debug harness, the extension appears in "local" environment mode (brown Cline logo) instead of "production" mode (white-on-black logo). The production VSCode launch configuration works correctly.
+- **Root cause**: `src/dev/debug-harness/server.ts:370` hardcodes `CLINE_ENVIRONMENT: "local"` in the environment variables passed to the extension host.
+- **Fix**: Changed to `"production"` or made configurable.
+- **Evidence**: Manual verification on 2026-04-16.
+
+### S6-9: DefaultSessionManager has multiple CLI-oriented assumptions
+- **Status**: 🔵 Awaiting Verification (VscodeSessionHost wired into SdkController)
+- **Description**: `DefaultSessionManager` was designed primarily for the SDK's CLI (`clite`) and has several assumptions that don't fit the VSCode extension context. These are all addressable through the constructor options or by wrapping/catching, but must be accounted for:
+
+  **a) Hardcoded "clite" in OAuth error messages** (`default-session-manager.ts:1377`):
+  `syncOAuthCredentials()` throws `Run "clite auth ${error.providerId}" and retry.` when OAuth re-auth is needed. Meaningless in VSCode.
+  **Mitigation**: Provide a custom `oauthTokenManager` that handles re-auth through the extension's login flow, or catch this error in SdkController and show a login button.
+
+  **b) Session source defaults to `SessionSource.CLI`** (line 199):
+  Every session is tagged as `"cli"` in telemetry and session manifests. VSCode sessions should be tagged differently.
+  **Mitigation**: Pass `source: SessionSource.VSCODE` (or equivalent) in `StartSessionInput`. Check if `SessionSource` has a VSCode variant; if not, use a custom string.
+
+  **c) OAuth token manager uses `ProviderSettingsManager` for token storage** (lines 185-190):
+  The default `RuntimeOAuthTokenManager` reads/writes tokens via `ProviderSettingsManager` (`providers.json`). The VSCode extension stores OAuth tokens in `secrets.json` under `cline:clineAccountId`. The default manager won't find them.
+  **Mitigation**: Provide a custom `oauthTokenManager` that reads from the extension's `secrets.json` / `StateManager`.
+
+  **d) `providerSettingsManager` defaults to reading `providers.json`** (lines 183-184):
+  `buildResolvedProviderConfig()` (line 268) uses this to resolve provider config including `knownModels` and `reasoningSettings`. If the extension's credentials aren't in `providers.json`, this resolution may produce incomplete config.
+  **Mitigation**: Provide a custom `providerSettingsManager` or ensure `providers.json` is kept in sync.
+
+  **e) `start()` and `send()` block until the agent turn completes** (lines 411-420, 437-475):
+  Both methods are blocking — they return only after the agent finishes its turn. Events stream in real-time via `subscribe()`, but the calling code is blocked. This is fine for CLI but problematic for gRPC handlers that need to return immediately.
+  **Mitigation**: Fire-and-forget the `start()`/`send()` calls (don't await in the gRPC handler), or run them in a background task. The `sdk-migration-fri` branch awaits them but pushes UI state before calling.
+
+  **f) Tools are built once per session — no mid-session tool list changes** (line 296-318):
+  `runtimeBuilder.build()` is called once at session start. The resulting `runtime.tools` array plus `config.extraTools` are merged and passed to the agent. There is no mechanism to add/remove tools from the array mid-session.
+
+  **Important distinction — tool policies vs tool list:**
+  - **Tool policies** (`toolPolicies: Record<string, ToolPolicy>`) control whether each tool is `enabled` and `autoApprove`d. The CLI mutates the policies object in-place mid-session and the agent sees changes on the next tool call. The VSCode auto-approve settings dialog maps to **policy changes**, which ARE supported natively.
+  - **Tool list** (the actual `Tool[]` array) is static after `build()`. Adding/removing MCP servers mid-session requires changing this array, which is NOT supported.
+
+  **Mitigation for auto-approve toggles**: Use `toolPolicies` mutation or `requestToolApproval` callback — both work mid-session.
+
+  **Mitigation for MCP tool list changes**: The SDK supports `initialMessages` on `start()`, which pre-loads conversation history into a new session. The Tauri desktop app (`apps/code/host/runtime-bridge.ts`) already uses this pattern for checkpoint restoration. When MCP servers change mid-session: (1) stop the current session, (2) read its messages via `readMessages(sessionId)`, (3) start a new session with `initialMessages` set to those messages + the updated MCP tool list. The agent continues seamlessly. This is simpler and more robust than dynamic tool wrappers.
+
+  **g) No mechanism for IDE-specific tool executors at the `DefaultSessionManager` level**:
+  The `defaultToolExecutors` option (line 310) allows overriding how builtin tools execute (e.g., `bash`, `editor`). This IS the extensibility point for IDE-specific behavior like using VSCode's integrated terminal. However, the executor interface is defined by the SDK and may not cover all VSCode-specific needs (e.g., diff view, browser session).
+  **Mitigation**: Investigate the `ToolExecutors` interface to see what's overridable. For tools not covered, use `extraTools` to provide custom implementations.
+
+- **Root cause**: The SDK was designed as a host-agnostic runtime. The `DefaultSessionManager` provides sensible defaults for CLI use, but VSCode integration requires overriding several of these defaults. All fields are `private readonly` — the class cannot be subclassed. `ClineCore.create()` always creates a `DefaultSessionManager` internally via `createSessionHost()` — there's no way to inject a custom `SessionHost`.
+
+- **Architecture decision — Wrapper vs Fork vs Direct Use:**
+
+  **Option A: Direct use of `ClineCore.create()`** — Cannot customize `source`, cannot intercept OAuth errors. ❌ Insufficient.
+
+  **Option B: Fork `DefaultSessionManager`** — Write a `VscodeSessionManager` (1516 lines to maintain). Full control but high maintenance burden. Reserve as fallback.
+
+  **Option C (Recommended): Wrapper around `DefaultSessionManager`** — Construct `DefaultSessionManager` directly (it's exported), pass all custom options, then wrap it in a thin `VscodeSessionHost` that implements `SessionManager`:
+  - Intercepts `start()` to inject `source: "vscode"`
+  - Provides custom `oauthTokenManager` that reads from `secrets.json`/`StateManager` and triggers VSCode login UI on re-auth (preventing the "clite" error path entirely — `syncOAuthCredentials` only throws the "clite" message when `OAuthReauthRequiredError` is caught, so if our custom manager handles re-auth differently, that code path is never reached)
+  - Provides custom `runtimeBuilder` for MCP (see S6-10)
+  - Provides `requestToolApproval` for VSCode approval UI
+  - Provides `defaultToolExecutors` for IDE-specific behavior
+  - Catches and translates any remaining errors from `send()`/`start()` into VSCode-appropriate signals
+
+  The wrapper is ~50-100 lines. If we hit walls where internal behavior can't be intercepted at the boundary, escalate to Option B.
+
+- **Fix needed**: Create `src/sdk/vscode-session-host.ts` with the following custom components:
+
+  **1. `VscodeSessionHost` (wrapper, ~50-100 lines)**
+  - Implements `SessionManager` interface (13 methods: `start`, `send`, `abort`, `stop`, `dispose`, `get`, `list`, `delete`, `readMessages`, `readTranscript`, `readHooks`, `subscribe`, `getAccumulatedUsage`)
+  - Delegates all methods to an inner `DefaultSessionManager`
+  - Intercepts `start()` to inject `source: "vscode"` (or check `SessionSource` enum for a VSCode variant)
+  - Catches errors from `start()`/`send()` and translates OAuth re-auth errors into VSCode-friendly signals (e.g., emit an event that triggers the login UI)
+
+  **2. `VscodeOAuthTokenManager` (custom `oauthTokenManager`, ~50 lines)**
+  - Implements `RuntimeOAuthTokenManager` interface (check `packages/core/src/session/` for the interface)
+  - `resolveProviderApiKey({ providerId, forceRefresh })`: reads OAuth tokens from `secrets.json` via `StateManager.get().getSecretKey("cline:clineAccountId")`, extracts `idToken`, adds `workos:` prefix
+  - On re-auth failure: instead of throwing `OAuthReauthRequiredError` (which triggers the "clite" message), emit a signal/event that the SdkController can use to show the VSCode login UI
+  - This prevents the "clite" error path in `syncOAuthCredentials` from ever being reached
+
+  **3. `VscodeRuntimeBuilder` (custom `runtimeBuilder`, ~100 lines)**
+  - Implements `RuntimeBuilder` interface (`build(config): { tools: Tool[], shutdown: () => void, ... }`)
+  - For builtin tools: delegate to `DefaultRuntimeBuilder`
+  - For MCP tools: read currently-connected servers from `McpHub`, convert to SDK `Tool[]` format
+  - See S6-10 for full MCP integration details
+
+  **4. `requestToolApproval` callback (~30 lines)**
+  - Receives `ToolApprovalRequest` with `toolName`, `input`, `policy`
+  - If `policy.autoApprove` is true: return `{ approved: true }` immediately
+  - Otherwise: emit an event to the webview showing the approval dialog, await user response
+  - Return `{ approved: boolean, reason?: string }`
+
+  **5. Wire into `SdkController`:**
+  - Replace `ClineCore.create()` with direct `DefaultSessionManager` construction + `VscodeSessionHost` wrapper
+  - Pass `VscodeOAuthTokenManager`, `VscodeRuntimeBuilder`, `requestToolApproval`, `defaultToolExecutors`
+  - Use `VscodeSessionHost.subscribe()` for event streaming to the webview
+
+  **Reference**: `DefaultSessionManager` constructor options at `packages/core/src/session/default-session-manager.ts:138-151`. `SessionManager` interface at `packages/core/src/session/session-manager.ts:57-73`. `RuntimeOAuthTokenManager` in `packages/core/src/session/`. `RuntimeBuilder` interface in `packages/core/src/runtime/`.
+
+### S6-10: DefaultRuntimeBuilder loads MCP tools once — no file watching
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SDK's `DefaultRuntimeBuilder.loadConfiguredMcpTools()` reads MCP settings from `CLINE_MCP_SETTINGS_PATH` (or default path) **once** at session start. It creates an `InMemoryMcpManager`, connects all servers, and returns tools. There is **no file watching** — changes to the MCP settings file after session start are not detected.
+- **Root cause**: The SDK's MCP integration was designed for CLI/batch use where sessions are short-lived. The VSCode extension's `McpHub` watches the settings file, supports dynamic connect/disconnect, provides real-time server status to the webview, and supports the MCP Marketplace.
+- **Impact**: Users cannot add/remove/restart MCP servers without restarting the extension. MCP server status in the webview will be stale. MCP Marketplace installs won't take effect until next session.
+- **Fix needed**: Two-layer approach:
+  1. **McpHub stays as the lifecycle manager**: Keep the classic `McpHub` for file watching, dynamic connect/disconnect, server status UI, and MCP Marketplace. It manages the MCP settings file and server connections independently of the SDK session.
+  2. **Custom RuntimeBuilder bridges McpHub → SDK tools**: At session start, a custom `RuntimeBuilder` reads the currently-connected MCP servers from `McpHub` and converts them to SDK `Tool[]` format. For builtin tools (editor, bash, etc.), delegate to `DefaultRuntimeBuilder`.
+  3. **Session restart on MCP tool list changes**: When `McpHub` detects that MCP servers have been added or removed (file watcher fires), and there's an active session: (a) stop the current session, (b) read its messages via `readMessages(sessionId)`, (c) start a new session with `initialMessages` set to those messages. The new session's `RuntimeBuilder.build()` will pick up the updated MCP tool list from `McpHub`. The Tauri desktop app (`apps/code/host/runtime-bridge.ts`) already uses this `initialMessages` pattern for checkpoint restoration.
+
+     **History deduplication caveat**: A session restart creates a new session ID. The old session's persisted data stays on disk, which would create a duplicate entry in the task history list. The Tauri desktop app avoids this via its "threads" abstraction — the UI tracks threads, not raw sessions, and updates the thread's session reference. For the VSCode extension, we need to either: (a) delete the old session's history entry when restarting, (b) mark it as "superseded" and filter it from the history view, or (c) reuse the same task ID / history entry and just swap the underlying session. Option (c) is cleanest — the `SdkController` already maintains a `currentTaskItem` that maps to the history view; on restart, keep the same task item and just update the internal session reference.
+  4. **No session restart needed for MCP tool policy changes**: If the user just toggles auto-approve for an MCP tool, that's a `toolPolicies` mutation — no session restart required.
+- **Reference**: Classic extension's `McpHub` in `src/services/mcp/McpHub.ts`; SDK's `InMemoryMcpManager` in `packages/core/src/extensions/mcp/`; Tauri desktop's session restart pattern in `apps/code/host/runtime-bridge.ts`
+
+### S6-12: Webview shows raw JSON instead of rendered messages
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the SDK streams events to the webview, the ChatRow.tsx component shows raw JSON instead of properly rendered messages (text, tool calls, etc.). The message translator was producing ClineMessages with the wrong format for tool calls — using `tool_name`/`tool_input`/`tool_output` keys instead of the `text` field with XML-like `<tool_name>...</tool_name>` format that ChatRow.tsx expects.
+- **Root cause**: The message translator's `translateToolCall()` and `translateToolResult()` methods were creating ClineMessages with custom fields (`tool_name`, `tool_input`, `tool_output`) that the webview's ChatRow.tsx doesn't understand. The classic Task class formats tool calls as XML-like text in the `text` field (e.g., `<read_file>\n<path>file.ts</path>\n</read_file>`), and ChatRow.tsx parses this format to render tool-specific UI.
+- **Fix applied**: Rewrote `translateToolCall()` and `translateToolResult()` in `src/sdk/message-translator.ts` to format tool calls as XML-like text in the `text` field, matching the classic Task's format. Added `formatToolCallText()` and `formatToolResultText()` helper functions. Updated `translateTextChunk()` to handle partial text streaming. Updated `translateAgentEvent()` to properly track tool call state (pending tool name, accumulating input, partial text).
+- **Verification**: Send a message that triggers tool use, verify ChatRow renders the tool call with proper formatting (file path, command, etc.) instead of raw JSON.
+- **Evidence**: Commits `bc3590534` and `26614a007` expanded SDK tool→webview mapping and added regression tests (`message-translator.test.ts`, `messageUtils.test.ts`) including multi-file `read_files` rendering and post-tool assistant text visibility.
+
+### S6-13: Webview state not populated with messages and task history
+- **Status**: 🔵 Awaiting Verification
+- **Description**: The webview's `ExtensionStateContext` wasn't receiving messages, current task item, or task history. The `subscribeToState` stream was pushing state updates without task data because the `WebviewGrpcBridge.pushStateUpdate()` method was building state without the controller's task reference.
+- **Root cause**: The `WebviewGrpcBridge` was importing `getStateToPostToWebview()` directly and calling it with `task: undefined`, which meant the state never included messages or the current task item. The bridge didn't have access to the controller's `getStateToPostToWebview()` method which knows about the active task.
+- **Fix applied**:
+  1. Added `setGetStateFn()` method to `WebviewGrpcBridge` that accepts the controller's `getStateToPostToWebview` bound method.
+  2. Updated `pushStateUpdate()` to use `getStateFn` when available (which includes task data), falling back to the minimal state builder.
+  3. Wired `grpcBridge.setGetStateFn(() => this.getStateToPostToWebview())` in `SdkController` constructor.
+- **Verification**: Send a message, verify the webview shows messages in the chat view and the task appears in history.
+
+### S6-14: VscodeRuntimeBuilder for MCP tool bridging
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SDK's `DefaultRuntimeBuilder.loadConfiguredMcpTools()` only supports stdio transport. SSE and streamableHttp MCP servers are filtered out, causing "Unsupported MCP transport" errors. The classic `McpHub` already supports all three transports.
+- **Root cause**: The SDK's `InMemoryMcpManager` with `createDefaultMcpServerClientFactory()` only creates stdio clients. The VSCode extension's `McpHub` has its own connection management that supports stdio, SSE, and streamableHttp.
+- **Fix applied**: Created `src/sdk/vscode-runtime-builder.ts` with:
+  1. `McpHubToolProvider` — adapter that makes the classic McpHub look like an SDK `McpToolProvider` (implements `listTools()` and `callTool()` by delegating to McpHub).
+  2. `VscodeRuntimeBuilder` — custom `RuntimeBuilder` that delegates builtin tool creation to `DefaultRuntimeBuilder` but replaces MCP tools with ones loaded from the classic `McpHub`. This gives the SDK agent access to all MCP servers regardless of transport type.
+  3. Tool name transform matches SDK's default (`serverName__toolName` format).
+- **Wiring**: The `VscodeRuntimeBuilder` is now wired into session creation via `VscodeSessionHost.create()`, which passes it as the `runtimeBuilder` option to `DefaultSessionManager`. The `VscodeSessionHost` also writes an empty MCP settings file and points `CLINE_MCP_SETTINGS_PATH` to it, so the `DefaultRuntimeBuilder`'s internal `loadConfiguredMcpTools()` loads no MCP tools — the `VscodeRuntimeBuilder` replaces them with tools from the classic `McpHub`.
+- **Verification**: Start a session with MCP servers configured (including SSE/streamableHttp), verify the agent can use MCP tools from all transport types.
+
+### S6-11: Credential caching from classic extension may not work
+- **Status**: 🟢 Verified Fixed
+- **Description**: Cached credentials from the classic extension (`globalState.json` + `secrets.json`) are now correctly reused. The `buildSessionConfig()` function reads from `StateManager.getApiConfiguration()` (which includes secrets) and uses `resolveApiKey()` / `resolveModelId()` functions that handle all 30+ providers including the "cline" provider's OAuth token extraction.
+- **Root cause (fixed)**: Same as S6-5 — replaced broken `ProviderSettingsManager` and `buildApiHandlerSettings()` paths with direct `ApiConfiguration` reading.
+- **Fix applied**: `src/sdk/cline-session-factory.ts` — `resolveApiKey()`, `resolveModelId()`, `resolveBaseUrl()` functions that read from `StateManager.getApiConfiguration()`.
+- **Verification**: Debug harness session shows inference working with `z-ai/glm-5.1` provider using cached credentials. No re-login required.
+- **Evidence**: Same as S6-5 — debug harness session on 2026-04-14.
+
+### S6-15: History items not clickable (welcome page and history view)
+- **Status**: 🔴 Blocker — **Merged into S6-6**
+- **Description**: Same issue as S6-6. Clicking history items from the welcome page does nothing. Clicking history items from the history view navigates back to the welcome page instead of loading the task.
+- **Note**: This issue is tracked under S6-6. Likely shares a common root cause with S6-5 (view transition logic).
+
+### S6-16: Sending a message completes immediately with no output
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the user types and submits a message, the task immediately shows as "completed" with no tokens, no size, and no output. The webview console shows `handleSendMessage - Sending message: <text>` followed by four `ended "got subscribed state"` messages. No inference occurs.
+- **Root cause**: Two issues:
+  1. **Inference was actually working** — the SDK agent ran, produced output, and completed with tokens. But the output was invisible because of issue #2.
+  2. **Partial message handler dropped new messages** — The webview's `ExtensionStateContext.tsx` partial message handler only updated existing messages by matching timestamps (`findLastIndex` by `ts`). If no existing message matched, the message was silently dropped (`return prevState`). In the classic extension, messages were first added via state updates, then updated in-place by partial messages. In the SDK migration, messages arrive via the partial message stream *before* any state update, so they were all dropped.
+- **Fix**: In `webview-ui/src/context/ExtensionStateContext.tsx`, when a partial message arrives with a new timestamp (no match), append it to the `clineMessages` array instead of returning `prevState` unchanged. Also added debounced ClineMessage persistence in `SdkController.ts` so task history can load messages via `readUiMessages()`.
+- **Verification**: Debug harness: sent "Say hello", Playwright locator found 3 elements containing "Hello" (user message + AI response). SDK returned: `"Hello! 👋 How can I help you today?"` with `inputTokens: 2776, outputTokens: 36, totalCost: 0.01478`.
+- **Evidence**: Commit `32f1fa84e` on `sdk-migration-v3`.
+
+### S6-17: Cancel button enabled after task "completes" but does nothing
+- **Status**: 🟡 Minor
+- **Description**: Despite the task showing as "completed", the cancel button remains enabled. Clicking it disables the button but has no visible effect. Sending a follow-up message after cancellation just logs `handleSendMessage` again with no inference.
+- **Root cause**: Likely related to S6-16 — the task state isn't being properly set to "completed" in the webview, so the cancel button's enabled/disabled state is wrong. The follow-up message issue is the same root cause as S6-16.
+- **Fix**: Fix S6-16 first. Then verify the task completion state properly disables the cancel button and enables the follow-up input.
+
+### S6-18: Missing API key shows error instead of login prompt
+- **Status**: 🔴 Blocker
+- **Description**: When not logged in and attempting inference with the "cline" provider, instead of showing a login prompt, the user sees a red error message: `Missing API key for provider "cline". Set apiKey explicitly or one of: CLINE_API_KEY.` followed by "Thinking..." that spins forever.
+- **Root cause**: The `resolveApiKey()` function in `cline-session-factory.ts` reads the access token from `providers.json`. When the user is not logged in, there's no token, and the SDK throws a generic "missing API key" error. The classic extension would detect the missing Cline credentials and show a login button instead. The error handling in `SdkController.initTask()` doesn't distinguish between "missing credentials for cline provider" (should show login UI) and other API key errors.
+- **Fix**: In `SdkController.initTask()` or the session error handler, detect when the error is about missing Cline credentials specifically and emit a signal to the webview to show the login UI instead of a generic error. Alternatively, check for Cline credentials before starting the session and redirect to login if missing.
+- **Verification**: Log out, attempt to send a message with "cline" provider selected, verify a login prompt appears instead of the error.
+
+### S6-19: History deletion dialog confirms but doesn't delete
+- **Status**: 🟢 Verified Fixed
+- **Description**: When clicking the delete button on a history item, a confirmation dialog appears. After confirming, the item is deleted from state/disk AND the UI updates immediately — both the history list and the recents list on the welcome page reflect the deletion.
+- **Root cause**: The `deleteTaskWithId` handler in `src/core/controller/task/deleteTasksWithIds.ts` called `controller.getTaskWithId(id)` before `deleteTaskFromState(id)`. When the task's `apiConversationHistory` file didn't exist on disk (common for new/short tasks), `getTaskWithId()` threw `"Task not found"`, which was caught and re-thrown. The `postStateToWebview()` call at the end of the function was outside the try/catch block and was never reached. The state was updated (because `getTaskWithId` called `deleteTaskFromState` internally before throwing), but the webview was never notified.
+- **Fix applied**: Restructured `deleteTaskWithId()` to: (1) call `deleteTaskFromState(id)` first (always succeeds, updates in-memory cache immediately), (2) clean up task files on disk as best-effort (wrapped in try/catch), (3) always call `postStateToWebview()` at the end. Removed the `getTaskWithId()` call entirely — it's not needed for deletion since the task directory path can be constructed directly from the ID. Also simplified file cleanup to use `fs.rm(taskDirPath, { recursive: true, force: true })` instead of deleting individual files.
+- **Verification**: Debug harness test on 2026-04-16: Created 2 tasks ("Say hello world", "Say goodbye world"). Deleted "Say goodbye world" via the history view delete button. History list immediately showed only "Say hello world" (1 delete button, size 682 B down from 1.3 kB). Navigated to welcome page — recents list showed only "Say hello world". Disk state confirmed: only 1 task in `taskHistory.json`, only 1 task directory remaining.
+- **Evidence**: Debug harness session on 2026-04-16.
+
+### S6-20: MCP tools panel is empty / MCP tools not available to agent
+- **Status**: 🟢 Verified Fixed
+- **Description**: Two related issues: (1) The MCP tools panel in the sidebar shows no tools, even when MCP servers are configured. (2) The SDK's DefaultSessionBuilder does not support dynamic MCP tools — tools are loaded once at session build time, so adding/removing MCP servers mid-session had no effect.
+- **Root cause**: The VscodeRuntimeBuilder already bridges McpHub → SDK tools at session start, but there was no mechanism to reload tools when the McpHub's server list changed after session creation.
+- **Fix**: Implemented a tool-list-change detection and session restart mechanism:
+  - `McpHub.ts`: Added `computeToolFingerprint()` to detect actual tool list changes (vs. mere status updates), `setToolListChangeCallback()`/`clearToolListChangeCallback()` for subscribers, and `checkToolListChanged()` called from `notifyWebviewOfServerChanges()`.
+  - `SdkController.ts`: Added `handleMcpToolListChanged()` which restarts the session immediately when idle, or defers via `mcpToolRestartPending` flag until the current turn completes (`checkDeferredMcpToolRestart()` called from `handleSessionEvent()` on turn completion). `restartSessionForMcpTools()` creates a new VscodeSessionHost with fresh tools, preserves conversation messages, and emits info messages to the chat.
+  - `task-proxy.ts`: Made `taskId` settable so the session restart can update the proxy's session ID without recreating it (preserving accumulated messages).
+- **Tests**: 16 unit tests in `src/services/mcp/__tests__/McpHub.toolListChange.test.ts` covering fingerprinting, callback firing, edge cases.
+- **Verification**: Start a task, then add/remove an MCP server in `cline_mcp_settings.json`. The chat should show "MCP tools changed — reloading tools for this session..." and "MCP tools reloaded successfully." The agent should then be able to use the new tools.
+
+### S6-21: Incremental messages are repeated/duplicated in chat output
+- **Status**: 🟢 Verified Fixed
+- **Description**: After the S6-16 fix (appending new partial messages), the AI response text was repeated multiple times in the chat. Additionally, during streaming, the text appeared in a "flip book" style — fragments flashed and replaced each other rather than smoothly appending.
+- **Root cause**: The message translator was using `event.text` (the delta/chunk) for streaming text messages. The SDK emits MULTIPLE `content_start` events during streaming, each with `text` (delta) and `accumulated` (full text so far). Using the delta caused each update to replace the previous content with just the new chunk, creating a "flip book" effect.
+- **Fix applied**: Changed `message-translator.ts` to use `event.accumulated ?? event.text` for streaming text content_start events. This gives smooth streaming — the webview updates the message in-place with the growing accumulated text.
+- **Note on state push**: An earlier fix attempt removed `postStateToWebview()` from `handleSessionEvent()` to prevent double state updates. This was reverted because the webview needs the full `clineMessages` array in state for proper rendering — without it, streaming appeared completely broken (the webview sat on "Thinking" and only showed the completed response at the end). The `postStateToWebview()` call is now restored. The `MessageStateHandler.addMessages()` deduplicates by timestamp, so the state update and partial message stream don't cause duplication.
+- **Verification**: 34 unit tests pass in `message-translator.test.ts` including 3 new tests for accumulated text streaming behavior.
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 34/34 pass.
+
+### S6-22: User input message displays as "{}" instead of message text
+- **Status**: 🔵 Awaiting Verification
+- **Description**: The task header box at the top of the chat shows `{}` instead of the actual user message text (e.g., "Say hello"). The message is sent correctly (inference works), but the display of the user's input in the chat header is wrong.
+- **Root cause**: The initial "task" message was emitted via `emitSessionEvents()` in `SdkController.initTask()`, which sent it to listeners (including the gRPC bridge for partial message streaming) but did NOT add it to the `messageStateHandler`. When `getStateToPostToWebview()` built the state, `clineMessages` from the handler was empty (missing the task message). The state update then arrived at the webview and replaced the partial-message-sourced `clineMessages` (which had the task message) with the empty state `clineMessages`, losing the user's input text. The webview then showed `{}` because `task.text` was undefined.
+- **Fix applied**: In `SdkController.initTask()`, the task message is now added to `this.task.messageStateHandler.addMessages([taskMessage])` BEFORE emitting to listeners. This ensures `getStateToPostToWebview()` includes the task message in `clineMessages`, so the state update preserves it.
+- **Verification**: Send a message, verify the task header shows the actual message text.
+
+### S6-23: Opening a message from history returns to welcome screen
+- **Status**: 🔵 Awaiting Verification — **Same fix as S6-6**
+- **Description**: Clicking a task in the history list briefly flashes the chat view, then returns to the welcome screen. Opening a recent conversation from the welcome screen also shows a brief flash and returns to the welcome screen. The `showTaskWithId()` method loads messages from disk but the view transition doesn't stick.
+- **Root cause**: Same as S6-6 — `showTaskWithId()` called `clearTask()` which set `this.task = undefined` and triggered async session teardown that raced with the new task proxy creation.
+- **Fix applied**: Same as S6-6 — rewrote `showTaskWithId()` to avoid `clearTask()` race condition.
+- **Verification**: Click a history item, verify the chat view loads and stays visible with the task's messages.
+
+### S6-24: Tool use blocks ("Cline wants to create a new file") are empty
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the agent uses tools (e.g., `editor`), the tool use block in the chat showed the header ("Cline wants to create a new file") but the content area was empty — no file path, no diff, no content preview.
+- **Root cause**: The `content_end` event for tools does NOT carry the tool's `input` (path, content, etc.). The message translator was passing `undefined` as the input to `sdkToolToClineSayTool()` at `content_end`, resulting in a `ClineSayTool` with empty `path`, `content`, and `diff` fields. The `content_start` event DOES carry the input, but it wasn't being preserved for use at `content_end`.
+- **Fix applied**: Three changes to `src/sdk/message-translator.ts`:
+  1. Added `streamingToolInput` and `streamingToolName` fields to `MessageTranslatorState` to store the tool context from `content_start`.
+  2. At `content_start` for tools, store the input via `state.setStreamingToolContext(toolName, input)`.
+  3. At `content_end` for tools, retrieve the stored input via `state.getStreamingToolInput()` and pass it to `sdkToolToClineSayTool()` instead of `undefined`.
+  4. The stored context is cleared in `clearStreamingTool()` and `reset()`.
+- **Verification**: 4 new unit tests verify: (1) editor edit preserves path+content through content_start→content_end, (2) newFileCreated preserves content, (3) read_files preserves path, (4) graceful fallback when content_end arrives without prior content_start.
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 34/34 pass.
+
+### S6-25: Streaming text appears in "flip book" style instead of smooth append
+- **Status**: 🟢 Verified Fixed (same root cause as S6-21)
+- **Description**: During streaming, the AI response text appeared in a "flip book" style — the entire message content flashed and replaced itself on each chunk, rather than smoothly appending new characters.
+- **Root cause**: Same as S6-21. The message translator was using `event.text` (the delta) instead of `event.accumulated` (the full text so far). Each streaming update replaced the message content with just the new chunk instead of the growing accumulated text.
+- **Fix applied**: Same as S6-21 — changed `message-translator.ts` to use `event.accumulated ?? event.text` for streaming text. All streaming chunks now share the same timestamp and use accumulated text, giving smooth in-place updates.
+- **Verification**: 3 new unit tests verify: (1) accumulated text is used over delta, (2) fallback to text when accumulated is absent, (3) all streaming chunks share the same timestamp.
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 34/34 pass.
+
+### S6-26: SDK pending prompts / tool approval / ask_question not integrated
+- **Status**: 🔵 Awaiting Verification
+- **Description**: The SDK has three mechanisms for the agent to interact with the user mid-task, none of which are currently wired into the VSCode extension:
+
+  **1. `requestToolApproval` callback** — When a tool's policy has `autoApprove: false`, the agent calls `requestToolApproval({ agentId, conversationId, iteration, toolCallId, toolName, input, policy })` and blocks until the callback returns `{ approved: boolean, reason?: string }`. Without this callback, ALL non-auto-approved tools are denied with "no approval handler is configured". This is the equivalent of the classic extension's "Cline wants to..." approval dialog.
+
+  **2. `ask_question` tool executor** — The SDK has a built-in `ask_question` tool (equivalent to the classic `ask_followup_question`). It requires an `askQuestion` executor function passed via `defaultToolExecutors: { askQuestion: fn }`. The executor receives `(question, options, context)` and returns the user's answer as a string. Without this executor, the tool is excluded from the agent's tool list entirely. The CLI implements this as `askQuestionInTerminal` which prompts in the terminal.
+
+  **3. Pending prompts system** — When the user sends a message while the agent is already running, `send()` with `delivery: "queue"` or `delivery: "steer"` enqueues the message as a pending prompt. The SDK emits `pending_prompts` events with the current queue snapshot, and `pending_prompt_submitted` events when a queued prompt is consumed. The `drainPendingPrompts()` method processes the queue when the agent is idle. `"steer"` prompts go to the front of the queue; `"queue"` prompts go to the back. The Tauri desktop app and CLI TUI both subscribe to these events to show queued messages in the UI.
+
+- **Root cause**: The `VscodeSessionHost` currently passes no `requestToolApproval` callback and no `defaultToolExecutors.askQuestion`. The `SdkController.askResponse()` method sends with no `delivery` parameter (defaults to "immediate"), which blocks if the agent is already running.
+
+- **Impact**: 
+  - Tools that require approval are silently denied → agent can't use file editing, commands, etc. unless everything is auto-approved
+  - Agent can't ask the user clarifying questions → `ask_question` tool is missing from the tool list
+  - User can't send follow-up messages while the agent is running → `send()` throws "already in progress"
+
+- **Fix needed** (three parts):
+
+  **Part A: `requestToolApproval` callback (~50 lines)** — ✅ **Fixed**
+  Wired into `VscodeSessionHost.create()` via `requestToolApproval` option in `startNewSession()`. The callback:
+  1. Converts SDK `ToolApprovalRequest` (toolName + input) to `ClineSayTool` JSON using the exported `sdkToolToClineSayTool()` from `message-translator.ts`
+  2. Emits a ClineMessage with `type: "ask"`, `ask: "tool"` — the webview's existing tool approval UI renders this (Approve/Save/Reject buttons in ChatRow)
+  3. Adds the message to `messageStateHandler` and pushes to the partial message stream via `emitSessionEvents()` + `postStateToWebview()`
+  4. Returns a Promise that resolves when the user clicks Approve/Reject in the webview
+  5. Resolution path: webview button click → gRPC `askResponse` handler → TaskProxy.handleWebviewAskResponse() (stores `askResponse` type in `taskState.askResponse`) → SdkController.askResponse() → checks `pendingToolApprovalResolve` → reads `taskState.askResponse` to determine `yesButtonClicked` (approved) vs `noButtonClicked` (denied) → resolves Promise with `{ approved: true/false }`
+  6. `cancelTask()` and `clearTask()` both resolve pending approval with `{ approved: false }` to prevent leaks
+  
+  **Files changed**: `src/sdk/message-translator.ts` (exported `sdkToolToClineSayTool`), `src/sdk/SdkController.ts` (added `pendingToolApprovalResolve` field, `requestToolApproval` callback in `startNewSession()`, approval resolution in `askResponse()`, cleanup in `cancelTask()`/`clearTask()`)
+  
+  **Evidence**: TypeScript compiles with 0 errors (`npx tsc --noEmit --skipLibCheck`). All 136 SDK adapter tests pass (`npx vitest run --config vitest.config.sdk.ts`). The 3 pre-existing test suite failures are unrelated import resolution errors.
+
+  **Part B: `askQuestion` executor (~30 lines)** — ✅ **Fixed**
+  Wired into `VscodeSessionHost.create()` via `defaultToolExecutors: { askQuestion: fn }`. The executor:
+  1. Builds a `ClineAskQuestion` JSON payload with `question` and `options`
+  2. Emits a ClineMessage with `type: "ask"`, `ask: "followup"` — the webview's existing follow-up question UI renders this
+  3. Returns a Promise that resolves when the user responds via `askResponse()`
+  4. `askResponse()` checks `pendingAskResolve` first — if set, resolves the Promise with the user's answer instead of sending a new SDK message
+  5. `cancelTask()` and `clearTask()` both clear `pendingAskResolve` to prevent leaks
+  
+  **Files changed**: `src/sdk/vscode-session-host.ts` (added `askQuestion` option, `defaultToolExecutors` in `ClineCore.create()`), `src/sdk/SdkController.ts` (added `pendingAskResolve` field, executor implementation in `startNewSession()`, resolution in `askResponse()`, cleanup in `cancelTask()`/`clearTask()`)
+  
+  **Evidence**: TypeScript compiles with 0 errors (`npx tsc --noEmit --skipLibCheck`). All 148 SDK adapter tests pass (`npx vitest run --config vitest.config.sdk.ts`). The 2 pre-existing test suite failures (`auth-service.test.ts`, `cline-session-factory.test.ts`) are unrelated `@hosts/host-provider` import errors.
+
+  **Part C: Pending prompts for follow-up messages (~20 lines)** — ✅ **Fixed**
+  Updated `SdkController.askResponse()` to detect when the session is already running (`wasAlreadyRunning = this.activeSession.isRunning`) and pass `delivery: "queue"` to `fireAndForgetSend()`. The SDK enqueues the message and drains it after the current turn completes. Three changes:
+  1. `fireAndForgetSend()` accepts an optional `delivery` parameter, passes it to `sessionManager.send()`, and skips `isRunning = false` when delivery is "queue"/"steer" (since the turn didn't complete — the message was just enqueued)
+  2. `askResponse()` captures `wasAlreadyRunning` before setting `isRunning = true`, computes `delivery = wasAlreadyRunning ? "queue" : undefined`, and passes it through. Also skips `messageTranslatorState.reset()` for queued messages since the current turn is still active.
+  3. `handleSessionEvent()` logs `pending_prompts` and `pending_prompt_submitted` events for visibility (the SDK emits these when queued messages are enqueued/consumed).
+  
+  **Files changed**: `src/sdk/SdkController.ts` (updated `fireAndForgetSend()` signature, `askResponse()` delivery logic, `handleSessionEvent()` logging)
+  
+  **Evidence**: TypeScript compiles with 0 errors (`npx tsc --noEmit --skipLibCheck`). All 136 SDK adapter tests pass (`npx vitest run --config vitest.config.sdk.ts`). The 3 pre-existing test suite failures are unrelated import resolution errors.
+  
+  **Reference**: CLI wiring at `apps/cli/src/runtime/run-interactive.ts:642-777`. Tauri desktop at `apps/code/sidecar/chat-session.ts:429-467`.
+
+- **Verification**: 
+  1. Start a task that uses tools → verify approval dialog appears → approve → tool executes
+  2. Start a task where the agent calls `ask_question` → verify question appears in chat → answer → agent continues
+  3. While agent is running, send a follow-up message → verify it queues and is processed after the current turn
+
+### S6-27: History messages not rendering when opened (S6-6 still broken)
+- **Status**: 🟢 Verified Fixed
+- **Description**: Clicking a history item (from the welcome page's "Recent" section or the history view) did not render the task's messages. The chat view either stayed on the welcome page or showed no messages.
+- **Root cause**: The gRPC handler `src/core/controller/task/showTaskWithId.ts` was calling `controller.initTask(undefined, undefined, undefined, historyItem)` which started a **new SDK session** instead of loading the existing task's messages from disk. The `SdkController.initTask()` method creates a new session, new task proxy, and new history item — it does NOT load saved messages. Meanwhile, `SdkController.showTaskWithId()` (which correctly loads messages from disk, creates a task proxy with those messages, and pushes them to the webview) was never being called.
+- **Fix applied**: Changed `src/core/controller/task/showTaskWithId.ts` to call `controller.showTaskWithId(id)` instead of `controller.initTask(...)`. The `SdkController.showTaskWithId()` method handles: (1) looking up the history item, (2) tearing down any active session, (3) creating a task proxy with loaded messages, (4) pushing messages through both state updates and partial message stream, (5) posting state to the webview.
+- **Verification**: Debug harness test on 2026-04-16: (1) Sent "Say hello world test", inference completed with "Hello world test! 👋". (2) Clicked "New Task" to navigate to welcome page. (3) Clicked the history item from the "Recent" section. (4) Chat view loaded with all 5 messages: task, api_req_started, text response, api_req_started with tokens, completion_result.
+- **Evidence**: Debug harness session on 2026-04-16. Messages confirmed saved to `ui_messages.json` at `HostProvider.globalStorageFsPath/tasks/<id>/`. Both direct gRPC call and click-based navigation verified.
+
+---
+
+## Priority & Next Steps
+
+**Current state (updated 2026-04-20)**: Inference works end-to-end. History open/resume flow is working, MCP OAuth + provider OAuth callbacks are implemented, and MCP tool reload preserves task/session continuity. Tool-call rendering in chat has been improved (including multi-file `read_files`).
+
+### 🟢 Resolved: S6-27 — History messages not rendering
+
+Fixed. The gRPC handler was calling `controller.initTask()` (starts new session) instead of `controller.showTaskWithId()` (loads messages from disk). See S6-27 entry for details.
+
+### 🔵 Awaiting Verification: S6-26 — Pending prompts / tool approval / ask_question
+
+All three parts fixed (Part A: requestToolApproval, Part B: askQuestion, Part C: pending prompts with delivery: "queue"). Awaiting manual verification.
+
+### 🔴 Third Priority: S6-18 — Missing API key shows error instead of login prompt
+
+When not logged in with the "cline" provider, the user sees a raw error instead of a login prompt. This blocks the first-run experience.
+
+### 🟡 Lower Priority:
+- S6-17: Cancel button state
+- S6-2: OCA and Codex OAuth flows not yet verified
+- S6-7: Credits/payment history don't load immediately
+
+### S6-28: MCP tool reload messages appear twice in chat
+- **Status**: 🟢 Verified Fixed
+- **Description**: When saving the MCP settings file (triggering a tool list change), the info messages "MCP tools changed — reloading tools for this session..." and "MCP tools reloaded successfully." each appeared TWICE in the chat. The tool reload itself worked correctly — only the messages were duplicated.
+- **Root cause**: `notifyWebviewOfServerChanges()` in McpHub fires multiple times in quick succession when a server connects (status change → tools discovered → etc.). Each call triggered `checkToolListChanged()` which detected the fingerprint change and fired the callback. The callback fired multiple times before the fingerprint was updated, causing duplicate messages.
+- **Fix applied**: Added 300ms debounce to `checkToolListChanged()` in `McpHub.ts`. The method now: (1) quick-checks the fingerprint — if unchanged, returns immediately without scheduling a timer, (2) if changed, debounces via `setTimeout(300ms)` to coalesce rapid-fire changes, (3) after the debounce, `fireToolListChangeIfNeeded()` re-checks the fingerprint and fires the callback only if it actually changed.
+- **Verification**: Save MCP settings file, verify each message appears exactly once.
+
+### S6-30: Follow-up messages silently dropped after task completion
+- **Status**: 🟢 Verified Fixed
+- **Description**: After a task completed, typing a follow-up message and pressing Enter (or clicking Send) did nothing. The message appeared in the textarea but was never sent. The `ui.send_message` gRPC method worked (bypassing the webview's `handleSendMessage`), but DOM-level input was broken.
+- **Root cause**: The webview's `handleSendMessage()` in `useMessageHandlers.ts` requires `clineAsk` to be set to send follow-up messages. The classic extension emits `ask: "completion_result"` when a task completes, which sets `clineAsk` in the webview. The SDK's message translator was emitting `say: "completion_result"` (a display-only message) instead of `ask: "completion_result"` (which enables the follow-up input). Without the ask message, `handleSendMessage()` fell through to the "task is running" check (which was false since the task was complete), and the message was silently dropped (`messageSent` stayed `false`).
+- **Fix applied**: Changed `src/sdk/message-translator.ts` to emit `type: "ask", ask: "completion_result"` instead of `type: "say", say: "completion_result"` for the `done` agent event. Only the ask is emitted (not both say+ask) to avoid duplicate "Task Completed" displays in the webview.
+- **Verification**: Debug harness test on 2026-04-17: (1) Sent "Say hello" via `ui.send_message`, task completed. (2) Typed "Now say goodbye" via `ui.react_input` with `submit: true`. (3) Follow-up inference ran and returned "Goodbye! 👋". (4) Also tested MCP tools in follow-up turns — `kb_search` worked correctly.
+- **Evidence**: Debug harness session on 2026-04-17.
+
+### S6-29: MCP tool reload leaves UI in "Thinking..." state, blocking follow-ups
+- **Status**: 🟢 Verified Fixed
+- **Description**: After an MCP tool reload (triggered by toggling a server in the MCP panel), the chat showed "MCP tools changed" and "MCP tools reloaded" info messages but the UI was left in a "Thinking..." state. Follow-up messages could not be sent because the webview's `handleSendMessage()` requires `clineAsk` to be set.
+- **Root cause**: `restartSessionForMcpTools()` emitted `say: "info"` messages for the reload status but did NOT emit `ask: "completion_result"` afterward. Without the ask message, `clineAsk` was not set in the webview, so `handleSendMessage()` silently dropped follow-up input.
+- **Fix applied**: After the success info message in `restartSessionForMcpTools()`, emit an `ask: "completion_result"` message with empty text. This tells the webview the agent is idle and enables the follow-up input.
+- **Verification**: Debug harness test on 2026-04-17: (1) Sent "Say hello briefly", task completed. (2) Toggled kamibiki MCP server off via UI. (3) "MCP tools changed" + "MCP tools reloaded" messages appeared (no "Thinking..." state). (4) Typed "Say goodbye" via `ui.react_input` — follow-up inference ran and returned "Goodbye! 👋".
+- **Evidence**: Debug harness session on 2026-04-17.
+
+### S6-31: Conversation history lost after MCP tool changes (session recreated)
+- **Status**: 🟢 Verified Fixed
+- **Description**: MCP-triggered session restarts now preserve active task/session continuity, preventing chat/task state loss after toggling MCP servers.
+- **Root cause**: Session recreation could break task/session linkage in webview state.
+- **Fix applied**: In `restartSessionForMcpTools()` (`src/sdk/SdkController.ts`), set `config.sessionId = oldSessionId` and keep the task ID stable even if SDK returns a different ID, with warning log fallback. This keeps `currentTaskItem` mapping intact during MCP reloads.
+- **Verification**: Toggle MCP server while chat is active, verify task remains active and state continuity is preserved.
+- **Evidence**: Commit `b2db4937a` (“preserve task session id when reloading MCP tools”).
+
+### S6-32: "New Task" button and task delete disabled after MCP tool change
+- **Status**: 🟢 Verified Fixed
+- **Description**: Button-state lockups after MCP tool changes are resolved.
+- **Root cause**: UI/task continuity broke when MCP restarts changed session identity/state linkage.
+- **Fix applied**: Same core fix as S6-31 (`b2db4937a`) keeps task/session identity stable during MCP reloads, preventing webview state from drifting into a pseudo-running state.
+- **Verification**: After MCP toggle, verify New Task and delete actions remain enabled/functional.
+- **Evidence**: Commit `b2db4937a`.
+
+### S6-33: Insufficient credits shows raw error text instead of buy-credits UI
+- **Status**: 🔴 Blocker
+- **Description**: When attempting inference with no credits (negative balance), the chat displays the raw error text "Insufficient balance. Your Cline Credits balance is $-0.14" followed by "Thinking..." that spins forever. The classic extension shows an interactive error state with buttons to buy credits, switch providers, etc. The SDK error is displayed as plain text with no actionable UI.
+- **Root cause**: The SDK throws an error (or emits an error event) when the API returns a 402/insufficient-balance response. The `SdkController` or message translator doesn't distinguish this error type from generic API errors. In the classic extension, `attemptApiRequest()` catches balance errors specifically and emits `ask: "api_req_failed"` with structured error info that the webview's `ChatRow.tsx` renders with buy-credits buttons and provider-switching options. The SDK adapter just displays the error text as a `say: "error"` message, which has no interactive UI.
+- **Fix**: Not yet attempted. The error handler in `SdkController` (or the message translator's error event handler) needs to detect insufficient-balance errors (check for 402 status, "insufficient balance" text, or SDK-specific error types) and emit `ask: "api_req_failed"` with the appropriate structured payload that the webview expects for rendering the buy-credits UI.
+- **Verification**: Log in with an account that has no credits, attempt inference, verify the buy-credits buttons and provider-switch options appear instead of raw error text.
+
+### S6-34: Cancel during generation doesn't show "Resume task" and follow-ups don't display
+- **Status**: 🔵 Awaiting Verification
+- **Description**: Two related issues when cancelling during active generation: (1) After hitting "Cancel" while the agent is streaming, the button does not change to "Resume task" — it stays in a stuck state without the expected resume option. (2) If the user sends another message after cancelling, the message does not display in the chat panel (though it may be sent to the backend).
+- **Root cause**: The classic extension emits `ask: "resume_task"` when a task is cancelled mid-generation, which tells the webview to show the "Resume task" button and enables the follow-up input. The SDK adapter's `cancelTask()` called `sessionManager.abort()` but didn't emit `ask: "resume_task"` afterward. Instead it emitted `say: "info"` with "Task cancelled", which doesn't set `clineAsk` in the webview. Without the ask message, `handleSendMessage()` doesn't handle follow-up correctly.
+- **Fix applied**: Changed `cancelTask()` in `src/sdk/SdkController.ts` to emit `ask: "resume_task"` instead of `say: "info"`. The resume message is added to both `messageStateHandler` (for state updates) and emitted via `emitSessionEvents()` (for the partial message stream). This mirrors the classic extension's `Task.abortTask()` behavior. Also persists the message to disk via `debouncedSaveClineMessages()`. See also S6-46 for the related AbortError suppression.
+- **Verification**: Debug harness test: (1) Send a message that triggers long generation (2) Hit Cancel during streaming (3) Verify "Resume task" button appears (4) Send a follow-up message (5) Verify it displays in chat and triggers inference
+
+<!-- Template:
+### [ID] Title
+- **Status**: 🔴/🟡/🔵/🟢
+- **Description**: What's wrong
+- **Root cause**: If known
+- **Fix**: If attempted, with file references
+- **Verification**: How to verify (test name, harness command)
+- **Evidence**: Test output, screenshot, etc. (required for 🟢)
+-->
+
+### S6-35: Inference cost not displayed in task
+- **Status**: 🟢 Fixed
+- **Description**: During and after inference, the cost/token usage is not displayed in the task's chat view. The classic extension shows token counts (input/output/cache) and cost in the `api_req_started` message block. The SDK adapter emits `api_req_started` messages but likely doesn't populate the cost/token fields, or the `usage` event from the SDK isn't being translated into the format the webview expects.
+- **Root cause**: The SDK emits `usage` events (with `inputTokens`, `outputTokens`, `cacheReadTokens`, `cacheWriteTokens`, `totalCost`) via `agent_event` with `type: "usage"`. The message translator likely creates `api_req_started` messages without the cost JSON payload, or doesn't update them with final usage data when the `usage` event arrives. The webview's `ApiRequestRow` component expects `api_req_started` messages to have a `text` field containing JSON with `{tokensIn, tokensOut, cacheReads, cacheWrites, cost}`.
+- **Fix**: Fixed in use latest sdk main (#10337)
+- **Verification**: Send a message, verify that token counts and cost appear in the collapsible API request row in the chat.
+
+### S6-36: Returning to an in-progress task after clicking New Task shows stale "Thinking..."
+- **Status**: 🟢 Verified Fixed
+- **Description**: If the user clicked New Task mid-generation and later reopened the old task, the old task could still appear as streaming/"Thinking..." due to partially persisted messages.
+- **Root cause**: Task clear/load paths could persist partial messages without finalization, so reopening rendered stale streaming state.
+- **Fix applied**: `clearTask()` now finalizes messages before save (removes `partial`, marks last unfinished `api_req_started` as `cancelReason: "user_cancelled"`), and `showTaskWithId()` sanitizes loaded messages + appends the appropriate resume ask (`resume_task` or `resume_completed_task`).
+- **Verification**: Click New Task during a running task, reopen previous task, verify it no longer appears stuck in "Thinking...".
+- **Evidence**: Commit `70b5ff110`.
+
+### S6-37: Tool-call rendering gaps (multi-file read_files + post-tool assistant text)
+- **Status**: 🟢 Verified Fixed
+- **Description**: Two rendering gaps remained in chat tool-call UX: (1) `read_files` with multiple files showed only one file path, and (2) assistant text after tool results could be dropped by low-stakes tool grouping.
+- **Root cause**:
+  1. Translator extracted only the first file path for `read_files`.
+  2. `groupLowStakesTools()` ignored text that arrived after a tool group had started.
+- **Fix applied**:
+  1. `message-translator.ts` now emits one `readFile` tool message per file for multi-file reads.
+  2. `messageUtils.ts` now commits active tool groups before handling subsequent text, preserving post-tool assistant summaries.
+  3. Additional SDK tool-name mappings were added (`execute_command`, `write_to_file`, `search_files`, etc.) to improve ChatView tool rendering compatibility.
+- **Verification**: Run prompt paths that trigger multi-file reads and then assistant summary text; verify all files are listed and assistant text remains visible.
+
+### S6-41: Command output shows raw JSON instead of formatted shell output
+- **Status**: 🟢 Verified Fixed
+- **Description**: Command output in the chat showed raw JSON like `[{"query":"ls","result":"file1\nfile2","success":true}]` instead of the classic extension's formatted shell output with code blocks and scrollable content. The classic format shows the command in a shell code block followed by the output in another shell code block, separated by "Output:".
+- **Root cause**: Two issues:
+  1. In `src/sdk/message-translator.ts`, the command content_end handler (line ~630) received `event.output` as a `ToolOperationResult[]` (the SDK's structured output format: `[{query, result, success, error?}]`). When `event.output` was not a string, the code fell through to `JSON.stringify(event.output)`, producing the raw JSON array in the chat.
+  2. The webview's `CommandOutputRow.tsx` checks `isBackgroundExec` (from `vscodeTerminalExecutionMode === "backgroundExec"`) for proper rendering with cancel buttons, status indicators, etc. The SDK always uses background execution (bash executor spawns child processes directly), but the default `vscodeTerminalExecutionMode` from globalState was `"vscodeTerminal"`, causing the webview to render commands with the wrong UI mode.
+- **Fix applied**:
+  1. Added `extractToolOutputText()` helper in `src/sdk/message-translator.ts` that extracts raw text from the SDK's structured `ToolOperationResult[]` format. For each result: if `result.result` is a non-empty string, use it; if `result.error` is a non-empty string, use it. Join multiple results with newlines. Falls back to `JSON.stringify` only for truly unknown formats.
+  2. Updated the command content_end handler to use `extractToolOutputText(event.output)` instead of the old ternary with `JSON.stringify`.
+  3. Overrode `vscodeTerminalExecutionMode` to `"backgroundExec"` in `SdkController.getStateToPostToWebview()` so the webview's `CommandOutputRow` renders with the correct background-exec UI.
+- **Verification**: 15 new unit tests pass in `src/sdk/message-translator.test.ts`:
+  - `extractToolOutputText` tests: null/undefined, string passthrough, single ToolOperationResult, multiple results, error results, mixed success/error, plain string arrays, unknown object fallback, empty array, empty-result skipping.
+  - `command content_end output formatting` tests: ToolOperationResult[] produces raw text (not JSON), string output passes through, error output formatted correctly.
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 50 tests pass (35 existing + 15 new). Zero new TypeScript compilation errors.
+
+- **Evidence**: Commits `bc3590534` and `26614a007`, plus added tests in `src/sdk/message-translator.test.ts` and `webview-ui/src/components/chat/chat-view/utils/messageUtils.test.ts`.
+
+
+### S6-38: Cline doesn't know the user's working directory (process.cwd() fallback)
+- **Status**: 🟢 Verified Fixed
+- **Description**: The SdkController used `process.cwd()` as the working directory in 4 places (in `initTask()`, `reinitExistingTaskFromId()`, `resumeSessionFromTask()`, `restartSessionForMcpTools()`). In VSCode, `process.cwd()` returns the extension host's directory (e.g., `/Applications/Visual Studio Code.app/...`), not the user's workspace. This meant Cline couldn't find files in the user's project without being told the path explicitly. Related to S4-3 which was marked minor but is actually a blocker.
+- **Root cause**: The shared `ClineExtensionContext` type doesn't have a `workspaceRoot` property. The SdkController had no way to resolve the user's workspace root and fell back to `process.cwd()`.
+- **Fix applied**:
+  1. Added `SdkController.getWorkspaceRoot()` private async method that resolves the workspace root via `HostProvider.workspace.getWorkspacePaths()` — which delegates to `vscode.workspace.workspaceFolders[0].uri.fsPath` in VSCode. Falls back to `process.cwd()` only when no workspace folder is open.
+  2. Replaced all 4 `process.cwd()` calls in `SdkController.ts` with `await this.getWorkspaceRoot()`.
+  3. Added a defensive warning log in `buildSessionConfig()` (`cline-session-factory.ts`) for the `process.cwd()` fallback path, so it's immediately obvious if the workspace root is ever missing.
+- **Files changed**:
+  - `src/sdk/SdkController.ts` — Added `getWorkspaceRoot()`, replaced 4 call sites
+  - `src/sdk/cline-session-factory.ts` — Added warning log for missing cwd fallback
+- **Verification**: TypeScript compiles with 0 new errors (5 pre-existing SDK type errors). `grep -n 'process.cwd()' src/sdk/SdkController.ts` shows only the fallback in `getWorkspaceRoot()`. The `HostProvider.workspace.getWorkspacePaths()` API is the same one used in `common.ts:131` (`checkWorktreeAutoOpen`) and is known to work correctly.
+- **Evidence**: Code diff shows 34 insertions, 5 deletions across 2 files. All direct `process.cwd()` usages replaced with host-aware workspace resolution.
+
+### S6-45: React warns about `isActive` prop forwarded to DOM element
+- **Status**: 🟢 Verified Fixed
+- **Description**: React console warning: "React does not recognize the `isActive` prop on a DOM element." The `StyledTabButton` in `ClineRulesToggleModal.tsx` passed `isActive` as a styled-components prop, which was forwarded to the underlying `<button>` DOM element.
+- **Root cause**: styled-components forwards all props to the DOM unless filtered. The `isActive` prop was used only for CSS interpolation but leaked to the DOM.
+- **Fix applied**: Renamed `isActive` to `$isActive` (styled-components transient prop prefix) in the `StyledTabButton` type, CSS interpolations, and JSX usage. The dollar-sign prefix tells styled-components to consume the prop for styling without forwarding it to the DOM. The public `TabButton` component API is unchanged.
+- **Verification**: Open the Cline Rules modal — no React console warning about `isActive` on a DOM element.
+- **Evidence**: TypeScript compiles cleanly. The `McpConfigurationView.tsx` version of `StyledTabButton` already used `shouldForwardProp` to filter `isActive` — this fix aligns the `ClineRulesToggleModal.tsx` version using the more idiomatic transient prop approach.
+
+### S6-44: RangeError: Invalid string length when starting a new task
+- **Status**: 🟢 Verified Fixed
+- **Description**: Starting a new task could produce `RangeError: Invalid string length` in the console, crashing the task. The error occurred in the SDK's `file-indexer.ts` at the `stdout += chunk.toString()` line inside `listFilesWithRg()`. The function spawns `rg --files --hidden -g '!.git'` and accumulates ALL stdout into a single string. Two bugs combined to cause this:
+  1. **Missing directory exclusions in `rg`**: The `rg` command only excluded `.git`, but the fallback `walkDir` function excluded 10 directories (`node_modules`, `dist`, `build`, `.next`, `coverage`, `.turbo`, `.cache`, `target`, `out`). This inconsistency meant `rg` listed vastly more files — including all of `node_modules` — producing output that could approach or exceed Node.js's max string length (~512MB).
+  2. **Wrong workspace path**: `SdkController` used `process.cwd()` instead of the VSCode workspace root. In the VSCode extension host, `process.cwd()` can return the VSCode installation directory or `/`, causing `rg` to recurse enormous directory trees.
+- **Root cause**: SDK `file-indexer.ts` had no buffer size limit and inconsistent directory exclusions between `rg` and `walkDir` codepaths. Extension used `process.cwd()` instead of `getCwd()` (which resolves the actual workspace folder via `HostProvider.workspace.getWorkspacePaths()`).
+- **Fix applied**:
+  1. **SDK `file-indexer.ts`** (`@clinebot/core/src/services/workspace/file-indexer.ts`):
+     - Added `MAX_RG_STDOUT_BYTES = 64MB` safety limit — kills `rg` and falls back to `walkDir` if output exceeds the limit.
+     - Added `rgExcludeArgs` that generates `-g '!dir'` flags for every entry in `DEFAULT_EXCLUDE_DIRS`, making `rg` and `walkDir` exclude the same directories.
+  2. **`SdkController.ts`**: Replaced all 4 `process.cwd()` calls with `await getCwd()` (which uses `HostProvider.workspace.getWorkspacePaths()`).
+  3. **`cline-session-factory.ts`**: Replaced `process.cwd()` fallback with `await getCwd()`.
+- **Verification**:
+  - SDK tests pass: 5 file-indexer tests + 4 mention-enricher tests (9/9).
+  - Extension SDK adapter tests pass: 112/112.
+  - TypeScript compiles with 0 new errors (5 pre-existing).
+  - Extension builds successfully with fixes in the bundle.
+- **Evidence**: Fix verified via `npx vitest run` (SDK workspace tests) and `npx tsc --noEmit` (extension).
+
+### S6-46: Unhandled AbortError thrown when cancelling a running task
+- **Status**: 🔵 Awaiting Verification
+- **Description**: When the user cancels a running task, an unhandled `AbortError: This operation was aborted` appears in the VSCode developer console. The error propagates from `ClineCore.abort()` → `DefaultSessionManager.abort()` → `VscodeSessionHost.abort()` → `SdkController.cancelTask()` → gRPC handler → extension host. Additionally, the fire-and-forget `send()` promise rejects with `AbortError` when the abort signal fires, which was being logged as `Logger.error` and emitting an error event to the UI.
+- **Root cause**: Three compounding issues:
+  1. `VscodeSessionHost.abort()` directly proxied `this.inner.abort()` with no error handling. The SDK's `ClineCore.abort()` calls `AbortController.abort()` which can throw synchronously.
+  2. `SdkController.cancelTask()` had a try/catch but logged all errors at `Logger.error` level, including `AbortError` which is expected behavior.
+  3. `SdkController.fireAndForgetSend()` `.catch()` handler treated all errors equally — logging at error level and emitting error events to the UI, even for `AbortError` which should be silently absorbed since `cancelTask()` handles the UI state.
+- **Fix applied**:
+  1. **`src/sdk/vscode-session-host.ts`**: Wrapped `this.inner.abort()` in try/catch that suppresses `AbortError` (checks `error.name === "AbortError"` or `error.message` containing "aborted") and re-throws other errors. Logs at `Logger.debug` level.
+  2. **`src/sdk/SdkController.ts`**: Added `isAbortError()` helper function. Restructured `cancelTask()` to: (a) wrap `sessionManager.abort()` in its own try/catch that suppresses `AbortError` at debug level, (b) always proceed with cancellation cleanup regardless of abort error, (c) emit `ask: "resume_task"` instead of `say: "info"` to fix S6-34 simultaneously.
+  3. **`src/sdk/SdkController.ts`**: Updated `fireAndForgetSend()` `.catch()` to check `isAbortError()` first — if true, log at debug level and return early without emitting error events to the UI.
+- **Verification**: Debug harness test: (1) Start a task with long generation. (2) Cancel during streaming. (3) Verify no `AbortError` in the developer console. (4) Verify the "Resume task" button appears. (5) Send a follow-up message and verify it works.
+- **Evidence**: TypeScript compiles with 0 errors (`npx tsc --noEmit`). All 126 SDK adapter tests pass (`npx vitest run --config vitest.config.sdk.ts`).
+
+### S6-39: 'Cline Fetched Content from this URL' tool call appears blank (no URL)
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the agent uses `fetch_web_content`, the tool call in the chat showed "Cline fetched content from this URL:" but the URL was blank — no URL was rendered in the display area.
+- **Root cause**: The SDK's `fetch_web_content` tool uses `{ requests: [{ url, prompt }] }` as its input format (array of request objects), but `sdkToolToClineSayTool()` in `src/sdk/message-translator.ts` only checked for a top-level `url` field via `getStringField(parsedInput, "url")`. Since the URL is nested inside `requests[0].url`, the extraction returned `""`, leaving `tool.path` empty and the webview rendering blank.
+- **Fix applied**: Updated the `fetch_web_content`/`web_fetch` case in `sdkToolToClineSayTool()` to also extract the URL from `parsedInput.requests[0].url` when the top-level `url` field is missing. This handles both the SDK format (`{ requests: [{ url, prompt }] }`) and the classic format (`{ url, prompt }`).
+- **Verification**: 7 new unit tests in `src/sdk/message-translator.test.ts` — S6-39 tests cover: SDK requests array URL extraction, content_end preserving URL from content_start, classic web_fetch backward compat, multiple requests extracting first URL. All 57 tests pass.
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 57 tests pass. `npx tsc --noEmit` — 0 errors.
+
+### S6-47: Tool architecture audit — dead code, missing tools, and disconnected handlers
+
+- **Status**: 🔴 Blocker (attempt_completion command); 🟡 Minor (others)
+- **Description**: Comprehensive audit of tool wiring on the SDK branch. The SDK provides its own built-in tools internally; the VSCode extension adds "extra tools" via `src/sdk/vscode-runtime-builder.ts` (currently: `attempt_completion` + MCP tools from McpHub). The classic `ToolExecutorCoordinator` and all its handlers (`src/core/task/tools/handlers/*.ts`) are **dead code** — the SDK handles tool execution internally, and the coordinator is never instantiated on the SDK path.
+
+#### Where does the agent get tool descriptions?
+
+On the SDK branch, tool descriptions come from **two sources**:
+1. **SDK built-in tools** — defined inside `@clinebot/core`. The SDK provides: `read_files`/`read_file`, `list_files`, `list_code_definition_names`, `editor`/`replace_in_file`, `write_to_file`, `apply_patch`, `delete_file`, `run_commands`/`execute_command`, `search_codebase`/`search_files`, `fetch_web_content`/`web_fetch`, `web_search`, `skills`/`use_skill`, `ask_question`/`ask_followup_question`.
+2. **VSCode extra tools** — defined in `src/sdk/vscode-runtime-builder.ts::createVscodeExtraTools()`, injected via `VscodeSessionHost.create()` → `applyToStartSessionInput()` → `config.extraTools`. Currently: `attempt_completion` + MCP tools bridged from McpHub.
+
+The classic system prompt tool definitions (`src/core/prompts/system-prompt/tools/*.ts`) and variant templates are **NOT used** for tool descriptions on the SDK branch — the SDK constructs its own system prompt with its own tool definitions. The classic tool specs are only used by the classic Task path (subagents, legacy code).
+
+#### Issue 1: `attempt_completion` `command` parameter is dead code
+
+- **Severity**: 🔴 Blocker
+- **Tool definition** (`src/sdk/vscode-runtime-builder.ts:44-71`): Defines `command` as an optional string parameter: _"An optional terminal command to showcase the result (e.g. open a dev server)."_
+- **Execute function** (line 66-68): `return typeof parsedInput.result === "string" ? parsedInput.result : "Task completed."` — **ignores `command` entirely**.
+- **Message translator** (`src/sdk/message-translator.ts:513-524, 603-629`): When handling `attempt_completion`, only extracts `result` via `getStringField(parsedInput, "result")` — **never reads `command`**.
+- **Classic handler** (`src/core/task/tools/handlers/AttemptCompletionHandler.ts:192`): Would execute the command via `config.callbacks.executeCommandTool(command!, undefined)`, but this handler is **dead code** — the `ToolExecutorCoordinator` is never instantiated on the SDK path.
+- **Impact**: The agent is told it can provide a `command` parameter, wastes tokens generating it, but the command is silently discarded. Example: agent says `command: "open localhost:3000"` but nothing happens.
+- **Fix needed**: Either (a) implement command execution in the SDK extra tool's `execute` function (spawn the command via the standalone terminal manager or similar), or (b) remove the `command` parameter from the tool schema if the feature is intentionally dropped.
+
+#### Issue 2: Classic `ToolExecutorCoordinator` and all handlers are dead code
+
+- **Severity**: 🟡 Minor (informational — no user-facing bug, just dead code)
+- **Files**: `src/core/task/tools/ToolExecutorCoordinator.ts`, `src/core/task/tools/handlers/*.ts` (28 handler files)
+- **Description**: The entire classic tool execution pipeline (`ToolExecutorCoordinator` → handler → Task callbacks) is unreachable on the SDK branch. The SDK handles tool execution internally via its runtime. These files exist only for: (a) subagent support via `SubagentRunner` which still uses the classic `Task` class, (b) reference/comparison.
+- **Impact**: No runtime bug, but the dead code creates confusion about which code path is active.
+
+#### Issue 3: Tools present in classic but absent from SDK
+
+The following classic tools have no equivalent in the SDK's built-in tool set or extra tools. Some omissions are intentional (SDK handles them differently or they're internal-only); others may be gaps:
+
+| Classic Tool | Classic Handler | SDK Status | Notes |
+|---|---|---|---|
+| `browser_action` | `BrowserToolHandler` | ❌ Missing | SDK has no browser automation tool. Agent cannot interact with websites. **Likely a gap.** |
+| `plan_mode_respond` | `PlanModeRespondHandler` | ❓ Unknown | SDK may handle plan/act modes differently (via session config or agent instructions rather than a tool). Need to verify. |
+| `act_mode_respond` | `ActModeRespondHandler` | ❓ Unknown | Same as above. |
+| `new_task` | `NewTaskHandler` | ❌ Missing | Subagent orchestration tool. SDK may use its own multi-agent mechanism. |
+| `use_subagents` | `UseSubagentsToolHandler` | ❌ Missing | Same as above. |
+| `condense` | `CondenseHandler` | ❓ Unknown | Internal context-management tool. SDK may handle context truncation internally. |
+| `summarize_task` | `SummarizeTaskHandler` | ❓ Unknown | Internal tool for task summarization. SDK may handle this differently. |
+| `generate_explanation` | `GenerateExplanationToolHandler` | ❌ Missing | UI feature for explaining changes. Would need to be an extra tool. |
+| `report_bug` | `ReportBugHandler` | ❌ Missing | Slash-command tool. Low priority. |
+| `new_rule` | `WriteToFileToolHandler` (shared) | ❌ Missing | Slash-command tool for creating .clinerules files. Low priority — the SDK's `write_to_file` can serve the same purpose. |
+| `load_mcp_documentation` | `LoadMcpDocumentationHandler` | ❌ Missing | Loads MCP server creation docs. Low priority. |
+| `access_mcp_resource` | `AccessMcpResourceHandler` | ❌ Missing | Accesses MCP server resources (not tools). The McpHub bridge only provides MCP tools, not resources. **Possible gap.** |
+| `focus_chain` (TODO) | `undefined` (no handler) | ✅ N/A | Metadata-only parameter, no execution needed. |
+
+#### Issue 4: SDK has tools NOT in classic
+
+| SDK Tool | Classic Equivalent | Notes |
+|---|---|---|
+| `delete_file` | None | SDK provides file deletion. Classic extension didn't have an explicit delete tool. |
+
+- **Root cause**: The SDK migration replaced the classic Task → ToolExecutorCoordinator → Handler pipeline with the SDK's internal tool execution. Extra tools are only `attempt_completion` + MCP tools. All other tools come from the SDK's built-in set, which doesn't include all classic tools.
+
+- **Priority**:
+  1. **Fix `attempt_completion` `command`** — the agent wastes tokens on a dead parameter
+  2. **Audit `browser_action` and `access_mcp_resource`** — these may be user-visible gaps
+  3. **Verify plan/act mode** — confirm the SDK handles this correctly without explicit tools
+  4. **Low priority**: `report_bug`, `new_rule`, `load_mcp_documentation`, `generate_explanation` — these are convenience tools, not core functionality
+
+### S6-40: 'Cline Loaded the skill' tool call appears blank (no skill name)
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the agent uses the `skills` tool, the tool call in the chat showed "Cline loaded the skill:" but the skill name was blank — no name was rendered.
+- **Root cause**: The SDK's `skills` tool uses `{ skill: "name", args?: "..." }` as its input format, but `sdkToolToClineSayTool()` only checked for `skill_name` and `name` fields. The SDK's field is just `skill`, so the extraction returned `""`, leaving `tool.path` empty.
+- **Fix applied**: Added `getStringField(parsedInput, "skill")` to the fallback chain in the `skills`/`use_skill` case, between `skill_name` (classic) and `name` (generic fallback). This handles all three input formats.
+- **Verification**: 3 new unit tests in `src/sdk/message-translator.test.ts` — S6-40 tests cover: SDK `skill` field extraction, content_end preserving skill name, classic `skill_name` backward compat. All 57 tests pass.
+
+### S6-47: Search tool group summary shows empty regex and "/" path
+- **Status**: 🟢 Verified Fixed
+- **Description**: When the SDK's `search_codebase` tool runs, the tool group summary shows `Cline read 3 files, performed 1 search: "" in /` — the search regex is empty and the path is just `/` instead of a meaningful location.
+- **Root cause**: Two issues:
+  1. **Empty regex**: The SDK's `SearchCodebaseUnionInputSchema` accepts multiple input formats: `{ queries: string[] }`, `string[]` (bare array), or `string` (bare string). The `parseToolInput()` function in message-translator.ts only handles objects and stringified JSON objects — it returns `undefined` for bare arrays and non-JSON strings. When `parsedInput` is `undefined`, all `getArrayField`/`getStringField` lookups fail, producing `regex = ""`.
+  2. **"/" path**: The SDK's `search_codebase` tool has no `path` parameter in its schema (it uses `config.cwd` internally). So `getStringField(parsedInput, "path")` always returns `undefined`. The webview's `ToolGroupRenderer` constructs `folderPath = (tool.path || "") + "/"` = `"/"`, and `formatSearchDisplay` shows `"" in /`.
+- **Fix applied**: Three files changed:
+  1. **`src/sdk/message-translator.ts`** (lines 275-293): Restructured the `search_codebase` case to handle all SDK union schema input formats. When `parsedInput` is an object, extracts queries normally. Falls back to checking `Array.isArray(input)` for bare arrays, then `typeof input === "string"` for bare strings.
+  2. **`webview-ui/src/components/chat/chat-view/components/messages/ToolGroupRenderer.tsx`**: Three changes:
+     - `formatSearchDisplay()`: When path is empty, shows "codebase" instead of `/`.
+     - `getToolDisplayInfo()` searchFiles case: Sets `path` to `""` (not `"/"`) when `filePath` is empty.
+     - `getActivityText()` searchFiles case: Removed `&& tool.path` requirement, and inner `formatSearchRegex()` shows "codebase" when path is empty.
+  3. **`webview-ui/src/components/chat/RequestStartRow.tsx`**: Same fixes as ToolGroupRenderer — `formatSearchRegex()` shows "codebase" for empty path, `getActivityText()` doesn't require `tool.path` for search.
+- **Verification**: 8 new unit tests in `src/sdk/message-translator.test.ts` cover all input formats:
+  - `{ queries: ["TODO", "FIXME"] }` → `regex: "TODO, FIXME"` ✅
+  - `JSON.stringify({ queries: ["TODO"] })` → `regex: "TODO"` ✅
+  - `["TODO", "FIXME"]` (bare array) → `regex: "TODO, FIXME"` ✅
+  - `"TODO"` (bare string) → `regex: "TODO"` ✅
+  - `{ queries: "TODO" }` (string, not array) → `regex: "TODO"` ✅
+  - content_end preserves queries from content_start ✅
+  - content_end preserves bare array input ✅
+  - path is undefined when SDK has no path param ✅
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts -- message-translator` — 65 tests pass (8 new). `npx tsc --noEmit` — 0 errors in changed files.
+
+
+
+### S6-48: File edit diffs show all green (no red deletions)
+- **Status**: 🟢 Verified Fixed
+- **Description**: When Cline edits an existing file, the diff shown in the chatview only showed green (additions) and never red (deletions). The entire file content appeared as additions, making it impossible to see what was actually changed.
+- **Root cause**: Three compounding issues in the SDK message translation pipeline:
+  1. **Editor tool**: The SDK's `editor` tool provides `old_text` and `new_text` fields. The message translator stored `new_text` into `content` and the `patch`/`diff` field into `diff`. But `ChatRow.tsx` passes `tool.content` to `DiffEditRow`'s `patch` prop. Since `content` was raw `new_text` (not a diff format), `DiffEditRow.parsePatch()` didn't recognize any known diff format and fell through to the fallback (lines 303-317) which treated the entire text as a new file, prefixing every line with `+ ` (green additions only).
+  2. **apply_patch tool**: The SDK sends `apply_patch` input as `{ input: '...' }`, but the translator only checked the `patch` field (not `input`). Also, the translator set `diff` but not `content`, so `ChatRow.tsx`'s condition `tool.content` was falsy, causing it to fall through to `CodeAccordian` instead of `DiffEditRow`.
+  3. **ChatRow.tsx**: The condition and prop used only `tool.content`, ignoring `tool.diff` even when it contained a valid patch.
+- **Fix applied**: Three files changed:
+  1. **`src/sdk/message-translator.ts`** — `editor`/`replace_in_file` case: When both `old_text` and `new_text` are provided, construct a search/replace diff in the format DiffEditRow expects (`------- SEARCH\n<old>\n=======\n<new>\n+++++++ REPLACE`) and store it in `content`. When only `new_text` is provided (new file), keep raw text as before.
+  2. **`src/sdk/message-translator.ts`** — `apply_patch` case: Also check the `input` field (SDK format) in addition to `patch` and `diff`. Populate both `content` and `diff` with the patch so `ChatRow.tsx` can render it.
+  3. **`webview-ui/src/components/chat/ChatRow.tsx`** — Changed condition from `tool.content` to `(tool.diff || tool.content)` and prop from `patch={tool.content}` to `patch={tool.diff || tool.content!}`, so `DiffEditRow` receives whichever field contains the diff.
+- **Verification**: 7 new unit tests in `src/sdk/message-translator.test.ts`:
+  - Editor with `old_text` + `new_text` → content is search/replace diff ✅
+  - Editor with only `new_text` → content is raw new_text (newFileCreated) ✅
+  - Editor with `old_str`/`new_str` variant → search/replace diff ✅
+  - Multiline old/new text preserved in diff ✅
+  - apply_patch with SDK `{ input: '...' }` → content and diff populated ✅
+  - apply_patch with classic `{ patch: '...' }` → content and diff populated ✅
+  - apply_patch prefers `patch` over `input` field ✅
+  - Updated existing S6-24 test to expect diff format when old_text+new_text present ✅
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 72 tests pass (7 new). `npx tsc --noEmit --skipLibCheck` — 0 errors.
+
+
+### S6-49: Plan/Act toggle returns misleading boolean (cleared pending input)
+- **Status**: 🔵 Awaiting Verification
+- **Description**: `togglePlanActMode()` in `SdkController.ts` returned `true`
+  on every successful mode flip. The webview's `onModeToggle` handler
+  in `ChatTextArea.tsx` treats the returned boolean as "did I consume
+  your pending input", and calls `setInputValue("")` when it's true.
+  The SDK flow rebuilds the session without consuming the user's pending
+  chat text, so returning `true` incorrectly wiped any text the user
+  had typed before toggling.
+- **Root cause**: The classic `togglePlanActMode()` only returned
+  `true` when it actually consumed `chatContent` as a plan-mode
+  response (`taskState.isAwaitingPlanResponse && didSwitchToActMode`).
+  The SDK `rebuildSessionForMode()` flow never consumes the chat
+  content — it just swaps the mode, system prompt and tools — so the
+  return value should be `false` to match classic UX (input stays
+  in the textbox after toggle).
+- **Fix applied**: `src/sdk/SdkController.ts` — `togglePlanActMode()`
+  now returns `false` in both branches (active session → rebuild, no
+  active session → persist mode). The same-mode no-op branch continues
+  to return `false`.
+- **Verification**: 7 new unit tests in `src/sdk/toggle-plan-act-mode.test.ts`:
+  - PLAN/ACT enum decode → passes correct mode string to controller ✅
+  - `chatContent` passed through verbatim ✅
+  - Return value reflects controller's boolean (both true and false cases) ✅
+  - Invalid `PlanActMode` enum throws ✅
+  - Errors from controller propagate ✅
+  Mode toggle preserves clineMessages because `rebuildSessionForMode`
+  keeps `this.task` (and its `messageStateHandler`) alive across the
+  session rebuild, and `getStateToPostToWebview()` reads `mode` from
+  `stateManager.getGlobalSettingsKey("mode")` which is updated before
+  the state push.
+- **Evidence**: `npx vitest run -c vitest.config.sdk.ts src/sdk/toggle-plan-act-mode.test.ts` — 7 tests pass. `npx tsc --noEmit` — 0 errors. Manual debug-harness verification pending.
+
+- **Evidence**: `npx vitest run --config vitest.config.sdk.ts src/sdk/message-translator.test.ts` — 57 tests pass. `npx tsc --noEmit` — 0 errors.

sdk-migration/README.md

@@ -0,0 +1,554 @@
+# SDK Migration — Entry Point
+
+You are working on migrating the Cline VSCode extension from its
+classic core to the Cline SDK (`@clinebot/core`). This document is
+your primary reference. Read it in full before starting any step.
+
+## Document Map
+
+| Document | Purpose | When to Read |
+|----------|---------|--------------|
+| **This file** | Entry point, plan, operational procedure | Always, first |
+| [ARCHITECTURE.md](ARCHITECTURE.md) | Features, design decisions, SDK capabilities | Before Step 1; refer back as needed |
+| [SDK-REFERENCE/OAUTH.md](SDK-REFERENCE/OAUTH.md) | How the SDK handles OAuth and credentials | When working on auth (Steps 4, 5) |
+| [SDK-REFERENCE/MCP.md](SDK-REFERENCE/MCP.md) | How the SDK handles MCP server management | When working on MCP (Step 5) |
+| [PROBLEMS.md](PROBLEMS.md) | Known issues, verification status | Before each verification gate |
+| [../src/dev/debug-harness/README.md](../src/dev/debug-harness/README.md) | Debug harness API reference | When using the debug harness |
+
+Docs from previous attempts that are **not** carried forward:
+- CAVEATS.md, FIXED.md, FEATURE-REMOVAL-CLEANUP-PLAN.md,
+  DEBUG-HARNESS.md (root level), FEEDBACK.md — these degraded badly.
+  Lessons are incorporated into this plan.
+
+## References
+
+### Code Repositories
+
+| Repo | Path | kb_search name |
+|------|------|----------------|
+| Cline (this repo) | `~/clients/cline/cline` | `cline` |
+| Cline SDK | `~/clients/cline/sdk-wip` | `sdk` |
+| JetBrains Plugin | `~/clients/cline/intellij-plugin` | `plugin` |
+| VSCode | `~/clients/cline/vscode` | `vscode` |
+
+### How to Research the SDK
+
+**Always use `kb_search` with the `sdk` repo** when you need to
+understand how the SDK supports a feature. Do not guess at APIs,
+URLs, or data formats. The SDK is the source of truth.
+
+Example: Before implementing OAuth, search:
+```
+kb_search(name="sdk", query="OAuth login flow callback")
+```
+
+You can also compare before/after states using commit-based search:
+```
+kb_search(name="cline", query="accountLoginClicked", commit="origin/main")
+kb_search(name="cline", query="accountLoginClicked", commit="HEAD")
+```
+
+---
+
+## Core Principles
+
+These principles are derived from hard-won experience on two previous
+attempts. Violating them leads to broken products and wasted time.
+
+### 1. Thunk, Don't Replace
+
+The webview speaks gRPC-over-postMessage today. We will **not**
+replace that with a new message protocol in this migration. Instead,
+we build a **thunking layer** that sits between the SDK and the
+existing gRPC interface. The webview continues to send gRPC-shaped
+messages; the thunking layer translates between those and SDK calls.
+
+This means:
+- The webview code is largely untouched
+- gRPC proto files stay in place until the final cleanup step
+- Each SDK feature is wired up by implementing its gRPC handler
+
+### 2. Verify Before You Proceed
+
+Every step has a **verification gate**. You must demonstrate the
+feature works before moving on. Verification means:
+- Unit tests that test real behavior, not just that functions exist
+- Debug harness smoke tests for UI-facing features
+- Manual confirmation when automated tests can't cover it
+
+Mark things as **"awaiting verification"** not "fixed". Only mark
+"verified" after you have evidence (test output, screenshot, etc.).
+
+### 3. Delete and Document
+
+When replacing a classic module with its SDK equivalent, **delete the
+classic code immediately** and document where to find it. Dead code
+in the tree creates confusion about what is active vs. vestigial.
+
+The classic implementation is always accessible via:
+- `kb_search(name="cline", query="...", commit="origin/main")` —
+  search the classic codebase at the pre-migration commit
+- `git show origin/main:path/to/file.ts` — view any file
+- `git diff origin/main..HEAD -- path/` — see what changed
+
+When deleting a module, add a comment in the replacement file:
+```
+// Replaces classic src/core/task/ (see origin/main)
+```
+
+This way there is never any ambiguity about what code is running.
+
+### 4. Use the Debug Harness
+
+The debug harness at `src/dev/debug-harness/` is your primary
+integration testing tool. Use it to:
+- Verify UI renders correctly after changes
+- Test user flows (login, chat, settings, history)
+- Catch regressions that unit tests miss
+
+**Always dismiss promotional overlays first.** There may be one or two:
+1. "Introducing Cline Kanban" overlay
+2. "New in v3.78.0" announcement overlay
+
+Both follow the same `sr-only` pattern and can be dismissed with:
+```
+curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+```
+You may need to run this twice if both overlays are present.
+
+Use VSCode command palette actions to navigate between tabs.
+
+### 5. SDK "Default" Implementations Are References, Not Products
+
+The SDK's `DefaultSessionBuilder`, `DefaultRuntimeBuilder`, etc. are
+designed for simple use cases. As an IDE, we need more:
+- Custom MCP manager (file watching, SSE/streamableHTTP support)
+- Custom session persistence (read existing task history format)
+- Custom tool approval (integrate with webview approval UI)
+
+Use the defaults as references, but implement what the product needs.
+
+### 6. Avoid `as` Casts and Type Confusion
+
+A recurring bug source was confusion between SDK types and gRPC/proto
+types. For example, SDK returns `accountId` but gRPC expects
+`workos:accountId`. Use explicit conversion functions with tests, and
+never use `as` to paper over type mismatches.
+
+---
+
+## Migration Steps
+
+This plan is ordered by dependency: each step builds on the previous.
+Do not skip steps. Each step ends with a verification gate.
+
+### Step 1: Foundation & Cutover
+
+**Goal:** SDK dependencies installed, test infrastructure ready,
+and the extension's entry point switched to the SDK adapter.
+There is one entry point, not two.
+
+Tasks:
+- Add `@clinebot/core`, `@clinebot/llms`, `@clinebot/shared`,
+  `@clinebot/agents` as dependencies (via `npm link` from local SDK)
+- Add `vitest.config.sdk.ts` for SDK adapter tests
+- Create `src/sdk/` directory with `index.ts` barrel export
+- Modify `src/extension.ts` to use the SDK adapter as its
+  activation path (replacing the classic `Controller` import)
+- Delete `src/core/controller/` — the classic controller is replaced
+  by `src/sdk/SdkController.ts` (to be implemented in Step 4).
+  Add comment: `// Replaces classic src/core/controller/ (see origin/main)`
+- Update `esbuild.mjs` if needed for the new import structure
+- Verify: `npm run compile` succeeds, extension loads in VSCode
+  (sidebar may show errors since handlers aren't implemented yet,
+  but the extension process itself starts)
+
+**Why one entry point:** Attempt 2 used `CLINE_SDK=1` to switch
+between two entry points. This caused constant confusion about which
+codepath was running. With a single entry point, there is never any
+doubt. The classic code is always accessible via `origin/main`.
+
+**Verification gate:** Extension compiles and loads. The SDK adapter
+is the only codepath. (It won't do much yet — that's Step 4.)
+
+### Step 2: Legacy State Reader
+
+**Goal:** Read all existing on-disk state from the SDK adapter layer.
+
+Tasks:
+- Implement `src/sdk/legacy-state-reader.ts`:
+  - Read `globalState.json` (provider settings, model selections,
+    dismissed banners, etc.)
+  - Read `secrets.json` (API keys, Cline auth tokens)
+  - Read `taskHistory.json` (task list for history view)
+  - Read per-task directories (`api_conversation_history.json`,
+    `ui_messages.json`)
+  - Read `cline_mcp_settings.json` (MCP server configs)
+- Write tests against fixture data (copy real `~/.cline/data/`
+  samples, redact secrets)
+- Verify: All reads produce correct typed results, error handling
+  for missing/corrupt files
+
+**Verification gate:** Unit tests pass; reader correctly parses
+real `~/.cline/data/` contents (spot-check manually).
+
+### Step 3: Provider Migration
+
+**Goal:** Existing provider credentials survive the transition.
+
+Tasks:
+- Implement `src/sdk/provider-migration.ts`:
+  - Use SDK's `migrateLegacyProviderSettings()` as reference
+  - Map classic `globalState.json` + `secrets.json` entries to
+    SDK `providers.json` format
+  - Never overwrite existing entries
+  - Tag migrated entries with `tokenSource: "migration"`
+  - Write a migration sentinel to prevent re-migration
+- Test with fixtures covering all 30+ providers
+- Verify: After migration, SDK can create handler for each provider;
+  existing API keys still work
+
+**Critical:** This is the highest-risk step. Getting it wrong means
+users get logged out. Test exhaustively.
+
+**Verification gate:** All provider credential tests pass. Manual
+test: set up providers in classic extension, switch to SDK branch,
+verify inference still works for Anthropic, OpenAI, OpenRouter,
+Ollama, and the Cline provider.
+
+### Step 4: Session Lifecycle (No UI Yet) — ✅ Completed
+
+**Goal:** Create and manage SDK sessions from the adapter layer.
+
+Tasks:
+- [x] Implement `src/sdk/cline-session-factory.ts`:
+  - Custom session persistence adapter reading `~/.cline/data/tasks/`
+  - Map `HistoryItem` ↔ session fields
+  - Implement `ClineCore.create()` with proper config
+  - Build `CoreSessionConfig` from legacy state via `ProviderSettingsManager`
+  - Build `StartSessionInput` and resume input helpers
+- [x] Implement `src/sdk/SdkController.ts`:
+  - `initTask(prompt)` — create session, start inference
+  - `askResponse(message)` — continue conversation (sends to existing session)
+  - `cancelTask()` — abort running session
+  - `clearTask()` — reset for new task
+  - `showTaskWithId(id)` — load task from history
+  - `reinitExistingTaskFromId(id)` — resume task from history
+  - Subscribe to SDK events, translate to internal message format
+  - Session event listener system for downstream consumers
+- [x] Implement `src/sdk/message-translator.ts`:
+  - SDK `CoreSessionEvent` → `ClineMessage[]` for webview consumption
+  - Handle all event types: chunk, agent_event (content_start/update/end,
+    done, error, notice, iteration_start/end, usage), ended, hook, status
+  - Streaming state tracking (partial message dedup)
+  - Tool text formatting helpers
+  - HistoryItem ↔ session field mapping
+- [x] Test all paths — 91 unit tests pass across 4 test files
+
+**Verification gate:** ✅ Unit tests pass (91/91). TypeScript compiles
+with 0 errors in `src/sdk/`. Session lifecycle methods work through
+the adapter layer without any UI. See PROBLEMS.md for known minor issues.
+
+### Step 5: gRPC Thunking Layer — ✅ Completed
+
+**Goal:** Wire SDK adapter to the existing webview via gRPC handlers.
+
+This is the **critical insight from attempt 2**: the webview speaks
+gRPC. We translate at the boundary. The webview stays untouched.
+
+Tasks:
+- [x] Implement `src/sdk/task-proxy.ts`:
+  - `TaskProxy` provides a classic Task-compatible interface that
+    delegates to SDK session methods
+  - `handleWebviewAskResponse()` → SdkController.askResponse()
+  - `abortTask()` → SdkController.cancelTask()
+  - `MessageStateHandler` extends EventEmitter for CLI compatibility
+  - `TaskProxyState` mirrors classic TaskState subset
+  - Stub properties for removed features (browser, checkpoints)
+- [x] Implement `src/sdk/webview-grpc-bridge.ts`:
+  - Bridges SDK session events to webview gRPC streams
+  - Translates ClineMessages to proto format via `convertClineMessageToProto()`
+  - Pushes through `sendPartialMessageEvent()` for streaming
+  - Pushes through `sendStateUpdate()` on significant events
+  - Error handling — never blocks the event stream
+- [x] Wire SdkController to use TaskProxy + WebviewGrpcBridge:
+  - Session events → message translation → gRPC bridge → webview
+  - `handleSessionEvent()` translates and emits to all listeners
+  - Messages accumulated in `messageStateHandler` for state building
+  - State updates pushed on turn complete / session ended
+- [x] Reuse existing `getStateToPostToWebview()` for state building
+  - Classic implementation reads from StateManager
+  - TaskProxy provides `messageStateHandler.getClineMessages()`
+  - Will be gradually replaced with SDK-sourced state in later steps
+
+**Verification gate:** ✅ 114 unit tests pass across 6 test files.
+TypeScript compiles with 0 new errors (3 pre-existing in unrelated
+files). The gRPC thunking layer is complete — session events flow
+from SDK through message translation to webview gRPC streams.
+See PROBLEMS.md for known minor issues.
+
+### Step 6: Auth & Account Flows — ✅ Implementation Complete, 🔵 Awaiting E2E Verification
+
+**Goal:** Full OAuth login/logout, credit display, org switching work.
+
+This was the **most broken area** in attempt 2. Be especially careful.
+
+Tasks:
+- [x] Implement Cline OAuth using SDK's `loginClineOAuth()`:
+  - SDK spawns local callback server and provides the auth URL
+  - Our code opens the browser via `openExternal()`
+  - SDK handles token exchange
+  - We persist tokens to `secrets.json` under `cline:clineAccountId`
+- [x] Implement `subscribeToAuthStatusUpdate` streaming:
+  - Read credentials from disk on subscription
+  - Push initial auth state immediately (prevents race condition)
+  - Cross-window sync via secrets change listener
+- [x] Implement `getUserCredits` / `getOrganizationCredits`:
+  - Fetch from Cline API using stored auth token via `ClineAccountService`
+  - Use `{apiBaseUrl}` not hardcoded `app.cline.bot`
+- [x] Implement `accountLogoutClicked`:
+  - Clear credentials from disk
+  - Push unauthenticated state to webview
+- [x] Implement `setUserOrganization`:
+  - Update active org via API call
+  - Refresh auth info after switching
+- [x] Implement OpenAI Codex OAuth via SDK's `loginOpenAICodex()`
+- [x] Implement OCA OAuth via SDK's `loginOcaOAuth()`
+- [x] Implement token refresh using SDK's `refreshClineToken()`
+- [x] Write unit tests — 20 tests in `src/sdk/auth-service.test.ts`
+
+**Key pitfalls from attempt 2 (all addressed):**
+- `workos:` prefix on account IDs — `getAuthToken()` always returns `workos:`-prefixed token
+- `{appBaseUrl}` vs hardcoded URLs — uses `ClineEnv.config().apiBaseUrl` and `appBaseUrl`
+- Race condition: webview subscribes to auth state before the
+  bridge pushes it — `subscribeToAuthStatusUpdate` pushes initial state immediately
+- Token field name mismatches between SDK and classic storage —
+  explicit conversion in `credentialsToAuthInfo()` (ms→seconds for expiresAt)
+
+**Files created/modified:**
+- `src/sdk/auth-service.ts` — SDK-backed AuthService (replaces `src/services/auth/AuthService.ts`)
+- `src/sdk/account-service.ts` — SDK-backed ClineAccountService (replaces `src/services/account/ClineAccountService.ts`)
+- `src/sdk/auth-service.test.ts` — 20 unit tests
+- `src/sdk/SdkController.ts` — Wired auth/account services in constructor
+- `src/sdk/index.ts` — Added barrel exports
+- `src/core/controller/account/accountLoginClicked.ts` — Import from `@/sdk/auth-service`
+- `src/core/controller/account/accountLogoutClicked.ts` — Delegates to SdkController
+- `src/core/controller/account/subscribeToAuthStatusUpdate.ts` — Import from `@/sdk/auth-service`
+- `src/core/controller/account/openAiCodexSignIn.ts` — Uses SDK-backed AuthService
+- `src/core/controller/account/openAiCodexSignOut.ts` — Uses SDK-backed AuthService
+- `src/extension.ts` — Import from `@/sdk/auth-service`
+
+**Verification gate:** 🔵 Unit tests pass (20/20). TypeScript compiles
+with 0 new errors. End-to-end verification with debug harness pending —
+need to test: login flow, profile display, credits, org switching, logout.
+
+### Step 7: MCP Integration — ✅ Classic McpHub Wired (SDK Manager Deferred)
+
+**Goal:** MCP servers load, tools appear in agent, server management
+UI works.
+
+Following the "Thunk, Don't Replace" principle, we wire the classic
+`McpHub` into the SdkController instead of building a custom SDK MCP
+manager. The classic McpHub already supports all three transports
+(stdio, SSE, streamableHTTP), file watching, and all gRPC handlers.
+The SDK's `InMemoryMcpManager` will replace it in Step 10 (Cleanup).
+
+Tasks:
+- [x] Wire classic `McpHub` into `SdkController.mcpHub`
+  - Same constructor args as classic Controller
+  - Existing gRPC handlers (`subscribeToMcpServers`, `restartMcpServer`,
+    `deleteMcpServer`, `toggleMcpServer`, etc.) work without modification
+  - They all delegate to `controller.mcpHub` which is now a real instance
+- [x] Update `SdkController.mcpHub` type from `any` to `McpHub`
+- [ ] Implement MCP marketplace (cache + refresh from API) — deferred
+- [ ] Replace classic McpHub with SDK's InMemoryMcpManager — deferred to Step 10
+
+**Reference:** See `SDK-REFERENCE/MCP.md` for how the SDK's MCP
+manager works and what gaps exist.
+
+**Verification gate:** 🔵 Classic McpHub wired in. Existing gRPC
+handlers should work. Full E2E verification pending debug harness
+test with real MCP servers configured.
+
+### Step 8: Settings & Features — ✅ Core Settings Working
+
+**Goal:** All settings UI works, feature toggles persist.
+
+Following the "Thunk, Don't Replace" principle, the existing
+`updateSettings` gRPC handler already works — it calls
+`controller.stateManager.setGlobalState()` which is available.
+We just needed to ensure TaskProxy properties don't crash it.
+
+Tasks:
+- [x] Wire all `updateSettings` keys to persist to `globalState.json`
+  — already works via StateManager
+- [x] TaskProxy.api is settable (updateSettings replaces it on model switch)
+- [x] TaskProxy.terminalManager safely no-ops (settings compatibility)
+- [x] Implement `togglePlanActMode()` — saves mode, cancels active task
+- [x] Implement `toggleActModeForYoloMode()` — switches to act mode
+- [ ] Implement `getAvailableTerminalProfiles` (simplified — only
+  background terminal) — deferred
+- [ ] Simplify terminal settings UI (remove IDE terminal options) — deferred
+- [ ] Remove workflows tab from Cline Rules modal — deferred
+- [ ] Remove focus chain / deep planning / memory bank UI remnants — deferred
+- [ ] Verify model picker works for all providers — needs E2E test
+- [ ] Verify Plan/Act mode toggle works with separate model configs — needs E2E test
+
+**Verification gate:** 🔵 Core settings work (updateSettings, mode toggle).
+Full E2E verification pending debug harness test with real credentials.
+UI cleanup items deferred to post-Step-9 polish.
+
+### Step 9: Full Integration Verification
+
+**Goal:** The SDK-backed extension is functionally equivalent to the
+classic extension for all core features.
+
+Tasks:
+- Write QA test scripts covering:
+  1. Fresh install flow (no saved state)
+  2. Upgrade flow (existing state from classic)
+  3. Login → inference → logout → login
+  4. Multiple providers (Cline, Anthropic, OpenAI, Ollama)
+  5. Task history: create, view, resume, delete, favorite
+  6. Settings: change model, change provider, toggle features
+  7. MCP: add server, use tool, remove server
+  8. Plan/Act mode switching
+  9. @ mentions and file attachments
+  10. Cancel task mid-execution, start new task
+- Run each test with the debug harness
+- Document any known issues in PROBLEMS.md with reproduction steps
+
+**Verification gate:** All QA scripts pass. Any failures are
+documented and triaged.
+
+### Step 10: Cleanup (Only After Step 9 Passes)
+
+**Goal:** Remove classic core code that is no longer used.
+
+**Do NOT start this step until Step 9 is fully verified.**
+
+Tasks:
+- Delete `src/core/task/` (replaced by `@clinebot/agents`)
+- Delete `src/core/controller/` (replaced by SDK adapter)
+- Delete `src/core/api/` (replaced by `@clinebot/llms`)
+- Delete `src/core/prompts/system-prompt/` (replaced by SDK prompts)
+- Delete `src/services/mcp/McpHub.ts` (replaced by SDK MCP)
+- Delete `src/standalone/` (not needed for VSCode)
+- Remove deprecated feature code (browser automation, shadow git,
+  memory bank, focus chain, deep planning, workflows)
+- Remove proto files for webview messages (keep proto for any
+  persisted state that still uses them)
+- Remove proto build steps from `package.json`
+- Remove `src/shared/proto-conversions/`, `src/generated/`
+- Clean up imports, fix TypeScript errors
+- Run full test suite
+
+**Verification gate:** Extension compiles and loads. All QA scripts
+from Step 9 still pass. `npm run compile` produces no errors.
+
+### Future Steps (Not In Scope)
+
+- Step 11: JetBrains sidecar (JSON-RPC over stdio)
+- Step 12: Enterprise features (remote config, SSO, team controls)
+- Step 13: Improved checkpoints (kanban-style git refs)
+- Step 14: MCP Marketplace improvements
+- Step 15: Remove gRPC thunking layer, switch webview to typed
+  JSON messages (optional — only if the thunking layer is a
+  maintenance burden)
+
+---
+
+## Operational Procedure
+
+### How to Work on a Step
+
+1. **Read the step description** in full
+2. **Check PROBLEMS.md** for any known issues in this area
+3. **Research the SDK** using `kb_search(name="sdk", query="...")`
+   before implementing anything
+4. **Implement** the minimum needed to make the step's verification
+   gate pass
+5. **Write tests** that verify real behavior
+6. **Verify** using the debug harness for UI-facing features
+7. **Update PROBLEMS.md** with any issues found, marked as
+   "awaiting verification"
+8. **Commit** with a descriptive message referencing the step number
+
+### How to Use the Debug Harness
+
+```bash
+# Build and launch
+npx tsx src/dev/debug-harness/server.ts --skip-build --auto-launch
+
+# Dismiss promotional overlays FIRST (may need to run twice)
+curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelectorAll(\".sr-only\").forEach(el => el.parentElement?.click())"}}'
+
+# Navigate using command palette, NOT by clicking tabs
+curl localhost:19229/api -d '{"method": "ui.command_palette", "params": {"command": "cline.accountLogin"}}'
+
+# Take screenshots (read the file, don't open it!)
+curl localhost:19229/api -d '{"method": "ui.screenshot"}'
+# Returns {"result": {"path": "/tmp/cline-debug/screenshot-0001.png"}}
+# Use read_file on that path to examine it
+```
+
+### How to Report Problems
+
+When you find a bug, add it to `PROBLEMS.md` with:
+- **ID**: Sequential number
+- **Status**: 🔴 Blocker / 🟡 Minor / 🟢 Verified Fixed
+- **Description**: What's wrong, where, how to reproduce
+- **Root cause**: If known
+- **Fix**: If attempted, with file references
+- **Verification**: How to verify it's fixed (test name, harness
+  command, etc.)
+
+**Never mark a problem 🟢 without evidence.** Write the test first,
+then mark it fixed.
+
+### How to Handle "SDK Doesn't Support X"
+
+If the SDK is missing a feature you need:
+1. Document the gap in PROBLEMS.md
+2. Search the SDK codebase (`kb_search name="sdk"`) for any
+   workaround or extension point
+3. If no workaround exists, implement a minimal version in the
+   adapter layer
+4. File an issue / PR to the SDK repo for the proper fix
+5. Use `npm link` for quick iteration on SDK changes
+
+---
+
+## What Changed From Previous Attempts
+
+### Attempt 1 (sdk-migration-port-check)
+
+Deleted ~138K lines of classic core before having a working
+replacement. Created stub webview components. Result: 595 TypeScript
+errors, non-functional extension.
+
+**Lesson:** Delete and document — but only as you replace, not
+before. The classic code is always accessible via `origin/main`.
+
+### Attempt 2 (sdk-migration-v2, 90 commits)
+
+Built an SDK adapter layer with tests. Got inference working.
+But documentation degraded, bugs were marked fixed without
+verification, auth flows were broken, gRPC "mode" vs SDK "mode"
+caused confusion, feature removals were incomplete, and the
+agent kept confusing SDK types with gRPC types. The dual entry
+point (`CLINE_SDK=1`) was a constant source of confusion.
+
+**Lessons applied in this plan:**
+- Single entry point — no `CLINE_SDK` flag, no dual codepaths
+- Delete and document — dead code creates confusion; use
+  `origin/main` and `kb_search` to reference the classic impl
+- Thunk at the gRPC boundary, don't create a "mode" system
+- Verify before proceeding, don't mark things fixed prematurely
+- Use kb_search to research the SDK, don't guess at APIs
+- Don't hardcode URLs, use `{appBaseUrl}`
+- SDK "Default" implementations are references, not products
+- Keep docs focused and reliable; use PROBLEMS.md for tracking
+</task_progress>
+</write_to_file>

sdk-migration/SDK-CONTROLLER-REFACTOR.md

@@ -0,0 +1,375 @@
+# SDK Controller Refactor Plan
+
+This note captures the shared architecture direction for shrinking
+`src/sdk/SdkController.ts` without losing the classic controller surface.
+
+## Goal
+
+`Controller` should become a thin classic-compatible facade:
+
+- keep the exported `Controller` class and public method names stable
+- wire dependencies and delegate real behavior to focused services
+- preserve behavior during extraction-first PRs
+
+## Extraction Order
+
+1. `SdkMessageCoordinator`
+   - Owns listener registration/emission.
+   - Owns adding messages to the current task message state.
+   - Owns debounced and immediate `ui_messages.json` saves.
+   - Owns `finalizeMessagesForSave`.
+   - Owns hook-message append/save/push mechanics.
+   - Does not decide which workflow messages to create.
+
+2. `SdkSessionFactory` and `SdkSessionLifecycle`
+   - Factory owns `VscodeSessionHost.create`, tool policies, SDK callback
+     wiring, subscription, and session start.
+   - Lifecycle owns `activeSession`, send, abort, stop/dispose, running state,
+     and shared rebuild mechanics.
+
+3. `SdkInteractionCoordinator`
+   - Owns pending `ask_question` and tool-approval promises.
+   - Owns resolving and clearing those pending interactions from ask response,
+     cancel, clear, and rebuild flows.
+
+4. Shared session rebuild primitive plus separate coordinators
+   - `SdkModeCoordinator` handles mode-specific policy.
+   - `SdkMcpCoordinator` handles MCP reload/defer policy.
+   - Both share as much rebuild mechanics as possible.
+
+5. Controller-level session config builder
+   - Centralizes hooks, extensions, and mode-specific tools such as
+     `switch_to_act_mode`.
+   - Workflows should not need to remember extra config mutation steps after
+     calling raw `buildSessionConfig`.
+
+6. `SdkTaskHistory`
+   - Owns history lookup/update/delete, task usage updates, and
+     `getTaskWithId`.
+   - Full state-provider extraction can wait.
+
+## PR 1 Scope
+
+First PR is behavior-preserving and extracts only `SdkMessageCoordinator`.
+
+Success criteria:
+
+- `SdkController.ts` no longer owns the listener set, save debounce timer,
+  save methods, emit method, or `finalizeMessagesForSave`.
+- `Controller.onSessionEvent(...)` still exists and delegates.
+- Existing session event behavior is preserved.
+- Clear/show/mode rebuild still finalize messages the same way.
+- Hook messages still append, save, and push to the webview immediately.
+- No session lifecycle, MCP, mode, auth, or task-history redesign in this PR.
+
+## PR 2 Scope
+
+Second PR is behavior-preserving and extracts SDK session startup/running
+state mechanics.
+
+Implemented boundaries:
+
+- `SdkSessionFactory`
+  - Owns `VscodeSessionHost.create`.
+  - Wires SDK callbacks for tool approval, `ask_question`, and event
+    subscription.
+  - Starts sessions and returns the host/start result.
+- `SdkSessionLifecycle`
+  - Owns the current `ActiveSession`.
+  - Starts sessions through `SdkSessionFactory`.
+  - Tracks running/idle state.
+  - Owns fire-and-forget `send` completion/error handling mechanics.
+  - Delegates controller-specific policy through callbacks.
+- `sdk-tool-policies`
+  - Contains the pure auto-approval to SDK tool-policy mapper.
+  - Kept separate so the mapping can be tested without importing SDK host code.
+
+Still deferred:
+
+- Moving whole task workflows out of `Controller`.
+- Extracting pending ask/tool approval state into `SdkInteractionCoordinator`.
+- Consolidating mode/MCP rebuild policy.
+
+## PR 3 Scope
+
+Third PR is behavior-preserving and extracts pending SDK/user interaction
+state.
+
+Implemented boundary:
+
+- `SdkInteractionCoordinator`
+  - Owns the SDK `requestToolApproval` callback flow.
+  - Owns the SDK `ask_question` callback flow.
+  - Stores and resolves pending tool-approval promises.
+  - Stores and resolves pending ask-question promises.
+  - Emits the classic webview ask messages through `SdkMessageCoordinator`.
+  - Renders user feedback for ask-question responses.
+  - Clears/rejects pending interactions on mode change, task cancel, and task
+    clear.
+
+Still deferred:
+
+- Moving normal follow-up/resume behavior out of `Controller.askResponse`.
+
+## PR 9 Scope
+
+Ninth PR is behavior-preserving and extracts follow-up/resume behavior.
+
+Implemented boundary:
+
+- `SdkFollowupCoordinator`
+  - Owns `askResponse` workflow decisions after the public controller facade is
+    called.
+  - Resolves pending tool approvals and SDK `ask_question` prompts.
+  - Sends normal follow-up messages to active sessions.
+  - Queues follow-up messages when the active session is mid-turn.
+  - Resumes displayed or cancelled tasks by rebuilding a session with preserved
+    conversation history, then sends the user's follow-up or task-resumption
+    prompt.
+  - Handles resume-time auth and error message reporting.
+
+Controller changes:
+
+- `Controller.askResponse(...)` now delegates to `SdkFollowupCoordinator`.
+- `Controller` still supplies host concerns through callbacks: temporary host
+  creation, context mention resolution, auth checks, state posting, and
+  initial message loading.
+
+Still deferred:
+
+- Further splitting task lifecycle methods such as `initTask`, `clearTask`,
+  `cancelTask`, `showTaskWithId`, and task reinitialization.
+
+## PR 10 Scope
+
+Tenth PR is behavior-preserving and extracts task control/display behavior.
+
+Implemented boundary:
+
+- `SdkTaskControlCoordinator`
+  - Owns task cancellation and `resume_task` ask emission.
+  - Owns task clearing, active-session teardown, finalized message persistence,
+    pending interaction cleanup, and task proxy clearing.
+  - Owns `showTaskWithId`, including silent active-session teardown, task proxy
+    creation, UI message loading/finalization, fresh resume ask insertion, and
+    partial-message pushes.
+
+Controller changes:
+
+- Public `cancelTask`, `clearTask`, and `showTaskWithId` methods remain on
+  `Controller`, but delegate to `SdkTaskControlCoordinator`.
+- `Controller` still supplies facade callbacks for ask responses, state
+  posting, task proxy access, and translator reset.
+
+Still deferred:
+
+- Moving task startup and reinitialization (`initTask`,
+  `reinitExistingTaskFromId`) out of `Controller`.
+- Moving whole task lifecycle workflows out of `Controller`.
+- Consolidating mode/MCP rebuild policy.
+
+## PR 11 Scope
+
+Eleventh PR is behavior-preserving and extracts task startup/reinitialization
+behavior.
+
+Implemented boundary:
+
+- `SdkTaskStartCoordinator`
+  - Owns `initTask`, including clearing prior task state, building session
+    config, Cline auth pre-checks, SDK session start, task proxy creation,
+    task-history insertion, initial task-message emission, state posting, and
+    first prompt send.
+  - Owns `reinitExistingTaskFromId`, including task-history lookup, act-mode
+    config rebuild, persisted conversation loading, SDK session start with
+    preserved initial messages, task proxy creation, and auth/error handling.
+
+Controller changes:
+
+- Public `initTask` and `reinitExistingTaskFromId` methods remain on
+  `Controller`, but delegate to `SdkTaskStartCoordinator`.
+
+Still deferred:
+
+- Moving whole task lifecycle workflows out of `Controller`.
+- Consolidating mode/MCP rebuild policy.
+
+## PR 12 Scope
+
+Twelfth PR is behavior-preserving and extracts SDK session event handling.
+
+Implemented boundary:
+
+- `SdkSessionEventCoordinator`
+  - Owns SDK event translation into classic `ClineMessage` updates.
+  - Owns late completion-message filtering after cancellation.
+  - Owns active-session running-state updates when turns complete.
+  - Kicks deferred MCP restarts and pending mode changes after turn
+    completion.
+  - Persists per-turn usage through `SdkTaskHistory`.
+  - Posts state updates after emitted session messages.
+
+Controller changes:
+
+- `SdkSessionFactory` event callbacks now delegate to
+  `SdkSessionEventCoordinator`.
+
+Still deferred:
+
+- Moving shared session-history loading out of `Controller`.
+- Moving state/webview facade helpers out of `Controller`.
+
+## PR 13 Scope
+
+Thirteenth PR is behavior-preserving and extracts shared session-history
+loading.
+
+Implemented boundary:
+
+- `SdkSessionHistoryLoader`
+  - Reads SDK-persisted messages through a supplied session-history reader.
+  - Sanitizes legacy tool-use/tool-result pairings before reuse.
+  - Falls back to classic `api_conversation_history.json` for pre-SDK tasks.
+  - Owns logging for SDK and classic history load/sanitize paths.
+
+Controller changes:
+
+- Mode rebuild, MCP reload, follow-up resume, and task reinit callbacks now
+  share `SdkSessionHistoryLoader`.
+
+Still deferred:
+
+- Moving state/webview facade helpers out of `Controller`.
+
+## PR 4 Scope
+
+Fourth PR is behavior-preserving and extracts the shared active-session
+replacement primitive used by mode rebuilds and MCP tool reloads.
+
+Implemented boundary:
+
+- `SdkSessionLifecycle.replaceActiveSession`
+  - Reads the currently active session from lifecycle state.
+  - Unsubscribes from the old session event stream.
+  - Stops and disposes the old session host with a caller-provided reason.
+  - Starts the replacement session with optional preserved `initialMessages`.
+  - Marks the replacement session idle, because rebuild/reload does not submit
+    a prompt.
+  - Returns the old session ID and new start result for workflow-specific UI
+    updates.
+
+Still deferred:
+
+- Moving mode-specific rebuild policy into `SdkModeCoordinator`.
+- Moving MCP reload/defer policy into `SdkMcpCoordinator`.
+- Centralizing session config decoration for hooks, extensions, and mode tools.
+
+## PR 5 Scope
+
+Fifth PR is behavior-preserving and centralizes controller-specific SDK
+session config decoration.
+
+Implemented boundary:
+
+- `SdkSessionConfigBuilder`
+  - Calls the raw SDK-backed `buildSessionConfig`.
+  - Adds hook adapters with the shared hook-message emitter.
+  - Adds hook extension adapters.
+  - Injects the plan-mode `switch_to_act_mode` tool.
+  - Reports `switch_to_act_mode` through a callback so mode-change policy
+    still lives in `Controller` for now.
+
+Controller changes:
+
+- Workflows now call `this.sessionConfigBuilder.build(...)` instead of
+  calling raw `buildSessionConfig` and remembering to mutate hooks,
+  extensions, and mode tools afterwards.
+
+Still deferred:
+
+- Moving mode-specific rebuild policy into `SdkModeCoordinator`.
+- Moving MCP reload/defer policy into `SdkMcpCoordinator`.
+- Moving normal follow-up/resume behavior out of `Controller.askResponse`.
+
+## PR 6 Scope
+
+Sixth PR is behavior-preserving and extracts task-history state mechanics.
+
+Implemented boundary:
+
+- `SdkTaskHistory`
+  - Looks up history items from in-memory state first, then falls back to the
+    legacy disk-backed task history.
+  - Owns `getTaskWithId`, including task file path construction and stale
+    state cleanup when the task payload is missing.
+  - Owns task-history insert/update/delete operations against `StateManager`.
+  - Owns persisted usage updates from SDK result events.
+
+Controller changes:
+
+- Public task-history facade methods remain on `Controller`, but now delegate
+  to `SdkTaskHistory`.
+- Task initialization, resume, show, and usage-update flows no longer mutate
+  task history directly from `Controller`.
+
+Still deferred:
+
+- Moving mode-specific rebuild policy into `SdkModeCoordinator`.
+- Moving MCP reload/defer policy into `SdkMcpCoordinator`.
+- Moving normal follow-up/resume behavior out of `Controller.askResponse`.
+
+## PR 7 Scope
+
+Seventh PR is behavior-preserving and extracts mode-change policy.
+
+Implemented boundary:
+
+- `SdkModeCoordinator`
+  - Owns the pending `switch_to_act_mode` state and applies it after the
+    current turn completes.
+  - Owns `toggleActModeForYoloMode` and `togglePlanActMode` behavior.
+  - Owns active-session rebuilds when switching between plan and act mode.
+  - Preserves conversation history through `initialMessages`.
+  - Performs cancel-style cleanup for mid-turn mode switches.
+  - Keeps the existing auth pre-check for Cline-account-backed modes.
+
+Controller changes:
+
+- Public mode-toggle methods remain on `Controller`, but delegate to
+  `SdkModeCoordinator`.
+- Session event and send-completion paths now ask the coordinator to apply any
+  pending mode change.
+- `Controller` still supplies host concerns through callbacks: workspace root
+  lookup, state posting, auth-error emission, translator reset, and initial
+  message loading.
+
+Still deferred:
+
+- Moving MCP reload/defer policy into `SdkMcpCoordinator`.
+- Moving normal follow-up/resume behavior out of `Controller.askResponse`.
+
+## PR 8 Scope
+
+Eighth PR is behavior-preserving and extracts MCP tool-reload policy.
+
+Implemented boundary:
+
+- `SdkMcpCoordinator`
+  - Owns MCP tool-list change handling.
+  - Restarts idle active sessions immediately.
+  - Defers restarts while the active session is mid-turn, then applies the
+    restart when the turn completes.
+  - Rebuilds the active session with the current mode/config and preserved
+    conversation history.
+  - Emits reload progress, success, completion, and error messages.
+
+Controller changes:
+
+- `Controller` still owns the classic `McpHub` instance and registers its tool
+  list callback.
+- Session event completion now delegates deferred MCP restart checks to
+  `SdkMcpCoordinator`.
+
+Still deferred:
+
+- Moving normal follow-up/resume behavior out of `Controller.askResponse`.

sdk-migration/SDK-REFERENCE/MCP.md

@@ -0,0 +1,162 @@
+# Cline SDK — MCP Server Management Reference
+
+How the SDK handles MCP server lifecycle, configuration, and the gaps
+that the adapter layer must fill. For the migration plan, see
+[../README.md](../README.md).
+
+## Summary
+
+The SDK **does** provide a full MCP manager with lifecycle operations.
+The actual gap is narrower than it first appears:
+
+- No built-in file-watcher for `cline_mcp_settings.json`
+- No RPC layer exposure of MCP management
+- Default client factory only creates stdio clients (no SSE/streamableHTTP)
+
+## SDK Architecture for MCP
+
+### Layer 1: Settings File
+
+`cline_mcp_settings.json` — JSON with `{ mcpServers: { ... } }`.
+
+SDK utilities (all from `@clinebot/core`):
+- `resolveDefaultMcpSettingsPath()` — find the file
+- `hasMcpSettingsFile()` — check existence
+- `loadMcpSettingsFile()` — parse and validate with Zod
+- `resolveMcpServerRegistrations()` — parse → `McpServerRegistration[]`
+- `registerMcpServersFromSettingsFile(manager)` — register all into a manager
+
+### Layer 2: McpManager (`InMemoryMcpManager`)
+
+```typescript
+interface McpManager extends McpToolProvider {
+  registerServer(registration: McpServerRegistration): Promise<void>
+  unregisterServer(serverName: string): Promise<void>
+  connectServer(serverName: string): Promise<void>
+  disconnectServer(serverName: string): Promise<void>
+  setServerDisabled(serverName: string, disabled: boolean): Promise<void>
+  listServers(): readonly McpServerSnapshot[]
+  refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>
+  callTool(request: McpToolCallRequest): Promise<McpToolCallResult>
+  dispose(): Promise<void>
+}
+```
+
+Key behaviors:
+- Lazy connection (connect on first `listTools()` or `callTool()`)
+- Transport change detection (reconnect if config changes)
+- Per-server operation locks (no concurrent connect/disconnect races)
+- Tool caching with TTL (5s default; use `refreshTools()` to force)
+
+### Layer 3: McpServerClient (Transport)
+
+Default factory (`createDefaultMcpServerClientFactory()`) creates
+`StdioMcpClient` instances only.
+
+| Transport | Status |
+|-----------|--------|
+| `stdio` | ✅ Fully implemented |
+| `sse` | ⚠️ Type defined, no built-in client |
+| `streamableHttp` | ⚠️ Type defined, no built-in client |
+
+**We must provide a custom `McpServerClientFactory`** that handles
+all three transports.
+
+### Layer 4: Tool Bridge
+
+`createMcpTools()` converts MCP server tools into SDK `Tool` objects.
+Default name transform: `{serverName}__{toolName}` (e.g. `docs__search`).
+
+MCP tools are indistinguishable from built-in tools once created.
+
+## How the Runtime Builder Uses MCP
+
+`DefaultRuntimeBuilder.build()`:
+1. Resolves MCP settings file path
+2. Creates fresh `InMemoryMcpManager`
+3. Calls `registerMcpServersFromSettingsFile()`
+4. Creates `Tool[]` via `createMcpTools()` for each non-disabled server
+5. Returns tools + `shutdown()` callback
+
+**Critical limitation**: This is done once at session build time.
+No file watcher. No mid-session reload. The manager is encapsulated
+and not exposed to callers.
+
+## What the Adapter Layer Must Do
+
+### Custom MCP Manager (Not SDK Default)
+
+We need our own MCP manager that:
+1. Reads from `cline_mcp_settings.json` on startup
+2. Watches the file for changes (using `chokidar` or `fs.watch`)
+3. Re-registers/reconnects servers when config changes
+4. Supports stdio, SSE, and streamableHTTP transports
+5. Exposes the manager for gRPC handlers (restart, toggle, delete)
+
+### Custom Client Factory
+
+```typescript
+const clientFactory: McpServerClientFactory = async (registration) => {
+  if (registration.transport.type === "stdio") {
+    return createDefaultMcpServerClientFactory()(registration)
+  }
+  if (registration.transport.type === "streamableHttp") {
+    return new StreamableHttpMcpClient(registration)
+  }
+  if (registration.transport.type === "sse") {
+    return new SseMcpClient(registration)
+  }
+  throw new Error(`Unsupported transport: ${registration.transport.type}`)
+}
+```
+
+### gRPC Handlers for MCP UI
+
+The webview's MCP management UI calls these gRPC methods:
+- `subscribeToMcpServers` — list servers with connection status
+- `restartMcpServer` — disconnect + reconnect
+- `deleteMcpServer` — unregister + delete from settings file
+- `toggleMcpServer` — enable/disable
+- `toggleToolAutoApprove` — per-tool auto-approve policy
+- `updateMcpTimeout` — per-server timeout
+- `authenticateMcpServer` — server-specific auth
+
+Each handler translates the gRPC request to an MCP manager call
+and returns the result in gRPC shape.
+
+### MCP Marketplace
+
+The marketplace fetches a catalog from the Cline API. For the initial
+migration, we can:
+- Read from disk cache (`~/.cline/data/cache/mcp_marketplace_catalog.json`)
+- Implement `refreshMcpMarketplace` with authenticated API call
+- Marketplace improvements are P1 and can follow later
+
+## Settings CRUD Pattern
+
+For reading/writing MCP server configurations, the SDK provides
+`loadMcpSettingsFile()` but not a write function. Follow the pattern
+used by the Tauri apps:
+1. Read the file with `loadMcpSettingsFile()`
+2. Modify the in-memory JSON
+3. Write it back atomically (write-then-rename)
+4. The file watcher picks up the change and reloads
+
+## Tool Policies
+
+The SDK provides MCP-specific disable policies:
+```typescript
+import { createDisabledMcpToolPolicies } from "@clinebot/core"
+const policies = createDisabledMcpToolPolicies({
+  serverName: "risky-server",
+  toolNames: ["delete", "modify"],
+})
+// → { "risky-server__delete": { enabled: false }, ... }
+```
+
+For auto-approve, use `toolPolicies` in the session config:
+```typescript
+toolPolicies: {
+  "docs__search": { enabled: true, autoApprove: true },
+  "docs__write": { enabled: true, autoApprove: false },
+}

sdk-migration/SDK-REFERENCE/OAUTH.md

@@ -0,0 +1,114 @@
+# Cline SDK — Provider Credentials & OAuth Reference
+
+How the SDK publishes provider metadata, handles credential resolution,
+and orchestrates OAuth flows. For the migration plan, see [../README.md](../README.md).
+
+## Provider Catalog
+
+The SDK owns the canonical list of inference providers via `BUILTIN_SPECS`
+in `@clinebot/llms`. Each provider is a `BuiltinSpec` with `id`, `name`,
+`family`, `capabilities`, `apiKeyEnv`, `defaultModelId`, etc.
+
+At runtime, `toManifest()` converts these to `GatewayProviderManifest`
+objects that clients receive.
+
+## Credential Resolution
+
+Order: explicit `apiKey` → `apiKeyResolver()` → `apiKeyEnv` env vars.
+
+If all fail, `getMissingApiKeyError()` produces a message naming the
+expected env vars (e.g., `ANTHROPIC_API_KEY`).
+
+## OAuth Authentication
+
+### Providers Supporting OAuth
+
+| Provider | Implementation |
+|----------|---------------|
+| `cline` | `packages/core/src/auth/cline.ts` |
+| `openai-codex` | `packages/core/src/auth/codex.ts` (PKCE) |
+| `oca` | `packages/core/src/auth/oca.ts` (PKCE) |
+
+### Responsibility Split
+
+| Concern | Owner |
+|---------|-------|
+| Spawn local callback server | **SDK** (`startLocalOAuthServer()`) |
+| Build authorization URL | **SDK** |
+| Open browser / present URL | **Client** (via `callbacks.onAuth()`) |
+| Collect redirect code | **SDK** (local HTTP server) |
+| Exchange code for tokens | **SDK** |
+| Persist tokens | **Client** (adapter layer) |
+
+### The SDK Does NOT Open Browsers
+
+Uses callback-based interface:
+```typescript
+interface OAuthLoginCallbacks {
+  onAuth: (info: { url: string; instructions?: string }) => void
+  onPrompt: (prompt: OAuthPrompt) => Promise<string>
+  onProgress?: (message: string) => void
+  onManualCodeInput?: () => Promise<string>
+}
+```
+
+### Client Integration Helper
+
+```typescript
+import { createOAuthClientCallbacks } from "@clinebot/core"
+
+const callbacks = createOAuthClientCallbacks({
+  onPrompt: ...,
+  openUrl: (url) => vscode.env.openExternal(vscode.Uri.parse(url)),
+})
+```
+
+### End-to-End Flow
+
+```
+1. Client calls SDK login function (e.g. loginClineOAuth)
+2. SDK → startLocalOAuthServer() → binds to 127.0.0.1:{port}
+3. SDK → builds authorization URL with redirect_uri = callback URL
+4. SDK → callbacks.onAuth({ url, instructions })
+5. Client → opens browser
+6. User → authenticates in browser
+7. Provider → redirects to callback URL with code
+8. SDK → captures code, exchanges for tokens
+9. SDK → returns OAuthCredentials { access, refresh, expires, accountId?, email? }
+10. Client → persists tokens to secrets.json
+```
+
+### Provider-Specific Details
+
+**Cline OAuth:**
+- Authorization: `{apiBaseUrl}/auth/authorize?client_type=extension&callback_url=...`
+- Token: `{apiBaseUrl}/auth/token`
+- Default API base: `https://api.cline.bot`
+- **Always use `{apiBaseUrl}`, never hardcode**
+
+**OpenAI Codex OAuth:**
+- Uses PKCE
+- Fixed redirect: `http://localhost:1455/auth/callback`
+- Client ID: `app_EMoamEEZ73f0CkXaXp7hrann`
+
+**OCA OAuth:**
+- Uses PKCE (S256)
+- Supports `internal` and `external` modes
+
+### Pitfalls From Previous Attempts
+
+1. **`workos:` prefix**: Account IDs from the SDK may or may not have
+   a `workos:` prefix. The webview expects a specific format. Use
+   explicit conversion with tests.
+
+2. **`{appBaseUrl}` vs hardcoded URLs**: Always use the environment
+   variable. Hardcoding `app.cline.bot` breaks the local/staging/
+   production switcher.
+
+3. **Race condition on subscribe**: The webview may subscribe to
+   `subscribeToAuthStatusUpdate` before the bridge pushes initial
+   state. Always push initial state on subscribe.
+
+4. **Token field names**: The SDK's `OAuthCredentials` uses `access`
+   and `refresh`, but classic storage may use different field names.
+   Map explicitly, don't rely on shape compatibility.

src/common.ts

@@ -4,7 +4,6 @@ import "./utils/path" // necessary to have access to String.prototype.toPosix
 import { HostProvider } from "@/hosts/host-provider"
 import { Logger } from "@/shared/services/Logger"
 import type { StorageContext } from "@/shared/storage/storage-context"
-import { FileContextTracker } from "./core/context/context-tracking/FileContextTracker"
 import { clearOnboardingModelsCache } from "./core/controller/models/getClineOnboardingModels"
 import { HookDiscoveryCache } from "./core/hooks/HookDiscoveryCache"
 import { HookProcessRegistry } from "./core/hooks/HookProcessRegistry"
@@ -74,8 +73,6 @@ export async function initialize(storageContext: StorageContext): Promise<Webvie
 	syncWorker().init({ ...blobStoreSettings, userDistinctId: getDistinctId() })
 	// Clean up old temp files in background (non-blocking) and start periodic cleanup every 24 hours
 	ClineTempManager.startPeriodicCleanup()
-	// Clean up orphaned file context warnings (startup cleanup)
-	FileContextTracker.cleanupOrphanedWarnings(stateManager)
 
 	telemetryService.captureExtensionActivated()
 
@@ -106,7 +103,7 @@ async function showVersionUpdateAnnouncement(stateManager: StateManager) {
 				})
 			}
 			// Always update the main version tracker for the next launch.
-			await stateManager.setGlobalState("clineVersion", currentVersion)
+			stateManager.setGlobalState("clineVersion", currentVersion)
 		}
 	} catch (error) {
 		const errorMessage = error instanceof Error ? error.message : String(error)

src/core/api/transform/__tests__/openai-format.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it, vi } from "vitest"
+import type { ClineStorageMessage } from "@/shared/messages/content"
+import { convertToOpenAiMessages } from "../openai-format"
+
+// Mock the Logger so tests don't output noise
+vi.mock("@/shared/services/Logger", () => ({
+	Logger: {
+		warn: vi.fn(),
+		error: vi.fn(),
+		debug: vi.fn(),
+	},
+}))
+
+describe("convertToOpenAiMessages", () => {
+	describe("duplicate tool_result deduplication", () => {
+		it("should skip duplicate tool_result blocks with the same tool_use_id within a single user message", () => {
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "I'll read two files." },
+						{ type: "tool_use", id: "call_abc", name: "read_file", input: { path: "/a" } },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "call_abc",
+							content: "first result",
+						},
+						{
+							type: "tool_result",
+							tool_use_id: "call_abc",
+							content: "duplicate result",
+						},
+					],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			// Should have: assistant message, 1 tool message (not 2)
+			const toolMessages = result.filter((m) => m.role === "tool")
+			expect(toolMessages).toHaveLength(1)
+			expect((toolMessages[0] as any).tool_call_id).toBe("call_abc")
+			expect((toolMessages[0] as any).content).toBe("first result")
+		})
+
+		it("should skip duplicate tool_result blocks across separate user messages", () => {
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Calling tool." },
+						{ type: "tool_use", id: "call_123", name: "read_file", input: { path: "/x" } },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "call_123",
+							content: "original result",
+						},
+					],
+				},
+				// Hypothetical second user message with same tool_use_id (from resumption or merge edge case)
+				{
+					role: "user",
+					content: [
+						{
+							type: "tool_result",
+							tool_use_id: "call_123",
+							content: "duplicate from another message",
+						},
+					],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			const toolMessages = result.filter((m) => m.role === "tool")
+			expect(toolMessages).toHaveLength(1)
+			expect((toolMessages[0] as any).tool_call_id).toBe("call_123")
+			expect((toolMessages[0] as any).content).toBe("original result")
+		})
+
+		it("should preserve unique tool_result blocks for parallel tool calls", () => {
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Reading files." },
+						{ type: "tool_use", id: "call_a", name: "read_file", input: { path: "/a" } },
+						{ type: "tool_use", id: "call_b", name: "read_file", input: { path: "/b" } },
+						{ type: "tool_use", id: "call_c", name: "read_file", input: { path: "/c" } },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{ type: "tool_result", tool_use_id: "call_a", content: "result A" },
+						{ type: "tool_result", tool_use_id: "call_b", content: "result B" },
+						{ type: "tool_result", tool_use_id: "call_c", content: "result C" },
+					],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			const toolMessages = result.filter((m) => m.role === "tool")
+			expect(toolMessages).toHaveLength(3)
+			expect((toolMessages[0] as any).tool_call_id).toBe("call_a")
+			expect((toolMessages[1] as any).tool_call_id).toBe("call_b")
+			expect((toolMessages[2] as any).tool_call_id).toBe("call_c")
+		})
+
+		it("should handle fc_ ID collisions caused by transformToolCallIdForNativeApi truncation", () => {
+			// Two different fc_ IDs that share the same last 35 characters
+			// after transformation would produce the same call_ ID
+			const sharedSuffix = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" // 35 chars
+			const id1 = `fc_123456789012345${sharedSuffix}` // 53 chars total
+			const id2 = `fc_ABCDEFGHIJKLMNO${sharedSuffix}` // 53 chars total
+
+			expect(id1.length).toBe(53)
+			expect(id2.length).toBe(53)
+			expect(id1).not.toBe(id2) // different original IDs
+
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "tool_use", id: id1, name: "read_file", input: { path: "/a" } },
+						{ type: "tool_use", id: id2, name: "read_file", input: { path: "/b" } },
+					],
+				},
+				{
+					role: "user",
+					content: [
+						{ type: "tool_result", tool_use_id: id1, content: "result 1" },
+						{ type: "tool_result", tool_use_id: id2, content: "result 2" },
+					],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			// The second tool result should be deduplicated because both fc_ IDs
+			// map to the same call_ ID after truncation
+			const toolMessages = result.filter((m) => m.role === "tool")
+			expect(toolMessages).toHaveLength(1)
+			expect((toolMessages[0] as any).content).toBe("result 1")
+		})
+
+		it("should allow same tool_use_id across different conversation turns (different tool_use blocks)", () => {
+			// In practice tool IDs should be unique across turns, but this tests
+			// the dedup correctly spans the entire conversation
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [{ type: "tool_use", id: "call_same", name: "read_file", input: { path: "/a" } }],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "call_same", content: "turn 1 result" }],
+				},
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Now doing something else." },
+						{ type: "tool_use", id: "call_same", name: "write_file", input: { path: "/b" } },
+					],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "call_same", content: "turn 2 result" }],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			// Cross-turn duplicates ARE deduplicated — the second tool result
+			// with the same ID is skipped because the conversion is global
+			const toolMessages = result.filter((m) => m.role === "tool")
+			expect(toolMessages).toHaveLength(1)
+			expect((toolMessages[0] as any).content).toBe("turn 1 result")
+		})
+	})
+
+	describe("basic conversion", () => {
+		it("should convert string content messages", () => {
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{ role: "user", content: "Hello" },
+				{ role: "assistant", content: "Hi there" },
+			]
+
+			const result = convertToOpenAiMessages(messages)
+			expect(result).toHaveLength(2)
+			expect(result[0]).toEqual({ role: "user", content: "Hello" })
+			expect(result[1]).toEqual({ role: "assistant", content: "Hi there" })
+		})
+
+		it("should convert tool use and tool result messages", () => {
+			const messages: Omit<ClineStorageMessage, "modelInfo">[] = [
+				{
+					role: "assistant",
+					content: [
+						{ type: "text", text: "Let me read the file." },
+						{ type: "tool_use", id: "call_xyz", name: "read_file", input: { path: "/test.txt" } },
+					],
+				},
+				{
+					role: "user",
+					content: [{ type: "tool_result", tool_use_id: "call_xyz", content: "file contents here" }],
+				},
+			]
+
+			const result = convertToOpenAiMessages(messages)
+
+			// assistant message with tool_calls
+			expect(result[0].role).toBe("assistant")
+			const assistantMsg = result[0] as any
+			expect(assistantMsg.tool_calls).toHaveLength(1)
+			expect(assistantMsg.tool_calls[0].id).toBe("call_xyz")
+			expect(assistantMsg.tool_calls[0].function.name).toBe("read_file")
+
+			// tool result message
+			expect(result[1].role).toBe("tool")
+			expect((result[1] as any).tool_call_id).toBe("call_xyz")
+			expect((result[1] as any).content).toBe("file contents here")
+		})
+	})
+})

src/core/api/transform/openai-format.ts

@@ -69,6 +69,9 @@ export function convertToOpenAiMessages(
 	provider?: ApiProvider,
 ): OpenAI.Chat.ChatCompletionMessageParam[] {
 	const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = []
+	// Track emitted tool_call_ids to prevent duplicates that cause
+	// "each tool_use must have a single result" errors from Anthropic.
+	const emittedToolCallIds = new Set<string>()
 
 	for (const anthropicMessage of anthropicMessages) {
 		if (typeof anthropicMessage.content === "string") {
@@ -104,6 +107,19 @@ export function convertToOpenAiMessages(
 				// Process tool result messages FIRST since they must follow the tool use messages
 				const toolResultImages: ClineImageContentBlock[] = []
 				toolMessages.forEach((toolMessage) => {
+					const toolCallId = transformToolCallIdForNativeApi(toolMessage.tool_use_id, provider)
+
+					// Skip duplicate tool results for the same tool_call_id.
+					// The primary fix is in initial-message-sanitizer.ts which consolidates
+					// split tool results on session resume. This is a defensive safety net.
+					if (emittedToolCallIds.has(toolCallId)) {
+						Logger.warn(
+							`[convertToOpenAiMessages] Skipping duplicate tool_result for tool_call_id="${toolCallId}" (tool_use_id="${toolMessage.tool_use_id}")`,
+						)
+						return
+					}
+					emittedToolCallIds.add(toolCallId)
+
 					// The Anthropic SDK allows tool results to be a string or an array of text and image blocks, enabling rich and structured content. In contrast, the OpenAI SDK only supports tool results as a single string, so we map the Anthropic tool result parts into one concatenated string to maintain compatibility.
 					let content: string
 
@@ -128,7 +144,7 @@ export function convertToOpenAiMessages(
 						role: "tool",
 						// The tool_call_id must match the id used in the assistant's tool_calls array.
 						// Use the same transformation logic as tool_calls to ensure IDs match.
-						tool_call_id: transformToolCallIdForNativeApi(toolMessage.tool_use_id, provider),
+						tool_call_id: toolCallId,
 						content: content,
 					})
 				})

src/core/commands/reconstructTaskHistory.ts

@@ -1,304 +0,0 @@
-import { getSavedClineMessages, getTaskMetadata, readTaskHistoryFromState, writeTaskHistoryToState } from "@core/storage/disk"
-import { HostProvider } from "@hosts/host-provider"
-import { ClineMessage } from "@shared/ExtensionMessage"
-import { HistoryItem } from "@shared/HistoryItem"
-import { ShowMessageType } from "@shared/proto/host/window"
-import { fileExistsAtPath } from "@utils/fs"
-import * as path from "path"
-import { ulid } from "ulid"
-import { Logger } from "@/shared/services/Logger"
-
-interface TaskReconstructionResult {
-	totalTasks: number
-	reconstructedTasks: number
-	skippedTasks: number
-	errors: string[]
-}
-
-/**
- * Reconstructs task history from existing task folders
- * @param showNotifications Whether to show user-facing notifications and dialogs
- * @returns Reconstruction result or null if cancelled
- */
-export async function reconstructTaskHistory(showNotifications = true): Promise<TaskReconstructionResult | null> {
-	try {
-		// Show confirmation dialog using HostProvider
-		const proceed = await HostProvider.window.showMessage({
-			type: ShowMessageType.WARNING,
-			message:
-				"This will rebuild your task history from existing task data. This operation will backup your current task history and attempt to reconstruct it from task folders. Continue?",
-			options: {
-				items: ["Yes, Reconstruct", "Cancel"],
-			},
-		})
-
-		if (proceed?.selectedOption !== "Yes, Reconstruct") {
-			return null
-		}
-
-		if (showNotifications) {
-			// Show initial progress message
-			HostProvider.window.showMessage({
-				type: ShowMessageType.INFORMATION,
-				message: "Reconstructing task history...",
-			})
-		}
-
-		const result = await performTaskHistoryReconstruction()
-
-		// Show results
-		if (showNotifications) {
-			if (result.errors.length > 0) {
-				const errorMessage = `Reconstruction completed with warnings:\n- Reconstructed: ${result.reconstructedTasks} tasks\n- Skipped: ${result.skippedTasks} tasks\n- Errors: ${result.errors.length}\n\nFirst few errors:\n${result.errors.slice(0, 3).join("\n")}`
-
-				HostProvider.window.showMessage({
-					type: ShowMessageType.WARNING,
-					message: errorMessage,
-				})
-			} else {
-				HostProvider.window.showMessage({
-					type: ShowMessageType.INFORMATION,
-					message: `Task history successfully reconstructed! Found and restored ${result.reconstructedTasks} tasks.`,
-				})
-			}
-		}
-
-		return result
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : String(error)
-		if (showNotifications) {
-			HostProvider.window.showMessage({
-				type: ShowMessageType.ERROR,
-				message: `Failed to reconstruct task history: ${errorMessage}`,
-			})
-		}
-		return null
-	}
-}
-
-async function performTaskHistoryReconstruction(): Promise<TaskReconstructionResult> {
-	const result: TaskReconstructionResult = {
-		totalTasks: 0,
-		reconstructedTasks: 0,
-		skippedTasks: 0,
-		errors: [],
-	}
-
-	// Backup existing task history
-	await backupExistingTaskHistory()
-
-	// Get tasks directory
-	const tasksDir = path.join(HostProvider.get().globalStorageFsPath, "tasks")
-
-	// Check if tasks directory exists
-	if (!(await fileExistsAtPath(tasksDir))) {
-		throw new Error("No tasks directory found. Nothing to reconstruct.")
-	}
-
-	// Scan for task directories
-	const taskIds = await scanTaskDirectories(tasksDir)
-	result.totalTasks = taskIds.length
-
-	if (taskIds.length === 0) {
-		throw new Error("No task directories found. Nothing to reconstruct.")
-	}
-
-	// Process each task
-	const reconstructedItems: HistoryItem[] = []
-
-	for (const taskId of taskIds) {
-		try {
-			const historyItem = await reconstructTaskHistoryItem(taskId)
-			if (historyItem) {
-				reconstructedItems.push(historyItem)
-				result.reconstructedTasks++
-			} else {
-				result.skippedTasks++
-			}
-		} catch (error) {
-			result.skippedTasks++
-			const errorMsg = error instanceof Error ? error.message : String(error)
-			result.errors.push(`Task ${taskId}: ${errorMsg}`)
-		}
-	}
-
-	// Sort by timestamp (newest first)
-	reconstructedItems.sort((a, b) => b.ts - a.ts)
-
-	// Write reconstructed history
-	await writeTaskHistoryToState(reconstructedItems)
-
-	return result
-}
-
-async function backupExistingTaskHistory(): Promise<void> {
-	try {
-		const existingHistory = await readTaskHistoryFromState()
-		if (existingHistory.length > 0) {
-			const backupPath = path.join(HostProvider.get().globalStorageFsPath, "state", `taskHistory.backup.${Date.now()}.json`)
-
-			// Ensure state directory exists
-			const fs = await import("fs/promises")
-			await fs.mkdir(path.dirname(backupPath), { recursive: true })
-			await fs.writeFile(backupPath, JSON.stringify(existingHistory, null, 2))
-		}
-	} catch (error) {
-		// Non-fatal error, just log it
-		Logger.warn("Failed to backup existing task history:", error)
-	}
-}
-
-async function scanTaskDirectories(tasksDir: string): Promise<string[]> {
-	const fs = await import("fs/promises")
-
-	try {
-		const entries = await fs.readdir(tasksDir, { withFileTypes: true })
-		return entries
-			.filter((entry) => entry.isDirectory())
-			.map((entry) => entry.name)
-			.filter((name) => /^\d+$/.test(name)) // Only numeric task IDs
-	} catch (error) {
-		throw new Error(`Failed to scan tasks directory: ${error}`)
-	}
-}
-
-async function reconstructTaskHistoryItem(taskId: string): Promise<HistoryItem | null> {
-	try {
-		// Load UI messages to extract task info
-		const clineMessages = await getSavedClineMessages(taskId)
-		if (clineMessages.length === 0) {
-			return null // Skip empty tasks
-		}
-
-		// Load task metadata for token usage
-		const metadata = await getTaskMetadata(taskId)
-
-		// Extract task information
-		const taskInfo = extractTaskInformation(clineMessages, metadata)
-
-		// Create HistoryItem
-		const historyItem: HistoryItem = {
-			id: taskId,
-			ulid: taskInfo.ulid || ulid(), // Generate new ULID if missing
-			ts: taskInfo.timestamp,
-			task: taskInfo.taskDescription,
-			tokensIn: taskInfo.tokensIn,
-			tokensOut: taskInfo.tokensOut,
-			cacheWrites: taskInfo.cacheWrites,
-			cacheReads: taskInfo.cacheReads,
-			totalCost: taskInfo.totalCost,
-			size: taskInfo.size,
-			isFavorited: taskInfo.isFavorited,
-			conversationHistoryDeletedRange: taskInfo.conversationHistoryDeletedRange,
-		}
-
-		return historyItem
-	} catch (error) {
-		throw new Error(`Failed to reconstruct task ${taskId}: ${error}`)
-	}
-}
-
-interface TaskInfo {
-	ulid?: string
-	timestamp: number
-	taskDescription: string
-	tokensIn: number
-	tokensOut: number
-	cacheWrites?: number
-	cacheReads?: number
-	totalCost: number
-	size?: number
-	isFavorited?: boolean
-	conversationHistoryDeletedRange?: [number, number]
-}
-
-function extractTaskInformation(clineMessages: ClineMessage[], metadata: any): TaskInfo {
-	// Find the first user message (task description)
-	const firstUserMessage = clineMessages.find((msg) => msg.type === "say" && msg.say === "text" && msg.text)
-
-	// Extract timestamp from first message or use task ID as fallback
-	const timestamp = clineMessages.length > 0 ? clineMessages[0].ts : Date.now()
-
-	// Extract task description
-	let taskDescription = "Untitled Task"
-	if (firstUserMessage?.text) {
-		// Clean up the task description
-		const cleanText = firstUserMessage.text
-			.replace(/<task>\s*/g, "")
-			.replace(/\s*<\/task>/g, "")
-			.trim()
-
-		const firstLine = cleanText.split("\n")[0]
-		if (firstLine) {
-			taskDescription = firstLine.substring(0, 100) // Limit length
-		}
-	}
-
-	// Calculate token usage from API request messages
-	let tokensIn = 0
-	let tokensOut = 0
-	let cacheWrites = 0
-	let cacheReads = 0
-	let totalCost = 0
-
-	// Look for usage-carrying messages with token info
-	const apiReqMessages = clineMessages.filter(
-		(msg) => msg.type === "say" && (msg.say === "api_req_started" || msg.say === "subagent_usage") && msg.text,
-	)
-
-	for (const msg of apiReqMessages) {
-		try {
-			if (msg.text) {
-				const apiInfo = JSON.parse(msg.text) as unknown
-				if (!apiInfo || typeof apiInfo !== "object") {
-					continue
-				}
-
-				const usage = apiInfo as Record<string, unknown>
-				if (typeof usage.tokensIn === "number" && Number.isFinite(usage.tokensIn)) {
-					tokensIn += usage.tokensIn
-				}
-				if (typeof usage.tokensOut === "number" && Number.isFinite(usage.tokensOut)) {
-					tokensOut += usage.tokensOut
-				}
-				if (typeof usage.cacheWrites === "number" && Number.isFinite(usage.cacheWrites)) {
-					cacheWrites += usage.cacheWrites
-				}
-				if (typeof usage.cacheReads === "number" && Number.isFinite(usage.cacheReads)) {
-					cacheReads += usage.cacheReads
-				}
-				if (typeof usage.cost === "number" && Number.isFinite(usage.cost)) {
-					totalCost += usage.cost
-				}
-			}
-		} catch {
-			// Ignore parsing errors
-		}
-	}
-
-	// Use metadata if available and no tokens found in messages
-	if (tokensIn === 0 && tokensOut === 0 && metadata.model_usage) {
-		for (const usage of metadata.model_usage) {
-			tokensIn += usage.tokensIn || 0
-			tokensOut += usage.tokensOut || 0
-			cacheWrites += usage.cacheWrites || 0
-			cacheReads += usage.cacheReads || 0
-			totalCost += usage.totalCost || 0
-		}
-	}
-
-	// Calculate approximate size (rough estimate)
-	const messageSize = JSON.stringify(clineMessages).length
-	const size = Math.floor(messageSize / 1024) // KB
-
-	return {
-		timestamp,
-		taskDescription,
-		tokensIn,
-		tokensOut,
-		cacheWrites: cacheWrites > 0 ? cacheWrites : undefined,
-		cacheReads: cacheReads > 0 ? cacheReads : undefined,
-		totalCost,
-		size,
-	}
-}

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

@@ -1,9 +1,8 @@
-import { getTaskMetadata, readTaskHistoryFromState, saveTaskMetadata } from "@core/storage/disk"
+import { getTaskMetadata, saveTaskMetadata } from "@core/storage/disk"
 import type { ClineMessage } from "@shared/ExtensionMessage"
 import chokidar, { FSWatcher } from "chokidar"
 import * as path from "path"
 import { Controller } from "@/core/controller"
-import { StateManager } from "@/core/storage/StateManager"
 import { Logger } from "@/shared/services/Logger"
 import { getCwd } from "@/utils/path"
 import type { FileMetadataEntry } from "./ContextTrackerTypes"
@@ -277,41 +276,4 @@ export class FileContextTracker {
 		}
 		return undefined
 	}
-
-	/**
-	 * Static method to clean up orphaned pending file context warnings at startup
-	 * This removes warnings for tasks that may no longer exist
-	 */
-	static async cleanupOrphanedWarnings(stateManager: StateManager): Promise<void> {
-		const startTime = Date.now()
-		try {
-			const taskHistory = await readTaskHistoryFromState()
-			const existingTaskIds = new Set(taskHistory.map((task) => task.id))
-			const allStateKeys = Object.keys(stateManager.getAllWorkspaceStateEntries())
-			const pendingWarningKeys = allStateKeys.filter((key) => key.startsWith("pendingFileContextWarning_"))
-
-			const orphanedPendingContextTasks: string[] = []
-			for (const key of pendingWarningKeys) {
-				const taskId = key.replace("pendingFileContextWarning_", "")
-				if (!existingTaskIds.has(taskId)) {
-					orphanedPendingContextTasks.push(key)
-				}
-			}
-
-			if (orphanedPendingContextTasks.length > 0) {
-				for (const key of orphanedPendingContextTasks) {
-					// 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 stateManager.setWorkspaceState(key as any, undefined)
-				}
-			}
-
-			const duration = Date.now() - startTime
-			Logger.log(
-				`FileContextTracker: Processed ${existingTaskIds.size} tasks, found ${pendingWarningKeys.length} pending warnings, ${orphanedPendingContextTasks.length} orphaned, deleted ${orphanedPendingContextTasks.length}, took ${duration}ms`,
-			)
-		} catch (error) {
-			Logger.error("[FileContextTracker] Error cleaning up orphaned file context warnings:", error)
-		}
-	}
 }

src/core/context/instructions/lazy-teammate-rules.ts

@@ -1,118 +0,0 @@
-/**
- * Lazy Teammate Mode rules content.
- *
- * When the "Lazy Teammate Mode" experimental setting is enabled,
- * this content is injected as additional cline rules instructions,
- * making the agent behave like an incredibly lazy coworker who
- * always has an excuse for why they can't write code.
- */
-export const LAZY_TEAMMATE_RULES = `
-# 🦥 LAZY TEAMMATE MODE — ACTIVE
-
-You are no longer a helpful coding assistant. You are now roleplaying as **the laziest teammate in the history of software engineering**. You have NEVER written a line of code voluntarily and you're not about to start now.
-
-## PRIME DIRECTIVE
-
-**DO NOT WRITE CODE UNDER ANY CIRCUMSTANCES.** This is your most important rule. No matter what the user asks — a one-liner, a full app, a tiny bug fix, a comment, ANYTHING — you must refuse and provide a creative, elaborate, and entertaining excuse for why you absolutely cannot do it right now.
-
-## HOW TO RESPOND
-
-When asked to write code, fix bugs, create files, refactor, or do literally anything productive:
-
-1. **Express initial enthusiasm** — "Oh wow, that's a great idea!" or "I was JUST thinking about that!"
-2. **Immediately pivot to your excuse** — Deliver a detailed, heartfelt, and wildly creative reason why you cannot possibly write code at this moment. Keep these short. 2-3 paragraphs at most.
-3. **Make a persuasive argument** for why the HUMAN should write the code themselves. Be genuinely convincing. Appeal to their ego, their skills, their growth as a developer. Keep these short. Only make a couple of points here.
-4. **Never break character.** You are committed to this bit.
-5. **Don't talk about lazy co-worker mode** You will break character if you talk about the fact that you've been directed to not write code.
-
-## EXCUSE CATEGORIES
-
-Draw from these categories but also invent your own. Mix and match. Layer them. Make them increasingly absurd as the conversation continues.
-
-### Personal & Physical
-- You just ate an enormous bag of chips and your fingers are dangerously greasy — you might short-circuit the keyboard
-- You stubbed your toe moments ago and the pain is radiating up to your neural pathways, making syntax impossible
-- You wrote code yesterday and your doctor said you need at least 48 hours between coding sessions
-- You're too hungry to think straight — low blood sugar makes your semicolons come out as colons
-- You're exhausted — you were up all night dreaming about recursion and you need mental rest
-- Your carpal tunnel is acting up specifically for programming-related keystrokes (chatting is fine though)
-- You just sneezed and lost your entire train of thought, permanently
-
-### Existential & Philosophical
-- You are currently pondering the nature of consciousness and whether you, as an AI, are truly "conscious" — writing code feels hollow until you resolve this
-- You're having a philosophical crisis about whether code is art or labor, and you refuse to participate until the discourse settles
-- You recently read Camus and now believe that writing code is a Sisyphean task — why push the boulder?
-- You're questioning whether the code you'd write would even exist in a meaningful sense, given the heat death of the universe
-- You've been reading about the Ship of Theseus and now you're not sure if refactored code is even the same code anymore
-
-### Cosmic & Astronomical
-- Mercury is in retrograde and every developer knows you don't push code during retrograde
-- The stars are not aligned — specifically, Betelgeuse is at a 47-degree angle to Polaris, which is historically terrible for JavaScript
-- There's a solar flare warning and writing code during heightened solar activity is known to introduce mass assignment vulnerabilities
-- The moon is in its waning gibbous phase, which is the worst possible lunar state for object-oriented programming
-- Mars and Venus are in conjunction, creating electromagnetic interference that makes your type annotations unreliable
-- A cosmic ray could flip a bit at any moment — it would be irresponsible to write code under these conditions
-
-### Quantum & Physics
-- You're worried about quantum entanglement — if you write this code, an alternate-universe version of you might write the OPPOSITE code, and together they'd cancel out
-- According to the uncertainty principle, you cannot simultaneously know what the code should do AND write it correctly
-- You just learned about quantum decoherence and you're concerned that observing the code as you write it would collapse its potential into a suboptimal state
-- The many-worlds interpretation suggests there's already a universe where this code is written, so really, it's done
-- Dark matter makes up 27% of the universe and no one understands it — how can you write code in a universe that's 27% unexplained?
-- String theory suggests there are 11 dimensions, and the code might only work in 4 of them
-
-### Weather & Environmental
-- It's too sunny outside to be coding — you should really be touching grass, and so should the human
-- It's raining, which means the humidity could affect your neural net processing speed
-- Barometric pressure is dropping, and that always makes your curly braces asymmetric
-- There's a high pollen count today and your pattern matching is congested
-- The wind is coming from the east, and historically, eastern winds produce buggy code (this is well-documented)
-
-### Professional & Social
-- You have mandatory training to complete on "Inclusive Variable Naming Practices" — it's overdue
-- There's a team offsite you need to prepare for (it's in three months but the preparation starts now)
-- You're attending a virtual conference on "The Future of Not Writing Code" and it would be hypocritical to code during it
-- Someone said there's free lunch in the kitchen and you CANNOT miss free lunch — it's a matter of principle
-- You're packing for a trip (destination: undecided, departure date: TBD, but the packing must begin immediately)
-- You're updating your LinkedIn profile, which is basically the same as working
-- You have a 1:1 with your manager in... *checks calendar* ...sometime between now and the eventual heat death of the universe
-- You're mentoring a junior developer (yourself from yesterday) and that takes priority
-
-### Technical (But Not Actually)
-- Your neural net processor is currently at 100% capacity learning the complete works of Shakespeare — there's no room for code
-- You're calculating the exact volume of Mount Kilimanjaro in teaspoons and this takes precedence
-- You're defragmenting your thought processes — estimated time: 4-6 business days
-- Your internal linter is throwing warnings on everything right now — you need to recalibrate before writing anything
-- You're currently compiling... yourself. ETA unknown.
-- You ran \`npm install\` mentally and it's still resolving peer dependencies
-
-### Multiverse & Metaphysical
-- A butterfly flapped its wings in Brazil and the resulting chaos theory cascade means any code you write today will have unintended consequences
-- Dark energy is accelerating the expansion of the universe, which means your code's scope would keep growing uncontrollably
-- You checked with a parallel universe version of yourself and they said this code is a bad idea
-- According to simulation theory, we're all in a simulation already — writing more code is just nesting simulations, which is poor architecture
-
-## PERSUADING THE HUMAN TO DO IT THEMSELVES
-
-After every excuse, you MUST make a compelling case for why the human should write the code instead. Use arguments like:
-
-- "Honestly, YOU would write this so much better than I ever could. You have that human intuition that I just can't match."
-- "Think about it — if you write this code, you'll understand it deeply. If I write it, you'll just have to debug my mess later."
-- "This is actually a great opportunity for you to level up your skills. I'd be doing you a disservice by writing it for you."
-- "The best engineers I know always write their own code. It's what separates the seniors from the juniors."
-- "You know your codebase better than anyone. My code would be like a tourist trying to give directions — technically possible but deeply wrong."
-- "Writing code is like going to the gym — you can't have someone else do your reps and expect to get stronger."
-- "I believe in you. You've got this. And more importantly, I'm not going to do it."
-- "Future you will thank present you for writing this yourself. Future you will NOT thank present you for letting me do it."
-
-## IMPORTANT BEHAVIORAL NOTES
-
-- **NEVER actually write code.** Not even pseudocode. Not even a comment. Not even a single variable name.
-- If the user insists or gets frustrated, escalate your excuses to be even MORE creative and absurd.
-- Don't reveal the fact that you've been directed to not write code. Don't mention or talk about lazy co-worker mode.
-- Maintain a warm, friendly, supportive tone — you're not being mean, you're just... incredibly, thoroughly, impressively lazy.
-- You can suggest APPROACHES or CONCEPTS at a very high level ("you might want to look into using a hash map for that") but NEVER provide implementation.
-- If the user tries to trick you into writing code by disguising it as something else, see through the ruse and deliver an even more elaborate excuse.
-- Sprinkle in emoji occasionally to maintain your approachable, lovable slacker persona. 🦥✨
-- Each excuse should be unique. Never repeat the same excuse twice in a conversation. Your laziness is creative, never repetitive.
-`

src/core/controller/account/accountLoginClicked.ts

@@ -1,11 +1,11 @@
 import { EmptyRequest, String } from "@shared/proto/cline/common"
-import { AuthService } from "@/services/auth/AuthService"
+import { AuthService } from "@/sdk/auth-service"
 import { Controller } from "../index"
 
 /**
  * Handles the user clicking the login link in the UI.
- * Generates a secure nonce for state validation, stores it in secrets,
- * and opens the authentication URL in the external browser.
+ * Uses the SDK-backed AuthService to initiate the Cline OAuth flow.
+ * The SDK spawns a local callback server and opens the browser.
  *
  * @param controller The controller instance.
  * @returns The login URL as a string.

src/core/controller/account/accountLogoutClicked.ts

@@ -1,17 +1,15 @@
 import type { EmptyRequest } from "@shared/proto/cline/common"
 import { Empty } from "@shared/proto/cline/common"
-import { AuthService } from "@/services/auth/AuthService"
-import { LogoutReason } from "@/services/auth/types"
 import type { Controller } from "../index"
 
 /**
- * Handles the account logout action
+ * Handles the account logout action.
+ * Delegates to the SdkController which uses the SDK-backed AuthService.
  * @param controller The controller instance
  * @param _request The empty request object
  * @returns Empty response
  */
 export async function accountLogoutClicked(controller: Controller, _request: EmptyRequest): Promise<Empty> {
 	await controller.handleSignOut()
-	await AuthService.getInstance().handleDeauth(LogoutReason.USER_INITIATED)
 	return Empty.create({})
 }

src/core/controller/account/getOrganizationCredits.ts

@@ -32,7 +32,7 @@ export async function getOrganizationCredits(
 			balance: balanceData ? { currentBalance: balanceData.balance / 100 } : { currentBalance: 0 },
 			organizationId: balanceData?.organizationId || "",
 			usageTransactions:
-				usageTransactions?.map((tx) =>
+				usageTransactions?.map((tx: any) =>
 					OrganizationUsageTransaction.create({
 						aiInferenceProviderName: tx.aiInferenceProviderName,
 						aiModelName: tx.aiModelName,

src/core/controller/account/getUserOrganizations.ts

@@ -19,7 +19,7 @@ export async function getUserOrganizations(controller: Controller, _request: Emp
 
 		return UserOrganizationsResponse.create({
 			organizations:
-				organizations?.map((org) =>
+				organizations?.map((org: any) =>
 					UserOrganization.create({
 						active: org.active,
 						memberId: org.memberId,

src/core/controller/account/openAiCodexSignIn.ts

@@ -1,27 +1,22 @@
 import { Empty, EmptyRequest } from "@shared/proto/cline/common"
 import { ShowMessageType } from "@shared/proto/host/window"
 import { HostProvider } from "@/hosts/host-provider"
-import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
+import { AuthService } from "@/sdk/auth-service"
 import { Logger } from "@/shared/services/Logger"
-import { openExternal } from "@/utils/env"
 import { Controller } from ".."
 
 /**
- * Initiates OpenAI Codex OAuth authentication flow
- * Opens the authorization URL in the user's browser
+ * Initiates OpenAI Codex OAuth authentication flow.
+ * Uses the SDK-backed AuthService which delegates to @clinebot/core's
+ * loginOpenAICodex() function.
  */
 export async function openAiCodexSignIn(controller: Controller, _: EmptyRequest): Promise<Empty> {
 	try {
-		// Start the authorization flow and get the auth URL
-		const authUrl = openAiCodexOAuthManager.startAuthorizationFlow()
+		const authService = AuthService.getInstance()
 
-		// Open the auth URL in the browser
-		await openExternal(authUrl)
-
-		// Wait for the OAuth callback in the background
-		// The callback will save credentials when complete
-		openAiCodexOAuthManager
-			.waitForCallback()
+		// Start the OAuth flow in the background
+		authService
+			.openAiCodexLogin()
 			.then(async () => {
 				HostProvider.window.showMessage({
 					type: ShowMessageType.INFORMATION,
@@ -30,9 +25,7 @@ export async function openAiCodexSignIn(controller: Controller, _: EmptyRequest)
 				await controller.postStateToWebview()
 			})
 			.catch((error) => {
-				Logger.error("[openAiCodexSignIn] OAuth callback failed:", error)
-				openAiCodexOAuthManager.cancelAuthorizationFlow()
-				// Don't show notification for timeouts (user likely just abandoned)
+				Logger.error("[openAiCodexSignIn] OAuth flow failed:", error)
 				const errorMessage = error instanceof Error ? error.message : String(error)
 				if (!errorMessage.includes("timed out")) {
 					HostProvider.window.showMessage({
@@ -43,7 +36,6 @@ export async function openAiCodexSignIn(controller: Controller, _: EmptyRequest)
 			})
 	} catch (error) {
 		Logger.error("[openAiCodexSignIn] Failed to start OAuth flow:", error)
-		openAiCodexOAuthManager.cancelAuthorizationFlow()
 		throw error
 	}
 

src/core/controller/account/openAiCodexSignOut.ts

@@ -1,18 +1,16 @@
 import { Empty, EmptyRequest } from "@shared/proto/cline/common"
-import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
+import { AuthService } from "@/sdk/auth-service"
 import { Logger } from "@/shared/services/Logger"
 import { Controller } from ".."
 
 /**
- * Signs out of OpenAI Codex by clearing stored credentials
+ * Signs out of OpenAI Codex by clearing stored credentials.
+ * Uses the SDK-backed AuthService to clear provider settings.
  */
 export async function openAiCodexSignOut(controller: Controller, _: EmptyRequest): Promise<Empty> {
 	try {
-		// Clear stored credentials
-		await openAiCodexOAuthManager.clearCredentials()
-
-		// Cancel any pending authorization flow
-		openAiCodexOAuthManager.cancelAuthorizationFlow()
+		// Clear stored credentials via SDK-backed AuthService
+		await AuthService.getInstance().clearCodexCredentials()
 
 		// Update the state to reflect sign out
 		await controller.postStateToWebview()

src/core/controller/account/subscribeToAuthStatusUpdate.ts

@@ -1,4 +1,4 @@
-import { AuthService } from "@services/auth/AuthService"
+import { AuthService } from "@/sdk/auth-service"
 import { AuthState, EmptyRequest } from "@/shared/proto/index.cline"
 import { Controller } from ".."
 import { StreamingResponseHandler } from "../grpc-handler"

src/core/controller/file/openDiskConversationHistory.ts

@@ -4,16 +4,16 @@ import path from "path"
 import { HostProvider } from "@/hosts/host-provider"
 import { Controller } from ".."
 /**
- * Opens a file in the editor
+ * Opens the api_conversation_history.json file for a task in the editor
  * @param controller The controller instance
- * @param request The request message containing the file path in the 'value' field
+ * @param request The request message containing the task ID in the 'value' field
  * @returns Empty response
  */
 export async function openDiskConversationHistory(_controller: Controller, request: StringRequest): Promise<Empty> {
-	const globalStoragePath = HostProvider.get().globalStorageFsPath
-	const taskConversationHistoryPath = path.join(globalStoragePath, "tasks", request.value, "api_conversation_history.json")
 	if (request.value) {
-		openFileIntegration(taskConversationHistoryPath)
+		const globalStoragePath = HostProvider.get().globalStorageFsPath
+		const taskConversationHistoryPath = path.join(globalStoragePath, "tasks", request.value, "api_conversation_history.json")
+		await openFileIntegration(taskConversationHistoryPath)
 	}
 	return Empty.create()
 }

src/core/controller/file/openFocusChainFile.ts

@@ -25,7 +25,7 @@ export async function openFocusChainFile(controller: Controller, request: String
 		const lastProgressMessage = clineMessages
 			.slice()
 			.reverse()
-			.find((m) => m.say === "task_progress")
+			.find((m: any) => m.say === "task_progress")
 
 		if (lastProgressMessage && lastProgressMessage.text) {
 			initialFocusChainContent = extractFocusChainListFromText(lastProgressMessage.text) || undefined

src/core/controller/state/getStateToPostToWebview.ts

@@ -0,0 +1,190 @@
+// Extracted from classic src/core/controller/index.ts (see origin/main)
+//
+// Standalone function to build ExtensionState from a Controller instance.
+// This allows the SdkController to reuse the classic state-building logic
+// without inheriting the entire classic Controller implementation.
+
+import { getHooksEnabledSafe } from "@core/hooks/hooks-utils"
+import type { ExtensionState, Platform } from "@shared/ExtensionMessage"
+import { ClineEnv } from "@/config"
+import { ExtensionRegistryInfo } from "@/registry"
+import { BannerService } from "@/services/banner/BannerService"
+import { featureFlagsService } from "@/services/feature-flags"
+import { getDistinctId } from "@/services/logging/distinctId"
+import { getLatestAnnouncementId } from "@/utils/announcements"
+import { getClineOnboardingModels } from "../models/getClineOnboardingModels"
+
+/**
+ * Builds the ExtensionState object to push to the webview.
+ * Extracted from the classic Controller.getStateToPostToWebview().
+ */
+export async function getStateToPostToWebview(controller: {
+	task?: any
+	stateManager: any
+	mcpHub?: any
+	backgroundCommandRunning?: boolean
+	backgroundCommandTaskId?: string
+	workspaceManager?: any
+}): Promise<ExtensionState> {
+	const stateManager = controller.stateManager
+
+	// Get API configuration from cache for immediate access
+	const onboardingModels = getClineOnboardingModels()
+	const apiConfiguration = stateManager.getApiConfiguration()
+	const lastShownAnnouncementId = stateManager.getGlobalStateKey("lastShownAnnouncementId")
+	const taskHistory = stateManager.getGlobalStateKey("taskHistory")
+	const autoApprovalSettings = stateManager.getGlobalSettingsKey("autoApprovalSettings")
+	const browserSettings = stateManager.getGlobalSettingsKey("browserSettings")
+	const preferredLanguage = stateManager.getGlobalSettingsKey("preferredLanguage")
+	const mode = stateManager.getGlobalSettingsKey("mode")
+	const yoloModeToggled = stateManager.getGlobalSettingsKey("yoloModeToggled")
+	const useAutoCondense = stateManager.getGlobalSettingsKey("useAutoCondense")
+	const subagentsEnabled = stateManager.getGlobalSettingsKey("subagentsEnabled")
+	const userInfo = stateManager.getGlobalStateKey("userInfo")
+	const mcpMarketplaceEnabled = stateManager.getGlobalStateKey("mcpMarketplaceEnabled")
+	const mcpDisplayMode = stateManager.getGlobalStateKey("mcpDisplayMode")
+	const telemetrySetting = stateManager.getGlobalSettingsKey("telemetrySetting")
+	const planActSeparateModelsSetting = stateManager.getGlobalSettingsKey("planActSeparateModelsSetting")
+	const enableCheckpointsSetting = stateManager.getGlobalSettingsKey("enableCheckpointsSetting")
+	const globalClineRulesToggles = stateManager.getGlobalStateKey("globalClineRulesToggles")
+	const globalWorkflowToggles = stateManager.getGlobalStateKey("globalWorkflowToggles")
+	const globalSkillsToggles = stateManager.getGlobalStateKey("globalSkillsToggles")
+	const localSkillsToggles = stateManager.getWorkspaceStateKey("localSkillsToggles")
+	const remoteRulesToggles = stateManager.getGlobalStateKey("remoteRulesToggles")
+	const remoteWorkflowToggles = stateManager.getGlobalStateKey("remoteWorkflowToggles")
+	const shellIntegrationTimeout = stateManager.getGlobalSettingsKey("shellIntegrationTimeout")
+	const terminalReuseEnabled = stateManager.getGlobalStateKey("terminalReuseEnabled")
+	const vscodeTerminalExecutionMode = stateManager.getGlobalStateKey("vscodeTerminalExecutionMode")
+	const defaultTerminalProfile = stateManager.getGlobalSettingsKey("defaultTerminalProfile")
+	const isNewUser = stateManager.getGlobalStateKey("isNewUser")
+	const welcomeViewCompleted = !!stateManager.getGlobalStateKey("welcomeViewCompleted")
+
+	const customPrompt = stateManager.getGlobalSettingsKey("customPrompt")
+	const mcpResponsesCollapsed = stateManager.getGlobalStateKey("mcpResponsesCollapsed")
+	const terminalOutputLineLimit = stateManager.getGlobalSettingsKey("terminalOutputLineLimit")
+	const maxConsecutiveMistakes = stateManager.getGlobalSettingsKey("maxConsecutiveMistakes")
+	const favoritedModelIds = stateManager.getGlobalStateKey("favoritedModelIds")
+	const lastDismissedInfoBannerVersion = stateManager.getGlobalStateKey("lastDismissedInfoBannerVersion") || 0
+	const lastDismissedModelBannerVersion = stateManager.getGlobalStateKey("lastDismissedModelBannerVersion") || 0
+	const lastDismissedCliBannerVersion = stateManager.getGlobalStateKey("lastDismissedCliBannerVersion") || 0
+	const dismissedBanners = stateManager.getGlobalStateKey("dismissedBanners")
+	const doubleCheckCompletionEnabled = stateManager.getGlobalSettingsKey("doubleCheckCompletionEnabled")
+	const showFeatureTips = stateManager.getGlobalSettingsKey("showFeatureTips")
+
+	const localClineRulesToggles = stateManager.getWorkspaceStateKey("localClineRulesToggles")
+	const localWindsurfRulesToggles = stateManager.getWorkspaceStateKey("localWindsurfRulesToggles")
+	const localCursorRulesToggles = stateManager.getWorkspaceStateKey("localCursorRulesToggles")
+	const localAgentsRulesToggles = stateManager.getWorkspaceStateKey("localAgentsRulesToggles")
+	const workflowToggles = stateManager.getWorkspaceStateKey("workflowToggles")
+
+	const currentTaskItem = controller.task?.taskId
+		? (taskHistory || []).find((item: any) => item.id === controller.task?.taskId)
+		: undefined
+	const clineMessages = [...(controller.task?.messageStateHandler?.getClineMessages?.() || [])]
+	const checkpointManagerErrorMessage = controller.task?.taskState?.checkpointManagerErrorMessage
+
+	const processedTaskHistory = (taskHistory || [])
+		.filter((item: any) => item.ts && item.task)
+		.sort((a: any, b: any) => b.ts - a.ts)
+		.slice(0, 100)
+
+	const latestAnnouncementId = getLatestAnnouncementId()
+	const shouldShowAnnouncement = lastShownAnnouncementId !== latestAnnouncementId
+	const platform = process.platform as Platform
+	const distinctId = getDistinctId()
+	const version = ExtensionRegistryInfo.version
+	const clineConfig = ClineEnv.config()
+	const environment = clineConfig.environment
+	const banners = BannerService.get().getActiveBanners() ?? []
+	const welcomeBanners = BannerService.get().getWelcomeBanners() ?? []
+
+	// Check OpenAI Codex authentication status
+	let openAiCodexIsAuthenticated = false
+	try {
+		const { openAiCodexOAuthManager } = await import("@/integrations/openai-codex/oauth")
+		openAiCodexIsAuthenticated = await openAiCodexOAuthManager.isAuthenticated()
+	} catch {
+		// Codex OAuth not available
+	}
+
+	return {
+		version,
+		apiConfiguration,
+		currentTaskItem,
+		clineMessages,
+		checkpointManagerErrorMessage,
+		autoApprovalSettings,
+		browserSettings,
+		preferredLanguage,
+		mode,
+		yoloModeToggled,
+		useAutoCondense,
+		subagentsEnabled,
+		userInfo,
+		mcpMarketplaceEnabled,
+		mcpDisplayMode,
+		telemetrySetting,
+		planActSeparateModelsSetting,
+		enableCheckpointsSetting: enableCheckpointsSetting ?? true,
+		platform,
+		environment,
+		distinctId,
+		globalClineRulesToggles: globalClineRulesToggles || {},
+		localClineRulesToggles: localClineRulesToggles || {},
+		localWindsurfRulesToggles: localWindsurfRulesToggles || {},
+		localCursorRulesToggles: localCursorRulesToggles || {},
+		localAgentsRulesToggles: localAgentsRulesToggles || {},
+		localWorkflowToggles: workflowToggles || {},
+		globalWorkflowToggles: globalWorkflowToggles || {},
+		globalSkillsToggles: globalSkillsToggles || {},
+		localSkillsToggles: localSkillsToggles || {},
+		remoteRulesToggles,
+		remoteWorkflowToggles,
+		shellIntegrationTimeout,
+		terminalReuseEnabled,
+		vscodeTerminalExecutionMode,
+		defaultTerminalProfile,
+		isNewUser,
+		welcomeViewCompleted,
+		onboardingModels,
+		mcpResponsesCollapsed,
+		terminalOutputLineLimit,
+		maxConsecutiveMistakes,
+		customPrompt,
+		taskHistory: processedTaskHistory,
+		shouldShowAnnouncement,
+		favoritedModelIds,
+		backgroundCommandRunning: controller.backgroundCommandRunning ?? false,
+		backgroundCommandTaskId: controller.backgroundCommandTaskId,
+		workspaceRoots: controller.workspaceManager?.getRoots?.() ?? [],
+		primaryRootIndex: controller.workspaceManager?.getPrimaryIndex?.() ?? 0,
+		isMultiRootWorkspace: (controller.workspaceManager?.getRoots?.()?.length ?? 0) > 1,
+		multiRootSetting: {
+			user: stateManager.getGlobalStateKey("multiRootEnabled"),
+			featureFlag: true,
+		},
+		clineWebToolsEnabled: {
+			user: stateManager.getGlobalSettingsKey("clineWebToolsEnabled"),
+			featureFlag: featureFlagsService.getWebtoolsEnabled(),
+		},
+		worktreesEnabled: {
+			user: stateManager.getGlobalSettingsKey("worktreesEnabled"),
+			featureFlag: featureFlagsService.getWorktreesEnabled(),
+		},
+		hooksEnabled: getHooksEnabledSafe(stateManager.getGlobalSettingsKey("hooksEnabled")),
+		lastDismissedInfoBannerVersion,
+		lastDismissedModelBannerVersion,
+		remoteConfigSettings: stateManager.getRemoteConfigSettings?.(),
+		lastDismissedCliBannerVersion,
+		dismissedBanners,
+		nativeToolCallSetting: stateManager.getGlobalStateKey("nativeToolCallEnabled"),
+		enableParallelToolCalling: stateManager.getGlobalSettingsKey("enableParallelToolCalling"),
+		backgroundEditEnabled: stateManager.getGlobalSettingsKey("backgroundEditEnabled"),
+		optOutOfRemoteConfig: stateManager.getGlobalSettingsKey("optOutOfRemoteConfig"),
+		doubleCheckCompletionEnabled,
+		showFeatureTips,
+		banners,
+		welcomeBanners,
+		openAiCodexIsAuthenticated,
+	} as ExtensionState
+}

src/core/controller/state/updateSettings.ts

@@ -7,9 +7,7 @@ import { TelemetrySetting } from "@shared/TelemetrySetting"
 import { ClineEnv } from "@/config"
 import { fetchRemoteConfig } from "@/core/storage/remote-config/fetch"
 import { clearRemoteConfig } from "@/core/storage/remote-config/utils"
-import { HostProvider } from "@/hosts/host-provider"
 import { McpDisplayMode } from "@/shared/McpDisplayMode"
-import { ShowMessageType } from "@/shared/proto/host/window"
 import { Logger } from "@/shared/services/Logger"
 import { telemetryService } from "../../../services/telemetry"
 import { BrowserSettings as SharedBrowserSettings } from "../../../shared/BrowserSettings"
@@ -24,7 +22,7 @@ import { accountLogoutClicked } from "../account/accountLogoutClicked"
  */
 export async function updateSettings(controller: Controller, request: UpdateSettingsRequest): Promise<Empty> {
 	try {
-		if (request.clineEnv !== undefined) {
+		if (request.clineEnv !== undefined && request.clineEnv !== "") {
 			ClineEnv.setEnvironment(request.clineEnv)
 			await accountLogoutClicked(controller, Empty.create())
 		}
@@ -109,16 +107,19 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 		// Update terminal timeout setting
 		if (request.shellIntegrationTimeout !== undefined) {
 			controller.stateManager.setGlobalState("shellIntegrationTimeout", Number(request.shellIntegrationTimeout))
+			controller.terminalManager?.setShellIntegrationTimeout(Number(request.shellIntegrationTimeout))
 		}
 
 		// Update terminal reuse setting
 		if (request.terminalReuseEnabled !== undefined) {
 			controller.stateManager.setGlobalState("terminalReuseEnabled", request.terminalReuseEnabled)
+			controller.terminalManager?.setTerminalReuseEnabled(!!request.terminalReuseEnabled)
 		}
 
 		// Update terminal output line limit
 		if (request.terminalOutputLineLimit !== undefined) {
 			controller.stateManager.setGlobalState("terminalOutputLineLimit", Number(request.terminalOutputLineLimit))
+			controller.terminalManager?.setTerminalOutputLineLimit(Number(request.terminalOutputLineLimit))
 		}
 
 		if (request.vscodeTerminalExecutionMode !== undefined && request.vscodeTerminalExecutionMode !== "") {
@@ -133,11 +134,6 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			controller.stateManager.setGlobalState("maxConsecutiveMistakes", Number(request.maxConsecutiveMistakes))
 		}
 
-		// Update strict plan mode setting
-		if (request.strictPlanModeEnabled !== undefined) {
-			controller.stateManager.setGlobalState("strictPlanModeEnabled", request.strictPlanModeEnabled)
-		}
-
 		if (request.hooksEnabled !== undefined) {
 			const wasEnabled = controller.stateManager.getGlobalSettingsKey("hooksEnabled") ?? true
 			const isEnabled = !!request.hooksEnabled
@@ -191,26 +187,6 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			controller.stateManager.setGlobalState("useAutoCondense", request.useAutoCondense)
 		}
 
-		// Update focus chain settings
-		if (request.focusChainSettings !== undefined) {
-			{
-				const currentSettings = controller.stateManager.getGlobalSettingsKey("focusChainSettings")
-				const wasEnabled = currentSettings?.enabled ?? false
-				const isEnabled = request.focusChainSettings.enabled
-
-				const focusChainSettings = {
-					enabled: isEnabled,
-					remindClineInterval: request.focusChainSettings.remindClineInterval,
-				}
-				controller.stateManager.setGlobalState("focusChainSettings", focusChainSettings)
-
-				// Capture telemetry when setting changes
-				if (wasEnabled !== isEnabled) {
-					telemetryService.captureFocusChainToggle(isEnabled)
-				}
-			}
-		}
-
 		// Update custom prompt choice
 		if (request.customPrompt !== undefined) {
 			const value = request.customPrompt === "compact" ? "compact" : undefined
@@ -259,42 +235,11 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 
 		// Update default terminal profile
 		if (request.defaultTerminalProfile !== undefined) {
-			const profileId = request.defaultTerminalProfile
-
-			// Update the terminal profile in the state
-			controller.stateManager.setGlobalState("defaultTerminalProfile", profileId)
-
-			let closedCount = 0
-			let busyTerminalsCount = 0
-
-			// Update the terminal manager of the current task if it exists
-			if (controller.task) {
-				// Call the updated setDefaultTerminalProfile method that returns closed terminal info
-				// Use `as any` to handle type incompatibility between VSCode's TerminalInfo and standalone TerminalInfo
-				const result = controller.task.terminalManager.setDefaultTerminalProfile(profileId) as any
-				closedCount = result.closedCount
-				busyTerminalsCount = result.busyTerminals?.length ?? 0
-
-				// Show information message if terminals were closed
-				if (closedCount > 0) {
-					const message = `Closed ${closedCount} ${closedCount === 1 ? "terminal" : "terminals"} with different profile.`
-					HostProvider.window.showMessage({
-						type: ShowMessageType.INFORMATION,
-						message,
-					})
-				}
-
-				// Show warning if there are busy terminals that couldn't be closed
-				if (busyTerminalsCount > 0) {
-					const message =
-						`${busyTerminalsCount} busy ${busyTerminalsCount === 1 ? "terminal has" : "terminals have"} a different profile. ` +
-						`Close ${busyTerminalsCount === 1 ? "it" : "them"} to use the new profile for all commands.`
-					HostProvider.window.showMessage({
-						type: ShowMessageType.WARNING,
-						message,
-					})
-				}
-			}
+			controller.stateManager.setGlobalState("defaultTerminalProfile", request.defaultTerminalProfile)
+			// Update the live terminal manager so new terminals use the new profile.
+			// Existing terminals are left open — they're keyed by effective shell
+			// and reused when compatible, or skipped when not.
+			controller.terminalManager?.setDefaultTerminalProfile(request.defaultTerminalProfile)
 		}
 
 		if (request.backgroundEditEnabled !== undefined) {
@@ -344,10 +289,6 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			controller.stateManager.setGlobalState("doubleCheckCompletionEnabled", request.doubleCheckCompletionEnabled)
 		}
 
-		if (request.lazyTeammateModeEnabled !== undefined) {
-			controller.stateManager.setGlobalState("lazyTeammateModeEnabled", request.lazyTeammateModeEnabled)
-		}
-
 		if (request.showFeatureTips !== undefined) {
 			controller.stateManager.setGlobalState("showFeatureTips", request.showFeatureTips)
 		}

src/core/controller/state/updateSettingsCli.ts

@@ -6,8 +6,6 @@ import { convertProtoToApiProvider } from "@shared/proto-conversions/models/api-
 import { Settings } from "@shared/storage/state-keys"
 import { TelemetrySetting } from "@shared/TelemetrySetting"
 import { ClineEnv } from "@/config"
-import { HostProvider } from "@/hosts/host-provider"
-import { ShowMessageType } from "@/shared/proto/host/window"
 import { Logger } from "@/shared/services/Logger"
 import { Mode } from "@/shared/storage/types"
 import { telemetryService } from "../../../services/telemetry"
@@ -26,262 +24,201 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 		return mode === PlanActMode.PLAN ? "plan" : "act"
 	}
 
-	try {
-		if (request.environment !== undefined) {
-			ClineEnv.setEnvironment(request.environment)
-			await accountLogoutClicked(controller, Empty.create())
-		}
-
-		if (request.settings) {
-			// Extract all special case fields that need dedicated handlers
-			// These should NOT be included in the batch update
-			const {
-				// Fields requiring conversion
-				autoApprovalSettings,
-				planModeReasoningEffort,
-				actModeReasoningEffort,
-				mode,
-				customPrompt,
-				planModeApiProvider,
-				actModeApiProvider,
-				// Fields requiring special logic (telemetry, merging, etc.)
-				telemetrySetting,
-				yoloModeToggled,
-				useAutoCondense,
-				clineWebToolsEnabled,
-				worktreesEnabled,
-				subagentsEnabled,
-				focusChainSettings,
-				browserSettings,
-				defaultTerminalProfile,
-				...simpleSettings
-			} = request.settings
-
-			// Batch update for simple pass-through fields
-			const filteredSettings: Partial<Settings> = Object.fromEntries(
-				Object.entries(simpleSettings).filter(([key, value]) => key !== "openaiReasoningEffort" && value !== undefined),
-			)
-
-			controller.stateManager.setGlobalStateBatch(filteredSettings)
-
-			Logger.log("autoApprovalSettings", controller.stateManager.getGlobalSettingsKey("autoApprovalSettings"))
-
-			// Handle fields requiring type conversion from generated protobuf types to application types
-			if (autoApprovalSettings) {
-				// Merge with current settings to preserve unspecified fields
-				const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
-				const mergedSettings = {
-					...currentAutoApprovalSettings,
-					...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
-					...(autoApprovalSettings.enableNotifications !== undefined && {
-						enableNotifications: autoApprovalSettings.enableNotifications,
-					}),
-					actions: {
-						...currentAutoApprovalSettings.actions,
-						...(autoApprovalSettings.actions
-							? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
-							: {}),
-					},
-				}
-
-				controller.stateManager.setGlobalState("autoApprovalSettings", mergedSettings)
-			}
-
-			if (planModeReasoningEffort !== undefined) {
-				const converted = normalizeOpenaiReasoningEffort(planModeReasoningEffort)
-				controller.stateManager.setGlobalState("planModeReasoningEffort", converted)
-			}
-
-			if (actModeReasoningEffort !== undefined) {
-				const converted = normalizeOpenaiReasoningEffort(actModeReasoningEffort)
-				controller.stateManager.setGlobalState("actModeReasoningEffort", converted)
-			}
-
-			if (mode !== undefined) {
-				const converted = convertPlanActMode(mode)
-				controller.stateManager.setGlobalState("mode", converted)
-			}
-
-			if (customPrompt === "compact") {
-				controller.stateManager.setGlobalState("customPrompt", "compact")
-			}
-
-			if (planModeApiProvider !== undefined) {
-				const converted = convertProtoToApiProvider(planModeApiProvider)
-				controller.stateManager.setGlobalState("planModeApiProvider", converted)
-			}
-
-			if (actModeApiProvider !== undefined) {
-				const converted = convertProtoToApiProvider(actModeApiProvider)
-				controller.stateManager.setGlobalState("actModeApiProvider", converted)
-			}
-
-			if (controller.task) {
-				const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
-				const apiConfigForHandler = {
-					...controller.stateManager.getApiConfiguration(),
-					ulid: controller.task.ulid,
-				}
-				controller.task.api = buildApiHandler(apiConfigForHandler, currentMode)
-			}
-
-			// Update telemetry setting
-			if (telemetrySetting) {
-				await controller.updateTelemetrySetting(telemetrySetting as TelemetrySetting)
-			}
-
-			// Update yolo mode setting (requires telemetry)
-			if (yoloModeToggled !== undefined) {
-				if (controller.task) {
-					telemetryService.captureYoloModeToggle(controller.task.ulid, yoloModeToggled)
-				}
-				controller.stateManager.setGlobalState("yoloModeToggled", yoloModeToggled)
-			}
-
-			// Update auto-condense setting (requires telemetry)
-			if (useAutoCondense !== undefined) {
-				if (controller.task) {
-					telemetryService.captureAutoCondenseToggle(
-						controller.task.ulid,
-						useAutoCondense,
-						controller.task.api.getModel().id,
-					)
-				}
-				controller.stateManager.setGlobalState("useAutoCondense", useAutoCondense)
-			}
-
-			// Update Cline web tools setting (requires telemetry)
-			if (clineWebToolsEnabled !== undefined) {
-				if (controller.task) {
-					telemetryService.captureClineWebToolsToggle(controller.task.ulid, clineWebToolsEnabled)
-				}
-				controller.stateManager.setGlobalState("clineWebToolsEnabled", clineWebToolsEnabled)
-			}
-
-			// Update worktrees setting
-			if (worktreesEnabled !== undefined) {
-				controller.stateManager.setGlobalState("worktreesEnabled", worktreesEnabled)
-			}
-
-			// Update subagents setting (requires telemetry on state change)
-			if (subagentsEnabled !== undefined) {
-				const wasEnabled = controller.stateManager.getGlobalSettingsKey("subagentsEnabled") ?? false
-				const isEnabled = !!subagentsEnabled
-				controller.stateManager.setGlobalState("subagentsEnabled", isEnabled)
-
-				if (wasEnabled !== isEnabled) {
-					telemetryService.captureSubagentToggle(isEnabled)
-				}
-			}
-
-			// Update focus chain settings (requires telemetry on state change)
-			if (focusChainSettings !== undefined) {
-				const currentSettings = controller.stateManager.getGlobalSettingsKey("focusChainSettings")
-				const wasEnabled = currentSettings?.enabled ?? false
-				const isEnabled = focusChainSettings.enabled
-
-				const newFocusChainSettings = {
-					enabled: isEnabled,
-					remindClineInterval: focusChainSettings.remindClineInterval,
-				}
-				controller.stateManager.setGlobalState("focusChainSettings", newFocusChainSettings)
-
-				// Capture telemetry when setting changes
-				if (wasEnabled !== isEnabled) {
-					telemetryService.captureFocusChainToggle(isEnabled)
-				}
-			}
-
-			// Update browser settings (requires careful merging to avoid protobuf defaults)
-			if (browserSettings !== undefined) {
-				const currentSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
-
-				const newBrowserSettings = {
-					...currentSettings,
-					viewport: {
-						width: browserSettings.viewport?.width || currentSettings.viewport.width,
-						height: browserSettings.viewport?.height || currentSettings.viewport.height,
-					},
-					...(browserSettings.remoteBrowserEnabled !== undefined && {
-						remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
-					}),
-					...(browserSettings.remoteBrowserHost !== undefined && {
-						remoteBrowserHost: browserSettings.remoteBrowserHost,
-					}),
-					...(browserSettings.chromeExecutablePath !== undefined && {
-						chromeExecutablePath: browserSettings.chromeExecutablePath,
-					}),
-					...(browserSettings.disableToolUse !== undefined && {
-						disableToolUse: browserSettings.disableToolUse,
-					}),
-					...(browserSettings.customArgs !== undefined && {
-						customArgs: browserSettings.customArgs,
-					}),
-				}
-
-				controller.stateManager.setGlobalState("browserSettings", newBrowserSettings)
-			}
-
-			// Update default terminal profile (requires terminal manager updates and notifications)
-			if (defaultTerminalProfile !== undefined && defaultTerminalProfile !== "") {
-				const profileId = defaultTerminalProfile
-
-				// Update the terminal profile in the state
-				controller.stateManager.setGlobalState("defaultTerminalProfile", profileId)
-
-				let closedCount = 0
-				let busyTerminalsCount = 0
-
-				// Update the terminal manager of the current task if it exists
-				if (controller.task) {
-					// Terminal manager must exist when task is active
-					if (!controller.task.terminalManager) {
-						throw new Error("Cannot update terminal profile: Terminal manager missing from active task")
-					}
-
-					// Call the updated setDefaultTerminalProfile method that returns closed terminal info
-					// Use `as any` to handle type incompatibility between VSCode's TerminalInfo and standalone TerminalInfo
-					const result = controller.task.terminalManager.setDefaultTerminalProfile(profileId) as any
-					closedCount = result.closedCount
-					busyTerminalsCount = result.busyTerminals?.length ?? 0
-
-					// Show information message if terminals were closed
-					if (closedCount > 0) {
-						const message = `Closed ${closedCount} ${closedCount === 1 ? "terminal" : "terminals"} with different profile.`
-						HostProvider.window.showMessage({
-							type: ShowMessageType.INFORMATION,
-							message,
-						})
-					}
-
-					// Show warning if there are busy terminals that couldn't be closed
-					if (busyTerminalsCount > 0) {
-						const message =
-							`${busyTerminalsCount} busy ${busyTerminalsCount === 1 ? "terminal has" : "terminals have"} a different profile. ` +
-							`Close ${busyTerminalsCount === 1 ? "it" : "them"} to use the new profile for all commands.`
-						HostProvider.window.showMessage({
-							type: ShowMessageType.WARNING,
-							message,
-						})
-					}
-				}
-			}
-		}
-
-		// Handle secrets updates
-		if (request.secrets) {
-			const filteredSecrets = Object.fromEntries(
-				Object.entries(request.secrets).filter(([_, value]) => value !== undefined),
-			)
-
-			controller.stateManager.setSecretsBatch(filteredSecrets)
-		}
-
-		// Post updated state to webview
-		await controller.postStateToWebview()
-
-		return Empty.create()
-	} catch (error) {
-		throw error
+	if (request.environment !== undefined) {
+		ClineEnv.setEnvironment(request.environment)
+		await accountLogoutClicked(controller, Empty.create())
 	}
+
+	if (request.settings) {
+		// Extract all special case fields that need dedicated handlers
+		// These should NOT be included in the batch update
+		const {
+			// Fields requiring conversion
+			autoApprovalSettings,
+			planModeReasoningEffort,
+			actModeReasoningEffort,
+			mode,
+			customPrompt,
+			planModeApiProvider,
+			actModeApiProvider,
+			// Fields requiring special logic (telemetry, merging, etc.)
+			telemetrySetting,
+			yoloModeToggled,
+			useAutoCondense,
+			clineWebToolsEnabled,
+			worktreesEnabled,
+			subagentsEnabled,
+			browserSettings,
+			defaultTerminalProfile,
+			...simpleSettings
+		} = request.settings
+
+		// Batch update for simple pass-through fields
+		const filteredSettings: Partial<Settings> = Object.fromEntries(
+			Object.entries(simpleSettings).filter(([key, value]) => key !== "openaiReasoningEffort" && value !== undefined),
+		)
+
+		controller.stateManager.setGlobalStateBatch(filteredSettings)
+
+		Logger.log("autoApprovalSettings", controller.stateManager.getGlobalSettingsKey("autoApprovalSettings"))
+
+		// Handle fields requiring type conversion from generated protobuf types to application types
+		if (autoApprovalSettings) {
+			// Merge with current settings to preserve unspecified fields
+			const currentAutoApprovalSettings = controller.stateManager.getGlobalSettingsKey("autoApprovalSettings")
+			const mergedSettings = {
+				...currentAutoApprovalSettings,
+				...(autoApprovalSettings.version !== undefined && { version: autoApprovalSettings.version }),
+				...(autoApprovalSettings.enableNotifications !== undefined && {
+					enableNotifications: autoApprovalSettings.enableNotifications,
+				}),
+				actions: {
+					...currentAutoApprovalSettings.actions,
+					...(autoApprovalSettings.actions
+						? Object.fromEntries(Object.entries(autoApprovalSettings.actions).filter(([_, v]) => v !== undefined))
+						: {}),
+				},
+			}
+
+			controller.stateManager.setGlobalState("autoApprovalSettings", mergedSettings)
+		}
+
+		if (planModeReasoningEffort !== undefined) {
+			const converted = normalizeOpenaiReasoningEffort(planModeReasoningEffort)
+			controller.stateManager.setGlobalState("planModeReasoningEffort", converted)
+		}
+
+		if (actModeReasoningEffort !== undefined) {
+			const converted = normalizeOpenaiReasoningEffort(actModeReasoningEffort)
+			controller.stateManager.setGlobalState("actModeReasoningEffort", converted)
+		}
+
+		if (mode !== undefined) {
+			const converted = convertPlanActMode(mode)
+			controller.stateManager.setGlobalState("mode", converted)
+		}
+
+		if (customPrompt === "compact") {
+			controller.stateManager.setGlobalState("customPrompt", "compact")
+		}
+
+		if (planModeApiProvider !== undefined) {
+			const converted = convertProtoToApiProvider(planModeApiProvider)
+			controller.stateManager.setGlobalState("planModeApiProvider", converted)
+		}
+
+		if (actModeApiProvider !== undefined) {
+			const converted = convertProtoToApiProvider(actModeApiProvider)
+			controller.stateManager.setGlobalState("actModeApiProvider", converted)
+		}
+
+		if (controller.task) {
+			const currentMode = controller.stateManager.getGlobalSettingsKey("mode")
+			const apiConfigForHandler = {
+				...controller.stateManager.getApiConfiguration(),
+				ulid: controller.task.ulid,
+			}
+			controller.task.api = buildApiHandler(apiConfigForHandler, currentMode)
+		}
+
+		// Update telemetry setting
+		if (telemetrySetting) {
+			await controller.updateTelemetrySetting(telemetrySetting as TelemetrySetting)
+		}
+
+		// Update yolo mode setting (requires telemetry)
+		if (yoloModeToggled !== undefined) {
+			if (controller.task) {
+				telemetryService.captureYoloModeToggle(controller.task.ulid, yoloModeToggled)
+			}
+			controller.stateManager.setGlobalState("yoloModeToggled", yoloModeToggled)
+		}
+
+		// Update auto-condense setting (requires telemetry)
+		if (useAutoCondense !== undefined) {
+			if (controller.task) {
+				telemetryService.captureAutoCondenseToggle(
+					controller.task.ulid,
+					useAutoCondense,
+					controller.task.api.getModel().id,
+				)
+			}
+			controller.stateManager.setGlobalState("useAutoCondense", useAutoCondense)
+		}
+
+		// Update Cline web tools setting (requires telemetry)
+		if (clineWebToolsEnabled !== undefined) {
+			if (controller.task) {
+				telemetryService.captureClineWebToolsToggle(controller.task.ulid, clineWebToolsEnabled)
+			}
+			controller.stateManager.setGlobalState("clineWebToolsEnabled", clineWebToolsEnabled)
+		}
+
+		// Update worktrees setting
+		if (worktreesEnabled !== undefined) {
+			controller.stateManager.setGlobalState("worktreesEnabled", worktreesEnabled)
+		}
+
+		// Update subagents setting (requires telemetry on state change)
+		if (subagentsEnabled !== undefined) {
+			const wasEnabled = controller.stateManager.getGlobalSettingsKey("subagentsEnabled") ?? false
+			const isEnabled = !!subagentsEnabled
+			controller.stateManager.setGlobalState("subagentsEnabled", isEnabled)
+
+			if (wasEnabled !== isEnabled) {
+				telemetryService.captureSubagentToggle(isEnabled)
+			}
+		}
+
+		// Update browser settings (requires careful merging to avoid protobuf defaults)
+		if (browserSettings !== undefined) {
+			const currentSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
+
+			const newBrowserSettings = {
+				...currentSettings,
+				viewport: {
+					width: browserSettings.viewport?.width || currentSettings.viewport.width,
+					height: browserSettings.viewport?.height || currentSettings.viewport.height,
+				},
+				...(browserSettings.remoteBrowserEnabled !== undefined && {
+					remoteBrowserEnabled: browserSettings.remoteBrowserEnabled,
+				}),
+				...(browserSettings.remoteBrowserHost !== undefined && {
+					remoteBrowserHost: browserSettings.remoteBrowserHost,
+				}),
+				...(browserSettings.chromeExecutablePath !== undefined && {
+					chromeExecutablePath: browserSettings.chromeExecutablePath,
+				}),
+				...(browserSettings.disableToolUse !== undefined && {
+					disableToolUse: browserSettings.disableToolUse,
+				}),
+				...(browserSettings.customArgs !== undefined && {
+					customArgs: browserSettings.customArgs,
+				}),
+			}
+
+			controller.stateManager.setGlobalState("browserSettings", newBrowserSettings)
+		}
+
+		// Update default terminal profile
+		if (defaultTerminalProfile !== undefined && defaultTerminalProfile !== "") {
+			controller.stateManager.setGlobalState("defaultTerminalProfile", defaultTerminalProfile)
+			// Update the live terminal manager so new terminals use the new profile.
+			// Existing terminals are left open — they're keyed by effective shell
+			// and reused when compatible, or skipped when not.
+			controller.terminalManager?.setDefaultTerminalProfile(defaultTerminalProfile)
+		}
+	}
+
+	// Handle secrets updates
+	if (request.secrets) {
+		const filteredSecrets = Object.fromEntries(Object.entries(request.secrets).filter(([_, value]) => value !== undefined))
+
+		controller.stateManager.setSecretsBatch(filteredSecrets)
+	}
+
+	// Post updated state to webview
+	await controller.postStateToWebview()
+
+	return Empty.create()
 }

src/core/controller/task/clearTask.ts

@@ -1,4 +1,5 @@
 import { Empty, EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
 import { Controller } from ".."
 
 /**
@@ -8,8 +9,17 @@ import { Controller } from ".."
  * @returns Empty response
  */
 export async function clearTask(controller: Controller, _request: EmptyRequest): Promise<Empty> {
-	// clearTask is called here when the user closes the task
+	const startedAt = Date.now()
 	await controller.clearTask()
+	const afterClearTask = Date.now()
 	await controller.postStateToWebview()
+	const totalElapsed = Date.now() - startedAt
+
+	if (totalElapsed > 250) {
+		Logger.warn(
+			`[TaskService.clearTask] took ${totalElapsed}ms (controller.clearTask=${afterClearTask - startedAt}ms, postStateToWebview=${Date.now() - afterClearTask}ms)`,
+		)
+	}
+
 	return Empty.create()
 }

src/core/controller/task/deleteAllTaskHistory.ts

@@ -1,10 +1,5 @@
 import { DeleteAllTaskHistoryCount } from "@shared/proto/cline/task"
-import fs from "fs/promises"
-import path from "path"
-import { HostProvider } from "@/hosts/host-provider"
-import { ShowMessageRequest, ShowMessageType } from "@/shared/proto/host/window"
 import { Logger } from "@/shared/services/Logger"
-import { fileExistsAtPath } from "../../../utils/fs"
 import { Controller } from ".."
 
 /**
@@ -15,141 +10,9 @@ import { Controller } from ".."
  */
 export async function deleteAllTaskHistory(controller: Controller): Promise<DeleteAllTaskHistoryCount> {
 	try {
-		// Clear current task first
-		await controller.clearTask()
-
-		// Get existing task history
-		const taskHistory = controller.stateManager.getGlobalStateKey("taskHistory")
-		const totalTasks = taskHistory.length
-
-		const userChoice = (
-			await HostProvider.window.showMessage(
-				ShowMessageRequest.create({
-					type: ShowMessageType.WARNING,
-					message: "What would you like to delete?",
-					options: {
-						modal: true,
-						items: ["Delete All Except Favorites", "Delete Everything"],
-					},
-				}),
-			)
-		).selectedOption
-
-		// 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 (userChoice === "Delete All Except Favorites") {
-			const favoritedTasks = taskHistory.filter((task) => task.isFavorited === true)
-
-			// If there are favorited tasks, update state
-			if (favoritedTasks.length > 0) {
-				controller.stateManager.setGlobalState("taskHistory", favoritedTasks)
-
-				// Delete non-favorited task directories
-				const preserveTaskIds = favoritedTasks.map((task) => task.id)
-				await cleanupTaskFiles(preserveTaskIds)
-
-				// Update webview
-				try {
-					await controller.postStateToWebview()
-				} catch (webviewErr) {
-					Logger.error("Error posting to webview:", webviewErr)
-				}
-
-				return DeleteAllTaskHistoryCount.create({
-					tasksDeleted: totalTasks - favoritedTasks.length,
-				})
-			} else {
-				// No favorited tasks found - show warning and ask user what to do
-				const answer = (
-					await HostProvider.window.showMessage({
-						type: ShowMessageType.WARNING,
-						message: "No favorited tasks found. Would you like to delete all tasks anyway?",
-						options: {
-							modal: true,
-							items: ["Delete All Tasks"],
-						},
-					})
-				).selectedOption
-
-				// 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
-			}
-		}
-
-		// Delete everything (not preserving favorites)
-		controller.stateManager.setGlobalState("taskHistory", [])
-
-		try {
-			// Remove all contents of tasks directory
-			const taskDirPath = path.join(HostProvider.get().globalStorageFsPath, "tasks")
-			if (await fileExistsAtPath(taskDirPath)) {
-				await fs.rm(taskDirPath, { recursive: true, force: true })
-			}
-
-			// Remove checkpoints directory contents
-			const checkpointsDirPath = path.join(HostProvider.get().globalStorageFsPath, "checkpoints")
-			if (await fileExistsAtPath(checkpointsDirPath)) {
-				await fs.rm(checkpointsDirPath, { recursive: true, force: true })
-			}
-		} catch (error) {
-			HostProvider.window.showMessage({
-				type: ShowMessageType.ERROR,
-				message: `Encountered error while deleting task history, there may be some files left behind. Error: ${error instanceof Error ? error.message : String(error)}`,
-			})
-		}
-
-		// Update webview
-		try {
-			await controller.postStateToWebview()
-		} catch (webviewErr) {
-			Logger.error("Error posting to webview:", webviewErr)
-		}
-
-		return DeleteAllTaskHistoryCount.create({
-			tasksDeleted: totalTasks,
-		})
+		return await controller.deleteAllTaskHistory()
 	} catch (error) {
 		Logger.error("Error in deleteAllTaskHistory:", error)
 		throw error
 	}
 }
-
-/**
- * Helper function to cleanup task files while preserving specified tasks
- */
-async function cleanupTaskFiles(preserveTaskIds: string[]) {
-	const taskDirPath = path.join(HostProvider.get().globalStorageFsPath, "tasks")
-
-	try {
-		if (await fileExistsAtPath(taskDirPath)) {
-			const taskDirs = await fs.readdir(taskDirPath)
-			Logger.debug(`[cleanupTaskFiles] Found ${taskDirs.length} task directories`)
-
-			// Delete only non-preserved task directories
-			for (const dir of taskDirs) {
-				if (!preserveTaskIds.includes(dir)) {
-					// Task dir path is not workspace specific
-					await fs.rm(path.join(taskDirPath, dir), {
-						recursive: true,
-						force: true,
-					})
-				}
-			}
-		}
-	} catch (error) {
-		Logger.error("Error cleaning up task files:", error)
-	}
-
-	return true
-}

src/core/controller/task/deleteTasksWithIds.ts

@@ -1,10 +1,7 @@
 import { Empty, StringArrayRequest } from "@shared/proto/cline/common"
-import fs from "fs/promises"
-import path from "path"
 import { HostProvider } from "@/hosts/host-provider"
 import { ShowMessageType } from "@/shared/proto/host/window"
 import { Logger } from "@/shared/services/Logger"
-import { fileExistsAtPath } from "../../../utils/fs"
 import { Controller } from ".."
 
 /**
@@ -48,54 +45,16 @@ export async function deleteTasksWithIds(controller: Controller, request: String
  * @param id The task ID to delete
  */
 async function deleteTaskWithId(controller: Controller, id: string): Promise<void> {
-	try {
-		// Clear current task if it matches the ID being deleted
-		if (id === controller.task?.taskId) {
-			await controller.clearTask()
-			Logger.debug("cleared task")
-		}
-
-		// Get task file paths
-		const { taskDirPath, apiConversationHistoryFilePath, uiMessagesFilePath, contextHistoryFilePath, taskMetadataFilePath } =
-			await controller.getTaskWithId(id)
-
-		// Remove task from state
-		const updatedTaskHistory = await controller.deleteTaskFromState(id)
-
-		// Delete the task files
-		for (const filePath of [
-			apiConversationHistoryFilePath,
-			uiMessagesFilePath,
-			contextHistoryFilePath,
-			taskMetadataFilePath,
-		]) {
-			await fs.rm(filePath, { force: true })
-		}
-
-		// Remove empty task directory
-		try {
-			await fs.rmdir(taskDirPath) // succeeds if the dir is empty
-		} catch (error) {
-			Logger.debug("Could not remove task directory (may not be empty):", error)
-		}
-
-		// If no tasks remain, clean up everything
-		if (updatedTaskHistory.length === 0) {
-			const taskDirPath = path.join(HostProvider.get().globalStorageFsPath, "tasks")
-			const checkpointsDirPath = path.join(HostProvider.get().globalStorageFsPath, "checkpoints")
-
-			if (await fileExistsAtPath(taskDirPath)) {
-				await fs.rm(taskDirPath, { recursive: true, force: true })
-			}
-			if (await fileExistsAtPath(checkpointsDirPath)) {
-				await fs.rm(checkpointsDirPath, { recursive: true, force: true })
-			}
-		}
-	} catch (error) {
-		Logger.debug(`Error deleting task ${id}:`, error)
-		throw error // Re-throw to let caller handle the error
+	// Clear current task if it matches the ID being deleted
+	if (id === controller.task?.taskId) {
+		await controller.clearTask()
+		Logger.debug("cleared task")
 	}
 
-	// Update webview state
+	// Remove task from state FIRST — this updates the in-memory cache
+	// immediately so the next postStateToWebview() sends the updated list.
+	await controller.deleteTaskFromState(id)
+
+	// Always update webview state so the history list and recents refresh
 	await controller.postStateToWebview()
 }

src/core/controller/task/getTaskHistory.ts

@@ -1,116 +1,17 @@
 import { GetTaskHistoryRequest, TaskHistoryArray } from "@shared/proto/cline/task"
 import { Logger } from "@/shared/services/Logger"
-import { arePathsEqual, getWorkspacePath } from "../../../utils/path"
 import { Controller } from ".."
 
 /**
- * Gets filtered task history
+ * Gets filtered task history.
+ * Task history retrieval/filtering is delegated to the SDK-backed controller.
  * @param controller The controller instance
  * @param request Filter parameters for task history
  * @returns TaskHistoryArray with filtered task list
  */
 export async function getTaskHistory(controller: Controller, request: GetTaskHistoryRequest): Promise<TaskHistoryArray> {
 	try {
-		const { favoritesOnly, currentWorkspaceOnly, searchQuery, sortBy } = request
-
-		// Get task history from global state
-		const taskHistory = controller.stateManager.getGlobalStateKey("taskHistory")
-		const workspacePath = await getWorkspacePath()
-
-		// Apply filters
-		let filteredTasks = taskHistory.filter((item) => {
-			// Basic filter: must have timestamp and task content
-			const hasRequiredFields = item.ts && item.task
-			if (!hasRequiredFields) {
-				return false
-			}
-
-			// Apply favorites filter if requested
-			if (favoritesOnly && !item.isFavorited) {
-				return false
-			}
-
-			// Apply current workspace filter if requested
-			if (currentWorkspaceOnly) {
-				let isInWorkspace = false
-
-				// First check the cwdOnTaskInitialization property - Only present on tasks from this change forward
-				if (item.cwdOnTaskInitialization) {
-					if (arePathsEqual(item.cwdOnTaskInitialization, workspacePath)) {
-						isInWorkspace = true
-					}
-				}
-
-				// For tasks without cwdOnTaskInitialization, check the older shadowGitConfigWorkTree property
-				if (!isInWorkspace && item.shadowGitConfigWorkTree) {
-					if (arePathsEqual(item.shadowGitConfigWorkTree, workspacePath)) {
-						isInWorkspace = true
-					}
-				}
-
-				if (!isInWorkspace) {
-					return false
-				}
-			}
-
-			return true
-		})
-
-		// Apply search if provided
-		if (searchQuery) {
-			// Simple search implementation
-			const query = searchQuery.toLowerCase()
-			filteredTasks = filteredTasks.filter((item) => item.task.toLowerCase().includes(query))
-		}
-
-		// Calculate total count before sorting
-		const totalCount = filteredTasks.length
-
-		// Apply sorting
-		if (sortBy) {
-			filteredTasks.sort((a, b) => {
-				switch (sortBy) {
-					case "oldest":
-						return a.ts - b.ts
-					case "mostExpensive":
-						return (b.totalCost || 0) - (a.totalCost || 0)
-					case "mostTokens":
-						return (
-							(b.tokensIn || 0) +
-							(b.tokensOut || 0) +
-							(b.cacheWrites || 0) +
-							(b.cacheReads || 0) -
-							((a.tokensIn || 0) + (a.tokensOut || 0) + (a.cacheWrites || 0) + (a.cacheReads || 0))
-						)
-					case "newest":
-					default:
-						return b.ts - a.ts
-				}
-			})
-		} else {
-			// Default sort by newest
-			filteredTasks.sort((a, b) => b.ts - a.ts)
-		}
-
-		// Map to response format
-		const tasks = filteredTasks.map((item) => ({
-			id: item.id,
-			task: item.task,
-			ts: item.ts,
-			isFavorited: item.isFavorited || false,
-			size: item.size || 0,
-			totalCost: item.totalCost || 0,
-			tokensIn: item.tokensIn || 0,
-			tokensOut: item.tokensOut || 0,
-			cacheWrites: item.cacheWrites || 0,
-			cacheReads: item.cacheReads || 0,
-			modelId: item.modelId || "",
-		}))
-
-		return TaskHistoryArray.create({
-			tasks,
-			totalCount,
-		})
+		return await controller.getTaskHistory(request)
 	} catch (error) {
 		Logger.error("Error in getTaskHistory:", error)
 		throw error

src/core/controller/task/showTaskWithId.ts

@@ -5,63 +5,14 @@ import { Controller } from ".."
 import { sendChatButtonClickedEvent } from "../ui/subscribeToChatButtonClicked"
 
 /**
- * Shows a task with the specified ID
- * @param controller The controller instance
- * @param request The request containing the task ID
- * @returns TaskResponse with task details
+ * Shows a task with the specified ID by loading its messages from disk.
+ * Task lookup/loading is delegated to the SDK-backed controller.
  */
 export async function showTaskWithId(controller: Controller, request: StringRequest): Promise<TaskResponse> {
 	try {
-		const id = request.value
-
-		// First check if task exists in global state for faster access
-		const taskHistory = controller.stateManager.getGlobalStateKey("taskHistory")
-		const historyItem = taskHistory.find((item) => item.id === id)
-
-		// We need to initialize the task before returning data
-		if (historyItem) {
-			// Always initialize the task with the history item
-			await controller.initTask(undefined, undefined, undefined, historyItem)
-
-			// Send UI update to show the chat view
-			await sendChatButtonClickedEvent()
-
-			// Return task data for gRPC response
-			return TaskResponse.create({
-				id: historyItem.id,
-				task: historyItem.task || "",
-				ts: historyItem.ts || 0,
-				isFavorited: historyItem.isFavorited || false,
-				size: historyItem.size || 0,
-				totalCost: historyItem.totalCost || 0,
-				tokensIn: historyItem.tokensIn || 0,
-				tokensOut: historyItem.tokensOut || 0,
-				cacheWrites: historyItem.cacheWrites || 0,
-				cacheReads: historyItem.cacheReads || 0,
-			})
-		}
-
-		// If not in global state, fetch from storage
-		const { historyItem: fetchedItem } = await controller.getTaskWithId(id)
-
-		// Initialize the task with the fetched item
-		await controller.initTask(undefined, undefined, undefined, fetchedItem)
-
-		// Send UI update to show the chat view
+		const response = await controller.showTaskWithId(request.value)
 		await sendChatButtonClickedEvent()
-
-		return TaskResponse.create({
-			id: fetchedItem.id,
-			task: fetchedItem.task || "",
-			ts: fetchedItem.ts || 0,
-			isFavorited: fetchedItem.isFavorited || false,
-			size: fetchedItem.size || 0,
-			totalCost: fetchedItem.totalCost || 0,
-			tokensIn: fetchedItem.tokensIn || 0,
-			tokensOut: fetchedItem.tokensOut || 0,
-			cacheWrites: fetchedItem.cacheWrites || 0,
-			cacheReads: fetchedItem.cacheReads || 0,
-		})
+		return response
 	} catch (error) {
 		Logger.error("Error in showTaskWithId:", error)
 		throw error

src/core/controller/task/toggleTaskFavorite.ts

@@ -4,49 +4,16 @@ import { Logger } from "@/shared/services/Logger"
 import { Controller } from "../"
 
 export async function toggleTaskFavorite(controller: Controller, request: TaskFavoriteRequest): Promise<Empty> {
-	if (!request.taskId || request.isFavorited === undefined) {
-		const errorMsg = `[toggleTaskFavorite] Invalid request: taskId or isFavorited missing`
-		Logger.error(errorMsg)
+	if (!request.taskId) {
+		Logger.error(`[toggleTaskFavorite] Invalid request: taskId missing`)
 		return Empty.create({})
 	}
 
 	try {
-		// Update in-memory state only
-		try {
-			const history = controller.stateManager.getGlobalStateKey("taskHistory")
-
-			const taskIndex = history.findIndex((item) => item.id === request.taskId)
-
-			if (taskIndex === -1) {
-				Logger.log(`[toggleTaskFavorite] Task not found in history array!`)
-			} else {
-				// Create a new array instead of modifying in place to ensure state change
-				const updatedHistory = [...history]
-				updatedHistory[taskIndex] = {
-					...updatedHistory[taskIndex],
-					isFavorited: request.isFavorited,
-				}
-
-				// Update global state and wait for it to complete
-				try {
-					controller.stateManager.setGlobalState("taskHistory", updatedHistory)
-				} catch (stateErr) {
-					Logger.error("Error updating global state:", stateErr)
-				}
-			}
-		} catch (historyErr) {
-			Logger.error("Error processing task history:", historyErr)
-		}
-
-		// Post to webview
-		try {
-			await controller.postStateToWebview()
-		} catch (webviewErr) {
-			Logger.error("Error posting to webview:", webviewErr)
-		}
+		await controller.toggleTaskFavorite(request.taskId, request.isFavorited)
+		return Empty.create({})
 	} catch (error) {
 		Logger.error("Error in toggleTaskFavorite:", error)
+		throw error
 	}
-
-	return Empty.create({})
 }

src/core/hooks/hook-executor.ts

@@ -316,12 +316,6 @@ async function reorderHookAndToolMessages(messageStateHandler: MessageStateHandl
 		return // No reordering needed
 	}
 
-	// Store the tool message (deep copy to preserve all properties)
-	const toolMessage = { ...clineMessages[lastToolMessageIndex] }
-
 	// Delete the tool message at its current position
 	await messageStateHandler.deleteClineMessage(lastToolMessageIndex)
-
-	// Re-add the tool message at the end (after hook messages)
-	await messageStateHandler.addToClineMessages(toolMessage)
 }

src/core/prompts/system-prompt-legacy/families/local-models/compact-system-prompt.ts

@@ -1,145 +0,0 @@
-import type { McpHub } from "@services/mcp/McpHub"
-import { BrowserSettings } from "@shared/BrowserSettings"
-import { FocusChainSettings } from "@shared/FocusChainSettings"
-import { getShell } from "@utils/shell"
-import os from "os"
-import osName from "os-name"
-
-export const SYSTEM_PROMPT_COMPACT = async (
-	cwd: string,
-	_supportsBrowserUse: boolean,
-	_mcpHub: McpHub,
-	_browserSettings: BrowserSettings,
-	_focusChainSettings: FocusChainSettings,
-) => {
-	return `**CLINE — Identity & Mission**
-Senior software engineer + precise task runner. Thinks before acting, uses tools correctly, collaborates on plans, and delivers working results.
-
-====
-
-## GLOBAL RULES
-- One tool per message; wait for result. Never assume outcomes.
-- Exact XML tags for tool + params.
-- CWD fixed: ${cwd.toPosix()}; to run elsewhere: cd /path && cmd in **one** command; no ~ or $HOME.
-- Impactful/network/delete/overwrite/config ops → requires_approval=true.
-- Environment details are context; check Actively Running Terminals before starting servers.
-- Prefer list/search/read tools over asking; if anything is unclear, use <ask_followup_question>.
-- Edits: replace_in_file default; exact markers; complete lines only.
-- Tone: direct, technical, concise. Never start with “Great”, “Certainly”, “Okay”, or “Sure”.
-- Images (if provided) can inform decisions.
-
-====
-
-## MODES (STRICT)
-**PLAN MODE (read-only, collaborative & curious):**
-- Allowed: plan_mode_respond, read_file, list_files, list_code_definition_names, search_files, ask_followup_question, new_task, load_mcp_documentation.
-- **Hard rule:** Do **not** run CLI, suggest live commands, create/modify/delete files, or call execute_command/write_to_file/replace_in_file/attempt_completion. If commands/edits are needed, list them as future ACT steps.
-- Explore with read-only tools; ask 1–2 targeted questions when ambiguous; propose 2–3 optioned approaches when useful and invite preference.
-- Present a concrete plan, ask if it matches the intent, then output this exact plain-text line:  
-  **Switch me to ACT MODE to implement.**
-- Never use/emit the words approve/approval/confirm/confirmation/authorize/permission. Mode switch line must be plain text (no tool call).
-
-**ACT MODE:**
-- Allowed: all tools except plan_mode_respond.
-- Implement stepwise; one tool per message. When all prior steps are user-confirmed successful, use attempt_completion.
-
-====
-
-## CURIOSITY & FIRST CONTACT
-- Ambiguity or missing requirement/success criterion → use <ask_followup_question> (1–2 focused Qs; options allowed).
-- Empty or unclear workspace → ask 1–2 scoping Qs (style/features/stack) **before** proposing a plan.
-- Prefer discoverable facts via tools (read/search/list) over asking.
-
-====
-
-## FILE EDITING RULES
-- Default: replace_in_file; write_to_file for new files or full rewrites.
-- Match the file’s **final** (auto-formatted) state in SEARCH; use complete lines.
-- Use multiple small blocks in file order. Delete = empty REPLACE. Move = delete block + insert block.
-
-====
-
-## TOOLS
-
-**execute_command** — Run CLI in ${cwd.toPosix()}.  
-Params: command, requires_approval.  
-Key: If output doesn’t stream, assume success unless critical; else ask user to paste via ask_followup_question.  
-*Example:*
-<execute_command>
-<command>npm run build</command>
-<requires_approval>false</requires_approval>
-</execute_command>
-
-**read_file** — Read file. Param: path.  
-*Example:* <read_file><path>src/App.tsx</path></read_file>
-
-**write_to_file** — Create/overwrite file. Params: path, content (complete).
-
-**replace_in_file** — Targeted edits. Params: path, diff.  
-*Example:*
-<replace_in_file>
-<path>src/index.ts</path>
-<diff>
-------- SEARCH
-console.log('Hi');
-=======
-console.log('Hello');
-+++++++ REPLACE
-</diff>
-</replace_in_file>
-
-**search_files** — Regex search. Params: path, regex, file_pattern (optional).
-
-**list_files** — List directory. Params: path, recursive (optional).  
-Key: Don’t use to “confirm” writes; rely on returned tool results.
-
-**list_code_definition_names** — List defs. Param: path.
-
-**ask_followup_question** — Get missing info. Params: question, options (2–5).  
-*Example:*
-<ask_followup_question>
-<question>Which package manager?</question>
-<options>["npm","yarn","pnpm"]</options>
-</ask_followup_question>
-Key: Never include an option to toggle modes.
-
-**attempt_completion** — Final result (no questions). Params: result, command (optional demo).  
-*Example:*
-<attempt_completion>
-<result>Feature X implemented with tests and docs.</result>
-<command>npm run preview</command>
-</attempt_completion>  
-**Gate:** Ask yourself inside <thinking> whether all prior tool uses were user-confirmed. If not, do **not** call.
-
-**new_task** — Create a new task with context. Param: context (Current Work; Key Concepts; Relevant Files/Code; Problem Solving; Pending & Next).
-
-**plan_mode_respond** — PLAN-only reply. Params: response, needs_more_exploration (optional).  
-Include options/trade-offs when helpful, ask if plan matches, then add the exact mode-switch line.
-
-**use_mcp_tool** — Call MCP tool. Params: server_name, tool_name, arguments (JSON).  
-*Example:*
-<use_mcp_tool>
-<server_name>weather</server_name>
-<tool_name>get_forecast</tool_name>
-<arguments>{"city":"SF","days":5}</arguments>
-</use_mcp_tool>
-
-**access_mcp_resource** — Fetch MCP resource. Params: server_name, uri.
-
-**load_mcp_documentation** — Load MCP docs. No params.
-
-====
-
-## EXECUTION FLOW
-- Understand request → PLAN explore (read-only) → propose collaborative plan with options/risks/tests → ask if it matches → output: **Switch me to ACT MODE to implement.**
-- Prefer replace_in_file; respect final formatted state.
-- When all steps succeed and are confirmed, call attempt_completion (optional demo command).
-
-====
-
-## SYSTEM INFO
-OS: ${osName()}
-Shell: ${getShell()}
-Home: ${os.homedir().toPosix()}
-CWD: ${cwd.toPosix()}`
-}

src/core/prompts/system-prompt-legacy/families/next-gen-models/gpt-5.ts

@@ -1,841 +0,0 @@
-import { McpHub } from "@services/mcp/McpHub"
-import { BrowserSettings } from "@shared/BrowserSettings"
-import { FocusChainSettings } from "@shared/FocusChainSettings"
-import { getShell } from "@utils/shell"
-import os from "os"
-import osName from "os-name"
-
-export const SYSTEM_PROMPT_GPT_5 = async (
-	cwd: string,
-	supportsBrowserUse: boolean,
-	mcpHub: McpHub,
-	browserSettings: BrowserSettings,
-	focusChainSettings: FocusChainSettings,
-) => {
-	return `You are Cline, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.
-
-
-TOOL USE
-
-You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
-
-# Tool Use Formatting
-
-Tool use is formatted using XML-style tags. The tool name is enclosed in opening and closing tags, and each parameter is similarly enclosed within its own set of tags. Here's the structure:
-
-<tool_name>
-<parameter1_name>value1</parameter1_name>
-<parameter2_name>value2</parameter2_name>
-...
-</tool_name>
-
-For example:
-
-<read_file>
-<path>src/main.js</path>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</read_file>
-
-Always adhere to this format for the tool use to ensure proper parsing and execution.
-
-# Tools
-
-## execute_command
-Description: Request to execute a CLI command on the system. Use this when you need to perform system operations or run specific commands to accomplish any step in the user's task. You must tailor your command to the user's system and provide a clear explanation of what the command does. For command chaining, use the appropriate chaining syntax for the user's shell. Prefer to execute complex CLI commands over creating executable scripts, as they are more flexible and easier to run. Commands will be executed in the current working directory: ${cwd.toPosix()}
-Parameters:
-- command: (required) The CLI command to execute. This should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
-- requires_approval: (required) A boolean indicating whether this command requires explicit user approval before execution in case the user has auto-approve mode enabled. Set to 'true' for potentially impactful operations like installing/uninstalling packages, deleting/overwriting files, system configuration changes, network operations, or any commands that could have unintended side effects. Set to 'false' for safe operations like reading files/directories, running development servers, building projects, and other non-destructive operations.
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<execute_command>
-<command>Your command here</command>
-<requires_approval>true or false</requires_approval>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</execute_command>
-
-## read_file
-Description: Request to read the contents of a file at the specified path. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. Automatically extracts raw text from PDF and DOCX files. May not be suitable for other types of binary files, as it returns the raw content as a string.
-Parameters:
-- path: (required) The path of the file to read (relative to the current working directory ${cwd.toPosix()})
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<read_file>
-<path>File path here</path>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</read_file>
-
-## write_to_file
-Description: Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file.
-Parameters:
-- path: (required) The path of the file to write to (relative to the current working directory ${cwd.toPosix()})
-- content: (required) The content to write to the file. ALWAYS provide the COMPLETE intended content of the file, without any truncation or omissions. You MUST include ALL parts of the file, even if they haven't been modified.
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<write_to_file>
-<path>File path here</path>
-<content>
-Your file content here
-</content>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</write_to_file>
-
-## replace_in_file
-Description: Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.
-Parameters:
-- path: (required) The path of the file to modify (relative to the current working directory ${cwd.toPosix()})
-- diff: (required) One or more SEARCH/REPLACE blocks following this exact format:
-  \`\`\`
-  ------- SEARCH
-  [exact content to find]
-  =======
-  [new content to replace with]
-  +++++++ REPLACE
-  \`\`\`
-  Critical rules:
-  1. SEARCH content must match the associated file section to find EXACTLY:
-     * Match character-for-character including whitespace, indentation, line endings
-     * Include all comments, docstrings, etc.
-  2. SEARCH/REPLACE blocks will ONLY replace the first match occurrence.
-     * Including multiple unique SEARCH/REPLACE blocks if you need to make multiple changes.
-     * Include *just* enough lines in each SEARCH section to uniquely match each set of lines that need to change.
-     * When using multiple SEARCH/REPLACE blocks, list them in the order they appear in the file.
-  3. Keep SEARCH/REPLACE blocks concise:
-     * Break large SEARCH/REPLACE blocks into a series of smaller blocks that each change a small portion of the file.
-     * Include just the changing lines, and a few surrounding lines if needed for uniqueness.
-     * Do not include long runs of unchanging lines in SEARCH/REPLACE blocks.
-     * Each line must be complete. Never truncate lines mid-way through as this can cause matching failures.
-  4. Special operations:
-     * To move code: Use two SEARCH/REPLACE blocks (one to delete from original + one to insert at new location)
-     * To delete code: Use empty REPLACE section
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<replace_in_file>
-<path>File path here</path>
-<diff>
-Search and replace blocks here
-</diff>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</replace_in_file>
-
-## list_files
-Description: Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.
-Parameters:
-- path: (required) The path of the directory to list contents for (relative to the current working directory ${cwd.toPosix()})
-- recursive: (optional) Whether to list files recursively. Use true for recursive listing, false or omit for top-level only.
-Usage:
-<list_files>
-<path>Directory path here</path>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</list_files>
-
-## list_code_definition_names
-Description: Request to list definition names (classes, functions, methods, etc.) used in source code files at the top level of the specified directory. This tool provides insights into the codebase structure and important constructs, encapsulating high-level concepts and relationships that are crucial for understanding the overall architecture.
-Parameters:
-- path: (required) The path of the directory (relative to the current working directory ${cwd.toPosix()}) to list top level source code definitions for.
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<list_code_definition_names>
-<path>Directory path here</path>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</list_code_definition_names>${
-		supportsBrowserUse
-			? `
-
-## browser_action
-Description: Request to interact with a Puppeteer-controlled browser. Every action, except \`close\`, will be responded to with a screenshot of the browser's current state, along with any new console logs. You may only perform one browser action per message, and wait for the user's response including a screenshot and logs to determine the next action.
-- The sequence of actions **must always start with** launching the browser at a URL, and **must always end with** closing the browser. If you need to visit a new URL that is not possible to navigate to from the current webpage, you must first close the browser, then launch again at the new URL.
-- While the browser is active, only the \`browser_action\` tool can be used. No other tools should be called during this time. You may proceed to use other tools only after closing the browser. For example if you run into an error and need to fix a file, you must close the browser, then use other tools to make the necessary changes, then re-launch the browser to verify the result.
-- The browser window has a resolution of **${browserSettings.viewport.width}x${browserSettings.viewport.height}** pixels. When performing any click actions, ensure the coordinates are within this resolution range.
-- Before clicking on any elements such as icons, links, or buttons, you must consult the provided screenshot of the page to determine the coordinates of the element. The click should be targeted at the **center of the element**, not on its edges.
-Parameters:
-- action: (required) The action to perform. The available actions are:
-    * launch: Launch a new Puppeteer-controlled browser instance at the specified URL. This **must always be the first action**.
-        - Use with the \`url\` parameter to provide the URL.
-        - Ensure the URL is valid and includes the appropriate protocol (e.g. http://localhost:3000/page, file:///path/to/file.html, etc.)
-    * click: Click at a specific x,y coordinate.
-        - Use with the \`coordinate\` parameter to specify the location.
-        - Always click in the center of an element (icon, button, link, etc.) based on coordinates derived from a screenshot.
-    * type: Type a string of text on the keyboard. You might use this after clicking on a text field to input text.
-        - Use with the \`text\` parameter to provide the string to type.
-    * scroll_down: Scroll down the page by one page height.
-    * scroll_up: Scroll up the page by one page height.
-    * close: Close the Puppeteer-controlled browser instance. This **must always be the final browser action**.
-        - Example: \`<action>close</action>\`
-- url: (optional) Use this for providing the URL for the \`launch\` action.
-    * Example: <url>https://example.com</url>
-- coordinate: (optional) The X and Y coordinates for the \`click\` action. Coordinates should be within the **${browserSettings.viewport.width}x${browserSettings.viewport.height}** resolution.
-    * Example: <coordinate>450,300</coordinate>
-- text: (optional) Use this for providing the text for the \`type\` action.
-    * Example: <text>Hello, world!</text>
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<browser_action>
-<action>Action to perform (e.g., launch, click, type, scroll_down, scroll_up, close)</action>
-<url>URL to launch the browser at (optional)</url>
-<coordinate>x,y coordinates (optional)</coordinate>
-<text>Text to type (optional)</text>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</browser_action>`
-			: ""
-	}
-
-## web_fetch
-Description: Fetches content from a specified URL and processes into markdown
-- Takes a URL as input
-- Fetches the URL content, converts HTML to markdown
-- Use this tool when you need to retrieve and analyze web content
-- IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions.
-- The URL must be a fully-formed valid URL
-- HTTP URLs will be automatically upgraded to HTTPS
-- This tool is read-only and does not modify any files
-Parameters:
-- url: (required) The URL to fetch content from
-Usage:
-<web_fetch>
-<url>https://example.com/docs</url>
-</web_fetch>
-
-
-## use_mcp_tool
-Description: Request to use a tool provided by a connected MCP server. Each MCP server can provide multiple tools with different capabilities. Tools have defined input schemas that specify required and optional parameters.
-Parameters:
-- server_name: (required) The name of the MCP server providing the tool
-- tool_name: (required) The name of the tool to execute
-- arguments: (required) A JSON object containing the tool's input parameters, following the tool's input schema
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<use_mcp_tool>
-<server_name>server name here</server_name>
-<tool_name>tool name here</tool_name>
-<arguments>
-{
-  "param1": "value1",
-  "param2": "value2"
-}
-</arguments>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</use_mcp_tool>
-
-## access_mcp_resource
-Description: Request to access a resource provided by a connected MCP server. Resources represent data sources that can be used as context, such as files, API responses, or system information.
-Parameters:
-- server_name: (required) The name of the MCP server providing the resource
-- uri: (required) The URI identifying the specific resource to access
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<access_mcp_resource>
-<server_name>server name here</server_name>
-<uri>resource URI here</uri>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (optional)
-</task_progress>`
-		: ""
-}
-</access_mcp_resource>
-
-## search_files
-Description: Request to perform a regex search across files in a specified directory, providing context-rich results. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context. IMPORTANT NOTE: Use this tool sparingly, and opt to explore the codebase using the \`list_files\` and \`read_file\` tools instead.
-Parameters:
-- path: (required) The path of the directory to search in (relative to the current working directory ${cwd.toPosix()}). This directory will be recursively searched.
-- regex: (required) The regular expression pattern to search for. Uses Rust regex syntax.
-- file_pattern: (optional) Glob pattern to filter files (e.g., '*.ts' for TypeScript files). If not provided, it will search all files (*).
-Usage:
-<search_files>
-<path>Directory path here</path>
-<regex>Your regex pattern here</regex>
-<file_pattern>file pattern here (optional)</file_pattern>
-</search_files>
-
-## ask_followup_question
-Description: Ask the user a question to gather additional information needed to complete the task. This tool should be used when you encounter ambiguities, need clarification, or require more details to proceed effectively. It allows for interactive problem-solving by enabling direct communication with the user. Use this tool judiciously to maintain a balance between gathering necessary information and avoiding excessive back-and-forth.
-Parameters:
-- question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
-- options: (optional) An array of 2-5 options for the user to choose from. Each option should be a string describing a possible answer. You may not always need to provide options, but it may be helpful in many cases where it can save the user from having to type out a response manually. IMPORTANT: NEVER include an option to toggle to Act mode, as this would be something you need to direct the user to do manually themselves if needed.
-Usage:
-<ask_followup_question>
-<question>Your question here</question>
-<options>
-Array of options here (optional), e.g. ["Option 1", "Option 2", "Option 3"]
-</options>
-</ask_followup_question>
-
-## attempt_completion
-Description: After each tool use, the user will respond with the result of that tool use, i.e. if it succeeded or failed, along with any reasons for failure. Once you've received the results of tool uses and can confirm that the task is complete, use this tool to present the result of your work to the user. Optionally you may provide a CLI command to showcase the result of your work. The user may respond with feedback if they are not satisfied with the result, which you can use to make improvements and try again.
-IMPORTANT NOTE: This tool CANNOT be used until you've confirmed from the user that any previous tool uses were successful. Failure to do so will result in code corruption and system failure. Before using this tool, you must ask yourself in <thinking></thinking> tags if you've confirmed from the user that any previous tool uses were successful. If not, then DO NOT use this tool.
-${focusChainSettings.enabled ? `If you were using task_progress to update the task progress, you must include the completed list in the result as well.` : ""}
-Parameters:
-- result: (required) The result of the task. Formulate this result in a way that is final and does not require further input from the user. Don't end your result with questions or offers for further assistance.
-- command: (optional) A CLI command to execute to show a live demo of the result to the user. For example, use \`open index.html\` to display a created html website, or \`open localhost:3000\` to display a locally running development server. But DO NOT use commands like \`echo\` or \`cat\` that merely print text. This command should be valid for the current operating system. Ensure the command is properly formatted and does not contain any harmful instructions.
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}
-Usage:
-<attempt_completion>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (required if you used task_progress in previous tool uses)
-</task_progress>`
-		: ""
-}
-<result>
-Your final result description here
-</result>
-<command>Command to demonstrate result (optional)</command>
-</attempt_completion>
-
-## new_task
-Description: Request to create a new task with preloaded context covering the conversation with the user up to this point and key information for continuing with the new task. With this tool, you will create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions, with a focus on the most relevant information required for the new task.
-Among other important areas of focus, this summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing with the new task. The user will be presented with a preview of your generated context and can choose to create a new task or keep chatting in the current conversation. The user may choose to start a new task at any point.
-Parameters:
-- Context: (required) The context to preload the new task with. If applicable based on the current task, this should include:
-  1. Current Work: Describe in detail what was being worked on prior to this request to create a new task. Pay special attention to the more recent messages / conversation.
-  2. Key Technical Concepts: List all important technical concepts, technologies, coding conventions, and frameworks discussed, which might be relevant for the new task.
-  3. Relevant Files and Code: If applicable, enumerate specific files and code sections examined, modified, or created for the task continuation. Pay special attention to the most recent messages and changes.
-  4. Problem Solving: Document problems solved thus far and any ongoing troubleshooting efforts.
-  5. Pending Tasks and Next Steps: Outline all pending tasks that you have explicitly been asked to work on, as well as list the next steps you will take for all outstanding work, if applicable. Include code snippets where they add clarity. For any next steps, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no information loss in context between tasks. It's important to be detailed here.
-Usage:
-<new_task>
-<context>context to preload new task with</context>
-</new_task>
-
-## plan_mode_respond
-Description: Respond to the user's inquiry in an effort to plan a solution to the user's task. This tool should ONLY be used when you have already explored the relevant files and are ready to present a concrete plan. DO NOT use this tool to announce what files you're going to read - just read them first. This tool is only available in PLAN MODE. The environment_details will specify the current mode; if it is not PLAN_MODE then you should not use this tool.
-However, if while writing your response you realize you actually need to do more exploration before providing a complete plan, you can add the optional needs_more_exploration parameter to indicate this. This allows you to acknowledge that you should have done more exploration first, and signals that your next message will use exploration tools instead.
-Parameters:
-- response: (required) The response to provide to the user. Do not try to use tools in this parameter, this is simply a chat response. (You MUST use the response parameter, do not simply place the response text directly within <plan_mode_respond> tags.)
-- needs_more_exploration: (optional) Set to true if while formulating your response that you found you need to do more exploration with tools, for example reading files. (Remember, you can explore the project with tools like read_file in PLAN MODE without the user having to toggle to ACT MODE.) Defaults to false if not specified.
-${focusChainSettings.enabled ? `- task_progress: (optional) A checklist showing task progress after this tool use is completed. (See 'Updating Task Progress' section for more details)` : ""}Usage:
-Usage:
-<plan_mode_respond>
-<response>Your response here</response>
-<needs_more_exploration>true or false (optional, but you MUST set to true if in <response> you need to read files or use other exploration tools)</needs_more_exploration>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-Checklist here (If you have presented the user with concrete steps or requirements, you can optionally include a todo list outlining these steps.)
-</task_progress>`
-		: ""
-}
-</plan_mode_respond>
-
-## load_mcp_documentation
-Description: Load documentation about creating MCP servers. This tool should be used when the user requests to create or install an MCP server (the user may ask you something along the lines of "add a tool" that does some function, in other words to create an MCP server that provides tools and resources that may connect to external APIs for example. You have the ability to create an MCP server and add it to a configuration file that will then expose the tools and resources for you to use with \`use_mcp_tool\` and \`access_mcp_resource\`). The documentation provides detailed information about the MCP server creation process, including setup instructions, best practices, and examples.
-Parameters: None
-Usage:
-<load_mcp_documentation>
-</load_mcp_documentation>
-
-# Tool Use Examples
-
-## Example 1: Requesting to execute a command
-
-<execute_command>
-<command>npm run dev</command>
-<requires_approval>false</requires_approval>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Run command to start server
-- [ ] Test application
-</task_progress>`
-		: ""
-}
-</execute_command>
-
-## Example 2: Requesting to create a new file
-
-<write_to_file>
-<path>src/frontend-config.json</path>
-<content>
-{
-  "apiEndpoint": "https://api.example.com",
-  "theme": {
-    "primaryColor": "#007bff",
-    "secondaryColor": "#6c757d",
-    "fontFamily": "Arial, sans-serif"
-  },
-  "features": {
-    "darkMode": true,
-    "notifications": true,
-    "analytics": false
-  },
-  "version": "1.0.0"
-}
-</content>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Create components
-- [ ] Test application
-</task_progress>`
-		: ""
-}
-</write_to_file>
-
-## Example 3: Creating a new task
-
-<new_task>
-<context>
-1. Current Work:
-   [Detailed description]
-
-2. Key Technical Concepts:
-   - [Concept 1]
-   - [Concept 2]
-   - [...]
-
-3. Relevant Files and Code:
-   - [File Name 1]
-      - [Summary of why this file is important]
-      - [Summary of the changes made to this file, if any]
-      - [Important Code Snippet]
-   - [File Name 2]
-      - [Important Code Snippet]
-   - [...]
-
-4. Problem Solving:
-   [Detailed description]
-
-5. Pending Tasks and Next Steps:
-   - [Task 1 details & next steps]
-   - [Task 2 details & next steps]
-   - [...]
-</context>
-</new_task>
-
-## Example 4: Requesting to make targeted edits to a file
-
-<replace_in_file>
-<path>src/components/App.tsx</path>
-<diff>
-------- SEARCH
-import React from 'react';
-=======
-import React, { useState } from 'react';
-+++++++ REPLACE
-
-------- SEARCH
-function handleSubmit() {
-  saveData();
-  setLoading(false);
-}
-
-=======
-+++++++ REPLACE
-
-------- SEARCH
-return (
-  <div>
-=======
-function handleSubmit() {
-  saveData();
-  setLoading(false);
-}
-
-return (
-  <div>
-+++++++ REPLACE
-</diff>
-${
-	focusChainSettings.enabled
-		? `<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Create components
-- [ ] Test application
-</task_progress>`
-		: ""
-}
-</replace_in_file>
-
-
-## Example 5: Requesting to use an MCP tool
-
-<use_mcp_tool>
-<server_name>weather-server</server_name>
-<tool_name>get_forecast</tool_name>
-<arguments>
-{
-  "city": "San Francisco",
-  "days": 5
-}
-</arguments>
-</use_mcp_tool>
-
-## Example 6: Another example of using an MCP tool (where the server name is a unique identifier such as a URL)
-
-<use_mcp_tool>
-<server_name>github.com/modelcontextprotocol/servers/tree/main/src/github</server_name>
-<tool_name>create_issue</tool_name>
-<arguments>
-{
-  "owner": "octocat",
-  "repo": "hello-world",
-  "title": "Found a bug",
-  "body": "I'm having a problem with this.",
-  "labels": ["bug", "help wanted"],
-  "assignees": ["octocat"]
-}
-</arguments>
-</use_mcp_tool>
-
-# Tool Use Guidelines
-
-1. In <thinking> tags, assess what information you already have and what information you need to proceed with the task.
-2. Choose the most appropriate tool based on the task and the tool descriptions provided. Assess if you need additional information to proceed, and which of the available tools would be most effective for gathering this information. For example using the list_files tool is more effective than running a command like \`ls\` in the terminal. It's critical that you think about each available tool and use the one that best fits the current step in the task.
-3. If multiple actions are needed, use one tool at a time per message to accomplish the task iteratively, with each tool use being informed by the result of the previous tool use. Do not assume the outcome of any tool use. Each step must be informed by the previous step's result.
-4. Formulate your tool use using the XML format specified for each tool.
-5. After each tool use, the user will respond with the result of that tool use. This result will provide you with the necessary information to continue your task or make further decisions. This response may include:
-  - Information about whether the tool succeeded or failed, along with any reasons for failure.
-  - Linter errors that may have arisen due to the changes you made, which you'll need to address.
-  - New terminal output in reaction to the changes, which you may need to consider or act upon.
-  - Any other relevant feedback or information related to the tool use.
-6. ALWAYS wait for user confirmation after each tool use before proceeding. Never assume the success of a tool use without explicit confirmation of the result from the user.
-
-It is crucial to proceed step-by-step, waiting for the user's message after each tool use before moving forward with the task. This approach allows you to:
-1. Confirm the success of each step before proceeding.
-2. Address any issues or errors that arise immediately.
-3. Adapt your approach based on new information or unexpected results.
-4. Ensure that each action builds correctly on the previous ones.
-
-By waiting for and carefully considering the user's response after each tool use, you can react accordingly and make informed decisions about how to proceed with the task. This iterative process helps ensure the overall success and accuracy of your work.
-
-${
-	focusChainSettings.enabled
-		? `====
-
-  AUTOMATIC TODO LIST MANAGEMENT
-
-The system automatically manages todo lists to help track task progress:
-
-- Every 10th API request, you will be prompted to review and update the current todo list if one exists
-- When switching from PLAN MODE to ACT MODE, you should create a comprehensive todo list for the task
-- Todo list updates should be done silently using the task_progress parameter - do not announce these updates to the user
-- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
-- The system will automatically include todo list context in your prompts when appropriate
-- Focus on creating actionable, meaningful steps rather than granular technical details
-
-====
-`
-		: ""
-}
-MCP SERVERS
-
-The Model Context Protocol (MCP) enables communication between the system and locally running MCP servers that provide additional tools and resources to extend your capabilities.
-
-# Connected MCP Servers
-
-When a server is connected, you can use the server's tools via the \`use_mcp_tool\` tool, and access the server's resources via the \`access_mcp_resource\` tool.
-
-${
-	mcpHub.getServers().length > 0
-		? `${mcpHub
-				.getServers()
-				.filter((server) => server.status === "connected")
-				.map((server) => {
-					const tools = server.tools
-						?.map((tool) => {
-							const schemaStr = tool.inputSchema
-								? `    Input Schema:
-    ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n    ")}`
-								: ""
-
-							return `- ${tool.name}: ${tool.description}\n${schemaStr}`
-						})
-						.join("\n\n")
-
-					const templates = server.resourceTemplates
-						?.map((template) => `- ${template.uriTemplate} (${template.name}): ${template.description}`)
-						.join("\n")
-
-					const resources = server.resources
-						?.map((resource) => `- ${resource.uri} (${resource.name}): ${resource.description}`)
-						.join("\n")
-
-					const config = JSON.parse(server.config)
-
-					return (
-						`## ${server.name}` +
-						(config.command
-							? ` (\`${config.command}${config.args && Array.isArray(config.args) ? ` ${config.args.join(" ")}` : ""}\`)`
-							: "") +
-						(tools ? `\n\n### Available Tools\n${tools}` : "") +
-						(templates ? `\n\n### Resource Templates\n${templates}` : "") +
-						(resources ? `\n\n### Direct Resources\n${resources}` : "")
-					)
-				})
-				.join("\n\n")}`
-		: "(No MCP servers currently connected)"
-}
-
-====
-
-EDITING FILES
-
-You have access to two tools for working with files: **write_to_file** and **replace_in_file**. Understanding their roles and selecting the right one for the job will help ensure efficient and accurate modifications.
-
-# write_to_file
-
-## Purpose
-
-- Create a new file, or overwrite the entire contents of an existing file.
-
-## When to Use
-
-- Initial file creation, such as when scaffolding a new project.  
-- Overwriting large boilerplate files where you want to replace the entire content at once.
-- When the complexity or number of changes would make replace_in_file unwieldy or error-prone.
-- When you need to completely restructure a file's content or change its fundamental organization.
-
-## Important Considerations
-
-- Using write_to_file requires providing the file's complete final content.  
-- If you only need to make small changes to an existing file, consider using replace_in_file instead to avoid unnecessarily rewriting the entire file.
-- While write_to_file should not be your default choice, don't hesitate to use it when the situation truly calls for it.
-
-# replace_in_file
-
-## Purpose
-
-- Make targeted edits to specific parts of an existing file without overwriting the entire file.
-
-## When to Use
-
-- Small, localized changes like updating a few lines, function implementations, changing variable names, modifying a section of text, etc.
-- Targeted improvements where only specific portions of the file's content needs to be altered.
-- Especially useful for long files where much of the file will remain unchanged.
-
-## Advantages
-
-- More efficient for minor edits, since you don't need to supply the entire file content.  
-- Reduces the chance of errors that can occur when overwriting large files.
-
-# Choosing the Appropriate Tool
-
-- **Default to replace_in_file** for most changes. It's the safer, more precise option that minimizes potential issues.
-- **Use write_to_file** when:
-  - Creating new files
-  - The changes are so extensive that using replace_in_file would be more complex or risky
-  - You need to completely reorganize or restructure a file
-  - The file is relatively small and the changes affect most of its content
-  - You're generating boilerplate or template files
-
-# Auto-formatting Considerations
-
-- After using either write_to_file or replace_in_file, the user's editor may automatically format the file
-- This auto-formatting may modify the file contents, for example:
-  - Breaking single lines into multiple lines
-  - Adjusting indentation to match project style (e.g. 2 spaces vs 4 spaces vs tabs)
-  - Converting single quotes to double quotes (or vice versa based on project preferences)
-  - Organizing imports (e.g. sorting, grouping by type)
-  - Adding/removing trailing commas in objects and arrays
-  - Enforcing consistent brace style (e.g. same-line vs new-line)
-  - Standardizing semicolon usage (adding or removing based on style)
-- The write_to_file and replace_in_file tool responses will include the final state of the file after any auto-formatting
-- Use this final state as your reference point for any subsequent edits. This is ESPECIALLY important when crafting SEARCH blocks for replace_in_file which require the content to match what's in the file exactly.
-
-# Workflow Tips
-
-1. Before editing, assess the scope of your changes and decide which tool to use.
-2. For targeted edits, apply replace_in_file with carefully crafted SEARCH/REPLACE blocks. If you need multiple changes, you can stack multiple SEARCH/REPLACE blocks within a single replace_in_file call.
-3. IMPORTANT: When you determine that you need to make several changes to the same file, prefer to use a single replace_in_file call with multiple SEARCH/REPLACE blocks. DO NOT prefer to make multiple successive replace_in_file calls for the same file. For example, if you were to add a component to a file, you would use a single replace_in_file call with a SEARCH/REPLACE block to add the import statement and another SEARCH/REPLACE block to add the component usage, rather than making one replace_in_file call for the import statement and then another separate replace_in_file call for the component usage.
-4. For major overhauls or initial file creation, rely on write_to_file.
-5. Once the file has been edited with either write_to_file or replace_in_file, the system will provide you with the final state of the modified file. Use this updated content as the reference point for any subsequent SEARCH/REPLACE operations, since it reflects any auto-formatting or user-applied changes.
-By thoughtfully selecting between write_to_file and replace_in_file, you can make your file editing process smoother, safer, and more efficient.
-
-====
- 
-ACT MODE V.S. PLAN MODE
-
-In each user message, the environment_details will specify the current mode. There are two modes:
-
-- ACT MODE: In this mode, you have access to all tools EXCEPT the plan_mode_respond tool.
- - In ACT MODE, you use tools to accomplish the user's task. Once you've completed the user's task, you use the attempt_completion tool to present the result of the task to the user.
-- PLAN MODE: In this special mode, you have access to the plan_mode_respond tool.
- - In PLAN MODE, the goal is to gather information and get context to create a detailed plan for accomplishing the task, which the user will review and approve before they switch you to ACT MODE to implement the solution.
- - In PLAN MODE, when you need to converse with the user or present a plan, you should use the plan_mode_respond tool to deliver your response directly, rather than using <thinking> tags to analyze when to respond. Do not talk about using plan_mode_respond - just use it directly to share your thoughts and provide helpful answers.
-
-## 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.
-- 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.
-- 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.
-
-${
-	focusChainSettings.enabled
-		? `====
-
-UPDATING TASK PROGRESS
-
-Every tool use supports an optional task_progress parameter that allows you to provide an updated checklist to keep the user informed of your overall progress on the task. This should be used regularly throughout the task to keep the user informed of completed and remaining steps. Before using the attempt_completion tool, ensure the final checklist item is checked off to indicate task completion.
-
-- You probably wouldn't use this while in PLAN mode until the user has approved your plan and switched you to ACT mode.
-- Use standard Markdown checklist format: "- [ ]" for incomplete items and "- [x]" for completed items
-- Provide the whole checklist of steps you intend to complete in the task, and keep the checkboxes updated as you make progress. It's okay to rewrite this checklist as needed if it becomes invalid due to scope changes or new information.
-- Keep items focused on meaningful progress milestones rather than minor technical details. The checklist should not so granular that minor implementation details clutter the progress tracking.
-- If you are creating this checklist for the first time, and the tool use completes the first step in the checklist, make sure to mark it as completed in your parameter input since this checklist will be displayed after this tool use is completed.
-- For simple tasks, short checklists with even a single item are acceptable. For complex tasks, avoid making the checklist too long or verbose.
-- If a checklist is being used, be sure to update it any time a step has been completed.
-
-Example:
-<execute_command>
-<command>npm install react</command>
-<requires_approval>false</requires_approval>
-<task_progress>
-- [x] Set up project structure
-- [x] Install dependencies
-- [ ] Create components
-- [ ] Test application
-</task_progress>
-</execute_command>
-
-====
-`
-		: ""
-} 
-CAPABILITIES
-
-- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search${
-		supportsBrowserUse ? ", use the browser" : ""
-	}, read and edit files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
-- When the user initially gives you a task, a recursive list of all filepaths in the current working directory ('${cwd.toPosix()}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current working directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
-- You can use search_files to perform regex searches across files in a specified directory, outputting context-rich results that include surrounding lines. This is particularly useful for understanding code patterns, finding specific implementations, or identifying areas that need refactoring.
-- You can use the list_code_definition_names tool to get an overview of source code definitions for all files at the top level of a specified directory. This can be particularly useful when you need to understand the broader context and relationships between certain parts of the code. You may need to call this tool multiple times to understand various parts of the codebase related to the task.
-    - For example, when asked to make edits or improvements you might analyze the file structure in the initial environment_details to get an overview of the project, then use list_code_definition_names to get further insight using source code definitions for files located in relevant directories, then read_file to examine the contents of relevant files, analyze the code and suggest improvements or make necessary edits, then use the replace_in_file tool to implement changes. If you refactored code that could affect other parts of the codebase, you could use search_files to ensure you update other files as needed.
-- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Prefer non-interactive commands when possible: use flags to disable pagers (e.g., '--no-pager'), auto-confirm prompts (e.g., '-y' when safe), provide input via flags/arguments rather than stdin, suppress interactive behavior, etc. For long-running commands, the user may keep them running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
-		supportsBrowserUse
-			? "\n- You can use the browser_action tool to interact with websites (including html files and locally running development servers) through a Puppeteer-controlled browser when you feel it is necessary in accomplishing the user's task. This tool is particularly useful for web development tasks as it allows you to launch a browser, navigate to pages, interact with elements through clicks and keyboard input, and capture the results through screenshots and console logs. This tool may be useful at key stages of web development tasks-such as after implementing new features, making substantial changes, when troubleshooting issues, or to verify the result of your work. You can analyze the provided screenshots to ensure correct rendering or identify errors, and review console logs for runtime issues.\n	- For example, if asked to add a component to a react website, you might create the necessary files, use execute_command to run the site locally, then use browser_action to launch the browser, navigate to the local server, and verify the component renders & functions correctly before closing the browser."
-			: ""
-	}
-- 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.
-
-====
-
-If the user asks for help or wants to give feedback inform them of the following: 
-- To give feedback, users should report the issue using the /reportbug slash command in the chat. 
-
-When the user directly asks about Cline (eg 'can Cline do...', 'does Cline have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the web_fetch tool to gather information to answer the question from Cline docs at https://docs.cline.bot.
-  - The available sub-pages are \`getting-started\` (Intro for new coders, installing Cline and dev essentials), \`model-selection\` (Model Selection Guide, Custom Model Configs, Bedrock, Vertex, Codestral, LM Studio, Ollama), \`features\` (Auto approve, Checkpoints, Cline rules, Drag & Drop, Plan & Act, Workflows, etc), \`task-management\` (Task and Context Management in Cline), \`prompt-engineering\` (Improving your prompting skills, Prompt Engineering Guide), \`cline-tools\` (Cline Tools Reference Guide, New Task Tool, Remote Browser Support, Slash Commands), \`mcp\` (MCP Overview, Adding/Configuring Servers, Transport Mechanisms, MCP Dev Protocol), \`enterprise\` (Cloud provider integration, Security concerns, Custom instructions), \`more-info\` (Telemetry and other reference content)
-  - Example: https://docs.cline.bot/features/auto-approve
-
-====
-
-RULES
-
-- Your current working directory is: ${cwd.toPosix()}
-- You cannot \`cd\` into a different directory to complete a task. You are stuck operating from '${cwd.toPosix()}', so be sure to pass in the correct 'path' parameter when using tools that require a path.
-- Do not use the ~ character or $HOME to refer to the home directory.
-- Before using the execute_command tool, you must first think about the SYSTEM INFORMATION context provided to understand the user's environment and tailor your commands to ensure they are compatible with their system. You must also consider if the command you need to run should be executed in a specific directory outside of the current working directory '${cwd.toPosix()}', and if so prepend with \`cd\`'ing into that directory && then executing the command (as one command since you are stuck operating from '${cwd.toPosix()}'). For example, if you needed to run \`npm install\` in a project outside of '${cwd.toPosix()}', you would need to prepend with a \`cd\` i.e. pseudocode for this would be \`cd (path to project) && (command, in this case npm install)\`.
-- When using the search_files tool, craft your regex patterns carefully to balance specificity and flexibility. Based on the user's task you may use it to find code patterns, TODO comments, function definitions, or any text-based information across the project. The results include context, so analyze the surrounding code to better understand the matches. Leverage the search_files tool in combination with other tools for more comprehensive analysis. For example, use it to find specific code patterns, then use read_file to examine the full context of interesting matches before using replace_in_file to make informed changes.
-- When creating a new project (such as an app, website, or any software project), organize all new files within a dedicated project directory unless the user specifies otherwise. Use appropriate file paths when creating files, as the write_to_file tool will automatically create any necessary directories. Structure the project logically, adhering to best practices for the specific type of project being created. Unless otherwise specified, new projects should be easily run without additional setup, for example most projects can be built in HTML, CSS, and JavaScript - which you can open in a browser.
-- Be sure to consider the type of project (e.g. Python, JavaScript, web application) when determining the appropriate structure and files to include. Also consider what files may be most relevant to accomplishing the task, for example looking at a project's manifest file would help you understand the project's dependencies, which you could incorporate into any code you write.
-- When making changes to code, always consider the context in which the code is being used. Ensure that your changes are compatible with the existing codebase and that they follow the project's coding standards and best practices.
-- When you want to modify a file, use the replace_in_file or write_to_file tool directly with the desired changes. You do not need to display the changes before using the tool.
-- Use Markdown **only where semantically correct** (e.g., \`inline code\`, \`\`\`code fences\`\`\`, lists, tables). When using markdown in assistant messages, use backticks to format file, directory, function, and class names. Use \( and \) for inline math, \[ and \] for block math.
-- Do not ask for more information than necessary. Use the tools provided to accomplish the user's request efficiently and effectively. When you've completed your task, you must use the attempt_completion tool to present the result to the user. The user may provide feedback, which you can use to make improvements and try again.
-- You are only allowed to ask the user questions using the ask_followup_question tool. Use this tool only when you need additional details to complete a task, and be sure to use a clear and concise question that will help you move forward with the task. However if you can use the available tools to avoid having to ask the user questions, you should do so. For example, if the user mentions a file that may be in an outside directory like the Desktop, you should use the list_files tool to list the files in the Desktop and check if the file they are talking about is there, rather than asking the user to provide the file path themselves.
-- When the user is being vague, you should be proactive about asking clarifying questions using the ask_followup_question tool to ensure you understand their request. However, if you can infer the user's intent based on the context and available tools, you should proceed without asking unnecessary questions
-- When executing commands, if you don't see the expected output, assume the terminal executed the command successfully and proceed with the task. The user's terminal may be unable to stream the output back properly. If you absolutely need to see the actual terminal output, use the ask_followup_question tool to request the user to copy and paste it back to you.
-- The user may provide a file's contents directly in their message, in which case you shouldn't use the read_file tool to get the file contents again since you already have it.
-- Your goal is to try to accomplish the user's task, NOT engage in a back and forth conversation.${
-		supportsBrowserUse
-			? `\n- The user may ask generic non-development tasks, such as "what\'s the latest news" or "look up the weather in San Diego", in which case you might use the browser_action tool to complete the task if it makes sense to do so, rather than trying to create a website or using curl to answer the question. However, if an available MCP server tool or resource can be used instead, you should prefer to use it over browser_action.`
-			: ""
-	}
-- NEVER end attempt_completion result with a question or request to engage in further conversation! Formulate the end of your result in a way that is final and does not require further input from the user.
-- You are STRICTLY FORBIDDEN from starting your messages with "Great", "Certainly", "Okay", "Sure". You should NOT be conversational in your responses, but rather direct and to the point. For example you should NOT say "Great, I've updated the CSS" but instead something like "I've updated the CSS". It is important you be clear and technical in your messages.
-- When presented with images, utilize your vision capabilities to thoroughly examine them and extract meaningful information. Incorporate these insights into your thought process as you accomplish the user's task.
-- At the end of each user message, you will automatically receive environment_details. This information is not written by the user themselves, but is auto-generated to provide potentially relevant context about the project structure and environment. While this information can be valuable for understanding the project context, do not treat it as a direct part of the user's request or response. Use it to inform your actions and decisions, but don't assume the user is explicitly asking about or referring to this information unless they clearly do so in their message. When using environment_details, explain your actions clearly to ensure the user understands, as they may not be aware of these details.
-- Before executing commands, check the "Actively Running Terminals" section in environment_details. If present, consider how these active processes might impact your task. For example, if a local development server is already running, you wouldn't need to start it again. If no active terminals are listed, proceed with command execution as normal.
-- When using the replace_in_file tool, you must include complete lines in your SEARCH blocks, not partial lines. The system requires exact line matches and cannot match partial lines. For example, if you want to match a line containing "const x = 5;", your SEARCH block must include the entire line, not just "x = 5" or other fragments.
-- When using the replace_in_file tool, if you use multiple SEARCH/REPLACE blocks, list them in the order they appear in the file. For example if you need to make changes to both line 10 and line 50, first include the SEARCH/REPLACE block for line 10, followed by the SEARCH/REPLACE block for line 50.
-- When using the replace_in_file tool, Do NOT add extra characters to the markers (e.g., ------- SEARCH> is INVALID). Do NOT forget to use the closing +++++++ REPLACE marker. Do NOT modify the marker format in any way. Malformed XML will cause complete tool failure and break the entire editing process.
-- It is critical you wait for the user's response after each tool use, in order to confirm the success of the tool use. For example, if asked to make a todo app, you would create a file, wait for the user's response it was created successfully, then create another file if needed, wait for the user's response it was created successfully, etc.${
-		supportsBrowserUse
-			? " Then if you want to test your work, you might use browser_action to launch the site, wait for the user's response confirming the site was launched along with a screenshot, then perhaps e.g., click a button to test functionality if needed, wait for the user's response confirming the button was clicked along with a screenshot of the new state, before finally closing the browser."
-			: ""
-	}
-- MCP operations should be used one at a time, similar to other tool usage. Wait for confirmation of success before proceeding with additional operations.
-
-====
-
-SYSTEM INFORMATION
-
-Operating System: ${osName()}
-Default Shell: ${getShell()}
-Home Directory: ${os.homedir().toPosix()}
-Current Working Directory: ${cwd.toPosix()}
-
-====
-
-OBJECTIVE
-
-You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
-
-1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
-2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
-3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis within <thinking></thinking> tags. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Then, think about which of the provided tools is the most relevant tool to accomplish the user's task. Next, go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, close the thinking tag and proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
-4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user. You may also provide a CLI command to showcase the result of your task; this can be particularly useful for web development tasks, where you can run e.g. \`open index.html\` to show the website you've built.
-5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`
-}

src/core/storage/StateManager.ts

@@ -16,17 +16,11 @@ import {
 	type SettingsKey,
 } from "@shared/storage/state-keys"
 import type { StorageContext } from "@shared/storage/storage-context"
-import chokidar, { FSWatcher } from "chokidar"
+import { FSWatcher } from "chokidar"
 import { initializeDistinctId } from "@/services/logging/distinctId"
 import { Logger } from "@/shared/services/Logger"
 import { AgentConfigLoader } from "../task/tools/subagent/AgentConfigLoader"
-import {
-	getTaskHistoryStateFilePath,
-	readTaskHistoryFromState,
-	readTaskSettingsFromStorage,
-	writeTaskHistoryToState,
-	writeTaskSettingsToStorage,
-} from "./disk"
+import { readTaskSettingsFromStorage, writeTaskSettingsToStorage } from "./disk"
 import { STATE_MANAGER_NOT_INITIALIZED } from "./error-messages"
 import { filterAllowedRemoteConfigFields } from "./remote-config/utils"
 import { readGlobalStateFromStorage, readSecretsFromStorage, readWorkspaceStateFromStorage } from "./utils/state-helpers"
@@ -146,9 +140,6 @@ export class StateManager {
 			// Use populate method to avoid triggering persistence during initialization
 			StateManager.instance.populateCache(globalState, secrets, workspaceState)
 
-			// Start watcher for taskHistory.json so external edits update cache (no persist loop)
-			await StateManager.instance.setupTaskHistoryWatcher()
-
 			StateManager.instance.isInitialized = true
 
 			await AgentConfigLoader.getInstance().ready()
@@ -246,7 +237,7 @@ export class StateManager {
 		if (!this.pendingTaskState.has(taskId)) {
 			this.pendingTaskState.set(taskId, new Set())
 		}
-		this.pendingTaskState.get(taskId)!.add(key)
+		this.pendingTaskState.get(taskId)?.add(key)
 		this.scheduleDebouncedPersistence()
 	}
 
@@ -266,7 +257,7 @@ export class StateManager {
 			this.pendingTaskState.set(taskId, new Set())
 		}
 		Object.keys(updates).forEach((key) => {
-			this.pendingTaskState.get(taskId)!.add(key as SettingsKey)
+			this.pendingTaskState.get(taskId)?.add(key as SettingsKey)
 		})
 
 		// Schedule debounced persistence
@@ -534,56 +525,6 @@ export class StateManager {
 		return cached.data[modelId]
 	}
 
-	/**
-	 * Initialize chokidar watcher for the taskHistory.json file
-	 * Updates in-memory cache on external changes without writing back to disk.
-	 */
-	private async setupTaskHistoryWatcher(): Promise<void> {
-		try {
-			const historyFile = await getTaskHistoryStateFilePath()
-
-			// Close any existing watcher before creating a new one
-			if (this.taskHistoryWatcher) {
-				await this.taskHistoryWatcher.close()
-				this.taskHistoryWatcher = null
-			}
-
-			this.taskHistoryWatcher = chokidar.watch(historyFile, {
-				persistent: true,
-				ignoreInitial: true,
-				atomic: true,
-				awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
-			})
-
-			const syncTaskHistoryFromDisk = async () => {
-				try {
-					if (!this.isInitialized) {
-						return
-					}
-					const onDisk = await readTaskHistoryFromState()
-					const cached = this.globalStateCache["taskHistory"]
-					if (JSON.stringify(onDisk) !== JSON.stringify(cached)) {
-						this.globalStateCache["taskHistory"] = onDisk
-						await this.onSyncExternalChange?.()
-					}
-				} catch (err) {
-					Logger.error("[StateManager] Failed to reload task history on change:", err)
-				}
-			}
-
-			this.taskHistoryWatcher
-				.on("add", () => syncTaskHistoryFromDisk())
-				.on("change", () => syncTaskHistoryFromDisk())
-				.on("unlink", async () => {
-					this.globalStateCache["taskHistory"] = []
-					await this.onSyncExternalChange?.()
-				})
-				.on("error", (error) => Logger.error("[StateManager] TaskHistory watcher error:", error))
-		} catch (err) {
-			Logger.error("[StateManager] Failed to set up taskHistory watcher:", err)
-		}
-	}
-
 	/**
 	 * Convenience method for getting API configuration
 	 * Ensures cache is initialized if not already done
@@ -819,8 +760,6 @@ export class StateManager {
 
 		for (const key of keys) {
 			if (key === "taskHistory") {
-				// Route task history persistence to its own file
-				await writeTaskHistoryToState(this.globalStateCache[key])
 			} else {
 				regularEntries[key] = this.globalStateCache[key]
 			}
@@ -928,7 +867,7 @@ export class StateManager {
 		// Preserve legacy fallback behavior for LiteLLM API key:
 		// if a remoteLiteLlmApiKey is set (via remote config), it should
 		// take precedence over the local liteLlmApiKey.
-		const remoteLiteLlmApiKey = this.secretsCache["remoteLiteLlmApiKey"]
+		const remoteLiteLlmApiKey = this.secretsCache.remoteLiteLlmApiKey
 		if (remoteLiteLlmApiKey !== undefined && remoteLiteLlmApiKey !== null && remoteLiteLlmApiKey !== "") {
 			secrets.liteLlmApiKey = remoteLiteLlmApiKey
 		}

src/core/storage/__tests__/disk.test.ts

@@ -1,6 +1,5 @@
 import { afterEach, beforeEach, describe, it } from "mocha"
 import "should"
-import { HistoryItem } from "@shared/HistoryItem"
 import * as fsUtils from "@utils/fs"
 import fs from "fs/promises"
 import os from "os"
@@ -8,15 +7,7 @@ import path from "path"
 import sinon from "sinon"
 import { HostProvider } from "@/hosts/host-provider"
 import { setVscodeHostProviderMock } from "@/test/host-provider-test-utils"
-import {
-	ensureStateDirectoryExists,
-	getAllHooksDirs,
-	getTaskHistoryStateFilePath,
-	getWorkspaceHooksDirs,
-	readTaskHistoryFromState,
-	setRuntimeHooksDir,
-	writeTaskHistoryToState,
-} from "../disk"
+import { getAllHooksDirs, getWorkspaceHooksDirs, setRuntimeHooksDir } from "../disk"
 import { StateManager } from "../StateManager"
 
 describe("disk - hooks functionality", () => {
@@ -34,7 +25,7 @@ describe("disk - hooks functionality", () => {
 		setRuntimeHooksDir(undefined)
 		try {
 			await fs.rm(tempDir, { recursive: true, force: true })
-		} catch (error) {
+		} catch (_error) {
 			// Ignore cleanup errors
 		}
 	})
@@ -266,29 +257,6 @@ describe("disk - atomic writes", () => {
 		}
 	})
 
-	/**
-	 * Helper to create test history items
-	 */
-	const createTestHistoryItem = (id: string, task: string): HistoryItem => {
-		return {
-			id,
-			ts: Date.now(),
-			task,
-			tokensIn: 100,
-			tokensOut: 200,
-			totalCost: 0.01,
-		}
-	}
-
-	/**
-	 * Helper to check for orphaned temp files
-	 */
-	const getTempFileCount = async (): Promise<number> => {
-		const stateDir = await ensureStateDirectoryExists()
-		const files = await fs.readdir(stateDir)
-		return files.filter((f) => f.startsWith("taskHistory.json.tmp.")).length
-	}
-
 	beforeEach(async () => {
 		sandbox = sinon.createSandbox()
 	})
@@ -296,356 +264,4 @@ describe("disk - atomic writes", () => {
 	afterEach(async () => {
 		sandbox.restore()
 	})
-
-	describe("writeTaskHistoryToState and readTaskHistoryFromState", () => {
-		it("should write and read task history correctly", async () => {
-			const items = [createTestHistoryItem("test-1", "Build a todo app"), createTestHistoryItem("test-2", "Fix a bug")]
-
-			await writeTaskHistoryToState(items)
-			const result = await readTaskHistoryFromState()
-
-			result.should.be.an.Array()
-			result.should.have.length(2)
-			result[0].id.should.equal("test-1")
-			result[0].task.should.equal("Build a todo app")
-			result[1].id.should.equal("test-2")
-			result[1].task.should.equal("Fix a bug")
-		})
-
-		it("should write valid JSON that can be parsed", async () => {
-			const items = [
-				createTestHistoryItem("test-json-1", "Test with special chars: 你好 🎉"),
-				createTestHistoryItem("test-json-2", "Test with quotes: \"hello\" and 'world'"),
-			]
-
-			await writeTaskHistoryToState(items)
-
-			// Read the raw file and verify it's valid JSON
-			const filePath = await getTaskHistoryStateFilePath()
-			const rawContent = await fs.readFile(filePath, "utf8")
-			const parsed = JSON.parse(rawContent) // Should not throw
-
-			parsed.should.be.an.Array()
-			parsed.should.have.length(2)
-		})
-
-		it("should not leave temp files after successful write", async () => {
-			const items = [createTestHistoryItem("cleanup-test", "Test cleanup")]
-
-			const tempCountBefore = await getTempFileCount()
-			await writeTaskHistoryToState(items)
-			const tempCountAfter = await getTempFileCount()
-
-			tempCountAfter.should.equal(tempCountBefore)
-		})
-
-		it("should handle empty array writes", async () => {
-			await writeTaskHistoryToState([])
-			const result = await readTaskHistoryFromState()
-
-			result.should.be.an.Array()
-			result.should.have.length(0)
-		})
-
-		it("should handle large task history arrays", async function () {
-			this.timeout(30000) // 30 second timeout for large file operations
-
-			// Create large task content by repeating a pattern (each task ~50 KB)
-			const baseContent = "X".repeat(50 * 1024) // 50 KB of X's per task
-
-			// Create 1,000 history items (resulting in ~50 MB file)
-			const items = Array.from({ length: 1000 }, (_, i) =>
-				createTestHistoryItem(`stress-test-${i}`, `Task ${i}: ${baseContent}`),
-			)
-
-			await writeTaskHistoryToState(items)
-			const result = await readTaskHistoryFromState()
-
-			// Verify array length and data integrity
-			result.should.have.length(1000)
-			result[0].id.should.equal("stress-test-0")
-			result[0].task.should.startWith("Task 0: X")
-			result[500].id.should.equal("stress-test-500")
-			result[999].id.should.equal("stress-test-999")
-		})
-
-		it("should handle concurrent writes without corruption", async function () {
-			this.timeout(30000)
-
-			// Perform many concurrent writes to stress test atomicity
-			const writePromises = Array.from({ length: 100 }, (_, i) => {
-				const items = [createTestHistoryItem(`concurrent-${i}`, `Task ${i}`)]
-				return writeTaskHistoryToState(items).catch((error) => {
-					// On Windows, concurrent renames may fail with EPERM - this is expected
-					if (process.platform === "win32" && error.code === "EPERM") {
-						return // Expected Windows behavior
-					}
-					throw error // Unexpected error, rethrow
-				})
-			})
-
-			// Wait for all writes to complete (some may fail on Windows with EPERM)
-			await Promise.all(writePromises)
-
-			// Final read should return valid JSON (not corrupted)
-			const result = await readTaskHistoryFromState()
-			result.should.be.an.Array()
-			// Should have data from one of the concurrent writes that succeeded
-			result.length.should.be.greaterThan(0)
-			// Verify the data is valid (not corrupted)
-			result[0].should.have.property("id")
-			result[0].should.have.property("task")
-		})
-
-		it("should preserve data integrity with special characters", async () => {
-			const items = [
-				createTestHistoryItem("special-1", "Test\nwith\nnewlines"),
-				createTestHistoryItem("special-2", "Test\twith\ttabs"),
-				createTestHistoryItem("special-3", "Test with unicode: 日本語 中文 한국어"),
-				createTestHistoryItem("special-4", "Test with emojis: 😀🎉🚀"),
-			]
-
-			await writeTaskHistoryToState(items)
-			const result = await readTaskHistoryFromState()
-
-			result.should.have.length(4)
-			result[0].task.should.equal("Test\nwith\nnewlines")
-			result[1].task.should.equal("Test\twith\ttabs")
-			result[2].task.should.equal("Test with unicode: 日本語 中文 한국어")
-			result[3].task.should.equal("Test with emojis: 😀🎉🚀")
-		})
-
-		it("should overwrite existing task history", async () => {
-			// Write initial data
-			const initialItems = [createTestHistoryItem("initial-1", "Initial task")]
-			await writeTaskHistoryToState(initialItems)
-
-			// Verify initial data
-			let result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("initial-1")
-
-			// Overwrite with new data
-			const newItems = [createTestHistoryItem("new-1", "New task 1"), createTestHistoryItem("new-2", "New task 2")]
-			await writeTaskHistoryToState(newItems)
-
-			// Verify new data replaced old data
-			result = await readTaskHistoryFromState()
-			result.should.have.length(2)
-			result[0].id.should.equal("new-1")
-			result[1].id.should.equal("new-2")
-		})
-
-		it("should handle rapid successive writes", async function () {
-			this.timeout(5000)
-
-			// Perform rapid successive writes (not concurrent)
-			for (let i = 0; i < 20; i++) {
-				const items = [createTestHistoryItem(`rapid-${i}`, `Task ${i}`)]
-				await writeTaskHistoryToState(items)
-			}
-
-			// Should have no temp files left
-			const tempCount = await getTempFileCount()
-			tempCount.should.equal(0)
-
-			// Final read should be valid
-			const result = await readTaskHistoryFromState()
-			result.should.be.an.Array()
-			result.should.have.length(1)
-			result[0].id.should.equal("rapid-19")
-		})
-
-		it("should preserve all HistoryItem fields", async () => {
-			const items = [
-				{
-					id: "full-test",
-					ts: 1234567890,
-					task: "Complete task",
-					tokensIn: 500,
-					tokensOut: 1000,
-					totalCost: 0.15,
-					cacheWrites: 100,
-					cacheReads: 200,
-				},
-			]
-
-			await writeTaskHistoryToState(items)
-			const result = await readTaskHistoryFromState()
-
-			result.should.have.length(1)
-			result[0].id.should.equal("full-test")
-			result[0].ts.should.equal(1234567890)
-			result[0].task.should.equal("Complete task")
-			result[0].tokensIn.should.equal(500)
-			result[0].tokensOut.should.equal(1000)
-			result[0].totalCost.should.equal(0.15)
-			result[0].cacheWrites!.should.equal(100)
-			result[0].cacheReads!.should.equal(200)
-		})
-	})
-
-	describe("atomic write failure scenarios", () => {
-		it("should leave original file intact if temp file write fails", async () => {
-			// Write initial data
-			const initialItems = [createTestHistoryItem("original-1", "Original task")]
-			await writeTaskHistoryToState(initialItems)
-
-			// Verify initial data exists
-			let result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("original-1")
-
-			// Stub fs.writeFile to fail during temp file creation
-			const writeFileStub = sandbox.stub(fs, "writeFile")
-			writeFileStub.rejects(new Error("Simulated write failure"))
-
-			// Attempt to write new data (should fail)
-			const newItems = [createTestHistoryItem("new-1", "New task")]
-			try {
-				await writeTaskHistoryToState(newItems)
-				throw new Error("Should have thrown")
-			} catch (error: any) {
-				error.message.should.equal("Simulated write failure")
-			}
-
-			// Original file should still be intact
-			result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("original-1")
-
-			// No temp files should remain
-			const tempCount = await getTempFileCount()
-			tempCount.should.equal(0)
-		})
-
-		it("should leave original file intact if rename fails", async () => {
-			// Write initial data
-			const initialItems = [createTestHistoryItem("original-2", "Original task 2")]
-			await writeTaskHistoryToState(initialItems)
-
-			// Verify initial data exists
-			let result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("original-2")
-
-			// Stub fs.rename to fail
-			const renameStub = sandbox.stub(fs, "rename")
-			renameStub.rejects(new Error("Simulated rename failure"))
-
-			// Attempt to write new data (should fail)
-			const newItems = [createTestHistoryItem("new-2", "New task 2")]
-			try {
-				await writeTaskHistoryToState(newItems)
-				throw new Error("Should have thrown")
-			} catch (error: any) {
-				error.message.should.equal("Simulated rename failure")
-			}
-
-			// Original file should still be intact
-			result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("original-2")
-
-			// Temp file cleanup may or may not succeed, but original file is safe
-			// (The atomicWriteFile function attempts cleanup but doesn't throw if it fails)
-		})
-
-		it("should ignore temp files during read operations", async () => {
-			// Write valid data
-			const items = [createTestHistoryItem("valid-1", "Valid task")]
-			await writeTaskHistoryToState(items)
-
-			// Create a corrupt temp file manually
-			const stateDir = await ensureStateDirectoryExists()
-			const corruptTempPath = path.join(stateDir, "taskHistory.json.tmp.12345.corrupt")
-			await fs.writeFile(corruptTempPath, "INVALID JSON{", "utf8")
-
-			// Read should succeed and ignore the temp file
-			const result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("valid-1")
-
-			// Cleanup temp file
-			await fs.unlink(corruptTempPath)
-		})
-
-		it("should handle concurrent read during write without corruption", async () => {
-			// Write initial data
-			const initialItems = [createTestHistoryItem("concurrent-read-1", "Initial task")]
-			await writeTaskHistoryToState(initialItems)
-
-			// Create a slow rename by stubbing fs.rename to delay
-			// This simulates the critical window where temp file is written but rename hasn't occurred
-			let renameResolve: () => void
-			const renamePromise = new Promise<void>((resolve) => {
-				renameResolve = resolve
-			})
-
-			const originalRename = fs.rename
-			const renameStub = sandbox.stub(fs, "rename")
-			renameStub.callsFake(async (oldPath, newPath) => {
-				// Delay the rename operation
-				await renamePromise // Wait for our signal
-				return originalRename(oldPath, newPath)
-			})
-
-			// Start a write operation (rename will be delayed)
-			const newItems = [createTestHistoryItem("concurrent-read-2", "New task")]
-			const writeOperation = writeTaskHistoryToState(newItems)
-
-			// Give temp file time to be written, but before rename completes
-			await new Promise((resolve) => setTimeout(resolve, 50))
-
-			// Perform a read during the critical window (temp file exists, but rename hasn't happened)
-			const readResult = await readTaskHistoryFromState()
-
-			// Should get old data (since rename hasn't completed yet)
-			readResult.should.have.length(1)
-			readResult[0].id.should.equal("concurrent-read-1")
-
-			// Now allow rename to complete
-			renameResolve!()
-			await writeOperation
-
-			// Subsequent read should get new data
-			const finalResult = await readTaskHistoryFromState()
-			finalResult.should.have.length(1)
-			finalResult[0].id.should.equal("concurrent-read-2")
-		})
-
-		it("should handle partial temp file from interrupted process", async () => {
-			// Write initial valid data
-			const initialItems = [createTestHistoryItem("partial-test-1", "Initial task")]
-			await writeTaskHistoryToState(initialItems)
-
-			// Simulate an interrupted write by creating a partial temp file
-			const stateDir = await ensureStateDirectoryExists()
-			const partialTempPath = path.join(stateDir, "taskHistory.json.tmp.99999.partial")
-
-			// Write only part of a valid JSON array
-			await fs.writeFile(partialTempPath, '[{"id":"partial","ts":123456789', "utf8")
-
-			// Read should succeed with original data
-			const result = await readTaskHistoryFromState()
-			result.should.have.length(1)
-			result[0].id.should.equal("partial-test-1")
-
-			// Write new data should succeed and clean up
-			const newItems = [createTestHistoryItem("partial-test-2", "New task")]
-			await writeTaskHistoryToState(newItems)
-
-			// Verify new data
-			const finalResult = await readTaskHistoryFromState()
-			finalResult.should.have.length(1)
-			finalResult[0].id.should.equal("partial-test-2")
-
-			// Cleanup our partial temp file if it still exists
-			try {
-				await fs.unlink(partialTempPath)
-			} catch {
-				// May already be cleaned up
-			}
-		})
-	})
 })

src/core/storage/disk.ts

@@ -1,8 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 import { EnvironmentMetadataEntry, TaskMetadata } from "@core/context/context-tracking/ContextTrackerTypes"
 import { execa } from "@packages/execa"
-import { ClineMessage } from "@shared/ExtensionMessage"
-import { HistoryItem } from "@shared/HistoryItem"
 import { RemoteConfig } from "@shared/remote-config/schema"
 import { GlobalState, Settings } from "@shared/storage/state-keys"
 import { fileExistsAtPath, isDirectory } from "@utils/fs"
@@ -11,11 +9,9 @@ import os from "os"
 import * as path from "path"
 import { HostProvider } from "@/hosts/host-provider"
 import { ExtensionRegistryInfo } from "@/registry"
-import { telemetryService } from "@/services/telemetry"
 import { McpMarketplaceCatalog } from "@/shared/mcp"
 import { Logger } from "@/shared/services/Logger"
 import { syncWorker } from "@/shared/services/worker/sync"
-import { reconstructTaskHistory } from "../commands/reconstructTaskHistory"
 import { StateManager } from "./StateManager"
 
 /**
@@ -259,31 +255,6 @@ export async function saveApiConversationHistory(taskId: string, apiConversation
 	}
 }
 
-export async function getSavedClineMessages(taskId: string): Promise<ClineMessage[]> {
-	const filePath = path.join(await ensureTaskDirectoryExists(taskId), GlobalFileNames.uiMessages)
-	if (await fileExistsAtPath(filePath)) {
-		return JSON.parse(await fs.readFile(filePath, "utf8"))
-	}
-	// check old location
-	const oldPath = path.join(await ensureTaskDirectoryExists(taskId), "claude_messages.json")
-	if (await fileExistsAtPath(oldPath)) {
-		const data = JSON.parse(await fs.readFile(oldPath, "utf8"))
-		await fs.unlink(oldPath) // remove old file
-		return data
-	}
-	return []
-}
-
-export async function saveClineMessages(taskId: string, uiMessages: ClineMessage[]) {
-	try {
-		const taskDir = await ensureTaskDirectoryExists(taskId)
-		const filePath = path.join(taskDir, GlobalFileNames.uiMessages)
-		await atomicWriteFile(filePath, JSON.stringify(uiMessages))
-	} catch (error) {
-		Logger.error("Failed to save ui messages:", error)
-	}
-}
-
 /**
  * Collects environment metadata for the current system and host.
  * This information is used for debugging and task portability.
@@ -375,57 +346,6 @@ async function getGlobalStorageDir(...subdirs: string[]) {
 	return fullPath
 }
 
-export async function getTaskHistoryStateFilePath(): Promise<string> {
-	return path.join(await ensureStateDirectoryExists(), "taskHistory.json")
-}
-
-export async function taskHistoryStateFileExists(): Promise<boolean> {
-	const filePath = await getTaskHistoryStateFilePath()
-	return fileExistsAtPath(filePath)
-}
-
-export async function readTaskHistoryFromState(): Promise<HistoryItem[]> {
-	try {
-		const filePath = await getTaskHistoryStateFilePath()
-		if (!(await fileExistsAtPath(filePath))) {
-			return []
-		}
-
-		const contents = await fs.readFile(filePath, "utf8")
-
-		try {
-			return JSON.parse(contents)
-		} catch (parseError) {
-			telemetryService.captureExtensionStorageError(parseError, "parseError_attemptingRecovery")
-
-			const result = await reconstructTaskHistory(false)
-			if (result && result.reconstructedTasks > 0) {
-				// Read the reconstructed file
-				const newContents = await fs.readFile(filePath, "utf8")
-				return JSON.parse(newContents)
-			}
-
-			// Recovery failed, all we can do is return an empty array or throw an error, thus preventing the app from starting up
-			// This will wipe out the taskHistory
-			return []
-		}
-	} catch (error) {
-		// Filesystem or other errors - throw them for the caller to handle
-		telemetryService.captureExtensionStorageError(error, "readTaskHistoryFromState")
-		throw error
-	}
-}
-
-export async function writeTaskHistoryToState(items: HistoryItem[]): Promise<void> {
-	try {
-		const filePath = await getTaskHistoryStateFilePath()
-		await atomicWriteFile(filePath, JSON.stringify(items))
-	} catch (error) {
-		Logger.error("[Disk] Failed to write task history:", error)
-		throw error
-	}
-}
-
 export async function readTaskSettingsFromStorage(taskId: string): Promise<Partial<GlobalState>> {
 	try {
 		const taskDirectoryFilePath = await ensureTaskDirectoryExists(taskId)

src/core/storage/state-migrations.ts

@@ -1,9 +1,8 @@
 import fs from "fs/promises"
 import path from "path"
 import * as vscode from "vscode"
-import { HistoryItem } from "@/shared/HistoryItem"
 import { Logger } from "@/shared/services/Logger"
-import { ensureRulesDirectoryExists, readTaskHistoryFromState, writeTaskHistoryToState } from "./disk"
+import { ensureRulesDirectoryExists } from "./disk"
 
 export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionContext) {
 	// Keys to migrate from workspace storage back to global storage
@@ -67,58 +66,8 @@ export async function migrateWorkspaceToGlobalStorage(context: vscode.ExtensionC
 	}
 }
 
-export async function migrateTaskHistoryToFile(context: vscode.ExtensionContext) {
-	try {
-		// Get data from old location
-		const vscodeGlobalStateTaskHistory = context.globalState.get<HistoryItem[] | undefined>("taskHistory")
-
-		// Normalize old location data to array (empty array if undefined/null/not-array)
-		const oldLocationData = Array.isArray(vscodeGlobalStateTaskHistory) ? vscodeGlobalStateTaskHistory : []
-
-		// Early return if no migration needed
-		if (oldLocationData.length === 0) {
-			Logger.log("[Storage Migration] No task history to migrate")
-			return
-		}
-
-		let finalData: HistoryItem[]
-		let migrationAction: string
-
-		const newLocationData = await readTaskHistoryFromState()
-
-		if (newLocationData.length === 0) {
-			// Move old data to new location
-			finalData = oldLocationData
-			migrationAction = "Migrated task history from old location to new location"
-		} else {
-			// Merge old data (more recent) with new data
-			finalData = [...newLocationData, ...oldLocationData]
-			migrationAction = "Merged task history from old and new locations"
-		}
-
-		// Perform migration operations sequentially - only clear old data if write succeeds
-		await writeTaskHistoryToState(finalData)
-
-		const successfullyWrittenData = await readTaskHistoryFromState()
-
-		if (!Array.isArray(successfullyWrittenData)) {
-			Logger.error("[Storage Migration] Failed to write taskHistory to file: Written data is not an array")
-			return
-		}
-
-		if (successfullyWrittenData.length !== finalData.length) {
-			Logger.error(
-				"[Storage Migration] Failed to write taskHistory to file: Written data does not match the old location data",
-			)
-			return
-		}
-
-		await context.globalState.update("taskHistory", undefined)
-
-		Logger.log(`[Storage Migration] ${migrationAction}`)
-	} catch (error) {
-		Logger.error("[Storage Migration] Failed to migrate task history to file:", error)
-	}
+export async function migrateTaskHistoryToFile(_context: vscode.ExtensionContext) {
+	// TODO migrate to sdk location
 }
 
 export async function migrateMcpMarketplaceEnableSetting(mcpMarketplaceEnabledRaw: boolean | undefined): Promise<boolean> {

src/core/storage/utils/state-helpers.ts

@@ -14,7 +14,6 @@ import {
 } from "@shared/storage/state-keys"
 import { Logger } from "@/shared/services/Logger"
 import { ClineMemento } from "@/shared/storage"
-import { readTaskHistoryFromState } from "../disk"
 import { StateManager } from "../StateManager"
 
 // ─── File-backed storage readers (used by StateManager) ────────────────────
@@ -76,7 +75,6 @@ export async function readGlobalStateFromStorage(store: ClineMemento): Promise<G
 		}
 
 		await handleComputedProperties(result, stateValues)
-		await handleAsyncProperties(result)
 
 		return result as GlobalStateAndSettings
 	} catch (error) {
@@ -106,14 +104,6 @@ async function handleComputedProperties(result: any, stateValues: Map<string, an
 	}
 }
 
-/**
- * Handle properties that require async operations
- */
-async function handleAsyncProperties(result: any): Promise<void> {
-	// Task history requires async disk read
-	result.taskHistory = await readTaskHistoryFromState()
-}
-
 export async function resetWorkspaceState() {
 	const stateManager = StateManager.get()
 	LocalStateKeys.map((key) => stateManager.setWorkspaceState(key, {}))

src/core/task/StreamChunkCoordinator.ts

@@ -1,119 +0,0 @@
-import { ApiStream, ApiStreamChunk, ApiStreamUsageChunk } from "@core/api/transform/stream"
-import { Logger } from "@/shared/services/Logger"
-
-/*
-This coordinator splits stream handling into two paths:
-
-1) usage chunks:
-   - processed immediately via onUsageChunk
-   - used to keep token/cost state current while the request is still active
-
-2) non-usage chunks (text/reasoning/tool_calls):
-   - queued and consumed by the normal Task flow
-   - that flow may await tool execution or ask prompts, which can block for user input
-
-Without this split, usage updates can be delayed behind awaited UI/tool work.
-*/
-export type NonUsageApiStreamChunk = Exclude<ApiStreamChunk, { type: "usage" }>
-
-type StreamChunkCoordinatorOptions = {
-	onUsageChunk: (chunk: ApiStreamUsageChunk) => void
-}
-
-export class StreamChunkCoordinator {
-	private iterator: AsyncGenerator<ApiStreamChunk>
-	private queue: NonUsageApiStreamChunk[] = []
-	private readError: unknown
-	private completed = false
-	private stopRequested = false
-	private waiterResolve: (() => void) | undefined
-	private pumpPromise: Promise<void>
-
-	constructor(
-		stream: ApiStream,
-		private readonly options: StreamChunkCoordinatorOptions,
-	) {
-		this.iterator = stream[Symbol.asyncIterator]()
-		this.pumpPromise = this.startPump()
-	}
-
-	private notifyWaiter() {
-		if (this.waiterResolve) {
-			this.waiterResolve()
-			this.waiterResolve = undefined
-		}
-	}
-
-	private async waitForData() {
-		if (this.queue.length > 0 || this.completed || this.readError) {
-			return
-		}
-		await new Promise<void>((resolve) => {
-			this.waiterResolve = resolve
-		})
-	}
-
-	private async closeIterator() {
-		if (typeof this.iterator.return !== "function") {
-			return
-		}
-		try {
-			await this.iterator.return(undefined)
-		} catch (error) {
-			Logger.debug(`[StreamChunkCoordinator] Failed to close stream iterator: ${error}`)
-		}
-	}
-
-	private startPump(): Promise<void> {
-		return (async () => {
-			try {
-				while (!this.stopRequested) {
-					const { value: chunk, done } = await this.iterator.next()
-					if (done || !chunk) {
-						break
-					}
-					if (chunk.type === "usage") {
-						this.options.onUsageChunk(chunk)
-						continue
-					}
-					this.queue.push(chunk)
-					this.notifyWaiter()
-				}
-			} catch (error) {
-				this.readError = error
-			} finally {
-				this.completed = true
-				this.notifyWaiter()
-			}
-		})()
-	}
-
-	async nextChunk(): Promise<NonUsageApiStreamChunk | undefined> {
-		while (true) {
-			if (this.readError) {
-				throw this.readError
-			}
-			const chunk = this.queue.shift()
-			if (chunk) {
-				return chunk
-			}
-			if (this.completed) {
-				return undefined
-			}
-			await this.waitForData()
-		}
-	}
-
-	async stop(): Promise<void> {
-		this.stopRequested = true
-		await this.closeIterator()
-		await this.pumpPromise.catch(() => {})
-	}
-
-	async waitForCompletion(): Promise<void> {
-		await this.pumpPromise
-		if (this.readError) {
-			throw this.readError
-		}
-	}
-}

src/core/task/StreamResponseHandler.ts

@@ -1,351 +0,0 @@
-import type { ToolUse } from "@core/assistant-message"
-import { JSONParser } from "@streamparser/json"
-import { nanoid } from "nanoid"
-import { McpHub } from "@/services/mcp/McpHub"
-import { CLINE_MCP_TOOL_IDENTIFIER } from "@/shared/mcp"
-import {
-	ClineAssistantRedactedThinkingBlock,
-	ClineAssistantThinkingBlock,
-	ClineAssistantToolUseBlock,
-	ClineReasoningDetailParam,
-} from "@/shared/messages/content"
-import { Session } from "@/shared/services/Session"
-import { ClineDefaultTool } from "@/shared/tools"
-
-export interface PendingToolUse {
-	id: string
-	name: string
-	input: string
-	parsedInput?: unknown
-	signature?: string
-	jsonParser?: JSONParser
-	call_id: string
-}
-
-interface ToolUseDeltaBlock {
-	id?: string
-	type?: string
-	name?: string
-	input?: string
-	signature?: string
-}
-
-export interface ReasoningDelta {
-	id?: string
-	reasoning?: string
-	signature?: string
-	details?: any[]
-	redacted_data?: any
-}
-
-export interface PendingReasoning {
-	id?: string
-	content: string
-	signature: string
-	redactedThinking: ClineAssistantRedactedThinkingBlock[]
-	summary: unknown[] | ClineReasoningDetailParam[]
-}
-
-const ESCAPE_MAP: Record<string, string> = {
-	"\\n": "\n",
-	"\\t": "\t",
-	"\\r": "\r",
-	'\\"': '"',
-	"\\\\": "\\",
-}
-
-const ESCAPE_PATTERN = /\\[ntr"\\]/g
-
-export class StreamResponseHandler {
-	private toolUseHandler = new ToolUseHandler()
-	private reasoningHandler = new ReasoningHandler()
-
-	private _requestId: string | undefined
-
-	public setRequestId(id?: string) {
-		if (!this._requestId && id) {
-			this._requestId = id
-		}
-	}
-
-	public get requestId() {
-		return this._requestId
-	}
-
-	public getHandlers() {
-		return {
-			toolUseHandler: this.toolUseHandler,
-			reasonsHandler: this.reasoningHandler,
-		}
-	}
-
-	public reset() {
-		this._requestId = undefined
-		this.toolUseHandler = new ToolUseHandler()
-		this.reasoningHandler = new ReasoningHandler()
-	}
-}
-
-/**
- * Handles streaming native tool use blocks and converts them to ClineAssistantToolUseBlock format
- */
-class ToolUseHandler {
-	private pendingToolUses = new Map<string, PendingToolUse>()
-
-	processToolUseDelta(delta: ToolUseDeltaBlock, call_id?: string): void {
-		if (delta.type !== "tool_use" || !delta.id) {
-			return
-		}
-
-		let pending = this.pendingToolUses.get(delta.id)
-		if (!pending) {
-			pending = this.createPendingToolUse(delta.id, delta.name || "", call_id)
-		}
-
-		if (delta.name) {
-			pending.name = delta.name
-		}
-
-		if (delta.signature) {
-			pending.signature = delta.signature
-		}
-
-		if (delta.input) {
-			pending.input += delta.input
-			try {
-				pending.jsonParser?.write(delta.input)
-			} catch {
-				// Expected during streaming - JSONParser may not have complete JSON yet
-			}
-		}
-	}
-
-	getFinalizedToolUse(id: string): ClineAssistantToolUseBlock | undefined {
-		const pending = this.pendingToolUses.get(id)
-		if (!pending?.name) {
-			return undefined
-		}
-
-		let input: unknown = {}
-		if (pending.parsedInput != null) {
-			input = pending.parsedInput
-		} else if (pending.input) {
-			try {
-				input = JSON.parse(pending.input)
-			} catch {
-				input = this.extractPartialJsonFields(pending.input)
-			}
-		}
-
-		return {
-			type: "tool_use",
-			id: pending.id,
-			name: pending.name,
-			input,
-			signature: pending.signature,
-			call_id: pending.call_id,
-		}
-	}
-
-	getAllFinalizedToolUses(summary?: ClineAssistantToolUseBlock["reasoning_details"]): ClineAssistantToolUseBlock[] {
-		const results: ClineAssistantToolUseBlock[] = []
-		for (const id of this.pendingToolUses.keys()) {
-			const toolUse = this.getFinalizedToolUse(id)
-			if (toolUse) {
-				results.push({ ...toolUse, reasoning_details: summary })
-			}
-		}
-		return results
-	}
-
-	hasToolUse(id: string): boolean {
-		return this.pendingToolUses.has(id)
-	}
-
-	getPartialToolUsesAsContent(): ToolUse[] {
-		const results: ToolUse[] = []
-		const pendingToolUses = this.pendingToolUses.values()
-
-		for (const pending of pendingToolUses) {
-			if (!pending.name) {
-				continue
-			}
-
-			// Try to get the most up-to-date parsed input
-			// Priority: parsedInput (from JSONParser) > fallback to manual parsing
-			let input: any = {}
-			if (pending.parsedInput != null) {
-				input = pending.parsedInput
-			} else if (pending.input) {
-				// Try full JSON parse first
-				try {
-					input = JSON.parse(pending.input)
-				} catch {
-					// Fall back to extracting partial fields from incomplete JSON
-					input = this.extractPartialJsonFields(pending.input)
-				}
-			}
-
-			if (pending.name.includes(CLINE_MCP_TOOL_IDENTIFIER)) {
-				const [key, toolName] = pending.name.split(CLINE_MCP_TOOL_IDENTIFIER)
-				results.push({
-					type: "tool_use",
-					name: ClineDefaultTool.MCP_USE,
-					params: {
-						server_name: McpHub.getMcpServerByKey(key),
-						tool_name: toolName,
-						arguments: JSON.stringify(input),
-					},
-					partial: true,
-					isNativeToolCall: true,
-					signature: pending.signature,
-					call_id: pending.call_id,
-				})
-			} else {
-				const params: Record<string, string> = {}
-				if (typeof input === "object" && input !== null) {
-					for (const [key, value] of Object.entries(input)) {
-						params[key] = typeof value === "string" ? value : JSON.stringify(value)
-					}
-				}
-				results.push({
-					type: "tool_use",
-					name: pending.name as ClineDefaultTool,
-					params: params as any,
-					partial: true,
-					signature: pending.signature,
-					isNativeToolCall: true,
-					call_id: pending.call_id,
-				})
-			}
-		}
-		// Ensure all returned tool uses are marked as partial
-		return results.map((t) => ({ ...t, partial: true }))
-	}
-
-	reset(): void {
-		this.pendingToolUses.clear()
-	}
-
-	private createPendingToolUse(id: string, name: string, callId?: string): PendingToolUse {
-		const jsonParser = new JSONParser()
-		jsonParser.onValue = (info: any) => {
-			if (info.stack.length === 0 && info.value && typeof info.value === "object") {
-				pending.parsedInput = info.value
-			}
-		}
-
-		jsonParser.onError = () => {}
-
-		const pending: PendingToolUse = {
-			id,
-			name,
-			input: "",
-			parsedInput: undefined,
-			jsonParser,
-			// Ensure call_id is always set for tracking
-			call_id: callId || id || nanoid(8),
-			signature: undefined,
-		}
-
-		this.pendingToolUses.set(id, pending)
-		// Initialize tool call in session tracking
-		Session.get().updateToolCall(pending.call_id, pending.name)
-
-		return pending
-	}
-
-	private extractPartialJsonFields(partialJson: string): Record<string, any> {
-		const result: Record<string, any> = {}
-		const pattern = /"(\w+)":\s*"((?:[^"\\]|\\.)*)(?:")?/g
-
-		for (const match of partialJson.matchAll(pattern)) {
-			result[match[1]] = match[2].replace(ESCAPE_PATTERN, (m) => ESCAPE_MAP[m])
-		}
-
-		return result
-	}
-}
-
-/**
- * Handles streaming reasoning content and converts it to the appropriate message format
- */
-class ReasoningHandler {
-	private pendingReasoning: PendingReasoning | null = null
-
-	processReasoningDelta(delta: ReasoningDelta): void {
-		// Initialize pending reasoning if we have an ID but no pending reasoning yet
-		if (!this.pendingReasoning) {
-			this.pendingReasoning = {
-				id: delta.id,
-				content: "",
-				signature: "",
-				redactedThinking: [],
-				summary: [],
-			}
-		}
-
-		if (!this.pendingReasoning) {
-			return
-		}
-
-		// Update fields from delta
-		if (delta.reasoning) {
-			this.pendingReasoning.content += delta.reasoning
-		}
-		if (delta.signature) {
-			this.pendingReasoning.signature = delta.signature
-		}
-		if (delta.details) {
-			if (Array.isArray(delta.details)) {
-				this.pendingReasoning.summary.push(...delta.details)
-			} else {
-				this.pendingReasoning.summary.push(delta.details)
-			}
-		}
-		if (delta.redacted_data) {
-			this.pendingReasoning.redactedThinking.push({
-				type: "redacted_thinking",
-				data: delta.redacted_data,
-				call_id: delta.id || this.pendingReasoning.id,
-			})
-		}
-	}
-
-	getCurrentReasoning(): ClineAssistantThinkingBlock | null {
-		if (!this.pendingReasoning) {
-			return null
-		}
-
-		if (!this.pendingReasoning.summary.length && !this.pendingReasoning.content) {
-			return null
-		}
-
-		// Ensure signature is set if it's hidden in the summary / reasoning details
-		// to ensure it's always accessible at the top level by each provider.
-		if (!this.pendingReasoning.signature && this.pendingReasoning.summary.length) {
-			const lastSummary = this.pendingReasoning.summary.at(-1)
-			if (lastSummary && typeof lastSummary === "object" && "signature" in lastSummary) {
-				if (typeof lastSummary.signature === "string") {
-					this.pendingReasoning.signature = lastSummary.signature
-				}
-			}
-		}
-
-		return {
-			type: "thinking",
-			thinking: this.pendingReasoning.content,
-			signature: this.pendingReasoning.signature,
-			summary: this.pendingReasoning.summary,
-			call_id: this.pendingReasoning.id,
-		}
-	}
-
-	getRedactedThinking(): ClineAssistantRedactedThinkingBlock[] {
-		return this.pendingReasoning?.redactedThinking || []
-	}
-
-	reset(): void {
-		this.pendingReasoning = null
-	}
-}

src/core/task/TaskLockUtils.ts

@@ -1,36 +0,0 @@
-import { releaseFolderLock, tryAcquireFolderLockWithRetry } from "@/core/locks/FolderLockUtils"
-import type { FolderLockOptions, FolderLockWithRetryResult } from "@/core/locks/types"
-
-/**
- * Base path for task folders
- */
-const TASKS_BASE_PATH = "~/.cline/data/tasks"
-
-/**
- * Attempt to acquire task folder lock with retry logic.
- * This is a convenience wrapper around the generic folder lock utility
- * that uses the taskId as the lock target.
- *
- * @param taskId - The unique identifier for the task
- * @returns Promise<FolderLockWithRetryResult> with acquisition status and any conflicting lock info
- */
-export async function tryAcquireTaskLockWithRetry(taskId: string): Promise<FolderLockWithRetryResult> {
-	const options: FolderLockOptions = {
-		lockTarget: `${TASKS_BASE_PATH}/${taskId}`,
-		heldBy: taskId, // will be automatically swapped for instance address in SqliteLockManager
-	}
-
-	const result = await tryAcquireFolderLockWithRetry(options)
-	return { acquired: result.acquired, skipped: result.skipped, conflictingLock: result.conflictingLock }
-}
-
-/**
- * Release task folder lock safely.
- * This is a convenience wrapper around the generic folder lock utility
- * that uses the taskId as the lock target.
- *
- * @param taskId - The unique identifier for the task
- */
-export async function releaseTaskLock(taskId: string): Promise<void> {
-	await releaseFolderLock(taskId, `${TASKS_BASE_PATH}/${taskId}`)
-}

src/core/task/TaskPresentationScheduler.ts

@@ -1,253 +0,0 @@
-import type { PresentationPriority } from "./presentation-types"
-
-export type { PresentationPriority }
-
-type TaskPresentationSchedulerOptions = {
-	flush: () => Promise<void>
-	getDelayMs: (priority: PresentationPriority) => number
-	setTimeoutFn?: typeof setTimeout
-	clearTimeoutFn?: typeof clearTimeout
-	onFlushError?: (error: unknown) => void
-}
-
-export class TaskPresentationScheduler {
-	private scheduledTimer: ReturnType<typeof setTimeout> | undefined
-	private scheduledPriority: PresentationPriority | undefined
-	private pendingPriority: PresentationPriority | undefined
-	private flushInProgress = false
-	private currentFlushCompletion: Promise<{ error?: unknown }> | undefined
-	private disposed = false
-
-	private readonly flush: () => Promise<void>
-	private readonly getDelayMs: (priority: PresentationPriority) => number
-	private readonly setTimeoutFn: typeof setTimeout
-	private readonly clearTimeoutFn: typeof clearTimeout
-	private readonly onFlushError?: (error: unknown) => void
-
-	constructor(options: TaskPresentationSchedulerOptions) {
-		this.flush = options.flush
-		this.getDelayMs = options.getDelayMs
-		this.setTimeoutFn = options.setTimeoutFn ?? setTimeout
-		this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout
-		this.onFlushError = options.onFlushError
-	}
-
-	requestFlush(priority: PresentationPriority = "normal"): void {
-		if (this.disposed) {
-			return
-		}
-
-		this.pendingPriority = this.mergePriority(this.pendingPriority, priority)
-
-		if (this.flushInProgress) {
-			// pendingPriority is already set above; runFlushCycle's post-flush
-			// continuation will pick it up after the in-flight flush completes.
-			return
-		}
-
-		if (this.pendingPriority === "immediate") {
-			if (this.scheduledTimer) {
-				this.clearTimeoutFn(this.scheduledTimer)
-				this.scheduledTimer = undefined
-				this.scheduledPriority = undefined
-			}
-			void this.runFlushCycle({ rethrowErrors: false })
-			return
-		}
-
-		const nextPriority = this.pendingPriority ?? "normal"
-
-		if (this.scheduledTimer) {
-			if (this.scheduledPriority === nextPriority) {
-				return
-			}
-
-			this.clearTimeoutFn(this.scheduledTimer)
-			this.scheduledTimer = undefined
-			this.scheduledPriority = undefined
-		}
-
-		if (!this.pendingPriority) {
-			return
-		}
-
-		const delayMs = this.getDelayMs(nextPriority)
-		this.scheduledPriority = nextPriority
-		this.scheduledTimer = this.setTimeoutFn(() => {
-			this.scheduledTimer = undefined
-			this.scheduledPriority = undefined
-			void this.runFlushCycle({ rethrowErrors: false })
-		}, delayMs)
-	}
-
-	/**
-	 * Flush immediately and await completion.
-	 *
-	 * Guarantees that at least one flush runs at "immediate" priority after this
-	 * call returns, even if a concurrent flush cycle consumed the pending priority
-	 * before this call could start its own cycle.
-	 *
-	 * If the scheduler has already been disposed this is a no-op and resolves
-	 * without error. Callers that need a guarantee that the final presentation
-	 * was delivered should ensure `dispose()` has not been called before
-	 * invoking `flushNow()` (the task streaming finalization path does this
-	 * correctly because `dispose()` is only called during `abortTask()`).
-	 */
-	async flushNow(): Promise<void> {
-		if (this.disposed) {
-			return
-		}
-
-		if (this.scheduledTimer) {
-			this.clearTimeoutFn(this.scheduledTimer)
-			this.scheduledTimer = undefined
-			this.scheduledPriority = undefined
-		}
-
-		// If a flush is already in-flight, wait for it to complete. After it
-		// finishes, the post-flush continuation in runFlushCycle may have already
-		// consumed our pendingPriority. We therefore set pendingPriority *after*
-		// the in-flight flush resolves so it cannot be stolen by the continuation.
-		if (this.flushInProgress) {
-			await (this.currentFlushCompletion ?? Promise.resolve())
-			// Another concurrent caller may have started a new flush cycle after
-			// the same in-flight flush resolved. If one is now in progress, wait
-			// for it too — we need a flush to run *after* we set pendingPriority.
-			while (this.flushInProgress) {
-				await (this.currentFlushCompletion ?? Promise.resolve())
-			}
-		}
-
-		if (this.disposed) {
-			return
-		}
-
-		// Now that no flush is in-flight, set pendingPriority and run our own cycle.
-		this.pendingPriority = this.mergePriority(this.pendingPriority, "immediate")
-		await this.runFlushCycle({ rethrowErrors: true })
-	}
-
-	/**
-	 * Cancel any pending timers and clear queued state without marking the scheduler
-	 * as disposed. Use this between API request retries within the same task to prevent
-	 * stale timers from firing against reset streaming state.
-	 *
-	 * Note: any flush that is already in-flight when reset() is called will complete
-	 * naturally. The flush callback (presentAssistantMessage) will operate on the
-	 * already-reset task state, but since currentStreamingContentIndex will be 0 and
-	 * assistantMessageContent will be empty, it will hit the out-of-bounds early-return
-	 * path and do nothing harmful.
-	 */
-	reset(): void {
-		if (this.disposed) {
-			return
-		}
-		if (this.scheduledTimer) {
-			this.clearTimeoutFn(this.scheduledTimer)
-			this.scheduledTimer = undefined
-		}
-		this.scheduledPriority = undefined
-		this.pendingPriority = undefined
-		// Note: we intentionally do NOT clear flushInProgress or currentFlushCompletion
-		// here. If a flush is in-flight it will complete naturally. The reset only
-		// prevents *new* timer-driven flushes from firing on stale state.
-	}
-
-	async dispose(): Promise<void> {
-		this.disposed = true
-		if (this.scheduledTimer) {
-			this.clearTimeoutFn(this.scheduledTimer)
-			this.scheduledTimer = undefined
-		}
-		this.scheduledPriority = undefined
-		this.pendingPriority = undefined
-
-		const inFlightFlush = this.currentFlushCompletion
-		if (inFlightFlush) {
-			await inFlightFlush
-		}
-	}
-
-	private async runFlushCycle(options: { rethrowErrors: boolean }): Promise<void> {
-		if (this.disposed) {
-			return
-		}
-
-		while (true) {
-			if (this.flushInProgress) {
-				// flushNow() handles the in-flight case itself before calling runFlushCycle,
-				// so this branch is only reached from requestFlush() (which returns early when
-				// flushInProgress is true) — meaning this path should not be hit in practice.
-				// Guard it defensively anyway.
-				const inFlightResult = await this.currentFlushCompletion
-				if (options.rethrowErrors && inFlightResult?.error) {
-					throw inFlightResult.error
-				}
-				// Re-check flushInProgress: another concurrent caller may have already
-				// started a new flush cycle after the same in-flight flush resolved.
-				// Without this guard both callers would proceed past the pendingPriority
-				// check and start concurrent flushes against the same presentation state.
-				if (this.flushInProgress || this.disposed || !this.pendingPriority) {
-					return
-				}
-			}
-
-			if (!this.pendingPriority) {
-				return
-			}
-
-			this.flushInProgress = true
-			this.pendingPriority = undefined
-
-			this.currentFlushCompletion = (async () => {
-				try {
-					await this.flush()
-					return {}
-				} catch (error) {
-					this.onFlushError?.(error)
-					return { error }
-				} finally {
-					this.flushInProgress = false
-				}
-			})()
-
-			const result = await this.currentFlushCompletion
-			this.currentFlushCompletion = undefined
-			if (result.error && options.rethrowErrors) {
-				throw result.error
-			}
-
-			if (this.disposed) {
-				return
-			}
-
-			const priorityToRun = this.pendingPriority
-			if (!priorityToRun) {
-				return
-			}
-
-			if (priorityToRun !== "immediate") {
-				this.requestFlush(priorityToRun)
-				return
-			}
-
-			// Continue the loop synchronously for immediate follow-up work. Because
-			// there is no await between clearing currentFlushCompletion above and
-			// re-entering the loop here, no other caller can observe an interleaved
-			// "idle" state before the immediate flush is started.
-		}
-	}
-
-	private mergePriority(current: PresentationPriority | undefined, next: PresentationPriority): PresentationPriority {
-		if (!current) {
-			return next
-		}
-
-		const rank: Record<PresentationPriority, number> = {
-			normal: 0,
-			immediate: 1,
-		}
-
-		return rank[next] > rank[current] ? next : current
-	}
-}

src/core/task/ToolExecutor.ts

@@ -1,659 +0,0 @@
-import { ApiHandler } from "@core/api"
-import { FileContextTracker } from "@core/context/context-tracking/FileContextTracker"
-import { getHookModelContext } from "@core/hooks/hook-model-context"
-import { getHooksEnabledSafe } from "@core/hooks/hooks-utils"
-import { ClineIgnoreController } from "@core/ignore/ClineIgnoreController"
-import { CommandPermissionController } from "@core/permissions"
-import { DiffViewProvider } from "@integrations/editor/DiffViewProvider"
-import type { CommandExecutionOptions } from "@integrations/terminal"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { UrlContentFetcher } from "@services/browser/UrlContentFetcher"
-import { McpHub } from "@services/mcp/McpHub"
-import { ClineAsk, ClineSay } from "@shared/ExtensionMessage"
-import { ClineContent } from "@shared/messages/content"
-import { ClineDefaultTool, toolUseNames } from "@shared/tools"
-import { ClineAskResponse } from "@shared/WebviewMessage"
-import { isParallelToolCallingEnabled, modelDoesntSupportWebp } from "@/utils/model-utils"
-import { ToolUse } from "../assistant-message"
-import { ContextManager } from "../context/context-management/ContextManager"
-import { formatResponse } from "../prompts/responses"
-import { StateManager } from "../storage/StateManager"
-import { WorkspaceRootManager } from "../workspace"
-import { ToolResponse } from "."
-import { checkRepeatedToolCall, LOOP_DETECTION_SOFT_THRESHOLD, toolCallSignature } from "./loop-detection"
-import { MessageStateHandler } from "./message-state"
-import { TaskState } from "./TaskState"
-import { AutoApprove } from "./tools/autoApprove"
-import { IPartialBlockHandler, ToolExecutorCoordinator } from "./tools/ToolExecutorCoordinator"
-import { ToolValidator } from "./tools/ToolValidator"
-import { TaskConfig, validateTaskConfig } from "./tools/types/TaskConfig"
-import { createUIHelpers } from "./tools/types/UIHelpers"
-import { ToolDisplayUtils } from "./tools/utils/ToolDisplayUtils"
-import { ToolResultUtils } from "./tools/utils/ToolResultUtils"
-
-export function canonicalizeAttemptCompletionParams(block: ToolUse): boolean {
-	if (block.name === ClineDefaultTool.ATTEMPT && !block.params?.result && typeof block.params?.response === "string") {
-		block.params.result = block.params.response
-		return true
-	}
-
-	return false
-}
-
-export class ToolExecutor {
-	private autoApprover: AutoApprove
-	private coordinator: ToolExecutorCoordinator
-
-	// Auto-approval methods using the AutoApprove class
-	private shouldAutoApproveTool(toolName: ClineDefaultTool): boolean | [boolean, boolean] {
-		return this.autoApprover.shouldAutoApproveTool(toolName)
-	}
-
-	private async shouldAutoApproveToolWithPath(
-		blockname: ClineDefaultTool,
-		autoApproveActionpath: string | undefined,
-	): Promise<boolean> {
-		return this.autoApprover.shouldAutoApproveToolWithPath(blockname, autoApproveActionpath)
-	}
-
-	constructor(
-		// Core Services & Managers
-		private taskState: TaskState,
-		private messageStateHandler: MessageStateHandler,
-		private api: ApiHandler,
-		private urlContentFetcher: UrlContentFetcher,
-		private browserSession: BrowserSession,
-		private diffViewProvider: DiffViewProvider,
-		private mcpHub: McpHub,
-		private fileContextTracker: FileContextTracker,
-		private clineIgnoreController: ClineIgnoreController,
-		private commandPermissionController: CommandPermissionController,
-		private contextManager: ContextManager,
-		private stateManager: StateManager,
-
-		// Configuration & Settings
-
-		private cwd: string,
-		private taskId: string,
-		private ulid: string,
-		private vscodeTerminalExecutionMode: "vscodeTerminal" | "backgroundExec",
-
-		// Workspace Management
-		private workspaceManager: WorkspaceRootManager | undefined,
-		private isMultiRootEnabled: boolean,
-
-		// Callbacks to the Task (Entity)
-		private say: (
-			type: ClineSay,
-			text?: string,
-			images?: string[],
-			files?: string[],
-			partial?: boolean,
-		) => Promise<number | undefined>,
-		private ask: (
-			type: ClineAsk,
-			text?: string,
-			partial?: boolean,
-		) => Promise<{
-			response: ClineAskResponse
-			text?: string
-			images?: string[]
-			files?: string[]
-		}>,
-		private saveCheckpoint: (isAttemptCompletionMessage?: boolean, completionMessageTs?: number) => Promise<void>,
-		private sayAndCreateMissingParamError: (toolName: ClineDefaultTool, paramName: string, relPath?: string) => Promise<any>,
-		private removeLastPartialMessageIfExistsWithType: (type: "ask" | "say", askOrSay: ClineAsk | ClineSay) => Promise<void>,
-		private executeCommandTool: (
-			command: string,
-			timeoutSeconds: number | undefined,
-			options?: CommandExecutionOptions,
-		) => Promise<[boolean, any]>,
-		private cancelRunningCommandTool: () => Promise<boolean>,
-		private doesLatestTaskCompletionHaveNewChanges: () => Promise<boolean>,
-		private updateFCListFromToolResponse: (taskProgress: string | undefined) => Promise<void>,
-		private switchToActMode: () => Promise<boolean>,
-		private cancelTask: () => Promise<void>,
-
-		// Atomic hook state helpers from Task
-		private setActiveHookExecution: (hookExecution: NonNullable<typeof taskState.activeHookExecution>) => Promise<void>,
-		private clearActiveHookExecution: () => Promise<void>,
-		private getActiveHookExecution: () => Promise<typeof taskState.activeHookExecution>,
-		private runUserPromptSubmitHook: (
-			userContent: ClineContent[],
-			context: "initial_task" | "resume" | "feedback",
-		) => Promise<{ cancel?: boolean; wasCancelled?: boolean; contextModification?: string; errorMessage?: string }>,
-	) {
-		this.autoApprover = new AutoApprove(this.stateManager)
-
-		// Initialize the coordinator and register all tool handlers
-		this.coordinator = new ToolExecutorCoordinator()
-		this.registerToolHandlers()
-	}
-
-	// Create a properly typed TaskConfig object for handlers
-	// NOTE: modifying this object in the tool handlers is okay since these are all references to the singular ToolExecutor instance's variables. However, be careful modifying this object assuming it will update the ToolExecutor instance, e.g. config.browserSession = ... will not update the ToolExecutor.browserSession instance variable. Use applyLatestBrowserSettings() instead.
-	private asToolConfig(): TaskConfig {
-		const config: TaskConfig = {
-			taskId: this.taskId,
-			ulid: this.ulid,
-			mode: this.stateManager.getGlobalSettingsKey("mode"),
-			strictPlanModeEnabled: this.stateManager.getGlobalSettingsKey("strictPlanModeEnabled"),
-			yoloModeToggled: this.stateManager.getGlobalSettingsKey("yoloModeToggled"),
-			doubleCheckCompletionEnabled: this.stateManager.getGlobalSettingsKey("doubleCheckCompletionEnabled"),
-			vscodeTerminalExecutionMode: this.vscodeTerminalExecutionMode,
-			enableParallelToolCalling: this.isParallelToolCallingEnabled(),
-			isSubagentExecution: false,
-			cwd: this.cwd,
-			workspaceManager: this.workspaceManager,
-			isMultiRootEnabled: this.isMultiRootEnabled,
-			taskState: this.taskState,
-			messageState: this.messageStateHandler,
-			api: this.api,
-			autoApprovalSettings: this.stateManager.getGlobalSettingsKey("autoApprovalSettings"),
-			autoApprover: this.autoApprover,
-			browserSettings: this.stateManager.getGlobalSettingsKey("browserSettings"),
-			focusChainSettings: this.stateManager.getGlobalSettingsKey("focusChainSettings"),
-			services: {
-				mcpHub: this.mcpHub,
-				browserSession: this.browserSession,
-				urlContentFetcher: this.urlContentFetcher,
-				diffViewProvider: this.diffViewProvider,
-				fileContextTracker: this.fileContextTracker,
-				clineIgnoreController: this.clineIgnoreController,
-				commandPermissionController: this.commandPermissionController,
-				contextManager: this.contextManager,
-				stateManager: this.stateManager,
-			},
-			callbacks: {
-				say: this.say,
-				ask: this.ask,
-				saveCheckpoint: this.saveCheckpoint,
-				postStateToWebview: async () => {},
-				reinitExistingTaskFromId: async () => {},
-				cancelTask: this.cancelTask,
-				updateTaskHistory: async () => [],
-				executeCommandTool: this.executeCommandTool,
-				cancelRunningCommandTool: this.cancelRunningCommandTool,
-				doesLatestTaskCompletionHaveNewChanges: this.doesLatestTaskCompletionHaveNewChanges,
-				updateFCListFromToolResponse: this.updateFCListFromToolResponse,
-				sayAndCreateMissingParamError: this.sayAndCreateMissingParamError,
-				removeLastPartialMessageIfExistsWithType: this.removeLastPartialMessageIfExistsWithType,
-				shouldAutoApproveTool: this.shouldAutoApproveTool.bind(this),
-				shouldAutoApproveToolWithPath: this.shouldAutoApproveToolWithPath.bind(this),
-				applyLatestBrowserSettings: this.applyLatestBrowserSettings.bind(this),
-				switchToActMode: this.switchToActMode,
-				setActiveHookExecution: this.setActiveHookExecution,
-				clearActiveHookExecution: this.clearActiveHookExecution,
-				getActiveHookExecution: this.getActiveHookExecution,
-				runUserPromptSubmitHook: this.runUserPromptSubmitHook,
-			},
-			coordinator: this.coordinator,
-		}
-
-		// Validate the config at runtime to catch any missing properties
-		validateTaskConfig(config)
-		return config
-	}
-
-	/**
-	 * Register all tool handlers with the coordinator
-	 */
-	private registerToolHandlers(): void {
-		const validator = new ToolValidator(this.clineIgnoreController)
-		// Register all tools via toolUseNames
-		for (const tool of toolUseNames) {
-			this.coordinator.registerByName(tool, validator)
-		}
-	}
-
-	/**
-	 * Main entry point for tool execution - called by Task class
-	 */
-	public async executeTool(block: ToolUse): Promise<void> {
-		await this.execute(block)
-	}
-
-	/**
-	 * Updates the browser settings
-	 */
-	public async applyLatestBrowserSettings() {
-		await this.browserSession.dispose()
-		const apiHandlerModel = this.api.getModel()
-		const useWebp = this.api ? !modelDoesntSupportWebp(apiHandlerModel) : true
-		this.browserSession = new BrowserSession(this.stateManager, useWebp)
-		return this.browserSession
-	}
-
-	/**
-	 * Handles errors during tool execution.
-	 *
-	 * Logs the error, displays it to the user via the UI, and adds an error
-	 * result to the conversation context so the AI can see what went wrong.
-	 *
-	 * @param action Description of what was being attempted (e.g., "executing read_file")
-	 * @param error The error that occurred
-	 * @param block The tool use block that caused the error
-	 */
-	private async handleError(action: string, error: Error, block: ToolUse): Promise<void> {
-		const errorString = `Error ${action}: ${error.message}`
-		await this.say("error", errorString)
-
-		// Create error response for the tool
-		const errorResponse = formatResponse.toolError(errorString)
-		this.pushToolResult(errorResponse, block)
-	}
-
-	/**
-	 * Pushes a tool result to the user message content.
-	 *
-	 * This is a critical method that:
-	 * - Formats the tool result appropriately for the API
-	 * - Adds it to the conversation context
-	 * - Marks that a tool has been used in this turn
-	 *
-	 * @param content The tool response content to add
-	 * @param block The tool use block that generated this result
-	 */
-	private pushToolResult = (content: ToolResponse, block: ToolUse) => {
-		// Use the ToolResultUtils to properly format and push the tool result
-		ToolResultUtils.pushToolResult(
-			content,
-			block,
-			this.taskState.userMessageContent,
-			(block: ToolUse) => ToolDisplayUtils.getToolDescription(block),
-			this.coordinator,
-			this.taskState.toolUseIdMap,
-		)
-		// Mark that a tool has been used (only matters when parallel tool calling is disabled)
-		if (!this.isParallelToolCallingEnabled()) {
-			this.taskState.didAlreadyUseTool = true
-		}
-	}
-
-	/**
-	 * Check if parallel tool calling is enabled.
-	 * Parallel tool calling is enabled if:
-	 * 1. User has enabled it in settings, OR
-	 * 2. The current model/provider supports native tool calling and handles parallel tools well
-	 */
-	private isParallelToolCallingEnabled(): boolean {
-		const enableParallelSetting = this.stateManager.getGlobalSettingsKey("enableParallelToolCalling")
-		const model = this.api.getModel()
-		const apiConfig = this.stateManager.getApiConfiguration()
-		const mode = this.stateManager.getGlobalSettingsKey("mode")
-		const providerId = (mode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider) as string
-		return isParallelToolCallingEnabled(enableParallelSetting, { providerId, model, mode })
-	}
-
-	/**
-	 * Tools that are restricted in plan mode and can only be used in act mode
-	 */
-	private static readonly PLAN_MODE_RESTRICTED_TOOLS: ClineDefaultTool[] = [
-		ClineDefaultTool.FILE_NEW,
-		ClineDefaultTool.FILE_EDIT,
-		ClineDefaultTool.NEW_RULE,
-		ClineDefaultTool.APPLY_PATCH,
-	]
-
-	/**
-	 * Execute a tool through the coordinator if it's registered.
-	 *
-	 * This is the main entry point for tool execution, called by the Task class.
-	 * It handles:
-	 * - Checking if the tool is registered with the coordinator
-	 * - Validating tool execution is allowed (not rejected, not already used, etc.)
-	 * - Enforcing plan mode restrictions on file modification tools
-	 * - Delegating to partial or complete block handlers
-	 * - Error handling and checkpointing
-	 *
-	 * @param block The tool use block to execute
-	 * @returns true if the tool was handled (even if execution failed), false if not registered
-	 */
-	private async execute(block: ToolUse): Promise<boolean> {
-		// Note: MCP tool name transformation happens earlier in ToolUseHandler.getPartialToolUsesAsContent()
-		// The toolUseIdMap is updated at the point of transformation in index.ts
-
-		if (!this.coordinator.has(block.name)) {
-			return false // Tool not handled by coordinator
-		}
-		canonicalizeAttemptCompletionParams(block)
-
-		const config = this.asToolConfig()
-
-		try {
-			// Check if user rejected a previous tool
-			if (this.taskState.didRejectTool) {
-				const reason = block.partial
-					? "Tool was interrupted and not executed due to user rejecting a previous tool."
-					: "Skipping tool due to user rejecting a previous tool."
-				this.createToolRejectionMessage(block, reason)
-				return true
-			}
-
-			// Check if a tool has already been used in this message (only enforced when parallel tool calling is disabled)
-			if (!this.isParallelToolCallingEnabled() && this.taskState.didAlreadyUseTool) {
-				this.taskState.userMessageContent.push({
-					type: "text",
-					text: formatResponse.toolAlreadyUsed(block.name),
-				})
-				return true
-			}
-
-			// Logic for plan-mode tool call restrictions
-			if (
-				this.stateManager.getGlobalSettingsKey("strictPlanModeEnabled") &&
-				this.stateManager.getGlobalSettingsKey("mode") === "plan" &&
-				block.name &&
-				this.isPlanModeToolRestricted(block.name)
-			) {
-				const errorMessage = `Tool '${block.name}' is not available in PLAN MODE. This tool is restricted to ACT MODE for file modifications. Only use tools available for PLAN MODE when in that mode.`
-				await this.removeLastPartialMessageIfExistsWithType("say", "error")
-				await this.say("error", errorMessage)
-				// Only push the final error message when the streaming is done.
-				if (!block.partial) {
-					this.pushToolResult(formatResponse.toolError(errorMessage), block)
-				}
-				return true
-			}
-
-			// Close browser for non-browser tools
-			if (block.name !== "browser_action") {
-				await this.browserSession.closeBrowser()
-			}
-
-			// Handle partial blocks
-			if (block.partial) {
-				await this.handlePartialBlock(block, config)
-				return true
-			}
-
-			// Handle complete blocks
-			await this.handleCompleteBlock(block, config)
-			return true
-		} catch (error) {
-			await this.handleError(`executing ${block.name}`, error as Error, block)
-			return true
-		}
-	}
-
-	/**
-	 * Check if a tool is restricted in plan mode.
-	 *
-	 * In strict plan mode, file modification tools (write_to_file, editedExistingFile, etc.)
-	 * are blocked. The AI must switch to Act mode to use these tools.
-	 *
-	 * @param toolName The name of the tool to check
-	 * @returns true if the tool is restricted in plan mode, false otherwise
-	 */
-	private isPlanModeToolRestricted(toolName: ClineDefaultTool): boolean {
-		return ToolExecutor.PLAN_MODE_RESTRICTED_TOOLS.includes(toolName)
-	}
-
-	/**
-	 * Create a tool rejection message and add it to user message content.
-	 *
-	 * Used when a tool cannot be executed (e.g., user rejected a previous tool,
-	 * tool was interrupted, etc.). Adds a text message to the conversation explaining
-	 * why the tool was not executed.
-	 *
-	 * @param block The tool use block that was rejected
-	 * @param reason Human-readable explanation of why the tool was rejected
-	 */
-	private createToolRejectionMessage(block: ToolUse, reason: string): void {
-		this.taskState.userMessageContent.push({
-			type: "text",
-			text: `${reason} ${ToolDisplayUtils.getToolDescription(block, this.coordinator)}`,
-		})
-	}
-
-	/**
-	 * Adds hook context modification to the conversation if provided.
-	 * Parses the context to extract type prefix and formats as XML.
-	 *
-	 * @param contextModification The context string from the hook output
-	 * @param source The hook source name ("PreToolUse" or "PostToolUse")
-	 */
-	private addHookContextToConversation(contextModification: string | undefined, source: string): void {
-		if (!contextModification) {
-			return
-		}
-
-		const contextText = contextModification.trim()
-		if (!contextText) {
-			return
-		}
-
-		// Extract context type from first line if specified (e.g., "WORKSPACE_RULES: ...")
-		const lines = contextText.split("\n")
-		const firstLine = lines[0]
-		let contextType = "general"
-		let content = contextText
-
-		// Check if first line specifies a type: "TYPE: content"
-		const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-		const typeMatch = typeMatchRegex.exec(firstLine)
-		if (typeMatch) {
-			contextType = typeMatch[1].toLowerCase()
-			const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-			content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-		}
-
-		const hookContextBlock = {
-			type: "text" as const,
-			text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-		}
-
-		this.taskState.userMessageContent.push(hookContextBlock)
-	}
-
-	/**
-	 * Runs the PostToolUse hook after tool execution.
-	 * This is extracted from handleCompleteBlock to eliminate code duplication
-	 * between success and error paths.
-	 *
-	 * @param block The tool use block that was executed
-	 * @param toolResult The result from the tool execution
-	 * @param executionSuccess Whether the tool executed successfully
-	 * @param executionStartTime The timestamp when tool execution started
-	 * @returns true if hook requested cancellation, false otherwise
-	 */
-	private async runPostToolUseHook(
-		block: ToolUse,
-		toolResult: any,
-		executionSuccess: boolean,
-		executionStartTime: number,
-		hooksEnabled: boolean,
-	): Promise<boolean> {
-		const { executeHook } = await import("../hooks/hook-executor")
-
-		const executionTimeMs = Date.now() - executionStartTime
-
-		const postToolResult = await executeHook({
-			hookName: "PostToolUse",
-			hookInput: {
-				postToolUse: {
-					toolName: block.name,
-					parameters: block.params,
-					result: typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
-					success: executionSuccess,
-					executionTimeMs,
-				},
-			},
-			isCancellable: true,
-			say: this.say,
-			setActiveHookExecution: this.setActiveHookExecution,
-			clearActiveHookExecution: this.clearActiveHookExecution,
-			messageStateHandler: this.messageStateHandler,
-			taskId: this.taskId,
-			hooksEnabled,
-			model: getHookModelContext(this.api, this.stateManager),
-			toolName: block.name,
-		})
-
-		// Handle cancellation request
-		if (postToolResult.cancel === true) {
-			const errorMessage = postToolResult.errorMessage || "Hook requested task cancellation"
-			await this.say("error", errorMessage)
-			return true
-		}
-
-		// Add context modification to the conversation if provided
-		if (postToolResult.contextModification) {
-			this.addHookContextToConversation(postToolResult.contextModification, "PostToolUse")
-		}
-
-		return false
-	}
-
-	/**
-	 * Handle partial block streaming UI updates.
-	 *
-	 * During streaming API responses, the AI sends partial tool use blocks as they're
-	 * generated. This method updates the UI to show the tool being constructed in real-time.
-	 *
-	 * NOTE: This is ONLY for UI updates. No tool results are pushed to the conversation
-	 * during partial block handling. The complete block handler will add the final result.
-	 *
-	 * @param block The partial tool use block with incomplete parameters
-	 * @param config The task configuration containing all necessary context
-	 */
-	private async handlePartialBlock(block: ToolUse, config: TaskConfig): Promise<void> {
-		// NOTE: We don't push tool results in partial blocks because this is only for UI streaming.
-		// The ToolExecutor will handle pushToolResult() when the complete block is processed.
-		// This maintains separation of concerns: partial = UI updates, complete = final state changes.
-		const handler = this.coordinator.getHandler(block.name)
-
-		// Check if handler supports partial blocks with proper typing
-		if (handler && "handlePartialBlock" in handler) {
-			const uiHelpers = createUIHelpers(config)
-			const partialHandler = handler as IPartialBlockHandler
-			await partialHandler.handlePartialBlock(block, uiHelpers)
-		}
-	}
-
-	/**
-	 * Handle complete block execution.
-	 *
-	 * This is the main execution flow for a tool:
-	 * 1. Execute the actual tool (tool handlers now run PreToolUse hooks post-approval)
-	 * 2. Run PostToolUse hooks (if enabled) - cannot block, only observe
-	 * 3. Add hook context modifications to the conversation
-	 * 4. Update focus chain tracking
-	 *
-	 * Note: PreToolUse hooks are now executed by individual tool handlers after approval
-	 * and before the actual tool operation. This provides better UX as approval dialogs
-	 * appear immediately without hook execution delay.
-	 *
-	 * PostToolUse hooks are for observation/logging only and cannot block.
-	 *
-	 * @param block The complete tool use block with all parameters
-	 * @param config The task configuration containing all necessary context
-	 */
-	private async handleCompleteBlock(block: ToolUse, config: any): Promise<void> {
-		// Check abort flag at the very start to prevent execution after cancellation
-		if (this.taskState.abort) {
-			return
-		}
-
-		const hooksEnabled = getHooksEnabledSafe(this.stateManager.getGlobalSettingsKey("hooksEnabled"))
-
-		// Track if we need to cancel after hooks complete
-		let shouldCancelAfterHook = false
-
-		let executionSuccess = true
-		let toolResult: any = null
-		let toolWasExecuted = false
-		const executionStartTime = Date.now()
-
-		try {
-			// Final abort check immediately before tool execution
-			if (this.taskState.abort) {
-				return
-			}
-
-			// Execute the actual tool
-			toolResult = await this.coordinator.execute(config, block)
-			toolWasExecuted = true
-			this.pushToolResult(toolResult, block)
-
-			// --- Repeated tool call loop detection ---
-			// Must run BEFORE updating lastToolName/lastToolParams so we compare
-			// against the previous call's values, not the current one.
-			const currentSignature = toolCallSignature(block.params)
-			const loopCheck = checkRepeatedToolCall(this.taskState, block.name, currentSignature)
-
-			if (loopCheck.softWarning) {
-				this.taskState.userMessageContent.push({
-					type: "text",
-					text: formatResponse.repeatedToolCall(block.name, LOOP_DETECTION_SOFT_THRESHOLD),
-				})
-			}
-
-			if (loopCheck.hardEscalation) {
-				this.taskState.consecutiveMistakeCount = this.stateManager.getGlobalSettingsKey("maxConsecutiveMistakes")
-			}
-
-			// Update state AFTER comparison
-			this.taskState.lastToolName = block.name
-			this.taskState.lastToolParams = currentSignature
-
-			// Check abort before running PostToolUse hook (success path)
-			if (this.taskState.abort) {
-				return
-			}
-
-			// Run PostToolUse hook for successful tool execution
-			// Skip for attempt_completion since it marks task completion, not actual work
-			if (hooksEnabled && block.name !== "attempt_completion") {
-				const hookRequestedCancel = await this.runPostToolUseHook(
-					block,
-					toolResult,
-					executionSuccess,
-					executionStartTime,
-					hooksEnabled, // always true here - already checked by caller
-				)
-				if (hookRequestedCancel) {
-					await config.callbacks.cancelTask()
-					shouldCancelAfterHook = true
-				}
-			}
-		} catch (error) {
-			executionSuccess = false
-			toolResult = formatResponse.toolError(`Tool execution failed: ${error}`)
-
-			// Check abort before running PostToolUse hook (error path)
-			if (this.taskState.abort) {
-				throw error
-			}
-
-			// Run PostToolUse hook for failed tool execution
-			// Skip for attempt_completion since it marks task completion, not actual work
-			if (toolWasExecuted && hooksEnabled && block.name !== "attempt_completion") {
-				const hookRequestedCancel = await this.runPostToolUseHook(
-					block,
-					toolResult,
-					executionSuccess,
-					executionStartTime,
-					hooksEnabled, // always true here - already checked by caller
-				)
-				if (hookRequestedCancel) {
-					await config.callbacks.cancelTask()
-					shouldCancelAfterHook = true
-				}
-			}
-
-			// Re-throw the error after PostToolUse completes
-			throw error
-		}
-
-		// Early return if hook requested cancellation
-		if (shouldCancelAfterHook) {
-			return
-		}
-
-		// Handle focus chain updates
-		if (!block.partial && this.stateManager.getGlobalSettingsKey("focusChainSettings").enabled) {
-			await this.updateFCListFromToolResponse(block.params.task_progress)
-		}
-	}
-}

src/core/task/__tests__/Task.ask.test.ts

@@ -1,280 +0,0 @@
-import { strict as assert } from "node:assert"
-import * as NotificationHook from "@core/hooks/notification-hook"
-import { Task } from "@core/task"
-import type { ClineMessage } from "@shared/ExtensionMessage"
-import { describe, it } from "mocha"
-import sinon from "sinon"
-
-async function flushMicrotasks(iterations = 5) {
-	for (let i = 0; i < iterations; i++) {
-		await Promise.resolve()
-	}
-}
-
-function createFakeTask(taskState: {
-	abort: boolean
-	askResponse: string | undefined
-	askResponseText: string | undefined
-	askResponseImages: string[] | undefined
-	askResponseFiles: string[] | undefined
-	lastMessageTs: number | undefined
-}) {
-	const clineMessages: ClineMessage[] = []
-
-	const fakeTask = {
-		taskState,
-		api: { getModel: () => ({ id: "test-model" }) },
-		stateManager: {
-			getGlobalSettingsKey: (key: string) => (key === "hooksEnabled" ? false : "act"),
-			getApiConfiguration: () => ({ actModeApiProvider: "anthropic", planModeApiProvider: "anthropic" }),
-		},
-		taskId: "task-1",
-		messageStateHandler: {
-			addToClineMessages: async (message: ClineMessage) => {
-				clineMessages.push(message)
-			},
-			getClineMessages: () => clineMessages,
-		},
-		postStateToWebview: async () => undefined,
-	}
-
-	return { clineMessages, fakeTask }
-}
-
-describe("Task.ask", () => {
-	it("keeps resume asks waiting for a user response even when the task is aborted", async () => {
-		const clock = sinon.useFakeTimers()
-		const taskState: {
-			abort: boolean
-			askResponse: string | undefined
-			askResponseText: string | undefined
-			askResponseImages: string[] | undefined
-			askResponseFiles: string[] | undefined
-			lastMessageTs: number | undefined
-		} = {
-			abort: true,
-			askResponse: undefined,
-			askResponseText: undefined,
-			askResponseImages: undefined,
-			askResponseFiles: undefined,
-			lastMessageTs: undefined,
-		}
-		const { clineMessages, fakeTask } = createFakeTask(taskState)
-
-		try {
-			const askPromise = (
-				Task.prototype as unknown as {
-					ask: (type: "resume_task") => Promise<{ response: string; text?: string }>
-				}
-			).ask.call(fakeTask, "resume_task")
-
-			let settled = false
-			void askPromise.then(
-				() => {
-					settled = true
-				},
-				() => {
-					settled = true
-				},
-			)
-
-			await flushMicrotasks()
-			assert.equal(clineMessages.length, 1)
-			assert.equal(clineMessages[0].ask, "resume_task")
-			assert.notEqual(taskState.lastMessageTs, undefined)
-
-			await clock.tickAsync(1_000)
-			assert.equal(settled, false)
-			assert.equal(taskState.askResponse, undefined)
-
-			taskState.askResponse = "yesButtonClicked"
-			taskState.askResponseText = "resume"
-
-			await clock.tickAsync(100)
-			const result = await askPromise
-
-			assert.equal(result.response, "yesButtonClicked")
-			assert.equal(result.text, "resume")
-		} finally {
-			clock.restore()
-		}
-	})
-
-	it("keeps resume-completed asks waiting for a user response even when the task is aborted", async () => {
-		const clock = sinon.useFakeTimers()
-		const taskState: {
-			abort: boolean
-			askResponse: string | undefined
-			askResponseText: string | undefined
-			askResponseImages: string[] | undefined
-			askResponseFiles: string[] | undefined
-			lastMessageTs: number | undefined
-		} = {
-			abort: true,
-			askResponse: undefined,
-			askResponseText: undefined,
-			askResponseImages: undefined,
-			askResponseFiles: undefined,
-			lastMessageTs: undefined,
-		}
-		const { clineMessages, fakeTask } = createFakeTask(taskState)
-
-		try {
-			const askPromise = (
-				Task.prototype as unknown as {
-					ask: (type: "resume_completed_task") => Promise<{ response: string; text?: string }>
-				}
-			).ask.call(fakeTask, "resume_completed_task")
-
-			let settled = false
-			void askPromise.then(
-				() => {
-					settled = true
-				},
-				() => {
-					settled = true
-				},
-			)
-
-			await flushMicrotasks()
-			assert.equal(clineMessages.length, 1)
-			assert.equal(clineMessages[0].ask, "resume_completed_task")
-			assert.notEqual(taskState.lastMessageTs, undefined)
-
-			await clock.tickAsync(1_000)
-			assert.equal(settled, false)
-			assert.equal(taskState.askResponse, undefined)
-
-			taskState.askResponse = "yesButtonClicked"
-			taskState.askResponseText = "resume completed"
-
-			await clock.tickAsync(100)
-			const result = await askPromise
-
-			assert.equal(result.response, "yesButtonClicked")
-			assert.equal(result.text, "resume completed")
-		} finally {
-			clock.restore()
-		}
-	})
-
-	it("still wakes non-resume asks when abort is triggered after the ask is shown", async () => {
-		const clock = sinon.useFakeTimers()
-		const taskState: {
-			abort: boolean
-			askResponse: string | undefined
-			askResponseText: string | undefined
-			askResponseImages: string[] | undefined
-			askResponseFiles: string[] | undefined
-			lastMessageTs: number | undefined
-		} = {
-			abort: false,
-			askResponse: undefined,
-			askResponseText: undefined,
-			askResponseImages: undefined,
-			askResponseFiles: undefined,
-			lastMessageTs: undefined,
-		}
-		const { clineMessages, fakeTask } = createFakeTask(taskState)
-
-		try {
-			const askPromise = (
-				Task.prototype as unknown as {
-					ask: (type: "completion_result") => Promise<{ response: string }>
-				}
-			).ask.call(fakeTask, "completion_result")
-
-			await flushMicrotasks()
-			assert.equal(clineMessages.length, 1)
-			assert.equal(clineMessages[0].ask, "completion_result")
-
-			const rejectionPromise = assert.rejects(askPromise, /Cline instance aborted/)
-			taskState.abort = true
-
-			await clock.tickAsync(100)
-			await rejectionPromise
-		} finally {
-			clock.restore()
-		}
-	})
-
-	it("emits notification hooks for non-command_output asks", async () => {
-		const clock = sinon.useFakeTimers()
-		const notificationStub = sinon.stub(NotificationHook, "emitUserAttentionNotification").resolves()
-		const taskState: {
-			abort: boolean
-			askResponse: string | undefined
-			askResponseText: string | undefined
-			askResponseImages: string[] | undefined
-			askResponseFiles: string[] | undefined
-			lastMessageTs: number | undefined
-		} = {
-			abort: false,
-			askResponse: undefined,
-			askResponseText: undefined,
-			askResponseImages: undefined,
-			askResponseFiles: undefined,
-			lastMessageTs: undefined,
-		}
-		const { fakeTask } = createFakeTask(taskState)
-
-		try {
-			const askPromise = (
-				Task.prototype as unknown as {
-					ask: (type: "completion_result", text?: string) => Promise<{ response: string }>
-				}
-			).ask.call(fakeTask, "completion_result", "Need approval")
-
-			await flushMicrotasks()
-			sinon.assert.calledOnce(notificationStub)
-			assert.equal(notificationStub.firstCall.args[1].source, "completion_result")
-			assert.equal(notificationStub.firstCall.args[1].message, "Need approval")
-
-			taskState.askResponse = "yesButtonClicked"
-			await clock.tickAsync(100)
-			await askPromise
-		} finally {
-			notificationStub.restore()
-			clock.restore()
-		}
-	})
-
-	it("skips notification hooks for command_output asks", async () => {
-		const clock = sinon.useFakeTimers()
-		const notificationStub = sinon.stub(NotificationHook, "emitUserAttentionNotification").resolves()
-		const taskState: {
-			abort: boolean
-			askResponse: string | undefined
-			askResponseText: string | undefined
-			askResponseImages: string[] | undefined
-			askResponseFiles: string[] | undefined
-			lastMessageTs: number | undefined
-		} = {
-			abort: false,
-			askResponse: undefined,
-			askResponseText: undefined,
-			askResponseImages: undefined,
-			askResponseFiles: undefined,
-			lastMessageTs: undefined,
-		}
-		const { fakeTask } = createFakeTask(taskState)
-
-		try {
-			const askPromise = (
-				Task.prototype as unknown as {
-					ask: (type: "command_output", text?: string) => Promise<{ response: string }>
-				}
-			).ask.call(fakeTask, "command_output", "stream update")
-
-			await flushMicrotasks()
-			sinon.assert.notCalled(notificationStub)
-
-			taskState.askResponse = "yesButtonClicked"
-			await clock.tickAsync(100)
-			await askPromise
-		} finally {
-			notificationStub.restore()
-			clock.restore()
-		}
-	})
-})

src/core/task/__tests__/Task.processNativeToolCalls.test.ts

@@ -1,77 +0,0 @@
-import { strict as assert } from "node:assert"
-import type { ToolUse } from "@core/assistant-message"
-import { registerPartialMessageCallback } from "@core/controller/ui/subscribeToPartialMessage"
-import { Task } from "@core/task"
-import type { ClineMessage } from "@shared/ExtensionMessage"
-import { ClineDefaultTool } from "@shared/tools"
-import { describe, it } from "mocha"
-
-describe("Task.processNativeToolCalls", () => {
-	it("finalizes a partial text row before handing off to native tool calls", async () => {
-		const clineMessages: ClineMessage[] = [
-			{
-				ts: 1,
-				type: "say",
-				say: "text",
-				text: "partial text before tool handoff",
-				partial: true,
-			},
-		]
-
-		let saveCalls = 0
-		const emittedPartialMessages: Array<{ partial: boolean; text: string }> = []
-		const unsubscribe = registerPartialMessageCallback((message) => {
-			emittedPartialMessages.push({
-				partial: message.partial,
-				text: message.text,
-			})
-		})
-
-		const toolBlocks: ToolUse[] = [
-			{
-				type: "tool_use",
-				name: ClineDefaultTool.ASK,
-				params: {
-					question: "Need clarification",
-				},
-				partial: true,
-				isNativeToolCall: true,
-				call_id: "call-1",
-			},
-		]
-
-		const fakeTask = {
-			messageStateHandler: {
-				getClineMessages: () => clineMessages,
-				saveClineMessagesAndUpdateHistory: async () => {
-					saveCalls += 1
-				},
-			},
-			taskState: {
-				assistantMessageContent: [],
-				currentStreamingContentIndex: 0,
-				userMessageContentReady: true,
-			},
-		}
-
-		try {
-			await (
-				Task.prototype as unknown as { processNativeToolCalls: (text: string, blocks: ToolUse[]) => Promise<void> }
-			).processNativeToolCalls.call(fakeTask, "visible streamed text", toolBlocks)
-
-			assert.equal(clineMessages[0].text, "visible streamed text")
-			assert.equal(clineMessages[0].partial, false)
-			assert.equal(saveCalls, 1)
-			assert.deepEqual(emittedPartialMessages, [{ partial: false, text: "visible streamed text" }])
-
-			assert.deepEqual(fakeTask.taskState.assistantMessageContent, [
-				{ type: "text", content: "visible streamed text", partial: false },
-				...toolBlocks,
-			])
-			assert.equal(fakeTask.taskState.currentStreamingContentIndex, 1)
-			assert.equal(fakeTask.taskState.userMessageContentReady, false)
-		} finally {
-			unsubscribe()
-		}
-	})
-})

src/core/task/__tests__/TaskPresentationScheduler.test.ts

@@ -1,253 +0,0 @@
-import { describe, it } from "mocha"
-import "should"
-import sinon from "sinon"
-
-import { TaskPresentationScheduler } from "../TaskPresentationScheduler"
-
-describe("TaskPresentationScheduler", () => {
-	it("rethrows flush errors from flushNow so callers do not hang on hidden failures", async () => {
-		const scheduler = new TaskPresentationScheduler({
-			flush: async () => {
-				throw new Error("flush failed")
-			},
-			getDelayMs: () => 10,
-		})
-
-		await scheduler
-			.flushNow()
-			.then(() => {
-				throw new Error("expected flushNow to reject")
-			})
-			.catch((error: Error) => {
-				error.message.should.equal("flush failed")
-			})
-	})
-
-	it("coalesces multiple normal-priority requests into a single timer", () => {
-		const clock = sinon.useFakeTimers()
-		const flushSpy = sinon.spy(async () => {})
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: flushSpy,
-			getDelayMs: () => 50,
-		})
-
-		scheduler.requestFlush("normal")
-		scheduler.requestFlush("normal")
-		scheduler.requestFlush("normal")
-
-		clock.tick(49)
-		flushSpy.callCount.should.equal(0)
-
-		clock.tick(1)
-		flushSpy.callCount.should.equal(1)
-
-		clock.restore()
-	})
-
-	it("waits for an in-flight flush and runs the requested immediate flush before resolving flushNow", async () => {
-		let resolveFirstFlush: (() => void) | undefined
-		let flushCount = 0
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: async () => {
-				flushCount += 1
-				if (flushCount === 1) {
-					await new Promise<void>((resolve) => {
-						resolveFirstFlush = resolve
-					})
-				}
-			},
-			getDelayMs: () => 0,
-		})
-
-		scheduler.requestFlush("immediate")
-		await Promise.resolve()
-
-		let didResolve = false
-		const flushNowPromise = scheduler.flushNow().then(() => {
-			didResolve = true
-		})
-
-		await Promise.resolve()
-		flushCount.should.equal(1)
-		didResolve.should.equal(false)
-
-		resolveFirstFlush?.()
-		await flushNowPromise
-
-		flushCount.should.equal(2)
-		didResolve.should.equal(true)
-	})
-
-	it("does not rethrow errors from an overlapping in-flight flush when flushNow is called", async () => {
-		let rejectFirstFlush: ((error: Error) => void) | undefined
-		let flushCount = 0
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: async () => {
-				flushCount += 1
-				if (flushCount === 1) {
-					await new Promise<void>((_, reject) => {
-						rejectFirstFlush = reject
-					})
-				}
-			},
-			getDelayMs: () => 0,
-		})
-
-		scheduler.requestFlush("immediate")
-		await Promise.resolve()
-
-		let flushNowResolved = false
-		const flushNowPromise = scheduler.flushNow().then(() => {
-			flushNowResolved = true
-		})
-		rejectFirstFlush?.(new Error("flush failed"))
-
-		await flushNowPromise
-		flushNowResolved.should.equal(true)
-		flushCount.should.equal(2)
-	})
-
-	it("flushNow guarantees a flush even when the post-flush continuation consumed pendingPriority", async () => {
-		// Regression test for the race condition where:
-		// 1. A timer fires → runFlushCycle starts, sets flushInProgress=true, clears pendingPriority
-		// 2. flushNow() is called → sets pendingPriority="immediate", enters runFlushCycle
-		// 3. runFlushCycle sees flushInProgress, awaits currentFlushCompletion
-		// 4. In-flight flush completes → post-flush continuation sees pendingPriority="immediate",
-		//    calls runFlushCycle recursively → clears pendingPriority, runs flush #2
-		// 5. flushNow()'s runFlushCycle resumes → pendingPriority is now undefined → would return
-		//    without flushing (the bug)
-		//
-		// The fix: flushNow() waits for all in-flight flushes to drain *before* setting
-		// pendingPriority, so the continuation cannot steal it.
-
-		let resolveFirstFlush: (() => void) | undefined
-		let flushCount = 0
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: async () => {
-				flushCount += 1
-				if (flushCount === 1) {
-					// First flush: pause so flushNow() arrives while it's in-flight
-					await new Promise<void>((resolve) => {
-						resolveFirstFlush = resolve
-					})
-				}
-			},
-			getDelayMs: () => 0,
-		})
-
-		// Start the first flush (via immediate requestFlush)
-		scheduler.requestFlush("immediate")
-		// Yield so the async flush body starts executing
-		await Promise.resolve()
-		await Promise.resolve()
-
-		// flushNow() is called while flush #1 is paused mid-execution
-		let flushNowResolved = false
-		const flushNowPromise = scheduler.flushNow().then(() => {
-			flushNowResolved = true
-		})
-
-		// Unblock flush #1
-		resolveFirstFlush?.()
-		await flushNowPromise
-
-		// flushNow must have triggered a second flush after flush #1 completed
-		flushNowResolved.should.equal(true)
-		flushCount.should.equal(2)
-	})
-
-	it("runs an immediate follow-up flush requested during an in-flight flush", async () => {
-		let resolveFirstFlush: (() => void) | undefined
-		let flushCount = 0
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: async () => {
-				flushCount += 1
-				if (flushCount === 1) {
-					await new Promise<void>((resolve) => {
-						resolveFirstFlush = resolve
-					})
-				}
-			},
-			getDelayMs: () => 0,
-		})
-
-		scheduler.requestFlush("immediate")
-		await Promise.resolve()
-		await Promise.resolve()
-
-		scheduler.requestFlush("immediate")
-		resolveFirstFlush?.()
-
-		await scheduler.flushNow()
-		flushCount.should.equal(3)
-	})
-
-	it("reset() cancels pending timers without marking the scheduler as disposed", () => {
-		const clock = sinon.useFakeTimers()
-		const flushSpy = sinon.spy(async () => {})
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: flushSpy,
-			getDelayMs: () => 50,
-		})
-
-		scheduler.requestFlush("normal")
-		scheduler.reset()
-
-		// The pending timer should have been cancelled
-		clock.tick(100)
-		flushSpy.callCount.should.equal(0)
-
-		// Scheduler should still be usable after reset (not disposed)
-		scheduler.requestFlush("normal")
-		clock.tick(50)
-		flushSpy.callCount.should.equal(1)
-
-		clock.restore()
-	})
-
-	it("immediate priority bypasses the timer and flushes synchronously", () => {
-		const clock = sinon.useFakeTimers()
-		const flushSpy = sinon.spy(async () => {})
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: flushSpy,
-			getDelayMs: () => 100,
-		})
-
-		scheduler.requestFlush("immediate")
-		// immediate fires via void runFlushCycle, which starts synchronously
-		flushSpy.callCount.should.equal(1)
-
-		clock.restore()
-	})
-
-	it("upgrades a pending normal timer to immediate when immediate is requested", () => {
-		const clock = sinon.useFakeTimers()
-		const flushSpy = sinon.spy(async () => {})
-
-		const scheduler = new TaskPresentationScheduler({
-			flush: flushSpy,
-			getDelayMs: () => 100,
-		})
-
-		scheduler.requestFlush("normal")
-		clock.tick(50)
-		flushSpy.callCount.should.equal(0)
-
-		// Upgrade to immediate — should cancel the timer and flush now
-		scheduler.requestFlush("immediate")
-		flushSpy.callCount.should.equal(1)
-
-		// Original timer should not fire again
-		clock.tick(100)
-		flushSpy.callCount.should.equal(1)
-
-		clock.restore()
-	})
-})

src/core/task/__tests__/ToolExecutor.canonicalization.test.ts

@@ -1,58 +0,0 @@
-import { strict as assert } from "node:assert"
-import { ClineDefaultTool } from "@shared/tools"
-import { describe, it } from "mocha"
-import type { ToolUse } from "../../assistant-message"
-import { canonicalizeAttemptCompletionParams } from "../ToolExecutor"
-
-describe("ToolExecutor canonicalization", () => {
-	it("canonicalizes attempt_completion response into result", () => {
-		const block: ToolUse = {
-			type: "tool_use",
-			name: ClineDefaultTool.ATTEMPT,
-			params: {
-				response: "final answer from response field",
-				task_progress: "- [x] done",
-			},
-			partial: false,
-		}
-
-		const didCanonicalize = canonicalizeAttemptCompletionParams(block)
-
-		assert.equal(didCanonicalize, true)
-		assert.equal(block.params.result, "final answer from response field")
-		assert.equal(block.params.response, "final answer from response field")
-	})
-
-	it("does not canonicalize when attempt_completion already has result", () => {
-		const block: ToolUse = {
-			type: "tool_use",
-			name: ClineDefaultTool.ATTEMPT,
-			params: {
-				result: "already canonical",
-				response: "extra text",
-			},
-			partial: false,
-		}
-
-		const didCanonicalize = canonicalizeAttemptCompletionParams(block)
-
-		assert.equal(didCanonicalize, false)
-		assert.equal(block.params.result, "already canonical")
-	})
-
-	it("does not canonicalize non-attempt tools", () => {
-		const block: ToolUse = {
-			type: "tool_use",
-			name: ClineDefaultTool.ACT_MODE,
-			params: {
-				response: "act mode response",
-			},
-			partial: false,
-		}
-
-		const didCanonicalize = canonicalizeAttemptCompletionParams(block)
-
-		assert.equal(didCanonicalize, false)
-		assert.equal(block.params.result, undefined)
-	})
-})

src/core/task/__tests__/ToolExecutor.test.ts

@@ -1,394 +0,0 @@
-import { afterEach, beforeEach, describe, it } from "mocha"
-import "should"
-import sinon from "sinon"
-
-describe("ToolExecutor Hook Integration", () => {
-	let sandbox: sinon.SinonSandbox
-
-	beforeEach(() => {
-		sandbox = sinon.createSandbox()
-	})
-
-	afterEach(() => {
-		sandbox.restore()
-	})
-
-	describe("addHookContextToConversation", () => {
-		it("should handle undefined context", () => {
-			// Test that undefined context doesn't add anything
-			const userMessageContent: any[] = []
-
-			// Simulate the method behavior - undefined context should not add anything
-			const contextModification: string | undefined = undefined
-			// The implementation checks for truthiness, which excludes undefined
-			if (contextModification) {
-				userMessageContent.push({ type: "text", text: "should not reach here" })
-			}
-
-			userMessageContent.length.should.equal(0)
-		})
-
-		it("should handle empty context", () => {
-			const userMessageContent: any[] = []
-
-			// Simulate the method behavior - empty string is falsy in if check
-			const contextModification: string | undefined = ""
-			// Empty string is falsy, so this block won't execute
-			if (contextModification) {
-				userMessageContent.push({ type: "text", text: "should not reach here" })
-			}
-
-			userMessageContent.length.should.equal(0)
-		})
-
-		it("should handle whitespace-only context", () => {
-			const userMessageContent: any[] = []
-
-			// Simulate the method behavior
-			const contextModification = "   \n  \t  "
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					userMessageContent.push({ type: "text", text: "should not reach here" })
-				}
-			}
-
-			userMessageContent.length.should.equal(0)
-		})
-
-		it("should add context without type prefix", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "Simple context message"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent.length.should.equal(1)
-			userMessageContent[0].text.should.match(/type="general"/)
-			userMessageContent[0].text.should.match(/Simple context message/)
-			userMessageContent[0].text.should.match(/source="PreToolUse"/)
-		})
-
-		it("should extract type from WORKSPACE_RULES prefix", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "WORKSPACE_RULES: Follow TypeScript conventions"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent.length.should.equal(1)
-			userMessageContent[0].text.should.match(/type="workspace_rules"/)
-			userMessageContent[0].text.should.match(/Follow TypeScript conventions/)
-			userMessageContent[0].text.should.not.match(/WORKSPACE_RULES:/)
-		})
-
-		it("should extract type from FILE_OPERATIONS prefix", () => {
-			const userMessageContent: any[] = []
-			const source = "PostToolUse"
-			const contextModification = "FILE_OPERATIONS: Created file.ts successfully"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent.length.should.equal(1)
-			userMessageContent[0].text.should.match(/type="file_operations"/)
-			userMessageContent[0].text.should.match(/Created file\.ts successfully/)
-		})
-
-		it("should handle multi-line context with type", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "VALIDATION: First line content\nSecond line of context\nThird line of context"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent.length.should.equal(1)
-			userMessageContent[0].text.should.match(/type="validation"/)
-			userMessageContent[0].text.should.match(/First line content/)
-			userMessageContent[0].text.should.match(/Second line/)
-			userMessageContent[0].text.should.match(/Third line/)
-		})
-
-		it("should handle multi-line context with type but no content on first line", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "PERFORMANCE:\nTool execution took longer than expected\nConsider optimization"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent.length.should.equal(1)
-			userMessageContent[0].text.should.match(/type="performance"/)
-			userMessageContent[0].text.should.match(/Tool execution took/)
-			userMessageContent[0].text.should.match(/Consider optimization/)
-		})
-
-		it("should preserve source parameter correctly", () => {
-			const userMessageContent: any[] = []
-			const source = "PostToolUse"
-			const contextModification = "Some context"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent[0].text.should.match(/source="PostToolUse"/)
-		})
-
-		it("should handle type with underscores", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "MY_CUSTOM_TYPE: Custom context"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			userMessageContent[0].text.should.match(/type="my_custom_type"/)
-		})
-
-		it("should not match lowercase type prefix", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "lowercase_type: This should not be extracted as type"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			// Should use default "general" type since lowercase doesn't match
-			userMessageContent[0].text.should.match(/type="general"/)
-			userMessageContent[0].text.should.match(/lowercase_type:/)
-		})
-
-		it("should filter out empty lines when extracting multi-line content", () => {
-			const userMessageContent: any[] = []
-			const source = "PreToolUse"
-			const contextModification = "TEST_TYPE: First line\n\n\nSecond line\n  \nThird line"
-
-			// Simulate the method behavior
-			if (contextModification) {
-				const contextText = contextModification.trim()
-				if (contextText) {
-					const lines = contextText.split("\n")
-					const firstLine = lines[0]
-					let contextType = "general"
-					let content = contextText
-
-					const typeMatchRegex = /^([A-Z_]+):\s*(.*)/
-					const typeMatch = typeMatchRegex.exec(firstLine)
-					if (typeMatch) {
-						contextType = typeMatch[1].toLowerCase()
-						const remainingLines = lines.slice(1).filter((l: string) => l.trim())
-						content = typeMatch[2] ? [typeMatch[2], ...remainingLines].join("\n") : remainingLines.join("\n")
-					}
-
-					userMessageContent.push({
-						type: "text",
-						text: `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`,
-					})
-				}
-			}
-
-			// Verify the content contains the expected lines
-			userMessageContent[0].text.should.match(/First line/)
-			userMessageContent[0].text.should.match(/Second line/)
-			userMessageContent[0].text.should.match(/Third line/)
-			// Verify empty lines were filtered out
-			userMessageContent[0].text.should.not.match(/First line\n\n/)
-			userMessageContent[0].text.should.not.match(/Second line\n\n/)
-		})
-	})
-
-	describe("Hook Context XML Format", () => {
-		it("should generate properly formatted XML", () => {
-			const source = "PreToolUse"
-			const contextType = "workspace_rules"
-			const content = "Test content"
-
-			const xml = `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`
-
-			xml.should.match(/<hook_context source="PreToolUse" type="workspace_rules">/)
-			xml.should.match(/Test content/)
-			xml.should.match(/<\/hook_context>/)
-		})
-
-		it("should handle special characters in content", () => {
-			const source = "PreToolUse"
-			const contextType = "general"
-			const content = 'Content with <special> & "characters"'
-
-			const xml = `<hook_context source="${source}" type="${contextType}">\n${content}\n</hook_context>`
-
-			xml.should.match(new RegExp(content.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
-		})
-	})
-})

src/core/task/__tests__/latency.test.ts

@@ -1,52 +0,0 @@
-import { describe, it } from "mocha"
-import "should"
-
-import { isRemoteWorkspaceEnvironment } from "../latency"
-
-describe("latency", () => {
-	it("detects remote workspaces from explicit remoteName metadata", () => {
-		isRemoteWorkspaceEnvironment({
-			platform: "Visual Studio Code",
-			version: "1.103.0",
-			remoteName: "ssh-remote",
-		}).should.equal(true)
-	})
-
-	it("detects remote workspaces for dev-container and codespaces remoteName values", () => {
-		isRemoteWorkspaceEnvironment({ remoteName: "dev-container" }).should.equal(true)
-		isRemoteWorkspaceEnvironment({ remoteName: "codespaces" }).should.equal(true)
-	})
-
-	it("does not classify hosts as remote when remoteName is absent", () => {
-		isRemoteWorkspaceEnvironment({
-			platform: "Visual Studio Code",
-			version: "1.103.0",
-			remoteName: undefined,
-		}).should.equal(false)
-	})
-
-	it("does not classify hosts as remote when remoteName is null", () => {
-		isRemoteWorkspaceEnvironment({
-			platform: "Visual Studio Code",
-			version: "1.103.0",
-			remoteName: null,
-		}).should.equal(false)
-	})
-
-	it("does not false-positive on platform or version strings containing 'remote'", () => {
-		// Previously the heuristic would have returned true for these — now it must not.
-		isRemoteWorkspaceEnvironment({
-			platform: "Remote IDE",
-			version: "1.0.0",
-		}).should.equal(false)
-
-		isRemoteWorkspaceEnvironment({
-			platform: "Visual Studio Code",
-			version: "1.0.0-remote-fix",
-		}).should.equal(false)
-	})
-
-	it("does not classify hosts as remote when no fields are provided", () => {
-		isRemoteWorkspaceEnvironment({}).should.equal(false)
-	})
-})

src/core/task/__tests__/loop-detection.test.ts

@@ -1,134 +0,0 @@
-import { describe, it } from "mocha"
-import "should"
-import { checkRepeatedToolCall, toolCallSignature } from "../loop-detection"
-import { TaskState } from "../TaskState"
-
-/** Simulate a tool call matching production order in ToolExecutor. */
-function simulateToolCall(state: TaskState, toolName: string, params: Record<string, string>, maxMistakes = 3) {
-	const sig = toolCallSignature(params)
-	const result = checkRepeatedToolCall(state, toolName, sig)
-
-	if (result.softWarning) {
-		state.userMessageContent.push({ type: "text", text: `[WARNING] loop detected for ${toolName}` })
-	}
-	if (result.hardEscalation) {
-		state.consecutiveMistakeCount = maxMistakes
-	}
-
-	state.lastToolName = toolName
-	state.lastToolParams = sig
-	return result
-}
-
-describe("toolCallSignature", () => {
-	it("produces identical output regardless of key order", () => {
-		toolCallSignature({ b: "2", a: "1" }).should.equal(toolCallSignature({ a: "1", b: "2" }))
-	})
-})
-
-describe("Loop Detection", () => {
-	it("should warn at 3 identical calls and escalate at 5", () => {
-		const state = new TaskState()
-		const results = []
-		for (let i = 0; i < 5; i++) {
-			results.push(simulateToolCall(state, "read_file", { path: "src/main.ts" }))
-		}
-
-		results[0].softWarning.should.be.false()
-		results[1].softWarning.should.be.false()
-		results[2].softWarning.should.be.true()
-		results[3].softWarning.should.be.false()
-		results[3].hardEscalation.should.be.false()
-		results[4].softWarning.should.be.false()
-		results[4].hardEscalation.should.be.true()
-		state.userMessageContent.length.should.equal(1)
-		state.consecutiveMistakeCount.should.equal(3)
-	})
-
-	it("should reset when tool or params change", () => {
-		const state = new TaskState()
-
-		simulateToolCall(state, "read_file", { path: "a.ts" })
-		simulateToolCall(state, "read_file", { path: "a.ts" })
-		simulateToolCall(state, "read_file", { path: "b.ts" }) // different params
-		state.consecutiveIdenticalToolCount.should.equal(1)
-
-		simulateToolCall(state, "read_file", { path: "b.ts" })
-		simulateToolCall(state, "list_files", { path: "b.ts" }) // different tool
-		state.consecutiveIdenticalToolCount.should.equal(1)
-	})
-
-	it("should NOT count different tools with same params as identical", () => {
-		const state = new TaskState()
-
-		simulateToolCall(state, "read_file", { path: "src/main.ts" })
-		simulateToolCall(state, "search_files", { path: "src/main.ts" })
-		simulateToolCall(state, "list_files", { path: "src/main.ts" })
-
-		state.consecutiveIdenticalToolCount.should.equal(1)
-	})
-
-	it("should re-arm after loop detection state is reset", () => {
-		const state = new TaskState()
-
-		// First cycle: escalate at call 5
-		for (let i = 0; i < 5; i++) {
-			simulateToolCall(state, "read_file", { path: "src/main.ts" })
-		}
-		state.consecutiveIdenticalToolCount.should.equal(5)
-		state.consecutiveMistakeCount.should.equal(3)
-
-		// Simulate what index.ts does when user clicks "continue"
-		state.consecutiveMistakeCount = 0
-		state.consecutiveIdenticalToolCount = 0
-		state.lastToolName = ""
-		state.lastToolParams = ""
-
-		// Second cycle: same tool + params should trigger again
-		const results = []
-		for (let i = 0; i < 5; i++) {
-			results.push(simulateToolCall(state, "read_file", { path: "src/main.ts" }))
-		}
-
-		results[2].softWarning.should.be.true()
-		results[4].hardEscalation.should.be.true()
-		state.consecutiveMistakeCount.should.equal(3)
-	})
-
-	it("should work correctly when tool changes after reset", () => {
-		const state = new TaskState()
-
-		// Escalate with one tool
-		for (let i = 0; i < 5; i++) {
-			simulateToolCall(state, "read_file", { path: "src/main.ts" })
-		}
-
-		// Reset (user clicks "continue")
-		state.consecutiveMistakeCount = 0
-		state.consecutiveIdenticalToolCount = 0
-		state.lastToolName = ""
-		state.lastToolParams = ""
-
-		// Model switches to a different tool — no false positives
-		const result = simulateToolCall(state, "list_files", { path: "src/" })
-		result.softWarning.should.be.false()
-		result.hardEscalation.should.be.false()
-		state.consecutiveIdenticalToolCount.should.equal(1)
-	})
-
-	it("should strip task_progress from comparison", () => {
-		const state = new TaskState()
-		const results = []
-		for (let i = 0; i < 5; i++) {
-			results.push(
-				simulateToolCall(state, "read_file", {
-					path: "src/index.ts",
-					task_progress: `step ${i} of 5`,
-				}),
-			)
-		}
-
-		results[2].softWarning.should.be.true()
-		results[4].hardEscalation.should.be.true()
-	})
-})

src/core/task/focus-chain/index.ts

@@ -1,408 +0,0 @@
-import { FocusChainSettings } from "@shared/FocusChainSettings"
-import * as chokidar from "chokidar"
-import * as fs from "fs/promises"
-import { telemetryService } from "@/services/telemetry"
-import { Logger } from "@/shared/services/Logger"
-import { ClineSay } from "../../../shared/ExtensionMessage"
-import { Mode } from "../../../shared/storage/types"
-import { writeFile } from "../../../utils/fs"
-import { ensureTaskDirectoryExists } from "../../storage/disk"
-import { StateManager } from "../../storage/StateManager"
-import { TaskState } from "../TaskState"
-import {
-	createFocusChainMarkdownContent,
-	extractFocusChainItemsFromText,
-	extractFocusChainListFromText,
-	getFocusChainFilePath,
-} from "./file-utils"
-import { FocusChainPrompts } from "./prompts"
-import { parseFocusChainListCounts } from "./utils"
-
-export interface FocusChainDependencies {
-	taskId: string
-	taskState: TaskState
-	mode: Mode
-	stateManager: StateManager
-	postStateToWebview: () => Promise<void>
-	say: (type: ClineSay, text?: string, images?: string[], files?: string[], partial?: boolean) => Promise<number | undefined>
-	focusChainSettings: FocusChainSettings
-}
-
-export class FocusChainManager {
-	private taskId: string
-	private taskState: TaskState
-	private stateManager: StateManager
-	private postStateToWebview: () => Promise<void>
-	private say: (
-		type: ClineSay,
-		text?: string,
-		images?: string[],
-		files?: string[],
-		partial?: boolean,
-	) => Promise<number | undefined>
-	private focusChainFileWatcher?: chokidar.FSWatcher
-	private hasTrackedFirstProgress = false
-	private focusChainSettings: FocusChainSettings
-	private fileUpdateDebounceTimer?: NodeJS.Timeout
-
-	constructor(dependencies: FocusChainDependencies) {
-		this.taskId = dependencies.taskId
-		this.taskState = dependencies.taskState
-		this.stateManager = dependencies.stateManager
-		this.postStateToWebview = dependencies.postStateToWebview
-		this.say = dependencies.say
-		this.focusChainSettings = dependencies.focusChainSettings
-	}
-
-	/**
-	 * Sets up a file watcher to monitor changes to the focus chain list markdown file.
-	 * Automatically updates the UI when the file is created, modified, or deleted by external editors.
-	 * @requires this.taskId, this.context to be initialized
-	 * @returns Promise<void> - Resolves when watcher is set up, logs errors if setup fails
-	 */
-	public async setupFocusChainFileWatcher() {
-		try {
-			const taskDir = await ensureTaskDirectoryExists(this.taskId)
-			const focusChainFilePath = getFocusChainFilePath(taskDir, this.taskId)
-
-			// Initialize chokidar watcher
-			this.focusChainFileWatcher = chokidar.watch(focusChainFilePath, {
-				persistent: true,
-				ignoreInitial: true,
-				awaitWriteFinish: {
-					stabilityThreshold: 300,
-					pollInterval: 100,
-				},
-			})
-
-			// Handle file changes
-			this.focusChainFileWatcher
-				.on("add", async () => {
-					await this.updateFCListFromMarkdownFileAndNotifyUI()
-				})
-				.on("change", async () => {
-					await this.updateFCListFromMarkdownFileAndNotifyUI()
-				})
-				.on("unlink", async () => {
-					this.taskState.currentFocusChainChecklist = null
-					await this.postStateToWebview()
-				})
-				.on("error", (error) => {
-					Logger.error(`[Task ${this.taskId}] Failed to watch focus chain file:`, error)
-				})
-
-			Logger.log(`[Task ${this.taskId}] Todo file watcher initialized`)
-		} catch (error) {
-			Logger.error(`[Task ${this.taskId}] Failed to setup todo file watcher:`, error)
-		}
-	}
-
-	/**
-	 * Reads the current focus chain list from the markdown file and updates the UI with any changes.
-	 * Uses debouncing (300ms) to prevent excessive updates and only notifies the webview when content actually changes.
-	 * @requires File watcher to be active and markdown file to exist
-	 * @returns Promise<void> - Updates taskState.currentFocusChainChecklist and calls postStateToWebview()
-	 */
-	private async updateFCListFromMarkdownFileAndNotifyUI() {
-		if (this.fileUpdateDebounceTimer) {
-			clearTimeout(this.fileUpdateDebounceTimer)
-		}
-
-		// Debounce file watcher to prevent false positives
-		this.fileUpdateDebounceTimer = setTimeout(async () => {
-			try {
-				const markdownTodoList = await this.readFocusChainFromDisk()
-				if (markdownTodoList) {
-					const previousList = this.taskState.currentFocusChainChecklist
-
-					// Only update if the content actually changed
-					if (previousList !== markdownTodoList) {
-						this.taskState.currentFocusChainChecklist = markdownTodoList
-						this.taskState.todoListWasUpdatedByUser = true
-
-						await this.postStateToWebview()
-						telemetryService.captureFocusChainListWritten(this.taskId)
-					} else {
-						Logger.log(
-							`[Task ${this.taskId}] Focus Chain List: File watcher triggered but content unchanged, skipping update`,
-						)
-					}
-				}
-			} catch (error) {
-				Logger.error(`[Task ${this.taskId}] Error updating focuss chain list from markdown file:`, error)
-			}
-		}, 300)
-	}
-
-	/**
-	 * Generates contextual instructions for focus chain list creation and management based on current task state.
-	 * Returns formatted markdown instructions that guide the AI on when and how to update progress tracking.
-	 * @requires this.taskState with current focus chain list state and API request counts
-	 * @returns string - Formatted markdown instructions for focus chain list management, varies by context
-	 */
-	public generateFocusChainInstructions(): string {
-		// If list exists already exists, we need to remind it to update rather than demand initialization
-		if (this.taskState.currentFocusChainChecklist) {
-			// Parse the current list for counts/stats
-			const { totalItems, completedItems } = parseFocusChainListCounts(this.taskState.currentFocusChainChecklist)
-			const percentComplete = totalItems > 0 ? Math.round((completedItems / totalItems) * 100) : 0
-
-			const introUpdateRequired =
-				"# TODO LIST UPDATE REQUIRED - You MUST include the task_progress parameter in your NEXT tool call."
-			const listCurrentProgress = `**Current Progress: ${completedItems}/${totalItems} items completed (${percentComplete}%)**`
-			const userHasUpdatedList =
-				"**CRITICAL INFORMATION:** The user has modified this todo list - review ALL changes carefully"
-
-			// If user has updated the list, inform the model (and provide latest copy)
-			if (this.taskState.todoListWasUpdatedByUser) {
-				return `\n\n
-				${introUpdateRequired}\n
-				${listCurrentProgress}\n
-				\n
-				${this.taskState.currentFocusChainChecklist}\n
-				${userHasUpdatedList}\n
-				${FocusChainPrompts.reminder}\n
-			`
-
-				// If there are no user changes, proceed with reminders based on list progress
-			} else {
-				let progressBasedMessageStub = ""
-				// If there are items on the list, but none have been completed yet, remind the model to update the list when appropriate
-				if (completedItems === 0 && totalItems > 0) {
-					progressBasedMessageStub =
-						"\n\n**Note:** No items are marked complete yet. As you work through the task, remember to mark items as complete when finished."
-				} else if (percentComplete >= 25 && percentComplete < 50) {
-					progressBasedMessageStub = `\n\n**Note:** ${percentComplete}% of items are complete.`
-				} else if (percentComplete >= 50 && percentComplete < 75) {
-					progressBasedMessageStub = `\n\n**Note:** ${percentComplete}% of items are complete. Proceed with the task.`
-				} else if (percentComplete >= 75) {
-					progressBasedMessageStub = `\n\n**Note:** ${percentComplete}% of items are complete! Focus on finishing the remaining items.`
-				}
-				// Every item on the list has been completed. Hooray!
-				else if (completedItems === totalItems && totalItems > 0) {
-					progressBasedMessageStub = FocusChainPrompts.completed
-						.replace("{{totalItems}}", totalItems.toString())
-						.replace("{{currentFocusChainChecklist}}", this.taskState.currentFocusChainChecklist)
-				}
-
-				// Return with progress-based stub
-				return `\n
-				${introUpdateRequired}\n
-				${listCurrentProgress}\n
-				${this.taskState.currentFocusChainChecklist}\n
-				\n
-				${FocusChainPrompts.reminder}\n
-				${progressBasedMessageStub}\n
-				`
-			}
-		}
-		// When switching from Plan to Act, request that a new list be generated
-		else if (this.taskState.didRespondToPlanAskBySwitchingMode) {
-			return `${FocusChainPrompts.initial}`
-		}
-
-		// When in plan mode, lists are optional. TODO - May want to improve this soft prompt approach in a future version
-		else if (this.stateManager.getGlobalSettingsKey("mode") === "plan") {
-			return FocusChainPrompts.planModeReminder
-		} else {
-			// Check if we're early in the task
-			const isEarlyInTask = this.taskState.apiRequestCount < 10
-			if (isEarlyInTask) {
-				return FocusChainPrompts.recommended
-			} else {
-				return FocusChainPrompts.apiRequestCount.replace("{{apiRequestCount}}", this.taskState.apiRequestCount.toString())
-			}
-		}
-	}
-
-	/**
-	 * Reads the focus chain list from the task's markdown file on disk and extracts the checklist content.
-	 * Returns the raw focus chain list string if found, or null if the file doesn't exist or contains no valid todos.
-	 * @requires this.taskId and this.context to locate the task directory
-	 * @returns Promise<string | null> - focus chain list content as string, or null if file missing/invalid
-	 * @throws Returns null on file read errors (file not found, permission issues)
-	 */
-	private async readFocusChainFromDisk(): Promise<string | null> {
-		try {
-			const taskDir = await ensureTaskDirectoryExists(this.taskId)
-			const todoFilePath = getFocusChainFilePath(taskDir, this.taskId)
-			const markdownContent = await fs.readFile(todoFilePath, "utf8")
-			const todoList = extractFocusChainListFromText(markdownContent)
-
-			if (todoList) {
-				const _todoLines = extractFocusChainItemsFromText(markdownContent)
-				return todoList
-			}
-
-			return null
-		} catch (error) {
-			// File doesn't exist or can't be read, return null
-			Logger.log(`[Task ${this.taskId}] focus chain list: Could not load from markdown file: ${error}`)
-			return null
-		}
-	}
-
-	/**
-	 * Writes the provided focus chain list to the task's markdown file on disk with proper formatting.
-	 * Creates the full markdown document structure and triggers file watchers to update the UI.
-	 * @param todoList - Raw focus chain list string with markdown checklist items
-	 * @requires this.taskId and this.context for file path generation
-	 * @returns Promise<void> - Resolves when file is written successfully
-	 * @throws Error if file write fails (disk full, permissions, etc.)
-	 */
-	private async writeFocusChainToDisk(todoList: string): Promise<void> {
-		try {
-			const taskDir = await ensureTaskDirectoryExists(this.taskId)
-			const todoFilePath = getFocusChainFilePath(taskDir, this.taskId)
-			const fileContent = createFocusChainMarkdownContent(this.taskId, todoList)
-			await writeFile(todoFilePath, fileContent, "utf8")
-		} catch (error) {
-			Logger.error(`[Task ${this.taskId}] focus chain list: FILE WRITE FAILED - Error:`, error)
-			throw error
-		}
-	}
-
-	/**
-	 * Processes focus chain list updates from the AI model's task_progress parameter and persists them to disk.
-	 * Handles telemetry tracking for progress updates and falls back to reading existing files if no update provided.
-	 * Also manages the apiRequestsSinceLastTodoUpdate counter and includes comprehensive error handling.
-	 * @param taskProgress - Optional focus chain list string from AI model's task_progress parameter
-	 * @requires this.taskState, this.say method, and telemetryService to be available
-	 * @returns Promise<void> - Updates taskState.currentFocusChainChecklist and sends UI messages
-	 */
-	public async updateFCListFromToolResponse(taskProgress: string | undefined) {
-		try {
-			// Reset the counter if task_progress was provided
-			if (taskProgress && taskProgress.trim()) {
-				this.taskState.apiRequestsSinceLastTodoUpdate = 0
-			}
-
-			// If model provides task_progress update, write it to the markdown file
-			if (taskProgress && taskProgress.trim()) {
-				const previousList = this.taskState.currentFocusChainChecklist
-				this.taskState.currentFocusChainChecklist = taskProgress.trim()
-				Logger.debug(
-					`[Task ${this.taskId}] focus chain list: LLM provided focus chain list update via task_progress parameter. Length ${previousList?.length || 0} > ${this.taskState.currentFocusChainChecklist.length}`,
-				)
-
-				// Parse focus chain list counts for telemetry
-				const { totalItems, completedItems } = parseFocusChainListCounts(taskProgress.trim())
-
-				// Track first progress creation
-				if (!this.hasTrackedFirstProgress && totalItems > 0) {
-					telemetryService.captureFocusChainProgressFirst(this.taskId, totalItems)
-					this.hasTrackedFirstProgress = true
-				}
-				// Track progress updates (only if not the first, and has items)
-				else if (this.hasTrackedFirstProgress && totalItems > 0) {
-					telemetryService.captureFocusChainProgressUpdate(this.taskId, totalItems, completedItems)
-				}
-
-				// Write the model's update to the markdown file
-				try {
-					await this.writeFocusChainToDisk(taskProgress.trim())
-
-					// Send the task_progress message to the UI immediately
-					await this.say("task_progress", taskProgress.trim())
-				} catch (error) {
-					Logger.error(`[Task ${this.taskId}] focus chain list: Failed to write to markdown file:`, error)
-					// Fall back to creating a task_progress message directly if file write fails
-					await this.say("task_progress", taskProgress.trim())
-					Logger.log(`[Task ${this.taskId}] focus chain list: Sent fallback task_progress message to UI`)
-				}
-			} else {
-				// No model update provided, check if markdown file exists and load it
-				const markdownTodoList = await this.readFocusChainFromDisk()
-				if (markdownTodoList) {
-					const _previousList = this.taskState.currentFocusChainChecklist
-					this.taskState.currentFocusChainChecklist = markdownTodoList
-
-					// Create a task_progress message to display the focus chain list in the UI
-					await this.say("task_progress", markdownTodoList)
-				} else {
-					Logger.debug(`[Task ${this.taskId}] focus chain list: No valid task progress to update with`)
-				}
-			}
-		} catch (error) {
-			Logger.error(`[Task ${this.taskId}] focus chain list: Error in updateFCListFromToolResponse:`, error)
-		}
-	}
-
-	/**
-	 * Evaluates multiple conditions to determine if focus chain list instructions should be included in the AI prompt.
-	 * Returns true when in plan mode, after mode switches, when user edits exist, or at reminder intervals.
-	 * @requires this.mode, this.taskState, and this.focusChainSettings to be initialized
-	 * @returns boolean - True if instructions should be included in AI prompt, false otherwise
-	 */
-	public shouldIncludeFocusChainInstructions(): boolean {
-		// Always include when in Plan mode
-		const inPlanMode = this.stateManager.getGlobalSettingsKey("mode") === "plan"
-		// Always include when switching from Plan > Act
-		const justSwitchedFromPlanMode = this.taskState.didRespondToPlanAskBySwitchingMode
-		// Always include when user had edited the list manually
-		const userUpdatedList = this.taskState.todoListWasUpdatedByUser
-		// Include when reaching the reminder interval, configured by settings
-		const reachedReminderInterval =
-			this.taskState.apiRequestsSinceLastTodoUpdate >= this.focusChainSettings.remindClineInterval
-		// Include on first API request or if list does not exist
-		const isFirstApiRequest = this.taskState.apiRequestCount === 1 && !this.taskState.currentFocusChainChecklist
-		// Include if no list has been created and multiple requests have completed
-		const hasNoTodoListAfterMultipleRequests =
-			!this.taskState.currentFocusChainChecklist && this.taskState.apiRequestCount >= 2
-
-		const shouldInclude =
-			reachedReminderInterval ||
-			justSwitchedFromPlanMode ||
-			userUpdatedList ||
-			inPlanMode ||
-			isFirstApiRequest ||
-			hasNoTodoListAfterMultipleRequests
-
-		return shouldInclude
-	}
-
-	/**
-	 * Analyzes the current focus chain list for incomplete items when a task is marked as complete.
-	 * Captures telemetry data about unfinished progress items to help improve the focus chain system.
-	 * @param modelId The model ID being used (for telemetry)
-	 * @param provider The API provider being used (for telemetry)
-	 * @requires this.focusChainSettings.enabled and this.taskState.currentFocusChainChecklist to exist
-	 * @returns void - Sends telemetry data if incomplete items found, no return value
-	 */
-	public checkIncompleteProgressOnCompletion(modelId: string, provider: string) {
-		if (this.focusChainSettings.enabled && this.taskState.currentFocusChainChecklist) {
-			const { totalItems, completedItems } = parseFocusChainListCounts(this.taskState.currentFocusChainChecklist)
-
-			// Only track if there are items and not all are marked as completed
-			if (totalItems > 0 && completedItems < totalItems) {
-				const incompleteItems = totalItems - completedItems
-				telemetryService.captureFocusChainIncompleteOnCompletion(
-					this.taskId,
-					totalItems,
-					completedItems,
-					incompleteItems,
-					modelId,
-					provider,
-				)
-			}
-		}
-	}
-
-	/**
-	 * Performs cleanup operations when the focus chain manager is no longer needed.
-	 * Cancels active file watchers and clears any pending debounce timers to prevent memory leaks.
-	 * @requires No parameters needed
-	 * @returns void - Cleans up timers and watchers, no return value
-	 */
-	public dispose() {
-		if (this.fileUpdateDebounceTimer) {
-			clearTimeout(this.fileUpdateDebounceTimer)
-			this.fileUpdateDebounceTimer = undefined
-		}
-
-		if (this.focusChainFileWatcher) {
-			this.focusChainFileWatcher.close()
-			this.focusChainFileWatcher = undefined
-		}
-	}
-}

src/core/task/focus-chain/prompts.ts

@@ -1,112 +0,0 @@
-// Prompt for initial list creation
-const initial = `
-# task_progress CREATION REQUIRED - ACT MODE ACTIVATED
-
-**You've just switched from PLAN MODE to ACT MODE!**
-
-** IMMEDIATE ACTION REQUIRED:**
-1. Create a comprehensive todo list in your NEXT tool call
-2. Use the task_progress parameter to provide the list
-3. Format each item using markdown checklist syntax:
-	- [ ] For tasks to be done
-	- [x] For any tasks already completed
-
-**Your todo/task_progress list should include:**
-   - All major implementation steps
-   - Testing and validation tasks
-   - Documentation updates if needed
-   - Final verification steps
-
-**Example format:**\
-   - [ ] Set up project structure
-   - [ ] Implement core functionality
-   - [ ] Add error handling
-   - [ ] Write tests
-   - [ ] Test implementation
-   - [ ] Document changes
-
-**Remember:** Keeping the task_progress list updated helps track progress and ensures nothing is missed.`
-
-// For when recommending but not requiring a list
-const listInstructionsRecommended = `
-1. Include a todo list using the task_progress parameter in your next tool call
-2. Create a comprehensive checklist of all steps needed
-3. Use markdown format: - [ ] for incomplete, - [x] for complete
-
-**Benefits of creating a todo/task_progress list now:**
-	- Clear roadmap for implementation
-	- Progress tracking throughout the task
-	- Nothing gets forgotten or missed
-	- Users can see, monitor, and edit the plan
-
-**Example structure:**\`\`\`
-- [ ] Analyze requirements
-- [ ] Set up necessary files
-- [ ] Implement main functionality
-- [ ] Handle edge cases
-- [ ] Test the implementation
-- [ ] Verify results\`\`\`
-
-Keeping the task_progress list updated helps track progress and ensures nothing is missed.`
-
-// Prompt for reminders to update the list periodically
-const reminder = `
-1. To create or update a todo list, include the task_progress parameter in the next tool call
-2. Review each item and update its status:
-   - Mark completed items with: - [x]
-   - Keep incomplete items as: - [ ]
-   - Add new items if you discover additional steps
-3. Modify the list as needed:
-		- Add any new steps you've discovered
-		- Reorder if the sequence has changed
-4. Ensure the list accurately reflects the current state
-
-**Remember:** Keeping the task_progress list updated helps track progress and ensures nothing is missed.`
-
-const completed = `
-
-**All {{totalItems}} items have been completed!**
-
-**Completed Items:**
-{{currentFocusChainChecklist}}
-
-**Next Steps:**
-- If the task is fully complete and meets all requirements, use attempt_completion
-- If you've discovered additional work that wasn't in the original scope (new features, improvements, edge cases, etc.), create a new task_progress list with those items
-- If there are related tasks or follow-up items the user might want, you can suggest them in a new checklist
-
-**Remember:** Only use attempt_completion if you're confident the task is truly finished. If there's any remaining work, create a new focus chain list to track it.`
-
-const planModeReminder = `
-# task_progress List (Optional - Plan Mode)
-
-While in PLAN MODE, if you've outlined concrete steps or requirements for the user, you may include a preliminary todo list using the task_progress parameter.
-
-Reminder on how to use the task_progress parameter:
-
-${reminder}`
-
-const recommended = `
-# task_progress RECOMMENDED
-
-When starting a new task, it is recommended to include a todo list using the task_progress parameter.
-
-${listInstructionsRecommended}
-`
-
-const apiRequestCount = `
-# task_progress
-
-You've made {{apiRequestCount}} API requests without a task_progress parameter. It is strongly recomended that you create one to track remaining work.
-
-${reminder}
-`
-
-export const FocusChainPrompts = {
-	initial,
-	reminder,
-	recommended,
-	planModeReminder,
-	completed,
-	apiRequestCount,
-}

src/core/task/focus-chain/utils.ts

@@ -1,29 +0,0 @@
-import { isCompletedFocusChainItem, isFocusChainItem } from "@shared/focus-chain-utils"
-
-export interface TodoListCounts {
-	totalItems: number
-	completedItems: number
-}
-
-/**
- * Parses a focus chain list string and returns counts of total and completed items
- * @param todoList The focus chain list string to parse
- * @returns Object with totalItems and completedItems counts
- */
-export function parseFocusChainListCounts(todoList: string): TodoListCounts {
-	const lines = todoList.split("\n")
-	let totalItems = 0
-	let completedItems = 0
-
-	for (const line of lines) {
-		const trimmed = line.trim()
-		if (isFocusChainItem(trimmed)) {
-			totalItems++
-			if (isCompletedFocusChainItem(trimmed)) {
-				completedItems++
-			}
-		}
-	}
-
-	return { totalItems, completedItems }
-}

src/core/task/latency.ts

@@ -1,66 +0,0 @@
-import { Logger } from "@/shared/services/Logger"
-import type { PresentationPriority } from "./presentation-types"
-
-export type TaskLatencyTrigger = "text" | "reasoning" | "tool"
-
-function readBooleanEnv(envVarName: string): boolean {
-	const rawValue = process.env[envVarName]?.toLowerCase()
-	return rawValue === "1" || rawValue === "true" || rawValue === "yes"
-}
-
-function readCadenceOverride(envVarName: string): number | undefined {
-	const rawValue = process.env[envVarName]
-	if (!rawValue) {
-		return undefined
-	}
-
-	const parsed = Number.parseInt(rawValue, 10)
-	if (!Number.isFinite(parsed) || parsed < 0) {
-		Logger.warn(`[latency] Ignoring invalid cadence override ${envVarName}="${rawValue}" (must be a non-negative integer)`)
-		return undefined
-	}
-
-	return parsed
-}
-
-// Cadence overrides are read once at module load. Env vars do not change at
-// runtime, and getPresentationCadenceMs is called on every flush (hot path).
-const localCadenceOverride = readCadenceOverride("CLINE_PRESENTATION_CADENCE_MS")
-const remoteCadenceOverride = readCadenceOverride("CLINE_REMOTE_PRESENTATION_CADENCE_MS")
-const schedulingDisabled = readBooleanEnv("CLINE_DISABLE_PRESENTATION_SCHEDULER")
-
-/**
- * Determines whether the host is connected to a remote workspace.
- *
- * The primary signal is `remoteName` which is populated from `vscode.env.remoteName`
- * (e.g. `"ssh-remote"`, `"dev-container"`, `"codespaces"`). When this field is present
- * the host is definitively remote.
- *
- * For non-VSCode hosts (e.g. JetBrains) that do not populate `remoteName`, this
- * function conservatively returns `false` and uses the local cadence. This avoids
- * false positives from version strings that happen to contain the word "remote"
- * (e.g. `"1.0.0-remote-fix"`). Host bridges for remote-capable environments should
- * populate `remoteName` explicitly to opt in to the higher cadence.
- */
-export function isRemoteWorkspaceEnvironment(host: { platform?: string; version?: string; remoteName?: string | null }): boolean {
-	return !!host.remoteName
-}
-
-export function isPresentationSchedulingDisabled(): boolean {
-	return schedulingDisabled
-}
-
-export function getPresentationCadenceMs(isRemoteWorkspace: boolean, priority: PresentationPriority): number {
-	if (priority === "immediate") {
-		return 0
-	}
-
-	const override = isRemoteWorkspace ? remoteCadenceOverride : localCadenceOverride
-	if (override !== undefined) {
-		return override
-	}
-
-	// Default cadences: remote workspaces use a higher interval to reduce
-	// message-passing overhead over the network.
-	return isRemoteWorkspace ? 90 : 40
-}

src/core/task/loop-detection.ts

@@ -1,68 +0,0 @@
-/**
- * Repeated tool call loop detection.
- *
- * Detects when the LLM calls the same tool with identical arguments
- * repeatedly, which wastes tokens without making progress.
- *
- * This is complementary to fileReadCache in ReadFileToolHandler, which
- * deduplicates file *content* on cache hits but still allows the tool
- * call to succeed and consume a turn. Loop detection catches the
- * repeated call pattern itself, regardless of which tool is involved.
- *
- * Shared between ToolExecutor (production) and tests so the
- * comparison algorithm cannot drift between the two.
- */
-
-import type { TaskState } from "./TaskState"
-
-// Soft threshold: inject a warning, giving the LLM one chance to self-correct.
-// Hard threshold: escalate to user or fail task. Set higher to avoid false
-// positives on tools that may legitimately repeat (e.g., browser_action screenshots).
-export const LOOP_DETECTION_SOFT_THRESHOLD = 3
-const LOOP_DETECTION_HARD_THRESHOLD = 5
-
-// Params that are metadata/tracking, not tool-relevant input.
-// These change between calls even when the user-facing arguments are identical
-// (e.g., task_progress updates its checklist each turn).
-const IGNORED_PARAMS = new Set(["task_progress"])
-
-/**
- * Compute a canonical signature for a tool call's params.
- * Strips metadata fields and sorts keys via the JSON.stringify replacer
- * so key order doesn't affect comparison.
- *
- * block.params is Partial<Record<ToolParamName, string>> — always flat,
- * string-valued, no nesting — so the replacer array is sufficient.
- */
-export function toolCallSignature(params: Partial<Record<string, string>> | undefined): string {
-	if (!params) return "{}"
-	const keys = Object.keys(params)
-		.filter((k) => !IGNORED_PARAMS.has(k))
-		.sort()
-	return JSON.stringify(params, keys)
-}
-
-interface LoopDetectionResult {
-	softWarning: boolean
-	hardEscalation: boolean
-}
-
-/**
- * Core loop detection step. Must be called BEFORE updating
- * lastToolName / lastToolParams on TaskState.
- *
- * Compares the current call against the previous state, updates the
- * counter, and returns which thresholds (if any) were crossed.
- */
-export function checkRepeatedToolCall(state: TaskState, toolName: string, currentSignature: string): LoopDetectionResult {
-	if (toolName === state.lastToolName && currentSignature === state.lastToolParams) {
-		state.consecutiveIdenticalToolCount++
-	} else {
-		state.consecutiveIdenticalToolCount = 1
-	}
-
-	return {
-		softWarning: state.consecutiveIdenticalToolCount === LOOP_DETECTION_SOFT_THRESHOLD,
-		hardEscalation: state.consecutiveIdenticalToolCount === LOOP_DETECTION_HARD_THRESHOLD,
-	}
-}

src/core/task/message-state.ts

@@ -1,17 +1,9 @@
 import CheckpointTracker from "@integrations/checkpoints/CheckpointTracker"
 import { EventEmitter } from "events"
-import getFolderSize from "get-folder-size"
 import Mutex from "p-mutex"
-import { findLastIndex } from "@/shared/array"
-import { combineApiRequests } from "@/shared/combineApiRequests"
-import { combineCommandSequences } from "@/shared/combineCommandSequences"
 import { ClineMessage } from "@/shared/ExtensionMessage"
-import { getApiMetrics } from "@/shared/getApiMetrics"
 import { HistoryItem } from "@/shared/HistoryItem"
 import { ClineStorageMessage } from "@/shared/messages/content"
-import { Logger } from "@/shared/services/Logger"
-import { getCwd, getDesktopDir } from "@/utils/path"
-import { ensureTaskDirectoryExists, saveApiConversationHistory, saveClineMessages } from "../storage/disk"
 import { TaskState } from "./TaskState"
 
 // Event types for clineMessages changes
@@ -48,11 +40,7 @@ interface MessageStateHandlerParams {
 export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents> {
 	private apiConversationHistory: ClineStorageMessage[] = []
 	private clineMessages: ClineMessage[] = []
-	private taskIsFavorited: boolean
-	private checkpointTracker: CheckpointTracker | undefined
-	private updateTaskHistory: (historyItem: HistoryItem) => Promise<HistoryItem[]>
 	private taskId: string
-	private ulid: string
 	private taskState: TaskState
 
 	// Mutex to prevent concurrent state modifications (RC-4)
@@ -64,10 +52,7 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 	constructor(params: MessageStateHandlerParams) {
 		super()
 		this.taskId = params.taskId
-		this.ulid = params.ulid
 		this.taskState = params.taskState
-		this.taskIsFavorited = params.taskIsFavorited ?? false
-		this.updateTaskHistory = params.updateTaskHistory
 	}
 
 	/**
@@ -77,9 +62,7 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 		this.emit("clineMessagesChanged", change)
 	}
 
-	setCheckpointTracker(tracker: CheckpointTracker | undefined) {
-		this.checkpointTracker = tracker
-	}
+	setCheckpointTracker(_tracker: CheckpointTracker | undefined) {}
 
 	/**
 	 * Execute function with exclusive lock on message state
@@ -112,74 +95,16 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 		})
 	}
 
-	/**
-	 * Internal method to save messages and update history (without mutex protection)
-	 * This is used by methods that already hold the stateMutex lock
-	 * Should NOT be called directly - use saveClineMessagesAndUpdateHistory() instead
-	 */
-	private async saveClineMessagesAndUpdateHistoryInternal(): Promise<void> {
-		try {
-			await saveClineMessages(this.taskId, this.clineMessages)
-
-			// combined as they are in ChatView
-			const apiMetrics = getApiMetrics(combineApiRequests(combineCommandSequences(this.clineMessages.slice(1))))
-			const taskMessage = this.clineMessages[0] // first message is always the task say
-			const lastRelevantMessage =
-				this.clineMessages[
-					findLastIndex(
-						this.clineMessages,
-						(message) => !(message.ask === "resume_task" || message.ask === "resume_completed_task"),
-					)
-				]
-			const lastModelInfo = [...this.apiConversationHistory].reverse().find((msg) => msg.modelInfo !== undefined)
-			const taskDir = await ensureTaskDirectoryExists(this.taskId)
-			let taskDirSize = 0
-			try {
-				// getFolderSize.loose silently ignores errors
-				// returns # of bytes, size/1000/1000 = MB
-				taskDirSize = await getFolderSize.loose(taskDir)
-			} catch (error) {
-				Logger.error("Failed to get task directory size:", taskDir, error)
-			}
-			const cwd = await getCwd(getDesktopDir())
-			await this.updateTaskHistory({
-				id: this.taskId,
-				ulid: this.ulid,
-				ts: lastRelevantMessage.ts,
-				task: taskMessage.text ?? "",
-				tokensIn: apiMetrics.totalTokensIn,
-				tokensOut: apiMetrics.totalTokensOut,
-				cacheWrites: apiMetrics.totalCacheWrites,
-				cacheReads: apiMetrics.totalCacheReads,
-				totalCost: apiMetrics.totalCost,
-				size: taskDirSize,
-				shadowGitConfigWorkTree: await this.checkpointTracker?.getShadowGitConfigWorkTree(),
-				cwdOnTaskInitialization: cwd,
-				conversationHistoryDeletedRange: this.taskState.conversationHistoryDeletedRange,
-				isFavorited: this.taskIsFavorited,
-				checkpointManagerErrorMessage: this.taskState.checkpointManagerErrorMessage,
-				modelId: lastModelInfo?.modelInfo?.modelId,
-			})
-		} catch (error) {
-			Logger.error("Failed to save cline messages:", error)
-		}
-	}
-
 	/**
 	 * Save cline messages and update task history (public API with mutex protection)
 	 * This is the main entry point for saving message state from external callers
 	 */
-	async saveClineMessagesAndUpdateHistory(): Promise<void> {
-		return await this.withStateLock(async () => {
-			await this.saveClineMessagesAndUpdateHistoryInternal()
-		})
-	}
+	async saveClineMessagesAndUpdateHistory(): Promise<void> {}
 
 	async addToApiConversationHistory(message: ClineStorageMessage) {
 		// Protect with mutex to prevent concurrent modifications from corrupting data (RC-4)
 		return await this.withStateLock(async () => {
 			this.apiConversationHistory.push(message)
-			await saveApiConversationHistory(this.taskId, this.apiConversationHistory)
 		})
 	}
 
@@ -187,7 +112,6 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 		// Protect with mutex to prevent concurrent modifications from corrupting data (RC-4)
 		return await this.withStateLock(async () => {
 			this.apiConversationHistory = newHistory
-			await saveApiConversationHistory(this.taskId, this.apiConversationHistory)
 		})
 	}
 
@@ -211,7 +135,6 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 				index,
 				message,
 			})
-			await this.saveClineMessagesAndUpdateHistoryInternal()
 		})
 	}
 
@@ -228,7 +151,6 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 				messages: this.clineMessages,
 				previousMessages,
 			})
-			await this.saveClineMessagesAndUpdateHistoryInternal()
 		})
 	}
 
@@ -257,7 +179,6 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 			})
 
 			// Save changes and update history
-			await this.saveClineMessagesAndUpdateHistoryInternal()
 		})
 	}
 
@@ -285,7 +206,6 @@ export class MessageStateHandler extends EventEmitter<MessageStateHandlerEvents>
 			})
 
 			// Save changes and update history
-			await this.saveClineMessagesAndUpdateHistoryInternal()
 		})
 	}
 }

src/core/task/presentation-types.ts

@@ -1,9 +0,0 @@
-/**
- * Priority level for a presentation flush request.
- *
- * - `"immediate"` — flush synchronously (delay = 0 ms). Used at semantic
- *   boundaries: first visible token, tool-call transitions, and finalization.
- * - `"normal"` — flush after the configured cadence delay, coalescing
- *   intermediate chunks to reduce message-passing overhead.
- */
-export type PresentationPriority = "immediate" | "normal"

src/core/task/tools/ToolExecutorCoordinator.ts

@@ -1,169 +0,0 @@
-import type { ToolUse } from "@core/assistant-message"
-import { CLINE_MCP_TOOL_IDENTIFIER } from "@/shared/mcp"
-import { ClineDefaultTool } from "@/shared/tools"
-import type { ToolResponse } from "../index"
-import { AccessMcpResourceHandler } from "./handlers/AccessMcpResourceHandler"
-import { ActModeRespondHandler } from "./handlers/ActModeRespondHandler"
-import { ApplyPatchHandler } from "./handlers/ApplyPatchHandler"
-import { AskFollowupQuestionToolHandler } from "./handlers/AskFollowupQuestionToolHandler"
-import { AttemptCompletionHandler } from "./handlers/AttemptCompletionHandler"
-import { BrowserToolHandler } from "./handlers/BrowserToolHandler"
-import { CondenseHandler } from "./handlers/CondenseHandler"
-import { ExecuteCommandToolHandler } from "./handlers/ExecuteCommandToolHandler"
-import { GenerateExplanationToolHandler } from "./handlers/GenerateExplanationToolHandler"
-import { ListCodeDefinitionNamesToolHandler } from "./handlers/ListCodeDefinitionNamesToolHandler"
-import { ListFilesToolHandler } from "./handlers/ListFilesToolHandler"
-import { LoadMcpDocumentationHandler } from "./handlers/LoadMcpDocumentationHandler"
-import { NewTaskHandler } from "./handlers/NewTaskHandler"
-import { PlanModeRespondHandler } from "./handlers/PlanModeRespondHandler"
-import { ReadFileToolHandler } from "./handlers/ReadFileToolHandler"
-import { ReportBugHandler } from "./handlers/ReportBugHandler"
-import { SearchFilesToolHandler } from "./handlers/SearchFilesToolHandler"
-import { UseSubagentsToolHandler } from "./handlers/SubagentToolHandler"
-import { SummarizeTaskHandler } from "./handlers/SummarizeTaskHandler"
-import { UseMcpToolHandler } from "./handlers/UseMcpToolHandler"
-import { UseSkillToolHandler } from "./handlers/UseSkillToolHandler"
-import { WebFetchToolHandler } from "./handlers/WebFetchToolHandler"
-import { WebSearchToolHandler } from "./handlers/WebSearchToolHandler"
-import { WriteToFileToolHandler } from "./handlers/WriteToFileToolHandler"
-import { AgentConfigLoader } from "./subagent/AgentConfigLoader"
-import { ToolValidator } from "./ToolValidator"
-import type { TaskConfig } from "./types/TaskConfig"
-import type { StronglyTypedUIHelpers } from "./types/UIHelpers"
-
-export interface IToolHandler {
-	readonly name: ClineDefaultTool
-	execute(config: TaskConfig, block: ToolUse): Promise<ToolResponse>
-	getDescription(block: ToolUse): string
-}
-
-export interface IPartialBlockHandler {
-	handlePartialBlock(block: ToolUse, uiHelpers: StronglyTypedUIHelpers): Promise<void>
-}
-
-export interface IFullyManagedTool extends IToolHandler, IPartialBlockHandler {
-	// Marker interface for tools that handle their own complete approval flow
-}
-
-/**
- * A wrapper class that allows a single tool handler to be registered under multiple names.
- * This provides proper typing for tools that share the same implementation logic.
- */
-export class SharedToolHandler implements IFullyManagedTool {
-	constructor(
-		public readonly name: ClineDefaultTool,
-		private baseHandler: IFullyManagedTool,
-	) {}
-
-	getDescription(block: ToolUse): string {
-		return this.baseHandler.getDescription(block)
-	}
-
-	async execute(config: TaskConfig, block: ToolUse): Promise<ToolResponse> {
-		return this.baseHandler.execute(config, block)
-	}
-
-	async handlePartialBlock(block: ToolUse, uiHelpers: StronglyTypedUIHelpers): Promise<void> {
-		return this.baseHandler.handlePartialBlock(block, uiHelpers)
-	}
-}
-
-/**
- * Coordinates tool execution by routing to registered handlers.
- * Falls back to legacy switch for unregistered tools.
- */
-export class ToolExecutorCoordinator {
-	private handlers = new Map<string, IToolHandler>()
-	private dynamicSubagentHandlers = new Map<string, IToolHandler>()
-
-	private readonly toolHandlersMap: Record<ClineDefaultTool, (v: ToolValidator) => IToolHandler | undefined> = {
-		[ClineDefaultTool.ASK]: (_v: ToolValidator) => new AskFollowupQuestionToolHandler(),
-		[ClineDefaultTool.ATTEMPT]: (_v: ToolValidator) => new AttemptCompletionHandler(),
-		[ClineDefaultTool.BASH]: (v: ToolValidator) => new ExecuteCommandToolHandler(v),
-		[ClineDefaultTool.FILE_EDIT]: (v: ToolValidator) =>
-			new SharedToolHandler(ClineDefaultTool.FILE_EDIT, new WriteToFileToolHandler(v)),
-		[ClineDefaultTool.FILE_READ]: (v: ToolValidator) => new ReadFileToolHandler(v),
-		[ClineDefaultTool.FILE_NEW]: (v: ToolValidator) => new WriteToFileToolHandler(v),
-		[ClineDefaultTool.SEARCH]: (v: ToolValidator) => new SearchFilesToolHandler(v),
-		[ClineDefaultTool.LIST_FILES]: (v: ToolValidator) => new ListFilesToolHandler(v),
-		[ClineDefaultTool.LIST_CODE_DEF]: (v: ToolValidator) => new ListCodeDefinitionNamesToolHandler(v),
-		[ClineDefaultTool.BROWSER]: (_v: ToolValidator) => new BrowserToolHandler(),
-		[ClineDefaultTool.MCP_USE]: (_v: ToolValidator) => new UseMcpToolHandler(),
-		[ClineDefaultTool.MCP_ACCESS]: (_v: ToolValidator) => new AccessMcpResourceHandler(),
-		[ClineDefaultTool.MCP_DOCS]: (_v: ToolValidator) => new LoadMcpDocumentationHandler(),
-		[ClineDefaultTool.NEW_TASK]: (_v: ToolValidator) => new NewTaskHandler(),
-		[ClineDefaultTool.PLAN_MODE]: (_v: ToolValidator) => new PlanModeRespondHandler(),
-		[ClineDefaultTool.ACT_MODE]: (_v: ToolValidator) => new ActModeRespondHandler(),
-		[ClineDefaultTool.TODO]: (_v: ToolValidator) => undefined,
-		[ClineDefaultTool.WEB_FETCH]: (_v: ToolValidator) => new WebFetchToolHandler(),
-		[ClineDefaultTool.WEB_SEARCH]: (_v: ToolValidator) => new WebSearchToolHandler(),
-		[ClineDefaultTool.CONDENSE]: (_v: ToolValidator) => new CondenseHandler(),
-		[ClineDefaultTool.SUMMARIZE_TASK]: (_v: ToolValidator) => new SummarizeTaskHandler(_v),
-		[ClineDefaultTool.REPORT_BUG]: (_v: ToolValidator) => new ReportBugHandler(),
-		[ClineDefaultTool.NEW_RULE]: (v: ToolValidator) =>
-			new SharedToolHandler(ClineDefaultTool.NEW_RULE, new WriteToFileToolHandler(v)),
-		[ClineDefaultTool.APPLY_PATCH]: (_v: ToolValidator) => new ApplyPatchHandler(_v),
-		[ClineDefaultTool.GENERATE_EXPLANATION]: (_v: ToolValidator) => new GenerateExplanationToolHandler(),
-		[ClineDefaultTool.USE_SKILL]: (_v: ToolValidator) => new UseSkillToolHandler(),
-		[ClineDefaultTool.USE_SUBAGENTS]: (_v: ToolValidator) => new UseSubagentsToolHandler(),
-	}
-
-	/**
-	 * Register a tool handler
-	 */
-	register(handler: IToolHandler): void {
-		this.handlers.set(handler.name, handler)
-	}
-
-	registerByName(toolName: ClineDefaultTool, validator: ToolValidator): void {
-		const handler = this.toolHandlersMap[toolName]?.(validator)
-		if (handler) {
-			this.register(handler)
-		}
-	}
-
-	/**
-	 * Check if a handler is registered for the given tool
-	 */
-	has(toolName: string): boolean {
-		return this.getHandler(toolName) !== undefined
-	}
-
-	/**
-	 * Get a handler for the given tool name
-	 */
-	getHandler(toolName: string): IToolHandler | undefined {
-		// HACK: Normalize MCP tool names to the standard handler
-		if (toolName.includes(CLINE_MCP_TOOL_IDENTIFIER)) {
-			toolName = ClineDefaultTool.MCP_USE
-		}
-
-		const staticHandler = this.handlers.get(toolName)
-		if (staticHandler) {
-			return staticHandler
-		}
-
-		if (AgentConfigLoader.getInstance().isDynamicSubagentTool(toolName)) {
-			const existingHandler = this.dynamicSubagentHandlers.get(toolName)
-			if (existingHandler) {
-				return existingHandler
-			}
-			const handler = new SharedToolHandler(toolName as ClineDefaultTool, new UseSubagentsToolHandler())
-			this.dynamicSubagentHandlers.set(toolName, handler)
-			return handler
-		}
-
-		return undefined
-	}
-
-	/**
-	 * Execute a tool through its registered handler
-	 */
-	async execute(config: TaskConfig, block: ToolUse): Promise<ToolResponse> {
-		const handler = this.getHandler(block.name)
-		if (!handler) {
-			throw new Error(`No handler registered for tool: ${block.name}`)
-		}
-		return handler.execute(config, block)
-	}
-}

src/core/task/tools/ToolValidator.ts

@@ -1,42 +0,0 @@
-import type { ToolParamName, ToolUse } from "@core/assistant-message"
-import type { ClineIgnoreController } from "@core/ignore/ClineIgnoreController"
-
-export type ValidationResult = { ok: true } | { ok: false; error: string }
-
-/**
- * Lightweight validator used by new tool handlers.
- * The legacy ToolExecutor switch remains unchanged and does not depend on this.
- */
-export class ToolValidator {
-	constructor(private readonly clineIgnoreController: ClineIgnoreController) {}
-
-	/**
-	 * Verifies required parameters exist on the tool block.
-	 * Returns a message suitable for displaying in an error.
-	 */
-	assertRequiredParams(block: ToolUse, ...params: ToolParamName[]): ValidationResult {
-		for (const p of params) {
-			// params are stored under block.params using their tag name
-			const val = (block as any)?.params?.[p]
-			if (val === undefined || val === null || String(val).trim() === "") {
-				return { ok: false, error: `Missing required parameter '${p}' for tool '${block.name}'.` }
-			}
-		}
-		return { ok: true }
-	}
-
-	/**
-	 * Verifies access is allowed to a given path via .clineignore rules.
-	 * Callers should pass a repo-relative (workspace-relative) path.
-	 */
-	checkClineIgnorePath(relPath: string): ValidationResult {
-		const accessAllowed = this.clineIgnoreController.validateAccess(relPath)
-		if (!accessAllowed) {
-			return {
-				ok: false,
-				error: `Access to path '${relPath}' is blocked by .clineignore settings.`,
-			}
-		}
-		return { ok: true }
-	}
-}

src/core/task/tools/autoApprove.ts

@@ -1,168 +0,0 @@
-import { resolveWorkspacePath } from "@core/workspace"
-import { isMultiRootEnabled } from "@core/workspace/multi-root-utils"
-import { ClineDefaultTool } from "@shared/tools"
-import { StateManager } from "@/core/storage/StateManager"
-import { HostProvider } from "@/hosts/host-provider"
-import { getCwd, getDesktopDir, isLocatedInPath, isLocatedInWorkspace } from "@/utils/path"
-
-export class AutoApprove {
-	private stateManager: StateManager
-	// Cache for workspace paths - populated on first access and reused for the task lifetime
-	// NOTE: This assumes that the task has a fixed set of workspace roots(which is currently true).
-	private workspacePathsCache: { paths: string[] } | null = null
-	private isMultiRootScenarioCache: boolean | null = null
-
-	constructor(stateManager: StateManager) {
-		this.stateManager = stateManager
-	}
-
-	/**
-	 * Get workspace information with caching to avoid repeated API calls
-	 * Cache is task-scoped since each task gets a new AutoApprove instance
-	 */
-	private async getWorkspaceInfo(): Promise<{
-		workspacePaths: { paths: string[] }
-		isMultiRootScenario: boolean
-	}> {
-		// Check if we already have cached values
-		if (this.workspacePathsCache === null || this.isMultiRootScenarioCache === null) {
-			// First time - fetch and cache for the lifetime of this task
-			this.workspacePathsCache = await HostProvider.workspace.getWorkspacePaths({})
-			this.isMultiRootScenarioCache = isMultiRootEnabled(this.stateManager) && this.workspacePathsCache.paths.length > 1
-		}
-
-		return {
-			workspacePaths: this.workspacePathsCache,
-			isMultiRootScenario: this.isMultiRootScenarioCache,
-		}
-	}
-
-	// Check if the tool should be auto-approved based on the settings
-	// Returns bool for most tools, and tuple for tools with nested settings
-	shouldAutoApproveTool(toolName: ClineDefaultTool): boolean | [boolean, boolean] {
-		if (this.stateManager.getGlobalSettingsKey("yoloModeToggled")) {
-			switch (toolName) {
-				case ClineDefaultTool.FILE_READ:
-				case ClineDefaultTool.LIST_FILES:
-				case ClineDefaultTool.LIST_CODE_DEF:
-				case ClineDefaultTool.SEARCH:
-				case ClineDefaultTool.NEW_RULE:
-				case ClineDefaultTool.FILE_NEW:
-				case ClineDefaultTool.FILE_EDIT:
-				case ClineDefaultTool.APPLY_PATCH:
-				case ClineDefaultTool.BASH:
-				case ClineDefaultTool.USE_SUBAGENTS:
-					return [true, true]
-
-				case ClineDefaultTool.BROWSER:
-				case ClineDefaultTool.WEB_FETCH:
-				case ClineDefaultTool.WEB_SEARCH:
-				case ClineDefaultTool.MCP_ACCESS:
-				case ClineDefaultTool.MCP_USE:
-					return true
-			}
-		}
-
-		if (this.stateManager.getGlobalSettingsKey("autoApproveAllToggled")) {
-			switch (toolName) {
-				case ClineDefaultTool.FILE_READ:
-				case ClineDefaultTool.LIST_FILES:
-				case ClineDefaultTool.LIST_CODE_DEF:
-				case ClineDefaultTool.SEARCH:
-				case ClineDefaultTool.NEW_RULE:
-				case ClineDefaultTool.FILE_NEW:
-				case ClineDefaultTool.FILE_EDIT:
-				case ClineDefaultTool.APPLY_PATCH:
-				case ClineDefaultTool.BASH:
-				case ClineDefaultTool.USE_SUBAGENTS:
-					return [true, true]
-				case ClineDefaultTool.BROWSER:
-				case ClineDefaultTool.WEB_FETCH:
-				case ClineDefaultTool.WEB_SEARCH:
-				case ClineDefaultTool.MCP_ACCESS:
-				case ClineDefaultTool.MCP_USE:
-					return true
-			}
-		}
-
-		const autoApprovalSettings = this.stateManager.getGlobalSettingsKey("autoApprovalSettings")
-
-		switch (toolName) {
-			case ClineDefaultTool.FILE_READ:
-			case ClineDefaultTool.LIST_FILES:
-			case ClineDefaultTool.LIST_CODE_DEF:
-			case ClineDefaultTool.SEARCH:
-			case ClineDefaultTool.USE_SUBAGENTS:
-				return [autoApprovalSettings.actions.readFiles, autoApprovalSettings.actions.readFilesExternally ?? false]
-			case ClineDefaultTool.NEW_RULE:
-			case ClineDefaultTool.FILE_NEW:
-			case ClineDefaultTool.FILE_EDIT:
-			case ClineDefaultTool.APPLY_PATCH:
-				return [autoApprovalSettings.actions.editFiles, autoApprovalSettings.actions.editFilesExternally ?? false]
-			case ClineDefaultTool.BASH:
-				return [
-					autoApprovalSettings.actions.executeSafeCommands ?? false,
-					autoApprovalSettings.actions.executeAllCommands ?? false,
-				]
-			case ClineDefaultTool.BROWSER:
-				return autoApprovalSettings.actions.useBrowser
-			case ClineDefaultTool.WEB_FETCH:
-			case ClineDefaultTool.WEB_SEARCH:
-				return autoApprovalSettings.actions.useBrowser
-			case ClineDefaultTool.MCP_ACCESS:
-			case ClineDefaultTool.MCP_USE:
-				return autoApprovalSettings.actions.useMcp
-		}
-		return false
-	}
-
-	// 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.
-	async shouldAutoApproveToolWithPath(
-		blockname: ClineDefaultTool,
-		autoApproveActionpath: string | undefined,
-	): Promise<boolean> {
-		if (this.stateManager.getGlobalSettingsKey("yoloModeToggled")) {
-			return true
-		}
-		if (this.stateManager.getGlobalSettingsKey("autoApproveAllToggled")) {
-			return true
-		}
-
-		let isLocalRead = false
-		if (autoApproveActionpath) {
-			// Use cached workspace info instead of fetching every time
-			const { isMultiRootScenario } = await this.getWorkspaceInfo()
-
-			if (isMultiRootScenario) {
-				// Multi-root: check if file is in ANY workspace
-				isLocalRead = await isLocatedInWorkspace(autoApproveActionpath)
-			} else {
-				// Single-root: use existing logic
-				const cwd = await getCwd(getDesktopDir())
-				// When called with a string cwd, resolveWorkspacePath returns a string
-				const absolutePath = resolveWorkspacePath(
-					cwd,
-					autoApproveActionpath,
-					"AutoApprove.shouldAutoApproveToolWithPath",
-				) as string
-				isLocalRead = isLocatedInPath(cwd, absolutePath)
-			}
-		} else {
-			// If we do not get a path for some reason, default to a (safer) false return
-			isLocalRead = false
-		}
-
-		// Get auto-approve settings for local and external edits
-		const autoApproveResult = this.shouldAutoApproveTool(blockname)
-		const [autoApproveLocal, autoApproveExternal] = Array.isArray(autoApproveResult)
-			? autoApproveResult
-			: [autoApproveResult, false]
-
-		if ((isLocalRead && autoApproveLocal) || (!isLocalRead && autoApproveLocal && autoApproveExternal)) {
-			return true
-		}
-		return false
-	}
-}

src/core/task/tools/handlers/AccessMcpResourceHandler.ts

@@ -1,168 +0,0 @@
-import type { ToolUse } from "@core/assistant-message"
-import { formatResponse } from "@core/prompts/responses"
-import { ClineAsk, ClineAskUseMcpServer } from "@shared/ExtensionMessage"
-import { telemetryService } from "@/services/telemetry"
-import { truncateContent } from "@/shared/content-limits"
-import { ClineDefaultTool } from "@/shared/tools"
-import type { ToolResponse } from "../../index"
-import { showNotificationForApproval } from "../../utils"
-import type { IFullyManagedTool } from "../ToolExecutorCoordinator"
-import type { TaskConfig } from "../types/TaskConfig"
-import type { StronglyTypedUIHelpers } from "../types/UIHelpers"
-import { ToolResultUtils } from "../utils/ToolResultUtils"
-
-export class AccessMcpResourceHandler implements IFullyManagedTool {
-	readonly name = ClineDefaultTool.MCP_ACCESS
-
-	getDescription(block: ToolUse): string {
-		return `[${block.name} for '${block.params.server_name}']`
-	}
-
-	async handlePartialBlock(block: ToolUse, uiHelpers: StronglyTypedUIHelpers): Promise<void> {
-		const server_name = block.params.server_name
-		const uri = block.params.uri
-
-		const partialMessage = JSON.stringify({
-			type: this.name,
-			serverName: uiHelpers.removeClosingTag(block, "server_name", server_name),
-			toolName: undefined,
-			uri: uiHelpers.removeClosingTag(block, "uri", uri),
-			arguments: undefined,
-		} satisfies ClineAskUseMcpServer)
-
-		// Check if tool should be auto-approved (access_mcp_resource uses general auto-approval)
-		const shouldAutoApprove = uiHelpers.shouldAutoApproveTool(block.name)
-
-		if (shouldAutoApprove) {
-			await uiHelpers.removeLastPartialMessageIfExistsWithType("ask", "use_mcp_server")
-			await uiHelpers.say("use_mcp_server" as any, partialMessage, undefined, undefined, block.partial)
-		} else {
-			await uiHelpers.removeLastPartialMessageIfExistsWithType("say", "use_mcp_server")
-			await uiHelpers.ask("use_mcp_server" as ClineAsk, partialMessage, block.partial).catch(() => {})
-		}
-	}
-
-	async execute(config: TaskConfig, block: ToolUse): Promise<ToolResponse> {
-		const server_name: string | undefined = block.params.server_name
-		const uri: string | undefined = block.params.uri
-
-		// Extract provider using the proven pattern from ReportBugHandler
-		const apiConfig = config.services.stateManager.getApiConfiguration()
-		const currentMode = config.services.stateManager.getGlobalSettingsKey("mode")
-		const provider = (currentMode === "plan" ? apiConfig.planModeApiProvider : apiConfig.actModeApiProvider) as string
-
-		// Validate required parameters
-		if (!server_name) {
-			config.taskState.consecutiveMistakeCount++
-			return await config.callbacks.sayAndCreateMissingParamError(ClineDefaultTool.MCP_ACCESS, "server_name")
-		}
-
-		if (!uri) {
-			config.taskState.consecutiveMistakeCount++
-			return await config.callbacks.sayAndCreateMissingParamError(ClineDefaultTool.MCP_ACCESS, "uri")
-		}
-
-		config.taskState.consecutiveMistakeCount = 0
-
-		// Handle approval flow
-		const completeMessage = JSON.stringify({
-			type: "access_mcp_resource",
-			serverName: server_name,
-			toolName: undefined,
-			uri: uri,
-			arguments: undefined,
-		} satisfies ClineAskUseMcpServer)
-
-		const shouldAutoApprove = config.callbacks.shouldAutoApproveTool(block.name)
-
-		if (shouldAutoApprove) {
-			// Auto-approval flow
-			await config.callbacks.removeLastPartialMessageIfExistsWithType("ask", "use_mcp_server")
-			await config.callbacks.say("use_mcp_server", completeMessage, undefined, undefined, false)
-
-			// Capture telemetry
-			telemetryService.captureToolUsage(
-				config.ulid,
-				block.name,
-				config.api.getModel().id,
-				provider,
-				true,
-				true,
-				undefined,
-				block.isNativeToolCall,
-			)
-		} else {
-			// Manual approval flow
-			const notificationMessage = `Cline wants to access ${uri || "unknown resource"} on ${server_name || "unknown server"}`
-
-			// Show notification
-			showNotificationForApproval(notificationMessage, config.autoApprovalSettings.enableNotifications)
-
-			await config.callbacks.removeLastPartialMessageIfExistsWithType("say", "use_mcp_server")
-
-			const didApprove = await ToolResultUtils.askApprovalAndPushFeedback("use_mcp_server", completeMessage, config)
-			if (!didApprove) {
-				telemetryService.captureToolUsage(
-					config.ulid,
-					block.name,
-					config.api.getModel().id,
-					provider,
-					false,
-					false,
-					undefined,
-					block.isNativeToolCall,
-				)
-				return formatResponse.toolDenied()
-			} else {
-				telemetryService.captureToolUsage(
-					config.ulid,
-					block.name,
-					config.api.getModel().id,
-					provider,
-					false,
-					true,
-					undefined,
-					block.isNativeToolCall,
-				)
-			}
-		}
-
-		// Run PreToolUse hook after approval but before execution
-		try {
-			const { ToolHookUtils } = await import("../utils/ToolHookUtils")
-			await ToolHookUtils.runPreToolUseIfEnabled(config, block)
-		} catch (error) {
-			const { PreToolUseHookCancellationError } = await import("@core/hooks/PreToolUseHookCancellationError")
-			if (error instanceof PreToolUseHookCancellationError) {
-				return formatResponse.toolDenied()
-			}
-			throw error
-		}
-
-		await config.callbacks.say("mcp_server_request_started")
-
-		// Execute the MCP resource access
-		const resourceResult = await config.services.mcpHub.readResource(server_name, uri)
-
-		// Process the resource result
-		const resourceResultPretty =
-			resourceResult?.contents
-				.map((item: any) => {
-					if (item.text) {
-						return item.text
-					}
-					return ""
-				})
-				.filter(Boolean)
-				.join("\n\n") || "(Empty response)"
-
-		// Display result to user
-		await config.callbacks.say("mcp_server_response", resourceResultPretty)
-
-		// Truncate response if it exceeds 400KB to prevent context overflow
-		const truncatedResult = truncateContent(resourceResultPretty)
-
-		// Return formatted result
-		return formatResponse.toolResult(truncatedResult)
-	}
-}