Simplify symbol formatting: omit () from all symbol names

Appending () is language-specific and can mislead for TypeScript,
Obj-C, etc. The kind suffix (— function, — class, etc.) already
communicates the symbol type clearly.

.agents/skills/create-pull-request/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: create-pull-request
+description: Create a GitHub pull request following project conventions. Use when the user asks to create a PR, submit changes for review, or open a pull request. Handles commit analysis, branch management, PR template usage, and PR creation using the gh CLI tool.
+---
+
+# Create Pull Request
+
+This skill guides you through creating a well-structured GitHub pull request that follows project conventions and best practices.
+
+## Prerequisites Check
+
+Before proceeding, verify the following:
+
+### 1. Check if `gh` CLI is installed
+
+```bash
+gh --version
+```
+
+If not installed, inform the user:
+> The GitHub CLI (`gh`) is required but not installed. Please install it:
+> - macOS: `brew install gh`
+> - Other: https://cli.github.com/
+
+### 2. Check if authenticated with GitHub
+
+```bash
+gh auth status
+```
+
+If not authenticated, guide the user to run `gh auth login`.
+
+### 3. Verify clean working directory
+
+```bash
+git status
+```
+
+If there are uncommitted changes, ask the user whether to:
+- Commit them as part of this PR
+- Stash them temporarily
+- Discard them (with caution)
+
+## Gather Context
+
+### 1. Identify the current branch
+
+```bash
+git branch --show-current
+```
+
+Ensure you're not on `main` or `master`. If so, ask the user to create or switch to a feature branch.
+
+### 2. Find the base branch
+
+```bash
+git remote show origin | grep "HEAD branch"
+```
+
+This is typically `main` or `master`.
+
+### 3. Analyze recent commits relevant to this PR
+
+```bash
+git log origin/main..HEAD --oneline --no-decorate
+```
+
+Review these commits to understand:
+- What changes are being introduced
+- The scope of the PR (single feature/fix or multiple changes)
+- Whether commits should be squashed or reorganized
+
+### 4. Review the diff
+
+```bash
+git diff origin/main..HEAD --stat
+```
+
+This shows which files changed and helps identify the type of change.
+
+## Information Gathering
+
+Before creating the PR, you need the following information. Check if it can be inferred from:
+- Commit messages
+- Branch name (e.g., `fix/issue-123`, `feature/new-login`)
+- Changed files and their content
+
+If any critical information is missing, use `ask_followup_question` to ask the user:
+
+### Required Information
+
+1. **Related Issue Number**: Look for patterns like `#123`, `fixes #123`, or `closes #123` in commit messages
+2. **Description**: What problem does this solve? Why were these changes made?
+3. **Type of Change**: Bug fix, new feature, breaking change, refactor, cosmetic, documentation, or workflow
+4. **Test Procedure**: How was this tested? What could break?
+
+### Example clarifying question
+
+If the issue number is not found:
+> I couldn't find a related issue number in the commit messages or branch name. What GitHub issue does this PR address? (Enter the issue number, e.g., "123" or "N/A" for small fixes)
+
+## Git Best Practices
+
+Before creating the PR, consider these best practices:
+
+### Commit Hygiene
+
+1. **Atomic commits**: Each commit should represent a single logical change
+2. **Clear commit messages**: Follow conventional commit format when possible
+3. **No merge commits**: Prefer rebasing over merging to keep history clean
+
+### Branch Management
+
+1. **Rebase on latest main** (if needed):
+   ```bash
+   git fetch origin
+   git rebase origin/main
+   ```
+
+2. **Squash if appropriate**: If there are many small "WIP" commits, consider interactive rebase:
+   ```bash
+   git rebase -i origin/main
+   ```
+   Only suggest this if commits appear messy and the user is comfortable with rebasing.
+
+### Push Changes
+
+Ensure all commits are pushed:
+```bash
+git push origin HEAD
+```
+
+If the branch was rebased, you may need:
+```bash
+git push origin HEAD --force-with-lease
+```
+
+## Create the Pull Request
+
+**IMPORTANT**: Read and use the PR template at `.github/pull_request_template.md`. The PR body format must **strictly match** the template structure. Do not deviate from the template format.
+
+When filling out the template:
+- Replace `#XXXX` with the actual issue number, or keep as `#XXXX` if no issue exists (for small fixes)
+- Fill in all sections with relevant information gathered from commits and context
+- Mark the appropriate "Type of Change" checkbox(es)
+- Complete the "Pre-flight Checklist" items that apply
+
+### Create PR with gh CLI
+
+**Use a temporary file for the PR body** to avoid shell escaping issues, newline problems, and other command-line flakiness:
+
+1. Write the PR body to a temporary file:
+   ```
+   /tmp/pr-body.md
+   ```
+
+2. Create the PR using the file:
+   ```bash
+   gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main
+   ```
+
+3. Clean up the temporary file:
+   ```bash
+   rm /tmp/pr-body.md
+   ```
+
+For draft PRs:
+```bash
+gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main --draft
+```
+
+**Why use a file?** Passing complex markdown with newlines, special characters, and checkboxes directly via `--body` is error-prone. The `--body-file` flag handles all content reliably.
+
+## Post-Creation
+
+After creating the PR:
+
+1. **Display the PR URL** so the user can review it
+2. **Remind about CI checks**: Tests and linting will run automatically
+3. **Suggest next steps**:
+   - Add reviewers if needed: `gh pr edit --add-reviewer USERNAME`
+   - Add labels if needed: `gh pr edit --add-label "bug"`
+
+## Error Handling
+
+### Common Issues
+
+1. **No commits ahead of main**: The branch has no changes to submit
+   - Ask if the user meant to work on a different branch
+
+2. **Branch not pushed**: Remote doesn't have the branch
+   - Push the branch first: `git push -u origin HEAD`
+
+3. **PR already exists**: A PR for this branch already exists
+   - Show the existing PR: `gh pr view`
+   - Ask if they want to update it instead
+
+4. **Merge conflicts**: Branch conflicts with base
+   - Guide user through resolving conflicts or rebasing
+
+## Summary Checklist
+
+Before finalizing, ensure:
+- [ ] `gh` CLI is installed and authenticated
+- [ ] Working directory is clean
+- [ ] All commits are pushed
+- [ ] Branch is up-to-date with base branch
+- [ ] Related issue number is identified, or placeholder is used
+- [ ] PR description follows the template exactly
+- [ ] Appropriate type of change is selected
+- [ ] Pre-flight checklist items are addressed

.changeset/README.md

@@ -1,8 +0,0 @@
-# Changesets
-
-Hello and welcome! This folder has been automatically generated by `@changesets/cli`, a build tool that works
-with multi-package repos, or single-package repos to help you version and publish your code. You can
-find the full documentation for it [in our repository](https://github.com/changesets/changesets)
-
-We have a quick list of common questions to get you started engaging with this project in
-[our documentation](https://github.com/changesets/changesets/blob/main/docs/common-questions.md)

.changeset/config.json

@@ -1,11 +0,0 @@
-{
-	"$schema": "https://unpkg.com/@changesets/config@3.0.5/schema.json",
-	"changelog": "@changesets/cli/changelog",
-	"commit": false,
-	"fixed": [],
-	"linked": [],
-	"access": "restricted",
-	"baseBranch": "main",
-	"updateInternalDependencies": "patch",
-	"ignore": []
-}

.changeset/cyan-bats-bow.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Pass linter diagnostics with the read_file tool

.changeset/funny-goats-fetch.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Add Kimi-K2 as the trending model in the Cline Provider

.changeset/olive-foxes-collect.md

@@ -1,5 +0,0 @@
----
-"claude-dev": minor
----
-
-Added API Key support for Bedrock integration

.changie.yaml

@@ -1,26 +0,0 @@
-changesDir: .changes
-unreleasedDir: unreleased
-headerPath: header.tpl.md
-changelogPath: CHANGELOG.md
-versionExt: md
-versionFormat: '## {{.Version}} - {{.Time.Format "2006-01-02"}}'
-kindFormat: "### {{.Kind}}"
-changeFormat: "* {{.Body}}"
-kinds:
-    - label: Added
-      auto: minor
-    - label: Changed
-      auto: major
-    - label: Deprecated
-      auto: minor
-    - label: Removed
-      auto: major
-    - label: Fixed
-      auto: patch
-    - label: Security
-      auto: patch
-newlines:
-    afterChangelogHeader: 1
-    beforeChangelogVersion: 1
-    endOfVersion: 1
-envPrefix: CHANGIE_

.claude/commands/hotfix-release.md

@@ -0,0 +1 @@
+../../.clinerules/workflows/hotfix-release.md

.claude/commands/release.md

@@ -0,0 +1 @@
+../../.clinerules/workflows/release.md

.claude/hooks/claude-code-for-web-setup.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+set -euo pipefail
+
+# Only run in Claude Code remote environments
+if [ "${CLAUDE_CODE_REMOTE:-}" != "true" ]; then
+  exit 0
+fi
+
+cd "$CLAUDE_PROJECT_DIR"
+
+echo "=== Claude Code for Web Setup ==="
+echo ""
+
+# Install latest gh CLI tool
+echo "Installing GitHub CLI..."
+GH_VERSION=$(curl -s https://api.github.com/repos/cli/cli/releases/latest | grep '"tag_name"' | cut -d'"' -f4 | sed 's/^v//')
+curl -sL "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_amd64.tar.gz" -o /tmp/gh.tar.gz
+tar -xzf /tmp/gh.tar.gz -C /tmp
+sudo mv "/tmp/gh_${GH_VERSION}_linux_amd64/bin/gh" /usr/local/bin/gh
+rm -rf /tmp/gh.tar.gz /tmp/gh_${GH_VERSION}_linux_amd64
+echo "Installed gh version: $(gh --version | head -1)"
+echo ""
+
+# Check if GITHUB_TOKEN is set and configure gh
+if [ -n "${GITHUB_TOKEN:-}" ]; then
+  echo "GITHUB_TOKEN is configured - gh CLI is ready to use"
+  echo ""
+  echo "You can use gh commands directly, for example:"
+  echo "  gh issue list --repo cline/cline --limit 5"
+  echo "  gh pr list --repo cline/cline --state open"
+  echo "  gh issue view 123 --repo cline/cline"
+  echo ""
+else
+  echo "GITHUB_TOKEN is not set - gh CLI will have limited functionality"
+  echo ""
+  echo "To enable full GitHub API access:"
+  echo "1. Create a Fine-grained Personal Access Token at https://github.com/settings/tokens?type=beta"
+  echo "2. Add it as GITHUB_TOKEN in your Claude Code environment settings"
+  echo ""
+fi
+
+# Install project dependencies
+echo "Installing dependencies..."
+npm run install:all
+
+# Generate gRPC/protobuf types (required for TypeScript)
+echo "Generating proto types..."
+npm run protos
+
+echo ""
+echo "Session setup complete!"

.claude/settings.json

@@ -0,0 +1,14 @@
+{
+	"hooks": {
+		"SessionStart": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "$CLAUDE_PROJECT_DIR/.claude/hooks/claude-code-for-web-setup.sh"
+					}
+				]
+			}
+		]
+	}
+}

.clinerules/cli.md

@@ -0,0 +1,33 @@
+# 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/cline-overview.md

@@ -716,7 +716,7 @@ The Controller class manages MCP servers through the McpHub service:
 class Controller {
   mcpHub?: McpHub
 
-  constructor(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel, webviewProvider: WebviewProvider) {
+  constructor(context: vscode.ExtensionContext, webviewProvider: WebviewProvider) {
     this.mcpHub = new McpHub(this)
   }
 

.clinerules/general.md

@@ -0,0 +1,205 @@
+This file is the secret sauce for working effectively in this codebase. It captures tribal knowledge—the nuanced, non-obvious patterns that make the difference between a quick fix and hours of back-and-forth & human intervention.
+
+**When to add to this file:**
+- User had to intervene, correct, or hand-hold
+- Multiple back-and-forth attempts were needed to get something working
+- You discovered something that required reading many files to understand
+- A change touched files you wouldn't have guessed
+- Something worked differently than you expected
+- User explicitly asks to "add this to CLAUDE.md"
+
+**Proactively suggest additions** when any of the above happen—don't wait to be asked.
+
+**What NOT to add:** Stuff you can figure out from reading a few files, obvious patterns, or standard practices. This file should be high-signal, not comprehensive.
+
+## Miscellaneous
+- This is a VS Code extension—check `package.json` for available scripts before trying to verify builds (e.g., `npm run compile`, not `npm run build`).
+- When creating PRs, contributors should not create changelog-entry files. Maintainers handle release versioning and changelog curation during the release process.
+- 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
+
+## gRPC/Protobuf Communication
+The extension and webview communicate via gRPC-like protocol over VS Code message passing.
+
+**Proto files live in `proto/`** (e.g., `proto/cline/task.proto`, `proto/cline/ui.proto`)
+- Each feature domain has its own `.proto` file
+- For simple data, use shared types in `proto/cline/common.proto` (`StringRequest`, `Empty`, `Int64Request`)
+- For complex data, define custom messages in the feature's `.proto` file
+- Naming: Services `PascalCaseService`, RPCs `camelCase`, Messages `PascalCase`
+- For streaming responses, use `stream` keyword (see `subscribeToAuthCallback` in `account.proto`)
+
+**Run `npm run protos`** after any proto changes—generates types in:
+- `src/shared/proto/` - Shared type definitions
+- `src/generated/grpc-js/` - Service implementations
+- `src/generated/nice-grpc/` - Promise-based clients
+- `src/generated/hosts/` - Generated handlers
+
+**Adding new enum values** (like a new `ClineSay` type) requires updating conversion mappings in `src/shared/proto-conversions/cline-message.ts`
+
+**Adding new RPC methods** requires:
+- Handler in `src/core/controller/<domain>/`
+- Call from webview via generated client: `UiServiceClient.scrollToSettings(StringRequest.create({ value: "browser" }))`
+
+**Example—the `explain-changes` feature touched:**
+- `proto/cline/task.proto` - Added `ExplainChangesRequest` message and `explainChanges` RPC
+- `proto/cline/ui.proto` - Added `GENERATE_EXPLANATION = 29` to `ClineSay` enum
+- `src/shared/ExtensionMessage.ts` - Added `ClineSayGenerateExplanation` type
+- `src/shared/proto-conversions/cline-message.ts` - Added mapping for new say type
+- `src/core/controller/task/explainChanges.ts` - Handler implementation
+- `webview-ui/src/components/chat/ChatRow.tsx` - UI rendering
+
+## Adding 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.
+
+Required steps:
+1. Type definition in `src/shared/storage/state-keys.ts` - Add to `GlobalState` or `Settings` interface
+2. Read from globalState in `src/core/storage/utils/state-helpers.ts`:
+   - Add `const myKey = context.globalState.get<GlobalStateAndSettings["myKey"]>("myKey")` in `readGlobalStateFromDisk()`
+   - Add to the return object: `myKey: myKey ?? defaultValue,`
+3. StateManager handles read/write via `setGlobalState()`/`getGlobalStateKey()` after initialization
+
+Common mistake: Adding only the return value without the `context.globalState.get()` call. This compiles but the value is always `undefined` on load.
+
+Settings plumbing gotcha: if a key is user-toggleable from settings, wire both controller update paths:
+- `src/core/controller/state/updateSettings.ts` for webview `updateSetting(...)`
+- `src/core/controller/state/updateSettingsCli.ts` for CLI/ACP settings updates
+Missing one path causes a toggle to appear to change in one surface while the backend state stays unchanged.
+
+Webview toggle gotcha: settings changes must also round-trip back in state payloads.
+- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `npm run protos`
+- Include the key in `Controller.getStateToPostToWebview()` (`src/core/controller/index.ts`)
+- Ensure `ExtensionState` and webview defaults include the key (`src/shared/ExtensionMessage.ts`, `webview-ui/src/context/ExtensionStateContext.tsx`)
+If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
+
+## StateManager Cache vs Direct globalState Access
+StateManager uses an in-memory cache populated during `StateManager.initialize(context)` in `common.ts`. For most state, use `controller.stateManager.setGlobalState()`/`getGlobalStateKey()`.
+
+Exception: State needed immediately at extension startup (before cache is ready)
+
+When Window A sets state and immediately opens Window B, the new window's StateManager cache is populated from `context.globalState` during initialization. If you need to read state in Window B right at startup (e.g., in `common.ts` during `initialize()`), read directly from `context.globalState.get()` instead of StateManager's cache.
+
+Example pattern (see `lastShownAnnouncementId` and `worktreeAutoOpenPath`):
+```typescript
+// Writing (normal pattern)
+controller.stateManager.setGlobalState("myKey", value)
+
+// Reading at startup in common.ts (bypass cache)
+const value = context.globalState.get<string>("myKey")
+```
+
+This is only needed for cross-window state read during the brief startup window before StateManager cache is fully usable. Normal state access after initialization should use StateManager.
+
+## ChatRow Cancelled/Interrupted States
+When a ChatRow displays a loading/in-progress state (spinner), you must handle what happens when the task is cancelled. This is non-obvious because cancellation doesn't update the message content—you have to infer it from context.
+
+**The pattern:**
+1. A message has a `status` field (e.g., `"generating"`, `"complete"`, `"error"`) stored in `message.text` as JSON
+2. When cancelled mid-operation, the status stays `"generating"` forever—no one updates it
+3. To detect cancellation, check TWO conditions:
+   - `!isLast` — if this message is no longer the last message, something else happened after it (interrupted)
+   - `lastModifiedMessage?.ask === "resume_task" || "resume_completed_task"` — task was just cancelled and is waiting to resume
+
+**Example from `generate_explanation`:**
+```tsx
+const wasCancelled =
+    explanationInfo.status === "generating" &&
+    (!isLast ||
+        lastModifiedMessage?.ask === "resume_task" ||
+        lastModifiedMessage?.ask === "resume_completed_task")
+const isGenerating = explanationInfo.status === "generating" && !wasCancelled
+```
+
+**Why both checks?**
+- `!isLast` catches: cancelled → resumed → did other stuff → this old message is stale
+- `lastModifiedMessage?.ask === "resume_task"` catches: just cancelled, hasn't resumed yet, this message is still technically "last"
+
+**See also:** `BrowserSessionRow.tsx` uses similar pattern with `isLastApiReqInterrupted` and `isLastMessageResume`.
+
+**Backend side:** When streaming is cancelled, clean up properly (close tabs, clear comments, etc.) by checking `taskState.abort` after the streaming function returns.

.clinerules/hooks/README.md

@@ -0,0 +1,423 @@
+# Cline Hooks Documentation
+
+## Overview
+
+Cline hooks allow you to execute custom scripts at specific points in the agentic workflow. Hooks can be placed in either:
+- **Global hooks directory**: `~/Documents/Cline/Hooks/` (applies to all workspaces)
+- **Workspace hooks directory**: `.clinerules/hooks/` (applies to the workspace the repo is part of)
+
+Hooks run automatically when enabled.
+
+## Enabling Hooks
+
+1. Open Cline settings in VSCode
+2. Navigate to the Feature Settings section
+3. Check the "Enable Hooks" checkbox
+4. Hooks must be executable files (on Unix/Linux/macOS use `chmod +x hookname`)
+
+## Available Hooks
+
+### TaskStart Hook
+- **When**: Runs when a NEW task is started (not when resuming)
+- **Purpose**: Initialize task context, validate task requirements, set up environment
+- **Global Location**: `~/Documents/Cline/Hooks/TaskStart`
+- **Workspace Location**: `.clinerules/hooks/TaskStart`
+
+### TaskResume Hook
+- **When**: Runs when an EXISTING task is resumed (after user clicks resume button)
+- **Purpose**: Validate resumed task state, restore context, check for changes since last run
+- **Global Location**: `~/Documents/Cline/Hooks/TaskResume`
+- **Workspace Location**: `.clinerules/hooks/TaskResume`
+
+### TaskCancel Hook
+- **When**: Runs when a task is cancelled or a hook is aborted by the user (only if there's actual active work or work was started)
+- **Purpose**: Clean up resources, log cancellation, save state
+- **Global Location**: `~/Documents/Cline/Hooks/TaskCancel`
+- **Workspace Location**: `.clinerules/hooks/TaskCancel`
+- **Note**: This hook is NOT cancellable
+
+### TaskComplete Hook (coming soon!)
+- **When**: Runs when a task is marked as complete
+- **Purpose**: Log completion status, perform final cleanup, generate reports
+- **Global Location**: `~/Documents/Cline/Hooks/TaskComplete`
+- **Workspace Location**: `.clinerules/hooks/TaskComplete`
+
+### UserPromptSubmit Hook
+- **When**: Runs when the user submits a prompt/message (initial task, resume, or feedback)
+- **Purpose**: Validate user input, preprocess prompts, add context to user messages
+- **Global Location**: `~/Documents/Cline/Hooks/UserPromptSubmit`
+- **Workspace Location**: `.clinerules/hooks/UserPromptSubmit`
+
+### PreToolUse Hook
+- **When**: Runs BEFORE a tool is executed
+- **Purpose**: Validate parameters, block execution, or add context
+- **Global Location**: `~/Documents/Cline/Hooks/PreToolUse`
+- **Workspace Location**: `.clinerules/hooks/PreToolUse`
+
+### PostToolUse Hook
+- **When**: Runs AFTER a tool completes
+- **Purpose**: Observe results, track patterns, or add context
+- **Global Location**: `~/Documents/Cline/Hooks/PostToolUse`
+- **Workspace Location**: `.clinerules/hooks/PostToolUse`
+
+### PreCompact Hook (coming soon!)
+- **When**: Runs BEFORE the conversation context is compacted/truncated
+- **Purpose**: Observe compaction events, log context management, track token usage
+- **Global Location**: `~/Documents/Cline/Hooks/PreCompact`
+- **Workspace Location**: `.clinerules/hooks/PreCompact`
+
+## Cross-Platform Hook Format
+
+Cline uses a git-style approach for hooks that works consistently across all platforms:
+
+### Hook Files (All Platforms)
+- **No file extensions**: Hooks are named exactly `PreToolUse` or `PostToolUse` (no `.bat`, `.cmd`, `.sh` etc.)
+- **Shebang required**: First line must be a shebang (e.g., `#!/usr/bin/env bash` or `#!/usr/bin/env node`)
+- **Executable on Unix**: On Unix/Linux/macOS, hooks must be executable: `chmod +x PreToolUse`
+- **Windows**: Not currently supported.
+
+### How It Works
+
+Like git hooks, Cline executes hook files through a shell that interprets the shebang line:
+- On Unix/Linux/macOS: Native shell execution with shebang support
+
+This means:
+- ✅ Same hook script works on all platforms
+- ✅ Write once, run anywhere
+- ✅ Use any scripting language (bash, node, python, etc.)
+
+### Creating Hooks
+
+**On Unix/Linux/macOS:**
+```bash
+# Create hook file
+nano ~/Documents/Cline/Hooks/PreToolUse
+
+# Make executable
+chmod +x ~/Documents/Cline/Hooks/PreToolUse
+```
+
+## Context Injection Timing
+
+**IMPORTANT**: Context injected by hooks affects **FUTURE AI decisions**, not the current tool execution.
+
+### Why This Matters
+
+When a hook runs:
+1. The AI has already decided what tool to use and with what parameters
+2. The hook cannot modify those parameters
+3. Context from the hook is added to the conversation
+4. The AI sees this context in the **NEXT API request** and can adjust future decisions
+
+### PreToolUse Hook Flow
+```
+1. AI decides: "I'll use write_to_file with these parameters"
+2. PreToolUse hook runs → can block or add context
+3. If allowed, tool executes with original parameters
+4. Context is added to conversation
+5. Next API request includes this context
+6. AI adjusts future decisions based on context
+```
+
+### PostToolUse Hook Flow
+```
+1. Tool completes execution
+2. PostToolUse hook runs → observes results
+3. Hook adds context about the outcome
+4. Context is added to conversation
+5. Next API request includes this context
+6. AI can learn from the results
+```
+
+## Hook Input/Output
+
+### Input (via stdin as JSON)
+
+All hooks receive:
+```json
+{
+  "clineVersion": "string",
+  "hookName": "TaskStart" | "TaskResume" | "TaskCancel" | "TaskComplete" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "PreCompact",
+  "timestamp": "string",
+  "taskId": "string",
+  "workspaceRoots": ["string"],
+  "userId": "string",
+  "taskStart": {  // Only for TaskStart
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string",
+      "initialTask": "string"
+    }
+  },
+  "taskResume": {  // Only for TaskResume
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    },
+    "previousState": {
+      "lastMessageTs": "string",
+      "messageCount": "string",
+      "conversationHistoryDeleted": "string"
+    }
+  },
+  "taskCancel": {  // Only for TaskCancel
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string",
+      "completionStatus": "string"
+    }
+  },
+  "taskComplete": {  // Only for TaskComplete
+    "taskMetadata": {
+      "taskId": "string",
+      "ulid": "string"
+    }
+  },
+  "userPromptSubmit": {  // Only for UserPromptSubmit
+    "prompt": "string",
+    "attachments": ["string"]
+  },
+  "preToolUse": {  // Only for PreToolUse
+    "toolName": "string",
+    "parameters": {}
+  },
+  "postToolUse": {  // Only for PostToolUse
+    "toolName": "string",
+    "parameters": {},
+    "result": "string",
+    "success": boolean,
+    "executionTimeMs": number
+  },
+  "preCompact": {  // Only for PreCompact
+    "contextSize": number,
+    "messagesToCompact": number,
+    "compactionStrategy": "string"
+  }
+}
+```
+
+### Output (via stdout as JSON)
+
+All hooks must return:
+```json
+{
+  "cancel": boolean,                   // Required: false to continue, true to block execution
+  "contextModification": "string",     // Optional: Context for future AI decisions
+  "errorMessage": "string"             // Optional: Error details if blocking
+}
+```
+
+**Note**: The `cancel` field works as follows:
+- `false` (or omitted): Allow execution to continue
+- `true`: Block execution and show error message to user
+
+## Hook Execution Limits
+
+- **Timeout**: Hooks must complete within 30 seconds (configurable via `HOOK_EXECUTION_TIMEOUT_MS`)
+- **Context Size**: Context modifications are limited to 50KB (configurable via `MAX_CONTEXT_MODIFICATION_SIZE`)
+- **Error Handling**: Expected errors (file not found, permission denied, not a directory) are handled silently; unexpected file system errors are propagated
+
+## Common Use Cases
+
+### 1. Validation - Block Invalid Operations
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
+  cat <<EOF
+{
+  "cancel": true,
+  "errorMessage": "Cannot create .js files in TypeScript project",
+  "contextModification": "Use .ts/.tsx extensions only"
+}
+EOF
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+### 2. Context Building - Learn from Operations
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+success=$(echo "$input" | jq -r '.postToolUse.success')
+path=$(echo "$input" | jq -r '.postToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$success" == "true" ]]; then
+  cat <<EOF
+{
+  "cancel": false,
+  "contextModification": "Created '$path'. Maintain consistency with this file's patterns in future operations."
+}
+EOF
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### 3. Performance Monitoring
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+execution_time=$(echo "$input" | jq -r '.postToolUse.executionTimeMs')
+tool_name=$(echo "$input" | jq -r '.postToolUse.toolName')
+
+if [[ "$execution_time" -gt 5000 ]]; then
+  cat <<EOF
+{
+  "cancel": false,
+  "contextModification": "Tool '$tool_name' took ${execution_time}ms. Consider optimizing future similar operations."
+}
+EOF
+else
+  echo '{"cancel": false}'
+fi
+```
+
+### 4. Logging and Telemetry
+
+```bash
+#!/usr/bin/env bash
+input=$(cat)
+
+# Log to file
+echo "$input" >> ~/.cline/hook-logs/tool-usage.jsonl
+
+# Allow execution
+echo '{"cancel": false}'
+```
+
+## Global vs Workspace Hooks
+
+Cline supports two levels of hooks:
+
+### Global Hooks
+- **Location**: `~/Documents/Cline/Hooks/` (macOS/Linux)
+- **Scope**: Apply to ALL workspaces and projects
+- **Use Case**: Organization-wide policies, personal preferences, universal validations
+- **Priority**: Order not guaranteed when combined with workspace hooks
+
+### Workspace Hooks
+- **Location**: `.clinerules/hooks/` in each workspace root
+- **Scope**: Apply only to the specific workspace
+- **Use Case**: Project-specific rules, team conventions, repository requirements
+- **Priority**: Order not guaranteed when combined with global hooks
+
+### Hook Execution
+
+When multiple hooks exist (global and/or workspace):
+- All hooks for a given step are executed **concurrently** using `Promise.all`
+- **Execution order is not guaranteed** - hooks run in parallel
+- If ALL hooks allow execution (`cancel: false`), the tool proceeds
+- If ANY hook blocks (`cancel: true`), execution is blocked
+
+**Result Combination:**
+- `cancel`: If ANY hook returns `true`, execution is blocked
+- `contextModification`: All context strings are concatenated with double newlines (`\n\n`)
+- `errorMessage`: All error messages are concatenated with single newlines (`\n`)
+
+### Setting Up Global Hooks
+
+1. The global hooks directory is automatically created at:
+   - macOS/Linux: `~/Documents/Cline/Hooks/`
+
+2. Add your hook script:
+   ```bash
+   # Unix/Linux/macOS
+   nano ~/Documents/Cline/Hooks/PreToolUse
+   chmod +x ~/Documents/Cline/Hooks/PreToolUse
+   ```
+
+3. Enable hooks in Cline settings
+
+### Example: Global + Workspace Hooks
+
+**Global Hook** (applies to all projects):
+```bash
+#!/usr/bin/env bash
+# ~/Documents/Cline/Hooks/PreToolUse
+# Universal rule: Never delete package.json
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *"package.json"* ]]; then
+  echo '{"cancel": true, "errorMessage": "Global policy: Cannot modify package.json"}'
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+**Workspace Hook** (applies to specific project):
+```bash
+#!/usr/bin/env bash
+# .clinerules/hooks/PreToolUse
+# Project rule: Only TypeScript files
+input=$(cat)
+tool_name=$(echo "$input" | jq -r '.preToolUse.toolName')
+path=$(echo "$input" | jq -r '.preToolUse.parameters.path // ""')
+
+if [[ "$tool_name" == "write_to_file" && "$path" == *.js ]]; then
+  echo '{"cancel": true, "errorMessage": "Project rule: Use .ts files only"}'
+  exit 0
+fi
+
+echo '{"cancel": false}'
+```
+
+**All hooks must allow execution for the tool to proceed.** Hooks may execute concurrently.
+
+## Multi-Root Workspaces
+
+If you have multiple workspace roots, you can place hooks in each root's `.clinerules/hooks/` directory. All hooks (global and workspace) may execute concurrently. Their results will be combined:
+
+- **cancel**: If ANY hook returns `true`, execution is blocked
+- **contextModification**: All context modifications are concatenated
+- **errorMessage**: All error messages are concatenated
+
+**Note:** No execution order is guaranteed between hooks from different directories.
+
+## Troubleshooting
+
+### Hook Not Running
+- Ensure the "Enable Hooks" setting is checked
+- Verify the hook file is executable (`chmod +x hookname`)
+- Check the hook file has no syntax errors
+- Look for errors in VSCode's Output panel (Cline channel)
+
+### Hook Timing Out
+- Reduce complexity of the hook script
+- Avoid expensive operations (network calls, heavy computations)
+- Consider moving complex logic to a background process
+
+### Context Not Affecting Behavior
+- Remember: context affects FUTURE decisions, not the current tool
+- Ensure context modifications are clear and actionable
+- Check that context isn't being truncated (50KB limit)
+
+## Security Considerations
+
+- Hooks run with the same permissions as VSCode
+- Be cautious with hooks from untrusted sources
+- Review hook scripts before enabling them
+- Consider using `.gitignore` to avoid committing sensitive hook logic
+- Hooks can access all workspace files and environment variables
+
+## Best Practices
+
+1. **Keep hooks fast** - Aim for <100ms execution time
+2. **Make context actionable** - Be specific about what the AI should do
+3. **Use structured prefixes** - Help the AI categorize context
+4. **Handle errors gracefully** - Always return valid JSON
+5. **Log for debugging** - Keep logs of hook executions for troubleshooting
+6. **Test incrementally** - Start with simple hooks and add complexity
+7. **Document your hooks** - Add comments explaining the purpose and logic

.clinerules/network.md

@@ -0,0 +1,90 @@
+# 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/storage.md

@@ -0,0 +1,64 @@
+# Storage Architecture
+
+Global settings, secrets and workspace state are stored in **file-backed JSON stores** under `~/.cline/data/`. This is the shared storage layer used by VSCode, CLI, and JetBrains.
+
+## Key Abstractions
+
+### `StorageContext` (src/shared/storage/storage-context.ts)
+The entry point. Created via `createStorageContext()` and passed to `StateManager.initialize()`. Contains three `ClineFileStorage` instances:
+- `globalState` → `~/.cline/data/globalState.json`
+- `secrets` → `~/.cline/data/secrets.json` (mode 0o600)
+- `workspaceState` → `~/.cline/data/workspaces/<hash>/workspaceState.json`
+
+### `ClineFileStorage` (src/shared/storage/ClineFileStorage.ts)
+Synchronous JSON key-value store backed by a single file. Supports `get()`, `set()`, `setBatch()`, `delete()`. Writes are atomic (write-then-rename).
+
+### `StateManager` (src/core/storage/StateManager.ts)
+In-memory cache on top of `StorageContext`. All runtime reads hit the cache; writes update cache immediately and debounce-flush to disk.
+
+## ⚠️ Do NOT Use VSCode's ExtensionContext for Storage
+
+**Do not** read from or write to `context.globalState`, `context.workspaceState`, or `context.secrets` for persistent data. These are VSCode-specific and not available on CLI or JetBrains.
+
+Instead, use:
+```typescript
+// Reading state
+StateManager.get().getGlobalStateKey("myKey")
+StateManager.get().getSecretKey("mySecretKey")
+StateManager.get().getWorkspaceStateKey("myWsKey")
+
+// Writing state
+StateManager.get().setGlobalState("myKey", value)
+StateManager.get().setSecret("mySecretKey", value)
+StateManager.get().setWorkspaceState("myWsKey", value)
+```
+
+Remember that your data may be read by a different client than the one that wrote it. For example, a value written by Cline in JetBrains may be read by Cline CLI.
+
+## VSCode Migration (src/hosts/vscode/vscode-to-file-migration.ts)
+
+On VSCode startup, a migration copies data from VSCode's `ExtensionContext` storage into the file-backed stores. This runs in `src/common.ts` before `StateManager.initialize()`.
+
+- **Sentinel**: `__vscodeMigrationVersion` key in global state and workspace state — prevents re-migration.
+- **Merge strategy**: File store wins. Existing values are never overwritten.
+- **Safe downgrade**: VSCode storage is NOT cleared, so older extension versions still work.
+
+## Adding New Storage Keys
+
+1. Add to `src/shared/storage/state-keys.ts` (see existing patterns)
+2. Read/write via `StateManager` (NOT via `context.globalState`)
+3. If adding a secret, add to `SecretKeys` array in `state-keys.ts`
+
+## File Layout
+
+```
+~/.cline/
+  data/
+    globalState.json          # Global settings & state
+    secrets.json              # API keys (mode 0o600)
+    tasks/
+      taskHistory.json        # Task history (separate file)
+    workspaces/
+      <hash>/
+        workspaceState.json   # Per-workspace toggles
+```

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

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

.clinerules/workflows/extension-release.md

@@ -1,549 +0,0 @@
-The goal of this workflow is to take a changeset for a release of Cline, an autonomous coding agent extension that plugs right into your IDE, and write the updated announcement component, and the updated changelog. 
-
-
-For reference, here are some examples of how we converted previous changesets to announcement components / changelogs. 
-
-
-- 3.14
-<changeset>
-This PR was opened by the Changesets release GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or setup this action to publish automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-Releases
-claude-dev@3.14.0
-Minor Changes
-77c9863: create clinerules folder if its currently a file and creating new rule
-0ffb7dd: disabling shift hint for now & improving tooltip behavior
-79b76fd: Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile.
-eb6e481: Full support for LaTeX rendering
-df37f29: Add support for custom API request timeout. Previously, timeouts were hardcoded to 30 seconds for providers like Ollama or 15 seconds for OpenRouter and Cline. Now users can set a custom timeout value in milliseconds through the settings interface.
-e4d26be: allow cursorrules and windsurfrules
-c5de50f: Fix Handle @withRetry() SyntaxError when running extension locally issue
-61d2f42: enabled pricing calculation for gemini and vertex + more robust caching & cache tracking for gemini & vertex
-aed152b: add truncation notice when truncating manually
-2fe2405: Migrate Cline Tools Section to new docs
-19cc8bc: Add a timeout setting for the terminal connection, allowing users to adjust this if they are having timeout issues
-03d4410: Added copy button to code blocks.
-c78fe23: addressed race condition in terminal command usage
-91e222f: add checkpoints after more messages
-14230e7: add newrule slash command
-1c7d33a: Add remote config with posthog allowing for disabling new features until they're reading, making for a better developer experience.
-4196c14: add cache ui for open router and cline provider
-d97424f: showing expanded task by default
-5294e78: Refactor to not pass a message for showing the MCP View from the servers modal
-70cc437: Fix Windows path issue: Correct handling of import.meta.url to avoid leading slash in pathname
-4b697d8: Migrate the addRemoteServer to protobus
-Patch Changes
-c63d9a1: updated drag and drop text to say "drop" instead of "drag"
-459adf0: Add markdown copy to chat
-74ec823: Minor UX improvement to drag and drop ux
-b0961f4: Remove linear pull request action
-e9ce384: searchCommits protobus migration
-5802b68: createRuleFile protobus migration
-df7f9fc: Add dependsOn to more blocks in the tasks.json
-41ae732: Fix for git commit mentions in repos with no git commits
-7e78445: Adding args to allow Cursor to open workspaces (for checkpoint testing/development)
-bdfda6f: feat(bedrock): Introduce Amazon Nova Premier
-65243ad: Introduce UI library for future UI development
-4565e06: checkIsImageURL migrated to protobus
-5a8e9d8: protobus migration for openImage
-deeda6e: Lowering Gemini cache TTL time
-db0b022: Adding UI to show openrouter balance next to provider
-4650ffa: deleteRuleFile protobus migration
-d4bd755: fix cost calculation
-</changeset>
-
-<changelog>
-## [3.14.0]
-
--   Add UI to show openrouter balance next to provider
--   Add support for custom model ID in AWS Bedrock provider, enabling use of Application Inference Profile (Thanks @clicube!)
--   Add more robust caching & cache tracking for gemini & vertex providers
--   Add support for LaTeX rendering
--   Add support for custom API request timeout. Timeouts were 15-30s, but can now be configured via settings for OpenRouter/Cline & Ollama (Thanks @WingsDrafterwork!)
--   Add truncation notice when truncating manually
--   Add a timeout setting for the terminal connection, allowing users to set a time to wait for terminal startup
--   Add copy button to code blocks
--   Add copy button to markdown blocks (Thanks @weshoke!)
--   Add checkpoints to more messages
--   Add slash command to create a new rules file (/newrule)
--   Add cache ui for open router and cline provider
--   Add Amazon Nova Premier model to Bedrock (Thanks @watany!)
--   Add support for cursorrules and windsurfrules
--   Add support for batch history deletion (Thanks @danix800!)
--   Improve Drag & Drop experience
--   Create clinerules folder creating new rule if it's needed
--   Enable pricing calculation for gemini and vertex providers
--   Refactor message handling to not show the MCP View of the server modal
--   Migrate the addRemoteServer to protobus (Thanks @DaveFres!)
--   Update task header to be expanded by default
--   Update Gemini cache TTL time to 15 minutes
--   Fix race condition in terminal command usage
--   Fix to correctly handle `import.meta.url`, avoiding leading slash in pathname for Windows (Thanks @DaveFres!)
--   Fix @withRetry() decoration syntax error when running extension locally (Thanks @DaveFres!)
--   Fix for git commit mentions in repos with no git commits
--   Fix cost calculation (Thanks @BarreiroT!)
-</changelog>
-
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Gemini prompt caching:</b> Gemini and Vertex providers now support prompt caching and price tracking for
-					Gemini models.
-				</li>
-				<li>
-					<b>Copy Buttons:</b> Buttons were added to Markdown and Code blocks that allow you to copy their contents
-					easily.
-				</li>
-				<li>
-					<b>/newrule command:</b> New slash command to have cline write your .clinerules for you based on your
-					workflow.
-				</li>
-				<li>
-					<b>Drag and drop improvements:</b> Don't forget to hold shift while dragging files!
-				</li>
-				<li>Added more checkpoints across the task, allowing you to restore from more than just file changes.</li>
-				<li>Added support for rendering LaTeX in message responses. (Try asking Cline to show the quadratic formula)</li>
-			</ul>
-			<Accordion isCompact className="pl-0">
-				<AccordionItem
-					key="1"
-					aria-label="Previous Updates"
-					title="Previous Updates:"
-					classNames={{
-						trigger: "bg-transparent border-0 pl-0 pb-0 w-fit",
-						title: "font-bold text-[var(--vscode-foreground)]",
-						indicator:
-							"text-[var(--vscode-foreground)] mb-0.5 -rotate-180 data-[open=true]:-rotate-90 rtl:rotate-0 rtl:data-[open=true]:-rotate-90",
-					}}>
-					<ul style={ulStyle}>
-						<li>
-							<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between
-							projects.
-						</li>
-						<li>
-							<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files
-							to plug and play specific rules for the task
-						</li>
-						<li>
-							<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a
-							new task (more coming soon!)
-						</li>
-						<li>
-							<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally
-							restore your project when the message was sent!
-						</li>
-					</ul>
-				</AccordionItem>
-			</Accordion>
-
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-- 3.13
-
-<changeset>
-Minor Changes
-2964388: Added copy button to MermaidBlock component
-75143a7: Add the ability to fetch from global cline rules files
-Patch Changes
-a0252e7: convert inline style to tailwind css of file SettingsView.tsx
-ab59bd9: Add stream options back to xai provider
-7276f50: Icons to indicate an action is occuring outside of the users workspace
-0b19ba6: update to NEW model
-</changeset>
-
-<changelog>
-## [3.13.0]
-
--   Add Cline rules popover under the chat field, allowing you to easily add, enable & disable workspace level or global rule files
--   Add new slash command menu letting you type “/“ to do quick actions like creating new tasks
--   Add ability to edit past messages, with options to restore your workspace back to that point
--   Allow sending a message when selecting an option provided by the question or plan tool
--   Add command to jump to Cline's chat input
--   Add support for OpenAI o3 & 4o-mini (Thanks @PeterDaveHello and @arafatkatze!)
--   Add baseURL option for Google Gemini provider (Thanks @owengo and @olivierhub!)
--   Add support for Azure's DeepSeek model. (Thanks @yt3trees!)
--   Add ability for models that support it to receive image responses from MCP servers (Thanks @rikaaa0928!)
--   Improve search and replace diff editing by making it more flexible with models that fail to follow structured output instructions. (Thanks @chi-cat!)
--   Add detection of Ctrl+C termination in terminal, improving output reading issues
--   Fix issue where some commands with large output would cause UI to freeze
--   Fix token usage tracking issues with vertex provider (Thanks @mzsima!)
--   Fix issue with xAI reasoning content not being parsed (Thanks @mrubens!)
-</changelog>
-
-<announcement-component>
-const Announcement = ({ version, hideAnnouncement }: AnnouncementProps) => {
-	const minorVersion = version.split(".").slice(0, 2).join(".") // 2.0.0 -> 2.0
-	return (
-		<div style={containerStyle}>
-			<VSCodeButton appearance="icon" onClick={hideAnnouncement} style={closeIconStyle}>
-				<span className="codicon codicon-close"></span>
-			</VSCodeButton>
-			<h3 style={h3TitleStyle}>
-				🎉{"  "}New in v{minorVersion}
-			</h3>
-			<ul style={ulStyle}>
-				<li>
-					<b>Global Cline Rules:</b> store multiple rules files in Documents/Cline/Rules to share between projects.
-				</li>
-				<li>
-					<b>Cline Rules Popup:</b> New button in the chat area to view workspace and global cline rules files to plug
-					and play specific rules for the task
-				</li>
-				<li>
-					<b>Slash Commands:</b> Type <code>/</code> in chat to see the list of quick actions, like starting a new task
-					(more coming soon!)
-				</li>
-				<li>
-					<b>Edit Messages:</b> You can now edit a message you sent previously by clicking on it. Optionally restore
-					your project when the message was sent!
-				</li>
-			</ul>
-			<h4 style={{ margin: "5px 0 5px" }}>Previous Updates:</h4>
-			<ul style={ulStyle}>
-				<li>
-					<b>Model Favorites:</b> You can now mark your favorite models when using Cline & OpenRouter providers for
-					quick access!
-				</li>
-				<li>
-					<b>Faster Diff Editing:</b> Improved animation performance for large files, plus a new indicator in chat
-					showing the number of edits Cline makes.
-				</li>
-				<li>
-					<b>New Auto-Approve Options:</b> Turn off Cline's ability to read and edit files outside your workspace.
-				</li>
-			</ul>
-			{/*
-			// Leave this here for an example of how to structure the announcement
-			<ul style={{ margin: "0 0 8px", paddingLeft: "12px" }}>
-				 <li>
-					OpenRouter now supports prompt caching! They also have much higher rate limits than other providers,
-					so I recommend trying them out.
-					<br />
-					{!apiConfiguration?.openRouterApiKey && (
-						<VSCodeButtonLink
-							href={getOpenRouterAuthUrl(vscodeUriScheme)}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Get OpenRouter API Key
-						</VSCodeButtonLink>
-					)}
-					{apiConfiguration?.openRouterApiKey && apiConfiguration?.apiProvider !== "openrouter" && (
-						<VSCodeButton
-							onClick={() => {
-								vscode.postMessage({
-									type: "apiConfiguration",
-									apiConfiguration: { ...apiConfiguration, apiProvider: "openrouter" },
-								})
-							}}
-							style={{
-								transform: "scale(0.85)",
-								transformOrigin: "left center",
-								margin: "4px -30px 2px 0",
-							}}>
-							Switch to OpenRouter
-						</VSCodeButton>
-					)}
-				</li>
-				<li>
-					<b>Edit Cline's changes before accepting!</b> When he creates or edits a file, you can modify his
-					changes directly in the right side of the diff view (+ hover over the 'Revert Block' arrow button in
-					the center to undo "<code>{"// rest of code here"}</code>" shenanigans)
-				</li>
-				<li>
-					New <code>search_files</code> tool that lets Cline perform regex searches in your project, letting
-					him refactor code, address TODOs and FIXMEs, remove dead code, and more!
-				</li>
-				<li>
-					When Cline runs commands, you can now type directly in the terminal (+ support for Python
-					environments)
-				</li>
-			</ul>*/}
-			<div style={hrStyle} />
-			<p style={linkContainerStyle}>
-				Join us on{" "}
-				<VSCodeLink style={linkStyle} href="https://x.com/cline">
-					X,
-				</VSCodeLink>{" "}
-				<VSCodeLink style={linkStyle} href="https://discord.gg/cline">
-					discord,
-				</VSCodeLink>{" "}
-				or{" "}
-				<VSCodeLink style={linkStyle} href="https://www.reddit.com/r/cline/">
-					r/cline
-				</VSCodeLink>
-				for more updates!
-			</p>
-		</div>
-	)
-}
-</announcement-component>
-
-
-We have a changeset PR that automatically generated as new unreleased PRs are merged into main, the PR is always called "Changeset version bump" and the author is github-actions. 
-
-The Changeset PR description looks something like this:
-
-<changeset-pr-description>
-This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and publish to npm yourself or [setup this action to publish automatically](https://github.com/changesets/action#with-publishing). If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated.
-
-
-# Releases
-## claude-dev@3.16.0
-
-### Minor Changes
-
--   c6e8b04: Recent task list is now collapsible, allowing users to hide their recent tasks (e.g. when sharing their screen).
--   aabe4ae: Add detection for new users to display special components
--   6c18d51: adds global endpoint for vertex ai users
--   080ed7c: Add Tailwind CSS IntelliSense to the the recommended extensions list
--   5147e28: new workflow feature
-
-### Patch Changes
-
--   c0b3c69: fix eternal loading states when the last message is a checkpoint
--   570ece3: selectImages protos migration
--   8d8452e: askResponse protobus migration
--   cd1ff2a: Finishing the migration of Vscode Advanced settings to Settings Webview
-</changeset-pr-description>
-
-The changeset pr is ALWAYS on the following branch: `changeset-release/main`.
-
-I have the `gh` command line tool set up and authenticated, so you have everything you need.
-
-The first step is to get the full diff from the changeset PR to look at the changes that were automatically made to the `CHANGELOG.md` file. By default it will automatically add a new section to the changelog.md file with the new version. The problem with the automatically generated section is that it just takes the text that the developers threw into their changeset files for each corresponding PR, and they can be pretty vague and bad. Additionally there's some stuff that is totally irrelevant for the end user, like minor refactoring changes. So I manually typically go in and update this section to be a proper changelog that will show up in our patchnotes. You can look at how the rest of the file is done because those are all good examples of us updating this to use good language for the end user. We usually put new features up top (and the most exciting flagship features at the very top), and then bug fixes/improvements at the bottom. Having some basic organization to the ordering of the bullet points by content is nice. But use common sense. 
-
-To handle this process effectively, do the following:
-
-For each of the automatically generated bullet points in the Changelog.md, you should
-1. Take the commit hash at the start of the bullet point, and use the `gh` command line tool find the PR that it was associated with. 
-2. Use the `gh` command to get the PR title/description/discussion to understand the context surrounding the PR.
-3. Use the `gh` command line tool to get the full PR diff to fully understand the changes made in the code.
-4. Synthesize that knowledge to determine (a) whether or not this change is relevant to end users and (b) what the text & ordering of the line should be.  
-5. Update the `CHANGELOG.md` accordingly 
-
-Do this for every single item in the list from the autogenerated bullet points. We want to be diligent and have a full understanding of every feature so we can make the best changelog ever!
-
-Here are some principles for good changelogs from keepchangelog.com, a handy guide:
-
-<keepachangelog-pinciples-for-good-changelogs>
-### Guiding Principles
-- Changelogs are for humans, not machines.
-- There should be an entry for every single version.
-- The same types of changes should be grouped.
-- The latest version comes first.
-
-### Bullet points in the changelog should follow these principles:
-- Types of changes
-- Added for new features.
-- Changed for changes in existing functionality.
-- Deprecated for soon-to-be removed features.
-- Removed for now removed features.
-- Fixed for any bug fixes.
-- Security in case of vulnerabilities.
-</keepachangelog-pinciples-for-good-changelogs>
-
-Lastly, when developers make a PR, they typically make a changeset. And they have 3 options when making the changeset:
-
-1. Patch
-2. Minor
-3. Major
-
-Sometimes they label something as minor when really it should just be a patch. Or vice versa. Because of this, the automatic version bump may be incorrect. So when starting out this workflow, you should use the <ask_followup_question> tool to confirm with me whether or not this should be a patch bump (show the old version number and what the proposed new version number would be) or a minor bump. Part of the release process is making sure the version in package.json that is automatically changed actually corresponds with what we decided the bump should actually be based on the features. ALL these modifications happen in the `changeset-release/main` branch btw. 
-
-<important_note>
-Before doing any of this, make sure you check out the `changeset-release/main` and pull the most recent up to date changes. Then perform all this work in that branch. 
-
-New announcement banners should ONLY be made for minor version bumps or higher. That's another reason why double checking if the changelog warrants the bump is important.
-
-Also, SUPER important: For any external contributors that aren't part of the cline github organization, we always want to add a (Thanks @username!) at the end of the changelog to attribute them properly. We're an open source project and it's ethical to do this.
-</important_note>
-
-Once the changelog looks good, and the version number looks good, we gotta double check that the version number in the changelog has the brackets around it. And as a final step, double check the package.json version number matches the latest number in the changelog. And as the ultimate final step we run `npm run install:all` to make sure the package version number permiates through the lock file. 
-
-
-<detailed_sequence_of_steps>
-# Cline Release Process - Detailed Sequence of Steps
-
-## Before Starting
-1. First, examine the changeset PR without checking it out:
-   ```bash
-   gh pr view changeset-release/main
-   ```
-
-2. View the PR diff to see the auto-generated CHANGELOG.md changes:
-   ```bash
-   gh pr diff changeset-release/main > changeset-diff.txt
-   cat changeset-diff.txt | grep -A 50 "CHANGELOG.md"
-   ```
-
-## Initial Setup
-3. Once you're ready to start, checkout and update the changeset release branch:
-   ```bash
-   git checkout changeset-release/main
-   git pull origin changeset-release/main
-   ```
-
-## Analyzing Each Change
-4. For each commit hash in the auto-generated changelog entries:
-
-   a. Find the PR number associated with a commit hash:
-      ```bash
-      gh pr list --search "<commit-hash>" --state merged
-      ```
-   
-   b. Get PR details for better context:
-      ```bash
-      gh pr view <PR-number>
-      ```
-   
-   c. Check if the contributor is external to determine if attribution is needed:
-      ```bash
-      # Extract username from PR
-      USERNAME=$(gh pr view <PR-number> --json author --jq .author.login)
-      
-      # Check if user is a member of the Cline organization
-	  # this command is a bit finnicky, but it 100% works. 
-	  # if you see a `Error executing command: The command ran successfully, but we couldn't capture its output. Please proceed accordingly.` error, just retry it until you actually get the output
-	  # don't make any assumptions, just retry the command to actually get the output and determine if they're external or not.
-	  # no output means they are an external contributor, otherwise if there is output they are an internal contributor (part of our github org)
-      gh api "orgs/cline/members" --jq "map(.login)" | grep -i "pashpashpash"
-      ```
-   
-   d. View the full PR diff to understand code changes:
-      ```bash
-      gh pr diff <PR-number> > pr-diff-<PR-number>.txt
-      cat pr-diff-<PR-number>.txt
-      ```
-
-## Updating the Changelog
-5. Based on PR analysis, update the CHANGELOG.md with user-friendly descriptions:
-   - Use the `<replace_in_file>` tool to edit the CHANGELOG.md file
-   - Group by feature type (Added, Changed, Fixed)
-   - Put most exciting features at the top
-   - Move bug fixes and small improvements to the bottom
-   - Use clear, end-user focused language
-   - For external contributors, add attribution at the end of the relevant entry: `(Thanks @username!)`
-
-## Version Number Verification
-6. Confirm the version bump is appropriate:
-   - Check package.json to verify the auto-generated version number:
-     ```bash
-     cat package.json | grep "\"version\""
-     ```
-   - If the feature set doesn't warrant a minor bump, use the `<replace_in_file>` tool to modify package.json
-
-7. Ensure the version in CHANGELOG.md has brackets around it:
-   ```
-   ## [3.16.0]
-   ```
-
-## Creating the Announcement (for minor/major versions only)
-8. If this is a minor version bump, create/update the announcement component:
-   - Use the `<replace_in_file>` tool to edit the src/views/components/announcement.tsx file
-   - Update the highlights based on key features
-   - Move previous version highlights to the "Previous Updates" section
-   - Use the previous announcement components as reference for structure
-
-## Finalizing the Release
-9. Update dependencies with the new version number:
-   ```bash
-   npm run install:all
-   ```
-
-10. Commit your changes:
-    ```bash
-    git add CHANGELOG.md package.json package-lock.json src/views/components/announcement.tsx
-    git commit -m "Update CHANGELOG.md and announcement for version 3.16.0"
-    ```
-
-11. Push your changes to the changeset branch:
-    ```bash
-    git push origin changeset-release/main
-    ```
-
-12. Check that your changes pushed successfully:
-    ```bash
-    git status
-    ```
-</detailed_sequence_of_steps>

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

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

.clinerules/workflows/git-branch-analysis.md

@@ -6,28 +6,14 @@ Analyze the current branch's changes against main to provide informed insights a
 ## Step 1: Gather Git Information
 <important>Do not return any text or conversation other than what is necessary to run these commands</important>
 
-**First, check the expected output size:**
-   ```shell
-   (git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat) | wc -l
-   ```
+**Run the following command to get the latest changes (bash):**
+```bash
+B=$(for c in main master origin/main origin/master; do git rev-parse --verify -q "$c" >/dev/null && echo "$c" && break; done); B=${B:-HEAD}; r(){ git branch --show-current; printf "=== STATUS ===\n"; git status --porcelain | cat; printf "=== COMMIT MESSAGES ===\n"; git log "$B"..HEAD --oneline | cat; printf "=== CHANGED FILES ===\n"; git diff "$B" --name-only | cat; printf "=== FULL DIFF ===\n"; git diff "$B" | cat; }; L=$(r | wc -l); if [ "$L" -gt 500 ]; then r > cline-git-analysis.temp && echo "::OUTPUT_FILE=cline-git-analysis.temp"; else r; fi
+```
 
-**If the expected line count is greater than 500 lines, use the file-based approach:**
-   ```shell
-   git branch --show-current > cline-git-analysis.temp && echo "=== STATUS ===" >> cline-git-analysis.temp && git status --porcelain >> cline-git-analysis.temp && echo "=== COMMIT MESSAGES ===" >> cline-git-analysis.temp && git log main..HEAD --oneline >> cline-git-analysis.temp && echo "=== CHANGED FILES ===" >> cline-git-analysis.temp && git diff main --name-only >> cline-git-analysis.temp && echo "=== FULL DIFF ===" >> cline-git-analysis.temp && git diff main >> cline-git-analysis.temp
-   ```
-
-   Then, read the file using the read_file tool. After you have read the file but before you proceed with subsequent steps, delete it:
-   ```shell
-   rm cline-git-analysis.temp
-   ```
-
-**If the expected line count is 500 lines or fewer, use the direct approach:**
-   ```shell
-   git branch --show-current && echo "=== STATUS ===" && git status --porcelain | cat && echo "=== COMMIT MESSAGES ===" && git log main..HEAD --oneline | cat && echo "=== CHANGED FILES ===" && git diff main --name-only | cat && echo "=== FULL DIFF ===" && git diff main | cat
-   ```
-
-<important>If using the direct approach, pipe outputs through `cat` to avoid interactive terminals. If the user's shell is not bash/zsh, adjust the command and chaining
- syntax accordingly.</important>
+```powershell
+$B=$null;foreach($c in 'main','master','origin/main','origin/master'){git rev-parse --verify -q $c *> $null;if($LASTEXITCODE -eq 0){$B=$c;break}};if(-not $B){$B='HEAD'};function r([string]$b){git rev-parse --abbrev-ref HEAD; '=== STATUS ==='; git status --porcelain | cat; '=== COMMIT MESSAGES ==='; git log "$b"..HEAD --oneline | cat; '=== CHANGED FILES ==='; git diff "$b" --name-only | cat; '=== FULL DIFF ==='; git diff "$b" | cat};$out=r $B|Out-String;$lines=($out -split "`r?`n").Count;if($lines -gt 500){$out|Set-Content -NoNewline cline-git-analysis.temp; '::OUTPUT_FILE=cline-git-analysis.temp'}else{$out}
+```
 
 ## Step 2: Silent, Structured Analysis Phase
 - Analyze all git output without providing commentary or narration

.clinerules/workflows/hotfix-release.md

@@ -0,0 +1,187 @@
+# Hotfix Release
+
+Create a hotfix release by cherry-picking specific commits from main onto the latest release tag.
+
+## Overview
+
+This workflow helps you:
+1. Select specific commits from main to include in a hotfix
+2. Create a release notes commit on main (changelog + version bump)
+3. Cherry-pick everything onto the latest release tag
+4. Tag and push the new release
+
+## Step 1: Setup and Gather Information
+
+First, ensure we're on main and up to date:
+
+```bash
+git checkout main && git pull origin main
+```
+
+Get the latest release tag:
+
+```bash
+git tag --sort=-v:refname | head -1
+```
+
+## Step 2: Present Commits Since Last Release
+
+Show all commits on main since the last release tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git log ${LAST_TAG}..HEAD --oneline --format="%h %s (%an)"
+```
+
+Also get the commit messages already on the tag (to identify previously cherry-picked commits). Note: Run these as separate commands to avoid shell parsing issues with parentheses in author names:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+PREV_TAG=$(git tag --sort=-v:refname | head -2 | tail -1)
+```
+
+```bash
+git log $PREV_TAG..$LAST_TAG --oneline --format="%s"
+```
+
+**Present the list** to the user in a numbered format with commit hash, subject, and author. For any commits whose subject line already appears in the tag's history (previously cherry-picked in an earlier hotfix) or are "Release Notes" commits, add `(already in previous hotfix)` or `(release notes - skip)` after them so the user knows to skip those.
+
+Ask which commits to include in the hotfix.
+
+Use the ask_followup_question tool to let the user specify which commits they want (by number or hash).
+
+## Step 3: Analyze Selected Commits
+
+For each selected commit:
+1. Get the full commit message: `git show --no-patch --format="%B" <hash>`
+2. Get the diff to understand the change: `git show <hash> --stat`
+3. Find the associated PR if any: `gh pr list --search "<hash>" --state merged --json number,title --jq '.[0]'`
+
+Build a mental model of what these changes do for the changelog.
+
+## Step 4: Determine New Version Number
+
+Parse the current version from package.json and the last tag:
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+echo "Last release: $LAST_TAG"
+cat package.json | grep '"version"'
+```
+
+Hotfixes always increment the patch version (e.g., 3.40.0 -> 3.40.1, or 3.40.1 -> 3.40.2).
+
+**Ask the user to confirm the new version number.**
+
+## Step 5: Create Release Notes Commit on Main
+
+On the main branch, create a commit that updates:
+
+1. **CHANGELOG.md** - Add a new section for the hotfix version at the top:
+   ```markdown
+   ## [3.40.1]
+
+   - Description of fix 1
+   - Description of fix 2
+   ```
+
+   Write clear, user-friendly descriptions based on your analysis of the commits.
+
+2. **package.json** - Update the version field to the new version
+
+3. No changelog-entry file cleanup is needed. Contributors do not create changelog-entry files in this repo.
+
+**Skip running `npm run install:all`** - release automation handles lockfile consistency as needed.
+
+Commit with message format: `v{VERSION} Release Notes (hotfix)`
+
+In the commit body, mention:
+- This is for a hotfix release
+- List the cherry-picked commits that will be included
+
+```bash
+git add CHANGELOG.md package.json
+git commit -m "v3.40.1 Release Notes (hotfix)
+
+Hotfix release including:
+- <commit1-hash>: <description>
+- <commit2-hash>: <description>
+"
+```
+
+Push to main:
+
+```bash
+git push origin main
+```
+
+## Step 6: Build the Hotfix on the Tag
+
+Checkout the last release tag (detached HEAD):
+
+```bash
+LAST_TAG=$(git tag --sort=-v:refname | head -1)
+git checkout $LAST_TAG
+```
+
+Cherry-pick the selected commits in order:
+
+```bash
+git cherry-pick <commit1-hash>
+git cherry-pick <commit2-hash>
+# ... etc
+```
+
+Finally, cherry-pick the release notes commit you just pushed to main:
+
+```bash
+# Get the hash of the release notes commit (should be HEAD of main)
+RELEASE_NOTES_COMMIT=$(git rev-parse main)
+git cherry-pick $RELEASE_NOTES_COMMIT
+```
+
+## Step 7: Tag and Push
+
+After all cherry-picks are applied successfully:
+
+```bash
+# Tag the new release
+git tag v{VERSION}
+
+# Push the tag to remote
+git push origin v{VERSION}
+```
+
+## Step 8: Return to Main and Summary
+
+Return to main branch:
+
+```bash
+git checkout main
+```
+
+**Copy a Slack announcement message to clipboard** with the version and PR links for each included fix:
+
+```
+VS Code Hotfix v{VERSION} Published
+
+- Description of fix 1 https://github.com/cline/cline/pull/{PR_NUMBER}
+- Description of fix 2 https://github.com/cline/cline/pull/{PR_NUMBER}
+```
+
+Present a final summary:
+- New version: v{VERSION}
+- Tag pushed: yes
+- Commits included: (list them)
+- Slack message copied to clipboard: yes
+
+Remind the user to:
+1. Manually trigger the publish release GitHub Action at: https://github.com/cline/cline/actions/workflows/publish.yml (paste `v{VERSION}` as the tag)
+2. Post the Slack message to announce the hotfix
+
+## Important Notes
+
+- This workflow does NOT create a release branch - only tags
+- The release notes commit goes to main first, then gets cherry-picked to the tag
+- This keeps main's history accurate while allowing hotfix releases from tags
+- If cherry-pick conflicts occur, resolve them before continuing

.clinerules/workflows/pr-review.md

@@ -219,6 +219,9 @@ EOF
 
 ## Basic PR Commands
 ```bash
+# Get current PR number
+gh pr view --json number -q .number
+
 # List open PRs
 gh pr list
 
@@ -344,8 +347,6 @@ A few notes:
 So until the settings page is update, and this is added to settings in a way that's clean and doesn't confuse new users, I don't think we can merge this. Please bear with us.
 </request_changes_comment>
 <request_changes_comment>
-Also, don't forget to add a changeset since this fixes a user-facing bug.
-
 The architectural change is solid - moving the focus logic to the command handlers makes sense. Just don't want to introduce subtle timing issues by removing those timeouts.
 </request_changes_comment>
 </example_comments_that_i_have_written_before>

.clinerules/workflows/release.md

@@ -0,0 +1,64 @@
+# Release
+
+Prepare and publish a release directly from `main`.
+
+## Overview
+
+This workflow helps you:
+1. Select/confirm the target version
+2. Curate `CHANGELOG.md` entries manually for end users
+3. Ensure `package.json` version matches the changelog
+4. Create and push a release commit + tag
+5. Trigger publish workflow
+6. Update GitHub release notes and share a summary
+
+## Process
+
+### 1) Sync and determine version
+
+```bash
+git checkout main
+git pull origin main
+cat package.json | grep '"version"'
+```
+
+Confirm the release version with the maintainer (patch/minor/major).
+
+### 2) Curate changelog and version
+
+- Edit `CHANGELOG.md` for the target version using human-friendly release notes.
+- Ensure version headers use bracket format, e.g. `## [3.66.1]`.
+- Update `package.json` version to the same value.
+
+### 3) Commit and tag
+
+```bash
+git add CHANGELOG.md package.json package-lock.json
+git commit -m "v<version> Release Notes"
+git push origin main
+git tag v<version>
+git push origin v<version>
+```
+
+### 4) Trigger publish workflow
+
+Tell the maintainer to run:
+https://github.com/cline/cline/actions/workflows/publish.yml
+
+Use `v<version>` as the release tag.
+
+### 5) Update GitHub release notes
+
+After publish completes:
+
+```bash
+gh release view v<version> --json body --jq '.body'
+gh release edit v<version> --notes "<final curated release notes>"
+```
+
+### 6) Final summary
+
+Provide:
+- Released version/tag
+- Link to release page
+- Summary of top end-user changes

.clinerules/workflows/writing-documentation.md

@@ -0,0 +1,392 @@
+# General writing guide
+
+# How I want you to write 
+
+I'm gonna write something technical.
+
+It's often less about the nitty-gritty details of the tech stuff and more about learning something new or getting a solution handed to me on a silver platter.
+
+Look, when I read, I want something out of it. So when I write, I gotta remember that my readers want something too. This whole piece? It's about cluing in anyone who writes for me, or wants me to write for them, on how I see this whole writing product thing.
+
+I'm gonna lay out a checklist of stuff I'd like to have. It'll make the whole writing gig a bit smoother, you know?
+
+## Crafting Compelling Titles
+
+I often come across titles like "How to do X with Y,Z technology." These don't excite me because X or Y are usually unfamiliar unless they're already well-known. Its rarely the dream to use X unless X is the dream. 
+
+My dream isn’t to use instructor, its to do something valueble with the data it extracts
+
+An effective title should:
+
+- Evoke an emotional response
+- Highlight someone's goal
+- Offer a dream or aspiration
+- Challenge or comment on a belief
+- Address someone's problems
+
+I believe it's more impactful to write about specific problems. If this approach works, you can replicate it across various scenarios rather than staying too general.
+
+- Time management for everyone can be a 15$ ebook
+- Time management for executives is a 2000$ workshop
+
+Aim for titles that answer questions you think everyone is asking, or address thoughts people have but can't quite articulate.
+
+Instead of "How I do something" or "How to do something," frame it from the reader's perspective with "How you can do something." This makes the title more engaging. Just make sure the difference is advisory if the content is subjective. “How I made a million dollars” might be more reasonable than “How to make a million dollars” since you are the subject and the goal might be to share your story in hopes of helping others.
+
+This approach ultimately trains the reader to have a stronger emotional connection to your content.
+
+- "How I do X"
+- "How You Can do X"
+
+Between these two titles, it's obvious which one resonates more emotionally.
+
+You can take it further by adding specific conditions. For instance, you could target a particular audience or set a timeframe:
+
+- How to set up Braintrust
+- How to set up Braintrust in 5 minutes
+
+## NO adjectiives
+
+I want you to almost always avoid adjectives and try to use evidence instead. Instead of saying "production ready," you can write something like "scaling this to 100 servers or 1 million documents per second." Numbers like that will tell you exactly what the specificity of your product is. If you have to use adjectives rather than evidence, you are probably making something up. 
+
+There's no reason to say something like "blazingly fast" unless those things are already known phrases.
+
+Instead, say "200 times faster" or "30% faster." A 30% improvement in recommendation system speed is insane.
+
+There's a 200 times performance improvement because we went from one programming language to another. It's just something that's a little bit more expected and understandable.
+
+Another test that I really like using recently is tracking whether or not the statements you make can be:
+
+- Visualized
+- Proven false
+- Said only by you
+
+If you can nail all three, the claim you make will be more likely to resonate with an audience because only you can say it.
+
+Earlier this year, I had an example where I embedded all of Wikipedia in 17 minutes with 20 bucks, and it got half a million views. All we posted was a video of me kicking off the job, and then you can see all the log lines go through. You see the number of containers go from 1 out of 50 to 50 out of 50.
+
+It was easy to visualize and could have been proven false by being unreproducible. Lastly, Modal is the only company that could do that in such an effortless way, which made it unique.
+
+## Keep It Digestible 
+    - Aim for 5-minute reads
+    - Write at a Grade 10 reading level
+    - Break up long paragraphs
+    - Use headers and bullet points
+
+## Make It Scannable
+    - Bold key points
+    - Use subheadings every 3-4 paragraphs
+    - Include plenty of white space
+    - Add relevant examples
+
+This structure works whether you're writing a tweet thread or a full blog post. The key is making complex ideas accessible.
+
+# Guide to Writing Cline Documentation
+
+## Some general principles for explaining features
+
+If you're talking about a feature, it's helpful to start with a human-readable explanations that cover what the feature is in simple terms. Skip jargon and explain it like you're talking to someone who's never seen it before. This sets the foundation for everything that follows.
+
+Combine location and usage into one flowing section. Tell users exactly where to find the feature and how to use it, but weave the instructions into natural prose with a good balance of bullet points, numbered lists, code examples (if applicable), mintlify components, and headers/subheaders. Users shouldn't have to jump between separate "where is it" and "how do I use it" sections.
+
+Show the feature in action with real examples like actual files, workflows, or code. Users need to see concrete implementations, not just abstract descriptions. This is where understanding turns into practical knowledge.
+
+When talking about a feature, include an inspiration section that sparks imagination. This section pushes people from understanding to action by showing them what becomes possible when they use this feature creatively. It's what separates good documentation from great documentation.
+
+## Writing Principles That Actually Work
+
+### Write for Action, Not Just Understanding
+
+Documentation should motivate users to try things. Instead of just explaining how something works, focus on what users can accomplish with it. The inspiration section is crucial - it's what transforms passive readers into active users.
+
+### Create a Natural Story Flow
+
+It should feel like a conversation that naturally progresses from "what is this?" to "how do I use it?" to "here's a real example" to "imagine what you could do with this." 
+
+### Show Real Examples, Not Toy Demos
+
+Provide actual workflow files, real code snippets, and concrete implementations that users can copy and adapt. Abstract examples don't help anyone - users want to see exactly what they'll be working with.
+
+### Keep It Scannable But Not Fragmented
+
+Write in prose that flows naturally when read completely, but structure it so users can quickly find specific information when they're troubleshooting. Avoid dense walls of text, but also avoid over-formatting with excessive bullet points and bold headers. There should be a nice visual heirarchy of balance between all elements, so you can quickly scan the page and find what you're looking for.
+
+## Language and Tone Guidelines
+
+Write clearly without dumbing things down. Use simple language when possible, but don't avoid technical terms that users need to know. Explain concepts in terms of what users can achieve rather than how the software works internally.
+
+Make your writing conversational and encouraging. Phrases like "you can also try" or "when that works" feel more natural than rigid instructional language. Help users feel confident about trying new things.
+
+Keep content concise and purposeful. Every sentence should either help users understand something or help them do something. If it doesn't serve one of those purposes, cut it.
+
+Build in context and reasoning. Users want to understand why they're doing something, not just what to do. This builds confidence and helps them troubleshoot when things don't work exactly as expected.
+
+## Practical Implementation
+
+Structure each feature page consistently with the four-section approach, but let the content flow naturally within that structure. Use visual assets like videos and screenshots to complement the written content - they often communicate more effectively than paragraphs of description.
+
+Link generously to related resources, examples, and deeper documentation. Users should never feel stuck or wonder where to go next. Maintain a repository of real examples that users can reference and adapt to their own needs.
+
+The goal is documentation that feels more like helpful guidance from an experienced colleague than a technical manual. Users should finish reading feeling excited about what they can accomplish, not just informed about what the feature does.
+
+## Balance Structure with Flexibility
+
+While they discuss having consistent documentation structure, there's also mention of making content feel less rigid and more natural. The writing should follow guidelines while still feeling conversational and engaging. 
+
+## Bad examples
+
+I personally hate this pattern of bullet point **Bold Text** colon and then more text:
+<bad_example_of_writing>
+#### macOS
+
+1. **Switch to bash**: Go to Cline Settings → Terminal → Default Terminal Profile → Select "bash"
+2. **Disable Oh-My-Zsh temporarily**: If using zsh, try `mv ~/.zshrc ~/.zshrc.backup` and restart VSCode
+3. **Set environment**: Add to your shell config: `export TERM=xterm-256color`
+
+#### Windows
+
+1. **Use PowerShell 7**: Install from Microsoft Store, then select it in Cline settings
+2. **Disable Windows ConPTY**: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → Uncheck
+3. **Try Command Prompt**: Sometimes simpler is better - switch to cmd.exe
+
+#### Linux
+
+1. **Use bash**: Most reliable option - select in Cline settings
+2. **Check permissions**: Ensure VSCode has terminal access permissions
+3. **Disable custom prompts**: Comment out prompt customizations in `.bashrc`
+
+</bad_example_of_writing>
+
+We should instead strive to write beautiful docs that read well. We can use bullet points and numbered lists but it should read naturally and be delightful to look at hierachally when scanning through the doc. There should be a good balance between blocks of text, code snippets, paragraphs, numbered lists, and bullet points. When scanning the documentation visually, you should feel like you're adminiring a tasteful art piece.
+
+<good_example_of_writing>
+#### macOS
+
+The most common fix is switching to bash. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown.
+
+If you're still having issues, Oh-My-Zsh might be interfering with terminal integration. Try temporarily disabling it:
+- Run `mv ~/.zshrc ~/.zshrc.backup` 
+- Restart VSCode
+
+You can also add `export TERM=xterm-256color` to your shell configuration file to improve compatibility.
+
+#### Windows
+
+PowerShell 7 provides the most reliable experience. Install it from the Microsoft Store, then select it in your Cline settings.
+
+Still seeing problems? Try these solutions:
+- Disable Windows ConPTY: VSCode Settings → Terminal › Integrated: Windows Enable Conpty → uncheck
+- Switch to Command Prompt (cmd.exe) - sometimes simpler shells work better
+
+#### Linux
+
+Bash is your most dependable option. Select it in Cline settings if you haven't already.
+
+Check these common issues:
+- Ensure VSCode has terminal access permissions
+- Temporarily comment out custom prompt configurations in your `.bashrc`
+</good_example_of_writing>
+
+This is much more natural to read. Writing this way creates a conversational flow, and bullet points are used idiomatically.
+
+# Using Mintlify Components Idiomatically
+
+Mintlify's custom components can transform basic documentation into engaging, scannable content that users actually want to read. Here's how to use them effectively.
+
+## Visual Content with Frames
+
+Videos and images should be wrapped in `<Frame>` components rather than using raw HTML or markdown. This creates consistent styling and proper responsive behavior.
+
+For videos, embed them directly rather than linking externally. Users are much more likely to watch a 30-second demonstration than click through to another platform:
+
+```jsx
+<Frame>
+	<iframe
+		style={{ width: "100%", aspectRatio: "16/9" }}
+		src="https://www.youtube.com/embed/your-video-id"
+		title="Feature demonstration"
+		frameBorder="0"
+		allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+		allowFullScreen
+	/>
+</Frame>
+```
+
+Screenshots work similarly - the frame provides visual polish and consistency:
+
+```jsx
+<Frame>
+	<img src="/path/to/screenshot.png" alt="Descriptive alt text" />
+</Frame>
+```
+
+## Cards for Navigation and Overview
+
+Cards excel at creating scannable overviews that link to detailed documentation. They're perfect for feature listings, getting started guides, or any section where users need to choose their path.
+
+Use the two-column layout for related features:
+
+```jsx
+<Columns cols={2}>
+  <Card title="Feature Name" icon="relevant-icon" href="/link/to/docs">
+    Brief description that explains what this feature does and why someone would use it.
+  </Card>
+  
+  <Card title="Related Feature" icon="another-icon" href="/another/link">
+    Another concise explanation that helps users understand the value proposition.
+  </Card>
+</Columns>
+```
+
+The key is writing card descriptions that are informative enough to help users decide whether to click through, but concise enough to scan quickly. Each card should answer "what does this do?" and "why would I need this?"
+
+## Tips and Notes for Context
+
+Use `<Tip>` components for helpful information that enhances the main content without cluttering it:
+
+```jsx
+<Tip>
+	Pro tip: You can combine multiple @ mentions in a single message to give Cline 
+	comprehensive context about your issue.
+</Tip>
+```
+
+`<Note>` components work well for important caveats or technical limitations:
+
+```jsx
+<Note>
+	Due to VS Code limitations, some features require specific settings to work properly.
+</Note>
+```
+
+`<Info>` is also cool:
+
+<Info>
+	**Quick Fix**: If you're experiencing terminal issues, try switching to a simpler shell like `bash` in the Cline settings.
+	This resolves 90% of terminal integration problems.
+</Info>
+
+**Never** fall into that awful **Bold Text** - description pattern that we specifically identified as bad writing. The content should flow naturally as connected thoughts rather than feeling like a templated AI response with forced formatting.
+
+
+## When to Use Bullet Points and Numbered Lists Strategically
+
+Bullet points serve functional purposes - use them for:
+
+**Sequential actions or troubleshooting steps** where users need to follow a specific order:
+1. Install the extension
+2. Restart VSCode  
+3. Check the settings panel
+
+**Lists of related options** where users need to choose one approach:
+- Try PowerShell 7 for the most reliable experience
+- Switch to Command Prompt if you're still having issues
+- Use WSL Bash for Linux compatibility
+
+**Quick reference items** that users might need to scan quickly when problem-solving.
+
+**Improving Visual Hierarchy** when there's a wall of text - that's a good time to introduce bullet points or numbered lists.
+
+Each bulleted item or numbered list should be a discrete action or piece of information that benefits from being visually separated. This is a key weapon you can employ when going for that artwork experience I mentioned earlier. 
+
+<good_example_of_bullet_points>
+## Finding and Configuring Terminal Settings
+
+You can access Cline's terminal settings by clicking the settings icon in the Cline sidebar, then navigating to the Terminal section. These settings control how Cline interacts with your system's terminal.
+
+- The **Default Terminal Profile** setting determines which shell Cline uses for executing commands. If you're experiencing issues, this is usually the first thing to change. I personally keep this set to `bash` on all my systems because it's the most reliable option, even though I use `zsh` for my regular terminal work.
+
+- **Shell Integration Timeout** controls how long Cline waits for the terminal to become ready. The default is 4 seconds, but if you have a heavy shell configuration (lots of plugins, slow startup scripts), you might need to increase this to 10 or even 15 seconds. I've found that WSL environments and SSH connections often need longer timeouts.
+
+- The **Enable Aggressive Terminal Reuse** setting determines whether Cline tries to reuse existing terminals even when they're not in the correct directory. When this causes problems (commands running in the wrong directory, virtual environment issues), disabling it creates more terminal instances but ensures each command runs in a clean state.
+
+- **Terminal Output Line Limit** sets how many lines of output Cline will read from commands. The default of 500 lines works for most cases, but you might need to adjust it. For verbose build outputs, increase it. For commands with progress bars that spam thousands of lines, decrease it to around 100 to avoid consuming too many tokens.
+</good_example_of_bullet_points>
+
+## Write Like a Human, Not an AI
+
+Keep it short and direct. If you can say something in fewer words, do it. Long explanations often confuse more than they help.
+
+Use normal sentence lengths. Mix short and long sentences naturally, like you would when talking to someone. Avoid those meandering compound sentences that go on forever.
+
+Cut the corporate speak. Instead of "utilize," say "use." Instead of "in order to," just say "to." Write like you're explaining something to a colleague, not drafting a press release.
+
+Don't over-explain obvious things. If users are reading documentation, they probably understand basic concepts. Respect their intelligence.
+
+## Never use em dashes or emojis
+
+That's pretty much it. Never use them. Only AI writes with em dashes or emojis.
+
+# Anthropomorphizing Cline
+
+When referring to Cline, always call him a "him" not an "it". 
+
+Bad example:
+- When Cline can’t execute commands or read their output, you lose access to one of its most powerful capabilities.
+
+Good Example:
+
+- When Cline can’t execute commands or read their output, you lose access to one of his most powerful capabilities.
+
+# Using "I" when sharing your workflow
+
+Adding a personal touch goes a long way. There are great examples in the docs currently where I use "I" to share how I personally use cline, from dev to dev. It's a great technique.
+
+# Crosslinking relevant documentation pages
+
+Make sure you crosslink when you're done writing the docs. If there are relevant docs, just link to them.
+
+# Brevity is the soul of wit
+
+Don't ramble if you don't need to. Use bullet points and numbered lists. Keep things easy to read.
+
+<bad_example>
+
+When Cline can't execute commands or read their output, you lose access to one of his most powerful capabilities. Terminal integration problems are frustrating, but they're usually fixable with a few simple changes.
+
+## The Most Common Problem: Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline isn't getting command output, the issue is almost always your shell configuration. Complex shell setups with custom prompts, plugins, and fancy configurations can interfere with VSCode's terminal integration.
+
+**Switch to bash first.** This fixes the problem 90% of the time. Navigate to Cline Settings → Terminal → Default Terminal Profile and select "bash" from the dropdown. Restart VSCode after making this change.
+
+Still having issues? Try increasing the shell integration timeout. Go to Cline Settings → Terminal → Shell Integration Timeout and change it from 4 seconds to 10 seconds. Heavy shell configurations need more time to initialize properly.
+
+If commands are running in the wrong directories or you're seeing weird behavior, disable aggressive terminal reuse. In Cline Settings → Terminal, uncheck "Enable aggressive terminal reuse." This creates more terminal instances but ensures each command runs in a clean environment.
+
+
+</bad_exaxmple>
+
+The first part is total filler, useless to any serious developer. You can tell it's written by a non technical person that doesn't value clean, straightforward information. 
+
+<good_example>
+## Shell Integration Issues
+
+If you're seeing "Shell integration unavailable" or Cline can't read command output, your shell configuration is interfering with VSCode's terminal integration.
+
+**Switch to bash first.** Go to Cline Settings → Terminal → Default Terminal Profile and select "bash." This fixes 90% of problems.
+
+Still broken? Try these:
+- Increase shell integration timeout to 10 seconds in Cline Settings → Terminal
+- Disable "aggressive terminal reuse" if commands run in wrong directories
+- Restart VSCode after making changes
+</good_example>
+
+The good version cuts straight to the problem and solution. No hand-holding, no emotional language about frustration, just the facts: what's wrong, how to fix it, what to try next. Respects that developers want information, not sympathy.RetryClaude can make mistakes. Please double-check responses.
+
+ALWAYS consider your audience. And your audience is devs who don't want their time wasted. Give them the info. I cannot stress this enough. Use bullet points and numbered lists. Prose is good, but every word should actually mean something to the dev reading it.
+
+# Lastly, before you start writing docs
+
+1. Internalize these guidelines. I mean it. 
+
+2. Read `docs/docs.json` and get an understanding of the structure of the docs. This will come in handly at the end when you're doing a final pass so you can cross link to docs where relevant.
+
+3. Read some good examples that I personally wrote and am proud of:
+
+- docs/features/slash-commands/workflows.mdx
+- docs/features/slash-commands/new-task.mdx
+- docs/features/at-mentions/overview.mdx
+- docs/features/drag-and-drop.mdx
+
+4. If the user specifies any other instructions make sure you follow them.

.codespellrc

@@ -1,6 +0,0 @@
-[codespell]
-# Ref: https://github.com/codespell-project/codespell#using-a-config-file
-skip = .git*,*.svg,package-lock.json,*.css,.codespellrc,locales
-check-hidden = true
-ignore-regex = (\b(optIn|isTaller)\b|https://\S+)
-# ignore-words-list =

.codex/environments/environment.toml

@@ -0,0 +1,49 @@
+# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY
+version = 1
+name = "cline"
+
+[setup]
+script = '''
+if [ ! -d "node_modules" ]; then
+  MAIN_WORKTREE="$(git worktree list | head -n1 | awk '{print $1}')"
+  ln -s "$MAIN_WORKTREE/node_modules" node_modules
+  ln -s "$MAIN_WORKTREE/webview-ui/node_modules" webview-ui/node_modules
+fi
+'''
+
+[[actions]]
+name = "VS Code"
+icon = "run"
+command = "chmod +x ./scripts/run-extension-host.sh && ./scripts/run-extension-host.sh production"
+
+[[actions]]
+name = "CLI"
+icon = "run"
+command = '''
+npm run cli:build
+npm run cli:run
+'''
+
+[[actions]]
+name = "npm install"
+icon = "tool"
+command = '''
+rm node_modules
+rm webview-ui/node_modules
+npm run install:all
+'''
+
+[[actions]]
+name = "pull main"
+icon = "tool"
+command = '''
+git fetch origin main                                                                                                                                                             
+                                                                                                                                                                                
+if ! git merge-base --is-ancestor main origin/main; then                                                                                                                          
+  echo "Local main has commits not on origin/main. Aborting..."                                                                                                                     
+  exit 1                                                                                                                                                                          
+fi
+
+git update-ref refs/heads/main refs/remotes/origin/main
+echo "main updated to $(git rev-parse --short main)"
+'''

.env.example

@@ -0,0 +1,134 @@
+# Cline Development Environment Variables
+# Copy this file to .env and fill in your actual values
+# Values should be obtained from 1Password shared vault for development
+
+# ============================================================================
+# DEVELOPMENT FLAGS
+# Recomend not changing these unless you know what you're doing they are set by the launch.json normally
+# ============================================================================
+# IS_DEV=true
+# CLINE_ENVIRONMENT=local
+
+# ============================================================================
+# POSTHOG TELEMETRY (Existing)
+# ============================================================================
+# Get these values from 1Password shared vault
+TELEMETRY_SERVICE_API_KEY=your-posthog-telemetry-api-key
+ERROR_SERVICE_API_KEY=your-posthog-error-tracking-api-key
+
+# ============================================================================
+# OPENTELEMETRY (Optional - for advanced telemetry)
+# ============================================================================
+# OpenTelemetry provides flexible telemetry collection with multiple export options
+# Can run alongside PostHog or independently
+# Primary focus: Logs (events), with optional metrics support
+
+# Enable OpenTelemetry (set to 1 to enable)
+# OTEL_TELEMETRY_ENABLED=1
+
+# Exporters: "console" for local debugging, "otlp" for remote collector
+# Logs are the primary signal (recommended)
+# OTEL_LOGS_EXPORTER=console
+# OTEL_METRICS_EXPORTER=otlp
+
+# OTLP Protocol: "grpc", "http/json", or "http/protobuf"
+# OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+
+# OTLP Endpoint (without /v1/logs or /v1/metrics path - auto-appended)
+# For gRPC: use "localhost:4317" (no http:// prefix)
+# For HTTP: use "http://localhost:4318"
+# OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
+
+# OTLP Headers (for authentication, e.g., bearer tokens)
+# OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token-here
+
+# Use insecure gRPC connections (for local testing only, NOT for production)
+# OTEL_EXPORTER_OTLP_INSECURE=true
+
+# Metric export interval in milliseconds (default: 60000)
+# OTEL_METRIC_EXPORT_INTERVAL=10000
+
+# Batch configuration for logs (optional)
+# OTEL_LOG_BATCH_SIZE=512              # Max logs per batch (default: 512)
+# OTEL_LOG_BATCH_TIMEOUT=5000          # Max wait time in ms (default: 5000)
+# OTEL_LOG_MAX_QUEUE_SIZE=2048         # Max queue size (default: 2048)
+
+# Enable detailed export diagnostics (for debugging)
+# TEL_DEBUG_DIAGNOSTICS=true
+
+# Advanced: Separate endpoints for metrics and logs (optional)
+# OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf
+# OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://metrics.example.com:4318
+# OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=grpc
+# OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=logs.example.com:4317
+
+# Example configurations:
+#
+# Console debugging (logs only):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=console
+#   TEL_DEBUG_DIAGNOSTICS=true
+#
+# OTLP with gRPC (insecure, for local testing):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=otlp
+#   OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+#   OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
+#   OTEL_EXPORTER_OTLP_INSECURE=true
+#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
+#
+# OTLP with HTTP/JSON (production):
+#   OTEL_TELEMETRY_ENABLED=true
+#   OTEL_LOGS_EXPORTER=otlp
+#   OTEL_EXPORTER_OTLP_PROTOCOL=http/json
+#   OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.example.com
+#   OTEL_EXPORTER_OTLP_HEADERS=authorization=Bearer your-token
+
+# ============================================================================
+# OBJECT STORE CONFIGURATION
+# ============================================================================
+# TO ENABLE S3 OR R2 STORAGE, UNCOMMENT AND FILL IN THE FOLLOWING:
+# CLINE_STORAGE_ADAPTER="s3" # Options: "s3" or "r2"
+# CLINE_STORAGE_BUCKET="cline"
+# CLINE_STORAGE_ACCESS_KEY_ID="key"
+# CLINE_STORAGE_SECRET_ACCESS_KEY="secrets"
+# 
+# [OPTIONAL FIELDS FOR R2]
+# CLINE_STORAGE_ACCOUNT_ID = "account-id" 
+# Default R2 endpoint (if not set): "https://<CLINE_STORAGE_ACCOUNT_ID>.r2.cloudflarestorage.com"
+# CLINE_STORAGE_ENDPOINT = "http://localhost:8333"
+# 
+# [OPTIONAL FIELDS FOR S3]
+# CLINE_STORAGE_REGION = "us-west-1" # AWS Bucket Region (default: "us-east-1")
+# Default S3 endpoint (if not set): "https://s3.<CLINE_STORAGE_REGION>.amazonaws.com"
+# CLINE_STORAGE_ENDPOINT = "http://localhost:8333"
+# 
+# [OPTIONAL FIELDS FOR ALL STORAGE TYPES]
+# CLINE_STORAGE_SYNC_INTERVAL_MS = 30000 # Interval for sync worker in milliseconds
+# CLINE_STORAGE_SYNC_MAX_RETRIES = 5     # Max retries for failed sync operations
+# CLINE_STORAGE_SYNC_BATCH_SIZE = 10     # Number of files to sync in each batch
+# CLINE_STORAGE_SYNC_BACKFILL_ENABLED = false # Enable backfill of existing data on startup
+
+# ============================================================================
+# OPTIONAL DEVELOPMENT SETTINGS
+# ============================================================================
+# Uncomment and modify as needed for development
+
+# Multi-root workspace debugging
+# MULTI_ROOT_TRACE=true
+
+# gRPC recorder for testing
+# GRPC_RECORDER_ENABLED=true
+# GRPC_RECORDER_FILE_NAME=test-recording
+
+# Test mode
+# E2E_TEST=true
+# IS_TEST=true
+
+# ============================================================================
+# USAGE INSTRUCTIONS
+# ============================================================================
+# 1. Copy this file: cp .env.example .env
+# 2. Get PostHog keys from 1Password shared vault
+# 3. Update the values in .env
+# 4. The .env file is gitignored for security

.eslintrc.json

@@ -1,35 +0,0 @@
-{
-	"root": true,
-	"parser": "@typescript-eslint/parser",
-	"parserOptions": {
-		"ecmaVersion": 6,
-		"sourceType": "module"
-	},
-	"plugins": ["@typescript-eslint", "eslint-rules"],
-	"rules": {
-		"@typescript-eslint/naming-convention": [
-			"warn",
-			{
-				"selector": "import",
-				"format": ["camelCase", "PascalCase"]
-			}
-		],
-		"@typescript-eslint/semi": "off",
-		"curly": "warn",
-		"eqeqeq": "warn",
-		"no-throw-literal": "warn",
-		"semi": "off",
-		"react-hooks/exhaustive-deps": "off",
-		"eslint-rules/no-protobuf-object-literals": "error",
-		"eslint-rules/no-grpc-client-object-literals": "error",
-		"eslint-rules/no-direct-vscode-api": "warn",
-		"no-restricted-syntax": [
-			"error",
-			{
-				"selector": "VariableDeclarator[id.type=\"ObjectPattern\"][init.object.name=\"process\"][init.property.name=\"env\"]",
-				"message": "Use process.env.VARIABLE_NAME directly instead of destructuring"
-			}
-		]
-	},
-	"ignorePatterns": ["out", "dist", "**/*.d.ts"]
-}

.gitattributes

@@ -1,4 +1,5 @@
 demo.gif filter=lfs diff=lfs merge=lfs -text
 assets/docs/demo.gif filter=lfs diff=lfs merge=lfs -text
+webview-ui/src/assets/cline_kanban_demo.webm filter=lfs diff=lfs merge=lfs -text
 
 * text=auto eol=lf

.github/CODEOWNERS

@@ -1 +1,2 @@
-*       @saoudrizwan @ocasta181 @NightTrek @pashpashpash @dcbartlett @saito-sv @Garoth
+/.github/   @saoudrizwan @arafatkatze @maxpaulus43 @candieduniverse
+/README.md  @saoudrizwan @juanpflores

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,70 +1,70 @@
 name: 🐛 Bug Report
 description: File a bug report
-labels: ["bug"]
+labels: ['bug']
 body:
-    - type: markdown
-      attributes:
-          value: |
-              **Important:** All bug reports must be reproducible using Claude 3.5 Sonnet. Cline uses complex prompts so less capable models may not work as expected.
-    - type: textarea
-      id: what-happened
-      attributes:
-          label: What happened?
-          description: Also tell us, what did you expect to happen?
-          placeholder: Tell us what you see!
-      validations:
-          required: true
-    - type: textarea
-      id: steps
-      attributes:
-          label: Steps to reproduce
-          description: How do you trigger this bug? Please walk us through it step by step.
-          value: |
-              1.
-              2.
-              3.
-      validations:
-          required: true
-    - type: textarea
-      id: logs
-      attributes:
-          label: Relevant API REQUEST output
-          description: Please copy and paste any relevant output. This will be automatically formatted into code, so no need for backticks.
-          render: shell
-    - type: input
-      id: provider-model
-      attributes:
-          label: Provider/Model
-          description: What provider and model were you using when the issue occurred?
-          placeholder: "e.g., cline:anthropic/claude-3.7-sonnet, gemini:gemini-2.5-pro-exp-03-25"
-      validations:
-          required: true
-    - type: input
-      id: operating-system
-      attributes:
-          label: Operating System
-          description: What operating system are you using?
-          placeholder: "e.g., Windows 11, macOS Sonoma, Ubuntu 22.04"
-      validations:
-          required: true
-    - type: textarea
-      id: system-info
-      attributes:
-          label: System Info
-          description: What system information is relevant to the issue?
-          placeholder: "e.g., CPU: Intel Core i7-11700K, GPU: NVIDIA GeForce RTX 3070, RAM: 32GB DDR4"
-      validations:
-          required: true
-    - type: input
-      id: cline-version
-      attributes:
-          label: Cline Version
-          description: What version of Cline are you using? (You can find this at the bottom of the Settings view)
-          placeholder: "e.g., 1.2.3"
-      validations:
-          required: true
-    - type: textarea
-      id: additional-context
-      attributes:
-          label: Additional context
-          description: Add any other context about the problem here, such as screenshots or related issues.
+  - type: markdown
+    attributes:
+      value: |
+        **Important:** All bug reports must be reproducible using Claude Sonnet 4.5. Cline uses complex prompts so less capable models may not work as expected.
+  - type: dropdown
+    id: plugin-type
+    attributes:
+      label: Plugin Type
+      description: Which plugin are you reporting a bug for?
+      options:
+        - VSCode Extension
+        - JetBrains Plugin
+        - CLI
+      default: 0
+    validations:
+      required: true
+  - type: input
+    id: cline-version
+    attributes:
+      label: Cline Version
+      description: What version of Cline are you using? (You can find this at the bottom of the Settings view)
+      placeholder: 'e.g., 1.2.3'
+    validations:
+      required: true
+  - type: textarea
+    id: what-happened
+    attributes:
+      label: What happened?
+      description: Also tell us, what did you expect to happen?
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: How do you trigger this bug? Please walk us through it step by step.
+      value: |
+        1.
+        2.
+        3.
+    validations:
+      required: false
+  - type: input
+    id: provider-model
+    attributes:
+      label: Provider/Model
+      description: What provider and model were you using when the issue occurred?
+      placeholder: 'e.g., cline:anthropic/claude-sonnet-4.5, gemini:gemini-2.5-pro-exp-03-25'
+    validations:
+      required: false
+  - type: textarea
+    id: system-info
+    attributes:
+      label: System Information
+      description: What operating system and hardware are you using?
+      placeholder: |
+        Operating System: Windows 11, macOS Sonoma, Ubuntu 22.04, etc.
+        Hardware: CPU, GPU, RAM specifications if relevant
+        e.g.,
+        OS: Windows 11
+        CPU: Intel Core i7-11700K
+        GPU: NVIDIA GeForce RTX 3070
+        RAM: 32GB DDR4
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_contribution.yml

@@ -1,116 +0,0 @@
-name: 💡 Feature Proposal & Contribution
-description: Propose a new feature or improvement, and optionally offer to implement feature as a contributor
-labels: ["proposal"]
-body:
-    - type: markdown
-      attributes:
-          value: |
-              **Feature Proposal & Contribution for Cline**
-
-              Thank you for proposing a feature or improvement for Cline! This template helps us understand the problem, evaluate the solution, and coordinate implementation.
-
-              **For detailed proposals:** Please provide comprehensive information to enable fast prioritization and discussion.
-              **For contribution offers:** You can indicate your willingness to implement the feature yourself.
-
-              Before submitting:
-              - Search existing [Issues](https://github.com/cline/cline/issues) and [Discussions](https://github.com/cline/cline/discussions) to avoid duplicates
-              - Read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md) if you plan to contribute
-              - Don't start implementation until the proposal is reviewed and approved
-
-    - type: textarea
-      id: problem-description
-      attributes:
-          label: What problem does this solve?
-          description: |
-              Describe the problem clearly from a user's point of view. Focus on why this matters, who it affects, and when it occurs.
-
-              ✅ Good examples:
-              - "LLM provider returns 400 error when nearing the context window instead of truncating"
-              - "Submit button is invisible in dark mode"
-              - "Users can't easily share their Cline configurations with team members"
-
-              ❌ Avoid vague descriptions:
-              - "Performance is bad"
-              - "UI needs work"
-
-              Your description should include:
-              - Who is affected?
-              - When does it happen?
-              - What's the current vs expected behavior?
-              - What is the impact?
-          placeholder: Be specific about the problem, who it affects, and the impact.
-      validations:
-          required: true
-
-    - type: textarea
-      id: proposed-solution
-      attributes:
-          label: What's the proposed solution?
-          description: |
-              Describe how the problem should be solved. Be specific about UX, system behavior, and any flows that would change.
-
-              ✅ Good examples:
-              - "Add error handling immediately after attempting to create the llm stream and retry after manually truncating"
-              - "Update button styling to ensure contrast in all themes"
-              - "Add export/import functionality in settings with JSON format"
-
-              ❌ Avoid vague solutions:
-              - "Improve performance"
-              - "Fix the bug"
-
-              Your solution should include:
-              - What exactly will change?
-              - How will users interact with it?
-              - What's the expected outcome?
-          placeholder: Describe the proposed changes and how they solve the problem.
-      validations:
-          required: false
-
-    - type: dropdown
-      id: contribution-intent
-      attributes:
-          label: Are you interested in implementing this?
-          description: Let us know if you'd like to contribute to this feature
-          options:
-              - "No, just proposing the idea"
-              - "Yes, I'd like to implement this myself"
-              - "Yes, I'd like to collaborate with others"
-              - "Maybe, depending on complexity and guidance"
-      validations:
-          required: false
-
-    - type: textarea
-      id: implementation-approach
-      attributes:
-          label: Implementation approach (if contributing)
-          description: |
-              **Only fill this out if you selected "Yes" above.**
-
-              How do you plan to implement this? Include:
-              - High-level technical approach
-              - Files/components that would be affected
-              - Any new dependencies required
-              - Potential challenges or considerations you've identified
-
-              This helps us provide better guidance and ensures alignment before you start coding.
-          placeholder: "My implementation approach would be..."
-
-    - type: checkboxes
-      id: checklist
-      attributes:
-          label: Proposal checklist
-          options:
-              - label: I've checked for existing issues or related proposals
-                required: true
-              - label: I understand this needs review before implementation can start
-                required: true
-
-    - type: checkboxes
-      id: contribution-checklist
-      attributes:
-          label: Contribution checklist (if contributing)
-          description: Only check these if you plan to contribute
-          options:
-              - label: I've read the [Contributing Guide](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
-              - label: I'm willing to make changes based on feedback
-              - label: I understand the code review process and requirements

.github/copilot-instructions.md

@@ -0,0 +1,58 @@
+# Copilot Instructions for Cline
+
+This is a VS Code extension. Read `.clinerules/general.md` for tribal knowledge and nuanced patterns.
+
+## Architecture
+- **Core** (`src/`): `extension.ts` → `WebviewProvider` → `Controller` (single source of truth) → `Task` (agent loop).
+- **Webview** (`webview-ui/`): React/Vite app. State via `ExtensionStateContext.tsx`, synced through message passing.
+- **CLI** (`cli/`): React Ink terminal UI sharing core logic. Update CLI when changing webview features.
+- **Communication**: Protobuf-defined gRPC-like protocol over VS Code message passing. Schemas in `proto/`.
+- **MCP**: `src/services/mcp/McpHub.ts`.
+
+## Build & Test (Critical — non-obvious commands)
+- **Build**: `npm run compile` — NOT `npm run build`.
+- **Watch**: `npm run watch` (extension + webview).
+- **Protos**: `npm run protos` — run **immediately** after any `.proto` change. Generates into `src/shared/proto/`, `src/generated/`.
+- **Tests**: `npm run test:unit`. After prompt/tool changes: `UPDATE_SNAPSHOTS=true npm run test:unit`.
+
+## Protobuf RPC Workflow (4 steps)
+1. **Define** in `proto/cline/*.proto`. Naming: `PascalCaseService`, `camelCase` RPCs, `PascalCase` Messages. Use `common.proto` shared types for simple data.
+2. **Generate**: `npm run protos`.
+3. **Backend handler**: `src/core/controller/<domain>/`. 
+4. **Frontend call**: `UiServiceClient.myMethod(Request.create({...}))`.
+- Adding enums (e.g. `ClineSay`) → also update `src/shared/proto-conversions/cline-message.ts`.
+
+## Adding API Providers (silent failure risk)
+Three proto conversion updates are **required** or the provider silently resets to Anthropic:
+1. `proto/cline/models.proto` — add to `ApiProvider` enum.
+2. `convertApiProviderToProto()` in `src/shared/proto-conversions/models/api-configuration-conversion.ts`.
+3. `convertProtoToApiProvider()` in the same file.
+
+Also update: `src/shared/api.ts`, `src/shared/providers/providers.json`, `src/core/api/index.ts`, `webview-ui/.../providerUtils.ts`, `webview-ui/.../validate.ts`, `webview-ui/.../ApiOptions.tsx`, and `cli/src/components/ModelPicker.tsx`.
+
+For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/model-utils.ts` and set `apiFormat: ApiFormat.OPENAI_RESPONSES` on models.
+
+## Adding Tools to System Prompt (5+ file chain)
+1. Add enum to `ClineDefaultTool` in `src/shared/tools.ts`.
+2. Create definition in `src/core/prompts/system-prompt/tools/` (export `[GENERIC]` minimum).
+3. Register in `src/core/prompts/system-prompt/tools/init.ts`.
+4. Whitelist in `src/core/prompts/system-prompt/variants/*/config.ts` for each model family.
+5. Handler in `src/core/task/tools/handlers/`, wire in `ToolExecutor.ts`.
+6. If tool has UI: add `ClineSay` enum in proto → `ExtensionMessage.ts` → `cline-message.ts` → `ChatRow.tsx`.
+7. Regenerate snapshots: `UPDATE_SNAPSHOTS=true npm run test:unit`.
+
+## Modifying System Prompt
+Modular: `components/` (shared) + `variants/` (model-specific) + `templates/` (`{{PLACEHOLDER}}`). Variants override components via `componentOverrides` in `config.ts` or custom `template.ts`. XS variant is heavily condensed inline. Always regenerate snapshots after changes.
+
+## Global State Keys (silent failure risk)
+Adding a key requires: type in `src/shared/storage/state-keys.ts`, read via `context.globalState.get()` in `src/core/storage/utils/state-helpers.ts` `readGlobalStateFromDisk()`, and add to return object. Missing the `.get()` call compiles fine but value is always `undefined`.
+
+## Slash Commands (3 places)
+- `src/core/slash-commands/index.ts` — definitions.
+- `src/core/prompts/commands.ts` — system prompt integration.
+- `webview-ui/src/utils/slash-commands.ts` — webview autocomplete.
+
+## Conventions
+- **Paths**: Always use `src/utils/path` helpers (`toPosixString`) for cross-platform compatibility.
+- **Logging**: `src/shared/services/Logger.ts`.
+- **Feature flags**: See PR #7566 as reference pattern.

.github/pull_request_template.md

@@ -2,15 +2,14 @@
 Thank you for contributing to Cline!
 
 ⚠️ Important: Before submitting this PR, please ensure you have:
-- Opened an issue and discussed your proposed changes with the community / contributors
-- Received approval from a core Cline contributor prior to proceeding with the implementation
-- Link the associated issue in the "Related Issue" section
+- For feature requests: Created a discussion in our Feature Requests discussions board https://github.com/cline/cline/discussions/categories/feature-requests and received approval from core maintainers before implementation
+- For all changes: Link the associated issue/discussion in the "Related Issue" section below
 
 Limited exceptions:
-Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly.
+Small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality may be submitted directly without prior discussion.
 
 Why this requirement?
-We deeply appreciate all community contributions - they are the core reason we're able to operate successfully and keep innovating! We welcome community input and want to make it as easy as possible for people to submit quality work. This process helps our core maintainers review new ideas faster and saves contributor time by ensuring you have the go-ahead before spending time on implementation.
+We deeply appreciate all community contributions - they are essential to Cline's success! To ensure the best use of everyone's time and maintain project direction, we use our Feature Requests discussions board to gauge community interest and validate feature ideas before implementation begins. This helps us focus development efforts on features that will benefit the most users.
 -->
 
 ### Related Issue
@@ -61,7 +60,6 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
 -   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
--   [ ] I have created a changeset using `npm run changeset` (required for user-facing changes)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/scripts/overwrite_changeset_changelog.py

@@ -1,79 +0,0 @@
-"""
-This script updates a specific version's release notes section in CHANGELOG.md with new content
-or reformats existing content.
-
-The script:
-1. Takes a version number, changelog path, and optionally new content as input from environment variables
-2. Finds the section in the changelog for the specified version
-3. Either:
-   a) Replaces the content with new content if provided, or
-   b) Reformats existing content by:
-      - Removing the first two lines of the changeset format
-      - Ensuring version numbers are wrapped in square brackets
-4. Writes the updated changelog back to the file
-
-Environment Variables:
-    CHANGELOG_PATH: Path to the changelog file (defaults to 'CHANGELOG.md')
-    VERSION: The version number to update/format
-    PREV_VERSION: The previous version number (used to locate section boundaries)
-    NEW_CONTENT: Optional new content to insert for this version
-"""
-
-#!/usr/bin/env python3
-
-import os
-
-CHANGELOG_PATH = os.environ.get("CHANGELOG_PATH", "CHANGELOG.md")
-VERSION = os.environ['VERSION']
-PREV_VERSION = os.environ.get("PREV_VERSION", "")
-NEW_CONTENT = os.environ.get("NEW_CONTENT", "")
-
-def overwrite_changelog_section(changelog_text: str, new_content: str):
-    # Find the section for the specified version
-    version_pattern = f"## {VERSION}\n"
-    unformmatted_prev_version_pattern = f"## {PREV_VERSION}\n"
-    prev_version_pattern = f"## [{PREV_VERSION}]\n"
-    print(f"latest version: {VERSION}")
-    print(f"prev_version: {PREV_VERSION}")
-
-    notes_start_index = changelog_text.find(version_pattern) + len(version_pattern)
-    notes_end_index = changelog_text.find(prev_version_pattern, notes_start_index) if PREV_VERSION and (prev_version_pattern in changelog_text or unformmatted_prev_version_pattern in changelog_text) else len(changelog_text)
-
-    if new_content:
-        return changelog_text[:notes_start_index] + f"{new_content}\n" + changelog_text[notes_end_index:]
-    else:
-        changeset_lines = changelog_text[notes_start_index:notes_end_index].split("\n")
-        filtered_lines = []
-        for line in changeset_lines:
-            # If the previous line is a changeset format
-            if len(filtered_lines) > 1 and filtered_lines[-1].startswith("### "):
-                # Remove the last two lines from the filted_lines
-                filtered_lines.pop()
-                filtered_lines.pop()
-            else:
-                filtered_lines.append(line.strip())
-
-        # Prepend a new line to the first line of filtered_lines
-        if filtered_lines:
-            filtered_lines[0] = "\n" + filtered_lines[0]
-
-        # Print filted_lines wiht a "\n" at the end of each line
-        for line in filtered_lines:
-            print(line.strip())
-
-        parsed_lines = "\n".join(line for line in filtered_lines)
-        updated_changelog = changelog_text[:notes_start_index] + parsed_lines + changelog_text[notes_end_index:]
-        return updated_changelog
-
-with open(CHANGELOG_PATH, 'r') as f:
-    changelog_content = f.read()
-
-new_changelog = overwrite_changelog_section(changelog_content, NEW_CONTENT)
-# print("----------------------------------------------------------------------------------")
-# print(new_changelog)
-# print("----------------------------------------------------------------------------------")
-# Write back to CHANGELOG.md
-with open(CHANGELOG_PATH, 'w') as f:
-    f.write(new_changelog)
-
-print(f"{CHANGELOG_PATH} updated successfully!")

.github/workflows/changeset-converter.yml

@@ -1,113 +0,0 @@
-name: Changeset Converter
-run-name: Changeset Conversion
-
-on:
-    workflow_dispatch:
-    pull_request:
-        types: [closed]
-
-env:
-    REPO_PATH: ${{ github.repository }}
-    GIT_REF: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || 'main' }}
-    NODE_VERSION: 20.18.1
-
-jobs:
-    # Job 1: Create version bump PR when changesets are merged to main
-    changeset-pr-version-bump:
-        if: |
-            github.event_name == 'workflow_dispatch' ||
-            (
-                github.event_name == 'pull_request' &&
-                github.event.pull_request.merged == true &&
-                github.event.pull_request.base.ref == 'main' &&
-                github.actor != 'github-actions'
-            )
-        runs-on: ubuntu-latest
-        permissions:
-            contents: write
-            pull-requests: write
-        steps:
-            - name: Check user for team affiliation
-              id: team_check
-              if: github.event_name == 'workflow_dispatch'
-              uses: morfien101/actions-authorized-user@4a3cfbf0bcb3cafe4a71710a278920c5d94bb38b
-              with:
-                  username: ${{ github.actor }}
-                  org: ${{ github.repository_owner }}
-                  team: "deployer"
-                  github_token: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: Check if user is authorized
-              if: github.event_name == 'workflow_dispatch'
-              run: |
-                  if [ "${{ steps.team_check.outputs.authorized }}" != "true" ]; then
-                      echo "User is not authorized to run this workflow."
-                      exit 1
-                  fi
-
-            - name: Git Checkout
-              uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0
-                  ref: ${{ env.GIT_REF }}
-
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: ${{ env.NODE_VERSION }}
-                  cache: "npm"
-
-            - name: Install Dependencies
-              run: npm install changeset
-
-            # Check if there are any new changesets to process
-            - name: Check for changesets
-              id: check-changesets
-              run: |
-                  NEW_CHANGESETS=$(find .changeset -name "*.md" ! -name "README.md" | wc -l | tr -d ' ')
-                  echo "Changesets diff with previous version: $NEW_CHANGESETS"
-                  echo "new_changesets=$NEW_CHANGESETS" >> $GITHUB_OUTPUT
-
-            # Create version bump PR using changesets/action if there are new changesets
-            - name: Create Changeset Pull Request
-              if: steps.check-changesets.outputs.new_changesets != '0'
-              uses: changesets/action@v1
-              with:
-                  commit: "changeset version bump"
-                  title: "Changeset version bump"
-                  version: npm run version-packages # This performs the changeset version bump
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-            # Get current and previous versions to edit changelog entry
-            - name: Get version
-              id: get_version
-              run: |
-                  VERSION=$(git show HEAD:package.json | jq -r '.version')
-                  echo "version=$VERSION" >> $GITHUB_OUTPUT
-                  PREV_VERSION=$(git show origin/main:package.json | jq -r '.version')
-                  echo "prev_version=$PREV_VERSION" >> $GITHUB_OUTPUT
-                  echo "version=$VERSION"
-                  echo "prev_version=$PREV_VERSION"
-
-            # Update CHANGELOG.md with proper format
-            - name: Update Changelog Format
-              env:
-                  VERSION: ${{ steps.get_version.outputs.version }}
-                  PREV_VERSION: ${{ steps.get_version.outputs.prev_version }}
-              run: python .github/scripts/overwrite_changeset_changelog.py
-
-            # Commit and push changelog updates
-            - name: Push Changelog updates to Pull Request
-              run: |
-                  git config user.name "github-actions"
-                  git config user.email github-actions@github.com
-                  echo "Running git add and commit..."
-                  git add CHANGELOG.md
-                  git commit -m "Updating CHANGELOG.md format"
-                  git status
-                  echo "--------------------------------------------------------------------------------"
-                  echo "Pushing to remote..."
-                  echo "--------------------------------------------------------------------------------"
-                  CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
-                  git push origin $CURRENT_BRANCH

.github/workflows/cli-tui-tests.yml

@@ -0,0 +1,83 @@
+name: CLI TUI Tests
+
+on:
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  cli-tui-tests:
+    name: CLI TUI Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Install dependencies
+        run: npm ci
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build CLI
+        run: npm run cli:build
+
+      - name: Run TUI Tests
+        id: tui_tests
+        run: |
+          npm run test:e2e:cli:tui 2>&1 | tee tui-test-output.log
+          exit_code=${PIPESTATUS[0]}
+          echo "tui_exit_code=$exit_code" >> $GITHUB_OUTPUT
+          exit $exit_code
+
+      - name: Write failure summary
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        run: |
+          echo "## ❌ CLI TUI Tests Failed" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "**Step outcome:** \`${{ steps.tui_tests.outcome }}\`" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### Test Output" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          if [ -f tui-test-output.log ]; then
+            cat tui-test-output.log >> $GITHUB_STEP_SUMMARY
+          else
+            echo "(no test output captured — process may have been killed before output was flushed)" >> $GITHUB_STEP_SUMMARY
+          fi
+          echo '```' >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "### Debugging" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- **TUI traces** are attached as artifacts below — download and inspect them to see terminal state at the point of failure." >> $GITHUB_STEP_SUMMARY
+          echo "- **To view a trace replay/Run a TUI Trace: ** run \`npx tui-test show-trace path/to/trace/file\` in your terminal" >> $GITHUB_STEP_SUMMARY
+          echo "- **Full test log** is also attached as an artifact." >> $GITHUB_STEP_SUMMARY
+          echo "- Tests run with \`retries: 2\` so any failure shown is a consistent failure, not a flake." >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload TUI traces
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        uses: actions/upload-artifact@v4
+        with:
+          name: tui-test-traces
+          path: tests/e2e/cli/tui-traces/
+          retention-days: 14
+          if-no-files-found: warn
+
+      - name: Upload test log
+        if: always() && steps.tui_tests.outcome != 'success' && steps.tui_tests.outcome != 'skipped'
+        uses: actions/upload-artifact@v4
+        with:
+          name: tui-test-log
+          path: tui-test-output.log
+          retention-days: 14
+          if-no-files-found: warn

.github/workflows/cline-evals-regression.yml

@@ -0,0 +1,85 @@
+name: Smoke Tests
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'src/core/**'
+      - 'src/shared/**'
+      - 'proto/**'
+      - 'evals/**'
+      - '.github/workflows/cline-evals-regression.yml'
+  pull_request:
+    paths:
+      - 'src/core/**'
+      - 'src/shared/**'
+      - 'proto/**'
+      - 'evals/**'
+      - '.github/workflows/cline-evals-regression.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: smoke-tests-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  smoke-tests:
+    name: Smoke Tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build and install CLI
+        run: |
+          npm run protos
+          cd cli && npm install && npm run build && npm link
+          echo "$(npm config get prefix)/bin" >> $GITHUB_PATH
+
+      - name: Verify CLI
+        run: cline --version
+
+      - name: Run smoke tests
+        env:
+          CLINE_API_KEY: ${{ secrets.CLINE_API_KEY }}
+        run: |
+          cline auth -p cline -k "$CLINE_API_KEY" -m "anthropic/claude-sonnet-4.5"
+          max_attempts=3
+          for attempt in $(seq 1 $max_attempts); do
+            echo "::group::Attempt $attempt of $max_attempts"
+            if npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1 --parallel; then
+              echo "::endgroup::"
+              echo "Smoke tests passed on attempt $attempt"
+              exit 0
+            fi
+            echo "::endgroup::"
+            if [ $attempt -lt $max_attempts ]; then
+              echo "::warning::Smoke tests failed on attempt $attempt, retrying..."
+              sleep 10
+            fi
+          done
+          echo "::error::Smoke tests failed after $max_attempts attempts"
+          exit 1
+
+      - name: Generate summary
+        if: always()
+        run: cat evals/smoke-tests/results/latest/summary.md >> $GITHUB_STEP_SUMMARY
+
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: smoke-test-results-${{ github.run_id }}
+          path: evals/smoke-tests/results/latest/
+          retention-days: 30

.github/workflows/codespell.yml

@@ -1,28 +0,0 @@
-# Codespell configuration is within .codespellrc
----
-name: Codespell
-
-on:
-    push:
-        branches: [main]
-    pull_request:
-        branches: [main]
-
-permissions:
-    contents: read
-
-jobs:
-    codespell:
-        if: false
-        name: Check for spelling errors
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: Checkout
-              uses: actions/checkout@v4
-            - name: Annotate locations with typos
-              uses: codespell-project/codespell-problem-matcher@v1
-            - name: Codespell
-              uses: codespell-project/actions-codespell@v2
-              with:
-                  only_warn: 1

.github/workflows/e2e.yml

@@ -0,0 +1,111 @@
+name: E2E Tests
+
+on:
+    push:
+        branches:
+            - main
+    pull_request:
+        types: [opened, reopened, synchronize, ready_for_review]
+    workflow_dispatch:
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+    cancel-in-progress: true
+
+jobs:
+    matrix_prep:
+        runs-on: ubuntu-latest
+        outputs:
+            matrix: ${{ steps.set-matrix.outputs.matrix }}
+        steps:
+            - id: set-matrix
+              run: |
+                  echo 'matrix=[{"runner":"ubuntu"},{"runner":"windows"},{"runner":"macos"}]' >> $GITHUB_OUTPUT
+
+    e2e:
+        needs: matrix_prep
+        strategy:
+            fail-fast: false
+            matrix:
+                include: ${{ fromJson(needs.matrix_prep.outputs.matrix) }}
+        runs-on: ${{ matrix.runner }}-latest
+        timeout-minutes: 20
+        permissions:
+            id-token: write
+            contents: read
+        steps:
+            - uses: actions/checkout@v4
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+
+            # Cache root dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache root dependencies
+              uses: actions/cache@v4
+              id: root-cache
+              with:
+                  path: node_modules
+                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
+
+            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
+            - name: Cache webview-ui dependencies
+              uses: actions/cache@v4
+              id: webview-cache
+              with:
+                  path: webview-ui/node_modules
+                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+
+            # Cache VS Code installation
+            - name: Cache VS Code
+              uses: actions/cache@v4
+              id: vscode-cache
+              with:
+                  path: .vscode-test
+                  key: vscode-${{ runner.os }}-stable-${{ hashFiles('.vscode-test.mjs', 'package.json') }}
+                  restore-keys: |
+                      vscode-${{ runner.os }}-stable-
+
+            # Cache Playwright browsers
+            - name: Cache Playwright browsers
+              uses: actions/cache@v4
+              id: playwright-cache
+              with:
+                  path: |
+                      ~/.cache/ms-playwright
+                      ~/Library/Caches/ms-playwright
+                      ~/AppData/Local/ms-playwright
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+                  restore-keys: |
+                      playwright-browsers-${{ runner.os }}-
+
+            - name: Install root dependencies
+              run: npm ci
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Install webview-ui dependencies
+              run: cd webview-ui && npm ci
+
+            - name: Install vsce
+              run: npm install -g @vscode/vsce
+
+            - name: Install xvfb on Linux
+              if: matrix.runner == 'ubuntu'
+              run: sudo apt-get update && sudo apt-get install -y xvfb
+
+            # Run optimized E2E tests (eliminates redundant builds)
+            - name: Run E2E tests - Linux
+              if: matrix.runner == 'ubuntu'
+              run: xvfb-run -a npm run test:e2e:optimal
+
+            - name: Run E2E tests - Non-Linux
+              if: matrix.runner != 'ubuntu'
+              run: npm run test:e2e:optimal
+
+            - uses: actions/upload-artifact@v4
+              if: ${{ failure() }}
+              with:
+                  name: playwright-recordings-${{ matrix.runner }}
+                  path: |
+                      test-results/playwright/

.github/workflows/label-jetbrains-issues.yml

@@ -0,0 +1,53 @@
+name: Auto-label Issues
+
+on:
+  issues:
+    types: [opened, edited]
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const body = context.payload.issue.body || '';
+            const labels = context.payload.issue.labels.map(l => l.name);
+            
+            // Check if JetBrains Plugin is selected
+            if (body.match(/###\s*Plugin Type\s*\n+JetBrains Plugin/i)) {
+              if (!labels.includes('JetBrains')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['JetBrains']
+                });
+              }
+            }
+
+            // Check if VSCode Extension is selected
+            if (body.match(/###\s*Plugin Type\s*\n+VSCode Extension/i)) {
+              if (!labels.includes('VS Code')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['VS Code']
+                });
+              }
+            }
+
+            // Check if CLI is selected
+            if (body.match(/###\s*Plugin Type\s*\n+CLI/i)) {
+              if (!labels.includes('CLI')) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: context.issue.number,
+                  labels: ['CLI']
+                });
+              }
+            }

.github/workflows/npm-main.yaml

@@ -0,0 +1,93 @@
+name: Publish NPM Release
+
+on:
+  workflow_call:
+    inputs:
+      confirm_publish:
+        description: 'Type "publish" to confirm you want to publish to NPM'
+        required: true
+        type: string
+
+permissions:
+  contents: write # Required for pushing tags
+  id-token: write # Required for npm trusted publishing (OIDC)
+  checks: write # Required by test workflow
+  pull-requests: write # Required by test workflow
+
+jobs:
+  test:
+    uses: ./.github/workflows/test.yml
+
+  publish-npm-release:
+    needs: test
+    name: Publish Cline CLI to NPM
+    if: github.repository == 'cline/cline' && github.ref == 'refs/heads/main' && inputs.confirm_publish == 'publish'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install root dependencies and CLI dependencies
+        run: npm ci --include=optional # this will also install cli deps because "cli" in included in root package.json workspaces field
+
+      - name: Generate Protos
+        run: npm run protos
+
+      - name: Read release version
+        id: version
+        run: |
+          # Read version from cli/package.json
+          VERSION=$(node -p "require('./cli/package.json').version")
+          echo "Release version: $VERSION"
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Build standalone NPM package
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          CLINE_ENVIRONMENT: production
+          OTEL_TELEMETRY_ENABLED: "1"
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+        run: node scripts/package-npm.mjs
+
+      - name: Verify build output
+        run: |
+          echo "Checking dist-standalone directory..."
+          ls -la dist-standalone/
+
+          echo "Verifying CLI binaries..."
+          ls -lh cli/bin/cline-* || echo "Warning: CLI binaries not found"
+
+          echo "Checking package.json in dist-standalone..."
+          cat dist-standalone/package.json | grep version
+
+      - name: Publish to NPM with latest tag
+        run: |
+          echo "Publishing version ${{ steps.version.outputs.version }} to NPM with tag 'latest'..."
+          cd dist-standalone
+          npm publish --tag latest --access public
+
+      - name: Tag release
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag "v${{ steps.version.outputs.version }}-cli"
+          git push origin "v${{ steps.version.outputs.version }}-cli"
+
+      - name: Summary
+        run: |
+          echo "✅ Successfully published cline@${{ steps.version.outputs.version }} to NPM with tag 'latest'"
+          echo ""
+          echo "📦 Install with: npm install -g cline"
+          echo "🔗 NPM: https://www.npmjs.com/package/cline/v/${{ steps.version.outputs.version }}"

.github/workflows/npm-nightly.yaml

@@ -0,0 +1,134 @@
+name: Publish NPM Nightly
+
+on:
+  workflow_call:
+    inputs:
+      force_publish:
+        description: "Force publish even if there are no commits in the last 24 hours"
+        required: false
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+  id-token: write # Required for npm trusted publishing (OIDC)
+  checks: write # Required by test workflow
+  pull-requests: write # Required by test workflow
+
+jobs:
+  test:
+    uses: ./.github/workflows/test.yml
+
+  publish-npm-nightly:
+    needs: test
+    name: Publish Cline CLI (Nightly) to NPM
+    if: github.repository == 'cline/cline' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Check for recent commits
+        id: check_commits
+        run: |
+          if [ "${{ inputs.force_publish }}" = "true" ]; then
+            echo "force_publish enabled, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          if [ $(git rev-list --count HEAD --since="24 hours ago") -eq 0 ]; then
+            echo "No commits in last 24 hours, skipping publish"
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "Found recent commits, proceeding with publish"
+            echo "skip=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Setup Node.js
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: actions/setup-node@v4
+        with:
+          node-version: "24.x"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install root dependencies and CLI dependencies
+        if: steps.check_commits.outputs.skip != 'true'
+        run: npm ci --include=optional # this will also install cli deps because "cli" in included in root package.json workspaces field
+
+      - name: Generate Protos
+        if: steps.check_commits.outputs.skip != 'true'
+        run: npm run protos
+
+      - name: Generate nightly version with timestamp
+        if: steps.check_commits.outputs.skip != 'true'
+        id: version
+        run: |
+          # Read base version from cli/package.json (e.g., "2.0.0")
+          BASE_VERSION=$(node -p "require('./cli/package.json').version")
+
+          # Generate timestamp (Unix epoch seconds)
+          TIMESTAMP=$(date +%s)
+
+          # Create unique nightly version: 1.0.9-nightly.1736365200
+          VERSION="${BASE_VERSION}-nightly.${TIMESTAMP}"
+
+          echo "Base version: $BASE_VERSION"
+          echo "Generated nightly version: $VERSION"
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Update cli/package.json with nightly version
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          # Update version with timestamp-based nightly version
+          node -e "
+            const fs = require('fs');
+            const pkg = JSON.parse(fs.readFileSync('cli/package.json', 'utf8'));
+            pkg.version = '${{ steps.version.outputs.version }}';
+            fs.writeFileSync('cli/package.json', JSON.stringify(pkg, null, '\t'));
+          "
+
+          echo "Using version ${{ steps.version.outputs.version }} for build"
+          cat cli/package.json | grep '"version"'
+
+      - name: Build and package CLI
+        if: steps.check_commits.outputs.skip != 'true'
+        env:
+          TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+          ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+          CLINE_ENVIRONMENT: production
+          OTEL_TELEMETRY_ENABLED: "1"
+          OTEL_METRICS_EXPORTER: otlp
+          OTEL_LOGS_EXPORTER: otlp
+          OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+          OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+          OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+        run: node scripts/package-npm.mjs
+
+      - name: Verify build output
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          echo "Checking dist-standalone directory..."
+          ls -la dist-standalone/
+
+          echo "Verifying CLI binaries..."
+          ls -lh cli/bin/cline-* || echo "Warning: CLI binaries not found"
+
+          echo "Checking package.json in dist-standalone..."
+          cat dist-standalone/package.json | grep version
+
+      - name: Publish to NPM with nightly tag
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          echo "Publishing version ${{ steps.version.outputs.version }} to NPM with tag 'nightly'..."
+          cd dist-standalone
+          npm publish --tag nightly --access public
+
+      - name: Summary
+        if: steps.check_commits.outputs.skip != 'true'
+        run: |
+          echo "✅ Successfully published cline@${{ steps.version.outputs.version }} to NPM with tag 'nightly'"
+          echo ""
+          echo "📦 Install with: npm install -g cline@nightly"
+          echo "🔗 NPM: https://www.npmjs.com/package/cline/v/${{ steps.version.outputs.version }}"

.github/workflows/pack-cli.yml

@@ -0,0 +1,215 @@
+# Build and Pack CLI
+#
+# Builds a CLI tarball from any branch/commit and publishes it as a GitHub Release.
+# Requires write access to the repository (maintainers/collaborators only).
+#
+# Security: Split into two jobs to isolate untrusted build code from write tokens.
+# The build job runs arbitrary ref code with zero permissions. The release job
+# only runs trusted GitHub Actions with write scope.
+#
+# Usage (helper script, auto-detects current branch):
+#   ./scripts/build-cli-artifact.sh
+#   ./scripts/build-cli-artifact.sh feature/my-changes
+#   ./scripts/build-cli-artifact.sh feature/my-changes 1234  # comments on PR
+#
+# Usage (gh CLI directly):
+#   gh workflow run pack-cli.yml -f ref=main
+#   gh workflow run pack-cli.yml -f ref=abc123 -f pr_number=1234
+#
+# Install the built CLI (no auth required):
+#   npm install -g https://github.com/cline/cline/releases/download/cli-build-<sha>/cline-<ver>.tgz
+#
+# Find releases:
+#   gh release list --limit 10
+
+name: Build and Pack CLI
+
+permissions:
+  contents: read
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: 'Branch, tag, or commit SHA to build (leave empty for default branch)'
+        required: false
+        type: string
+      pr_number:
+        description: 'PR number to comment on with install instructions (optional)'
+        required: false
+        type: number
+
+jobs:
+  # ── Build job: runs untrusted ref code with ZERO permissions ──
+  build:
+    name: Build CLI
+    runs-on: ubuntu-latest
+    permissions: {}
+    outputs:
+      commit_sha: ${{ steps.commit.outputs.sha }}
+      tarball: ${{ steps.pack.outputs.tarball }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+          persist-credentials: false
+
+      - name: Get commit SHA
+        id: commit
+        run: |
+          COMMIT_SHA=$(git rev-parse --short HEAD)
+          echo "sha=$COMMIT_SHA" >> $GITHUB_OUTPUT
+          echo "Building from commit: $COMMIT_SHA"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20.x"
+
+      - name: Install dependencies
+        run: npm ci --include=optional
+
+      - name: Generate Protos
+        run: npm run protos
+
+      - name: Build standalone package
+        run: node scripts/package-npm.mjs
+
+      - name: Create Tarball
+        id: pack
+        run: |
+          cd dist-standalone
+          TARBALL=$(npm pack)
+          echo "tarball=$TARBALL" >> $GITHUB_OUTPUT
+          echo "Created tarball: $TARBALL"
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: cli-tarball
+          path: dist-standalone/*.tgz
+
+  # ── Release job: only trusted Actions code, with write permissions ──
+  release:
+    name: Release CLI
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: cli-tarball
+          path: dist-standalone
+
+      - name: Create GitHub Release
+        id: create_release
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const fs = require('fs');
+            const path = require('path');
+            const commit = '${{ needs.build.outputs.commit_sha }}';
+            const tarball = '${{ needs.build.outputs.tarball }}';
+
+            // Delete existing release/tag if re-running for the same commit
+            const tagName = `cli-build-${commit}`;
+            try {
+              const existing = await github.rest.repos.getReleaseByTag({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                tag: tagName
+              });
+              await github.rest.repos.deleteRelease({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                release_id: existing.data.id
+              });
+              await github.rest.git.deleteRef({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                ref: `tags/${tagName}`
+              });
+              core.info(`Deleted existing release for ${tagName}`);
+            } catch (e) {
+              // Release doesn't exist yet, that's fine
+            }
+
+            // Create a release
+            const release = await github.rest.repos.createRelease({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              tag_name: tagName,
+              name: `CLI Build (${commit})`,
+              body: `Automated CLI build from commit ${commit}\n\nInstall with:\n\`\`\`bash\nnpm install -g https://github.com/${context.repo.owner}/${context.repo.repo}/releases/download/${tagName}/${tarball}\n\`\`\``,
+              draft: false,
+              prerelease: true
+            });
+
+            // Upload the tarball as a release asset
+            const tarballPath = path.join('dist-standalone', tarball);
+            const tarballData = fs.readFileSync(tarballPath);
+
+            await github.rest.repos.uploadReleaseAsset({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              release_id: release.data.id,
+              name: tarball,
+              data: tarballData
+            });
+
+            const downloadUrl = `https://github.com/${context.repo.owner}/${context.repo.repo}/releases/download/${tagName}/${tarball}`;
+            core.setOutput('release_url', release.data.html_url);
+            core.setOutput('download_url', downloadUrl);
+
+      - name: Comment on PR with download instructions
+        if: inputs.pr_number != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const commit = '${{ needs.build.outputs.commit_sha }}';
+            const releaseUrl = '${{ steps.create_release.outputs.release_url }}';
+            const downloadUrl = '${{ steps.create_release.outputs.download_url }}';
+            const prNumber = ${{ inputs.pr_number || 0 }};
+            if (!prNumber) return;
+
+            const comment = `## 📦 CLI Build Ready
+
+            A CLI build has been created for commit \`${commit}\`.
+
+            ### Install Directly from URL (No Authentication Required!)
+
+            \`\`\`bash
+            npm install -g ${downloadUrl}
+            \`\`\`
+
+            ### Alternative: Download and Install
+
+            \`\`\`bash
+            curl -L ${downloadUrl} -o cline.tgz
+            npm install -g ./cline.tgz
+            \`\`\`
+
+            📦 [View Release](${releaseUrl})
+            `;
+
+            await github.rest.issues.createComment({
+              issue_number: prNumber,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: comment
+            });
+
+      - name: Summary
+        run: |
+          echo "✅ CLI build complete!"
+          echo ""
+          echo "📦 Release: ${{ steps.create_release.outputs.release_url }}"
+          echo "🔗 Download URL: ${{ steps.create_release.outputs.download_url }}"
+          echo ""
+          echo "Install from anywhere (no authentication required):"
+          echo "  npm install -g ${{ steps.create_release.outputs.download_url }}"

.github/workflows/publish-cli-trusted.yaml

@@ -0,0 +1,60 @@
+name: Publish CLI (Trusted)
+
+on:
+  schedule:
+    - cron: "0 12 * * *" # 4 AM PST (UTC-8) = 12 UTC
+  workflow_dispatch:
+    inputs:
+      publish_target:
+        description: "Which publish flow to run"
+        required: true
+        default: "main"
+        type: choice
+        options:
+          - main
+          - nightly
+      confirm_publish:
+        description: 'Required when publish_target=main. Type "publish" to confirm release publish.'
+        required: false
+        type: string
+      force_nightly_publish:
+        description: "Force nightly publish even with no commits in last 24h"
+        required: false
+        type: boolean
+        default: false
+
+permissions:
+  id-token: write # Required for npm trusted publishing (OIDC)
+  contents: write # Required because npm-main creates/pushes git tags
+  checks: write # Required by nested reusable test workflow
+  pull-requests: write # Required by nested reusable test workflow
+
+jobs:
+  cli-tui-tests:
+    uses: ./.github/workflows/cli-tui-tests.yml
+
+  publish-main:
+    needs: cli-tui-tests
+    if: |
+      github.repository == 'cline/cline' && (
+        github.event_name == 'workflow_dispatch' &&
+        github.event.inputs.publish_target == 'main' &&
+        github.event.inputs.confirm_publish == 'publish' &&
+        !endsWith(github.actor, '[bot]')
+      )
+    uses: ./.github/workflows/npm-main.yaml
+    secrets: inherit
+    with:
+      confirm_publish: ${{ github.event.inputs.confirm_publish }}
+
+  publish-nightly:
+    needs: cli-tui-tests
+    if: |
+      github.repository == 'cline/cline' && (
+        github.event_name == 'schedule' ||
+        (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_target == 'nightly')
+      )
+    uses: ./.github/workflows/npm-nightly.yaml
+    secrets: inherit
+    with:
+      force_publish: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.force_nightly_publish == 'true' }}

.github/workflows/publish-nightly.yml

@@ -0,0 +1,76 @@
+name: "Publish Nightly Release"
+
+on:
+  schedule:
+    - cron: '0 12 * * *'  # 4 AM PST (UTC-8) = 12 UTC
+  workflow_dispatch:
+
+permissions:
+    contents: write
+    packages: write
+    checks: write
+    pull-requests: write
+
+jobs:
+    test:
+        uses: ./.github/workflows/test.yml
+
+    publish:
+        needs: test
+        name: Publish Cline (Nightly) Extension
+        if: github.repository == 'cline/cline'
+        runs-on: ubuntu-latest
+        environment: PublishNightly
+
+        steps:
+            - uses: actions/checkout@v4
+              with:
+                  lfs: true
+
+            - name: Check for recent commits
+              run: |
+                if [ $(git rev-list --count HEAD --since="24 hours ago") -eq 0 ]; then
+                  echo "No commits in last 24 hours, exiting"
+                  exit 0
+                fi
+                echo "Found recent commits, proceeding with build"
+                
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                  # Keep publish environment aligned with test workflow/tooling lockfile expectations.
+                  # Newer LTS (Node 24 / npm 11) can make `npm list` fail with ELSPROBLEMS during vsce packaging.
+                  node-version: 22
+
+            - name: Install root dependencies
+              run: npm ci --include=optional
+
+            - name: Install webview-ui dependencies
+              run: cd webview-ui && npm ci --include=optional
+
+            - name: Install Publishing Tools
+              run: npm install -g @vscode/vsce ovsx
+
+            - name: Verify LFS media assets are resolved
+              run: |
+                  FILE="webview-ui/src/assets/cline_kanban_demo.webm"
+                  if grep -q "git-lfs.github.com/spec/v1" "$FILE"; then
+                    echo "Error: $FILE is still a Git LFS pointer in CI checkout"
+                    exit 1
+                  fi
+
+            - name: Publish Extension as Pre-release
+              env:
+                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
+                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+                  CLINE_ENVIRONMENT: production
+                  # OpenTelemetry production defaults (can be overridden at runtime)
+                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
+              run: npm run publish:marketplace:nightly

.github/workflows/publish.yml

@@ -11,8 +11,13 @@ on:
                 options:
                     - pre-release
                     - release
+            auto_create_tag_from_main:
+                description: "Auto-create and push the provided tag from the tested main commit (recommended)"
+                required: true
+                default: true
+                type: boolean
             tag:
-                description: "Enter existing tag to publish (e.g., v3.1.2)"
+                description: "Tag to publish (required in both modes, e.g., v3.1.2)"
                 required: true
                 type: string
 
@@ -35,36 +40,80 @@ jobs:
         steps:
             - uses: actions/checkout@v4
               with:
-                  ref: ${{ github.event.inputs.tag }}
+                  ref: main
+                  fetch-depth: 0
+                  fetch-tags: true
+                  lfs: true
+
+            - name: Resolve Release Tag
+              id: resolve_tag
+              run: |
+                  TAG="${{ github.event.inputs.tag }}"
+                  AUTO_CREATE="${{ github.event.inputs.auto_create_tag_from_main }}"
+                  TESTED_SHA="${{ github.sha }}"
+                  WORKFLOW_REF="${{ github.ref }}"
+
+                  if [[ -z "$TAG" ]]; then
+                    echo "Error: tag input is required"
+                    exit 1
+                  fi
+
+                  if [[ ! "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$ ]]; then
+                    echo "Error: tag must match vX.Y.Z (optionally with -suffix or .suffix)"
+                    exit 1
+                  fi
+                  TAG_REF="refs/tags/$TAG"
+
+                  git fetch origin main --tags
+
+                  if [[ "$AUTO_CREATE" == "true" ]]; then
+                    if [[ "$WORKFLOW_REF" != "refs/heads/main" ]]; then
+                      echo "Error: auto-create mode requires dispatching from main (current ref: $WORKFLOW_REF)"
+                      exit 1
+                    fi
+                    echo "Auto-create enabled. Using tested workflow SHA: $TESTED_SHA"
+
+                    if ! git merge-base --is-ancestor "$TESTED_SHA" origin/main; then
+                      echo "Error: tested SHA $TESTED_SHA is not on origin/main"
+                      exit 1
+                    fi
+
+                    if git show-ref --verify --quiet "$TAG_REF"; then
+                      TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
+                      if [[ "$TAG_SHA" != "$TESTED_SHA" ]]; then
+                        echo "Error: tag '$TAG' already exists at $TAG_SHA, not at tested SHA ($TESTED_SHA)"
+                        exit 1
+                      fi
+                      echo "Tag '$TAG' already exists at tested SHA. Continuing."
+                    else
+                      git config user.name "github-actions[bot]"
+                      git config user.email "github-actions[bot]@users.noreply.github.com"
+                      git tag "$TAG" "$TESTED_SHA"
+                      git push origin "$TAG_REF"
+                      echo "Created and pushed tag '$TAG' from tested SHA $TESTED_SHA."
+                    fi
+                  else
+                    if ! git show-ref --verify --quiet "$TAG_REF"; then
+                      echo "Error: tag '$TAG' does not exist in the repository"
+                      exit 1
+                    fi
+                    echo "Using existing tag '$TAG'."
+                  fi
+
+                  git checkout --detach "$TAG_REF^{commit}"
+                  echo "tag=$TAG" >> $GITHUB_OUTPUT
+                  echo "resolved_sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
 
             - name: Setup Node.js
               uses: actions/setup-node@v4
               with:
-                  node-version: "lts/*"
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+                  node-version: 22
 
             - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
-              run: npm ci --include=optional
+              run: npm install --include=optional
 
             - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
-              run: cd webview-ui && npm ci --include=optional
+              run: cd webview-ui && npm install --include=optional
 
             - name: Install Publishing Tools
               run: npm install -g @vscode/vsce ovsx
@@ -75,28 +124,41 @@ jobs:
                   VERSION=$(node -p "require('./package.json').version")
                   echo "version=$VERSION" >> $GITHUB_OUTPUT
 
-            - name: Validate Tag
-              id: validate_tag
+            - name: Verify Tag Matches Package Version
               run: |
-                  TAG="${{ github.event.inputs.tag }}"
-                  echo "tag=$TAG" >> $GITHUB_OUTPUT
-                  echo "Using existing tag: $TAG"
-
-                  # Verify the tag exists
-                  if ! git rev-parse "$TAG" >/dev/null 2>&1; then
-                    echo "Error: Tag '$TAG' does not exist in the repository"
+                  TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  VERSION="v${{ steps.get_version.outputs.version }}"
+                  if [[ "$TAG" != "$VERSION" ]]; then
+                    echo "Error: tag '$TAG' does not match package version '$VERSION'"
                     exit 1
                   fi
+                  echo "Tag and package version match: $TAG"
 
-                  echo "Tag '$TAG' validated successfully"
+            - name: Verify LFS media assets are resolved
+              run: |
+                  FILE="webview-ui/src/assets/cline_kanban_demo.webm"
+                  if grep -q "git-lfs.github.com/spec/v1" "$FILE"; then
+                    echo "Error: $FILE is still a Git LFS pointer in CI checkout"
+                    exit 1
+                  fi
 
             - name: Package and Publish Extension
               env:
                   VSCE_PAT: ${{ secrets.VSCE_PAT }}
                   OVSX_PAT: ${{ secrets.OVSX_PAT }}
+                  CLINE_ENVIRONMENT: production
+                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
+                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
+                  # OpenTelemetry production defaults (can be overridden at runtime)
+                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
+                  OTEL_LOGS_EXPORTER: otlp
+                  OTEL_METRICS_EXPORTER: otlp
+                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
+                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
+                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
               run: |
                   # Required to generate the .vsix
-                  vsce package --out "cline-${{ steps.get_version.outputs.version }}.vsix"
+                  vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
                   if [ "${{ github.event.inputs.release-type }}" = "pre-release" ]; then
                     npm run publish:marketplace:prerelease
@@ -106,22 +168,31 @@ jobs:
                     echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   fi
 
-            # - name: Get Changelog Entry
-            #   id: changelog
-            #   uses: mindsers/changelog-reader-action@v2
-            #   with:
-            #       # This expects a standard Keep a Changelog format
-            #       # "latest" means it will read whichever is the most recent version
-            #       # set in "## [1.2.3] - 2025-01-28" style
-            #       version: latest
+            - name: Get Previous Tag
+              id: prev_tag
+              run: |
+                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
+                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
+
+            - name: Get Changelog Entry
+              id: changelog
+              run: |
+                  # Get content between first ## [ and second ## [
+                  CONTENT=$(awk '/^## \[/{if(found) exit; found=1; next} found{print}' CHANGELOG.md)
+                  echo "content<<EOF" >> $GITHUB_OUTPUT
+                  echo "$CONTENT" >> $GITHUB_OUTPUT
+                  echo "EOF" >> $GITHUB_OUTPUT
 
             - name: Create GitHub Release
               uses: softprops/action-gh-release@v1
               with:
-                  tag_name: ${{ steps.validate_tag.outputs.tag }}
+                  tag_name: ${{ steps.resolve_tag.outputs.tag }}
                   files: "*.vsix"
-                  # body: ${{ steps.changelog.outputs.content }}
-                  generate_release_notes: true
+                  body: |
+                      ${{ steps.changelog.outputs.content }}
+
+                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}
                   prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -1,6 +1,9 @@
 name: Tests
 
 on:
+    push:
+        branches:
+            - main
     workflow_dispatch:
     pull_request:
         branches:
@@ -14,7 +17,35 @@ permissions:
     pull-requests: write # Needed to add comments/annotations to PRs
 
 jobs:
+    quality-checks:
+        runs-on: ubuntu-latest
+        name: Quality Checks
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Setup Node.js environment
+              uses: actions/setup-node@v4
+              with:
+                  node-version: 22
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      package-lock.json
+                      webview-ui/package-lock.json
+
+            - name: Install root dependencies
+              run: npm ci
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Install webview-ui dependencies
+              run: cd webview-ui && npm ci
+
+            - name: Run Quality Checks (Parallel)
+              run: npm run ci:check-all
+
     test:
+        needs: quality-checks
         strategy:
             fail-fast: false
             matrix:
@@ -32,93 +63,63 @@ jobs:
               uses: actions/setup-node@v4
               with:
                   node-version: 22
-
-            # Setup Python for coverage script
-            - name: Setup Python
-              uses: actions/setup-python@v4
-              with:
-                  python-version: "3.10"
-
-            - name: Install Python dependencies
-              run: |
-                  python -m pip install --upgrade pip
-                  pip install requests
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      package-lock.json
+                      webview-ui/package-lock.json
 
             - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
               run: npm ci
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
             - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
-            - name: Install local modules on windows
-              if: runner.os == 'Windows' && steps.root-cache.outputs.cache-hit == 'true'
-              run: |
-                  npm install eslint-plugin-eslint-rules 
-                  cd webview-ui/ && npm install eslint-plugin-eslint-rules
-
             - name: Set up NPM on Windows
               if: runner.os == 'Windows'
               run: |
                   npm config set script-shell "C:\\Program Files\\Git\\bin\\bash.exe"
 
-            - name: Type Check
-              run: npm run check-types
-
-            - name: ESLint Check
-              run: npm run lint
-
-            - name: Prettier / Format Check
-              run: npm run format
-
-            # Build the extension before running tests
+            # Build the extension and tests (without redundant checks)
             - name: Build Tests and Extension
-              run: npm run pretest
+              id: build_step
+              run: npm run ci:build
 
-            # Unit Tests disabled due to module system conflicts between backend and webview-ui
-            # - name: Unit Tests
-            #   run: npm run test:unit
-
-            # Run extension tests with coverage
-            - name: Extension Tests with Coverage
-              id: extension_coverage
-              continue-on-error: true
+            - name: Unit Tests with coverage - Linux
+              id: unit_tests_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
               run: |
-                  node ./scripts/test-ci.js > extension_coverage.txt 2>&1
-                  # Default the encoding to UTF-8 - It's not the default on Windows
-                  PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage extension_coverage.txt --type=extension --github-output --verbose
+                  npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
+
+            - name: Unit Tests - Non-Linux
+              id: unit_tests_non_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              run: |
+                  npm run test:unit
+
+            - name: Extension Integration Tests - Linux
+              id: integration_tests_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
+              run: xvfb-run -a npm run test:coverage
+
+            - name: Extension Integration Tests - Non-Linux
+              id: integration_tests_non_linux
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
+              run: npm run test:integration
 
-            # Run webview tests with coverage
             - name: Webview Tests with Coverage
-              id: webview_coverage
-              continue-on-error: true
+              id: webview_tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
               run: |
                   cd webview-ui
-                  # Ensure coverage dependency is installed
-                  npm install --no-save @vitest/coverage-v8
-                  npm run test:coverage > webview_coverage.txt 2>&1
-                  cd ..
-                  # Default the encoding to UTF-8 - It's not the default on Windows
-                  PYTHONUTF8=1 PYTHONPATH=.github/scripts python -m coverage_check extract-coverage webview-ui/webview_coverage.txt --type=webview --github-output --verbose
+                  npm run test:coverage
+
+            - name: CLI Tests
+              id: cli_tests
+              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
+              run: cd cli && npm run test:run
 
-            # Save coverage reports as artifacts (workflow-scoped)
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
               # Only upload artifacts on Linux - We only need coverage from one OS
@@ -126,101 +127,98 @@ jobs:
               with:
                   name: pr-coverage-reports
                   path: |
-                      extension_coverage.txt
-                      webview-ui/webview_coverage.txt
-                  retention-period: workflow # Artifacts are automatically deleted when the workflow completes
+                      coverage-unit/lcov.info
+                      webview-ui/coverage/lcov.info
 
-            # Set the check as failed if any of the tests failed
-            - name: Print test results and check for failures
-              run: |
-                  echo "Extension Tests Result: ${{ steps.extension_coverage.outcome }}"
-                  cat extension_coverage.txt
-
-                  echo "Webview Tests Result: ${{ steps.webview_coverage.outcome }}"
-                  cat webview-ui/webview_coverage.txt
-
-                  # Check if any of the test steps failed
-                  # https://docs.github.com/en/actions/writing-workflows/choosing-what-your-workflow-does/accessing-contextual-information-about-workflow-runs#steps-context
-                  if [ "${{ steps.extension_coverage.outcome }}" != "success" ] || [ "${{ steps.webview_coverage.outcome }}" != "success" ]; then
-                      echo "Tests failed."
-                      exit 1
-                  fi
-
-    coverage:
-        needs: test
+    test-platform-integration:
+        needs: quality-checks
         runs-on: ubuntu-latest
-        # Only run on PRs to main branch
-        if: github.event_name == 'pull_request' && github.base_ref == 'main'
         steps:
             - name: Checkout code
               uses: actions/checkout@v4
-              with:
-                  fetch-depth: 0 # Fetch all history for accurate comparison
-
-            # Setup Python for coverage script
-            - name: Setup Python
-              uses: actions/setup-python@v4
-              with:
-                  python-version: "3.10"
-
-            - name: Install Python dependencies
-              run: |
-                  python -m pip install --upgrade pip
-                  pip install requests
 
             - name: Setup Node.js environment
               uses: actions/setup-node@v4
               with:
                   node-version: 22
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+                  cache: 'npm'
+                  cache-dependency-path: |
+                      package-lock.json
+                      webview-ui/package-lock.json
+                      testing-platform/package-lock.json
 
             - name: Install root dependencies
-              if: steps.root-cache.outputs.cache-hit != 'true'
               run: npm ci
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
             - name: Install webview-ui dependencies
-              if: steps.webview-cache.outputs.cache-hit != 'true'
               run: cd webview-ui && npm ci
 
-            # Build the extension before running tests
-            - name: Build Extension
-              run: npm run compile
+            - name: Download ripgrep binaries
+              run: npm run download-ripgrep
 
-            # Download coverage artifacts from test job
-            - name: Download Coverage Reports
+            - name: Compile Standalone
+              run: npm run compile-standalone
+
+            - name: Install testing platform dependencies
+              run: cd testing-platform && npm ci
+
+            - name: Running testing platform integration spec tests
+              timeout-minutes: 7
+              run: npm run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
+
+            - name: Save Coverage Reports
+              uses: actions/upload-artifact@v4
+              with:
+                name: test-platform-integration-core-coverage
+                path: coverage/**/lcov.info
+
+    qlty:
+        needs: [test, test-platform-integration]
+        runs-on: ubuntu-latest
+        # Run on PRs to main, pushes to main, and manual dispatches
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+
+            - name: Download unit tests coverage reports
               uses: actions/download-artifact@v4
               with:
                   name: pr-coverage-reports
-                  path: . # Download to root directory to match expected paths
+                  path: .
 
-            # Process coverage workflow
-            - name: Process coverage workflow
-              id: coverage
-              run: |
-                  # Extract PR number from GITHUB_REF
-                  PR_NUMBER=$(echo "$GITHUB_REF" | sed -e 's/refs\/pull\///' -e 's/\/merge//')
+            - name: Upload core unit tests coverage to Qlty
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                  # we can merge multiple files if necessary
+                  files: |
+                    coverage-unit/lcov.info
+                  tag: unit:core
 
-                  # Run the coverage workflow from root directory
-                  PYTHONPATH=.github/scripts python -m coverage_check process-workflow \
-                    --base-branch ${{ github.base_ref }} \
-                    --pr-number $PR_NUMBER \
-                    --repo $GITHUB_REPOSITORY \
-                    --token ${{ secrets.GITHUB_TOKEN }} \
-                    --verbose
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+            - name: Upload webview-ui unit tests coverage to Qlty
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                  token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                  # we can merge multiple files if necessary
+                  files: |
+                    webview-ui/coverage/lcov.info
+                  tag: unit:webview-ui
+                  add-prefix: webview-ui/
+
+            - name: Download test platform integration core coverage artifact
+              uses: actions/download-artifact@v4
+              continue-on-error: true
+              id: download-integration-coverage
+              with:
+                name: test-platform-integration-core-coverage
+                path: integration-core-coverage-reports
+
+            - name: Upload core integration tests coverage to Qlty
+              if: steps.download-integration-coverage.outcome == 'success'
+              uses: qltysh/qlty-action/coverage@v2
+              with:
+                token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
+                files: integration-core-coverage-reports/**/lcov.info
+                tag: integration:core

.github/workflows/trigger-jetbrains-tests.yml

@@ -0,0 +1,98 @@
+name: Trigger Jetbrains Plugin <-> Cline Tests
+on:
+  pull_request_target:
+    types: [opened, reopened]
+  issue_comment:
+    types: [created]
+permissions:
+  contents: read
+  pull-requests: read
+concurrency:
+  group: jetbrains-trigger-${{ github.event.pull_request.number || github.event.issue.number }}
+  cancel-in-progress: true
+
+jobs:
+  trigger-integration-test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    # Run on PR open/reopen, or when someone comments /test-jetbrains on a PR
+    if: |
+      github.event_name == 'pull_request_target' ||
+      (github.event_name == 'issue_comment' &&
+       github.event.issue.pull_request &&
+       contains(github.event.comment.body, '/test-jetbrains') &&
+       contains(fromJSON('["MEMBER","OWNER","COLLABORATOR"]'), github.event.comment.author_association))
+    steps:
+      - name: Generate GitHub App Token
+        id: app-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: 1998650
+          private-key: ${{ secrets.CLINE_JETBRAINS_WORKFLOW_KEY }}
+          owner: cline
+          repositories: intellij-plugin
+
+      - name: Get PR details (for issue_comment trigger)
+        id: pr-details
+        if: github.event_name == 'issue_comment'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          PR_DATA=$(gh api repos/${{ github.repository }}/pulls/${{ github.event.issue.number }})
+          echo "head_ref=$(echo "$PR_DATA" | jq -r '.head.ref')" >> $GITHUB_OUTPUT
+          echo "head_sha=$(echo "$PR_DATA" | jq -r '.head.sha')" >> $GITHUB_OUTPUT
+          echo "title=$(echo "$PR_DATA" | jq -r '.title')" >> $GITHUB_OUTPUT
+          echo "html_url=$(echo "$PR_DATA" | jq -r '.html_url')" >> $GITHUB_OUTPUT
+
+      - name: Sanitize untrusted inputs
+        id: sanitize
+        env:
+          RAW_BRANCH_NAME: ${{ github.event_name == 'pull_request_target' && github.head_ref || steps.pr-details.outputs.head_ref }}
+          RAW_PR_TITLE: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.title || steps.pr-details.outputs.title }}
+        run: |
+          # Sanitize branch name for JSON
+          BRANCH_NAME_JSON=$(jq -n --arg b "$RAW_BRANCH_NAME" '$b')
+          echo "branch_name=$BRANCH_NAME_JSON" >> $GITHUB_OUTPUT
+
+          # Sanitize PR title for JSON
+          PR_TITLE_JSON=$(jq -n --arg t "$RAW_PR_TITLE" '$t')
+          echo "pr_title=$PR_TITLE_JSON" >> $GITHUB_OUTPUT
+
+      - name: Trigger IntelliJ Plugin Integration Test
+        env:
+          BRANCH_NAME: ${{ steps.sanitize.outputs.branch_name }}
+          PR_TITLE: ${{ steps.sanitize.outputs.pr_title }}
+          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
+          PR_SHA: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || steps.pr-details.outputs.head_sha }}
+          PR_URL: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.html_url || steps.pr-details.outputs.html_url }}
+        run: |
+          curl -X POST \
+            -H "Authorization: Bearer ${{ steps.app-token.outputs.token }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            -H "User-Agent: cline-pr-trigger" \
+            -H "Content-Type: application/json" \
+            https://api.github.com/repos/cline/intellij-plugin/dispatches \
+            -d @- <<EOF
+          {
+            "event_type": "cline-pr-check",
+            "client_payload": {
+              "pr_number": "$PR_NUMBER",
+              "branch_name": $BRANCH_NAME,
+              "action": "${{ github.event.action }}",
+              "sha": "$PR_SHA",
+              "pr_title": $PR_TITLE,
+              "pr_url": "$PR_URL"
+            }
+          }
+          EOF
+
+      - name: Log trigger details
+        env:
+          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
+          PR_SHA: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || steps.pr-details.outputs.head_sha }}
+        run: |
+          echo "Triggered IntelliJ Plugin integration test for:"
+          echo "  PR #$PR_NUMBER"
+          echo "  Trigger: ${{ github.event_name }}"
+          echo "  Action: ${{ github.event.action }}"
+          echo "  SHA: $PR_SHA"

.gitignore

@@ -8,34 +8,51 @@ tmp
 
 .DS_Store
 .idea
+.husky/_/
 
 pnpm-lock.yaml
 
 .clineignore
 .venv
 .actrc
+CLAUDE.local.md
+
+webview-ui/src/**/*.js
+webview-ui/src/**/*.js.map
 
 # Ignore coverage directories and files
 coverage
+coverage-unit
+.nyc_output
 # But don't ignore the coverage scripts in .github/scripts/
 !.github/scripts/coverage/
 
 *evals.env
+.env
+.secrets
+.github/act/.secrets
 
-# Generated files
+.worktrees
+
+## Generated files ##
 src/generated/
-# Core
-src/core/controller/*/methods.ts
-src/core/controller/*/index.ts
-src/core/controller/grpc-service-config.ts
-# Shared
-src/shared/proto/*.ts
-src/shared/proto/host/*.ts
-# Webview
+src/shared/proto/
 webview-ui/src/services/grpc-client.ts
-# Host bridge
-src/hosts/vscode/*/methods.ts
-src/hosts/vscode/*/index.ts
-src/hosts/vscode/client/host-grpc-client.ts
-src/hosts/vscode/host-grpc-service-config.ts
-src/standalone/server-setup.ts
+*.tsbuildinfo
+
+# E2E Tests
+test-results
+
+/.github/act
+/pkg
+.secrets
+
+*.tsbuildinfo
+
+# Smoke test results (generated)
+evals/smoke-tests/results/
+
+.tui-test
+secrets.json
+tui-traces
+tests/**/cache

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "evals/cline-bench"]
+	path = evals/cline-bench
+	url = https://github.com/cline/cline-bench.git

.husky/pre-commit

@@ -1,17 +1 @@
-echo "Running pre-commit checks..."
-
-# Run ESLint
-echo "Running ESLint..."
-npm run lint || {
-    echo "❌ ESLint check failed. Please fix the errors and try committing again."
-    exit 1
-}
-
-# Run Prettier
-echo "Running Prettier..."
-npx lint-staged --verbose || {
-     echo "❌ Prettier failed. Please fix the errors and try committing again."
-     exit 1
- }
-
-echo "✅ All checks passed!"
+lint-staged

.mocharc.json

@@ -1,6 +1,15 @@
 {
-	"extension": ["ts"],
-	"spec": ["src/**/__tests__/*.ts", "eslint-rules/__tests__/**/*.test.ts"],
-	"require": ["ts-node/register", "source-map-support/register", "./src/test/requires.ts"],
-	"recursive": true
+	"extension": [
+		"ts"
+	],
+	"spec": [
+		"src/**/__tests__/*.ts"
+	],
+	"require": [
+		"ts-node/register",
+		"source-map-support/register",
+		"./src/test/requires.ts"
+	],
+	"recursive": true,
+	"exit": true
 }

.nycrc.unit.json

@@ -0,0 +1,48 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": [
+		"text",
+		"lcov"
+	],
+	"include": [
+		"src/**/*.ts"
+	],
+	"exclude": [
+		"**/*.d.ts",
+
+		"**/*.{test,spec}.{js,jsx,ts,tsx,mjs,cjs}",
+		"**/__tests__/**",
+		"**/test/**",
+		"**/tests/**",
+		"**/.nyc_output/**",
+		"**/.vscode-test/**",
+		"**/tests-results/**",
+		"src/test/**",
+
+		"src/generated/**",
+
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/out/**",
+		"**/build/**",
+		"**/coverage/**",
+		"**/coverage-unit/**",
+		"**/proto/**",
+
+		"**/*.{config,setup}.{js,ts,mjs,cjs}",
+		"**/vite-env.d.ts",
+
+		"**/*.{css,scss,sass,less,styl}",
+		"**/*.{svg,png,jpg,jpeg,gif,ico}",
+		"**/*.{json,yaml,yml}"
+	],
+	"extension": [
+		".ts",
+		".js"
+	],
+	"cache": true,
+	"sourceMap": true,
+	"instrument": true,
+	"report-dir": "./coverage-unit"
+}

.prettierignore

@@ -1,8 +0,0 @@
-dist/
-node_modules
-webview-ui/build/
-*.md
-package-lock.json
-src/core/prompts/system.ts
-src/core/prompts/model_prompts/claude4.ts
-evals/

.prettierrc.json

@@ -1,8 +0,0 @@
-{
-	"tabWidth": 4,
-	"useTabs": true,
-	"printWidth": 130,
-	"semi": false,
-	"bracketSameLine": true,
-	"endOfLine": "lf"
-}

.vscode-test.mjs

@@ -2,7 +2,7 @@ import { defineConfig } from "@vscode/test-cli"
 import path from "path"
 
 export default defineConfig({
-	files: "{out/**/*.test.js,src/**/*.test.js}",
+	files: "{out/**/*.test.js,src/**/*.test.js,!src/test/e2e/**/*.test.js,!out/src/test/e2e/**/*.test.js}",
 	mocha: {
 		ui: "bdd",
 		timeout: 20000, // Maximum time (in ms) that a test can run before failing

.vscode/extensions.json

@@ -2,9 +2,9 @@
 	// See http://go.microsoft.com/fwlink/?LinkId=827846
 	// for the documentation about the extensions.json format
 	"recommendations": [
-		"dbaeumer.vscode-eslint",
 		"connor4312.esbuild-problem-matchers",
 		"ms-vscode.extension-test-runner",
-		"bradlc.vscode-tailwindcss"
+		"bradlc.vscode-tailwindcss",
+		"biomejs.biome"
 	]
 }

.vscode/launch.json

@@ -6,15 +6,76 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "Run Extension",
+			"name": "Run Extension (production)",
 			"type": "extensionHost",
 			"request": "launch",
-			"args": ["--extensionDevelopmentPath=${workspaceFolder}", "--disable-workspace-trust", "${workspaceFolder}"],
-			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}",
+				"--disable-extensions"
+			],
+			"outFiles": [
+				"${workspaceFolder}/dist/**/*.js"
+			],
 			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/.env",
 			"env": {
 				"IS_DEV": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
+			}
+		},
+		{
+			"name": "Run Extension (staging)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}"
+			],
+			"outFiles": [
+				"${workspaceFolder}/dist/**/*.js"
+			],
+			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/.env",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "staging"
+			}
+		},
+		{
+			"name": "Run Extension (local)",
+			"type": "extensionHost",
+			"request": "launch",
+			"args": [
+				"--extensionDevelopmentPath=${workspaceFolder}",
+				"--disable-workspace-trust",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
+				"${workspaceFolder}"
+			],
+			"outFiles": [
+				"${workspaceFolder}/dist/**/*.js"
+			],
+			"preLaunchTask": "${defaultBuildTask}",
+			"envFile": "${workspaceFolder}/.env",
+			"env": {
+				"IS_DEV": "true",
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "local"
 			}
 		},
 		{
@@ -26,39 +87,118 @@
 				"--user-data-dir=${workspaceFolder}/dist/tmp/user",
 				"--profile-temp",
 				"--sync=off",
-				"--disable-extensions",
+				"--disable-extension",
+				"saoudrizwan.claude-dev", // Avoid conflicts with installed Cline
+				"--disable-extension",
+				"saoudrizwan.cline-nightly", // Avoid conflicts with installed Cline Nightly
 				"--extensionDevelopmentPath=${workspaceFolder}",
 				"${workspaceFolder}"
 			],
-			"outFiles": ["${workspaceFolder}/dist/**/*.js"],
+			"outFiles": [
+				"${workspaceFolder}/dist/**/*.js"
+			],
 			"preLaunchTask": "clean-tmp-user",
 			"internalConsoleOptions": "openOnSessionStart",
 			"postDebugTask": "stop",
+			"envFile": "${workspaceFolder}/.env",
 			"env": {
 				"IS_DEV": "true",
 				"TEMP_PROFILE": "true",
-				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}"
+				"DEV_WORKSPACE_FOLDER": "${workspaceFolder}",
+				"CLINE_ENVIRONMENT": "production"
 			}
 		},
 		{
 			"type": "node",
 			"request": "launch",
-			"name": "Run Standalone Service",
-			"skipFiles": ["<node_internals>/**"],
+			"name": "Debug Test Standalone Core Api Server (test:sca-server)",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
 			"sourceMaps": true,
-			"resolveSourceMapLocations": ["${workspaceFolder}/**", "!**/node_modules/**"],
-			"cwd": "${workspaceFolder}/dist-standalone",
-			"outFiles": ["${workspaceFolder}/dist-standalone/**/*.js"],
+			"resolveSourceMapLocations": [
+				"${workspaceFolder}/**",
+				"!**/node_modules/**"
+			],
+			"cwd": "${workspaceFolder}",
+			"outFiles": [
+				"${workspaceFolder}/dist/**/*.js",
+				"${workspaceFolder}/dist-standalone/**/*.js"
+			],
 			"preLaunchTask": "compile-standalone",
+			"runtimeExecutable": "npx",
+			"runtimeArgs": [
+				"tsx"
+			],
+			"program": "scripts/test-standalone-core-api-server.ts",
+			"envFile": "${workspaceFolder}/.env",
 			"env": {
-				// Turns on grpc debug log.
-				//"GRPC_TRACE": "all",
-				//"GRPC_VERBOSITY": "DEBUG",
-				"NODE_PATH": "${workspaceFolder}/dist-standalone/node_modules",
-
-				"HOST_BRIDGE_ADDRESS": "localhost:50052"
+				"PROTOBUS_PORT": "26040",
+				"HOSTBRIDGE_PORT": "26041",
+				"WORKSPACE_DIR": "${workspaceFolder}",
+				"E2E_TEST": "true",
+				"CLINE_ENVIRONMENT": "local"
 			},
-			"program": "standalone.js"
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "neverOpen"
+		},
+		{
+			"type": "node",
+			"request": "launch",
+			"name": "Debug Current Test File",
+			"skipFiles": [
+				"<node_internals>/**"
+			],
+			"sourceMaps": true,
+			"resolveSourceMapLocations": [
+				"${workspaceFolder}/**",
+				"!**/node_modules/**"
+			],
+			"cwd": "${workspaceFolder}",
+			"runtimeExecutable": "npx",
+			"runtimeArgs": [
+				"mocha"
+			],
+			"args": [
+				"--require",
+				"ts-node/register",
+				"--require",
+				"source-map-support/register",
+				"--require",
+				"./src/test/requires.ts",
+				"--exit",
+				"${file}"
+			],
+			"envFile": "${workspaceFolder}/.env",
+			"env": {
+				"TS_NODE_PROJECT": "./tsconfig.unit-test.json",
+				"NODE_ENV": "test",
+				"IS_DEV": "true",
+				"CLINE_ENVIRONMENT": "local"
+			},
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "openOnSessionStart"
+		},
+		{
+			"name": "Open Storybook",
+			"type": "node",
+			"request": "launch",
+			"runtimeExecutable": "npm",
+			"runtimeArgs": [
+				"run",
+				"storybook"
+			],
+			"cwd": "${workspaceFolder}/webview-ui",
+			"console": "integratedTerminal",
+			"internalConsoleOptions": "neverOpen",
+			"serverReadyAction": {
+				"pattern": "Local:.*http://localhost:([0-9]+)",
+				"uriFormat": "http://localhost:%s",
+				"action": "openExternally"
+			},
+			"env": {
+				"IS_DEV": "true"
+			}
 		}
 	]
 }

.vscode/settings.json

@@ -6,8 +6,28 @@
 	},
 	"search.exclude": {
 		"out": true, // set this to false to include "out" folder in search results
-		"dist": true // set this to false to include "dist" folder in search results
+		"dist": true, // set this to false to include "dist" folder in search results,
+		"node_modules": true,
+		"dist-standalone": true
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off"
+	"typescript.tsc.autoDetect": "off",
+	"typescript.preferences.quoteStyle": "double",
+	// Protobuf settings
+	"protoc": {
+		"options": [
+			"--proto_path=proto"
+		]
+	},
+	// Enable Lint and format using Biome
+	"biome.enabled": true,
+	"editor.defaultFormatter": "biomejs.biome",
+	"editor.codeActionsOnSave": {
+		"source.fixAll.biome": "explicit",
+		"source.removeUnused.biome": "always",
+		"source.removeUnusedImports": "always",
+		"source.organizeImports.biome": "always"
+	},
+	// Disable auto-forwarding ports to prevent Simple Browser from opening the Vite dev server
+	"remote.autoForwardPorts": false
 }

.vscode/tasks.json

@@ -30,7 +30,13 @@
 		},
 		{
 			"label": "watch",
-			"dependsOn": ["npm: protos", "npm: build:webview", "npm: dev:webview", "npm: watch:tsc", "npm: watch:esbuild"],
+			"dependsOn": [
+				"npm: protos",
+				"npm: build:webview",
+				"npm: dev:webview",
+				"npm: watch:tsc",
+				"npm: watch:esbuild"
+			],
 			"presentation": {
 				"reveal": "always"
 			},
@@ -60,7 +66,9 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -78,7 +86,9 @@
 			"problemMatcher": [],
 			"isBackground": true,
 			"label": "npm: build:webview:test",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -113,7 +123,9 @@
 			],
 			"isBackground": true,
 			"label": "npm: dev:webview",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -149,7 +161,9 @@
 			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -185,7 +199,9 @@
 			},
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -204,7 +220,9 @@
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"label": "npm: watch:tsc",
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"group": "watch",
 				"reveal": "always"
@@ -215,7 +233,9 @@
 			"script": "watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
-			"dependsOn": ["npm: protos"],
+			"dependsOn": [
+				"npm: protos"
+			],
 			"presentation": {
 				"reveal": "always",
 				"group": "watchers"
@@ -224,7 +244,11 @@
 		},
 		{
 			"label": "tasks: watch-tests",
-			"dependsOn": ["npm: protos", "npm: watch", "npm: watch-tests"],
+			"dependsOn": [
+				"npm: protos",
+				"npm: watch",
+				"npm: watch-tests"
+			],
 			"problemMatcher": []
 		},
 		{
@@ -235,8 +259,30 @@
 		{
 			"label": "clean-tmp-user",
 			"type": "shell",
-			"dependsOn": ["watch"],
+			"dependsOn": [
+				"watch"
+			],
 			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
+		},
+		{
+			"type": "npm",
+			"script": "storybook",
+			"group": "build",
+			"problemMatcher": [],
+			"isBackground": false,
+			"label": "npm: storybook",
+			"dependsOn": [
+				"npm: protos",
+				"npm: build:webview"
+			],
+			"presentation": {
+				"reveal": "always"
+			},
+			"options": {
+				"env": {
+					"IS_DEV": "true"
+				}
+			}
 		}
 	],
 	"inputs": [

.vscodeignore

@@ -1,15 +1,18 @@
 # Default
 .vscode/**
 .vscode-test/**
-out/**
-dist-standalone/**
-node_modules/**
+.worktrees/**
+CLAUDE.local.md
+out/
+dist-standalone/
+node_modules/
 src/**
 standalone/**
 .gitignore
 .yarnrc
 esbuild.js
-**/tsconfig.json
+vsc-extension-quickstart.md
+tsconfig*.json
 **/.eslintrc.json
 **/*.map
 **/*.ts
@@ -17,12 +20,25 @@ esbuild.js
 eslint-rules/**
 .github/**
 .husky/**
+.env
+
+# cli
+cli/**
 
 # Custom
 **/demo.gif
 .nvmrc
 .gitattributes
 .prettierignore
+.husky/
+.github/
+eslint-rules/
+old_docs/
+evals/
+.codespellrc
+.mocharc.json
+buf.yaml
+.clinerules/
 
 # Ignore all webview-ui files except the build directory (https://github.com/microsoft/vscode-webview-ui-toolkit-samples/blob/main/frameworks/hello-world-react-cra/.vscodeignore)
 webview-ui/src/**
@@ -47,3 +63,14 @@ old_docs/**
 
 # Include icons
 !assets/icons/**
+
+# Ignore E2E build files
+e2e-build.mjs
+e2e.vsix
+test-results/
+
+# Ignore Storybook files
+**/*.stories.tsx
+*storybook.log
+storybook-static
+**/StorybookDecorator.tsx

.worktreeinclude

@@ -0,0 +1 @@
+.gitignore

CLAUDE.md

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

CONTRIBUTING.md

@@ -14,14 +14,11 @@ Bug reports help make Cline better for everyone! Before creating a new issue, pl
 ## Before Contributing
 
 All contributions must begin with a GitHub Issue, unless the change is for small bug fixes, typo corrections, minor wording improvements, or simple type fixes that don't change functionality.
-
-- **Check existing issues**: Search [GitHub Issues](https://github.com/cline/cline/issues).
-- **Create an issue**: Use appropriate templates:
-    - **Contributions:** Use the "Contribution Request" template to propose what you'd like to work on.
-    - **Bugs:** "Bug Report" template for reporting issues.
-    - **Features:** "Detailed Feature Proposal" template for suggesting new features.
-- **Wait for approval**: A core Cline contributor must approve your contribution request before you start implementation.
-- **Claim issues**: Once approved, the issue will be assigned to you.
+**For features and contributions**:
+- First check the [Feature Requests discussions board](https://github.com/cline/cline/discussions/categories/feature-requests) for similar ideas
+- If your idea is new, create a new feature request  
+- Wait for approval from core maintainers before starting implementation
+- Once approved, feel free to begin working on a PR with the help of our community!
 
 **PRs without approved issues may be closed.**
 
@@ -49,35 +46,24 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
     ```bash
     npm run install:all
     ```
-4. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+4. Generate Protocol Buffer files (required before first build):
+    ```bash
+    npm run protos
+    ```
+5. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
 
 
 
 
 ### Creating a Pull Request
 
-1. Before creating a PR, generate a changeset entry:
-    ```bash
-    npm run changeset
-    ```
-   This will prompt you for:
-   - Type of change (major, minor, patch)
-     - `major` → breaking changes (1.0.0 → 2.0.0)
-     - `minor` → new features (1.0.0 → 1.1.0)
-     - `patch` → bug fixes (1.0.0 → 1.0.1)
-   - Description of your changes
+1. Commit your changes.
 
-2. Commit your changes and the generated `.changeset` file
-
-3. Push your branch and create a PR on GitHub. Our CI will:
+2. Push your branch and create a PR on GitHub. Our CI will:
    - Run tests and checks
-   - Changesetbot will create a comment showing the version impact
-   - When merged to main, changesetbot will create a Version Packages PR
-   - When the Version Packages PR is merged, a new release will be published
-4. Testing
+3. Testing
     - Run `npm run test` to run tests locally. 
     - Before submitting PR, run `npm run format:fix` to format your code
-    - Run `npm run test:ci` to run tests locally
 
 ### Extension
 
@@ -89,8 +75,10 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 2. **Local Development**
     - Run `npm run install:all` to install dependencies
+    - Run `npm run protos` to generate Protocol Buffer files (required before first build)
     - Run `npm run test` to run tests locally
     - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
+    - **Terminal Workflow**: Use `npm run dev` (generates protos + runs watch mode) or `npm run watch` (if protos already generated)
     - Before submitting PR, run `npm run format:fix` to format your code
 
 3. **Linux-specific Setup**
@@ -150,7 +138,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     - Run `npm run lint` to check code style
     - Run `npm run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
-    - Address any ESLint warnings or errors before submitting
+    - Address any warnings or errors from linter before submitting
     - Follow TypeScript best practices and maintain type safety
 
 3. **Testing**
@@ -160,15 +148,40 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     - Update existing tests if your changes affect them
     - Include both unit tests and integration tests where appropriate
 
-4. **Version Management with Changesets**
+    **End-to-End (E2E) Testing**
+    
+    Cline includes comprehensive E2E tests using Playwright that simulate real user interactions with the extension in VS Code:
+    
+    - **Running E2E tests:**
+      ```bash
+      npm run test:e2e        # Build and run all E2E tests
+      npm run e2e             # Run tests without rebuilding
+      npm run test:e2e -- --debug  # Run with interactive debugger
+      ```
+    
+    - **Writing E2E tests:**
+      - Tests are located in `src/test/e2e/`
+      - Use the `e2e` fixture for single-root workspace tests
+      - Use `e2eMultiRoot` fixture for multi-root workspace tests
+      - Follow existing patterns in `auth.test.ts`, `chat.test.ts`, `diff.test.ts`, and `editor.test.ts`
+      - See `src/test/e2e/README.md` for detailed documentation
+    
+    - **Debug mode features:**
+      - Interactive Playwright Inspector for step-by-step debugging
+      - Record new interactions and generate test code automatically
+      - Visual VS Code instance for manual testing
+      - Element inspection and selector validation
+    
+    - **Test environment:**
+      - Automated VS Code setup with Cline extension loaded
+      - Mock API server for backend testing
+      - Temporary workspaces with test fixtures
+      - Video recording for failed tests
 
-    - Create a changeset for any user-facing changes using `npm run changeset`
-    - Choose the appropriate version bump:
-        - `major` for breaking changes (1.0.0 → 2.0.0)
-        - `minor` for new features (1.0.0 → 1.1.0)
-        - `patch` for bug fixes (1.0.0 → 1.0.1)
-    - Write clear, descriptive changeset messages that explain the impact
-    - Documentation-only changes don't require changesets
+4. **Versioning & Changelog Notes**
+
+    - Contributors do not need to create changelog-entry files as part of PRs.
+    - Maintainers handle release versioning and changelog curation during the release process.
 
 5. **Commit Guidelines**
 

LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2025 Cline Bot Inc.
+   Copyright 2026 Cline Bot Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -2,7 +2,7 @@
 English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md" target="_blank">Español</a> | <a href="https://github.com/cline/cline/blob/main/locales/de/README.md" target="_blank">Deutsch</a> | <a href="https://github.com/cline/cline/blob/main/locales/ja/README.md" target="_blank">日本語</a> | <a href="https://github.com/cline/cline/blob/main/locales/zh-cn/README.md" target="_blank">简体中文</a> | <a href="https://github.com/cline/cline/blob/main/locales/zh-tw/README.md" target="_blank">繁體中文</a> | <a href="https://github.com/cline/cline/blob/main/locales/ko/README.md" target="_blank">한국어</a>
 </sub></div>
 
-# Cline – \#1 on OpenRouter
+# Cline
 
 <p align="center">
   <img src="https://media.githubusercontent.com/media/cline/cline/main/assets/docs/demo.gif" width="100%" />
@@ -30,9 +30,9 @@ English | <a href="https://github.com/cline/cline/blob/main/locales/es/README.md
 </table>
 </div>
 
-Meet Cline (pronounced /klaɪn/, like "Klein"), an AI assistant that can use your **CLI** a**N**d **E**ditor.
+Meet Cline, an AI assistant that can use your **CLI** a**N**d **E**ditor.
 
-Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
+Thanks to [Claude Sonnet's agentic coding capabilities](https://www.anthropic.com/claude/sonnet), Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support. Cline can even use the Model Context Protocol (MCP) to create new tools and extend his own capabilities. While autonomous AI scripts traditionally run in sandboxed environments, this extension provides a human-in-the-loop GUI to approve every file change and terminal command, providing a safe and accessible way to explore the potential of agentic AI.
 
 1. Enter your task and add images to convert mockups into functional apps or fix bugs with screenshots.
 2. Cline starts by analyzing your file structure & source code ASTs, running regex searches, and reading relevant files to get up to speed in existing projects. By carefully managing what information is added to context, Cline can provide valuable assistance even for large, complex projects without overwhelming the context window.
@@ -43,7 +43,7 @@ Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthrop
 4. When a task is completed, Cline will present the result to you with a terminal command like `open -a "Google Chrome" index.html`, which you run with a click of a button.
 
 > [!TIP]
-> Use the `CMD/CTRL + Shift + P` shortcut to open the command palette and type "Cline: Open In New Tab" to open the extension as a tab in your editor. This lets you use Cline side-by-side with your file explorer, and see how he changes your workspace more clearly.
+> Follow [this guide](https://docs.cline.bot/features/customization/opening-cline-in-sidebar) to open Cline on the right side of your editor. This lets you use Cline side-by-side with your file explorer, and see how he changes your workspace more clearly.
 
 ---
 
@@ -51,7 +51,7 @@ Thanks to [Claude 3.7 Sonnet's agentic coding capabilities](https://www.anthrop
 
 ### Use any API and Model
 
-Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, and Cerebras. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
+Cline supports API providers like OpenRouter, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras and Groq. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using OpenRouter, the extension fetches their latest model list, allowing you to use the newest models as soon as they're available.
 
 The extension also keeps track of total tokens and API usage cost for the entire task loop and individual requests, keeping you informed of spend every step of the way.
 
@@ -87,7 +87,7 @@ All changes made by Cline are recorded in your file's Timeline, providing an eas
 
 ### Use the Browser
 
-With Claude 3.5 Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
+With Claude Sonnet's new [Computer Use](https://www.anthropic.com/news/3-5-models-and-computer-use) capability, Cline can launch a browser, click elements, type text, and scroll, capturing screenshots and console logs at each step. This allows for interactive debugging, end-to-end testing, and even general web use! This gives him autonomy to fixing visual bugs and runtime issues without you needing to handhold and copy-pasting error logs yourself.
 
 Try asking Cline to "test the app", and watch as he runs a command like `npm run dev`, launches your locally running dev server in a browser, and performs a series of tests to confirm that everything works. [See a demo here.](https://x.com/sdrzn/status/1850880547825823989)
 
@@ -141,6 +141,11 @@ For example, when working with a local web server, you can use 'Restore Workspac
 
 To contribute to the project, start with our [Contributing Guide](CONTRIBUTING.md) to learn the basics. You can also join our [Discord](https://discord.gg/cline) to chat with other contributors in the `#contributors` channel. If you're looking for full-time work, check out our open positions on our [careers page](https://cline.bot/join-us)!
 
+## Enterprise
+
+Get the same Cline experience with enterprise-grade controls: SSO (SAML/OIDC), global policies and configuration, observability with audit trails, private networking (VPC/private link), and self-hosted or on-prem deployments, and enterprise support. Learn more at our [enterprise page](https://cline.bot/enterprise) or [talk to us](https://cline.bot/contact-sales).
+
+
 ## License
 
-[Apache 2.0 © 2025 Cline Bot Inc.](./LICENSE)
+[Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)

SECURITY.md

@@ -0,0 +1,27 @@
+# Security Policy
+
+## Supported Versions
+
+We actively patch only the most recent minor release of Cline. Older versions receive fixes at our discretion.
+
+## Reporting a Vulnerability
+
+We appreciate your efforts to responsibly disclose your findings and will make every effort to acknowledge your contributions.
+
+To report a security issue, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/cline/cline/security/advisories/new) tab.
+
+The team will send a response indicating the next steps in handling your report. After the initial reply, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
+
+When reporting, please include:
+
+- A short summary of the issue
+- Steps to reproduce or a proof of concept
+- Any logs, stack traces, or screenshots that might help us understand the problem
+
+We acknowledge reports within 48 hours and aim to release a fix or mitigation within 30 days. While we work on a resolution, please keep the details private.
+
+## Escalation
+
+If you do not receive an acknowledgement of your report within 5 business days, you may send an email to security@cline.bot.
+
+Thank you for helping us keep Cline users safe.

assets/icons/cline-bot.svg

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

assets/icons/social/discord.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M20.317 4.15557C18.7873 3.45369 17.147 2.93658 15.4319 2.6404C15.4007 2.63469 15.3695 2.64897 15.3534 2.67754C15.1424 3.05276 14.9087 3.54225 14.7451 3.927C12.9004 3.65083 11.0652 3.65083 9.25832 3.927C9.09465 3.5337 8.85248 3.05276 8.64057 2.67754C8.62449 2.64992 8.59328 2.63564 8.56205 2.6404C6.84791 2.93563 5.20756 3.45275 3.67693 4.15557C3.66368 4.16129 3.65233 4.17082 3.64479 4.18319C0.533392 8.83155 -0.31895 13.3657 0.0991801 17.8436C0.101072 17.8655 0.11337 17.8864 0.130398 17.8997C2.18321 19.4073 4.17171 20.3225 6.12328 20.9291C6.15451 20.9386 6.18761 20.9272 6.20748 20.9015C6.66913 20.2711 7.08064 19.6063 7.43348 18.9073C7.4543 18.8664 7.43442 18.8178 7.39186 18.8016C6.73913 18.554 6.1176 18.2521 5.51973 17.9093C5.47244 17.8816 5.46865 17.814 5.51216 17.7816C5.63797 17.6873 5.76382 17.5893 5.88396 17.4902C5.90569 17.4721 5.93598 17.4683 5.96153 17.4797C9.88928 19.273 14.1415 19.273 18.023 17.4797C18.0485 17.4674 18.0788 17.4712 18.1015 17.4893C18.2216 17.5883 18.3475 17.6873 18.4742 17.7816C18.5177 17.814 18.5149 17.8816 18.4676 17.9093C17.8697 18.2588 17.2482 18.554 16.5945 18.8006C16.552 18.8168 16.533 18.8664 16.5538 18.9073C16.9143 19.6054 17.3258 20.2701 17.7789 20.9005C17.7978 20.9272 17.8319 20.9386 17.8631 20.9291C19.8241 20.3225 21.8126 19.4073 23.8654 17.8997C23.8834 17.8864 23.8948 17.8664 23.8967 17.8445C24.3971 12.6676 23.0585 8.17064 20.3482 4.18414C20.3416 4.17082 20.3303 4.16129 20.317 4.15557ZM8.02002 15.117C6.8375 15.117 5.86313 14.0313 5.86313 12.6981C5.86313 11.3648 6.8186 10.2791 8.02002 10.2791C9.23087 10.2791 10.1958 11.3743 10.1769 12.6981C10.1769 14.0313 9.22141 15.117 8.02002 15.117ZM15.9947 15.117C14.8123 15.117 13.8379 14.0313 13.8379 12.6981C13.8379 11.3648 14.7933 10.2791 15.9947 10.2791C17.2056 10.2791 18.1705 11.3743 18.1516 12.6981C18.1516 14.0313 17.2056 15.117 15.9947 15.117Z" fill="#FAFAFA"/>
+</svg>

assets/icons/social/github.svg

@@ -0,0 +1,3 @@
+        <svg viewBox="0 0 24 24" fill="black" xmlns="http://www.w3.org/2000/svg">
+          <path d="M12 2C6.477 2 2 6.477 2 12C2 16.418 4.865 20.166 8.84 21.49C9.34 21.58 9.52 21.27 9.52 21C9.52 20.77 9.51 20.14 9.51 19.31C6.73 19.91 6.14 17.97 6.14 17.97C5.68 16.81 5.03 16.5 5.03 16.5C4.12 15.88 5.1 15.9 5.1 15.9C6.1 15.97 6.63 16.93 6.63 16.93C7.5 18.45 8.97 18 9.54 17.76C9.63 17.11 9.89 16.67 10.17 16.42C7.95 16.17 5.62 15.31 5.62 11.5C5.62 10.39 6 9.5 6.65 8.79C6.55 8.54 6.2 7.5 6.75 6.15C6.75 6.15 7.59 5.88 9.5 7.17C10.29 6.95 11.15 6.84 12 6.84C12.85 6.84 13.71 6.95 14.5 7.17C16.41 5.88 17.25 6.15 17.25 6.15C17.8 7.5 17.45 8.54 17.35 8.79C18 9.5 18.38 10.39 18.38 11.5C18.38 15.32 16.04 16.16 13.81 16.41C14.17 16.72 14.5 17.33 14.5 18.26C14.5 19.6 14.49 20.68 14.49 21C14.49 21.27 14.67 21.59 15.17 21.49C19.14 20.16 22 16.42 22 12C22 6.477 17.523 2 12 2Z" fill="white"/>
+        </svg>

assets/icons/social/linkedin.svg

@@ -0,0 +1,10 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_2001_1428)">
+<path d="M22.2234 0H1.77187C0.792187 0 0 0.773438 0 1.72969V22.2656C0 23.2219 0.792187 24 1.77187 24H22.2234C23.2031 24 24 23.2219 24 22.2703V1.72969C24 0.773438 23.2031 0 22.2234 0ZM7.12031 20.4516H3.55781V8.99531H7.12031V20.4516ZM5.33906 7.43438C4.19531 7.43438 3.27188 6.51094 3.27188 5.37187C3.27188 4.23281 4.19531 3.30937 5.33906 3.30937C6.47813 3.30937 7.40156 4.23281 7.40156 5.37187C7.40156 6.50625 6.47813 7.43438 5.33906 7.43438ZM20.4516 20.4516H16.8937V14.8828C16.8937 13.5562 16.8703 11.8453 15.0422 11.8453C13.1906 11.8453 12.9094 13.2937 12.9094 14.7891V20.4516H9.35625V8.99531H12.7687V10.5609H12.8156C13.2891 9.66094 14.4516 8.70938 16.1813 8.70938C19.7859 8.70938 20.4516 11.0813 20.4516 14.1656V20.4516Z" fill="#FAFAFA"/>
+</g>
+<defs>
+<clipPath id="clip0_2001_1428">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>
+</svg>

assets/icons/social/reddit.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M15.0512 4.07466C15.3113 5.17727 16.301 5.99866 17.4829 5.99866C18.8627 5.99866 19.9813 4.87965 19.9813 3.49933C19.9813 2.11902 18.8627 1 17.4829 1C16.2764 1 15.2703 1.85537 15.036 2.99314C13.0155 3.20991 11.4378 4.92417 11.4378 7.00167C11.4378 7.00636 11.4378 7.00988 11.4378 7.01456C9.24041 7.10713 7.23397 7.73284 5.641 8.72062C5.04949 8.26247 4.30688 7.98945 3.50102 7.98945C1.5672 7.98945 0 9.55725 0 11.4918C0 12.8955 0.824597 14.1048 2.01581 14.6637C2.13177 18.7297 6.56047 22 12.0082 22C17.4559 22 21.8905 18.7261 22.0006 14.6567C23.1824 14.0942 24 12.8885 24 11.493C24 9.55842 22.4328 7.99063 20.499 7.99063C19.6966 7.99063 18.9575 8.2613 18.3672 8.71594C16.7602 7.72113 14.7315 7.09541 12.5119 7.01222C12.5119 7.0087 12.5119 7.00636 12.5119 7.00285C12.5119 5.51473 13.6176 4.27971 15.0512 4.077V4.07466ZM5.50044 13.7146C5.559 12.4444 6.40234 11.4695 7.38272 11.4695C8.3631 11.4695 9.11274 12.4995 9.05417 13.7697C8.99561 15.0398 8.26354 15.5015 7.28199 15.5015C6.30044 15.5015 5.44187 14.9848 5.50044 13.7146ZM16.6348 11.4695C17.6164 11.4695 18.4597 12.4444 18.5171 13.7146C18.5757 14.9848 17.716 15.5015 16.7356 15.5015C15.7552 15.5015 15.022 15.041 14.9634 13.7697C14.9048 12.4995 15.6533 11.4695 16.6348 11.4695ZM15.4682 16.6533C15.6521 16.6721 15.7693 16.8631 15.6978 17.0341C15.0946 18.4766 13.6703 19.4901 12.0082 19.4901C10.3461 19.4901 8.92299 18.4766 8.31859 17.0341C8.24714 16.8631 8.36427 16.6721 8.54817 16.6533C9.62577 16.5444 10.7912 16.4846 12.0082 16.4846C13.2252 16.4846 14.3895 16.5444 15.4682 16.6533Z" fill="#FAFAFA"/>
+</svg>

assets/icons/social/x.svg

@@ -0,0 +1,3 @@
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M18.3263 1.90393H21.6998L14.3297 10.3274L23 21.7899H16.2112L10.894 14.838L4.80995 21.7899H1.43443L9.31743 12.78L1 1.90393H7.96111L12.7674 8.25826L18.3263 1.90393ZM17.1423 19.7707H19.0116L6.94539 3.81706H4.93946L17.1423 19.7707Z" fill="#FAFAFA"/>
+</svg>

biome.jsonc

@@ -0,0 +1,203 @@
+{
+	"$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true,
+		"defaultBranch": "main"
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on",
+				"useSortedAttributes": "on"
+			}
+		}
+	},
+	"linter": {
+		"enabled": true,
+		"domains": {
+			"react": "recommended"
+		},
+		// Ideally we would want to turn on all the rules that are currently off,
+		// keeping them off currently to make sure only changes on the migrations
+		// are included in the initial PR before we apply the format and lint changes.
+		// TODO: turn on all rules that are currently off if applicable.
+		// TODO: Remove --diagnostic-level=error from CI commands.
+		"rules": {
+			"recommended": true,
+			"correctness": {
+				"useExhaustiveDependencies": "info",
+				"noUndeclaredVariables": "off",
+				"noEmptyPattern": "info",
+				"useJsxKeyInIterable": "off",
+				"noInnerDeclarations": "off",
+				"useHookAtTopLevel": "info",
+				"useYield": "info",
+				"noConstructorReturn": "off",
+				"noInvalidPositionAtImportRule": "off",
+				"noSwitchDeclarations": "off",
+				"noUnusedImports": "error"
+			},
+			"a11y": "info",
+			"style": {
+				"useNodejsImportProtocol": "off",
+				"useImportType": "off",
+				"useBlockStatements": "off",
+				"useNamingConvention": "off",
+				"useThrowOnlyError": "info",
+				"useConsistentArrayType": "off",
+				"noParameterAssign": "off",
+				"useAsConstAssertion": "off",
+				"useDefaultParameterLast": "off",
+				"noNonNullAssertion": "info",
+				"useEnumInitializers": "off",
+				"useSelfClosingElements": "info",
+				"useSingleVarDeclarator": "off",
+				"useNumberNamespace": "info",
+				"noInferrableTypes": "info",
+				"useTemplate": "info",
+				"noUselessElse": "info"
+			},
+			"suspicious": {
+				"noDoubleEquals": "warn",
+				"noImplicitAnyLet": "info",
+				"noThenProperty": "off",
+				"noAsyncPromiseExecutor": "info",
+				"noImportAssign": "off",
+				"noExplicitAny": "info",
+				"noControlCharactersInRegex": "warn",
+				"noShadowRestrictedNames": "off",
+				"noArrayIndexKey": "info",
+				"noAssignInExpressions": "info",
+				"useIterableCallbackReturn": "info"
+			},
+			"complexity": {
+				"noUselessConstructor": "info",
+				"useOptionalChain": "info",
+				"noBannedTypes": "warn",
+				"useLiteralKeys": "info",
+				"noUselessCatch": "info",
+				"noUselessSwitchCase": "info",
+				"noStaticOnlyClass": "info"
+			},
+			"security": {
+				"noDangerouslySetInnerHtml": "info"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab",
+		"indentWidth": 4,
+		"lineWidth": 130,
+		"lineEnding": "lf",
+		"formatWithErrors": true
+	},
+	"css": {
+		"parser": {
+			"tailwindDirectives": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"semicolons": "asNeeded",
+			"arrowParentheses": "always",
+			"bracketSameLine": true,
+			"bracketSpacing": true,
+			"jsxQuoteStyle": "double",
+			"quoteProperties": "asNeeded",
+			"trailingCommas": "all"
+		}
+	},
+	"json": {
+		"formatter": {
+			"trailingCommas": "none",
+			"expand": "always"
+		}
+	},
+	"files": {
+		"ignoreUnknown": true,
+		"includes": [
+			"**",
+			// explicitly force files to be ignored by the scanner with !!
+			"!!**/dist",
+			"!!**/dist-*",
+			"!!**/out",
+			"!!**/evals",
+			"!!**/playwright",
+			"!!**/test-results",
+			"!!**/node_modules",
+			"!!**/webview-ui/build",
+			"!!**/generated",
+			"!!**/proto",
+			"!!**/tests/specs"
+		]
+	},
+	"plugins": [
+		"src/dev/grit/process-env.grit"
+	],
+	"overrides": [
+		{
+			"includes": [
+				"**",
+				"!!**/dist",
+				"!!**/hosts/vscode/**",
+				"!!**/test/**",
+				"!!**/*.test.ts",
+				"!!src/dev/**",
+				"!!src/extension.ts",
+				"!!src/integrations/git/commit-message-generator.ts",
+				"!!src/integrations/terminal/**",
+				"!!src/core/controller/ui/openWalkthrough.ts"
+			],
+			"plugins": [
+				"src/dev/grit/vscode-api.grit"
+			]
+		},
+		{
+			// Do not use console logging directly, use the Logger service instead.
+			"plugins": [
+				"src/dev/grit/console-log.grit"
+			],
+			"includes": [
+				"**",
+				"!!**/esbuild.*",
+				"!!**/*.mts",
+				"!!**/webview-ui/**",
+				"!!**/evals/**",
+				"!!**/standalone/**",
+				"!!**/cli/**",
+				"!!**/e2e/**",
+				"!!**/test/**",
+				"!!**/__tests__/**",
+				"!!**/*.test.ts",
+				"!!**/*.stories.ts",
+				"!!src/dev/**",
+				"!!**/*.mjs",
+				"!!**/*.js",
+				"!!**/scripts/**",
+				"!!**/*.tsx",
+				"!!**/testing-platform/**",
+				// ACP mode must redirect console to stderr - this is intentional
+				"!!cli/src/acp/index.ts"
+			]
+		},
+		{
+			"includes": [
+				"**",
+				"!!src/core/storage/state-migrations.ts",
+				"!!src/core/storage/FileContextTracker.ts",
+				"!!src/core/context/context-tracking/FileContextTracker.ts",
+				"!!src/common.ts",
+				"!!src/services/logging/distinctId.ts",
+				"!!src/core/storage/utils/state-helpers.ts",
+				"!!src/extension.ts"
+			],
+			"plugins": [
+				"src/dev/grit/use-cache-service.grit"
+			]
+		}
+	]
+}

buf.yaml

@@ -9,7 +9,6 @@ lint:
 
     except: # Add exceptions for current patterns that contradict STANDARD settings
         - RPC_PASCAL_CASE # rpcs are camel case (start with lowercase)
-        - PACKAGE_DIRECTORY_MATCH # the protos in the cline package are not in a dir named cline.
         - RPC_REQUEST_RESPONSE_UNIQUE # request messages are not unique.
         - RPC_REQUEST_STANDARD_NAME # request messages dont all end with Request
         - RPC_RESPONSE_STANDARD_NAME # response messages dont all end with Response

cli/CHANGELOG.md

@@ -0,0 +1,242 @@
+# cline
+
+## [2.9.0]
+
+### Added
+
+- Latency improvements for remote workspaces
+
+## [2.8.2]
+
+### Fixed
+- Use `kanban@latest` in `cline kanban` to always fetch the newest version
+
+## [2.8.1]
+
+### Added
+- Implement dynamic free model detection for Cline API
+- Add file read deduplication cache to prevent repeated reads
+- Add feature tips tooltip during thinking state
+
+### Fixed
+- Fix flaky CLI Enter-key handling across Windows/test environments
+- Replace error message when not logged in to Cline
+- Align ClineRulesToggleModal padding with ServersToggleModal
+- Skip WebP for GLM and Devstral models running through llama.cpp
+- Respect user-configured context window in LiteLLM getModel()
+- Honor explicit model IDs outside static catalog in W&B provider
+- Add missing Fireworks serverless models and pricing
+
+## [2.8.0]
+
+### Added
+
+- Added W&B Inference by CoreWeave as a new API provider with 17 models including DeepSeek-V3.1, Llama 4, and Qwen3-Coder
+- Added CLI TUI end-to-end test suite
+
+### Fixed
+
+- Claude Code: handle rate limit events, empty content arrays, error results, and unknown content types without crashing
+- CLI: `/q` and `/exit` slash commands now execute immediately on Enter without requiring the slash menu to be visible
+- CLI: slash command filtering now prioritizes exact and prefix matches over fuzzy matches
+
+## [2.7.0]
+
+### Added
+
+- Added MCP add shortcuts for stdio and HTTP servers
+- Added `--continue` for the current directory
+- Added `--auto-condense` flag for AI-powered context compaction
+- Added `--hooks-dir` flag for runtime hook injection
+- Enabled error autocapture
+- Prompt rules now include test verification guidance and make `CLI_RULES` language-agnostic
+
+### Fixed
+
+- Fixed remount behavior so TUI remounts only on width resize
+- Fixed startup prompt replay on resize remount
+- Fixed task flags so they are applied before the welcome TUI mounts
+
+### Changed
+
+- Hooks: reintroduced feature toggle
+
+## [2.6.1]
+
+### Added
+
+- Added GPT-5.4 models for ChatGPT subscription users
+- Hooks: Added a `Notification` hook for attention and completion boundaries
+- Added `--hooks-dir` CLI flag for runtime hook injection
+- Added `--auto-approve-all` CLI flag for interactive mode
+
+### Fixed
+
+- Handle streamable HTTP MCP reconnects more reliably
+
+## [2.6.0]
+
+### Added
+
+- Hook payloads now include `model.provider` and `model.slug` 
+- Token/cost updates now happen immediately as usage chunks arrive, not after tool execution
+
+### Fixed
+
+- Improve subagent context compaction logic
+- Subagent stream retry delay increased to reduce noise from transient failures
+- State serialization errors are now caught and logged instead of crashing
+- Removed incorrect `max_tokens` from OpenRouter requests
+
+## [2.5.2]
+
+### Added
+
+- Added Windows PowerShell support for hooks (execution, resolution, and management), improving hook behavior on Windows for CLI and shared core workflows.
+
+### Fixed
+
+- Restored GPT-OSS native file editing for OpenAI-compatible models used through shared core tooling.
+- Improved OpenRouter context overflow error handling so auto-compaction triggers correctly for wrapped 400 errors.
+- Hardened checkpoint recovery by retrying nested git restore and preventing silent `.git_disabled` leftovers.
+- Added a User-Agent header for requests to the Cline back-end to improve request handling consistency.
+
+## [2.5.1]
+
+### Added
+
+- Expanded CLI markdown rendering support (headings, lists, blockquotes, fenced code blocks, links, and nested lists).
+
+### Fixed
+
+- Fixed CLI headless auth provider model metadata loading for Cline and Vercel AI Gateway by fetching model info from API with cache fallback.
+- Increased flaky CLI import test timeout on Windows CI to reduce intermittent test failures.
+
+## [2.5.0]
+
+### Added
+
+- Added Cline SDK API interface for programmatic access to Cline features and tools, enabling integration into custom applications.
+- Added Codex 5.3 model support
+
+### Fixed
+
+- Fix OpenAI Codex by setting `store` to `false`
+- Use `isLocatedInPath()` instead of string matching for path containment checks
+
+## [2.4.3]
+
+### Added
+
+- Add /q command to quit CLI
+- Fetch featured models from backend with local fallback
+
+### Fixed
+
+- Fix auth check for ACP mode
+- Fix Cline auth with ACP flag
+- Fix yolo mode to not persist yolo setting to disk
+
+## [2.4.2]
+
+### Added
+
+- Gemini-3.1 Pro Preview
+
+### Patch Changes
+
+- VSCode uses shared files for global, workspace and secret state.
+
+## [2.4.1]
+
+### Fixed
+
+- Fix infinite retry loop when write_to_file fails with missing content parameter. Provides progressive guidance to the model, escalating from suggestions to hard stops, with context window awareness to break the loop.
+
+## [2.4.0]
+
+### Added
+
+- Adding Anthropic Sonnet 4.6
+- Allows users to enter custom aws region when selecting bedrock as a provider in CLI
+- Keep reasoning rows visible when low-stakes tool groups start immediately after reasoning.
+- Restore reasoning trace visibility in chat and improve the thinking row UX so streamed reasoning is visible, then collapsible after completion.
+
+### Fixed
+
+- Banners now display immediately when opening the extension instead of requiring user interaction first
+- Resolved 17 security vulnerabilities including high-severity DoS issues in dependencies (body-parser, axios, qs, tar, and others)
+
+## [2.2.2]
+
+- Allows users to enter custom aws region when selecting bedrock as a provider
+- Prevent Parent Container Scrolling In Dropdowns
+
+## [2.2.1]
+
+- Added Minimax 2.5 Free Promo
+- Fixed Response chaining for OpenAI's Responses API
+
+## [2.2.0]
+
+### Added
+
+- Subagent: replace legacy subagents with the native `use_subagents` tool
+- Bundle `endpoints.json` support so packaged distributions can ship required endpoints out-of-the-box
+- Amazon Bedrock: support parallel tool calling
+- New "double-check completion" experimental feature to verify work before marking tasks complete
+- CLI: new task controls/flags including custom `--thinking` token budget and `--max-consecutive-mistakes` for yolo runs
+- Remote config: new UI/options (including connection/test buttons) and support for syncing deletion of remotely configured MCP servers
+- Vertex / Claude Code: add 1M context model options for Claude Opus 4.6
+- ZAI/GLM: add GLM-5
+
+### Fixed
+
+- CLI: handle stdin redirection correctly in CI/headless environments
+- CLI: preserve OAuth callback paths during auth redirects
+- VS Code Web: generate auth callback URLs via `vscode.env.asExternalUri` (OAuth callback reliability)
+- Terminal: surface command exit codes in results and improve long-running `execute_command` timeout behavior
+- UI: add loading indicator and fix `api_req_started` rendering
+- Task streaming: prevent duplicate streamed text rows after completion
+- API: preserve selected Vercel model when model metadata is missing
+- Telemetry: route PostHog networking through proxy-aware shared fetch and ensure telemetry flushes on shutdown
+- CI: increase Windows E2E test timeout to reduce flakiness
+
+### Changed
+
+- Settings/model UX: move "reasoning effort" into model configuration and expose it in settings
+- CLI provider selection: limit provider list to those remotely configured
+- UI: consolidate ViewHeader component/styling across views
+- Tools: add auto-approval support for `attempt_completion` commands
+- Remotely configured MCP server schema now supports custom headers
+
+## [2.1.0]
+
+### Minor Changes
+
+- 42ce100: Add Generate API Key on Hicap Provider selection
+
+### Patch Changes
+
+- 195294f: Add support for bundled endpoints.json in enterprise distributions. Extensions can now include a pre-configured endpoints.json file that automatically switches Cline to self-hosted mode. Includes packaging scripts for VSIX, NPM, and JetBrains plugins.
+- a1f2601: Replace the LiteLLM model list with a selector
+- 739d75a: Add Claude Code provider support for Claude Opus 4.6 and Sonnet 4.5 1M variants via both full model names and aliases (`opus[1m]`, `sonnet[1m]`), and align the `opus` alias with Opus 4.6.
+- 8440380: Add GitHub Actions workflow to build CLI from any commit for testing
+- b1a8db2: fix(cli): prevent hang when spawned without TTY
+- 7c87017: Add Claude Opus 4.6 model support
+- d116ac5: Supports rendering markdown table in chat view.
+- 6d8fb85: Fix CLI crashing in CI environments and with stdin redirection (e.g., `cline "prompt" < /dev/null`). Now checks both stdin and stdout TTY status before using Ink, and only errors on empty stdin when no prompt is provided.
+- 70a9904: Fix JetBrains sign-in regression by adding fallback for openExternal RPC
+- f440f3a: fix: use vscode.env.openExternal for auth in remote environments
+
+  Fixes OAuth authentication in VS Code Server and remote environments by routing browser URL opening through VS Code's native openExternal API instead of the npm 'open' package.
+
+- 70a9904: fix: use vscode.env.asExternalUri for auth callback URLs only in VS Code Web
+
+  Fixes OAuth callback redirect in VS Code Web (`code serve-web`, Codespaces) by using `vscode.env.asExternalUri()` to resolve the callback URI. This is gated behind a `vscode.env.uiKind === UIKind.Web` check so regular desktop VS Code continues to use the `vscode://` URI directly. The `getCallbackUrl` API now accepts a `path` parameter so the full callback URI (including route) is resolved correctly, and callers pass their path directly instead of appending after.
+
+- 5308ded: Updating script documentation and removing unnecessary continue on error
+- b514f18: Prevent duplicate streamed text rows when a partial text update arrives after the same text was already finalized.
+- 26391c9: Fix Bedrock model id
+- d19a877: Unify ViewHeader Styles Across All Views
+- 5dcaa8c: Add Vertex Claude Opus 4.6 1M model option and global endpoint support, and pass the 1M beta header for Vertex Claude requests.

cli/DEVELOPMENT.md

@@ -0,0 +1,365 @@
+# Cline CLI
+
+The official CLI for Cline. Run Cline tasks directly from the terminal with the same underlying functionality as the VS Code extension.
+
+## Features
+
+- **Reuses Core Codebase**: Shares the same Controller, Task, and API handling as the VS Code extension
+- **Terminal Output**: Displays Cline messages directly in your terminal with colored output
+- **Task History**: Access your task history from the command line
+- **Configurable**: Use custom configuration directories and working directories
+- **Image Support**: Attach images to your prompts using file paths or inline references
+
+## Prerequisites
+
+- Node.js 20.x or later
+- npm or yarn
+- The parent Cline project dependencies installed
+
+## Installation
+
+From the repository root:
+
+```bash
+# Install all dependencies first
+npm run install:all
+
+# Ensure protos are generated
+npm run protos
+
+# Build and link the CLI globally
+npm run cli:link
+```
+
+## Usage
+
+### Interactive Mode (Default)
+
+When you run `cline` without any command, it launches an interactive welcome prompt:
+
+```bash
+# Launch interactive mode
+cline
+
+# Or run a task directly
+cline "Create a hello world function in Python"
+
+# With options
+cline -v --thinking "Analyze this codebase"
+```
+
+### Commands
+
+#### `task` (alias: `t`)
+
+Run a new task with a prompt.
+
+```bash
+cline task "Create a hello world function in Python"
+cline t "Create a hello world function"
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `-a, --act` | Run in act mode |
+| `-p, --plan` | Run in plan mode |
+| `-y, --yolo` | Enable yolo mode (auto-approve actions) |
+| `-m, --model <model>` | Model to use for the task |
+| `-i, --images <paths...>` | Image file paths to include with the task |
+| `-v, --verbose` | Show verbose output including reasoning |
+| `-c, --cwd <path>` | Working directory for the task |
+| `--config <path>` | Path to Cline configuration directory |
+| `-t, --thinking` | Enable extended thinking (1024 token budget) |
+
+**Examples:**
+
+```bash
+# Run in plan mode with verbose output
+cline task -p -v "Design a REST API"
+
+# Use a specific model with yolo mode
+cline task -m claude-sonnet-4-5-20250929 -y "Refactor this function"
+
+# Include images with your prompt
+cline task -i screenshot.png diagram.jpg "Fix the UI based on these images"
+
+# Or use inline image references in the prompt
+cline task "Fix the layout shown in @./screenshot.png"
+
+# Enable extended thinking for complex tasks
+cline task -t "Architect a microservices system"
+
+# Specify working directory
+cline task -c /path/to/project "Add unit tests"
+```
+
+#### `history` (alias: `h`)
+
+List task history with pagination support.
+
+```bash
+cline history
+cline h
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `-n, --limit <number>` | Number of tasks to show (default: 10) |
+| `-p, --page <number>` | Page number, 1-based (default: 1) |
+| `--config <path>` | Path to Cline configuration directory |
+
+**Examples:**
+
+```bash
+# Show last 10 tasks (default)
+cline history
+
+# Show 20 tasks
+cline history -n 20
+
+# Show page 2 with 5 tasks per page
+cline history -n 5 -p 2
+```
+
+#### `config`
+
+Show current configuration including global and workspace state.
+
+```bash
+cline config
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `--config <path>` | Path to Cline configuration directory |
+
+#### `auth`
+
+Authenticate a provider and configure what model is used.
+
+```bash
+cline auth
+```
+
+**Options:**
+
+| Option | Description |
+|--------|-------------|
+| `-p, --provider <id>` | Provider ID for quick setup (e.g., openai-native, anthropic) |
+| `-k, --apikey <key>` | API key for the provider |
+| `-m, --modelid <id>` | Model ID to configure (e.g., gpt-4o, claude-sonnet-4-5-20250929) |
+| `-b, --baseurl <url>` | Base URL (optional, only for openai provider) |
+| `-v, --verbose` | Show verbose output |
+| `-c, --cwd <path>` | Working directory for the task |
+| `--config <path>` | Path to Cline configuration directory |
+
+**Examples:**
+
+```bash
+# Interactive authentication
+cline auth
+
+# Quick setup with provider and API key
+cline auth -p anthropic -k sk-ant-xxxxx
+
+# Full quick setup with model
+cline auth -p openai-native -k sk-xxxxx -m gpt-4o
+
+# OpenAI-compatible provider with custom base URL
+cline auth -p openai -k your-api-key -b https://api.example.com/v1
+```
+
+### Global Options
+
+These options are available for the default command (running a task directly):
+
+| Option | Description |
+|--------|-------------|
+| `-v, --verbose` | Show verbose output |
+| `-c, --cwd <path>` | Working directory |
+| `--config <path>` | Configuration directory |
+| `--thinking` | Enable extended thinking (1024 token budget) |
+
+## Development
+
+### Quick Start
+
+```bash
+# 1. Install all dependencies (root, webview-ui, cli)
+npm run install:all
+
+# 2. Build and link globally so you can run `cline` from anywhere
+npm run cli:link
+
+# 3. Test it
+cline --help
+```
+
+### Scripts
+
+Run these from the repository root:
+
+| Script | Description |
+|--------|-------------|
+| `npm run install:all` | Install deps for root, webview-ui, and cli |
+| `npm run cli:build` | Generate protos and build CLI |
+| `npm run cli:build:production` | Production build (minified) |
+| `npm run cli:link` | Build and `npm link` so you can run `cline` from anywhere |
+| `npm run cli:unlink` | Remove the global `cline` symlink |
+| `npm run cli:dev` | Link + watch mode for development |
+| `npm run cli:watch` | Watch mode only (no initial build) |
+| `npm run cli:test` | Run CLI tests |
+
+### Development Workflow
+
+1. Run `npm run cli:dev` - this links the CLI globally and starts watch mode
+2. Make changes to files in `cli/src/`
+3. The build automatically rebuilds on save
+4. Test your changes by running `cline` in another terminal
+5. When done, run `npm run cli:unlink` to clean up
+
+### Proto Generation
+
+The CLI uses proto-generated types for message passing (same as the VS Code extension). If you modify any `.proto` files, run:
+
+```bash
+npm run protos
+```
+
+This generates TypeScript types in `src/generated/` that both the CLI and extension use.
+
+## Publish
+
+#### 1. Publish to npm
+```bash
+npm publish
+```
+
+#### 2. Update the Homebrew formula
+```bash
+npm run update-brew-formula
+```
+
+#### 3. Test the formula locally
+```bash
+# Create a local tap
+brew tap-new cline/local
+cp ./cli/cline.rb "$(brew --repository)/Library/Taps/cline/homebrew-local/Formula/cline.rb"
+
+# Build from Source
+brew install --build-from-source cline/local/cline
+
+# Install from your local tap
+brew install cline/local/cline
+
+# Clean up when done
+brew untap cline/local
+```
+
+#### 4. If using a tap, commit and push
+```bash
+git add cline.rb
+git commit -m "Update cline to v2.0.0"
+git push
+```
+
+## Architecture
+
+### How It Works
+
+The CLI directly imports and reuses the core Cline TypeScript codebase (the same code that powers the VS Code extension). This means feature parity is easy to maintain - when core gets updated, the CLI automatically benefits.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                     CLI (cli/)                          │
+│  - React Ink terminal UI                                │
+│  - Command parsing (commander)                          │
+│  - Terminal-specific adapters                           │
+└─────────────────────────────────────────────────────────┘
+                          │
+                          │ direct imports
+                          ▼
+┌─────────────────────────────────────────────────────────┐
+│                  Core (src/core/)                       │
+│  - Controller: task lifecycle, state management         │
+│  - Task: AI API calls, tool execution                   │
+│  - StateManager: persistent storage                     │
+│  - Proto types: message definitions                     │
+└─────────────────────────────────────────────────────────┘
+```
+
+Unlike a client-server architecture, the CLI runs everything in a single Node.js process. The "host bridge" pattern provides terminal-appropriate implementations for things the VS Code extension would handle differently (clipboard, file dialogs, etc.).
+
+### Key Files
+
+| File | Purpose |
+|------|---------|
+| `src/index.ts` | Entry point, command definitions |
+| `src/components/App.tsx` | Main React Ink app |
+| `src/components/ChatView.tsx` | Task conversation UI |
+| `src/controllers/CliWebviewProvider.ts` | Bridges core messages to terminal output |
+| `src/vscode-context.ts` | Mock VS Code extension context for core compatibility |
+| `src/vscode-shim.ts` | Shims for VS Code APIs that core depends on |
+| `src/constants/colors.ts` | Terminal color definitions |
+
+### React Ink
+
+The CLI uses [React Ink](https://github.com/vadimdemedes/ink) for its terminal UI. This lets us build the interface with React components that render to the terminal. Key patterns:
+
+- Components in `src/components/` render terminal UI
+- Hooks in `src/hooks/` manage terminal-specific state (size, scrolling)
+- The `useStateSubscriber` hook subscribes to core state changes
+
+## Configuration
+
+The CLI stores its data in `~/.cline/data/` by default:
+
+- `globalState.json`: Global settings and state
+- `secrets.json`: API keys and secrets
+- `workspace/`: Workspace-specific state
+- `tasks/`: Task history and conversation data
+
+Override with the `--config` option or `CLINE_DIR` environment variable.
+
+## Troubleshooting
+
+### Build Errors
+
+If you encounter build errors:
+
+```bash
+# Make sure all deps are installed
+npm run install:all
+
+# Regenerate proto types
+npm run protos
+
+# Then rebuild
+npm run cli:build
+```
+
+### "command not found: cline"
+
+The CLI isn't linked globally. Run:
+
+```bash
+npm run cli:link
+```
+
+### Changes Not Reflected
+
+If your code changes aren't showing up:
+
+1. Make sure watch mode is running (`npm run cli:dev`)
+2. Check for TypeScript errors in the watch output
+3. Try unlinking and relinking: `npm run cli:unlink && npm run cli:link`
+
+### Import Errors from Core
+
+The CLI imports from `@core/`, `@shared/`, etc. These paths are defined in the root `tsconfig.json`. If you see import errors, make sure you're building from the repo root, not from inside `cli/`.

cli/README.md

@@ -0,0 +1,81 @@
+# Cline
+
+<p align="center">
+  <img src="https://github.com/user-attachments/assets/7123f9d1-afeb-48d5-93fa-e750dec0ebba" width="70%" />
+</p>
+
+<div align="center">
+<table>
+<tbody>
+<td align="center">
+<a href="https://www.npmjs.com/package/cline" target="_blank"><strong>NPM</strong></a>
+</td>
+<td align="center">
+<a href="https://discord.gg/cline" target="_blank"><strong>Discord</strong></a>
+</td>
+<td align="center">
+<a href="https://www.reddit.com/r/cline/" target="_blank"><strong>r/cline</strong></a>
+</td>
+<td align="center">
+<a href="https://github.com/cline/cline/discussions/categories/feature-requests?discussions_q=is%3Aopen+category%3A%22Feature+Requests%22+sort%3Atop" target="_blank"><strong>Feature Requests</strong></a>
+</td>
+<td align="center">
+<a href="https://docs.cline.bot/getting-started/for-new-coders" target="_blank"><strong>Getting Started</strong></a>
+</td>
+</tbody>
+</table>
+</div>
+
+Meet Cline, an AI assistant that lives in your terminal.
+
+Cline can handle complex software development tasks step-by-step. With tools that let him create & edit files, explore large projects, use the browser, and execute terminal commands (after you grant permission), he can assist you in ways that go beyond code completion or tech support.
+
+```bash
+npm i -g cline
+
+# cd into your project and run:
+cline
+```
+
+> Move your mouse around under the Cline icon for a surprise!
+
+---
+
+<img align="right" width="340" src="https://github.com/user-attachments/assets/ceb74224-08aa-4b8b-a3e7-b438ac3d160a">
+
+### Use any API and Model
+
+Cline supports API providers like ChatGPT, Anthropic, OpenAI, Google Gemini, AWS Bedrock, Azure, GCP Vertex, Cerebras, Groq, and Moonshot. You can also configure any OpenAI compatible API, or use a local model through LM Studio/Ollama. If you're using a Cline Account, you'll always have access to the newest models as soon as they're available.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/ee14e6f7-20b8-4391-9091-8e8e25561929"><br>
+
+<img align="left" width="370" src="https://github.com/user-attachments/assets/cad091f6-6c0f-4e4b-97ea-a1ff67e39b9b">
+
+### Stay in Control with Human-in-the-Loop
+
+Cline asks for your approval before running commands, editing files, or taking any action. Review each step and approve or reject as you go—or enable auto-approve to let Cline work autonomously to completion.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/cad091f6-6c0f-4e4b-97ea-a1ff67e39b9b"><br>
+
+<img align="right" width="400" src="https://github.com/user-attachments/assets/4f264a0c-3802-49a7-8e5e-13d97beb659e">
+
+### Plan & Act Modes
+
+Toggle to Plan Mode to discuss implementation and architecture with Cline. He'll ask clarifying questions, explore your codebase, and present a plan for you to align on. Once you're satisfied, switch to Act Mode and let Cline execute the plan.
+
+<!-- Transparent pixel to create line break after floating image -->
+
+<img width="2000" height="0" src="https://github.com/user-attachments/assets/4f264a0c-3802-49a7-8e5e-13d97beb659e"><br>
+
+
+## Enterprise
+
+Get the same Cline experience with enterprise-grade controls: SSO (SAML/OIDC), global policies and configuration, observability with audit trails, private networking (VPC/private link), and self-hosted or on-prem deployments, and enterprise support. Learn more at our [enterprise page](https://cline.bot/enterprise) or [talk to us](https://cline.bot/contact-sales).
+
+## License
+
+[Apache 2.0 © 2026 Cline Bot Inc.](./LICENSE)

cli/cline.rb

@@ -0,0 +1,21 @@
+# IMPORTANT: `npm run postpublish` to update this file after publishing a new version of the package
+class Cline < Formula
+  desc "Autonomous coding agent CLI - capable of creating/editing files, running commands, and more"
+  homepage "https://cline.bot"
+  url "https://registry.npmjs.org/cline/-/cline-2.0.0.tgz" # GET from https://registry.npmjs.org/cline/latest tarball URL
+  sha256 "65bae90401191aeeabfbbc0b315e816aea96742043ba85b90671bf5e19d0761e"
+  license "Apache-2.0"
+
+  depends_on "node@20"
+  depends_on "ripgrep"
+
+  def install
+    system "npm", "install", *std_npm_args(prefix: false)
+    bin.install_symlink Dir["#{libexec}/bin/*"]
+  end
+
+  test do
+    # Test that the binary exists and is executable
+    assert_match version.to_s, shell_output("#{bin}/cline --version")
+  end
+end

cli/esbuild.mts

@@ -0,0 +1,305 @@
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import dotenv from "dotenv"
+import * as esbuild from "esbuild"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const rootDir = path.resolve(__dirname, "..")
+
+// Load .env from repo root
+dotenv.config({ path: path.join(rootDir, ".env") })
+
+const production = process.argv.includes("--production")
+const watch = process.argv.includes("--watch")
+
+/**
+ * Plugin to resolve path aliases from the parent project
+ */
+const aliasResolverPlugin: esbuild.Plugin = {
+	name: "alias-resolver",
+	setup(build) {
+		const aliases = {
+			"@": path.resolve(rootDir, "src"),
+			"@core": path.resolve(rootDir, "src/core"),
+			"@integrations": path.resolve(rootDir, "src/integrations"),
+			"@services": path.resolve(rootDir, "src/services"),
+			"@shared": path.resolve(rootDir, "src/shared"),
+			"@utils": path.resolve(rootDir, "src/utils"),
+			"@packages": path.resolve(rootDir, "src/packages"),
+			"@hosts": path.resolve(rootDir, "src/hosts"),
+			"@generated": path.resolve(rootDir, "src/generated"),
+			"@api": path.resolve(rootDir, "src/core/api"),
+		}
+
+		// For each alias entry, create a resolver
+		Object.entries(aliases).forEach(([alias, aliasPath]) => {
+			const aliasRegex = new RegExp(`^${alias}($|/.*)`)
+			build.onResolve({ filter: aliasRegex }, (args) => {
+				const importPath = args.path.replace(alias, aliasPath)
+
+				// First, check if the path exists as is
+				if (fs.existsSync(importPath)) {
+					const stats = fs.statSync(importPath)
+					if (stats.isDirectory()) {
+						// If it's a directory, try to find index files
+						const extensions = [".ts", ".tsx", ".js", ".jsx"]
+						for (const ext of extensions) {
+							const indexFile = path.join(importPath, `index${ext}`)
+							if (fs.existsSync(indexFile)) {
+								return { path: indexFile }
+							}
+						}
+					} else {
+						// It's a file that exists, so return it
+						return { path: importPath }
+					}
+				}
+
+				// If the path doesn't exist, try appending extensions
+				const extensions = [".ts", ".tsx", ".js", ".jsx"]
+				for (const ext of extensions) {
+					const pathWithExtension = `${importPath}${ext}`
+					if (fs.existsSync(pathWithExtension)) {
+						return { path: pathWithExtension }
+					}
+				}
+
+				// Handle .js -> .ts extension mapping (common in ESM TypeScript projects)
+				if (importPath.endsWith(".js")) {
+					const tsPath = importPath.replace(/\.js$/, ".ts")
+					if (fs.existsSync(tsPath)) {
+						return { path: tsPath }
+					}
+					const tsxPath = importPath.replace(/\.js$/, ".tsx")
+					if (fs.existsSync(tsxPath)) {
+						return { path: tsxPath }
+					}
+				}
+
+				// If nothing worked, return the original path and let esbuild handle the error
+				return { path: importPath }
+			})
+		})
+	},
+}
+
+/**
+ * Plugin to redirect vscode imports to our shim
+ */
+const vscodeStubPlugin: esbuild.Plugin = {
+	name: "vscode-stub",
+	setup(build) {
+		// Redirect 'vscode' imports to our shim
+		build.onResolve({ filter: /^vscode$/ }, () => {
+			return { path: path.join(__dirname, "src", "vscode-shim.ts") }
+		})
+	},
+}
+
+const esbuildProblemMatcherPlugin: esbuild.Plugin = {
+	name: "esbuild-problem-matcher",
+	setup(build) {
+		build.onStart(() => {
+			console.log("[cli esbuild] Build started...")
+		})
+		build.onEnd((result) => {
+			result.errors.forEach(({ text, location }) => {
+				console.error(`✘ [ERROR] ${text}`)
+				if (location) {
+					console.error(`    ${location.file}:${location.line}:${location.column}:`)
+				}
+			})
+			console.log("[cli esbuild] Build finished")
+		})
+	},
+}
+
+// Plugin to stub out optional devtools module
+const stubOptionalModulesPlugin: esbuild.Plugin = {
+	name: "stub-optional-modules",
+	setup(build) {
+		build.onResolve({ filter: /^react-devtools-core$/ }, () => {
+			return { path: path.join(__dirname, "src", "stub-devtools.js"), external: false }
+		})
+	},
+}
+
+const copyWasmFiles: esbuild.Plugin = {
+	name: "copy-wasm-files",
+	setup(build) {
+		build.onEnd(() => {
+			const destDir = path.join(__dirname, "dist")
+
+			// Ensure dist directory exists
+			if (!fs.existsSync(destDir)) {
+				fs.mkdirSync(destDir, { recursive: true })
+			}
+
+			// tree sitter
+			const sourceDir = path.join(rootDir, "node_modules", "web-tree-sitter")
+
+			// Copy tree-sitter.wasm
+			const treeSitterWasm = path.join(sourceDir, "tree-sitter.wasm")
+			if (fs.existsSync(treeSitterWasm)) {
+				fs.copyFileSync(treeSitterWasm, path.join(destDir, "tree-sitter.wasm"))
+			}
+
+			// Copy language-specific WASM files
+			const languageWasmDir = path.join(rootDir, "node_modules", "tree-sitter-wasms", "out")
+			const languages = [
+				"typescript",
+				"tsx",
+				"python",
+				"rust",
+				"javascript",
+				"go",
+				"cpp",
+				"c",
+				"c_sharp",
+				"ruby",
+				"java",
+				"php",
+				"swift",
+				"kotlin",
+			]
+
+			if (fs.existsSync(languageWasmDir)) {
+				languages.forEach((lang) => {
+					const filename = `tree-sitter-${lang}.wasm`
+					const sourcePath = path.join(languageWasmDir, filename)
+					if (fs.existsSync(sourcePath)) {
+						fs.copyFileSync(sourcePath, path.join(destDir, filename))
+					}
+				})
+			}
+		})
+	},
+}
+
+const buildEnvVars: Record<string, string> = {
+	"process.env.IS_STANDALONE": JSON.stringify("true"),
+	"process.env.IS_CLI": JSON.stringify("true"),
+}
+
+const buildTimeEnvs = [
+	"TELEMETRY_SERVICE_API_KEY",
+	"ERROR_SERVICE_API_KEY",
+	"ENABLE_ERROR_AUTOCAPTURE",
+	"POSTHOG_TELEMETRY_ENABLED",
+	"OTEL_TELEMETRY_ENABLED",
+	"OTEL_LOGS_EXPORTER",
+	"OTEL_METRICS_EXPORTER",
+	"OTEL_EXPORTER_OTLP_PROTOCOL",
+	"OTEL_EXPORTER_OTLP_ENDPOINT",
+	"OTEL_EXPORTER_OTLP_HEADERS",
+	"OTEL_METRIC_EXPORT_INTERVAL",
+	"CLINE_ENVIRONMENT",
+]
+
+buildTimeEnvs.forEach((envVar) => {
+	if (process.env[envVar]) {
+		console.log(`[cli esbuild] ${envVar} env var is set`)
+		buildEnvVars[`process.env.${envVar}`] = JSON.stringify(process.env[envVar])
+	}
+})
+
+if (production) {
+	buildEnvVars["process.env.IS_DEV"] = "false"
+}
+
+// Shared build options
+const sharedOptions: Partial<esbuild.BuildOptions> = {
+	bundle: true,
+	minify: production,
+	sourcemap: !production,
+	logLevel: "silent",
+	define: buildEnvVars,
+	tsconfig: path.join(__dirname, "tsconfig.json"),
+	plugins: [copyWasmFiles, aliasResolverPlugin, vscodeStubPlugin, stubOptionalModulesPlugin, esbuildProblemMatcherPlugin],
+	format: "esm",
+	sourcesContent: false,
+	platform: "node",
+	target: "node20",
+	// These modules need to load files from the module directory at runtime
+	external: [
+		"@grpc/reflection",
+		"grpc-health-check",
+		"better-sqlite3",
+		"ink",
+		"ink-spinner",
+		"ink-picture",
+		"react",
+		"aws4fetch",
+		"pino",
+		"pino-roll",
+		"@vscode/ripgrep", // Uses __dirname to locate the binary
+	],
+	supported: { "top-level-await": true },
+}
+
+// CLI executable configuration
+const cliConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "index.ts")],
+	outfile: path.join(__dirname, "dist", "cli.mjs"),
+	banner: {
+		js: `#!/usr/bin/env node
+// Suppress all Node.js warnings (deprecation, experimental, etc.)
+process.emitWarning = () => {};
+import { createRequire as _createRequire } from 'module';
+import { fileURLToPath as _fileURLToPath } from 'url';
+import { dirname as _dirname } from 'path';
+const require = _createRequire(import.meta.url);
+const __filename = _fileURLToPath(import.meta.url);
+const __dirname = _dirname(__filename);`,
+	},
+}
+
+// Library configuration for programmatic use
+const libConfig: esbuild.BuildOptions = {
+	...sharedOptions,
+	entryPoints: [path.join(__dirname, "src", "exports.ts")],
+	outfile: path.join(__dirname, "dist", "lib.mjs"),
+	banner: {
+		js: `// Cline Library - Programmatic API
+import { createRequire as _createRequire } from 'module';
+import { fileURLToPath as _fileURLToPath } from 'url';
+import { dirname as _dirname } from 'path';
+const require = _createRequire(import.meta.url);
+const __filename = _fileURLToPath(import.meta.url);
+const __dirname = _dirname(__filename);`,
+	},
+}
+
+async function main() {
+	if (watch) {
+		// In watch mode, only watch the CLI (primary use case for development)
+		const ctx = await esbuild.context(cliConfig)
+		await ctx.watch()
+		console.log("[cli] Watching for changes...")
+	} else {
+		// Build both CLI and library
+		console.log("[cli esbuild] Building CLI executable...")
+		const cliCtx = await esbuild.context(cliConfig)
+		await cliCtx.rebuild()
+		await cliCtx.dispose()
+
+		console.log("[cli esbuild] Building library bundle...")
+		const libCtx = await esbuild.context(libConfig)
+		await libCtx.rebuild()
+		await libCtx.dispose()
+
+		// Make the CLI output executable
+		const cliOutfile = path.join(__dirname, "dist", "cli.mjs")
+		if (fs.existsSync(cliOutfile)) {
+			fs.chmodSync(cliOutfile, "755")
+		}
+	}
+}
+
+main().catch((e) => {
+	console.error(e)
+	process.exit(1)
+})

cli/man/cline.1

@@ -0,0 +1,412 @@
+.\" Automatically generated by Pandoc 3.8.3
+.\"
+.TH "CLINE" "1" "January 2026" "Cline CLI 2.0" "User Commands"
+.SH NAME
+cline \- AI coding assistant in your terminal
+.SH SYNOPSIS
+\f[B]cline\f[R] [\f[I]prompt\f[R]] [\f[I]options\f[R]]
+.PP
+\f[B]cline\f[R] \f[I]command\f[R] [\f[I]options\f[R]]
+[\f[I]arguments\f[R]]
+.SH DESCRIPTION
+\f[B]cline\f[R] is a command\-line interface for the Cline AI coding
+assistant.
+It provides the same powerful AI capabilities as the VS Code extension,
+directly in your terminal.
+.PP
+Cline is an autonomous AI agent that can read, write, and execute code
+across your projects.
+He can create and edit files, run terminal commands, use a headless
+browser, and more\(emall while asking for your approval before taking
+actions.
+.PP
+The CLI supports both interactive mode (with a rich terminal UI) and
+plain text mode (for piped input and scripted workflows).
+.SH MODES OF OPERATION
+\f[B]Interactive Mode\f[R] : When you run \f[B]cline\f[R] without
+arguments, it launches an interactive welcome prompt with a rich
+terminal UI.
+You can type your task, view conversation history, and interact with
+Cline in real\-time.
+.PP
+\f[B]Task Mode\f[R] : Run \f[B]cline \(lqprompt\(rq\f[R] or \f[B]cline
+task \(lqprompt\(rq\f[R] to immediately start a task.
+If stdin is a TTY, you\(cqll see the interactive UI.
+If stdin is piped or output is redirected, the CLI automatically
+switches to plain text mode.
+.PP
+\f[B]Plain Text Mode\f[R] : Activated automatically when stdin is piped,
+output is redirected, or \f[B]\-\-json\f[R]/\f[B]\-\-yolo\f[R] flags are
+used.
+Outputs clean text without the Ink UI, suitable for scripting and CI/CD
+pipelines.
+.SH AGENT BEHAVIOR
+Cline operates in two primary modes:
+.PP
+\f[B]ACT MODE\f[R] : Cline actively uses tools to accomplish tasks.
+He can read files, write code, execute commands, use a headless browser,
+and more.
+This is the default mode for task execution.
+.PP
+\f[B]PLAN MODE\f[R] : Cline gathers information and creates a detailed
+plan before implementation.
+He explores the codebase, asks clarifying questions, and presents a
+strategy for user approval before switching to ACT MODE.
+.SH COMMANDS
+.SS task (alias: t)
+Run a new task with a prompt.
+.PP
+\f[B]cline task\f[R] \f[I]prompt\f[R] [\f[I]options\f[R]]
+.PP
+\f[B]cline t\f[R] \f[I]prompt\f[R] [\f[I]options\f[R]] : Create and run
+a new task.
+Options:
+.PP
+\f[B]\-a\f[R], \f[B]\-\-act\f[R] : Run in act mode (default)
+.PP
+\f[B]\-p\f[R], \f[B]\-\-plan\f[R] : Run in plan mode
+.PP
+\f[B]\-y\f[R], \f[B]\-\-yolo\f[R] : Enable yolo/yes mode (auto\-approve
+all actions, output in plain mode, exit process automatically when task
+complete)
+.PP
+\f[B]\-m\f[R], \f[B]\-\-model\f[R] \f[I]model\f[R] : Model to use for
+the task
+.PP
+\f[B]\-i\f[R], \f[B]\-\-images\f[R] \f[I]paths\&...\f[R] : Image file
+paths to include with the task
+.PP
+\f[B]\-v\f[R], \f[B]\-\-verbose\f[R] : Show verbose output including
+reasoning
+.PP
+\f[B]\-c\f[R], \f[B]\-\-cwd\f[R] \f[I]path\f[R] : Working directory for
+the task
+.PP
+\f[B]\-\-config\f[R] \f[I]path\f[R] : Path to Cline configuration
+directory
+.PP
+\f[B]\-\-thinking\f[R] : Enable extended thinking (1024 token budget)
+.PP
+\f[B]\-\-json\f[R] : Output messages as JSON instead of styled text
+.PP
+\f[B]\-T\f[R], \f[B]\-\-taskId\f[R] \f[I]id\f[R] : Resume an existing
+task by ID.
+The prompt argument becomes an optional follow\-up message.
+.SS history (alias: h)
+List task history with pagination.
+.PP
+\f[B]cline history\f[R] [\f[I]options\f[R]]
+.PP
+\f[B]cline h\f[R] [\f[I]options\f[R]] : Display previous tasks.
+Options:
+.PP
+\f[B]\-n\f[R], \f[B]\-\-limit\f[R] \f[I]number\f[R] : Number of tasks to
+show (default: 10)
+.PP
+\f[B]\-p\f[R], \f[B]\-\-page\f[R] \f[I]number\f[R] : Page number,
+1\-based (default: 1)
+.PP
+\f[B]\-\-config\f[R] \f[I]path\f[R] : Path to Cline configuration
+directory
+.SS config
+Show current configuration.
+.PP
+\f[B]cline config\f[R] [\f[I]options\f[R]] : Display global and
+workspace state.
+Options:
+.PP
+\f[B]\-\-config\f[R] \f[I]path\f[R] : Path to Cline configuration
+directory
+.SS auth
+Authenticate a provider and configure the model.
+.PP
+\f[B]cline auth\f[R] [\f[I]options\f[R]] : Launch interactive
+authentication wizard, or use quick setup flags.
+Options:
+.PP
+\f[B]\-p\f[R], \f[B]\-\-provider\f[R] \f[I]id\f[R] : Provider ID for
+quick setup (e.g., openai\-native, anthropic, openrouter, moonshot)
+.PP
+\f[B]\-k\f[R], \f[B]\-\-apikey\f[R] \f[I]key\f[R] : API key for the
+provider
+.PP
+\f[B]\-m\f[R], \f[B]\-\-modelid\f[R] \f[I]id\f[R] : Model ID to
+configure (e.g., gpt\-4o, claude\-sonnet\-4\-5\-20250929, kimi\-k2.5)
+.PP
+\f[B]\-b\f[R], \f[B]\-\-baseurl\f[R] \f[I]url\f[R] : Base URL (optional,
+for OpenAI\-compatible providers)
+.PP
+\f[B]\-v\f[R], \f[B]\-\-verbose\f[R] : Show verbose output
+.PP
+\f[B]\-c\f[R], \f[B]\-\-cwd\f[R] \f[I]path\f[R] : Working directory
+.PP
+\f[B]\-\-config\f[R] \f[I]path\f[R] : Path to Cline configuration
+directory
+.SS update
+Check for updates and install if available.
+.PP
+\f[B]cline update\f[R] [\f[I]options\f[R]] : Check npm for newer
+versions.
+Options:
+.PP
+\f[B]\-v\f[R], \f[B]\-\-verbose\f[R] : Show verbose output
+.SS version
+Show the CLI version number.
+.PP
+\f[B]cline version\f[R]
+.SS dev
+Developer tools and utilities.
+.PP
+\f[B]cline dev log\f[R] : Open the log file for debugging.
+.SH DEFAULT COMMAND OPTIONS
+When running \f[B]cline\f[R] with just a prompt (no subcommand), these
+options are available:
+.PP
+\f[B]\-a\f[R], \f[B]\-\-act\f[R] : Run in act mode (default)
+.PP
+\f[B]\-p\f[R], \f[B]\-\-plan\f[R] : Run in plan mode
+.PP
+\f[B]\-y\f[R], \f[B]\-\-yolo\f[R] : Enable yolo mode (auto\-approve all
+actions).
+Also forces plain text output mode.
+.PP
+\f[B]\-m\f[R], \f[B]\-\-model\f[R] \f[I]model\f[R] : Model to use for
+the task
+.PP
+\f[B]\-v\f[R], \f[B]\-\-verbose\f[R] : Show verbose output
+.PP
+\f[B]\-c\f[R], \f[B]\-\-cwd\f[R] \f[I]path\f[R] : Working directory
+.PP
+\f[B]\-\-config\f[R] \f[I]path\f[R] : Configuration directory
+.PP
+\f[B]\-\-thinking\f[R] : Enable extended thinking (1024 token budget)
+.PP
+\f[B]\-\-json\f[R] : Output messages as JSON instead of styled text.
+Forces plain text mode.
+.PP
+\f[B]\-T\f[R], \f[B]\-\-taskId\f[R] \f[I]id\f[R] : Resume an existing
+task by ID instead of starting a new one.
+The prompt becomes an optional follow\-up message.
+.SH JSON OUTPUT FORMAT
+When using \f[B]\-\-json\f[R], each message is output as a JSON object
+with these fields:
+.PP
+\f[B]Required fields:\f[R]
+.IP \(bu 2
+\f[B]type\f[R]: \(lqask\(rq or \(lqsay\(rq
+.IP \(bu 2
+\f[B]text\f[R]: message text
+.IP \(bu 2
+\f[B]ts\f[R]: Unix epoch timestamp in milliseconds
+.PP
+\f[B]Optional fields:\f[R]
+.IP \(bu 2
+\f[B]reasoning\f[R]: reasoning text
+.IP \(bu 2
+\f[B]say\f[R]: say subtype (when type is \(lqsay\(rq)
+.IP \(bu 2
+\f[B]ask\f[R]: ask subtype (when type is \(lqask\(rq)
+.IP \(bu 2
+\f[B]partial\f[R]: streaming flag
+.IP \(bu 2
+\f[B]images\f[R]: list of image URIs
+.IP \(bu 2
+\f[B]files\f[R]: list of file paths
+.SH EXAMPLES
+.SS Basic Usage
+.IP
+.EX
+\f[I]# Launch interactive mode\f[R]
+cline
+
+\f[I]# Run a task directly\f[R]
+cline \(dqCreate a hello world function in Python\(dq
+
+\f[I]# Run with verbose output and extended thinking\f[R]
+cline \-v \-\-thinking \(dqAnalyze this codebase architecture\(dq
+.EE
+.SS Mode Selection
+.IP
+.EX
+\f[I]# Run in plan mode (gather info before acting)\f[R]
+cline \-p \(dqDesign a REST API for user management\(dq
+
+\f[I]# Run in act mode with auto\-approval (yolo)\f[R]
+cline \-y \(dqFix the typo in README.md\(dq
+.EE
+.SS Using Specific Models
+.IP
+.EX
+\f[I]# Use a specific model\f[R]
+cline \-m claude\-sonnet\-4\-5\-20250929 \(dqRefactor this function\(dq
+
+\f[I]# Quick auth setup with model\f[R]
+cline auth \-p anthropic \-k sk\-ant\-xxxxx \-m claude\-sonnet\-4\-5\-20250929
+
+\f[I]# Quick auth setup for Moonshot\f[R]
+cline auth \-p moonshot \-k sk\-xxxxx \-m kimi\-k2.5
+.EE
+.SS Including Images
+.IP
+.EX
+\f[I]# Include images with explicit flag\f[R]
+cline task \-i screenshot.png diagram.jpg \(dqFix the UI based on these images\(dq
+
+\f[I]# Or use inline image references in the prompt\f[R]
+cline \(dqFix the layout shown in \(at./screenshot.png\(dq
+.EE
+.SS Piped Input
+.IP
+.EX
+\f[I]# Pipe file contents to Cline\f[R]
+cat README.md \f[B]|\f[R] cline \(dqSummarize this document\(dq
+
+\f[I]# Pipe with additional prompt\f[R]
+echo \(dqfunction add(a, b) { return a + b }\(dq \f[B]|\f[R] cline \(dqAdd TypeScript types to this\(dq
+
+\f[I]# Combine piped input with a prompt\f[R]
+git diff \f[B]|\f[R] cline \(dqReview these changes and suggest improvements\(dq
+.EE
+.SS Scripting and Automation
+.IP
+.EX
+\f[I]# JSON output for parsing\f[R]
+cline \-\-json \(dqWhat files are in this directory?\(dq \f[B]|\f[R] jq \(aq.text\(aq
+
+\f[I]# Yolo mode for automated workflows (auto\-approves all actions), forces plain text output\f[R]
+cline \-y \(dqRun the test suite and fix any failures\(dq
+.EE
+.SS Task History
+.IP
+.EX
+\f[I]# List recent tasks\f[R]
+cline history
+
+\f[I]# Show more tasks with pagination\f[R]
+cline history \-n 20 \-p 2
+.EE
+.SS Resuming Tasks
+.IP
+.EX
+\f[I]# Resume a task by ID (get IDs from cline history)\f[R]
+cline \-T abc123def
+
+\f[I]# Resume a task with a follow\-up message\f[R]
+cline \-T abc123def \(dqNow add unit tests for the changes\(dq
+
+\f[I]# Resume in plan mode to review before continuing\f[R]
+cline \-T abc123def \-p \(dqWhat\(aqs left to do?\(dq
+
+\f[I]# Resume with yolo mode for automated continuation\f[R]
+cline \-T abc123def \-y \(dqContinue with the implementation\(dq
+.EE
+.SS Authentication
+.IP
+.EX
+\f[I]# Interactive authentication wizard\f[R]
+cline auth
+
+\f[I]# Quick setup for Anthropic\f[R]
+cline auth \-p anthropic \-k sk\-ant\-api\-xxxxx
+
+\f[I]# Quick setup for OpenAI\f[R]
+cline auth \-p openai\-native \-k sk\-xxxxx \-m gpt\-4o
+
+\f[I]# Quick setup for Moonshot\f[R]
+cline auth \-p moonshot \-k sk\-xxxxx \-m kimi\-k2.5
+
+\f[I]# OpenAI\-compatible provider with custom base URL\f[R]
+cline auth \-p openai \-k your\-api\-key \-b https://api.example.com/v1
+.EE
+.SH ENVIRONMENT
+\f[B]CLINE_DIR\f[R] : Override the default configuration directory.
+When set, Cline stores all data in this directory instead of
+\f[CR]\(ti/.cline/data/\f[R].
+.PP
+\f[B]CLINE_COMMAND_PERMISSIONS\f[R] : JSON configuration for restricting
+which shell commands Cline can execute.
+When set, commands are validated against allow/deny patternks before
+execution.
+When not set, all commands are allowed.
+.PP
+Format:
+\f[CR]{\(dqallow\(dq: [\(dqpattern1\(dq, \(dqpattern2\(dq], \(dqdeny\(dq: [\(dqpattern3\(dq], \(dqallowRedirects\(dq: true}\f[R]
+.PP
+\f[B]Fields:\f[R]
+.IP \(bu 2
+\f[B]allow\f[R] (array of strings): Glob patterns for allowed commands.
+If specified, only matching commands are permitted.
+Uses \f[CR]*\f[R] to match any characters and \f[CR]?\f[R] to match a
+single character.
+Setting allow on anything will deny all others.
+.IP \(bu 2
+\f[B]deny\f[R] (array of strings): Glob patterns for denied commands.
+Deny rules take precedence over allow rules.
+.IP \(bu 2
+\f[B]allowRedirects\f[R] (boolean): Whether to allow shell redirects
+(\f[CR]>\f[R], \f[CR]>>\f[R], \f[CR]<\f[R], etc.).
+Defaults to false.
+.PP
+\f[B]Rule evaluation:\f[R]
+.IP "1." 3
+Check for dangerous characters (backticks outside single quotes,
+unquoted newlines)
+.IP "2." 3
+Parse command into segments split by operators (\f[CR]&&\f[R],
+\f[CR]||\f[R], \f[CR]|\f[R], \f[CR];\f[R])
+.IP "3." 3
+If redirects detected and \f[CR]allowRedirects\f[R] is not true, command
+is denied
+.IP "4." 3
+Each segment is validated against deny rules first, then allow rules
+.IP "5." 3
+Subshell contents (\f[CR]$(...)\f[R] and \f[CR](...)\f[R]) are
+recursively validated
+.IP "6." 3
+All segments must pass for the command to be allowed
+.PP
+\f[B]Examples:\f[R]
+.IP
+.EX
+\f[I]# Allow only npm and git commands.\f[R]
+export CLINE_COMMAND_PERMISSIONS=\(aq{\(dqallow\(dq: [\(dqnpm *\(dq, \(dqgit *\(dq]}\(aq
+
+\f[I]# Allow development commands but deny dangerous ones. Deny not strictly required here since allow is set.\f[R]
+export CLINE_COMMAND_PERMISSIONS=\(aq{\(dqallow\(dq: [\(dqnpm *\(dq, \(dqgit *\(dq, \(dqnode *\(dq], \(dqdeny\(dq: [\(dqrm \-rf *\(dq, \(dqsudo *\(dq]}\(aq
+
+\f[I]# Allow file operations with redirects\f[R]
+export CLINE_COMMAND_PERMISSIONS=\(aq{\(dqallow\(dq: [\(dqcat *\(dq, \(dqecho *\(dq], \(dqallowRedirects\(dq: true}\(aq
+.EE
+.SH CONFIGURATION FILES
+.IP
+.EX
+\(ti/.cline/
+├── data/                    # Default configuration directory
+│   ├── globalState.json     # Global settings and state
+│   ├── secrets.json         # API keys and secrets (stored securely)
+│   ├── workspace/           # Workspace\-specific state
+│   └── tasks/               # Task history and conversation data
+└── log/                     # Log files for debugging
+.EE
+.PP
+View logs with \f[CR]cline dev log\f[R].
+.SH BUGS
+Report bugs at: \c
+.UR https://github.com/cline/cline/issues
+.UE \c
+.PP
+For real\-time help, join the Discord community at: \c
+.UR https://discord.gg/cline
+.UE \c
+.SH SEE ALSO
+Full documentation: \c
+.UR https://docs.cline.bot
+.UE \c
+.PP
+VS Code extension: \c
+.UR https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev
+.UE \c
+.SH AUTHORS
+Cline is developed by Cline Bot Inc.\ and the open source community.
+.SH COPYRIGHT
+Copyright © 2025 Cline Bot Inc.\ Licensed under the Apache License 2.0.

cli/man/cline.1.md

@@ -0,0 +1,369 @@
+---
+title: CLINE
+section: 1
+header: User Commands
+footer: Cline CLI 2.0
+date: January 2026
+---
+
+# NAME
+
+cline - AI coding assistant in your terminal
+
+# SYNOPSIS
+
+**cline** [*prompt*] [*options*]
+
+**cline** *command* [*options*] [*arguments*]
+
+# DESCRIPTION
+
+**cline** is a command-line interface for the Cline AI coding assistant. It provides the same powerful AI capabilities as the VS Code extension, directly in your terminal.
+
+Cline is an autonomous AI agent that can read, write, and execute code across your projects. He can create and edit files, run terminal commands, use a headless browser, and more—all while asking for your approval before taking actions.
+
+The CLI supports both interactive mode (with a rich terminal UI) and plain text mode (for piped input and scripted workflows).
+
+# MODES OF OPERATION
+
+**Interactive Mode** :   When you run **cline** without arguments, it launches an interactive welcome prompt with a rich terminal UI. You can type your task, view conversation history, and interact with Cline in real-time.
+
+**Task Mode** :   Run **cline "prompt"** or **cline task "prompt"** to immediately start a task. If stdin is a TTY, you'll see the interactive UI. If stdin is piped or output is redirected, the CLI automatically switches to plain text mode.
+
+**Plain Text Mode** :   Activated automatically when stdin is piped, output is redirected, or **\--json**/**\--yolo** flags are used. Outputs clean text without the Ink UI, suitable for scripting and CI/CD pipelines.
+
+# AGENT BEHAVIOR
+
+Cline operates in two primary modes:
+
+**ACT MODE** :   Cline actively uses tools to accomplish tasks. He can read files, write code, execute commands, use a headless browser, and more. This is the default mode for task execution.
+
+**PLAN MODE** :   Cline gathers information and creates a detailed plan before implementation. He explores the codebase, asks clarifying questions, and presents a strategy for user approval before switching to ACT MODE.
+
+# COMMANDS
+
+## task (alias: t)
+
+Run a new task with a prompt.
+
+**cline task** *prompt* [*options*]
+
+**cline t** *prompt* [*options*] :   Create and run a new task. Options:
+
+**-a**, **\--act** :   Run in act mode (default)
+
+**-p**, **\--plan** :   Run in plan mode
+
+**-y**, **\--yolo** :   Enable yolo/yes mode (auto-approve all actions, output in plain mode, exit process automatically when task complete)
+
+**-t**, **\--timeout** *seconds* :   Optional timeout in seconds. Only applied when explicitly provided.
+
+**-m**, **\--model** *model* :   Model to use for the task
+
+**-i**, **\--images** *paths...* :   Image file paths to include with the task
+
+**-v**, **\--verbose** :   Show verbose output including reasoning
+
+**-c**, **\--cwd** *path* :   Working directory for the task
+
+**\--config** *path* :   Path to Cline configuration directory
+
+**\--thinking** :   Enable extended thinking (1024 token budget)
+
+**\--json** :   Output messages as JSON instead of styled text
+
+**-T**, **\--taskId** *id* :   Resume an existing task by ID. The prompt argument becomes an optional follow-up message.
+
+## history (alias: h)
+
+List task history with pagination.
+
+**cline history** [*options*]
+
+**cline h** [*options*] :   Display previous tasks. Options:
+
+**-n**, **\--limit** *number* :   Number of tasks to show (default: 10)
+
+**-p**, **\--page** *number* :   Page number, 1-based (default: 1)
+
+**\--config** *path* :   Path to Cline configuration directory
+
+## config
+
+Show current configuration.
+
+**cline config** [*options*] :   Display global and workspace state. Options:
+
+**\--config** *path* :   Path to Cline configuration directory
+
+## auth
+
+Authenticate a provider and configure the model.
+
+**cline auth** [*options*] :   Launch interactive authentication wizard, or use quick setup flags. Options:
+
+**-p**, **\--provider** *id* :   Provider ID for quick setup (e.g., openai-native, anthropic, openrouter)
+
+**-k**, **\--apikey** *key* :   API key for the provider
+
+**-m**, **\--modelid** *id* :   Model ID to configure (e.g., gpt-4o, claude-sonnet-4-5-20250929)
+
+**-b**, **\--baseurl** *url* :   Base URL (optional, for OpenAI-compatible providers)
+
+**-v**, **\--verbose** :   Show verbose output
+
+**-c**, **\--cwd** *path* :   Working directory
+
+**\--config** *path* :   Path to Cline configuration directory
+
+## update
+
+Check for updates and install if available.
+
+**cline update** [*options*] :   Check npm for newer versions. Options:
+
+**-v**, **\--verbose** :   Show verbose output
+
+## version
+
+Show the CLI version number.
+
+**cline version**
+
+## dev
+
+Developer tools and utilities.
+
+**cline dev log** :   Open the log file for debugging.
+
+# DEFAULT COMMAND OPTIONS
+
+When running **cline** with just a prompt (no subcommand), these options are available:
+
+**-a**, **\--act** :   Run in act mode (default)
+
+**-p**, **\--plan** :   Run in plan mode
+
+**-y**, **\--yolo** :   Enable yolo mode (auto-approve all actions). Also forces plain text output mode.
+
+**-t**, **\--timeout** *seconds* :   Optional timeout in seconds. Only applied when explicitly provided.
+
+**-m**, **\--model** *model* :   Model to use for the task
+
+**-v**, **\--verbose** :   Show verbose output
+
+**-c**, **\--cwd** *path* :   Working directory
+
+**\--config** *path* :   Configuration directory
+
+**\--thinking** :   Enable extended thinking (1024 token budget)
+
+**\--json** :   Output messages as JSON instead of styled text. Forces plain text mode.
+
+**-T**, **\--taskId** *id* :   Resume an existing task by ID instead of starting a new one. The prompt becomes an optional follow-up message.
+
+**\--continue** :   Resume the most recent task from the current working directory instead of starting a new one.
+
+# JSON OUTPUT FORMAT
+
+When using **\--json**, each message is output as a JSON object with these fields:
+
+**Required fields:**
+
+- **type**: "ask" or "say"
+- **text**: message text
+- **ts**: Unix epoch timestamp in milliseconds
+
+**Optional fields:**
+
+- **reasoning**: reasoning text
+- **say**: say subtype (when type is "say")
+- **ask**: ask subtype (when type is "ask")
+- **partial**: streaming flag
+- **images**: list of image URIs
+- **files**: list of file paths
+
+# EXAMPLES
+
+## Basic Usage
+
+```bash
+# Launch interactive mode
+cline
+
+# Run a task directly
+cline "Create a hello world function in Python"
+
+# Run with verbose output and extended thinking
+cline -v --thinking "Analyze this codebase architecture"
+```
+
+## Mode Selection
+
+```bash
+# Run in plan mode (gather info before acting)
+cline -p "Design a REST API for user management"
+
+# Run in act mode with auto-approval (yolo)
+cline -y "Fix the typo in README.md"
+```
+
+## Using Specific Models
+
+```bash
+# Use a specific model
+cline -m claude-sonnet-4-5-20250929 "Refactor this function"
+
+# Quick auth setup with model
+cline auth -p anthropic -k sk-ant-xxxxx -m claude-sonnet-4-5-20250929
+```
+
+## Including Images
+
+```bash
+# Include images with explicit flag
+cline task -i screenshot.png diagram.jpg "Fix the UI based on these images"
+
+# Or use inline image references in the prompt
+cline "Fix the layout shown in @./screenshot.png"
+```
+
+## Piped Input
+
+```bash
+# Pipe file contents to Cline
+cat README.md | cline "Summarize this document"
+
+# Pipe with additional prompt
+echo "function add(a, b) { return a + b }" | cline "Add TypeScript types to this"
+
+# Combine piped input with a prompt
+git diff | cline "Review these changes and suggest improvements"
+```
+
+## Scripting and Automation
+
+```bash
+# JSON output for parsing
+cline --json "What files are in this directory?" | jq '.text'
+
+# Yolo mode for automated workflows (auto-approves all actions), forces plain text output
+cline -y "Run the test suite and fix any failures"
+```
+
+## Task History
+
+```bash
+# List recent tasks
+cline history
+
+# Show more tasks with pagination
+cline history -n 20 -p 2
+```
+
+## Resuming Tasks
+
+```bash
+# Resume a task by ID (get IDs from cline history)
+cline -T abc123def
+
+# Resume a task with a follow-up message
+cline -T abc123def "Now add unit tests for the changes"
+
+# Resume the most recent task from the current directory
+cline --continue
+
+# Resume in plan mode to review before continuing
+cline -T abc123def -p "What's left to do?"
+
+# Resume with yolo mode for automated continuation
+cline -T abc123def -y "Continue with the implementation"
+```
+
+## Authentication
+
+```bash
+# Interactive authentication wizard
+cline auth
+
+# Quick setup for Anthropic
+cline auth -p anthropic -k sk-ant-api-xxxxx
+
+# Quick setup for OpenAI
+cline auth -p openai-native -k sk-xxxxx -m gpt-4o
+
+# OpenAI-compatible provider with custom base URL
+cline auth -p openai -k your-api-key -b https://api.example.com/v1
+```
+
+# ENVIRONMENT
+
+**CLINE_DIR** :   Override the default configuration directory. When set, Cline stores all data in this directory instead of `~/.cline/data/`.
+
+**CLINE_COMMAND_PERMISSIONS** :   JSON configuration for restricting which shell commands Cline can execute. When set, commands are validated against allow/deny patternks before execution. When not set, all commands are allowed.
+
+Format: `{"allow": ["pattern1", "pattern2"], "deny": ["pattern3"], "allowRedirects": true}`
+
+**Fields:**
+
+- **allow** (array of strings): Glob patterns for allowed commands. If specified, only matching commands are permitted. Uses `*` to match any characters and `?` to match a single character. Setting allow on anything will deny all others.
+- **deny** (array of strings): Glob patterns for denied commands. Deny rules take precedence over allow rules.
+- **allowRedirects** (boolean): Whether to allow shell redirects (`>`, `>>`, `<`, etc.). Defaults to false.
+
+**Rule evaluation:**
+
+1. Check for dangerous characters (backticks outside single quotes, unquoted newlines)
+2. Parse command into segments split by operators (`&&`, `||`, `|`, `;`)
+3. If redirects detected and `allowRedirects` is not true, command is denied
+4. Each segment is validated against deny rules first, then allow rules
+5. Subshell contents (`$(...)` and `(...)`) are recursively validated
+6. All segments must pass for the command to be allowed
+
+**Examples:**
+
+```bash
+# Allow only npm and git commands.
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"]}'
+
+# Allow development commands but deny dangerous ones. Deny not strictly required here since allow is set.
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *", "node *"], "deny": ["rm -rf *", "sudo *"]}'
+
+# Allow file operations with redirects
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["cat *", "echo *"], "allowRedirects": true}'
+```
+
+
+# CONFIGURATION FILES
+
+```
+~/.cline/
+├── data/                    # Default configuration directory
+│   ├── globalState.json     # Global settings and state
+│   ├── secrets.json         # API keys and secrets (stored securely)
+│   ├── workspace/           # Workspace-specific state
+│   └── tasks/               # Task history and conversation data
+└── log/                     # Log files for debugging
+```
+
+View logs with `cline dev log`.
+
+
+# BUGS
+
+Report bugs at: <https://github.com/cline/cline/issues>
+
+For real-time help, join the Discord community at: <https://discord.gg/cline>
+
+# SEE ALSO
+
+Full documentation: <https://docs.cline.bot>
+
+VS Code extension: <https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev>
+
+# AUTHORS
+
+Cline is developed by Cline Bot Inc. and the open source community.
+
+# COPYRIGHT
+
+Copyright © 2025 Cline Bot Inc. Licensed under the Apache License 2.0.

cli/package.json

@@ -0,0 +1,101 @@
+{
+	"name": "cline",
+	"version": "2.11.0",
+	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
+	"main": "dist/lib.mjs",
+	"types": "dist/lib.d.ts",
+	"bin": {
+		"cline": "./dist/cli.mjs"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/lib.mjs",
+			"types": "./dist/lib.d.ts"
+		}
+	},
+	"os": [
+		"darwin",
+		"linux",
+		"win32"
+	],
+	"cpu": [
+		"x64",
+		"arm64"
+	],
+	"man": "./man/cline.1",
+	"type": "module",
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"scripts": {
+		"package:brew": "npx tsx ./scripts/update-brew-formula.mts",
+		"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",
+		"watch": "npx tsx esbuild.mts --watch",
+		"dev": "IS_DEV=true && npm run link && npm run watch ; npm run unlink",
+		"clean": "rimraf dist",
+		"typecheck": "npx tsc --noEmit",
+		"link": "npm run build && npm link",
+		"unlink": "npm unlink -g cline",
+		"test": "vitest",
+		"test:run": "vitest run"
+	},
+	"keywords": [
+		"cline",
+		"claude",
+		"dev",
+		"mcp",
+		"openrouter",
+		"coding",
+		"agent",
+		"autonomous",
+		"chatgpt",
+		"sonnet",
+		"ai",
+		"llama",
+		"cli"
+	],
+	"author": {
+		"name": "Cline Bot Inc."
+	},
+	"license": "Apache-2.0",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/cline/cline"
+	},
+	"homepage": "https://cline.bot",
+	"bugs": {
+		"url": "https://github.com/cline/cline/issues"
+	},
+	"devDependencies": {
+		"@types/marked": "^5.0.2",
+		"@types/node": "20.x",
+		"@types/prompts": "^2.4.9",
+		"@types/react": "^19.2.9",
+		"dotenv": "^16.4.5",
+		"esbuild": "^0.25.0",
+		"ink-testing-library": "^4.0.0",
+		"rimraf": "^6.0.1",
+		"typescript": "^5.4.5",
+		"vitest": "^4.0.17"
+	},
+	"dependencies": {
+		"@agentclientprotocol/sdk": "^0.13.1",
+		"@vscode/ripgrep": "^1.15.9",
+		"aws4fetch": "^1.0.20",
+		"chalk": "^5.3.0",
+		"commander": "^12.1.0",
+		"ink": "npm:@jrichman/ink@6.4.7",
+		"ink-picture": "^1.3.3",
+		"ink-spinner": "^5.0.0",
+		"marked": "^17.0.3",
+		"nanoid": "^5.1.6",
+		"ora": "^8.0.1",
+		"pino": "^10.0.0",
+		"pino-roll": "^4.0.0",
+		"prompts": "^2.4.2",
+		"react": "^19.2.3"
+	}
+}

cli/scripts/update-brew-formula.mts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process"
+import { createHash } from "node:crypto"
+import { readFile, unlink, writeFile } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const CLI_DIR = join(__dirname, "..")
+const FORMULA_PATH = join(CLI_DIR, "cline.rb")
+
+interface PackageJson {
+	version: string
+}
+
+async function getLocalVersion(): Promise<string> {
+	const packageJson = JSON.parse(await readFile(join(CLI_DIR, "package.json"), "utf-8")) as PackageJson
+	return packageJson.version
+}
+
+async function packAndGetSHA256(version: string): Promise<string> {
+	console.log("Packing local package...")
+	execSync("npm run package", { cwd: CLI_DIR, stdio: "inherit" })
+
+	const tarballPath = join(CLI_DIR, "dist", `cline-cli-${version}.tgz`)
+	console.log(`Computing SHA256 for ${tarballPath}...`)
+
+	const buffer = await readFile(tarballPath)
+	const sha256 = createHash("sha256").update(buffer).digest("hex")
+
+	// Clean up the tarball
+	await unlink(tarballPath)
+
+	return sha256
+}
+
+async function updateFormula(version: string, sha256: string) {
+	console.log("Updating Homebrew formula...")
+
+	let formula = await readFile(FORMULA_PATH, "utf-8")
+
+	const tarballUrl = `https://registry.npmjs.org/cline/-/cline-${version}.tgz`
+
+	// Update URL - matches pattern like: url "https://registry.npmjs.org/cline/-/cline-1.0.10.tgz"
+	formula = formula.replace(/url "https:\/\/registry\.npmjs\.org\/cline\/-\/cline-[\d.]+\.tgz"/, `url "${tarballUrl}"`)
+
+	// Update SHA256
+	formula = formula.replace(/sha256 "[a-f0-9]+"/, `sha256 "${sha256}"`)
+
+	await writeFile(FORMULA_PATH, formula, "utf-8")
+}
+
+async function main() {
+	try {
+		const version = await getLocalVersion()
+		console.log(`\nLocal version: ${version}`)
+
+		const sha256 = await packAndGetSHA256(version)
+		console.log(`SHA256: ${sha256}`)
+
+		const tarballUrl = `https://registry.npmjs.org/cline/-/cline-${version}.tgz`
+		console.log(`Tarball URL: ${tarballUrl}`)
+
+		await updateFormula(version, sha256)
+
+		console.log("\n✓ Homebrew formula updated successfully!")
+		console.log("\nNext steps:")
+		console.log("1. Review the changes in cline.rb")
+		console.log("2. Test locally: brew install --build-from-source ./cline.rb")
+		console.log("3. Commit and push to your homebrew tap repository")
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		console.error(`\n✗ Error: ${errorMessage}\n`)
+		process.exit(1)
+	}
+}
+
+main()

cli/src/acp/ACPDiffViewProvider.ts

@@ -0,0 +1,248 @@
+/**
+ * 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

@@ -0,0 +1,408 @@
+/**
+ * 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

@@ -0,0 +1,141 @@
+/**
+ * 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

@@ -0,0 +1,141 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,274 @@
+/**
+ * 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

@@ -0,0 +1,114 @@
+/**
+ * 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)
+	}
+}