Debug harness improvements, some changes which break login.

Mark as fixed: Add to Cline command, model change persistence,
MCP Servers tab loading, attached images not submitted.

.clinerules/debug-harness.md

@@ -0,0 +1,51 @@
+# Debug Harness
+
+HTTP-controlled debugger for the VSCode extension at `src/dev/debug-harness/server.ts`.
+
+## Quick start
+
+```bash
+# Build extension first if needed (protos + esbuild):
+npm run protos && IS_DEV=true node esbuild.mjs
+
+# Launch (skip-build if already built):
+npx tsx src/dev/debug-harness/server.ts --skip-build --auto-launch
+
+# In another terminal:
+curl localhost:19229/api -d '{"method":"status"}'
+```
+
+## Key commands
+
+All via `POST localhost:19229/api` with `{"method":"...", "params":{...}}`:
+
+- **`launch`** / **`shutdown`** — lifecycle
+- **`ui.screenshot`** — screenshot to `/tmp/cline-debug/`; returns `{path}` — **use `read_file` on the path to examine, do NOT `open` the file** (Preview.app covers the VSCode window)
+- **`ui.open_sidebar`** — open the Cline sidebar
+- **`ext.set_breakpoint`** `{file, line, condition?}` — breakpoint by source file (sourcemap-resolved)
+- **`ext.evaluate`** `{expression, callFrameId?}` — eval in extension host
+- **`ext.resume`** / **`ext.step_over`** / **`ext.step_into`** — stepping
+- **`ext.call_stack`** — inspect when paused
+- **`web.evaluate`** `{expression}` — eval in webview
+- **`web.post_message`** `{message}` — send postMessage to extension host via exposed vsCodeApi
+- **`wait_for_pause`** `{timeout?}` — block until breakpoint hit
+- **`ui.locator`** `{role?, testId?, text?, action?, frame?}` — Playwright locator (auto-retries on stale sidebar frame)
+- **`ui.react_input`** `{text, selector?, clear?, submit?}` — set React textarea value via `execCommand('insertText')`; works reliably across multiple tasks
+- **`ui.send_message`** `{text, images?, files?, responseType?}` — send chat message bypassing the textarea entirely (via gRPC postMessage)
+- **`ui.command_palette`** `{command}` — run VSCode command
+
+## Caveats
+
+- **⚠️ Dismiss "Introducing Cline Kanban" overlay FIRST**: On fresh launches a full-screen promo overlay blocks the sidebar. **Dismiss it immediately after `ui.open_sidebar`**, before any other interaction or screenshot. Most reliable method:
+  ```bash
+  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+  curl localhost:19229/api -d '{"method": "web.evaluate", "params": {"expression": "document.querySelector(\".sr-only\")?.parentElement?.click()"}}'
+  ```
+- **Screenshots — don't open the file**: `ui.screenshot` and `ui.sidebar_screenshot` save PNGs to `/tmp/cline-debug/` and return the `{path}`. Use `read_file` on the path to examine screenshots. Running `open <path>` launches Preview.app on macOS which covers the VSCode window.
+- **Scripts count = 0 after launch**: CDP connects after extension host starts, so scripts parsed during startup aren't tracked. Breakpoints still work via sourcemap resolution.
+- **Port 9230**: Extension host inspector. If another VSCode instance uses this port, the harness will fail to connect. Kill other debug instances first.
+- **macOS only** for now (Playwright Electron launch behavior).
+- **Webview CDP**: `connect_webview` may fail depending on Electron version. `web.evaluate` still works via Playwright's `frame.evaluate()` fallback.
+- **Sourcemap paths**: esbuild outputs relative paths like `../src/extension.ts` in the sourcemap. The resolver handles this, but if a file isn't found, use `ext.source_files` to see exact paths.
+
+See `src/dev/debug-harness/README.md` for full API reference.

.gitattributes

@@ -1,5 +1,6 @@
 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.mp4 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/workflows/npm-main.yaml

@@ -91,3 +91,21 @@ jobs:
           echo ""
           echo "📦 Install with: npm install -g cline"
           echo "🔗 NPM: https://www.npmjs.com/package/cline/v/${{ steps.version.outputs.version }}"
+
+      - name: Post release to Slack
+        uses: slackapi/slack-github-action@v3.0.1
+        with:
+          method: chat.postMessage
+          token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
+          payload: |
+            channel: "C0APVKGGZFC"
+            text: "Cline CLI v${{ steps.version.outputs.version }}"
+            blocks:
+              - type: "section"
+                text:
+                  type: "mrkdwn"
+                  text: "*Cline CLI v${{ steps.version.outputs.version }}*"
+              - type: "context"
+                elements:
+                  - type: "mrkdwn"
+                    text: "<https://www.npmjs.com/package/cline/v/${{ steps.version.outputs.version }}|View on npm>"

.github/workflows/publish-nightly.yml

@@ -53,11 +53,12 @@ jobs:
 
             - 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
+                  for FILE in webview-ui/src/assets/cline_kanban_demo.mp4 webview-ui/src/assets/cline_kanban_demo.webm; do
+                    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
+                  done
 
             - name: Publish Extension as Pre-release
               env:

.github/workflows/publish.yml

@@ -136,11 +136,12 @@ jobs:
 
             - 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
+                  for FILE in webview-ui/src/assets/cline_kanban_demo.mp4 webview-ui/src/assets/cline_kanban_demo.webm; do
+                    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
+                  done
 
             - name: Package and Publish Extension
               env:
@@ -196,3 +197,25 @@ jobs:
                   prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: Post release to Slack
+              uses: slackapi/slack-github-action@v3.0.1
+              with:
+                  method: chat.postMessage
+                  token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
+                  payload: |
+                    channel: "C0APVKGGZFC"
+                    text: "Cline ${{ steps.resolve_tag.outputs.tag }}"
+                    blocks:
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: "*Cline ${{ steps.resolve_tag.outputs.tag }}*"
+                      - type: "section"
+                        text:
+                          type: "mrkdwn"
+                          text: ${{ toJSON(steps.changelog.outputs.content) }}
+                      - type: "context"
+                        elements:
+                          - type: "mrkdwn"
+                            text: "Full Changelog: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}"

.mocharc.json

@@ -3,7 +3,11 @@
 		"ts"
 	],
 	"spec": [
-		"src/**/__tests__/*.ts"
+		"src/**/__tests__/*.ts",
+		"src/test/services/**/*.test.ts"
+	],
+	"ignore": [
+		"src/sdk/**"
 	],
 	"require": [
 		"ts-node/register",

ARCHITECTURE.md

@@ -0,0 +1,940 @@
+# SDK Migration — Architecture & Design
+
+Evergreen reference for the Cline SDK migration project. For the
+living implementation plan, see `migration.md`.
+
+## References
+
+### Code References
+
+Cline SDK is at ~/clients/cline/sdk-wip
+Cline (core, classic VSCode extension, CLI) is at ~/clients/cline/cline
+JetBrains Plugin is at ~/clients/cline/intellij-plugin
+IntelliJ open source reference is at ~/clients/cline/intellij-community
+JCEF (Java-Chromium embedded framework reference) is at ~/clients/cline/jcef
+
+You can use kb_search with these identifiers to understand the
+existing code and the SDK code:
+
+cline - Cline core, classic VSCode extension, CLI
+sdk - Cline SDK
+plugin - JetBrains plugin
+vscode - Visual Studio Code opens source
+ij - IntelliJ open source
+jcef - JCEF IntelliJ's embedded Chromium layer
+
+Prototype VSCode extension on SDK is at ~/clients/cline/sdk-vscode-sample
+Prototype JetBrains plugin on SDK is at ~/clients/cline/sdk-intellij-plugin-sample
+
+These are prototypes with features missing and added, so refer to them
+as examples, but don't overindex on them.
+
+### Documentation references
+
+See the ~/clients/cline/cline/docs for extension product documentation
+and ~/clients/cline/sdk-wip/*.md for SDK documentation.
+
+### Background on the products & architecture
+
+There's a VSCode extension in cline/src. A large part of its UI is a
+React-based webview in cline/webview-ui.
+
+There's a JetBrains plugin in the intellij-plugin repo. It packages
+the core of the VSCode extension, including the webview, and
+communicates with it with protobufs. There's a bunch of stuff in the
+cline repo called "standalone" which is what JetBrains communicates
+with.
+
+In cline/cli there's a CLI and Kanban tool. Those use the SDK/are
+being ported separately to the SDK, so you don't need to worry about
+them. It is OK if you have to break them. Just ignore them.
+
+Note, there was an earlier, failed attempt at a cli in go. The go cli
+used to use "standalone" like JetBrains. If there's any old go support
+cluttering up the repo, it is fine to delete it and clean it up.
+
+The source code and docs mentioned above are the best reference to the
+product architecture, behavior, etc. Feel free to ask clarifying
+questions when necessary.
+
+---
+
+## Features
+
+### Features to remove
+
+Terminal integration: There is legacy code in the VSCode extension,
+and stubs in the RPC system for JetBrains, which used the IDE's
+integrated terminals. We have decided we don't need these old modes
+and they should be removed. Instead we will rely on "background
+terminal". This literally means the node code forks and execs a shell
+and uses pipes to communicate with it.
+
+Browser automation: Remove the system that uses Playwright to automate
+browsers. These use cases are now well served by third-party MCP
+tools.
+
+"Shadow git" checkpointing system. This is too slow, especially on
+Windows. The way the Kanban project uses the existing git repo to
+store references, and only after each user message, is better. So we
+will drop the "shadow copy" git checkpointing system.
+
+Memory bank, structured context: multi-file documentation
+(projectbrief, productContext, activeContext, systemPatterns,
+techContext, progress.)
+
+Memory bank, persistence: cross-session context preservation.
+
+Focus chain, task tracking: Auto-generated to-do list with real-time
+progress indicators.
+
+Focus chain, integration: Editable focus chain integration with deep
+planning and reminders.
+
+Deep planning exploration, output and the /deep-planning command.
+
+Workflows (definition, natural language + XML tool syntax, MCP tools
+and user input prompts) ... these have been superceded by SKILLS
+moving forward.
+
+Slash commands no longer necessary:
+
+/deep-planning (codebase investigation + plan... we have plan/act mode)
+/reportbug (bug reporting with diagnostics)
+Custom workflows (/workflow.md for user-defined workflows... we have "skills" now.)
+
+### Core features
+
+These must work:
+
+File operations: read, write, search, replace, list files, inspect
+code definitions (functions, classes, methods)
+
+Terminal integration: "Background terminal" must work. The agent
+relies on this to run npm, git, docker, etc.
+
+Multi-provider AI models: 30+ providers with seamless
+switching. There's one provider of note: VSCode has a provider which
+hooks up to Copilot using the VSCode LM Provider API. It would be good
+to support this *if possible.*
+
+Auto-approve & YOLO mode
+- Granular per-tool permission controls
+- YOLO mode for maximum automation
+- Monitoring, notifications for long-running commands
+
+Auto-compaction
+- Summarization automatically compresses conversations when context fills
+- Model support for Claude, Gemini, GPT-5, Grok, etc.
+
+Subagents
+- Parallel execution of independent research agents
+- Isolation with separate context windows
+- Cost tracking for task usage per subagent
+
+Web search and web fetch
+
+Worktrees
+- git worktrees for parallel sessions
+- branch management and .worktreeinclude support
+- conflict resolution and merging
+
+Workspaces
+- "multi-root" workspaces/projects with multiple root folders
+- @workspace:path scoped references
+
+Jupyter Notebooks
+- Generate, explain, and improve notebook cells
+
+Cline Rules
+- project-specific .cline/rules and global instructions.
+- Conditional logic: Path-based activation of rules.
+- Compatibility: Works with Cursor Rules, Windsurf rules, AGENTS.md
+
+Skills
+- SKILL.md format with YAML frontmatter
+- Loading levels: Metadata, instructions and resources
+- Scope: Global and project-specific; toggleable
+
+Hooks
+- Events: Task lifecycle + tool events (TaskStart, PreToolUse, etc.)
+- Runtimes: bash, powershell for Windows
+- IO: JSON
+- Context injection: Be able to modify or inject context dynamically
+
+.clineignore
+- Exclusion rules, gitignore-style file/directory exclusion
+- Exceptions: ! prefix for overrides
+- Override behavior: Explicit @ mentions bypass ignore rules
+
+MCP (Model Context Protocol)
+- Server management: Discovery, enable/disable, restart, config editing
+- Transport: stdio (local) and SSE (remote)
+- ...all the typical use cases for MCP: APIs, browser automation, db queries, etc.
+
+### Core workflows
+
+These must work:
+
+Task Management
+
+Task lifecycle - create and resume tasks; view task history
+Cost tracking - token using and cost monitoring per task
+
+Plan & Act Mode
+Plan mode - Explore and investigate without modifying files
+Act mode - Implementation with approval gates
+Model config - Separate model configuration for plan and act mode if
+               the user desires
+State persistence - Mode switching, task switching preserves history
+
+File context (@-mentions)
+Context referencing - Reference files, folders, terminal output, git
+changes, URLs, commits via @
+
+Slash commands
+/newtask (new task)
+/smol (compress history)
+/newrule (create rules)
+
+### Model Configuration
+
+We want to continue supporting our 30+ providers (Anthropic, OpenAI,
+OpenAI Codex, OpenRouter, Google Gemini, AWS Bedrock, DeepSeek,
+Cerebras, Qwen, Mistral, Groq, Fireworks, Together, xAI Grok,
+Moonshot, Nebius, HuggingFace, LiteLLM, Ollama, LM Studio, and more.)
+
+THE MOST IMPORTANT REQUIREMENT HERE, after continuing to support them,
+is to USE THE CREDENTIALS, MODEL NAMES, CONFIGS, etc. WE HAVE
+SAVED. Logging people out of their providers is really annoying to
+users; regenerating API keys is painful for them.
+
+VSCode LM API provider may be an interesting/unusual provider out of
+this set; it only works in VSCode by calling a specific API.
+
+We must continue supporting local models like Ollama and LM Studio.
+
+We must support the Cline provider with unified auth (open a
+webbrowser, handle the SSO redirect), built-in billing and credit
+display, banners advertising new or free models, stealth/early access
+models, organization switching.
+
+### Enterprise Features
+
+Security and governance
+- Client-side execution only (no data transmission outside of limited
+  Telemetry and inference; no remote codebase indexing)
+- SSO role-based access control (member, admin, owner)
+- Model and tool controls per team
+- Remote configuration downloaded and applied by the extension
+
+Observability
+- OpenTelemetry, Datadog, Grafana, Splunk integrations
+- Real-time analytics, cost breakdown by team, selective audit logging
+
+Infrastructure
+- AWS Bedrock, Google Vertex AI, Azure OpenAI integration
+- Bring-your-own-inference with custom endpoints
+
+### Priority "P1" (mid priority) items
+
+Checkpoints - automatic file snapshots after each change. Note, the
+snapshot system in the VSCode extension and JetBrains plugin which
+copies the whole repository is slow, *especially on Windows*, so we
+should replace it with one that writes refs directly into the local
+git repo. Look at the way the kanban project does it; this is
+preferred (and maybe we should extract and share this code.)
+
+Diffing - compare changes between checkpoints
+
+Restore - restore files, task to a point, or both
+
+MCP Marketplace - we could get rid of this, but ultimately we do want
+this feature with major improvements like allowing remote install. For
+now, consider removing it, but if it is easier to keep it around let's
+do that to lay the groundwork for improvements.
+
+### Priority "P2" (lower priority) items
+
+Task organization - favorites for task grouping and management
+
+File context - Drag and drop files to add to context
+File context - actions - context menus to add to Cline, fix, explain, improve
+
+Slash commands
+/explain-changes (git diff explanation)
+
+---
+
+## Detailed Design
+
+### Naming: "Sdk..." considered harmful
+
+Do not name types "SdkFoo" or folders "sdk". If you need to use SdkFoo
+as a way to keep two classes around in parallel while you're porting,
+that's OK, but when this project is done we want to have one clean,
+simple codebase; the SDK backing is an implementation detail so just
+use simple noun phrases for classes, etc. and don't litter "Sdk" all
+over identifiers and folders.
+
+### Proto deprecation and removal
+
+We don't need proto files to describe webview messages. The webview
+and extension backend are both in TypeScript and are versioned and
+shipped together. We just need to use shared TypeScript interfaces
+between them.
+
+We *also* don't need proto to describe JetBrains <--> node
+exchanges. We just need something typed and in sync between Kotlin and
+TypeScript that we can serialize. JSON probably makes sense. Protos
+are OK but we have had problems with that setup creating a ton of GC
+pressure on the Kotlin side, hit maximum message size limits, etc.
+
+There are proto build steps which we can remove, as we use proto less.
+
+protos are useful for state which is serialized. If there are files
+that are persisted described by protos, it is ok/good to keep
+them. Don't expand the use of protos to places protos are not already
+used.
+
+### Web View UI
+
+The Webview UI is very dependent on state arising from implementation
+details of the pre-SDK implementation. At the same time, we don't want
+to build a new UI from scratch right now because it may be forcing too
+many changes upon our users at once. So we aim to reuse the existing
+webview, but with radical simplificiation in its state management now
+that we will have a cleaner architecture in the extension "backend"
+with the layering enforced by the SDK.
+
+The webview UI had defects like showing the wrong keybindings for
+JetBrains, or using tons of memory or CPU cycles by spamming state
+updates really rapidly or sending n^2 state updates as they streamed
+in. The first principle of this migration to the SDK is not get worse,
+but at the same time, we expect the state clean-up necessary in the
+webview will lead to radical simplifications which make some
+low-hanging fruit available in performance. It's great to go make
+those improvements where they are available.
+
+We don't need this UI to be pixel perfect identical. We need it to be
+FAMILIAR, NOT WORSE and preferably BETTER than the status quo.
+
+### Data formats, settings
+
+We MUST pick up existing on-disk state for settings, etc. We don't
+want to log users out of their inference providers as we make this
+change to the SDK.
+
+The CLI, VSCode extension and JetBrains extension largely share state
+on disk. We should continue that situation. If data migrations are
+necessary, that's fine, but design them with care. In particular, we
+want the long term to be fast, so we should write breadcrumbs
+indicating when migration is done. In addition, users can upgrade and
+downgrade their extension versions, etc. and we want to be robust to
+that in addition to all kinds of failures. For example, in the past we
+had problems where we overwrote a JSON settings file, perhaps racily,
+and left trailing }s in the file and this caused the product to
+totally fail. That's a very serious issue for our users so pay extra
+effort and attention to what is happening on disk. (We want PRACTICAL
+solutions and robustness and not performative solutions that just add
+tons of code and complexity with no real benefit.)
+
+Invalidating old checkpoints is acceptable, unless it is particularly
+cheap to support the classic checkpoints. We won't be authoring those
+checkpoints any more, and it would be heavy to migrate them.
+
+We want to move from .clinerules (old style) to .cline/rules (new style.)
+
+### Telemetry
+
+We generally want to continue sending the same Telemetry events. If
+that is hard, make a detailed report and we can follow up with our
+backend team. Note some enterprise features depend on OTEL
+observability.
+
+### Code Sharing
+
+In general we should share code between IDEs where there are benefits
+to do so. However trivial tools, or tools specific to a given IDE, can
+be wired up directly from the extension through to the SDK. (This is
+something that was hard to do in the old architecture and we would
+like to make easier.)
+
+---
+
+## Research Findings
+
+### SDK Session Backend Extensibility
+
+**Question**: Does the SDK's `SessionBackend` interface support
+storing arbitrary per-task data (e.g., tool settings, hook
+configuration, auto-approve preferences per task)?
+
+**Answer**: Partially. The `SessionRow` has a `metadata:
+Record<string, unknown> | null` field that can store arbitrary
+key-value data per session. This is sufficient for per-task settings
+like auto-approve preferences, tool configuration, etc.
+
+The SDK supports three backend implementations:
+1. `SqliteSessionStore` — SQLite-backed (default, preferred)
+2. `FileSessionService` — JSON file-backed (fallback when SQLite
+   unavailable)
+3. `RpcCoreSessionService` — delegates to an RPC server
+
+For our migration, we'll use either `FileSessionService` or provide a
+custom `SessionPersistenceAdapter` that reads/writes our existing task
+history format. The `ClineCoreOptions.sessionService` field accepts
+any backend implementing `CoreSessionService | RpcCoreSessionService |
+FileSessionService`.
+
+**Key finding**: The `SessionPersistenceAdapter` interface is the
+cleanest extension point. It requires implementing: `ensureSessionsDir`,
+`upsertSession`, `getSession`, `listSessions`, `updateSession`,
+`deleteSession`, `enqueueSpawnRequest`, `claimSpawnRequest`. Our
+`LegacySessionBackend` adapter wraps the existing
+`~/.cline/data/tasks/` directory and `taskHistory` JSON array in
+`globalState.json`, mapping between `SessionRow` fields and our
+`HistoryItem` type:
+
+```
+HistoryItem.id          → SessionRow.sessionId
+HistoryItem.ts          → SessionRow.startedAt (ISO string)
+HistoryItem.task        → SessionRow.prompt
+HistoryItem.tokensIn    → metadata.tokensIn
+HistoryItem.tokensOut   → metadata.tokensOut
+HistoryItem.totalCost   → metadata.totalCost
+HistoryItem.modelId     → SessionRow.model
+HistoryItem.isFavorited → metadata.isFavorited
+```
+
+Per-task files (`api_conversation_history.json`, `ui_messages.json`)
+map to `SessionRow.messagesPath` and `SessionRow.transcriptPath`.
+
+**Decision**: We will provide a custom `SessionPersistenceAdapter`
+that translates between our existing format and the SDK's interface.
+No need for a separate sidecar storage layer. The `metadata` field
+handles all per-task extensions.
+
+### Telemetry Event Mapping
+
+The extension currently emits telemetry events via a PostHog-based
+`TelemetryService`. The SDK has its own `TelemetryService` with
+pluggable adapters (`OpenTelemetryAdapter`, `LoggerTelemetryAdapter`).
+
+**Mapping of current extension events → SDK events:**
+
+| Extension Event | SDK CORE_TELEMETRY_EVENTS | Notes |
+|---|---|---|
+| `user.extension_activated` | `CLIENT.STARTED` ("extension.activated") | ✅ Same event name |
+| `user.auth_started` | `USER.AUTH_STARTED` | ✅ Direct match |
+| `user.auth_succeeded` | `USER.AUTH_SUCCEEDED` | ✅ Direct match |
+| `user.auth_failed` | `USER.AUTH_FAILED` | ✅ Direct match |
+| `user.auth_logged_out` | `USER.AUTH_LOGGED_OUT` | ✅ Direct match |
+| `task.created` | `TASK.CREATED` | ✅ Direct match |
+| `task.restarted` | `TASK.RESTARTED` | ✅ Direct match |
+| `task.completed` | `TASK.COMPLETED` | ✅ Direct match |
+| `task.conversation_turn` | `TASK.CONVERSATION_TURN` | ✅ Direct match |
+| `task.tokens` | `TASK.TOKEN_USAGE` | ✅ Direct match |
+| `task.mode` | `TASK.MODE_SWITCH` | ✅ Direct match |
+| `task.tool_used` | `TASK.TOOL_USED` | ✅ Direct match |
+| `task.skill_used` | `TASK.SKILL_USED` | ✅ Direct match |
+| `task.diff_edit_failed` | `TASK.DIFF_EDIT_FAILED` | ✅ Direct match |
+| `task.provider_api_error` | `TASK.PROVIDER_API_ERROR` | ✅ Direct match |
+| `task.mention_used` | `TASK.MENTION_USED` | ✅ Direct match |
+| `task.mention_failed` | `TASK.MENTION_FAILED` | ✅ Direct match |
+| `task.mention_search_results` | `TASK.MENTION_SEARCH_RESULTS` | ✅ Direct match |
+| `task.subagent_started` | `TASK.SUBAGENT_STARTED` | ✅ Direct match |
+| `task.subagent_completed` | `TASK.SUBAGENT_COMPLETED` | ✅ Direct match |
+| `hooks.discovery_completed` | `HOOKS.DISCOVERY_COMPLETED` | ✅ Direct match |
+| `session.started` | `SESSION.STARTED` | ✅ Direct match |
+| `session.ended` | `SESSION.ENDED` | ✅ Direct match |
+
+**Extension events with NO SDK equivalent (need adapter-layer emit):**
+
+| Extension Event | Action |
+|---|---|
+| `user.opt_out` / `user.opt_in` | Emit via SDK's `captureRequired()` |
+| `user.telemetry_enabled` | Emit via SDK's `capture()` |
+| `user.extension_storage_error` | Emit via SDK's `capture()` |
+| `user.onboarding_progress` | Emit via SDK's `capture()` |
+| `workspace.*` (initialized, vcs_detected, etc.) | Emit via SDK's `capture()` |
+| `task.feedback` | Emit via SDK's `capture()` |
+| `task.option_selected` / `task.options_ignored` | Emit via SDK's `capture()` |
+| `task.checkpoint_used` | Emit via SDK's `capture()` |
+| `task.mcp_tool_called` | Emit via SDK's `capture()` |
+| `task.historical_loaded` | Emit via SDK's `capture()` |
+| `task.retry_clicked` | Emit via SDK's `capture()` |
+| `task.slash_command_used` | Emit via SDK's `capture()` |
+| `task.feature_toggled` | Emit via SDK's `capture()` |
+| `task.rule_toggled` | Emit via SDK's `capture()` |
+| `task.auto_condense_toggled` | Emit via SDK's `capture()` |
+| `task.yolo_mode_toggled` | Emit via SDK's `capture()` |
+| `task.terminal_*` (execution, output_failure, hang) | Emit via SDK's `capture()` |
+| `task.initialization` | Emit via SDK's `capture()` |
+| `task.summarize_task` | Emit via SDK's `capture()` |
+| `ui.*` (model_selected, button_clicked, etc.) | Emit via SDK's `capture()` |
+| `hooks.enabled` / `hooks.disabled` | Emit via SDK's `capture()` |
+| `hooks.cancel_requested` | Emit via SDK's `capture()` |
+| `hooks.context_modified` | Emit via SDK's `capture()` |
+| `worktree.*` | Emit via SDK's `capture()` |
+| `host.detected` | Emit via SDK's `capture()` |
+
+**Extension events being REMOVED (features deleted):**
+
+| Extension Event | Reason |
+|---|---|
+| `task.browser_tool_start/end/error` | Browser automation removed |
+| `task.focus_chain_*` (6 events) | Focus chain removed |
+| `task.workspace_search_pattern` | Folded into SDK search |
+| `task.subagent_enabled/disabled` | Toggle events; SDK manages directly |
+| `task.cline_web_tools_toggled` | Feature simplified |
+| `cline.grpc.response.size_bytes` | gRPC being removed |
+
+**Metrics (OTEL counters/histograms):**
+
+The extension has ~30 OTEL metrics (`cline.turns.total`,
+`cline.tokens.input.total`, `cline.api.ttft.seconds`, etc.). The SDK
+telemetry service supports `recordCounter`, `recordHistogram`, and
+`recordGauge`. We will emit these same metrics from the adapter layer
+using `telemetry.recordCounter()` / `telemetry.recordHistogram()`.
+The metric names can stay the same.
+
+**Decision**: The SDK's `ITelemetryService.capture()` is a generic
+event emitter — we can emit ALL extension events through it. The
+adapter layer will create a thin telemetry wrapper that provides
+the same `captureTaskCreated()`, `captureToolUsage()`, etc. methods
+but delegates to the SDK's telemetry service. Events where the SDK
+already has a helper function (listed in the first table) use those
+directly. Others use `capture({ event, properties })`. No backend
+team coordination needed for the initial migration.
+
+### JetBrains IPC Design
+
+#### Current Architecture
+
+```
+┌── Kotlin Plugin ──────────────────────────────┐
+│                                                │
+│  CoreProcessManager                            │
+│    └─ launches Node.js process (cline-core)    │
+│    └─ communicates via gRPC ProtoBus           │
+│       (port 26040-26340)                       │
+│                                                │
+│  HostBridgeService (gRPC server, port 26041)   │
+│    ├─ DiffService                              │
+│    ├─ WindowService (show file, open dialog)   │
+│    ├─ WorkspaceService (paths, diagnostics)    │
+│    ├─ EnvService                               │
+│    └─ TestingService (get webview HTML)         │
+│                                                │
+│  ProtoBusProxyService                          │
+│    └─ proxies webview ↔ cline-core gRPC        │
+│                                                │
+│  JsPostMessageHandler                          │
+│    └─ injects JS bridge into JCEF webview      │
+│    └─ converts postMessage → gRPC request      │
+│                                                │
+│  WebViewManager                                │
+│    └─ loads webview HTML in JCEF                │
+│    └─ receives gRPC responses → postMessage    │
+└────────────────────────────────────────────────┘
+```
+
+Problems with this architecture:
+- **Proto size limits**: gRPC messages hit 256MB limits with large
+  conversations. The `ProtoBusProxyService` logs warnings at 10MB+.
+- **Java heap pressure**: Serializing/deserializing large proto
+  messages stresses the JVM heap.
+- **Build complexity**: Proto compilation required for both
+  TypeScript and Java/Kotlin.
+- **Stateless-in-theory**: The design is somewhat stateless but we
+  haven't leveraged restart-for-reliability because state
+  reconstruction is expensive.
+
+#### Target Architecture
+
+```
+┌── Kotlin Plugin ──────────────────────────────┐
+│                                                │
+│  CoreProcessManager                            │
+│    └─ launches SDK sidecar (Node.js)           │
+│    └─ communicates via JSON-RPC over stdio     │
+│                                                │
+│  HostCallbackService (JSON-RPC server)         │
+│    ├─ showTextDocument, openDialog             │
+│    ├─ getWorkspacePaths, getDiagnostics        │
+│    ├─ getEnvVars, clipboard                    │
+│    └─ (extensible for PSI, run configs, etc.)  │
+│                                                │
+│  WebviewBridge                                 │
+│    └─ receives JSON messages from sidecar      │
+│    └─ forwards to JCEF via executeJavaScript   │
+│    └─ receives postMessage from JCEF           │
+│    └─ forwards to sidecar via stdio            │
+│                                                │
+│  WebViewManager                                │
+│    └─ loads adapted webview in JCEF            │
+└────────────────────────────────────────────────┘
+
+┌── SDK Sidecar (Node.js) ──────────────────────┐
+│                                                │
+│  SidecarMain                                   │
+│    └─ JSON-RPC over stdio (bidirectional)      │
+│    └─ imports @clinebot/core                   │
+│    └─ shares SDK adapter layer with VSCode     │
+│                                                │
+│  ClineCore instance                            │
+│    └─ session management                       │
+│    └─ tool execution                           │
+│    └─ provider handling                        │
+│                                                │
+│  HostCallbackClient                            │
+│    └─ calls back to Kotlin for IDE ops         │
+│    └─ registered as tool executors in SDK      │
+│                                                │
+│  WebviewBridge                                 │
+│    └─ translates SDK events → webview messages │
+│    └─ same code as VSCode adapter              │
+└────────────────────────────────────────────────┘
+```
+
+#### IPC Mechanism: JSON-RPC over stdio
+
+**Why JSON-RPC over stdio instead of gRPC:**
+- **No message size limits**: JSON over stdio has no inherent size
+  cap. Conversations with 100K+ tokens serialize to ~5-20MB JSON
+  which flows fine over pipes.
+- **No heap pressure**: No proto serialization on the Java side.
+  Kotlin reads/writes JSON strings directly. JCEF already works
+  with JSON.
+- **No proto compilation**: Eliminates the Java protobuf dependency
+  and the dual TypeScript/Java proto generation step.
+- **Simple**: Well-understood protocol. Easy to debug (just read
+  the pipe).
+
+**Protocol**: JSON-RPC 2.0 over stdin/stdout with newline-delimited
+JSON messages. The sidecar reads from stdin and writes to stdout.
+Stderr is reserved for logging.
+
+```
+→ {"jsonrpc":"2.0","method":"session/start","params":{...},"id":1}
+← {"jsonrpc":"2.0","result":{"sessionId":"..."},"id":1}
+← {"jsonrpc":"2.0","method":"webview/message","params":{"type":"assistant_delta","text":"..."}}
+```
+
+**Notifications** (no `id`) are used for streaming events
+(assistant deltas, tool events, state updates). The Kotlin plugin
+processes these and forwards them to the JCEF webview.
+
+**Callbacks** from sidecar → Kotlin (host operations) use
+JSON-RPC requests in the reverse direction:
+
+```
+← {"jsonrpc":"2.0","method":"host/showTextDocument","params":{"path":"..."},"id":100}
+→ {"jsonrpc":"2.0","result":{"success":true},"id":100}
+```
+
+#### Code Sharing Between VSCode, JetBrains, and CLI
+
+The shared SDK adapter layer contains:
+
+```
+src/sdk-adapter/
+  index.ts              — ClineSdkHost (creates ClineCore instance)
+  session-backend.ts    — LegacySessionBackend adapter
+  webview-bridge.ts     — SDK events → webview message translation
+  provider-migration.ts — Legacy provider settings migration
+  approval-adapter.ts   — Auto-approve settings → SDK tool policies
+  telemetry-adapter.ts  — Extension telemetry → SDK telemetry
+  types.ts              — WebviewInbound, WebviewOutbound types
+```
+
+Each host then has a thin integration layer:
+
+- **VSCode** (`src/hosts/vscode/sdk-extension.ts`): In-process.
+  Creates `ClineSdkHost`, registers VSCode LM handler, manages
+  webview lifecycle. Uses `postMessage` for webview communication.
+
+- **JetBrains** (`src/sidecar/main.ts`): Separate process. Creates
+  `ClineSdkHost`, reads/writes JSON-RPC on stdio. Registers
+  `HostCallbackClient` for IDE operations. The webview bridge code
+  is identical — it just sends messages over stdio instead of
+  `postMessage`.
+
+#### Statefulness and Reliability
+
+The sidecar is **stateful** — it holds the `ClineCore` instance with
+active sessions in memory. However, it is designed for **graceful
+restart**:
+
+- **Session persistence**: All session state is written to disk
+  after each turn (messages, manifest, transcript). On restart, the
+  sidecar re-reads the session index and can resume.
+- **Crash detection**: The Kotlin plugin monitors the sidecar
+  process. If it exits unexpectedly, the plugin restarts it after a
+  brief delay (same as current `CoreProcessManager.RESTART_DELAY`).
+- **Smaller messages**: Because the protocol is JSON-RPC with
+  incremental streaming (notifications for each delta), the
+  messages are much smaller than the current gRPC approach which
+  sends full state snapshots. This eliminates the heap pressure
+  that made the current system unreliable.
+- **Interrupted operations**: If the sidecar crashes mid-turn, the
+  next startup detects the unfinished session (status = "running"
+  but no live process) and marks it as interrupted, just like the
+  current task resumption flow.
+
+#### JetBrains-Specific Tools
+
+The HostCallback pattern makes it easy to add JetBrains-specific
+capabilities without changing shared code:
+
+1. **Registration**: The sidecar's `HostCallbackClient` declares
+   what capabilities the host supports (e.g., `"psi"`, `"runConfigs"`).
+2. **Tool Executors**: JetBrains-specific tool executors are
+   registered in `ClineCoreOptions.defaultToolExecutors` when the
+   sidecar starts. For example, a `getDiagnostics` executor that
+   calls `host/getDiagnostics` via JSON-RPC to get IntelliJ's PSI
+   analysis results.
+3. **No shared code changes**: Adding a new JetBrains capability
+   requires:
+   - Implementing the handler in Kotlin (`HostCallbackService`)
+   - Adding a JSON-RPC method in the sidecar's `HostCallbackClient`
+   - Optionally registering a custom tool executor
+
+Example for exposing JetBrains PSI:
+```kotlin
+// Kotlin side
+"host/getPsiStructure" -> {
+    val file = PsiManager.getInstance(project).findFile(virtualFile)
+    // ... extract structure
+    respondWithJson(result)
+}
+```
+```typescript
+// Sidecar side - registered as a custom tool executor
+defaultToolExecutors: {
+  list_code_definition_names: async (args) => {
+    // Call back to JetBrains for richer PSI-based results
+    const result = await hostCallback.call("host/getPsiStructure", { path: args.path });
+    return result;
+  }
+}
+```
+
+---
+
+## Architecture Overview
+
+### Current Architecture
+```
+┌─── VSCode Extension ──┐  ┌── JetBrains Plugin ──┐  ┌──── CLI ────┐
+│  WebviewProvider       │  │  Kotlin Plugin       │  │  React Ink  │
+│  Controller            │  │  CoreProcessManager  │  │  ClineAgent │
+│  Task                  │  │  ProtoBusProxy       │  │             │
+│  API providers (30+)   │  │  JCEF WebView        │  │             │
+│  McpHub                │  │                      │  │             │
+│  Webview (React)       │  │  ↓ gRPC              │  │             │
+│                        │  │  cline-core           │  │             │
+│  proto/cline/*.proto   │  │  (standalone Node)    │  │             │
+└────────────────────────┘  └──────────────────────┘  └─────────────┘
+```
+
+### Target Architecture
+```
+┌─── VSCode Extension ──┐  ┌── JetBrains Plugin ──┐  ┌──── CLI ────┐
+│  SDK Adapter Layer     │  │  Kotlin Plugin       │  │  React Ink  │
+│  @clinebot/core        │  │                      │  │  TUI        │
+│  (in-process)          │  │  ↓ JSON-RPC/stdio    │  │             │
+│  Webview (adapted)     │  │  SDK sidecar (Node)  │  │             │
+│                        │  │  @clinebot/core      │  │             │
+│  registerHandler       │  │                      │  │             │
+│  ("vscode-lm", ...)   │  │  Webview (adapted)    │  │             │
+└────────────────────────┘  └──────────────────────┘  └─────────────┘
+
+All clients backed by:
+  @clinebot/core → @clinebot/agents → @clinebot/llms
+       ↓                  ↓                   ↓
+    Sessions          Tools/Hooks        Providers
+    Storage           MCP Bridge         Model Catalog
+    Telemetry         Teams/Spawn        Handler Registry
+```
+
+---
+
+## What the SDK Already Provides
+
+These capabilities exist in the SDK and do not need to be rebuilt:
+
+1. **Legacy provider settings migration** —
+   `migrateLegacyProviderSettings()` reads `globalState.json` +
+   `secrets.json`, writes to `providers.json`. Handles Anthropic,
+   OpenAI, OpenAI Codex OAuth, OpenRouter, Bedrock, custom
+   OpenAI-compatible endpoints, etc. Existing providers are never
+   overwritten. Migrated entries are tagged `tokenSource: "migration"`.
+
+2. **30+ provider handlers** — Anthropic, OpenAI (chat + responses
+   API), Google Gemini, AWS Bedrock, Vertex AI, DeepSeek, Ollama,
+   LM Studio, Mistral, Groq, Fireworks, Together, xAI, Cerebras,
+   LiteLLM, Nebius, HuggingFace, and more.
+
+3. **Custom handler registry** — `registerHandler(id, factory)` and
+   `registerAsyncHandler(id, factory)` for providers that need
+   host-specific dependencies (e.g., VSCode LM API).
+
+4. **MCP management** — `InMemoryMcpManager` with stdio, SSE, and
+   streamableHttp transports. Config loader reads from
+   `~/.cline/data/settings/mcp.json` with Zod validation. Supports
+   legacy format migration.
+
+5. **Tool framework** — 8 built-in tools: `read_files`,
+   `search_codebase`, `run_commands`, `editor`, `apply_patch`,
+   `fetch_web_content`, `skills`, `ask_question`. Preset system with
+   `development` (act mode) and `readonly` (plan mode) presets.
+   Per-tool enable/disable. Policy-based approval (auto-approve,
+   require-approval, per-tool overrides). Model-aware tool routing
+   (e.g., OpenAI models use `apply_patch` instead of `editor`).
+
+6. **Session lifecycle** — `ClineCore.create()` → `host.start()` /
+   `host.send()` / `host.abort()` / `host.stop()` / `host.subscribe()`
+   Interactive mode with prompt queueing (`queue`/`steer` delivery).
+   Event subscription for streaming.
+
+7. **Telemetry** — `TelemetryService` with pluggable adapters:
+   `OpenTelemetryAdapter` (for enterprise OTEL), `LoggerTelemetryAdapter`.
+   Standard events: `session.started`, `session.ended`,
+   `task.created`, `task.conversation_turn`, `task.tool_used`, etc.
+   See "Telemetry Event Mapping" above for full mapping.
+
+8. **Rules & Skills** — Discovery from `.clinerules/`,
+   `~/Documents/Cline/Rules`, `~/.cline/data/settings/rules/`.
+   SKILL.md format with YAML frontmatter. Global and project scopes.
+
+9. **Hooks** — `HookEngine` with lifecycle events. Node subprocess
+   hook helpers for bash/powershell execution.
+
+10. **Subagents/Teams** — `AgentTeamsRuntime`, spawn tools, team
+    coordination with concurrent teammate agents.
+
+11. **System prompt generation** — `getClineDefaultSystemPrompt()`
+    with platform-aware customization.
+
+12. **OAuth token management** — `RuntimeOAuthTokenManager` handles
+    automatic token refresh during sessions for OAuth providers
+    (Cline, OpenAI Codex).
+
+13. **Storage isolation** — `CLINE_DIR`, `CLINE_DATA_DIR`,
+    `CLINE_SESSION_DATA_DIR` environment variables plus
+    `setClineDir()` / `setHomeDir()` APIs for test isolation.
+
+---
+
+## Test Strategy
+
+See `migration.md` for the phase-by-phase test plan. This section
+covers the evergreen test infrastructure and classification.
+
+### Test Infrastructure
+
+**Extension unit tests** use Mocha with a custom `requires.ts` that
+mocks `vscode` and `@integrations/checkpoints` modules. Config in
+`.mocharc.json`. These tests run without VSCode.
+
+**Webview tests** use Vitest with React Testing Library. Independent
+from the extension — they test React components in isolation.
+
+**E2E tests** use Playwright to drive a real VSCode instance with
+the extension loaded. They test chat, auth, diff editing, and editor
+integration against a mock API server on localhost:7777.
+
+**SDK adapter tests** use Vitest (simpler setup, better TypeScript
+support, no need for vscode-mock since adapter layer is
+VSCode-independent). Config in `vitest.config.sdk.ts`.
+
+### SDK Storage Isolation for Tests
+
+The SDK fully supports isolated test environments via environment
+variables and API calls:
+
+```typescript
+import { setClineDir, setHomeDir } from "@clinebot/shared/storage";
+const tempHome = mkdtempSync(join(tmpdir(), "test-home-"));
+process.env.HOME = tempHome;
+process.env.CLINE_DIR = join(tempHome, ".cline");
+process.env.CLINE_DATA_DIR = join(tempHome, ".cline", "data");
+setHomeDir(tempHome);
+setClineDir(process.env.CLINE_DIR);
+```
+
+### Test Framework Decisions
+
+- **Keep Mocha** for extension unit tests (existing infrastructure)
+- **Keep Vitest** for webview and CLI tests
+- **Keep Playwright** for VSCode E2E tests
+- **Add Vitest** for new SDK adapter tests
+- **Isolated home directories** for all new tests touching storage
+
+---
+
+## Manual QA Guide
+
+This section is for the QA team. It describes what has been removed
+(so you don't file bugs for missing features) and what areas carry
+the most regression risk after the SDK migration.
+
+### Removed Features — Do Not File Bugs
+
+- **Browser automation** — The built-in Playwright browser tool is
+  gone. Users should use third-party MCP browser tools instead.
+- **IDE terminal integration** — Commands now run exclusively in a
+  "background terminal" (headless shell). No terminal tab opens.
+- **Shadow-git checkpoints** — Existing checkpoints are invalidated.
+- **Memory bank / structured context** — All memory bank files and
+  UI removed.
+- **Focus chain** — No focus chain panel or inline indicators.
+- **Deep planning / `/deep-planning`** — Plan/Act mode remains as
+  the replacement.
+- **`/reportbug`** — Removed.
+- **Workflows** — Skills (SKILL.md format) are the replacement.
+- **Custom workflow slash commands** — Skills replace this.
+
+### Risk Areas — VSCode Extension
+
+1. **Provider credentials & model selection** — Verify existing API
+   keys survive the upgrade and downgrade.
+2. **Cline provider OAuth / SSO** — Test sign-in, sign-out, token
+   refresh, org switching.
+3. **Chat streaming & message display** — Watch for missing/duplicated
+   messages, broken streaming, performance regressions.
+4. **Tool approval flow** — Verify auto-approve, YOLO mode, per-tool
+   permissions.
+5. **Plan/Act mode** — Verify toggling, separate model configs,
+   state persistence.
+6. **Task history & resume** — Old tasks appear, can be resumed; new
+   tasks are saved.
+7. **MCP servers** — Existing configs picked up, tools work.
+8. **VSCode LM provider (Copilot)** — Verify it still works.
+9. **Settings UI** — All toggles and inputs persist correctly.
+10. **Webview performance** — Long conversations should not cause
+    sluggishness.
+
+### Risk Areas — JetBrains Extension
+
+1. **Sidecar process lifecycle** — Starts reliably, auto-restarts,
+   shuts down cleanly.
+2. **Webview communication** — Messages arrive, state is fresh.
+3. **Large conversations** — 100K+ tokens without OOM.
+4. **Host operations** — Open file, diagnostics, clipboard all work.
+5. **Keybindings** — Correct for the JetBrains platform.
+
+### Risk Areas — CLI
+
+1. **Agent backend replacement** — Core loop works in TUI and
+   headless modes.
+2. **Provider & model picker** — All providers appear, defaults
+   correct.
+3. **Shared state with IDE clients** — Credentials and history
+   visible across clients.
+4. **Slash commands** — Removed commands don't appear; remaining
+   ones work.
+5. **Worktrees & `--cwd`** — Function correctly.
+6. **ACP (Agent Communication Protocol)** — Programmatic usage works.

CAVEATS.md

@@ -0,0 +1,145 @@
+# SDK Migration Caveats & Known Issues
+
+Tracking issues found during the migration from the legacy inference system to the ClineCore SDK.
+
+## Status Legend
+- 🔴 **Blocker** — prevents core functionality
+- 🟡 **Minor** — cosmetic or UX annoyance
+- 🟢 **Fixed** — resolved
+
+NOTE:
+
+1. Use your debugging tool (DEBUG-HARNESS.md) to reproduce issues.
+2. Use your debugging tool to validate your fixes.
+3. Commit one verified change together.
+4. Work on these in any order you prefer.
+
+---
+
+🟢 Under accounts, the when logged in the "current balance" is ---- and
+the reload button does nothing. **Fixed:** getUserCredits handler fetches
+balance from Cline API using stored auth token.
+
+🟢 Under accounts, the "cline environment" dropdown doesn't change from
+production when you select "staging" or "local". **Fixed:** state-builder
+now reads `clineEnv` from globalState and maps to Environment enum;
+updateSettings handler persists clineEnv and clears auth on change.
+
+🟢 Under accounts, the logout button does nothing. **Fixed:**
+accountLogoutClicked handler clears auth credentials from disk.
+
+🟢 Reportedly under accounts you can't sign in. **Fixed:**
+accountLoginClicked handler (was STUB) now opens the Cline login page
+in the browser.
+
+🔴 When you have a low credit balance, even after you change accounts
+(for example from one "org" to another) or refreshing you keep getting
+an error "Insufficient balance. Your Cline Credits balance ..."
+
+🔴 In chat, a chat response has a "copy" button that is
+obscured/partially obscured by the last generated code block. In the
+classic extension, this appears with enough space around it to be
+visible.
+
+🟢 Changing the model during a conversation does not, *apparently*,
+change the model used for inference. **Fixed:** updateSettings now
+updates the in-memory apiConfiguration (not just disk) so
+model/provider changes take effect immediately for subsequent sessions.
+
+🔴 The OpenAI compatible provider produces "404 404 page not found"
+errors.
+
+🔴 When running tools (for example, prompt the agent to use kb_status)
+output rectangles appear but they are blank.
+
+🔴 When prompted with multiple-step work (like 1. Do this 2. Do that)
+the chat displays "0/0 TODOs".
+
+🟡 Checkpoints appear in options, but checkpoints don't appear in
+chats; we need to overhaul the checkpoints system anyway see
+ARCHITECTURE.md.
+
+🟢 In the history section, you can't mark chats as favorites.
+
+🟡 Banners (for example "Try Claude Sonnet 4.6") can be dismissed, but
+there are no < and > buttons visible to page between them.
+
+🟢 "Add to Cline" right click menu (use the command to trigger it)
+does not do anything. **Fixed:** sendAddToInputEvent now falls back to
+the SDK bridge's pushAddToInput when no classic gRPC subscriptions are
+active; WebviewGrpcBridge handles subscribeToAddToInput streaming and
+sends via both gRPC response and typed message.
+
+🟢 When a task is cancelled, you can't enter a new chat and send that
+chat in addition. (The repro is: Run a task, click cancel relatively
+quickly, type a new prompt, try to hit enter/click the arrow.) **Fixed:**
+cancelTask now clears currentSession after abort so subsequent
+askResponse calls start a new task instead of sending to the aborted
+session.
+
+🟢 MCP Servers tab never finishes loading (may be a workos: token
+prefix problem?) **Fixed:** subscribeToMcpServers now sends initial
+server data as a typed message (mcpServers) instead of only via gRPC
+streaming response, which the webview's dual-listen pattern picks up.
+
+🟢 Attached images (via drag and drop or the + icon to attach an image
+file) aren't submitted to models. **Fixed:** newTask and askResponse
+now include the images array in ClineMessage objects so attached images
+appear in the chat UI and are passed to the SDK session.
+
+🔴 Changing the account profile in the accounts tab (for example from
+Cline External, which has budget, to Cline Internal Testing Org, which
+doesn't) doesn't switch to that profile for inference.
+
+🟡 Account panel may show logged-out state on launch despite being
+logged in. Inference still works. The `subscribeToAuthStatusUpdate`
+streaming subscription in the webview may not be established before
+the bridge pushes initial auth data, causing a race condition. On most
+launches the auth state loads correctly (verified via debug harness),
+but the user reports intermittent occurrences.
+
+🔴 "Sign up with Cline" button does not do the IDE login flow — it
+opens the dashboard (`https://app.cline.bot/login`) instead. In
+origin/main, `accountLoginClicked` calls
+`AuthService.createAuthRequest()` which starts a local HTTP server for
+the OAuth callback, calls the Cline API auth endpoint with the
+callback URL, and opens the resulting OAuth redirect URL. The SDK does
+not have access to `AuthService` or `HostProvider.getCallbackUrl()`,
+so it falls back to opening the dashboard URL directly. Users who are
+not logged in cannot authenticate through the extension UI.
+**Requires:** SDK support for OAuth callback flows (see
+SDK-FEATURE-REQUESTS.md).
+
+🔴 Buttons in the MCP Servers popup do nothing. The restart (🔄),
+enable/disable toggle, and delete (🔴) buttons on individual MCP
+servers are all no-ops. The gRPC handler stubs these methods:
+`restartMcpServer`, `deleteMcpServer`, `toggleMcpServer`,
+`toggleToolAutoApprove`, `authenticateMcpServer`, `updateMcpTimeout`.
+In origin/main these go through `controller.mcpHub` which manages live
+MCP server connections. The SDK reads MCP settings from disk but does
+not expose server lifecycle management to the webview. See SDK-MCP.md
+for details, we need to implement much more elaborate MCP support
+client side to work with the SDK, via a custom RuntimeBuilder and tool
+client factory that supports streamable HTTP; watches the file for
+changes and either restarts a session or causes the tool definitions
+to change; etc.
+
+🔴 Buttons in the MCP Servers → Configure tab do nothing. Same root
+cause as above — the configure tab shows servers (e.g. "linear",
+"kamibiki") with restart/toggle/delete controls, but all interactions
+are stubbed. The "Configure MCP Servers" and "Advanced MCP Settings"
+links also depend on `openMcpSettings` which may or may not be wired.
+
+🟡 MCP Marketplace never loads. The Marketplace tab shows "No MCP
+servers found in the marketplace". **Partial fix applied:**
+`subscribeToMcpMarketplaceCatalog` in `webview-grpc-bridge.ts` now
+reads from the disk cache (`~/.cline/data/cache/mcp_marketplace_catalog.json`)
+via `readMcpMarketplaceCatalogFromCache()` and pushes the catalog to
+the webview as a streaming response. This works if the cache was
+previously populated by the classic extension. However,
+`refreshMcpMarketplace` (which fetches fresh data from the API) is
+still stubbed because it requires an authenticated API call to
+`https://api.cline.bot/v1/mcp/marketplace`. If no cache file exists
+(fresh install), the marketplace will remain empty.
+**Note:** Could not validate with debug harness since it runs the
+classic extension, not the SDK adapter.

CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [3.77.0]
+
+### Added
+
+- Add "Lazy Teammate Mode" experimental toggle
+- `read_file` tool now supports chunked reading for targeted file access
+
+### Fixed
+
+- Exclude `new_task` tool from system prompt in yolo/headless mode
+- Fix Kanban demo video formatting
+
+### Changed
+
+- Polish `Notification` hook functionality
+
 ## [3.76.0]
 
 ### Added

DEBUG-HARNESS.md

@@ -0,0 +1,134 @@
+# E2E Debugging Visibility
+
+This is a sub-project of the project described in migration.md. We are
+engaging in a big change to the VSCode extension. You gain visibility
+into the extension through tests, but sometimes that is not enough.
+
+Your goal is to create way where you can launch the VSCode extension
+and have access to the node debugger and webview debugger so that you
+can set break points, evaluate expressions, inject input (consider
+Microsoft's work with Playwright in VSCode, but anything that works is
+fine) step, etc. so that you can observe execution and find and fix
+problems without the tedious cycle off adding print statements,
+running a test which may hang, fixing something, removing the print
+statements, etc.
+
+For this step to be complete, you need to demonstrate you have the
+ability to:
+
+1. Build and run the VSCode extension in an unminified form, including
+   the webview unminified.
+
+2. Add and remove breakpoints, including conditional breakpoints, on
+   the extension side.
+
+3. Add and remove breakpoints, including conditional breakpoints, on
+   the webview side.
+
+4. Evaluate expressions at breakpoints. You should be able to refer to
+   local variables, that is, the extension code should be
+   unminified. (Concatenated is fine as long as you can find your way
+   around.)
+
+5. Run, step at breakpoints.
+
+6. Generate UI actions like opening the Cline sidebar, focusing
+   elements, typing, etc.
+
+7. Take screenshots that you can view.
+
+You need to use this tool inside your agentic loop, that is, you will
+need to drive both of these debugees simultaneously from one loop, so
+you may need to write yourself a tool which blocks until one of the
+debugees hits a breakpoint; can use a timeout and let you break and
+examine isolates and stacks; things of that nature.
+
+We are working on macOS, it is fine if this tool just works on macOS
+for now.
+
+## Caveats
+
+- **`CLINE_DIR` environment variable**: Because the debug harness
+  spawns a fresh VSCode instance that runs the Cline extension, and
+  because *you* (the agent) share state with that extension (API keys,
+  provider settings, task history), you **must** set `CLINE_DIR=~/.cline`
+  when launching the harness. Without it the debugee uses an isolated
+  data directory and won't have your API keys or provider configuration,
+  causing inference to fail silently (requests hang or error).
+  ```bash
+  CLINE_DIR=~/.cline npx tsx src/dev/debug-harness/server.ts --skip-build --auto-launch
+  ```
+
+- **⚠️ "Introducing Cline Kanban" promotion — DISMISS FIRST**: On
+  fresh launches, a full-screen promotional overlay ("Introducing Cline
+  Kanban") may appear in the sidebar webview. It obscures all other UI
+  elements, so screenshots will show only the promo and interactions
+  with the chat input, settings buttons, etc. will fail. **You must
+  dismiss it immediately after opening the sidebar, before doing
+  anything else.** This is easy to forget — if your screenshots look
+  wrong or interactions fail, this is almost certainly why.
+
+  **Method 1 — Click the close button via DOM** (most reliable):
+  ```bash
+  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+  curl localhost:19229/api -d '{
+    "method": "web.evaluate",
+    "params": {"expression": "document.querySelector(\".sr-only\")?.parentElement?.click()"}
+  }'
+  ```
+  This finds the `<span class="sr-only">Close</span>` element and
+  clicks its parent `<button>`.
+
+  **Method 2 — Press ESC** (simpler but less reliable):
+  ```bash
+  curl localhost:19229/api -d '{"method": "ui.open_sidebar"}'
+  curl localhost:19229/api -d '{
+    "method": "web.evaluate",
+    "params": {"expression": "document.activeElement.dispatchEvent(new KeyboardEvent(\"keydown\", {key: \"Escape\", code: \"Escape\", keyCode: 27, bubbles: true}))"}
+  }'
+  ```
+
+  If neither works, take a screenshot (`ui.screenshot`) to see what's
+  on screen and identify the current dismiss control.
+
+- **Screenshots**: `ui.screenshot` and `ui.sidebar_screenshot` save
+  PNG files to `/tmp/cline-debug/` and return `{path}` in the JSON
+  response. **Do NOT open the screenshot file with `open`** — on macOS
+  this launches Preview.app which covers the VSCode window you're
+  debugging. Use `read_file` on the returned path to examine the image
+  without disrupting the debuggee.
+
+- **Debuggee launch delay**: The post-launch activation delay is 1
+  second. If the extension hasn't fully loaded by the time you interact
+  with it, just retry — `ui.open_sidebar` and `findSidebar` have their
+  own internal polling with timeouts.
+
+- **Top toolbar buttons**: The "new task", "mcp servers", "history",
+  "accounts", and "settings" toolbar buttons are not in the webview DOM
+  (they're VSCode UI chrome). Instead of trying to click them, run the
+  associated VSCode commands directly:
+  - New Task: `cline.plusButtonClicked`
+  - MCP Servers: `cline.showMcpServers`
+  - History: `cline.showHistory`
+  - Accounts: `cline.showAccount`
+  - Settings: `cline.openSettings`
+  
+  Example:
+  ```bash
+  curl localhost:19229/api -d '{
+    "method": "ui.command_palette",
+    "params": {"command": "cline.openSettings"}
+  }'
+  ```
+
+- **CDP disconnects after window reload**: If you use
+  `workbench.action.reloadWindow` (e.g., to pick up a rebuilt
+  webview), the extension host CDP connection drops. You must do a full
+  `shutdown` + relaunch of the debug harness to reconnect.
+
+## References
+
+You can see the vscode source code in ~/clients/cline/vscode and
+search it with kb_search vscode
+
+You can search the cline source code (snapshot) with kb_search cline.

FIXED.md

@@ -0,0 +1,237 @@
+These are issues the agent claims to have fixed, but should be verified:
+
+## Fixed
+
+### 1. 🟢 Remote inference fails with ECONNREFUSED (localhost:4000)
+**File:** `src/sdk/cline-session-factory.ts`  
+**Symptom:** Sending any message with the Cline provider fails after 6 retries with "Cannot connect to API" / ECONNREFUSED to `http://localhost:4000/v1/chat/completions`.  
+**Root cause:** Base URL overrides (`openAiBaseUrl`, `openRouterBaseUrl`, `liteLlmBaseUrl`) were applied unconditionally to ALL providers, clobbering the Cline API URL. A stale `openAiBaseUrl: "http://localhost:4000/v1"` in `~/.cline/data/globalState.json` overwrote `https://api.cline.bot/api/v1`.  
+**Fix:** Guard each base URL override with a provider check so it only applies to its respective provider.
+
+---
+
+### 2. 🟢 Task history not persisted after completion
+**File:** `src/sdk/SdkController.ts`  
+**Symptom:** After a task completes successfully, the task did NOT appear in the RECENT section when returning to the home screen.  
+**Root cause:** `newTask()` created a `currentTaskItem` but never pushed it to `this.taskHistory[]`. `clearTask()` discarded it without saving. No disk persistence implementation existed.  
+**Fix:** `SdkController` now persists tasks on three paths: (1) `done` event updates `currentTaskItem` with final usage and calls `persistCurrentTask()`, (2) `clearTask()` calls `persistCurrentTask()` before resetting, (3) `cancelTask()` persists the in-progress task. `LegacyStateReader` gained `saveTaskHistory()`, `saveUiMessages()`, and `deleteTaskDirectory()` methods for disk I/O.
+
+### 3. 🟢 Task resumption not implemented
+**File:** `src/sdk/SdkController.ts`  
+**Symptom:** Cannot resume a previous task from history.  
+**Fix:** `showTaskWithId()` now finds the task in history, loads saved UI messages via `legacyState.readUiMessages()`, restores them into the translator, and sets `currentTaskItem`. The task view renders with full message history.
+
+### 6. 🟢 Settings persistence is best-effort / incomplete
+**File:** `src/sdk/SdkController.ts`  
+**Symptom:** `updateSettings()` was a no-op stub with a TODO comment.  
+**Fix:** `updateSettings()` now persists settings to `globalState.json` via `legacyState.saveApiConfiguration()`. `updateAutoApprovalSettings()` also persists via the same mechanism.
+
+### 7. 🟢 Completed task not appearing in RECENT section
+**Where:** Home screen → RECENT section  
+**Symptom:** After completing a task and clicking "New Task", the completed task did not appear in the RECENT history list.  
+**Fix:** Resolved by issue #2 fix — tasks are now persisted to `taskHistory` on completion, so they appear in RECENT.
+
+### 8. 🟢 Top bar buttons are non-functional
+**Where:** Header bar — accounts, settings, new chat, history buttons  
+**Symptom:** Clicking any of the top bar buttons (accounts icon, settings gear, new chat +, task history) does nothing. No navigation occurs, no panels open.  
+**Root cause:** gRPC stub. The webview subscribes to `subscribeToSettingsButtonClicked`, etc. — these are event streams pushed from the extension host when VSCode title bar buttons are clicked.  
+**Fix:** Extension.ts button commands now send typed `navigate` messages via `WebviewGrpcBridge.navigate()`, bypassing gRPC streaming subscriptions. Plus button also calls `clearSdkTask()` to reset the SDK session.
+
+### 9. 🟢 @ mentions / autocomplete not working
+**Where:** Chat input textarea  
+**Symptom:** Typing `@` in the chat input does not trigger any autocomplete dropdown. No filename suggestions, no context items offered.  
+**Root cause:** gRPC stub. The `@` autocomplete calls `FileServiceClient.searchFiles()` to get matching file paths.  
+**Fix:** Implemented `searchFiles` handler in grpc-handler.ts that delegates to `SdkController.searchFiles()`, which does a real filesystem walk of the workspace directory (max depth 8, skips node_modules/.git/etc). Returns results with `mentionsRequestId` for proper request correlation.
+
+### 10. 🟢 Add files/images button (+) does nothing
+**Where:** Bottom bar, "+" button next to chat input  
+**Symptom:** Clicking the "+" button to add files and images produces no response — no file picker, no dropdown, no action.  
+**Root cause:** gRPC stub. The button calls `FileServiceClient.selectFiles()` which opens a native file picker dialog.  
+**Fix:** Implemented `selectFiles` handler that returns `StringArrays` format (`values1` = image data URLs, `values2` = file paths). VscodeWebviewProvider callback reads image files as base64 data URLs and returns relative paths for non-images.
+
+### 11. 🟢 Cannot switch from Plan mode back to Act mode
+**Where:** Bottom bar Plan/Act toggle  
+**Symptom:** Clicking "Plan" successfully switches to Plan mode. However, clicking "Act" after that does NOT switch back to Act mode.  
+**Root cause:** Proto enum conversion bug — the webview sends numeric enum values (0=PLAN, 1=ACT) but the handler expected string values.  
+**Fix:** `handleTogglePlanActMode` now converts proto enum values: `0/"PLAN" → "plan"`, `1/"ACT" → "act"`, with fallback for already-converted string values.
+
+### 12. 🟢 "Manage cline rules and workflows" still mentions workflows
+**Where:** ClineRulesToggleModal tooltip and aria-label  
+**Symptom:** The tooltip and aria-label still said "Manage Cline Rules & Workflows".  
+**Fix:** Updated tooltip to "Manage Cline Rules" and aria-label to "Show/Hide Cline Rules". Also simplified chat placeholder text to remove "workflows" mention.
+
+### 4. 🟢 Input text not cleared immediately on send
+**Where:** Webview chat input  
+**Symptom:** After typing a message and pressing send/enter, the text remains visible in the input field briefly before clearing. Creates a feeling of lag.  
+**Root cause:** In `useMessageHandlers.ts`, `setInputValue("")` was called AFTER `await TaskServiceClient.newTask(...)` or `await TaskServiceClient.askResponse(...)` completed. The network round-trip caused visible delay before the input cleared.  
+**Fix:** Moved `setInputValue("")`, `setActiveQuote(null)`, `setSelectedImages([])`, `setSelectedFiles([])` to execute immediately when `hasContent` is true, before any async gRPC calls. React schedules a re-render synchronously, clearing the input before the network round-trip.
+
+### 5. 🟢 api_req_started fires with zeroed token counts
+**Where:** Message stream / ChatRow rendering  
+**Symptom:** An `api_req_started` partial message fires with `{"tokensIn":0,"tokensOut":0,"cost":0}` before real counts arrive, causing a brief flash of "0 / 200.0k" in the token usage bar.  
+**Root cause:** `ContextWindow.tsx` rendered the token bar whenever `tokenData` existed (i.e., when `contextWindow > 0`), regardless of whether `lastApiReqTotalTokens` was 0.  
+**Fix:** Added `tokenData.used === 0` guard to the null-return check in `ContextWindow.tsx`. The token bar now only renders when real (non-zero) token data is available.
+
+### 14. 🟢 "Delete chat" button shows placeholder size
+**Where:** Task history → delete button tooltip / label  
+**Symptom:** The "Delete chat" button tooltip displays `Delete Task (size: --)` when task size data is unavailable.  
+**Root cause:** `DeleteTaskButton.tsx` unconditionally rendered `(size: ${taskSize ? formatSize(taskSize) : "--"})`, showing "--" when `taskSize` is undefined.  
+**Fix:** Changed to conditionally include size: `taskSize ? \`Delete Task (${formatSize(taskSize)})\` : "Delete Task"`. The tooltip now shows just "Delete Task" when size is unavailable, or "Delete Task (12.4 KB)" when it is.
+
+### 13. 🟢 Terminal settings navigates to blank/stuck webview
+**Where:** Settings → Terminal tab  
+**Symptom:** Opening terminal settings causes React to crash, leaving a blank webview.  
+**Root cause:** `getAvailableTerminalProfiles` was a gRPC stub returning `{data:{}}`. The webview called `setAvailableTerminalProfiles(response.profiles)` where `response.profiles` was `undefined`, overwriting the default `[]`. Then `TerminalSettingsSection` called `profilesToShow.map()` on `undefined`, crashing React.  
+**Fix:** Implemented real `handleGetAvailableTerminalProfiles()` handler in grpc-handler.ts that calls `getAvailableTerminalProfiles()` from `utils/shell.ts`, returning platform-specific profiles (Default, zsh, bash on macOS). Also added `availableTerminalProfiles: []` to state-builder.ts as a safety net, and wired `scrollToSettings` to fire `navigate("settings", { targetSection })` via the bridge.  
+**Verified:** Debug harness confirmed handler returns `{data:{profiles:[{id:"default",...},{id:"zsh",...},{id:"bash",...}]}}`, Settings → Terminal tab renders "Default Terminal Profile" dropdown with all 3 options, shell integration timeout, and terminal reuse settings.
+
+### 16. 🟢 Cline Rules popup still has a "Workflows" tab
+**Where:** Scales-of-justice icon → Cline Rules modal  
+**Symptom:** The "Manage Cline Rules" popup contains a "Workflows" tab. Issue #12 fixed the tooltip text, but the tab itself still exists inside the modal.  
+**Root cause:** The `ClineRulesToggleModal` component had a full "Workflows" tab with toggle lists for global, local, and remote workflows, plus a description section. Workflows are no longer a feature.  
+**Fix:** Removed the Workflows tab button, workflows description text, workflows content section (remote/global/local workflow toggle lists), and the remote workflows banner condition from `ClineRulesToggleModal.tsx`. The `currentView` state type was narrowed from `"rules" | "workflows" | "hooks" | "skills"` to `"rules" | "hooks" | "skills"`.
+
+### 17. 🟢 Account pane shows "Sign up with Cline" despite being logged in
+**Where:** Account panel / pane  
+**Symptom:** Even when the user is already authenticated and logged in, the account pane still displays "Sign up with Cline" and other sign-up prompts as if the user were not authenticated.  
+**Root cause:** `subscribeToAuthStatusUpdate` is a streaming subscription. The bridge's `handleStreamingRequest()` fell into the `default` no-op case, so auth state was never pushed to the webview.  
+**Fix:** Added explicit `subscribeToAuthStatusUpdate` case in `handleStreamingRequest()` that reads auth credentials from disk and pushes them. Added `roles` to org data and null safety in `isAdminOrOwner()`.
+
+### 18. 🟢 "Sign up with Cline" button does nothing (moot)
+**Where:** Account pane → Sign up button  
+**Fix:** Resolved by #17 — the sign-up button is no longer shown when the user is already authenticated.
+
+### 19. 🟢 Terminal settings still shows "Terminal Execution Mode" option
+**Where:** Settings → Terminal  
+**Fix:** Removed the Terminal Execution Mode dropdown, its handler, and unused imports from `TerminalSettingsSection.tsx`.
+
+### 20. 🟢 Cline provider model type-ahead search does not work
+**Where:** Settings → Model selector (Cline provider)  
+**Root cause:** `refreshClineModelsRpc` was a gRPC stub returning `{}`. The webview never received any model data.  
+**Fix:** Implemented `handleRefreshClineModels()` in grpc-handler.ts that reads from disk cache first, then falls back to fetching from the Cline API using `globalThis.fetch`. Converts API response to `ModelInfo` records and returns in protobuf format.
+
+### 21. 🟢 Cline provider recommends possibly outdated model
+**Where:** Settings → Model selector (Cline provider)  
+**Fix:** Updated fallback recommendation text in `ClineModelPicker.tsx` from `anthropic/claude-sonnet-4.5` to `anthropic/claude-sonnet-4.6`.
+
+### 22. 🟢 "Use different models for Plan and Act" checkbox immediately unchecks
+**Where:** Settings → Model configuration  
+**Root cause:** `updateSettings()` was writing raw settings instead of merging individual known keys.  
+**Fix:** `updateSettings()` now iterates known settings keys and writes each one individually. `buildExtensionState()` reads `planActSeparateModels` from `globalState`.
+
+### 23. 🟢 MCP settings Configure tab crashes React
+**Where:** MCP Servers → Configure tab  
+**Root cause:** `refreshMcpMarketplace` stub returns `{}`, replacing the default `{ items: [] }` state, causing `items.find()` to crash.  
+**Fix:** Added optional chaining (`?.items?.find`) in `getMcpServerDisplayName()`.
+
+### 24. 🟢 History tab is empty and search does nothing
+**Where:** History tab (task history list)  
+**Root cause:** `handleGetTaskHistory()` returned `{ data: { history } }` but webview reads `response.tasks`.  
+**Fix:** Changed return to `{ data: { tasks, totalCount } }`. Implemented server-side filtering/sorting.
+
+### 25. 🟢 Auto-approve options immediately uncheck when toggled
+**Where:** Auto-approve options flyout  
+**Root cause:** Same as #22 — `updateAutoApprovalSettings()` was not persisting properly.  
+**Fix:** Fixed alongside #22.
+
+---
+
+### 15. 🟢 MCP tools are missing / not visible to the agent
+**Where:** Agent tool execution  
+**Symptom:** MCP tools that should be available to the agent are not discovered or listed. The agent cannot see or use any MCP-provided tools during task execution.  
+**Root cause:** `ClineCoreSession` in `cline-session-factory.ts` didn't pass MCP configuration through `coreConfig` when calling `host.start()`. The MCP settings file existed at `~/.cline/data/settings/cline_mcp_settings.json` but the session factory never wired MCP servers into the ClineCore session.  
+**Fix:** Added `getOrCreateMcpManager()` to `cline-session-factory.ts` that reads MCP server registrations via `resolveMcpServerRegistrations()`, creates an `InMemoryMcpManager` with a client factory using `@modelcontextprotocol/sdk` (supporting stdio, streamableHttp, and SSE transports), connects to all non-disabled servers, generates `Tool[]` via `createMcpTools()`, and passes them as `extraTools` in `coreConfig`. The MCP manager is cached across sessions (servers are long-lived processes). Connection has a 30s timeout to avoid blocking session start. Individual server connection failures are logged but don't prevent other servers or the session from starting.  
+**Verified:** Debug harness confirmed agent lists `kamibiki__kb_search`, `kamibiki__kb_status`, `kamibiki__kb_index` from the kamibiki MCP server, and successfully invoked `kamibiki__kb_status` returning real indexing data (6 repos, 1M+ embeddings).
+
+---
+
+### 27. 🟢 Banners (e.g., "Try Claude Sonnet 4.6") can't be dismissed
+**Where:** Home screen → banner carousel  
+**Symptom:** Clicking the X dismiss button on any banner does nothing — the banner remains visible and reappears on reload.  
+**Root cause:** Two issues: (1) `state-builder.ts` hardcoded `dismissedBanners: undefined` instead of reading from globalState, so dismissed banners were never communicated to the webview. (2) `grpc-handler.ts` wrote dismissed banner IDs as plain strings instead of the `{ bannerId, dismissedAt }` objects the webview expects.  
+**Fix:** State builder now reads `dismissedBanners` from globalState with `normalizeDismissedBanners()` that handles both legacy plain strings and new objects. Handler writes proper `{ bannerId, dismissedAt }` objects and normalizes legacy entries on read.  
+**Verified:** Debug harness confirmed banners dismiss correctly — carousel shrinks as each banner is dismissed and stays dismissed across reloads.
+
+### 28. 🟢 Can't mark chats as favorites in history
+**Where:** History tab → star button on task items  
+**Symptom:** Clicking the star icon on a history item does nothing — the favorite state never changes.  
+**Root cause:** Proto field name mismatch in `handleToggleTaskFavorite()`: handler read `request.params?.id` and `request.params?.isFavorite`, but the webview sends `taskId` and `isFavorited` (proto field names from `TaskFavoriteRequest`).  
+**Fix:** Handler now reads both proto names (`taskId`/`isFavorited`) with fallback to legacy names (`id`/`isFavorite`).  
+
+### 29. 🟢 Copy button obscured by last code block in chat
+**Where:** Chat response text with code blocks  
+**Symptom:** The response copy button overlaps with the last code block, making it hard to see and click.  
+**Root cause:** `CopyButton.tsx` positioned the bottom-right copy button at `bottom-1` (4px from bottom edge), which overlapped with code block content. No padding existed between the markdown content and the button.  
+**Fix:** Changed position to `bottom-2.5` (10px clearance) and added `pb-4` padding to the chat text content wrapper for code block clearance.  
+
+### 30. 🟢 Current balance shows "----" / reload button does nothing
+**Where:** Account pane → credit balance display  
+**Symptom:** The current balance always shows "----" and the reload button has no effect.  
+**Root cause:** `getUserCredits` handler returned `{ credits: undefined }` instead of calling the Cline API. The webview reads `response.balance.currentBalance` which was always undefined.  
+**Fix:** `getUserCredits` and `getOrganizationCredits` now fetch real balance data from the Cline API using the stored auth token (`Bearer` header). Includes 10s timeout and error handling.  
+**Tested:** Integration tests with mock HTTP server verify real balance data flows through correctly (7 tests).
+
+### 31. 🟢 Logout button does nothing
+**Where:** Account pane → logout button  
+**Symptom:** Clicking logout has no effect — the user remains logged in.  
+**Root cause:** `accountLogoutClicked` was a STUB (silent no-op) in grpc-handler.  
+**Fix:** Implemented `handleAccountLogout()` that calls `LegacyStateReader.clearClineAuthInfo()` to remove `cline:clineAccountId` from secrets.json, then pushes state update so the webview shows the sign-in view.  
+**Tested:** Integration test verifies credentials are cleared from disk and auth status shows unauthenticated after logout.
+
+### 32. 🟢 Low credit balance persists after account switching
+**Where:** Account pane after switching organizations  
+**Symptom:** After switching from a low-balance org to a high-balance org, the "Insufficient balance" error persists.  
+**Root cause:** `setUserOrganization` was a STUB. The active org was never updated on disk, so credit queries always returned the same org's data.  
+**Fix:** Implemented `handleSetUserOrganization()` that calls `LegacyStateReader.setActiveOrganization()` to update the `active` flag on orgs in stored credentials. Each credit fetch is a fresh API call keyed by org ID, so switching orgs correctly fetches the new org's balance.  
+**Tested:** Integration test with mock server verifies: switch from low-balance org → high-balance org returns correct (high) balance, not stale (low) balance.
+
+## Open Issues
+
+---
+
+### 26. 🟢 Clicking history items does not open them
+**Where:** History tab → clicking any task item; also RECENT section on home screen  
+**Symptom:** History items display correctly in the History view, but clicking on them does nothing — the view stays on the History tab instead of navigating to the chat view with the loaded task.  
+**Root cause:** `handleShowTaskWithId()` in `grpc-handler.ts` called `this.delegate.showTaskWithId(id)` to load the task data and push state, but never fired `this.onNavigateCallback?.("chat")` to tell the webview to navigate from the History view to the Chat view.  
+**Fix:** Added `this.onNavigateCallback?.("chat")` after `showTaskWithId()` completes in `grpc-handler.ts`. This sends a typed `navigate` message to the webview, which triggers `navigateToChat()` — hiding the History view and revealing the Chat view with the loaded task.  
+**Verified:** Debug harness confirmed clicking items in both the History tab and RECENT section on the home screen now navigates to the chat view with full message history loaded.
+
+---
+
+## Observations (not bugs, just notes)
+
+### UI Rendering — Task Completion View
+The completed task view renders correctly:
+- Task header with cost badge (e.g. "$0.0072")
+- Token usage bar (e.g. "1.4k / 200.0k")
+- Response text displayed properly
+- "Task Completed" card with green checkmark and the result
+- "Start New Task" button appears below the chat
+- Input area changes to "Type a message..." (follow-up mode)
+
+### Feature Card Carousel
+The home screen shows a rotating feature card carousel (1/4 through 4/4) promoting:
+- Claude Sonnet 4.6
+- MiniMax M2.5
+- ChatGPT integration
+- Jupyter Notebooks
+Each with a dismiss (X) button per-card.
+
+### Model Selector
+Bottom bar correctly shows `cline:anthropic/claud...` (truncated) with Plan/Act toggle. Act mode is the default.
+
+### Debug Harness: `ui.send_message` and `ui.react_input(submit:true)` Don't Start Tasks
+Both `ui.send_message` (gRPC postMessage) and `ui.react_input` with `submit:true` report success but don't actually start a new task—the webview stays on the home screen. The workaround is to use `ui.react_input` (without submit) to set the text, then dispatch a KeyboardEvent via `web.evaluate`:
+```
+curl -s localhost:19229/api -d '{"method":"ui.react_input","params":{"text":"your message","clear":true}}'
+curl -s localhost:19229/api -d '{"method":"web.evaluate","params":{"expression":"(() => { const ta = document.querySelector(\"textarea\"); ta.focus(); ta.dispatchEvent(new KeyboardEvent(\"keydown\",{key:\"Enter\",code:\"Enter\",keyCode:13,which:13,bubbles:true})); return \"ok\"; })()"}}'
+```
+
+### Debug Harness Limitations (Fixed)
+All three limitations below have been addressed:
+
+- ~~Programmatic textarea input doesn't reliably trigger React state updates after the first task.~~ **Fixed**: Two new commands added:
+  - `ui.react_input` — Uses `document.execCommand('insertText')` which fires real InputEvents that React's onChange handler processes correctly, even after multiple tasks.
+  - `ui.send_message` — Bypasses the textarea entirely by sending gRPC requests via `postMessage` directly to the extension host.
+- ~~The `web.evaluate` context can't access the VS Code API.~~ **Fixed**: The webview now exposes the VS Code API as `window.__clineVsCodeApi`, and a new `web.post_message` command lets the harness send arbitrary messages to the extension host through it.
+- ~~The `ui.locator` Playwright actions don't reliably target elements inside the webview iframe.~~ **Fixed**: `findSidebar()` now validates cached frame references (checking for both detached and stale frames), `getTarget()` accepts a `forceRefresh` flag, and `ui.locator` automatically retries with frame re-discovery when targeting sidebar elements.

README.md

@@ -129,9 +129,9 @@ Thanks to the [Model Context Protocol](https://github.com/modelcontextprotocol),
 
 ### Checkpoints: Compare and Restore
 
-As Cline works through a task, the extension takes a snapshot of your workspace at each step. You can use the 'Compare' button to see a diff between the snapshot and your current workspace, and the 'Restore' button to roll back to that point.
+As Cline works through a task, the extension can take an internal snapshot of your workspace at each step. You can use the 'Compare' button to see a diff between the snapshot and your current workspace, and the 'Restore' button to roll back to that point.
 
-For example, when working with a local web server, you can use 'Restore Workspace Only' to quickly test different versions of your app, then use 'Restore Task and Workspace' when you find the version you want to continue building from. This lets you safely explore different approaches without losing progress.
+For example, when working with a local web server, you can use 'Restore Workspace Only' to quickly test different versions of your app, then use 'Restore Task and Workspace' when you find the version you want to continue building from. This lets you safely explore different approaches without losing progress while the current checkpoint system is available.
 
 <!-- Transparent pixel to create line break after floating image -->
 

SDK-MCP.md

@@ -0,0 +1,436 @@
+# Cline SDK — MCP Server Management Reference
+
+This document describes how the Cline SDK handles MCP (Model Context Protocol) server lifecycle, configuration, and what is — and isn't — exposed for client integration. It is intended for client developers building UI around MCP server management.
+
+---
+
+## Summary: The Claim That "The SDK Lacks Hooks" Is Wrong
+
+The SDK **does** provide a full MCP manager with lifecycle operations. The `McpManager` interface in `@clinebot/core` supports:
+
+- `registerServer()` / `unregisterServer()` — add or remove servers
+- `connectServer()` / `disconnectServer()` — start or stop connections
+- `setServerDisabled()` — toggle enable/disable
+- `listServers()` — get snapshots of all servers with status
+- `refreshTools()` — force-refresh tool lists from a server
+- `dispose()` — shut down all servers
+
+The **actual gap** is narrower: there is no built-in file-watcher that auto-reloads `cline_mcp_settings.json` when it changes, and the RPC layer (`@clinebot/rpc`) does not currently expose MCP management endpoints. This means clients that manage MCP settings through the settings file must bridge the gap between file edits and runtime state themselves.
+
+---
+
+## SDK Architecture for MCP
+
+### Layer 1: Settings File (`cline_mcp_settings.json`)
+
+The SDK reads MCP server configuration from a JSON settings file:
+
+```json
+{
+  "mcpServers": {
+    "docs": {
+      "transport": { "type": "stdio", "command": "node", "args": ["./mcp.js"] }
+    },
+    "remote": {
+      "transport": { "type": "streamableHttp", "url": "https://mcp.example.com" },
+      "disabled": true
+    }
+  }
+}
+```
+
+**Location resolution** (`resolveDefaultMcpSettingsPath()`):
+- `CLINE_MCP_SETTINGS_PATH` env var (if set)
+- Otherwise defaults to the platform-specific Cline data directory
+
+**SDK utilities** for this file (all exported from `@clinebot/core`):
+- `resolveDefaultMcpSettingsPath()` — get the path
+- `hasMcpSettingsFile()` — check if it exists
+- `loadMcpSettingsFile()` — parse and validate with Zod
+- `resolveMcpServerRegistrations()` — parse file → `McpServerRegistration[]`
+- `registerMcpServersFromSettingsFile(manager)` — parse file and register all servers into a manager
+
+### Layer 2: McpManager (`InMemoryMcpManager`)
+
+`packages/core/src/extensions/mcp/manager.ts` — the runtime MCP lifecycle manager.
+
+```typescript
+interface McpManager extends McpToolProvider {
+  registerServer(registration: McpServerRegistration): Promise<void>;
+  unregisterServer(serverName: string): Promise<void>;
+  connectServer(serverName: string): Promise<void>;
+  disconnectServer(serverName: string): Promise<void>;
+  setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+  listServers(): readonly McpServerSnapshot[];
+  refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+  callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+  dispose(): Promise<void>;
+}
+```
+
+Key behaviors:
+- **Lazy connection**: Servers are registered in disconnected state; connection happens on first `listTools()` or `callTool()`.
+- **Transport change detection**: If `registerServer()` is called with a changed transport config, the existing connection is torn down and the client is recreated.
+- **Exclusive locking**: Per-server operation locks prevent concurrent connect/disconnect races.
+- **Tool caching**: `listTools()` caches results for `toolsCacheTtlMs` (default 5 seconds). Use `refreshTools()` to force a refresh.
+- **Disable = disconnect**: Calling `setServerDisabled(name, true)` immediately disconnects the server.
+
+### Layer 3: McpServerClient (Transport Layer)
+
+`packages/core/src/extensions/mcp/client.ts` — the actual MCP protocol client.
+
+The default factory (`createDefaultMcpServerClientFactory()`) creates `StdioMcpClient` instances:
+- Spawns child processes for `stdio` transport
+- Implements MCP JSON-RPC protocol (both newline-delimited and framed modes)
+- Auto-negotiates protocol mode by trying newline first, then framed
+- Protocol version: `2024-11-05`
+- Connect timeout: 1.5s, request timeout: 5s
+
+```typescript
+interface McpServerClient {
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  listTools(): Promise<readonly McpToolDescriptor[]>;
+  callTool(request: { name: string; arguments?: Record<string, unknown> }): Promise<McpToolCallResult>;
+}
+
+type McpServerClientFactory = (registration: McpServerRegistration) => Promise<McpServerClient> | McpServerClient;
+```
+
+**Transport types supported**:
+| Type | Status |
+|---|---|
+| `stdio` | ✅ Fully implemented in `StdioMcpClient` |
+| `sse` | ⚠️ Type defined, but no built-in client (factory only creates `StdioMcpClient`) |
+| `streamableHttp` | ⚠️ Type defined, but no built-in client |
+
+Clients needing SSE or StreamableHTTP support must provide a custom `McpServerClientFactory`.
+
+### Layer 4: Tool Bridge
+
+`packages/core/src/extensions/mcp/tools.ts` via `createMcpTools()` — converts MCP server tools into the SDK's `Tool` type for use in the agent loop.
+
+```typescript
+interface CreateMcpToolsOptions {
+  serverName: string;
+  provider: McpToolProvider;    // Usually the McpManager
+  nameTransform?: McpToolNameTransform;
+  timeoutMs?: number;
+  retryable?: boolean;
+  maxRetries?: number;
+}
+```
+
+Default name transform: `{serverName}__{toolName}` (e.g. `docs__search`).
+
+---
+
+## How the Runtime Builder Uses MCP
+
+`packages/core/src/runtime/runtime-builder.ts` → `loadConfiguredMcpTools()`:
+
+1. Resolves the MCP settings file path
+2. Creates a fresh `InMemoryMcpManager`
+3. Calls `registerMcpServersFromSettingsFile()` to load all servers
+4. Creates `Tool[]` via `createMcpTools()` for each non-disabled server
+5. Returns the tools + a `shutdown()` callback that calls `manager.dispose()`
+
+**Critical limitation**: This is done once at session build time. There is **no file watcher** that reloads MCP settings when they change during a session. If the settings file is edited mid-session, the running session won't see the changes.
+
+---
+
+## How Existing Apps Handle MCP Settings
+
+### Tauri Apps (`apps/code`, `apps/desktop`)
+
+Both Tauri apps implement MCP settings management **entirely in Rust** at the Tauri command level, bypassing the SDK's McpManager:
+
+```rust
+// apps/code/src-tauri/src/main.rs (identical pattern in apps/desktop)
+fn list_mcp_servers() -> Result<McpServersResponse, String>
+fn set_mcp_server_disabled(name, disabled) -> Result<McpServersResponse, String>
+fn upsert_mcp_server(input) -> Result<McpServersResponse, String>
+fn delete_mcp_server(name) -> Result<McpServersResponse, String>
+```
+
+These commands:
+- Read/write `cline_mcp_settings.json` directly
+- Return the full server list after each mutation
+- Do **not** interact with any running `McpManager` instance
+
+The frontend (`apps/code/components/views/settings/mcp-view.tsx`) calls these Tauri commands:
+- `list_mcp_servers` — refresh the displayed server list
+- `set_mcp_server_disabled` — toggle enable/disable
+- `upsert_mcp_server` — add or edit a server
+- `delete_mcp_server` — remove a server
+
+### Node.js Host (`apps/code/host/commands.ts`)
+
+The Code app's Node.js host also implements MCP CRUD directly:
+```typescript
+// Direct file reads/writes, not using McpManager
+function readMcpServersResponse(): JsonRecord    // reads cline_mcp_settings.json
+function writeMcpServersMap(servers: JsonRecord)  // writes cline_mcp_settings.json
+function ensureMcpSettingsFile(): string          // ensures file exists
+```
+
+Commands: `list_mcp_servers`, `set_mcp_server_disabled`, `upsert_mcp_server`, `delete_mcp_server`, `ensure_mcp_settings_file`
+
+### CLI (`apps/cli`)
+
+The CLI has `clite config mcp` / `clite list mcp` for listing configured MCP servers. It uses the SDK's `resolveMcpServerRegistrations()` to read the settings file.
+
+---
+
+## What the SDK DOES Expose (Exported from `@clinebot/core`)
+
+### Full Type & Implementation Exports
+
+```typescript
+// Manager
+export { InMemoryMcpManager } from "./extensions/mcp";
+export type { McpManager, McpManagerOptions } from "./extensions/mcp";
+
+// Client factory
+export { createDefaultMcpServerClientFactory } from "./extensions/mcp";
+export type { McpServerClient, McpServerClientFactory } from "./extensions/mcp";
+
+// Config loading
+export { hasMcpSettingsFile, loadMcpSettingsFile, registerMcpServersFromSettingsFile,
+         resolveDefaultMcpSettingsPath, resolveMcpServerRegistrations } from "./extensions/mcp";
+export type { LoadMcpSettingsOptions, McpSettingsFile, RegisterMcpServersFromSettingsOptions } from "./extensions/mcp";
+
+// Types
+export type { McpServerRegistration, McpServerSnapshot, McpConnectionStatus,
+             McpServerTransportConfig, McpStdioTransportConfig, McpSseTransportConfig,
+             McpStreamableHttpTransportConfig } from "./extensions/mcp";
+
+// Tool bridge
+export { createMcpTools } from "./extensions/mcp";
+export type { CreateMcpToolsOptions, McpToolCallRequest, McpToolCallResult,
+             McpToolDescriptor, McpToolNameTransform, McpToolProvider } from "./extensions/mcp";
+
+// Policies
+export { createDisabledMcpToolPolicies, createDisabledMcpToolPolicy } from "./extensions/mcp";
+```
+
+---
+
+## What's Missing / The Actual Gaps
+
+### 1. No RPC Endpoints for MCP Management
+
+`packages/rpc/src` has **zero** MCP-related code. There are no gRPC/RPC methods for:
+- Listing MCP servers
+- Registering/unregistering servers
+- Connecting/disconnecting servers
+- Toggling server disabled state
+- Refreshing tools
+
+This means RPC-backed clients cannot manage MCP through the RPC layer.
+
+### 2. No Settings File Watcher
+
+The SDK has a `UnifiedConfigFileWatcher` for agents, skills, rules, and workflows — but **not for MCP settings**. When another client edits `cline_mcp_settings.json`, running sessions don't see the change.
+
+### 3. No Live Manager Exposure to Clients
+
+The runtime builder creates an `InMemoryMcpManager` internally during `loadConfiguredMcpTools()`, but it's encapsulated — only the resulting `Tool[]` and a `shutdown()` callback are returned. The manager itself is not exposed to the caller, so clients can't call `connectServer()`, `disconnectServer()`, etc. on a running session's MCP manager.
+
+### 4. SSE/StreamableHTTP Client Not Implemented
+
+The transport types are defined, but the default client factory only produces `StdioMcpClient`. Clients needing SSE or StreamableHTTP must provide their own `McpServerClientFactory`.
+
+---
+
+## What a Client Needs to Do Today
+
+To implement full MCP server management UI:
+
+### Settings CRUD (Works Now)
+Read and write `cline_mcp_settings.json` directly. The SDK provides:
+- `resolveDefaultMcpSettingsPath()` — find the file
+- `loadMcpSettingsFile()` — parse it
+- Write it yourself (it's just JSON with `{ mcpServers: { ... } }`)
+
+This is exactly what the Tauri apps and Node.js host do today.
+
+### Runtime Lifecycle (Partial)
+For a new session, MCP tools are automatically loaded from the settings file by the runtime builder.
+
+For mid-session changes (restart, delete, toggle), clients currently have two options:
+1. **Edit the settings file and restart the session** — the next session build will pick up the changes
+2. **Create and manage your own `InMemoryMcpManager`** — the SDK exports everything needed:
+   ```typescript
+   const manager = new InMemoryMcpManager({
+     clientFactory: createDefaultMcpServerClientFactory(),
+   });
+   await manager.registerServer({ name: "docs", transport: { type: "stdio", command: "node", args: ["./mcp.js"] } });
+   await manager.connectServer("docs");
+   const tools = await manager.listTools("docs");
+   await manager.disconnectServer("docs");
+   await manager.unregisterServer("docs");
+   ```
+
+### Cross-Client Sync (Not Built)
+If multiple clients share the same settings file, there is no notification mechanism. Clients would need their own file watcher (e.g. `fs.watch()` / `chokidar`) on `cline_mcp_settings.json`.
+
+---
+
+## How MCP Tools Become Visible to the Agent (and the Client)
+
+### MCP Tools Are Injected as Regular SDK Tools
+
+The `createMcpTools()` function converts each MCP tool descriptor into a standard `Tool` object (from `@clinebot/shared`). These tools are **indistinguishable** from built-in tools once created — they have a `name`, `description`, `inputSchema`, and an `execute` function.
+
+```typescript
+// packages/core/src/extensions/mcp/tools.ts
+export async function createMcpTools(options: CreateMcpToolsOptions): Promise<Tool[]> {
+  const descriptors = await options.provider.listTools(options.serverName);
+  return descriptors.map((descriptor) => createTool({
+    name: nameTransform({ serverName, toolName: descriptor.name }),  // e.g. "docs__search"
+    description: descriptor.description || `Execute MCP tool "${descriptor.name}" from server "${serverName}".`,
+    inputSchema: descriptor.inputSchema,
+    execute: async (input, context) => options.provider.callTool({
+      serverName, toolName: descriptor.name, arguments: input, context,
+    }),
+  }));
+}
+```
+
+### The Runtime Builder Merges MCP Tools with Built-in Tools
+
+In `DefaultRuntimeBuilder.build()` (line ~460-476):
+```typescript
+if (normalized.enableTools) {
+  tools.push(...createBuiltinToolsList(...));   // SDK built-in tools
+  const mcpRuntime = await loadConfiguredMcpTools();  // MCP tools
+  tools.push(...mcpRuntime.tools);
+  mcpShutdown = mcpRuntime.shutdown;
+}
+```
+
+The resulting `tools: Tool[]` array — containing **both** built-in and MCP tools — is returned in the `BuiltRuntime`:
+```typescript
+interface BuiltRuntime {
+  tools: Tool[];        // ← includes MCP tools
+  hooks?: AgentHooks;
+  shutdown: (reason: string) => Promise<void> | void;
+  // ...
+}
+```
+
+### The Agent Receives All Tools (Including MCP) Uniformly
+
+The `Agent` (from `@clinebot/agents`) receives the merged `tools` array. It doesn't know or care which tools came from MCP vs built-in. The LLM sees all tools in its tool definitions and can call any of them.
+
+### Client Control Over MCP Tools
+
+Clients **can** control MCP tools through the same mechanisms they use for any tool:
+
+1. **Tool Policies** — Enable/disable or require approval per tool name:
+   ```typescript
+   toolPolicies: {
+     "docs__search": { enabled: true, autoApprove: true },
+     "docs__write": { enabled: true, autoApprove: false },  // requires approval
+     "risky__delete": { enabled: false },                    // completely disabled
+   }
+   ```
+
+2. **MCP-specific disable policies** — The SDK provides helpers to disable all tools from a specific MCP server:
+   ```typescript
+   import { createDisabledMcpToolPolicies } from "@clinebot/core";
+   const policies = createDisabledMcpToolPolicies({
+     serverName: "risky-server",
+     toolNames: ["delete", "modify", "drop"],
+   });
+   // → { "risky-server__delete": { enabled: false }, ... }
+   ```
+
+3. **CLI flags** — `--tool-enable <name>` and `--tool-disable <name>` work for MCP tools too (they operate on the transformed name like `docs__search`).
+
+4. **Tool approval callback** — When `autoApprove: false`, the agent calls `requestToolApproval()` before executing the tool, giving the client a chance to approve/reject each call.
+
+5. **`enableTools: false`** — Disables ALL tools including MCP.
+
+### What Clients Can See
+
+The `BuiltRuntime.tools` array is visible to the caller of `runtimeBuilder.build()`. The session manager and host apps can inspect it to know exactly which tools (including MCP tools) are available.
+
+MCP tools follow the naming convention `{serverName}__{toolName}` by default, so clients can identify which tools came from which MCP server by parsing the name prefix.
+
+---
+
+## Remote MCP Servers (StreamableHTTP / SSE)
+
+### The SDK's Design Intent
+
+The SDK clearly **intends** to support remote MCP servers. The evidence:
+
+1. **Transport types are fully defined and validated**:
+   ```typescript
+   interface McpStreamableHttpTransportConfig {
+     type: "streamableHttp";
+     url: string;
+     headers?: Record<string, string>;
+   }
+   interface McpSseTransportConfig {
+     type: "sse";
+     url: string;
+     headers?: Record<string, string>;
+   }
+   ```
+
+2. **Config loader validates all three transports** — The Zod schemas accept `stdio`, `sse`, and `streamableHttp` equally. Legacy formats (`url` without explicit type) default to `sse`; `transportType: "http"` maps to `streamableHttp`.
+
+3. **Manager is transport-agnostic** — The `McpManager` uses `McpServerClientFactory` to create clients. It doesn't care about transport type; that's the factory's job.
+
+4. **Tests use `streamableHttp` registrations** — The manager test suite registers servers with `transport: { type: "streamableHttp", url: "https://mcp.example.test" }` and they work fine (with a mock client factory).
+
+5. **Settings file and UI accept all transports** — Both Tauri apps and the Code app UI offer `stdio`, `sse`, and `streamableHttp` as choices.
+
+### What's Actually Implemented vs Not
+
+| Concern | Status |
+|---|---|
+| Transport type definitions | ✅ Complete |
+| Settings file parsing for all transports | ✅ Complete |
+| Settings file CRUD (UI/Tauri/CLI) for all transports | ✅ Complete |
+| `McpManager` lifecycle for all transports | ✅ Complete (transport-agnostic) |
+| `StdioMcpClient` (spawns child process) | ✅ Complete |
+| HTTP/SSE client (connects to remote URL) | ❌ Not in default factory |
+
+### The Gap for Remote Servers
+
+The **only** thing missing is that `createDefaultMcpServerClientFactory()` returns a `StdioMcpClient` unconditionally — it doesn't check `registration.transport.type` and will fail for `sse` or `streamableHttp` transports.
+
+A client can fix this by providing a custom factory:
+```typescript
+const manager = new InMemoryMcpManager({
+  clientFactory: async (registration) => {
+    if (registration.transport.type === "stdio") {
+      return createDefaultMcpServerClientFactory()(registration);
+    }
+    if (registration.transport.type === "streamableHttp") {
+      return new MyStreamableHttpMcpClient(registration);
+    }
+    if (registration.transport.type === "sse") {
+      return new MySseMcpClient(registration);
+    }
+    throw new Error(`Unsupported transport: ${registration.transport.type}`);
+  },
+});
+```
+
+The client just needs to implement the `McpServerClient` interface (4 methods: `connect`, `disconnect`, `listTools`, `callTool`).
+
+---
+
+## Recommendation for Improvement
+
+To close the gap, the SDK could:
+
+1. **Add MCP settings to the config watcher system** — create an `McpConfigDefinition` for `UnifiedConfigFileWatcher` to auto-detect changes to `cline_mcp_settings.json`
+2. **Expose the McpManager from the runtime builder** — return it alongside the tool list so clients can call lifecycle methods
+3. **Add MCP management to the RPC layer** — implement gRPC methods that proxy to `McpManager`
+4. **Implement SSE/StreamableHTTP clients** — extend the default client factory

SDK-OAUTH.md

@@ -0,0 +1,251 @@
+# Cline SDK — Provider Credentials & OAuth Reference
+
+This document describes how the Cline SDK publishes inference provider metadata, handles credential resolution, and orchestrates OAuth authentication flows. It is intended for client developers integrating with `@clinebot/llms` and `@clinebot/core`.
+
+---
+
+## Provider Catalog
+
+The SDK owns the canonical list of inference providers. It is **not** produced by clients.
+
+### Where Providers Are Defined
+
+| Layer | Location | What It Owns |
+|---|---|---|
+| `@clinebot/llms` | `packages/llms/src/gateway/builtins.ts` | `BUILTIN_SPECS` array — every built-in provider's `id`, `name`, `description`, `family`, `capabilities`, `apiKeyEnv`, `defaultModelId`, default `baseUrl` |
+| `@clinebot/llms` | `packages/llms/src/provider/ids.ts` | `BUILT_IN_PROVIDER` enum and `BUILT_IN_PROVIDER_IDS` array |
+| `@clinebot/shared` | `packages/shared/src/llms/gateway.ts` | `GatewayProviderManifest` type — the runtime shape clients receive |
+| `@clinebot/llms` | `packages/llms/src/gateway/provider-keys.ts` | Mapping from external `modelsDevKey` identifiers to runtime/generated provider IDs |
+
+### BuiltinSpec Shape
+
+Each built-in provider is declared as a `BuiltinSpec`:
+
+```typescript
+interface BuiltinSpec {
+  id: string;                          // e.g. "anthropic", "openai-native", "cline"
+  name: string;                        // Human-readable name
+  description: string;
+  family: ProviderFamily;              // Protocol family: "openai-compatible", "anthropic", "google", etc.
+  protocol?: ProviderProtocol;
+  client?: ProviderClient;
+  capabilities?: ProviderCapability[]; // "reasoning" | "prompt-cache" | "tools" | "oauth" | "temperature" | "files"
+  modelsProviderId?: string;
+  defaultModelId?: string;
+  modelsFactory?: () => Record<string, ModelInfo>;
+  env?: readonly ("browser" | "node")[];
+  apiKeyEnv?: readonly string[];       // Environment variable names for API key resolution
+  docsUrl?: string;
+  defaults?: GatewayProviderSettings;  // Includes default baseUrl
+}
+```
+
+### GatewayProviderManifest (Runtime Shape)
+
+`toManifest()` converts a `BuiltinSpec` into a `GatewayProviderManifest`, which is what clients interact with at runtime:
+
+```typescript
+interface GatewayProviderManifest {
+  id: string;
+  name: string;
+  description?: string;
+  defaultModelId: string;
+  models: readonly GatewayModelDefinition[];
+  env?: readonly ("browser" | "node")[];
+  api?: string;             // Default base URL
+  apiKeyEnv?: readonly string[];  // Env var names for credential resolution
+  docsUrl?: string;
+  metadata?: Record<string, JsonValue | undefined>;
+}
+```
+
+---
+
+## Credential Resolution
+
+### API Key Resolution Order
+
+The SDK resolves credentials in `packages/llms/src/gateway/http.ts` via `resolveApiKey()`:
+
+1. **Explicit `apiKey`** — passed directly in provider config
+2. **`apiKeyResolver()`** — async callback (e.g. fetch from keychain)
+3. **`apiKeyEnv`** — iterate environment variable names from the provider manifest; first non-empty value wins
+
+If all fail, `getMissingApiKeyError()` produces a message naming the expected env vars:
+> `Missing API key for provider "anthropic". Set apiKey explicitly or one of: ANTHROPIC_API_KEY.`
+
+### Per-Provider Credential Metadata Examples
+
+| Provider | `apiKeyEnv` |
+|---|---|
+| `anthropic` | `["ANTHROPIC_API_KEY"]` |
+| `openai-native` | `["OPENAI_API_KEY"]` |
+| `gemini` | `["GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"]` |
+| `vertex` | `["GCP_PROJECT_ID", "GOOGLE_CLOUD_PROJECT", "GOOGLE_APPLICATION_CREDENTIALS", "GEMINI_API_KEY", "GOOGLE_API_KEY"]` |
+| `bedrock` | `["AWS_REGION", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN"]` |
+| `sapaicore` | `["AICORE_SERVICE_KEY", "VCAP_SERVICES"]` |
+| `cline` | `["CLINE_API_KEY"]` |
+| `openrouter` | `["OPENROUTER_API_KEY"]` |
+| `deepseek` | `["DEEPSEEK_API_KEY"]` |
+
+Most OpenAI-compatible providers follow the pattern `["{PROVIDER}_API_KEY"]`.
+
+### Provider-Specific Settings
+
+Some providers need additional configuration beyond an API key:
+
+- **Vertex/GCP**: `gcpProjectId`, `gcpRegion`
+- **Bedrock/AWS**: `awsAuthentication` (`"iam" | "api-key" | "profile"`), `awsRegion`, `awsAccessKey`, `awsSecretKey`, `awsSessionToken`, `awsProfile`
+
+These are passed through `ProviderSelectionConfig.settings` rather than `apiKeyEnv`.
+
+---
+
+## OAuth Authentication
+
+### Which Providers Support OAuth
+
+Only providers with `"oauth"` in their `capabilities` array support OAuth:
+
+| Provider | OAuth Implementation |
+|---|---|
+| `cline` | `packages/core/src/auth/cline.ts` — Cline API OAuth |
+| `openai-codex` | `packages/core/src/auth/codex.ts` — ChatGPT/OpenAI Codex OAuth with PKCE |
+| `oca` | `packages/core/src/auth/oca.ts` — Oracle Code Assist OAuth with PKCE |
+
+The CLI confirms this in `apps/cli/src/commands/auth.ts`:
+```typescript
+// Only these three providers support CLI OAuth flow
+if (providerId === "cline") return oauthApi.loginClineOAuth(...)
+if (providerId === "oca") return oauthApi.loginOcaOAuth(...)
+if (providerId === "openai-codex") return oauthApi.loginOpenAICodex(...)
+throw new Error(`Provider "${providerId}" does not support CLI OAuth flow`)
+```
+
+### Responsibility Split: SDK vs Client
+
+| Concern | Owner | Details |
+|---|---|---|
+| Spawn local callback server | **SDK** | `startLocalOAuthServer()` in `packages/core/src/auth/server.ts` |
+| Build authorization URL | **SDK** | Each auth module constructs the URL with redirect_uri, state, etc. |
+| Open browser / present URL | **Client** | SDK calls `callbacks.onAuth({ url, instructions })` — client decides how to handle |
+| Collect redirect code | **SDK** | Local HTTP server parses `?code=&state=` from redirect |
+| Exchange code for tokens | **SDK** | Each auth module handles the token exchange |
+| Prompt for manual code input | **Client** | SDK calls `callbacks.onPrompt()` or `callbacks.onManualCodeInput()` as fallback |
+
+### The SDK Does NOT Open Browsers
+
+The SDK never calls `open()` or launches a browser. It uses a callback-based interface:
+
+```typescript
+// packages/core/src/auth/types.ts
+interface OAuthLoginCallbacks {
+  onAuth: (info: { url: string; instructions?: string }) => void;  // SDK emits URL here
+  onPrompt: (prompt: OAuthPrompt) => Promise<string>;              // SDK asks for input here
+  onProgress?: (message: string) => void;
+  onManualCodeInput?: () => Promise<string>;                       // Fallback if redirect fails
+}
+```
+
+### The SDK DOES Spawn the Local Callback Server
+
+`packages/core/src/auth/server.ts` exports `startLocalOAuthServer()`:
+
+- Creates a `node:http` server on `127.0.0.1`
+- Tries a list of candidate ports in order, skipping `EADDRINUSE`
+- Listens on a configured callback path (e.g. `/callback`)
+- Extracts `code`, `state`, `provider`, `error` from the redirect URL query params
+- Returns a success HTML page to the browser ("Authentication Successful — You can close this window")
+- Auto-closes after 3 seconds via embedded `<script>`
+- Times out after 5 minutes by default
+
+```typescript
+interface LocalOAuthServer {
+  callbackUrl: string;                                    // e.g. "http://127.0.0.1:54321/callback"
+  waitForCallback: () => Promise<OAuthCallbackPayload>;   // Resolves when redirect arrives
+  cancelWait: () => void;
+  close: () => void;
+}
+```
+
+### OAuth Redirect URLs Are NOT in Provider Metadata
+
+Redirect/callback URLs are **dynamically constructed at runtime**, not published in the provider manifest:
+
+- **Cline**: Dynamic port → `http://localhost:{port}/callback`
+- **OpenAI Codex**: Hardcoded `http://localhost:1455/auth/callback` (fixed port, fixed client ID `app_EMoamEEZ73f0CkXaXp7hrann`)
+- **OCA**: Dynamic port with configurable path, default `/oauth/callback`
+
+### Client Integration Helper
+
+`packages/core/src/auth/client.ts` provides a convenience adapter:
+
+```typescript
+interface OAuthClientCallbacksOptions {
+  onPrompt: (prompt: OAuthPrompt) => Promise<string>;
+  onOutput?: (message: string) => void;
+  openUrl?: (url: string) => void | Promise<void>;  // Client provides browser-open function
+  onOpenUrlError?: (context: { url: string; error: unknown }) => void;
+}
+
+function createOAuthClientCallbacks(options): OAuthLoginCallbacks
+```
+
+The `openUrl` field is where a CLI passes its `open` implementation, a Tauri app passes shell open, etc.
+
+### End-to-End OAuth Flow
+
+```
+1. Client calls SDK login function (e.g. loginClineOAuth)
+2. SDK → startLocalOAuthServer() → binds to 127.0.0.1:{port}
+3. SDK → builds authorization URL with redirect_uri = callback server URL
+4. SDK → callbacks.onAuth({ url, instructions })
+5. Client → opens browser (or displays URL to user)
+6. User → authenticates in browser
+7. Provider → redirects to http://127.0.0.1:{port}/callback?code=...&state=...
+8. SDK's local server → captures code and state, renders success page
+9. SDK → exchanges authorization code for tokens (provider-specific)
+10. SDK → returns OAuthCredentials { access, refresh, expires, accountId?, email? }
+```
+
+If the local server redirect times out or fails, the SDK falls back to:
+- `onManualCodeInput()` — ask user to paste code
+- `onPrompt({ message: "Paste the authorization code (or full redirect URL):" })` — final fallback
+- `parseAuthorizationInput()` can handle both raw codes and full URLs with query params
+
+### OAuthCredentials Shape
+
+```typescript
+interface OAuthCredentials {
+  access: string;       // Access token
+  refresh: string;      // Refresh token
+  expires: number;      // Expiration timestamp (ms since epoch)
+  accountId?: string;   // Provider-specific account ID
+  email?: string;       // For display/telemetry
+  metadata?: Record<string, unknown>;
+}
+```
+
+### Provider-Specific OAuth Details
+
+**Cline OAuth** (`packages/core/src/auth/cline.ts`):
+- Authorization URL: `{apiBaseUrl}/auth/authorize?client_type=extension&callback_url=...&state=...`
+- Token endpoint: `{apiBaseUrl}/auth/token`
+- Default API base: `https://api.cline.bot`
+- Supports provider passthrough (callback can include `?provider=google` etc.)
+
+**OpenAI Codex OAuth** (`packages/core/src/auth/codex.ts`):
+- Uses PKCE (code challenge + verifier)
+- Authorization: `https://auth.openai.com/oauth/authorize`
+- Token: `https://auth.openai.com/oauth/token`
+- Client ID: `app_EMoamEEZ73f0CkXaXp7hrann`
+- Fixed redirect: `http://localhost:1455/auth/callback`
+- Scopes: `openid profile email offline_access`
+- JWT claim path: `https://api.openai.com/auth`
+
+**OCA OAuth** (`packages/core/src/auth/oca.ts`):
+- Uses PKCE (S256 code challenge)
+- Supports `internal` and `external` mode with separate IDCS URLs and client IDs
+- Authorization: `{idcsUrl}/oauth2/v1/authorize`
+- Token: `{idcsUrl}/oauth2/v1/token`
+- Configurable callback ports and path

assets/icons/sleepy-cline.svg

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 512 535">
+  <!-- Generator: Adobe Illustrator 29.8.5, SVG Export Plug-In . SVG Version: 2.1.1 Build 2)  -->
+  <defs>
+    <style>
+      .st0 {
+        fill: #fff;
+      }
+    </style>
+  </defs>
+  <path class="st0" d="M500.6,300.5c-9-20.7-17.9-41.4-26.9-62.1-.7-2-.3-4.4-.3-6.4.4-9,1.1-18,1.4-27,2.8-28.4-6.5-58-25.2-79.6-15.1-18.1-36.6-30.7-59.6-35.5-8.1-1.8-16.6-1.6-25-2.1-10-.7-20-1-30-1.7,2-11.9,1-24.1-3.7-35.3-5.8-14.1-16.8-25.9-30.6-32.5-14.4-7-31.5-8.2-46.7-3.1-16,5.2-29.5,17-36.8,32.1-4.9,10-6.8,21.2-6.1,32.2-19.7-1-39.4-2.2-59.1-3.1-26.8.5-53,11.7-72,30.6-20.2,19.5-31.7,47-32.3,75-.5,9.3-1,18.7-1.5,28-.2,2.1,0,4.1-1.2,6-9.8,16.8-19.5,33.7-29.4,50.6-2.2,4.1-4.9,8-6.6,12.3-2,5.7-1.2,12.2,1.3,17.6,8.9,19.5,17.6,39.2,26.5,58.7.8,1.9,1.5,3.7,1.3,5.8-.6,10.3-1.1,20.7-1.7,31-1.5,21.2,3,42.6,13.5,61.1,8.8,15.8,21.6,29.4,37.1,38.9,13.9,8.7,29.7,13.9,46,15.4,72,3.9,144,7.7,216,11.5,20.1,1.8,40.8-2.8,58.5-12.5,18.8-10.1,34.2-26,44.1-44.9,6.5-12.6,10.5-26.4,11.7-40.5.7-12.4,1.2-24.7,2-37.1,0-3.3,1.9-5.5,3.3-8.2,6.6-11.8,13.5-23.4,20.1-35.2,3.7-6.9,8.1-13.4,11.6-20.4,3.2-6.1,3.2-13.5.3-19.7ZM218.5,316.5c-9.7,7.1-21.3,12.3-33.5,12.5-17.6,1-35.1-5.3-49-16-4.6-3.2-8.1-7.5-9.6-13,0-1.8-.7-3.6,1.7-3.8,4,1,7.9,2.6,12,3.5,22.8,5.6,47.6,5.9,71,4.8,6.5-.2,13-1.3,19.5-.9-2.7,5.6-7.1,9.2-12,12.9ZM276,449.7c-14,.5-28,.1-42-.2-2.1,0-4.3,0-6.4-.4-.9-2.1.6-3.2,1.7-4.8,4.8-5.9,11-11,18.7-12.4,8.4-1.6,16.5,1.2,23.5,5.5,4.7,3,9.2,6.3,12.6,10.8-2.6,1.1-5.3,1.4-8.1,1.4ZM390.4,319.4c-16.4,14.2-38.8,21.8-60.4,18.4-13.2-1.6-24.7-8.6-34.1-17.7-3-3-6.2-6.5-8.1-10.4.5-1,1.2-1.6,2.2-1.6,2.8-.2,5.7.7,8.5,1.1,16,2.9,32.3,4.9,48.5,5.5,14.3.4,28.2-.2,42.2-3.6,2.2-.6,3.7-.3,5.8.5-1.1,2.9-2.2,5.7-4.6,7.8Z"/>
+</svg>

cli/CHANGELOG.md

@@ -1,5 +1,19 @@
 # cline
 
+## [2.12.0]
+
+### Added
+
+- `read_file` tool now supports chunked reading for targeted file access
+
+### Fixed
+
+- Exclude `new_task` tool from system prompt in yolo/headless mode
+
+### Changed
+
+- Polish `Notification` hook functionality
+
 ## [2.9.0]
 
 ### Added

cli/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cline",
-	"version": "2.11.0",
+	"version": "2.13.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",

cli/src/agent/messageTranslator.ts

@@ -632,7 +632,6 @@ function translateAskMessage(
 		case "new_task":
 		case "condense":
 		case "summarize_task":
-		case "report_bug":
 		case "api_req_failed":
 		case "mistake_limit_reached":
 		case "command_output":

cli/src/components/ChatMessage.tsx

@@ -844,22 +844,6 @@ export const ChatMessage: React.FC<ChatMessageProps> = ({ message, mode, isStrea
 		)
 	}
 
-	// Report bug request
-	if (type === "ask" && ask === "report_bug" && text) {
-		return (
-			<Box flexDirection="column" marginBottom={1} width="100%">
-				<DotRow color={COLORS.primaryBlue} flashing={partial === true && isStreaming}>
-					<Text bold color={COLORS.primaryBlue}>
-						Cline wants to create a Github issue:
-					</Text>
-				</DotRow>
-				<Box flexDirection="column" paddingLeft={2}>
-					<Text color="gray">{text}</Text>
-				</Box>
-			</Box>
-		)
-	}
-
 	// Skip other message types
 	return null
 }

cli/src/components/ConfigView.tsx

@@ -1,6 +1,6 @@
 /**
  * Interactive config view component for displaying and editing configuration values
- * Supports tabs for Settings, Rules, Workflows, Hooks, and Skills
+ * Supports tabs for Settings, Rules, legacy Workflows, Hooks, and Skills
  */
 
 import {
@@ -515,7 +515,10 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 				if (workflowEntries.length === 0) {
 					return (
 						<Box>
-							<Text color="gray">No workflows configured. Add workflow files to enable this feature.</Text>
+							<Text color="gray">
+								No legacy workflows configured. Add workflow files only if you still need `/file.md`
+								compatibility.
+							</Text>
 						</Box>
 					)
 				}
@@ -531,7 +534,11 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 								<React.Fragment key={`${entry.source}-${entry.path}`}>
 									{showHeader && (
 										<SectionHeader
-											title={entry.source === "global" ? "Global Workflows:" : "Workspace Workflows:"}
+											title={
+												entry.source === "global"
+													? "Global Legacy Workflows:"
+													: "Workspace Legacy Workflows:"
+											}
 										/>
 									)}
 									<ToggleRow entry={entry} isSelected={actualIndex === selectedIndex} />

cli/src/components/ConfigViewComponents.tsx

@@ -71,7 +71,7 @@ export const SEPARATOR = "─".repeat(80)
 export const TABS: { key: TabView; label: string; requiresFlag?: "hooks" | "skills" }[] = [
 	{ key: "settings", label: "Settings" },
 	{ key: "rules", label: "Rules" },
-	{ key: "workflows", label: "Workflows" },
+	{ key: "workflows", label: "Legacy Workflows" },
 	{ key: "hooks", label: "Hooks", requiresFlag: "hooks" },
 	{ key: "skills", label: "Skills", requiresFlag: "skills" },
 ]

cli/src/components/FeatureTip.tsx

@@ -46,7 +46,7 @@ const FEATURE_TIPS: FeatureTipItem[] = [
 		text: "Cline can browse websites — ask it to test your local dev server in the browser.",
 	},
 	{
-		text: "Use /reportbug to quickly file a GitHub issue with diagnostic context included.",
+		text: "Use /newtask to start a fresh task while keeping the important context from your current conversation.",
 	},
 	{
 		text: "Try 'npm i -g cline' to manage tasks on a Kankan board — orchestrate coding agents across worktrees.",

cli/src/components/FocusChain.tsx

@@ -3,7 +3,7 @@
  * Displays a progress-tracked checklist of tasks
  */
 
-import { isCompletedFocusChainItem, isFocusChainItem, parseFocusChainItem } from "@shared/focus-chain-utils"
+import { isChecklistItem, isCompletedChecklistItem, parseChecklistItem } from "@shared/checklist-utils"
 import { Box, Text } from "ink"
 import React, { useMemo } from "react"
 
@@ -41,8 +41,8 @@ function parseCurrentTodoInfo(text: string): TodoInfo | null {
 	const lines = text.split("\n")
 	for (const rawLine of lines) {
 		const line = rawLine.trim()
-		if (isFocusChainItem(line)) {
-			const isCompleted = isCompletedFocusChainItem(line)
+		if (isChecklistItem(line)) {
+			const isCompleted = isCompletedChecklistItem(line)
 
 			if (isCompleted) {
 				completedCount++
@@ -80,7 +80,7 @@ function parseTodoItems(text: string): TodoItem[] {
 
 	for (const rawLine of lines) {
 		const line = rawLine.trim()
-		const parsed = parseFocusChainItem(line)
+		const parsed = parseChecklistItem(line)
 		if (parsed) {
 			items.push(parsed)
 		}
@@ -115,7 +115,7 @@ const Header: React.FC<{
 	const isCompleted = completedCount === totalCount
 
 	const displayText = isCompleted ? "All tasks completed!" : currentTodo?.text || "To-Do list"
-	const truncatedText = displayText.length > 50 ? displayText.substring(0, 47) + "..." : displayText
+	const truncatedText = displayText.length > 50 ? `${displayText.substring(0, 47)}...` : displayText
 
 	return (
 		<Box flexDirection="row" gap={1}>
@@ -136,8 +136,8 @@ const ExpandedList: React.FC<{
 }> = ({ items, isCompleted }) => {
 	return (
 		<Box flexDirection="column" marginLeft={2} marginTop={1}>
-			{items.map((item, index) => (
-				<Box key={index}>
+			{items.map((item) => (
+				<Box key={`${item.text}-${item.checked ? "done" : "todo"}`}>
 					<Text color={item.checked ? "green" : "gray"}>{item.checked ? "✓" : "○"} </Text>
 					<Text color={item.checked ? "green" : undefined} dimColor={item.checked}>
 						{item.text}

cli/src/components/KanbanMigrationView.test.tsx

@@ -8,11 +8,11 @@ describe("KanbanMigrationView", () => {
 		const onSelect = vi.fn()
 		const { lastFrame } = render(createElement(KanbanMigrationView, { isRawModeSupported: true, onSelect }))
 
-		expect(lastFrame()).toContain("Cline is moving out of the terminal. Introducing Cline Kanban.")
+		expect(lastFrame()).toContain("Introducing Cline Kanban!")
 		expect(lastFrame()).toContain("Open the new experience")
 		expect(lastFrame()).toContain("Launch Cline Kanban and start there by default.")
 		expect(lastFrame()).toContain("cline --tui")
-		expect(lastFrame()).toContain("Close and rerun with cline --tui if you want the old CLI.")
+		expect(lastFrame()).toContain("You can always run cline --tui for the terminal experience.")
 		expect(lastFrame()).toContain("Exit")
 	})
 

cli/src/components/KanbanMigrationView.tsx

@@ -30,7 +30,7 @@ const InternalKanbanMigrationView: React.FC<Pick<KanbanMigrationViewProps, "onSe
 			},
 			{
 				label: "Exit",
-				description: "Close and rerun with cline --tui if you want the old CLI.",
+				description: "You can always run cline --tui for the terminal experience.",
 				value: "exit",
 			},
 		],
@@ -60,7 +60,7 @@ const InternalKanbanMigrationView: React.FC<Pick<KanbanMigrationViewProps, "onSe
 			<StaticRobotFrame />
 			<Text> </Text>
 			<Text bold color="white">
-				Cline is moving out of the terminal. Introducing Cline Kanban.
+				Introducing Cline Kanban!
 			</Text>
 			<Text color="gray">A board for orchestrating coding agents across worktrees, right from your browser.</Text>
 			<Text> </Text>

cli/src/index.test.ts

@@ -99,6 +99,12 @@ describe("CLI Commands", () => {
 			.description("Run kanban")
 			.action(() => {})
 
+		program
+			.command("update")
+			.description("Check for updates and install if available")
+			.option("-v, --verbose", "Show verbose output")
+			.action(() => {})
+
 		// Default command for interactive mode
 		program
 			.argument("[prompt]", "Task prompt")
@@ -113,6 +119,7 @@ describe("CLI Commands", () => {
 			.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
 			.option("--hooks-dir <path>", "Additional hooks directory")
 			.option("--auto-approve-all", "Enable auto-approve all")
+			.option("--update", "Check for updates and install if available")
 			.option("--kanban", "Run kanban")
 			.option("--tui", "Open the legacy terminal UI instead of the kanban experience")
 			.action(() => {})
@@ -315,6 +322,20 @@ describe("CLI Commands", () => {
 		})
 	})
 
+	describe("update command", () => {
+		it("should parse update command", () => {
+			const args = ["node", "cli", "update"]
+			program.parse(args)
+		})
+
+		it("should parse --verbose on update command", () => {
+			const updateCmd = getCommand("update")
+			const args = ["--verbose"]
+			updateCmd.parse(args, { from: "user" })
+			expect(updateCmd.opts().verbose).toBe(true)
+		})
+	})
+
 	describe("auth command", () => {
 		it("should parse auth command", () => {
 			const args = ["node", "cli", "auth"]
@@ -439,6 +460,11 @@ describe("CLI Commands", () => {
 			expect(program.opts().kanban).toBe(true)
 		})
 
+		it("should parse --update flag", () => {
+			program.parse(["node", "cli", "--update"])
+			expect(program.opts().update).toBe(true)
+		})
+
 		it("should parse --tui flag", () => {
 			program.parse(["node", "cli", "--tui"])
 			expect(program.opts().tui).toBe(true)
@@ -454,6 +480,7 @@ describe("CLI Commands", () => {
 			expect(commandNames).toContain("auth")
 			expect(commandNames).toContain("mcp")
 			expect(commandNames).toContain("kanban")
+			expect(commandNames).toContain("update")
 		})
 
 		it("should have correct aliases", () => {

cli/src/index.ts

@@ -1027,7 +1027,7 @@ program
 	.command("update")
 	.description("Check for updates and install if available")
 	.option("-v, --verbose", "Show verbose output")
-	.action(() => checkForUpdates(CLI_VERSION))
+	.action((options) => checkForUpdates(CLI_VERSION, { verbose: options.verbose, includeKanban: true }))
 
 program
 	.command("kanban")
@@ -1183,6 +1183,7 @@ program
 	.option("--auto-condense", "Enable AI-powered context compaction instead of mechanical truncation")
 	.option("--hooks-dir <path>", "Path to additional hooks directory for runtime hook injection")
 	.option("--acp", "Run in ACP (Agent Client Protocol) mode for editor integration")
+	.option("--update", "Check for updates and install if available")
 	.option("--kanban", `Run ${KANBAN_LAUNCH_COMMAND}`)
 	.option("--tui", "Open the legacy terminal UI instead of the kanban experience")
 	.option("-T, --taskId <id>", "Resume an existing task by ID")
@@ -1193,6 +1194,16 @@ program
 			exit(1)
 		}
 
+		if (options.update) {
+			if (prompt || options.taskId || options.continue || options.kanban || options.tui || options.acp) {
+				printWarning("Use --update without a prompt or task flags.")
+				exit(1)
+			}
+
+			await checkForUpdates(CLI_VERSION, { verbose: options.verbose, includeKanban: true })
+			return
+		}
+
 		if (options.kanban) {
 			if (prompt) {
 				printWarning("Use --kanban without a prompt.")

cli/src/utils/update.ts

@@ -1,9 +1,10 @@
-import { spawn } from "node:child_process"
+import { type ChildProcess, spawn, spawnSync } from "node:child_process"
 import { realpathSync } from "node:fs"
 import { exit } from "node:process"
 import { ClineEndpoint } from "@/config"
 import { fetch } from "@/shared/net"
-import { printInfo, printWarning } from "./display"
+import { printInfo, printSuccess, printWarning } from "./display"
+import { resolveKanbanInstallCommand, spawnKanbanInstallProcess } from "./kanban"
 
 export enum PackageManager {
 	NPM = "npm",
@@ -19,6 +20,11 @@ interface InstallationInfo {
 	updateCommand?: string
 }
 
+interface CheckForUpdatesOptions {
+	verbose?: boolean
+	includeKanban?: boolean
+}
+
 /**
  * Check if a version string is a nightly build.
  */
@@ -91,9 +97,12 @@ function getInstallationInfo(currentVersion: string): InstallationInfo {
  * Uses the appropriate tag based on whether the current version is nightly.
  */
 async function getLatestVersion(currentVersion: string): Promise<string | null> {
+	return getLatestPackageVersion("cline", getNpmTag(currentVersion))
+}
+
+async function getLatestPackageVersion(packageName: string, tag = "latest"): Promise<string | null> {
 	try {
-		const tag = getNpmTag(currentVersion)
-		const response = await fetch(`https://registry.npmjs.org/cline/${tag}`)
+		const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/${tag}`)
 		if (!response.ok) return null
 		const data = (await response.json()) as { version: string }
 		return data.version || null
@@ -102,6 +111,29 @@ async function getLatestVersion(currentVersion: string): Promise<string | null>
 	}
 }
 
+async function getLatestKanbanVersion(): Promise<string | null> {
+	return getLatestPackageVersion("kanban")
+}
+
+function getInstalledKanbanVersion(): string | null {
+	try {
+		const command = process.platform === "win32" ? "kanban.cmd" : "kanban"
+		const result = spawnSync(command, ["--version"], {
+			encoding: "utf8",
+			shell: process.platform === "win32",
+		})
+		if (result.status !== 0) {
+			return null
+		}
+
+		const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim()
+		const versionMatch = output.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/)
+		return versionMatch?.[0] ?? null
+	} catch {
+		return null
+	}
+}
+
 /**
  * Auto-update check that runs on CLI startup.
  * Checks for updates asynchronously (non-blocking), then spawns a detached
@@ -157,85 +189,181 @@ async function checkAndUpdate(currentVersion: string, updateCommand: string): Pr
 	}
 }
 
+async function waitForProcessExit(updateProcess: ChildProcess): Promise<number> {
+	return new Promise<number>((resolve, reject) => {
+		updateProcess.once("close", (code) => {
+			resolve(code ?? 1)
+		})
+
+		updateProcess.once("error", (error) => {
+			reject(error)
+		})
+	})
+}
+
+async function runClineUpdate(updateCommand: string): Promise<number> {
+	const updateProcess = spawn(updateCommand, {
+		stdio: "inherit",
+		shell: true,
+		env: process.env,
+		windowsHide: true,
+	})
+
+	return waitForProcessExit(updateProcess)
+}
+
+type KanbanInstallCommand = NonNullable<ReturnType<typeof resolveKanbanInstallCommand>>
+
+async function runKanbanUpdate(installCommand: KanbanInstallCommand): Promise<number> {
+	const updateProcess = spawnKanbanInstallProcess(installCommand, {
+		env: process.env,
+		windowsHide: true,
+	})
+	return waitForProcessExit(updateProcess)
+}
+
+function formatUpdateSummaryTargets(targets: string[]): string {
+	if (targets.length === 0) {
+		return ""
+	}
+	if (targets.length === 1) {
+		return targets[0]
+	}
+	if (targets.length === 2) {
+		return `${targets[0]} and ${targets[1]}`
+	}
+	return `${targets.slice(0, -1).join(", ")}, and ${targets.at(-1)}`
+}
+
 /**
  * Check for updates and install if available (manual command)
  */
-export async function checkForUpdates(currentVersion: string, options?: { verbose?: boolean }) {
-	printInfo("Checking for updates...")
+export async function checkForUpdates(currentVersion: string, options: CheckForUpdatesOptions = {}) {
+	const includeKanban = options.includeKanban ?? true
+
+	printInfo("Checking for updates to cline and kanban packages...")
 
 	const { updateCommand, packageManager } = getInstallationInfo(currentVersion)
 
 	try {
-		const latestVersion = await getLatestVersion(currentVersion)
-		if (!latestVersion) {
-			printWarning("Failed to check for updates: could not fetch latest version")
-			exit(1)
-		}
+		const latestClineVersion = await getLatestVersion(currentVersion)
+		const canCheckClineVersion = latestClineVersion !== null
 
 		if (options?.verbose) {
 			printInfo(`Current version: ${currentVersion}`)
-			printInfo(`Latest version: ${latestVersion}`)
 			printInfo(`Package manager: ${packageManager}`)
-		}
-
-		// Compare versions
-		if (latestVersion === currentVersion) {
-			printInfo(`You are already on the latest version (${currentVersion})`)
-			exit(0)
-		}
-
-		// Check if current is newer (dev version)
-		if (compareVersions(currentVersion, latestVersion) > 0) {
-			printInfo(`You are already on a newer version ${currentVersion} (latest: ${latestVersion})`)
-			exit(0)
-		}
-
-		printInfo(`New version available: ${latestVersion} (current: ${currentVersion})`)
-
-		if (!updateCommand) {
-			printInfo("Unable to determine update command for your installation.")
-			printInfo("Please update manually using your package manager.")
-			exit(0)
-		}
-
-		// Ask user to confirm update
-		const userConfirmed = new Promise<boolean>((resolve) => {
-			process.stdout.write("Do you want to update now? (y/N): ")
-			process.stdin.setEncoding("utf-8")
-			process.stdin.once("data", (dataBuff) => {
-				const input = dataBuff.toString().trim().toLowerCase()
-				resolve(input === "y" || input === "yes")
-			})
-		})
-
-		if (!(await userConfirmed)) {
-			exit(0)
-		}
-
-		printInfo(`Installing update via ${packageManager}...`)
-
-		const updateProcess = spawn(updateCommand, {
-			stdio: "inherit",
-			shell: true,
-			env: process.env,
-			windowsHide: true,
-		})
-
-		updateProcess.on("close", (code) => {
-			if (code === 0) {
-				printInfo(`Successfully updated to version ${latestVersion}`)
-				exit(0)
-			} else {
-				printWarning(`Update failed. Please try running: ${updateCommand}`)
-				exit(1)
+			if (canCheckClineVersion) {
+				printInfo(`Latest version: ${latestClineVersion}`)
 			}
-		})
+		}
 
-		updateProcess.on("error", (err) => {
-			printWarning(`Failed to run update: ${err.message}`)
-			printInfo(`Please try running manually: ${updateCommand}`)
+		if (!canCheckClineVersion) {
+			printWarning("Failed to check for Cline updates: could not fetch latest version")
+		}
+
+		const clineComparison = latestClineVersion ? compareVersions(currentVersion, latestClineVersion) : null
+		const clineUpdateAvailable = clineComparison !== null && clineComparison < 0
+		const clineIsUpToDate = clineComparison !== null && clineComparison === 0
+		const canUpdateCline = clineUpdateAvailable && Boolean(updateCommand)
+
+		if (clineUpdateAvailable && latestClineVersion) {
+			printInfo(`New version available: ${latestClineVersion} (current: ${currentVersion})`)
+		}
+
+		if (clineUpdateAvailable && !updateCommand) {
+			printInfo("Unable to determine Cline update command for your installation.")
+			printInfo("Please update Cline manually using your package manager.")
+		}
+
+		const kanbanInstallCommand = includeKanban ? resolveKanbanInstallCommand() : null
+		const kanbanInstallerAvailable = kanbanInstallCommand !== null
+		if (includeKanban && !kanbanInstallerAvailable && options.verbose) {
+			printWarning("Unable to determine Kanban update command (npm, pnpm, or bun not found in PATH).")
+		}
+		const latestKanbanVersion = kanbanInstallerAvailable ? await getLatestKanbanVersion() : null
+		const installedKanbanVersion = includeKanban ? getInstalledKanbanVersion() : null
+		const kanbanIsUpToDate =
+			latestKanbanVersion !== null &&
+			installedKanbanVersion !== null &&
+			compareVersions(installedKanbanVersion, latestKanbanVersion) >= 0
+		const shouldInstallKanban =
+			kanbanInstallerAvailable &&
+			latestKanbanVersion !== null &&
+			(installedKanbanVersion === null || compareVersions(installedKanbanVersion, latestKanbanVersion) < 0)
+
+		if (!canCheckClineVersion && !shouldInstallKanban) {
 			exit(1)
-		})
+		}
+
+		if (!canUpdateCline && !shouldInstallKanban) {
+			if (clineIsUpToDate && kanbanIsUpToDate && installedKanbanVersion) {
+				printInfo(`You are already on the latest version cline@${currentVersion} and kanban@${installedKanbanVersion}`)
+			} else if (clineIsUpToDate) {
+				printInfo(`You are already on the latest version cline@${currentVersion}`)
+			}
+			exit(0)
+		}
+
+		let hadFailure = false
+		const installedUpdates: string[] = []
+
+		if (canUpdateCline && updateCommand && latestClineVersion) {
+			printInfo(`Installing cline@${latestClineVersion}...`)
+			try {
+				const clineUpdateCode = await runClineUpdate(updateCommand)
+				if (clineUpdateCode === 0) {
+					installedUpdates.push(`cline@${latestClineVersion}`)
+				} else {
+					printWarning(`Cline update failed. Please try running: ${updateCommand}`)
+					hadFailure = true
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				printWarning(`Failed to run Cline update: ${message}`)
+				printInfo(`Please try running manually: ${updateCommand}`)
+				hadFailure = true
+			}
+		}
+
+		if (shouldInstallKanban && kanbanInstallCommand && latestKanbanVersion) {
+			const kanbanTargetVersion = latestKanbanVersion ?? "latest"
+			printInfo(`Installing kanban@${kanbanTargetVersion}...`)
+			try {
+				const kanbanUpdateCode = await runKanbanUpdate(kanbanInstallCommand)
+				if (kanbanUpdateCode === 0) {
+					installedUpdates.push(`kanban@${kanbanTargetVersion}`)
+				} else {
+					printWarning(`Kanban update failed. Please try running: ${kanbanInstallCommand.displayCommand}`)
+					hadFailure = true
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				printWarning(`Failed to run Kanban update: ${message}`)
+				if (kanbanInstallCommand) {
+					printInfo(`Please try running manually: ${kanbanInstallCommand.displayCommand}`)
+				}
+				hadFailure = true
+			}
+		}
+
+		if (!hadFailure) {
+			if (installedUpdates.length > 1) {
+				printSuccess(`Installed updates for ${formatUpdateSummaryTargets(installedUpdates)}`)
+			} else if (installedUpdates.length === 1) {
+				printSuccess(`Installed update for ${installedUpdates[0]}`)
+			} else {
+				printInfo("No updates were installed.")
+			}
+		}
+
+		if (hadFailure) {
+			exit(1)
+		}
+
+		if (canUpdateCline || shouldInstallKanban) {
+			exit(0)
+		}
+		exit(1)
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error)
 		printWarning(`Error checking for updates: ${message}`)
@@ -259,7 +387,7 @@ function parseVersion(version: string): ParsedVersion {
 		return {
 			base: nightlyMatch[1].split(".").map(Number),
 			isNightly: true,
-			timestamp: parseInt(nightlyMatch[2], 10),
+			timestamp: Number.parseInt(nightlyMatch[2], 10),
 		}
 	}
 	return {

docs/cline-cli/configuration.mdx

@@ -38,11 +38,13 @@ Rules help Cline understand your project's conventions, coding standards, and pr
 
 ### Workflows Tab
 
-View and manage [workflows](/customization/workflows):
+View and manage [legacy workflows](/customization/workflows):
 
-- List available workflows
+- List available workflow files
 - View workflow definitions
-- Workflows appear as slash commands in interactive mode
+- Workflow files still appear as slash commands in interactive mode
+
+For new reusable capabilities, prefer [skills](/customization/skills). The Workflows tab exists to support older `/file.md` automations while they are being migrated.
 
 ### Hooks Tab
 

docs/cline-cli/installation.mdx

@@ -269,7 +269,7 @@ rm -rf ~/.cline
   </Card>
   
   <Card title="Configuration" icon="gear" href="/cline-cli/configuration">
-    Configure settings, rules, workflows, and environment variables.
+    Configure settings, rules, skills, legacy workflows, and environment variables.
   </Card>
   
   <Card title="CLI Reference" icon="book" href="/cline-cli/cli-reference">

docs/contributing/documentation-guide.mdx

@@ -39,12 +39,12 @@ Abstract descriptions don't help anyone. Show actual code, real file paths, and
 
 ```markdown
 # Good
-I use `/deep-planning` whenever I'm building features that touch multiple 
+I start in Plan mode whenever I'm building features that touch multiple 
 parts of the codebase. For example, when adding authentication, Cline 
-mapped every endpoint and created a migration plan that avoided breaking changes.
+mapped every endpoint and wrote an implementation plan that avoided breaking changes.
 
 # Bad
-The deep planning feature can be utilized for various complex tasks 
+Plan mode can be utilized for various complex tasks 
 that may require careful consideration and planning.
 ```
 
@@ -194,7 +194,7 @@ Open `http://localhost:3000` to see your changes in real time.
   <Card title="Documentation Templates" icon="file-lines" href="/contributing/doc-templates">
     Templates for different documentation types.
   </Card>
-  <Card title="Workflows" icon="diagram-project" href="/customization/workflows">
-    Learn about Cline's workflow system.
+  <Card title="Legacy Workflows" icon="diagram-project" href="/customization/workflows">
+    Learn about Cline's legacy workflow compatibility path.
   </Card>
 </CardGroup>

docs/core-workflows/checkpoints.mdx

@@ -1,20 +1,20 @@
 ---
 title: "Checkpoints"
 sidebarTitle: "Checkpoints"
-description: "Roll back code changes while keeping your conversation. Experiment freely."
+description: "Restore recent task changes while keeping your conversation context."
 ---
 
-Checkpoints let you undo code changes without losing your conversation. Every time Cline modifies a file or runs a command, it saves a snapshot of your project files. You can restore to any checkpoint, keeping the context you've built while reverting the code.
+Checkpoints let you undo code changes without losing your conversation. When checkpoints are enabled, Cline saves internal restore points for your project files so you can compare and roll back recent task changes while preserving the context you've built.
 
-This changes how you work with Cline. Instead of carefully reviewing every change before approving, you can let Cline move fast and roll back if something goes wrong. The cost of a mistake drops to nearly zero.
+This changes how you work with Cline. Instead of carefully reviewing every change before approving, you can let Cline move faster and roll back if something goes wrong.
 
 <Tip>
-Checkpoints are enabled by default. See [Enable or Disable Checkpoints](#enable-or-disable-checkpoints) if you need to turn them off.
+Checkpoints are available in the current product while the existing rollback system remains enabled. See [Enable or Disable Checkpoints](#enable-or-disable-checkpoints) if you need to turn them off.
 </Tip>
 
 ## How It Works
 
-Cline maintains a shadow Git repository separate from your project's actual Git history. After each tool use (file edits, commands, etc.), Cline commits the current state of your files to this shadow repo. Your main Git repository stays untouched.
+Cline currently powers checkpoints with internal Git-backed snapshots that stay separate from your project's visible Git history. After each tool use (file edits, commands, etc.), Cline records the current file state so the UI can offer compare and restore actions without rewriting your normal Git commits.
 
 This means:
 
@@ -23,6 +23,10 @@ This means:
 - You can restore to any point in a task without affecting commits you've made
 - Checkpoints persist across editor sessions
 
+<Note>
+The current checkpoint implementation is a compatibility layer during an active migration. The compare/restore experience remains the user-facing contract, but the underlying storage mechanism may evolve.
+</Note>
+
 Each checkpoint captures the complete file state at that moment. If Cline edits three files in sequence, you get three checkpoints and can restore to any of them independently.
 
 ## Enable or Disable Checkpoints

docs/core-workflows/plan-and-act.mdx

@@ -80,16 +80,16 @@ When enabled, switching between Plan and Act mode automatically switches to the
 | Maximum quality | Claude Opus | Claude Sonnet |
 | Speed-focused | Gemini 3 Flash | Cerebras |
 
-## Using `/deep-planning`
+## Planning larger tasks
 
-For complex tasks that need thorough analysis, use the `/deep-planning` slash command. This triggers an extended planning session where Cline:
+For complex tasks that need thorough analysis, stay in Plan mode long enough to do real investigation before switching back to Act mode. A solid planning pass usually includes:
 
-1. Explores the codebase systematically
-2. Identifies all affected files and dependencies
-3. Creates a detailed implementation plan
-4. Asks clarifying questions before proceeding
+1. Exploring the codebase systematically
+2. Identifying affected files, dependencies, and risks
+3. Writing down a detailed implementation plan
+4. Capturing a todo list you can work through in Act mode
 
-The deep planning prompt is optimized for each model family, so it adapts to the strengths of whatever model you're using. See the [Deep Planning docs](/features/deep-planning) for more details.
+For especially large changes, ask Cline to write the plan to a markdown file so you can keep it with the project and reuse it across sessions.
 
 ## Choosing the Right Approach by Task Size
 
@@ -105,9 +105,9 @@ For most development work, start in Plan mode to understand the scope and approa
 
 **Examples:** Add a new API endpoint, implement a UI component, fix a bug that requires investigation, refactor a single module.
 
-### Large tasks: Use `/deep-planning`
+### Large tasks: spend more time in Plan mode
 
-For complex features that span multiple files, require architectural decisions, or will take multiple sessions to complete, use the `/deep-planning` slash command. This creates a detailed implementation plan that Cline can reference throughout the work.
+For complex features that span multiple files, require architectural decisions, or will take multiple sessions to complete, use Plan mode to build a detailed implementation plan that Cline can reference throughout the work.
 
 **Examples:** Add a new feature across frontend and backend, major refactoring across the codebase, implementing a new system or integration, multi-step migrations.
 

docs/core-workflows/task-management.mdx

@@ -17,7 +17,7 @@ Each task:
 - Contains the full conversation history
 - Tracks token usage, API costs, and execution time
 - Can be interrupted and resumed across sessions
-- Creates [checkpoints](/core-workflows/checkpoints) for file changes through Git-based snapshots
+- Can create [checkpoints](/core-workflows/checkpoints) for file changes through the current internal snapshot system
 
 <Tip>
 Want to get better results from Cline? Learn how to write effective prompts in our [Prompt Module](https://cline.bot/learn).

docs/core-workflows/using-commands.mdx

@@ -1,10 +1,10 @@
 ---
 title: "Using Commands"
 sidebarTitle: "Using Commands"
-description: "Built-in slash commands to manage context, plan implementations, and create reusable workflows."
+description: "Built-in slash commands to manage context and keep work moving."
 ---
 
-Cline provides slash commands in chat that help you manage your conversation and plan complex implementations.
+Cline provides slash commands in chat that help you manage your conversation and keep momentum while you work.
 
 <Tip>
 **New to slash commands?** Watch our [quick video walkthrough](https://youtu.be/MxS5Jerpf-o) to see these commands in action.
@@ -19,9 +19,7 @@ Type `/` in the chat input to see available slash commands:
 | `/newtask` | Start fresh task with distilled context from current conversation |
 | `/smol` | Compress conversation history while preserving essential context |
 | `/newrule` | Create a rule file to teach Cline your preferences |
-| `/deep-planning` | Investigate codebase, plan thoroughly, then create implementation task |
 | `/explain-changes` | Generate AI explanations for any git diff (VS Code only) |
-| `/reportbug` | Report a bug with diagnostic info |
 
 ### /newtask
 
@@ -41,16 +39,7 @@ Use `/smol` when you're deep into a debugging session or brainstorming and need
 
 Use `/newrule` when you find yourself repeating the same instructions across tasks. For more about rules, see [Cline Rules](/customization/cline-rules).
 
-### /deep-planning
-
-Transform Cline into a meticulous architect who investigates your codebase, asks clarifying questions, and creates a comprehensive implementation plan before writing any code. Deep planning follows a four-step process:
-
-1. **Silent Investigation** - Cline explores your codebase structure and patterns
-2. **Discussion** - Targeted questions about requirements and approach
-3. **Plan Creation** - Generates `implementation_plan.md` with detailed specifications
-4. **Task Creation** - Creates a new task with trackable implementation steps
-
-Use `/deep-planning` for features touching multiple parts of your codebase, architectural changes, or complex integrations. For detailed documentation, see [Deep Planning](/features/deep-planning).
+For larger tasks, switch to [Plan & Act mode](/core-workflows/plan-and-act) and ask Cline to investigate the codebase, write down an implementation plan, and capture a todo list before you return to Act mode.
 
 ### /explain-changes
 
@@ -62,14 +51,8 @@ This command is only available in VS Code.
 
 Use `/explain-changes` when reviewing code, onboarding to a new codebase, or understanding what changed. For the full list of use cases and examples, see [Explain Changes Command](#explain-changes).
 
-### /reportbug
-
-`/reportbug` collects diagnostic information and helps you report issues with Cline. It gathers relevant context like your configuration, recent errors, and system details to make bug reports more useful for the development team.
-
-Use `/reportbug` when you encounter unexpected behavior, crashes, or bugs you want to report.
-
 ## Custom Workflows
 
-Beyond the built-in slash commands, you can create your own workflow files that work the same way. Store Markdown files in `.clinerules/workflows/` and invoke them with `/your-workflow.md`.
+Beyond the built-in slash commands, Cline still supports legacy workflow files that can be invoked as `/your-workflow.md`. Use this compatibility path only when you specifically need file-based slash commands; for new reusable guidance, prefer [Skills](/customization/skills).
 
-For a complete guide on creating and managing custom workflows, see [Workflows](/customization/workflows).
+For migration guidance and the remaining compatibility behavior, see [Legacy Workflows](/customization/workflows).

docs/customization/clineignore.mdx

@@ -107,4 +107,4 @@ You can still reference ignored files explicitly using [@ mentions](/core-workfl
 - [Cline Rules](/customization/cline-rules) - Define persistent instructions for Cline
 - [Task Management](/core-workflows/task-management#context-window) - Understand how context windows work
 - [Auto-Compact](/features/auto-compact) - Automatic context compression during long tasks
-- [Memory Bank](/features/memory-bank) - Structured documentation for cross-session context
+- [Plan & Act Mode](/core-workflows/plan-and-act) - Built-in planning and task execution workflow

docs/customization/overview.mdx

@@ -1,12 +1,12 @@
 ---
 title: "Overview"
 sidebarTitle: "Overview"
-description: "Understand how Rules, Skills, Workflows, Hooks, and .clineignore work together to customize Cline."
+description: "Understand how Rules, Skills, legacy Workflows, Hooks, and .clineignore fit together in Cline customization."
 ---
 
-Out of the box, Cline is a general-purpose AI assistant. Customizations transform it into an expert on your codebase, your team's conventions, and your workflows. Instead of repeating the same instructions every task, you define them once and Cline follows them automatically.
+Out of the box, Cline is a general-purpose AI assistant. Customizations transform it into an expert on your codebase, your team's conventions, and your recurring processes. Instead of repeating the same instructions every task, you define them once and Cline follows them automatically.
 
-Cline offers five systems for this: Rules, Skills, Workflows, Hooks, and .clineignore. Each serves a different purpose and activates at different times.
+Cline offers four primary systems plus a legacy compatibility path: Rules, Skills, Hooks, `.clineignore`, and legacy Workflows. Each serves a different purpose and activates at different times.
 
 ## Quick Comparison
 
@@ -14,7 +14,7 @@ Cline offers five systems for this: Rules, Skills, Workflows, Hooks, and .clinei
 |---------|---------|-------------|----------|
 | **[Rules](/customization/cline-rules)** | Define how Cline behaves | Always (or contextually) | Coding standards, project constraints, team conventions |
 | **[Skills](/customization/skills)** | Domain expertise loaded on-demand | Triggered by matching requests | Specialized knowledge, complex procedures, institutional expertise |
-| **[Workflows](/customization/workflows)** | Step-by-step task automation | Invoked with `/workflow.md` | Repetitive processes, release procedures, setup scripts |
+| **[Legacy Workflows](/customization/workflows)** | File-based slash-command compatibility | Invoked with `/workflow.md` | Existing `/file.md` automations you still need while migrating to skills |
 | **[Hooks](/customization/hooks)** | Inject custom logic at key moments | Automatically on specific events | Validation, enforcement, monitoring, automation triggers |
 | **[.clineignore](/customization/clineignore)** | Control file access | Always | Excluding dependencies, build artifacts, large data files |
 
@@ -24,7 +24,7 @@ Cline offers five systems for this: Rules, Skills, Workflows, Hooks, and .clinei
 
 **[Skills](/customization/skills)** are domain expertise that loads only when relevant. Use them when you have extensive knowledge that would waste context if always active. Cline sees skill descriptions at startup and activates the full instructions only when your request matches. A data analysis skill might include pandas patterns, visualization preferences, and output formats that Cline only loads when you're working with data files.
 
-**[Workflows](/customization/workflows)** are explicit task scripts you invoke on demand. Use them when you have a repeatable multi-step process that should run the same way every time. Type `/release.md` and Cline executes your release sequence: bump version, run tests, update changelog, commit, tag, push. Workflows define *what* to do, step by step.
+**[Legacy Workflows](/customization/workflows)** are explicit task scripts you invoke on demand. They remain useful when you already depend on a repeatable `/file.md` flow and need backward compatibility, but they are no longer the preferred direction for new reusable behavior. For new work, reach for [Skills](/customization/skills) first.
 
 **[Hooks](/customization/hooks)** are programmatic guardrails that run automatically at key moments. Use them when you need to validate, enforce, or extend Cline's behavior with custom code. A hook might block `.js` file creation in a TypeScript project, run linters before saves, or notify external services after deployments.
 
@@ -36,7 +36,7 @@ Consider how all five work together for releasing a new version:
 
 1. **Rules** ensure Cline follows your team's commit message format and versioning policy
 2. **Skills** offer deep knowledge about your CI/CD system that Cline loads when deployment questions arise
-3. **Workflows** provide the explicit `/release.md` sequence: bump version, update changelog, tag, push
+3. **Legacy workflows** can still provide the explicit `/release.md` sequence while you migrate that automation toward skills
 4. **Hooks** validate that tests pass before allowing any commit or that the changelog was actually updated
 5. **.clineignore** keeps build artifacts, `node_modules/`, and generated files out of Cline's context so it stays focused
 
@@ -48,13 +48,13 @@ All five systems support both global and project-specific configurations:
 |--------|-----------------|------------------|
 | Rules | `~/Documents/Cline/Rules/` | `.clinerules/` |
 | Skills | `~/.cline/skills/` | `.cline/skills/` |
-| Workflows | `~/Documents/Cline/Workflows/` | `.clinerules/workflows/` |
+| Legacy Workflows | `~/Documents/Cline/Workflows/` | `.clinerules/workflows/` |
 | Hooks | `~/Documents/Cline/Hooks/` | `.clinerules/hooks/` |
 | .clineignore | N/A | `.clineignore` |
 
 ### When to Use Each
 
-**Start with project storage.** Most customizations belong in your project's directory because they're tied to that specific codebase. Team coding standards, deployment workflows, and architectural constraints all live with the code they describe. This also means your customizations travel with the repository, so collaborators get them automatically and changes can be reviewed in pull requests.
+**Start with project storage.** Most customizations belong in your project's directory because they're tied to that specific codebase. Team coding standards, deployment skills, legacy workflows, and architectural constraints all live with the code they describe. This also means your customizations travel with the repository, so collaborators get them automatically and changes can be reviewed in pull requests.
 
 **Use global storage for personal preferences.** If you find yourself adding the same customization to every project, move it to global storage. Your preferred communication style, personal productivity workflows, and tools you use everywhere belong here. Global customizations apply to all projects but stay out of version control, so they won't affect your teammates.
 

docs/customization/workflows.mdx

@@ -1,10 +1,14 @@
 ---
-title: "Workflows"
-sidebarTitle: "Workflows"
-description: "Automate repetitive tasks with Markdown-based workflow files."
+title: "Legacy Workflows"
+sidebarTitle: "Legacy Workflows"
+description: "Use Markdown workflow files only when you need legacy slash-command compatibility while migrating to skills."
 ---
 
-Workflows are Markdown files that define a series of steps to guide Cline through repetitive or complex tasks. Type `/` followed by the workflow's filename to invoke it (e.g., `/deploy.md`).
+Workflows are a legacy compatibility feature for file-based slash commands like `/deploy.md`. If you're starting fresh, use [Skills](/customization/skills) instead. Skills are the preferred product direction for reusable guidance because they load on demand, support bundled resources cleanly, and align with the rest of the SDK migration.
+
+<Warning>
+For new reusable automations, create a [skill](/customization/skills) instead of a workflow. Keep workflows only when you still rely on existing `/name.md` commands or need a compatibility bridge while migrating older setups.
+</Warning>
 
 Deploying, setting up a new project, running through a release checklist: these tasks often require remembering a dozen steps, running commands in the right order, and updating files manually. Mess up one step and you're debugging for an hour. Workflows turn those multi-step processes into one command. Type `/release.md` and Cline handles the version bump, runs tests, updates the changelog, commits, tags, and pushes. You just review and approve.
 
@@ -50,18 +54,18 @@ Steps can be written at different levels of detail:
 </Steps>
 
 <Tip>
-**Create workflows from completed tasks.** After finishing something you'll need to repeat, tell Cline: "Create a workflow for the process I just completed." Cline analyzes the conversation, identifies the steps, and generates the workflow file. Your accumulated context becomes reusable automation.
+**Prefer skills for new reusable guidance.** After finishing something you'll need to repeat, ask Cline whether it should become a skill or a legacy workflow. Choose a workflow only if you specifically want a `/file.md` command for backward compatibility.
 </Tip>
 
 ### Invoking Workflows
 
-Type `/` in the chat input to see available workflows. Cline shows autocomplete suggestions as you type, so `/rel` would match `release-prep.md`. Select a workflow and press Enter to start it.
+Type `/` in the chat input to see available legacy workflows. Cline shows autocomplete suggestions as you type, so `/rel` would match `release-prep.md`. Select a workflow and press Enter to start it.
 
 Cline executes each step in sequence, pausing for your approval when needed. You can stop a workflow at any point by rejecting a step.
 
 ### Toggling Workflows
 
-Every workflow has a toggle to enable or disable it. This lets you control which workflows appear in the `/` menu without deleting the file.
+Every workflow has a toggle to enable or disable it. This lets you control which legacy workflows appear in the `/` menu without deleting the file.
 
 ## Where Workflows Live
 
@@ -81,6 +85,16 @@ Workflows can be stored in two locations: your project workspace or globally on
 
 Workspace workflows take precedence when names match global workflows. See [Storage Locations](/customization/overview#storage-locations) for more guidance.
 
+## When Workflows Still Make Sense
+
+Use a workflow when all of the following are true:
+
+- you already have people depending on a file-based slash command,
+- the process is still easiest to express as a linear `/name.md` script,
+- and you are not ready to migrate that reusable guidance into a skill yet.
+
+If you mainly need reusable expertise, richer instructions, or bundled docs/scripts, use [Skills](/customization/skills) instead.
+
 ## What Workflows Can Use
 
 Workflows can combine natural language instructions with specific tool calls. This flexibility lets you write workflows that are as simple or as precise as your task requires.
@@ -157,13 +171,15 @@ Include the changelog as the release body.
 
 **Start simple.** Write natural language steps first. Only add XML tool calls when you need guaranteed behavior.
 
+**Prefer skills for new systems.** If the reusable logic is evolving into a broader capability rather than a single `/file.md` routine, move it into a skill instead of expanding the workflow indefinitely.
+
 **Be specific about decisions.** If a step requires user input, make that explicit: "Ask whether to deploy to production or staging."
 
 **Include failure handling.** Tell Cline what to do when something goes wrong: "If tests fail, show the failures and stop the workflow."
 
 **Keep workflows focused.** A `deploy.md` should deploy. A `setup-db.md` should set up the database. Split complex processes into multiple workflows that can be run independently.
 
-**Version control your workflows.** Store workflows in `.clinerules/workflows/` and commit them. Your team can share, review, and improve them together.
+**Version control your workflows.** Store workflows in `.clinerules/workflows/` and commit them. Your team can share, review, and improve them together while you migrate long-lived patterns toward skills.
 
 <Warning>
 Workflows execute with your permissions. Review workflows before running them, especially those from external sources.

docs/docs.json

@@ -123,15 +123,12 @@
 					{
 						"group": "Features",
 						"pages": [
-							"features/memory-bank",
-							"features/focus-chain",
 							"features/auto-approve",
 							"features/auto-compact",
 							"features/multiroot-workspace",
 							"features/subagents",
 							"features/background-edit",
 							"features/jupyter-notebooks",
-							"features/deep-planning",
 							"features/web-tools",
 							"features/worktrees"
 						]
@@ -258,7 +255,7 @@
 							"enterprise-solutions/sso-setup",
 							"enterprise-solutions/team-management/managing-members",
 							{
-								"group": "SaaS Provider Configuration",
+								"group": "Remote Provider Configuration",
 								"pages": [
 									"enterprise-solutions/configuration/remote-configuration/overview",
 									{
@@ -268,19 +265,33 @@
 											"enterprise-solutions/configuration/remote-configuration/aws-bedrock/member-configuration"
 										]
 									},
-									{
-										"group": "LiteLLM",
-										"pages": [
-											"enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration",
-											"enterprise-solutions/configuration/remote-configuration/litellm/member-configuration"
-										]
-									},
 									{
 										"group": "Google Vertex AI",
 										"pages": [
 											"enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration",
 											"enterprise-solutions/configuration/remote-configuration/google-vertex/member-configuration"
 										]
+									},
+									{
+										"group": "OpenAI Compatible",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration"
+										]
+									},
+									{
+										"group": "Anthropic",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration"
+										]
+									},
+									{
+										"group": "LiteLLM",
+										"pages": [
+											"enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration",
+											"enterprise-solutions/configuration/remote-configuration/litellm/member-configuration"
+										]
 									}
 								]
 							},
@@ -633,9 +644,13 @@
 			"source": "/troubleshooting/terminal-integration-guide",
 			"destination": "/troubleshooting/terminal-quick-fixes"
 		},
+		{
+			"source": "/features/deep-planning",
+			"destination": "/core-workflows/plan-and-act"
+		},
 		{
 			"source": "/features/slash-commands/deep-planning",
-			"destination": "/features/deep-planning"
+			"destination": "/core-workflows/plan-and-act"
 		},
 		{
 			"source": "/features/slash-commands/smol",

docs/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration.mdx

@@ -0,0 +1,98 @@
+---
+title: "Configure Anthropic Provider (Admin)"
+sidebarTitle: "Configure Anthropic (Admin)"
+description: "This guide explains how administrators configure Anthropic as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add Anthropic as the organization-wide LLM provider for all Cline users through the hosted admin console. This centralized approach provides direct access to Anthropic's Claude models, with an optional custom base URL for organizations that route traffic through a proxy.
+
+## Before You Begin
+
+To get started with setting up Anthropic as your organization's LLM provider, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+**Anthropic API access**  
+Your organization needs an Anthropic account with API access to Claude models. Members will need individual API keys to authenticate.
+
+<Note>
+If your organization requires routing API traffic through a proxy or custom endpoint, have the proxy URL ready before configuring.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select Anthropic as the API Provider">
+Open the **API Provider** dropdown menu and select **Anthropic**. This will open the Anthropic configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure Anthropic Settings">
+The configuration panel includes settings that control how Anthropic works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (optional)">
+By default, Cline connects directly to the Anthropic API (`https://api.anthropic.com`). If your organization routes API traffic through a proxy or custom endpoint, enter the base URL here.
+
+Use cases for a custom base URL:
+- Corporate proxy that logs or filters API traffic
+- Self-hosted API gateway for rate limiting or access control
+- Regional routing requirements
+
+Leave this empty to use the default Anthropic API endpoint.
+
+<Tip>
+If using a proxy, ensure it correctly forwards requests to the Anthropic API and preserves all required headers.
+</Tip>
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use Anthropic with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "Anthropic" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only Anthropic as a provider
+4. Verify that Claude models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
+
+**Connection errors when using a custom base URL**  
+Verify the proxy URL is correct and accessible from your team's development environments. Ensure the proxy correctly forwards requests to the Anthropic API.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change settings later**  
+You can update the base URL or other settings at any time. Changes take effect immediately for all organization members.
+
+For further details, consult the [Anthropic API documentation](https://docs.anthropic.com/) and coordinate with your infrastructure team.

docs/enterprise-solutions/configuration/remote-configuration/anthropic/member-configuration.mdx

@@ -0,0 +1,95 @@
+---
+title: "Configure Anthropic in VS Code (Members)"
+sidebarTitle: "Configure Anthropic (Member)"
+description: "Guide for engineers connecting to their organization's Anthropic provider through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's Anthropic provider setup. This guide walks you through configuring your API key in VS Code so you can start using Claude models through your organization's configuration. Your administrator has already configured the provider settings — you just need to add your API key to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's Anthropic provider, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**Anthropic API key**  
+You need an API key from Anthropic to authenticate requests. Your organization may provide keys centrally or require you to create one through the [Anthropic Console](https://console.anthropic.com/).
+
+<Note>
+If you're unsure how to obtain an API key, check with your administrator about your organization's key provisioning process.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area
+
+</Step>
+
+<Step title="Enter Your API Key">
+
+1. Select or confirm the **Anthropic** provider is selected
+2. Enter your Anthropic API key in the **API Key** field
+3. If your administrator configured a custom base URL, it will already be set and locked
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally and are only used by the Cline extension.
+</Tip>
+
+<Note>
+The base URL setting is controlled by your administrator. If a custom proxy URL is configured, your API requests will be routed through it automatically.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After entering your API key, administrator-controlled settings (such as base URL) will be locked (shown with a lock icon 🔒) as they're managed by your organization.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your API key works correctly with the configured Anthropic endpoint.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity before starting development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Troubleshooting
+
+**Anthropic not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the Anthropic configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Invalid API Key" or "Unauthorized")**  
+Verify your API key is correct and active. Check the [Anthropic Console](https://console.anthropic.com/) to confirm your key status and that it has sufficient permissions.
+
+**Connection errors or timeouts**  
+If your administrator configured a custom base URL (proxy), check with your IT team about network requirements. If using the default Anthropic endpoint, ensure you have internet access to `api.anthropic.com`.
+
+**Models not available**  
+The available models depend on your Anthropic API plan and your organization's configuration. Contact your administrator if expected models are not available.
+
+**Rate limit errors**  
+Your API key may have rate limits configured by Anthropic. If you encounter rate limit errors during normal use, contact your administrator about adjusting limits or managing key usage across the team.
+
+## Security Best Practices
+
+When working with your Anthropic API key:
+
+- Keep your API key secure and do not share it
+- Never store your API key in code or version control
+- Report any suspected key compromise to your administrator immediately
+- Regularly check the [Anthropic Console](https://console.anthropic.com/) for unusual usage patterns
+
+For further details, consult the [Anthropic API documentation](https://docs.anthropic.com/) and coordinate with your organization's administrator.

docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration.mdx

@@ -0,0 +1,138 @@
+---
+title: "Configure OpenAI Compatible Provider (Admin)"
+sidebarTitle: "Configure OpenAI Compatible (Admin)"
+description: "This guide explains how administrators configure an OpenAI-compatible endpoint as the organization-wide LLM provider for Cline."
+---
+
+
+As an administrator, you can add an OpenAI-compatible endpoint as the organization-wide LLM provider for all Cline users through the hosted admin console. This covers any provider that exposes an OpenAI-compatible API, including Azure Foundry (Azure OpenAI), self-hosted inference engines (vLLM, TGI), and other compatible services.
+
+## Before You Begin
+
+To get started with setting up an OpenAI-compatible provider for your organization, you'll need a few items in place.
+
+**Administrator access to the Cline Admin console**  
+You need admin privileges to enforce provider settings across your organization. If you can navigate to **Settings → Cline Settings** in the admin console at [app.cline.bot](https://app.cline.bot), you have the right access level.
+
+**An OpenAI-compatible API endpoint**  
+You need a running endpoint that implements the OpenAI chat completions API. This could be:
+- Azure Foundry (Azure OpenAI Service)
+- A self-hosted inference engine (vLLM, text-generation-inference, etc.)
+- Any third-party service with an OpenAI-compatible API
+
+<Note>
+If you're using Azure Foundry, you'll need your Azure OpenAI endpoint URL and optionally the API version. Work with your Azure administrator to ensure the endpoint is provisioned and accessible.
+</Note>
+
+**Endpoint URL and authentication details**  
+You'll need the base URL of your endpoint and any required authentication headers.
+
+## Configuration Steps
+
+<Steps>
+<Step title="Access Cline Settings">
+Navigate to [app.cline.bot](https://app.cline.bot) and sign in with your administrator account. Go to **Settings → Cline Settings**.
+
+<Info>
+You should see the provider configuration options if you have the correct admin access level.
+</Info>
+</Step>
+
+<Step title="Enable Remote Provider Configuration">
+Toggle on **Enable settings** to reveal the remote provider configuration options. This allows you to enforce provider settings across your organization.
+</Step>
+
+<Step title="Select OpenAI Compatible as the API Provider">
+Open the **API Provider** dropdown menu and select **OpenAI Compatible**. This will open the configuration panel where you'll configure all your organization-wide settings.
+</Step>
+
+<Step title="Configure OpenAI Compatible Settings">
+The configuration panel includes settings that control how the provider works for your organization:
+
+<AccordionGroup>
+<Accordion title="Base URL (required)">
+Enter the base URL of your OpenAI-compatible endpoint. Examples:
+
+- **Azure Foundry**: `https://your-resource.openai.azure.com`
+- **Self-hosted vLLM**: `https://inference.yourcompany.com/v1`
+- **Other compatible services**: The provider's API base URL
+
+<Tip>
+Use HTTPS endpoints in production for security. Ensure the URL is accessible from your team's development environments.
+</Tip>
+</Accordion>
+
+<Accordion title="Custom Headers (optional)">
+Add custom HTTP headers that will be included with every API request. This is useful for:
+
+- Custom authentication schemes beyond API keys
+- Routing headers for internal load balancers
+- Organization or tenant identifiers required by your endpoint
+
+Headers are configured as key-value pairs.
+</Accordion>
+
+<Accordion title="Azure API Version (optional — Azure Foundry only)">
+If you're using Azure Foundry (Azure OpenAI), specify the API version string. For example: `2024-02-15-preview` or `2024-06-01`.
+
+This field is only needed for Azure OpenAI deployments. Leave it empty for non-Azure endpoints.
+
+<Note>
+Check the [Azure OpenAI API version documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/reference) for available versions.
+</Note>
+</Accordion>
+
+<Accordion title="Azure Identity Authentication (optional — Azure Foundry only)">
+Enable this to use Azure Active Directory (Entra ID) token-based authentication instead of API keys. When enabled, members authenticate using their Azure AD credentials rather than a static API key.
+
+This field is only relevant for Azure Foundry deployments.
+</Accordion>
+</AccordionGroup>
+</Step>
+
+<Step title="Save Configuration">
+After configuring your settings, close the provider configuration panel and click **Save** on the settings page to persist your changes.
+
+Once saved, all organization members signed into the Cline extension will automatically use the OpenAI Compatible provider with your configured settings. They won't be able to select other providers or switch to their personal Cline accounts.
+
+<Warning>
+Members can't switch to personal Cline accounts or join other organizations once remote configuration is enabled. This ensures consistent provider usage across your team.
+</Warning>
+</Step>
+</Steps>
+
+## Azure Foundry Configuration
+
+For organizations using Azure Foundry (Azure OpenAI Service), use the following configuration:
+
+1. **Base URL**: Your Azure OpenAI endpoint (e.g., `https://your-resource.openai.azure.com`)
+2. **Azure API Version**: The API version to use (e.g., `2024-06-01`)
+3. **Azure Identity Authentication**: Enable if your organization uses Azure AD for authentication instead of API keys
+
+## Verification
+
+To verify the configuration:
+
+1. Check that the provider shows as "OpenAI Compatible" in the Enabled provider field
+2. Confirm the settings persist after refreshing the page
+3. Test with a member account to ensure they see only the OpenAI Compatible provider
+4. Verify that configured models are available in the model dropdown
+
+## Troubleshooting
+
+**Members don't see the configured provider**  
+Ensure you clicked Save after closing the configuration panel. Verify the member account belongs to the correct organization.
+
+**Connection errors to the endpoint**  
+Verify the Base URL is correct and accessible from your team's development environments. Check that any firewalls or security groups allow access from developer IP addresses.
+
+**Azure authentication failures**  
+If using Azure Identity Authentication, verify that members' Azure AD accounts have the appropriate role assignments on the Azure OpenAI resource. If using API keys, verify the key is correctly entered by the member.
+
+**Configuration changes don't persist**  
+Make sure to click the Save button on the main settings page, not just close the configuration panel.
+
+**Need to change endpoint or settings later**  
+You can update these settings at any time. Changes take effect immediately for all organization members.
+
+For Azure Foundry, consult the [Azure OpenAI Service documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). For other OpenAI-compatible endpoints, refer to your provider's documentation.

docs/enterprise-solutions/configuration/remote-configuration/openai-compatible/member-configuration.mdx

@@ -0,0 +1,117 @@
+---
+title: "Configure OpenAI Compatible in VS Code (Members)"
+sidebarTitle: "Configure OpenAI Compatible (Member)"
+description: "Guide for engineers connecting to their organization's OpenAI-compatible endpoint through VS Code after admin setup"
+---
+
+As a team member, you can connect your local development environment to your organization's OpenAI-compatible endpoint. This guide walks you through configuring your credentials in VS Code so you can start using models through your organization's configured endpoint. Your administrator has already configured the provider settings — you just need to add your API key to get started.
+
+## Before You Begin
+
+To successfully connect to your organization's OpenAI-compatible endpoint, you'll need a few things ready.
+
+**Cline extension installed and configured**  
+The Cline extension must be installed in VS Code and you need to be signed into your organization account. If you haven't installed Cline yet, follow our [installation guide](/getting-started/installing-cline).
+
+<Info>
+**Quick Check**: Open the Cline panel in VS Code. If you see your organization name in the bottom left, you're signed in correctly.
+</Info>
+
+**API key or credentials for your endpoint**  
+You need an API key or credentials to authenticate with your organization's configured endpoint. For Azure Foundry deployments using Azure Identity Authentication, your Azure AD credentials may be used instead.
+
+<Note>
+If you're unsure what credentials to use, check with your administrator or IT team about how your organization has configured access.
+</Note>
+
+## Configuration Steps
+
+<Steps>
+<Step title="Open Cline Settings">
+Open VS Code and access the Cline settings panel using either of these methods:
+
+- Click the settings icon (⚙️) in the Cline panel
+- Click on the API Provider dropdown located directly below the chat area
+
+</Step>
+
+<Step title="Configure Your Credentials">
+The authentication method depends on how your administrator configured the endpoint:
+
+<AccordionGroup>
+<Accordion title="API Key Authentication">
+For most OpenAI-compatible endpoints:
+
+1. Select or confirm the **OpenAI Compatible** provider is selected
+2. Enter your API key in the **API Key** field
+3. The base URL, custom headers, and other settings are preconfigured by your administrator
+4. Click **Save** to store your credentials
+
+<Tip>
+API keys are stored locally and are only used by the Cline extension.
+</Tip>
+</Accordion>
+
+<Accordion title="Azure Identity Authentication (Azure Foundry)">
+If your organization uses Azure AD authentication:
+
+1. Select or confirm the **OpenAI Compatible** provider is selected
+2. Ensure you are signed into Azure in your development environment
+3. The extension will use your Azure AD credentials automatically
+4. No API key is needed when Azure Identity Authentication is enabled
+
+<Note>
+You may need the Azure Account extension or Azure CLI installed for credential resolution.
+</Note>
+</Accordion>
+</AccordionGroup>
+
+<Note>
+The Base URL, custom headers, Azure API version, and Azure Identity settings are preconfigured by your administrator and do not need to be set in the extension.
+</Note>
+</Step>
+
+<Step title="Verify Configuration">
+After configuring your credentials, administrator-controlled settings will be locked (shown with a lock icon 🔒) as they're managed by your organization.
+</Step>
+
+<Step title="Test the Connection">
+Send a test message in Cline to verify your credentials work correctly with the configured endpoint.
+
+<Tip>
+**Testing Recommendation**
+
+Try a simple test like "Hello" first to verify basic connectivity before starting development tasks.
+</Tip>
+</Step>
+</Steps>
+
+## Troubleshooting
+
+**OpenAI Compatible not available as provider option**  
+Confirm you're signed into the correct Cline organization. Verify your administrator has saved the configuration and that you have the latest version of the Cline extension.
+
+**Authentication errors ("Access Denied" or "Invalid API Key")**  
+Verify your API key is correct and active. For Azure Foundry with Azure Identity Authentication, ensure you are signed into Azure in your development environment and that your account has the appropriate role assignments on the Azure OpenAI resource.
+
+**Connection errors or timeouts**  
+The endpoint URL is configured by your administrator. If you experience connection issues, check with your IT team about network requirements (VPN, firewall rules, etc.).
+
+**Models not available**  
+The available models depend on your organization's endpoint configuration. Contact your administrator if expected models are not available in the model dropdown.
+
+**Configuration changes don't persist**  
+Make sure to save your credentials. The base URL and other admin-controlled settings cannot be changed locally.
+
+## Security Best Practices
+
+When working with your API credentials:
+
+- Keep your API key secure and do not share it
+- Never store credentials in code or version control
+- Report any suspected key compromise to your administrator immediately
+- Follow your organization's usage guidelines for the configured endpoint
+
+Your organization administrator controls which endpoint, models, and settings are available. The extension will automatically apply the configured settings based on your organization's remote configuration.
+
+For Azure Foundry, refer to the [Azure OpenAI Service documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/). For other endpoints, consult your organization's internal documentation or contact your administrator.

docs/enterprise-solutions/configuration/remote-configuration/overview.mdx

@@ -1,11 +1,11 @@
 ---
-title: "SaaS Provider Configuration"
+title: "Enterprise Provider Configuration"
 sidebarTitle: "Overview"
 description: "Configure inference providers through the Cline hosted admin console for centralized organization management"
 ---
 
 
-SaaS Provider Configuration allows administrators to centrally configure inference providers for their entire organization through the Cline hosted admin console. This approach ensures consistent provider access, security policies, and cost management across all team members without requiring individual developer setup or infrastructure deployment.
+Remote Provider Configuration allows administrators to centrally configure inference providers for their entire organization through the Cline hosted admin console. This approach ensures consistent provider access, security policies, and cost management across all team members without requiring individual developer setup or infrastructure deployment.
 
 ## How Remote Configuration Works
 
@@ -35,11 +35,17 @@ Cline supports remote configuration for the following inference providers:
 
 | Provider | Use Case | Configuration | Member Setup |
 |----------|----------|---------------|--------------|
-| **Cline** | Organizations using Cline's native provider with centralized API key management | API provider selection, model access | No individual API keys needed - fully managed by organization |
-| **Amazon Bedrock** | Organizations using AWS infrastructure | Region selection, VPC endpoints, cross-region inference, prompt caching | AWS credential configuration in VS Code |
-| **LiteLLM** | Organizations requiring multi-model access through a unified proxy | Proxy endpoint, authentication, model routing | API key or endpoint configuration in VS Code (or centralized with Master Key) |
-| **Google Vertex AI** | Organizations using Google Cloud Platform | Project ID, region selection, model access | Service account or credential configuration in VS Code |
+| **Cline** | Organizations using Cline's native provider with centralized API key management | API provider selection, model access | No individual API keys needed — fully managed by organization |
+| **Amazon Bedrock** | Organizations using AWS infrastructure | Region selection, VPC endpoints, cross-region inference, global inference, prompt caching | AWS credential configuration (API key, CLI profile, or credential chain) |
+| **Google Vertex AI** | Organizations using Google Cloud Platform | Project ID, region selection, model access | Google Cloud credential configuration (service account, SDK, or ADC) |
+| **Azure Foundry** | Organizations using Azure OpenAI or Azure AI services | Base URL, Azure API version, Azure identity authentication, custom headers | API key configuration in the extension |
+| **Anthropic** | Organizations using the Anthropic API directly | Optional custom base URL for proxy deployments, model access | API key configuration in the extension |
+| **OpenAI Compatible** | Organizations using any OpenAI-compatible endpoint (self-hosted, vLLM, custom proxies) | Base URL, custom headers, model access | API key configuration in the extension |
+| **LiteLLM** | Organizations requiring multi-model access through a unified proxy | Proxy endpoint, authentication, model routing | API key or endpoint configuration (or centralized with Master Key) |
 
+<Note>
+**Azure Foundry** uses the OpenAI Compatible provider configuration with Azure-specific settings (API version, Azure identity authentication). See the [OpenAI Compatible admin configuration](/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration) for setup instructions.
+</Note>
 
 ## Configuration Process
 
@@ -55,7 +61,7 @@ Provider configuration is automatically distributed to all organization members
 </Step>
 
 <Step title="Member Credential Setup">
-Team members add their individual credentials (API keys, AWS profiles, etc.) to connect to the configured provider.
+Team members add their individual credentials (API keys, AWS profiles, etc.) to connect to the configured provider. For some providers like Cline and LiteLLM (with Master Key), no individual credentials are needed.
 </Step>
 
 <Step title="Immediate Access">
@@ -92,11 +98,17 @@ Select your provider below to begin the configuration process:
     AWS-based AI models with enterprise security and compliance features.
   </Card>
   
+  <Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration">
+    Google Cloud's AI platform with Gemini models and regional control.
+  </Card>
+
+  <Card title="OpenAI Compatible" icon="plug" href="/enterprise-solutions/configuration/remote-configuration/openai-compatible/admin-configuration">
+    Any OpenAI-compatible endpoint, including Azure Foundry.
+  </Card>
+
+  <Card title="Anthropic" icon="robot" href="/enterprise-solutions/configuration/remote-configuration/anthropic/admin-configuration">
+
   <Card title="LiteLLM" icon="layer-group" href="/enterprise-solutions/configuration/remote-configuration/litellm/admin-configuration">
     Unified proxy for accessing 100+ AI models through a single interface.
   </Card>
-  
-  <Card title="Google Vertex AI" icon="google" href="/enterprise-solutions/configuration/remote-configuration/google-vertex/admin-configuration">
-    Google Cloud's AI platform with advanced ML capabilities and global infrastructure.
-  </Card>
 </CardGroup>

docs/enterprise-solutions/monitoring/opentelemetry_override.mdx

@@ -0,0 +1,155 @@
+---
+title: "OpenTelemetry Environment Variables"
+sidebarTitle: "OpenTelemetry Override"
+description: "Configure OpenTelemetry using environment variables for advanced scenarios"
+---
+
+<Note>
+This is an **advanced configuration method**. Most users should use [Remote Configuration](/enterprise-solutions/monitoring/opentelemetry) via the dashboard instead.
+</Note>
+
+Environment variables provide an alternative way to configure OpenTelemetry, useful for self-hosted deployments, local development, CI/CD pipelines, or when you need to override organization settings.
+
+## When to Use
+
+- **Self-hosted deployments** without dashboard access
+- **Local development and testing** with your own collectors
+- **CI/CD pipelines** that need observability
+- **Override organization settings** with user-specific configuration
+
+<Warning>
+Environment variable configuration bypasses user telemetry settings and will export data regardless of individual preferences.
+</Warning>
+
+## Environment Variables
+
+### Core Configuration
+
+| Variable | Description | Values |
+|----------|-------------|--------|
+| `CLINE_OTEL_TELEMETRY_ENABLED` | Enable OpenTelemetry export | `"true"` or `"false"` |
+| `CLINE_OTEL_METRICS_EXPORTER` | Metrics exporters (comma-separated) | `"console"`, `"otlp"` |
+| `CLINE_OTEL_LOGS_EXPORTER` | Logs exporters (comma-separated) | `"console"`, `"otlp"` |
+
+### OTLP Configuration
+
+| Variable | Description | Values |
+|----------|-------------|--------|
+| `CLINE_OTEL_EXPORTER_OTLP_PROTOCOL` | OTLP protocol | `"grpc"`, `"http/json"`, or `"http/protobuf"` |
+| `CLINE_OTEL_EXPORTER_OTLP_ENDPOINT` | OTLP collector endpoint (applies to both metrics and logs) | URL with optional port |
+| `CLINE_OTEL_EXPORTER_OTLP_HEADERS` | Authentication headers (comma-separated `key=value` pairs) | `"key=value,key2=value2"` |
+| `CLINE_OTEL_EXPORTER_OTLP_INSECURE` | Disable TLS for gRPC (local development only) | `"true"` |
+
+### Advanced OTLP Configuration
+
+For separate metrics and logs endpoints:
+
+| Variable | Description |
+|----------|-------------|
+| `CLINE_OTEL_EXPORTER_OTLP_METRICS_PROTOCOL` | Metrics-specific protocol override |
+| `CLINE_OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` | Metrics-specific endpoint |
+| `CLINE_OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` | Logs-specific protocol override |
+| `CLINE_OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` | Logs-specific endpoint |
+
+### Export Tuning
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `CLINE_OTEL_METRIC_EXPORT_INTERVAL` | Milliseconds between metric exports | 60000 |
+| `CLINE_OTEL_LOG_BATCH_SIZE` | Maximum batch size for log records | 512 |
+| `CLINE_OTEL_LOG_BATCH_TIMEOUT` | Maximum time before exporting logs (ms) | 5000 |
+| `CLINE_OTEL_LOG_MAX_QUEUE_SIZE` | Maximum queue size for log records | 2048 |
+
+## Quick Start Examples
+
+### Datadog with gRPC
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=https://api.datadoghq.com:4317
+export CLINE_OTEL_EXPORTER_OTLP_HEADERS="dd-api-key=YOUR_API_KEY"
+
+code .
+```
+
+<Note>
+The endpoint shown above is for Datadog's **US1 region**. If you're in a different region (EU, US3, US5, AP1, etc.), replace `api.datadoghq.com` with your region-specific hostname (e.g., `api.datadoghq.eu` for EU). See [Datadog's OTLP documentation](https://docs.datadoghq.com/opentelemetry/) for your region's endpoint.
+</Note>
+
+### New Relic with HTTP
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.nr-data.net:4318
+export CLINE_OTEL_EXPORTER_OTLP_HEADERS="api-key=YOUR_LICENSE_KEY"
+
+code .
+```
+
+### Local Development (Insecure)
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=otlp
+export CLINE_OTEL_LOGS_EXPORTER=otlp
+export CLINE_OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+export CLINE_OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
+export CLINE_OTEL_EXPORTER_OTLP_INSECURE=true
+
+code .
+```
+
+### Console Output (Testing)
+
+```bash
+export CLINE_OTEL_TELEMETRY_ENABLED=true
+export CLINE_OTEL_METRICS_EXPORTER=console
+export CLINE_OTEL_LOGS_EXPORTER=console
+
+code .
+```
+
+## Debugging
+
+Enable detailed OpenTelemetry diagnostic logging:
+
+```bash
+export TEL_DEBUG_DIAGNOSTICS=true
+code .
+```
+
+This outputs:
+- Configuration being used
+- Exporters being created
+- Connection attempts
+- Export successes/failures
+
+Check the VS Code Developer Tools Console (Help > Toggle Developer Tools) for diagnostic output.
+
+## Configuration Priority
+
+When multiple configuration methods are present, Cline uses this priority order:
+
+1. **Environment variables** (highest priority) - This method
+2. **Remote Configuration** - Dashboard settings
+3. **Default settings** - Built-in defaults
+
+Environment variable configuration will override dashboard settings.
+
+## See Also
+
+<CardGroup cols={2}>
+  <Card title="Dashboard Configuration" icon="globe" href="/enterprise-solutions/monitoring/opentelemetry">
+    Configure OpenTelemetry via the web dashboard
+  </Card>
+  
+  <Card title="Remote Configuration" icon="server" href="/enterprise-solutions/configuration/remote-configuration/overview">
+    Learn about Remote Configuration system
+  </Card>
+</CardGroup>

docs/enterprise-solutions/team-management/managing-members.mdx

@@ -199,8 +199,7 @@ Understanding how seats work helps you manage your license effectively:
   
   <Accordion title="Upgrading Your License" icon="arrow-up">
     Need more seats?
-    - **Teams Plan:** Contact your account manager or visit app.cline.bot/settings/billing to upgrade your license.
-    - **Enterprise Plan:** Includes unlimited seats with no per-user restrictions.
+    - **Enterprise Plan:** Includes unlimited seats with no per-user restrictions. Contact your account manager or visit app.cline.bot/settings/billing to upgrade.
   </Accordion>
 </AccordionGroup>
 

docs/features/auto-compact.mdx

@@ -35,7 +35,7 @@ Now with summarization:
 - You can work on much larger projects without interruption
 
 <Tip>
-Auto Compact works beautifully with [Focus Chain](/features/focus-chain). When Focus Chain is enabled, todo lists persist across summarizations. Cline can work on long-horizon tasks spanning multiple context windows while staying on track.
+Auto Compact works well with Cline's built-in task-progress tracking and, if you still use it, [Legacy Focus Chain](/features/focus-chain). When Focus Chain is enabled, todo lists persist across summarizations.
 </Tip>
 
 ## Cost Considerations

docs/features/deep-planning.mdx

@@ -1,129 +0,0 @@
----
-title: "Deep Planning"
-sidebarTitle: "Deep Planning"
-description: "Transform Cline into a meticulous architect who investigates your codebase and creates comprehensive implementation plans."
----
-
-Deep Planning (`/deep-planning`) turns Cline into an architect before it becomes a builder. Instead of jumping straight into code, Cline systematically explores your codebase, asks targeted questions, and produces a detailed implementation plan — all before writing a single line.
-
-<Tip>
-**When should you use this?** Use `/deep-planning` for features that touch multiple files, architectural changes, complex integrations, or any task where "just start coding" would lead to rework.
-</Tip>
-
-## How It Works
-
-Deep Planning follows a four-step process:
-
-<Steps>
-  <Step title="Silent Investigation">
-    Cline explores your codebase without asking you anything. It reads relevant files, traces dependencies, examines patterns, and builds a mental model of how your project is structured. You'll see Cline reading files and running searches during this phase.
-
-    This step is intentionally silent — Cline gathers context first so it can ask better questions next.
-  </Step>
-
-  <Step title="Discussion">
-    Based on what it learned, Cline asks you targeted, specific questions about your requirements and preferences. These aren't generic questions — they're informed by what Cline found in your code.
-
-    For example, instead of asking "how should authentication work?", Cline might ask "I see you're using JWT tokens in `auth/middleware.ts` with refresh token rotation. Should the new endpoint follow the same pattern, or do you want session-based auth for this feature?"
-
-    Answer these questions to shape the plan. The more specific you are, the better the implementation plan will be.
-  </Step>
-
-  <Step title="Plan Creation">
-    Cline generates a comprehensive `implementation_plan.md` file in your project. This plan typically includes:
-
-    - **Overview** of the feature and its scope
-    - **File-by-file changes** with specific descriptions of what to add, modify, or remove
-    - **Dependencies** between changes (what needs to happen first)
-    - **Edge cases** and error handling considerations
-    - **Testing strategy** for the implementation
-
-    The plan is saved as a markdown file you can review, edit, and share with your team before any code is written.
-  </Step>
-
-  <Step title="Task Creation">
-    After you approve the plan, Cline creates a new task with the implementation steps loaded as trackable items. This gives you a clean context window focused entirely on execution, with the plan serving as the roadmap.
-  </Step>
-</Steps>
-
-## Using Deep Planning
-
-### Invoking It
-
-Type `/deep-planning` in the Cline chat input, followed by a description of what you want to build:
-
-```
-/deep-planning Add a notification system that sends email and in-app 
-notifications when users receive comments on their posts
-```
-
-The more context you provide upfront, the more focused the investigation phase will be. Include:
-
-- What you want to build
-- Any constraints or preferences
-- Which parts of the codebase are relevant (if you know)
-
-### Reviewing the Plan
-
-Once Cline generates `implementation_plan.md`, review it carefully:
-
-1. **Check the scope** — Does it cover everything you need? Is anything missing?
-2. **Verify the approach** — Does the technical approach match your preferences?
-3. **Review the order** — Are dependencies handled correctly?
-4. **Edit if needed** — It's a markdown file. Change anything that doesn't look right.
-
-Tell Cline about any adjustments before proceeding to implementation.
-
-## Model-Specific Optimization
-
-The deep planning prompt is optimized for each model family. Cline adapts its investigation and planning approach based on the strengths of whatever model you're using — whether that's Claude, GPT, Gemini, DeepSeek, or others.
-
-This means you get effective deep planning regardless of your model choice, though stronger reasoning models will generally produce more thorough plans.
-
-<Tip>
-Consider using a stronger reasoning model for the planning phase and a faster model for implementation. You can configure separate models for Plan and Act modes in Cline Settings. See [Plan & Act Mode](/core-workflows/plan-and-act#using-different-models-for-each-mode) for details.
-</Tip>
-
-## Pairing with Other Features
-
-Deep Planning works well with several other Cline features:
-
-| Feature | How It Helps |
-|---------|-------------|
-| [Focus Chain](/features/focus-chain) | Tracks implementation progress against the plan with a visible todo list |
-| [Memory Bank](/features/memory-bank) | Preserves project context across sessions so deep planning has richer input |
-| [Plan & Act Mode](/core-workflows/plan-and-act) | Use Plan mode for quick exploration, deep planning for thorough architecture |
-| [Checkpoints](/core-workflows/checkpoints) | Roll back implementation steps if something goes wrong during execution |
-
-<Tip>
-A powerful workflow: run `/deep-planning` to create the plan, enable [Focus Chain](/features/focus-chain) to track progress, then let Cline implement step by step. You get architecture-level thinking with granular progress visibility.
-</Tip>
-
-## Deep Planning vs Plan Mode
-
-Both involve thinking before doing, but they serve different purposes:
-
-| | Plan Mode | Deep Planning |
-|---|-----------|---------------|
-| **Scope** | Quick exploration and discussion | Thorough codebase investigation |
-| **Output** | Conversation context | `implementation_plan.md` file |
-| **Best for** | Medium tasks, understanding code | Large tasks, multi-file features |
-| **Duration** | Minutes | Longer — depends on codebase size |
-| **Persistence** | Lives in conversation history | Saved as a file you can reference later |
-
-For most development work, starting in Plan mode is sufficient. Reserve `/deep-planning` for tasks where you'd normally spend significant time planning on a whiteboard before coding.
-
-## Tips
-
-- **Be specific in your initial prompt.** "Add authentication" gives a vague plan. "Add OAuth2 authentication with Google and GitHub providers, using our existing user model in `models/user.ts`" gives a focused one.
-- **Point Cline at relevant files.** Use `@` mentions to highlight key files in your prompt so the investigation phase starts in the right place.
-- **Edit the plan before implementing.** The generated plan is a starting point. Adjust priorities, remove unnecessary steps, or add details before Cline starts coding.
-- **Save plans for reference.** The `implementation_plan.md` file is useful documentation even after the feature is built. Consider committing it or moving it to a docs folder.
-- **Use for onboarding.** Run `/deep-planning` on a feature you're unfamiliar with to get Cline to map out the codebase and explain how things connect.
-
-## Related
-
-- [Plan & Act Mode](/core-workflows/plan-and-act) — Cline's dual-mode system for structured development
-- [Focus Chain](/features/focus-chain) — Automatic todo list tracking for long-running tasks
-- [Memory Bank](/features/memory-bank) — Structured documentation for cross-session context
-- [Using Commands](/core-workflows/using-commands) — All available slash commands

docs/features/focus-chain.mdx

@@ -1,10 +1,14 @@
 ---
-title: "Focus Chain"
-sidebarTitle: "Focus Chain"
-description: "Automatic todo list management with real-time progress tracking for long-running tasks."
+title: "Legacy Focus Chain"
+sidebarTitle: "Legacy Focus Chain"
+description: "A legacy todo-tracking feature kept for compatibility while Cline shifts toward built-in task_progress checklists and Plan & Act workflows."
 ---
 
-Focus Chain is automatic todo list management with real-time progress tracking. It helps Cline work on longer tasks by maintaining a visible checklist that persists across context window resets.
+Focus Chain is a legacy todo-tracking feature that maintains a visible checklist across long-running tasks. It is still available in this branch, but it is no longer the primary product direction for task planning and progress tracking.
+
+<Warning>
+For new work, prefer [Plan & Act mode](/core-workflows/plan-and-act), built-in `task_progress` checklists, and Cline's standard task-management flow. Use Focus Chain only if you explicitly want the older persistent checklist behavior.
+</Warning>
 
 <Frame>
 	<img
@@ -15,7 +19,7 @@ Focus Chain is automatic todo list management with real-time progress tracking.
 
 ## When to Use It
 
-Focus Chain works best for:
+Focus Chain still works best for:
 - Multi-step implementations (building a feature end-to-end)
 - Tasks that might span multiple context windows
 - Work where you want visibility into Cline's plan
@@ -23,7 +27,7 @@ Focus Chain works best for:
 For quick, single-step requests, Focus Chain adds overhead without much benefit.
 
 <Tip>
-Focus Chain pairs well with [Deep Planning](/features/deep-planning). Use `/deep-planning` to create a detailed implementation plan, then let Focus Chain track progress as you execute it.
+If you still use Focus Chain, pair it with [Plan & Act mode](/core-workflows/plan-and-act). For most users, the simpler path is to let Plan mode define the work and rely on built-in task-progress tracking during execution.
 </Tip>
 
 ## Enabling Focus Chain

docs/features/memory-bank.mdx

@@ -1,10 +1,24 @@
 ---
-title: "Memory Bank"
-sidebarTitle: "Memory Bank"
-description: "A structured documentation system that helps Cline maintain context across sessions."
+title: "Legacy Memory Bank"
+sidebarTitle: "Legacy Memory Bank"
+description: "A legacy documentation methodology for users who still want to maintain manual cross-session context outside Cline's core product direction."
 ---
 
-Memory Bank is a documentation methodology that transforms Cline from a stateless assistant into a persistent development partner. Through structured markdown files, Cline can "remember" your project details across sessions.
+Memory Bank is a legacy documentation methodology for users who want to maintain structured project context across sessions in plain markdown files. It is no longer a core product direction for Cline, but the pattern can still be useful if you explicitly want to manage persistent context by hand.
+
+<Warning>
+For new projects, prefer Cline's built-in context tools such as [Plan & Act mode](/core-workflows/plan-and-act), [`/newtask`](/core-workflows/using-commands#newtask), [`/smol`](/core-workflows/using-commands#smol), and [Cline Rules](/customization/cline-rules). Use Memory Bank only if you intentionally want a manual, file-based context system.
+</Warning>
+
+## When to Use It
+
+Use Memory Bank only when all of the following are true:
+
+- you want a manual documentation layer outside the core product workflow,
+- you are comfortable maintaining extra markdown files yourself,
+- and built-in task/context tools are not enough for your process.
+
+If you mainly want better planning, resumability, and context management inside Cline itself, start with [Plan & Act mode](/core-workflows/plan-and-act), [Task Management](/core-workflows/task-management), and [Cline Rules](/customization/cline-rules) instead.
 
 ## Quick Setup
 
@@ -51,12 +65,12 @@ These work alongside Cline's built-in [slash commands](/core-workflows/using-com
 
 ## Working with Plan & Act Modes
 
-Memory Bank pairs naturally with [Plan & Act mode](/core-workflows/plan-and-act):
+Memory Bank can still pair with [Plan & Act mode](/core-workflows/plan-and-act):
 
 - **Plan mode**: Start here when resuming a project. Ask Cline to read the Memory Bank, review the current state, and discuss strategy before making changes.
 - **Act mode**: Switch to Act mode once you have a plan. Cline retains everything from the planning session and can implement changes.
 
-For complex features, use [`/deep-planning`](/core-workflows/using-commands#deep-planning) to have Cline investigate your codebase and create a detailed implementation plan. The Memory Bank gives Cline the project context it needs to plan effectively.
+For complex features, stay in Plan mode long enough for Cline to investigate your codebase and write a detailed implementation plan. The Memory Bank gives Cline the project context it needs to plan effectively.
 
 ## Managing Context Windows
 

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

@@ -211,7 +211,7 @@ Click **Approve** to apply the changes, then refresh your browser to see the upd
 
 ## Step 8: Undo Mistakes with Checkpoints
 
-Cline automatically saves a **checkpoint** after each change it makes. If something breaks or you don't like a modification, you can go back to any previous state.
+If checkpoints are enabled, Cline saves a **checkpoint** after each change it makes. If something breaks or you don't like a modification, you can go back to an earlier state.
 
 ### How to find checkpoints
 
@@ -233,7 +233,7 @@ When you click **Restore**, you'll see three options:
 **Recommended for beginners:** Use **"Restore Workspace Only"** when you want to undo a change but keep chatting with Cline about what to do differently.
 
 <Tip>
-Checkpoints are separate from Git. They won't affect your commits, branches, or any version control you have set up.
+The current checkpoint system is separate from your main Git history. It won't affect your commits, branches, or any version control you have set up.
 </Tip>
 
 Learn more in the [Checkpoints guide](/core-workflows/checkpoints).
@@ -261,5 +261,5 @@ These same patterns work for any project, from simple scripts to full applicatio
 ## Need Help?
 
 - **Start a fresh conversation**: Type `/new` in the chat input to begin a new task
-- **Report issues**: Use `/reportbug` to help us improve
+- **Report issues**: Open a [GitHub issue](https://github.com/cline/cline/issues)
 - **Get support**: Join our [Discord community](https://discord.gg/cline)

docs/home.mdx

@@ -32,10 +32,10 @@ Cline is an AI coding agent that lives in your editor and your terminal. It can
     Learn the daily patterns: task management, plan & act, working with files, commands, and checkpoints.
   </Card>
   <Card title="Customization" icon="sliders" href="/customization/overview">
-    Tailor Cline to your workflow with rules, skills, workflows, hooks, and .clineignore.
+    Tailor Cline to your workflow with rules, skills, legacy workflows, hooks, and .clineignore.
   </Card>
-  <Card title="Features" icon="sparkles" href="/features/memory-bank">
-    Discover Memory Bank, Focus Chain, auto-approve, subagents, Jupyter support, and more.
+  <Card title="Features" icon="sparkles" href="/features/auto-approve">
+    Discover auto-approve, subagents, Jupyter support, web tools, and other current Cline capabilities.
   </Card>
   <Card title="Models & Providers" icon="microchip" href="/core-features/model-selection-guide">
     Choose and configure AI models: cloud providers, local models, and advanced setups.

docs/package-lock.json

@@ -139,6 +139,7 @@
 			"resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.4.tgz",
 			"integrity": "sha512-C3HlIdsBxszvm5McXlB8PeOEWfBhcGBTZGkGlWc2U0KFY5IwG5OQEuQ8rq52DZmcHDlPLd+YFBK+cZcytwIFWg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/utils": "^0.2.10"
 			}
@@ -148,6 +149,7 @@
 			"resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.5.tgz",
 			"integrity": "sha512-N0bD2kIPInNHUHehXhMke1rBGs1dwqvC9O9KYMyyjK7iXt7GAhnro7UlcuYcGdS/yYOlq0MAVgrow8IbWJwyqg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/core": "^1.7.4",
 				"@floating-ui/utils": "^0.2.10"
@@ -157,7 +159,8 @@
 			"version": "0.2.10",
 			"resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz",
 			"integrity": "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ==",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/@img/sharp-darwin-arm64": {
 			"version": "0.33.5",
@@ -1082,6 +1085,7 @@
 			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
 			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/dom": "^1.7.5"
 			},
@@ -1167,6 +1171,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
 			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3"
 			},
@@ -1190,6 +1195,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
 			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/primitive": "1.1.3",
 				"@radix-ui/react-compose-refs": "1.1.2",
@@ -1217,6 +1223,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
 			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-primitive": "2.1.3",
@@ -1280,6 +1287,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
 			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/react-dom": "^2.0.0",
 				"@radix-ui/react-arrow": "1.1.7",
@@ -1312,6 +1320,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
 			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -1336,6 +1345,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
 			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -1360,6 +1370,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
 			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-slot": "1.2.3"
 			},
@@ -1456,6 +1467,7 @@
 			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
 			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"loose-envify": "^1.1.0"
 			}
@@ -1919,6 +1931,7 @@
 			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
 			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/dom": "^1.7.5"
 			},
@@ -2105,6 +2118,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
 			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3"
 			},
@@ -2128,6 +2142,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
 			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/primitive": "1.1.3",
 				"@radix-ui/react-compose-refs": "1.1.2",
@@ -2155,6 +2170,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
 			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-primitive": "2.1.3",
@@ -2218,6 +2234,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
 			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/react-dom": "^2.0.0",
 				"@radix-ui/react-arrow": "1.1.7",
@@ -2250,6 +2267,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
 			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -2274,6 +2292,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
 			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -2298,6 +2317,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
 			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-slot": "1.2.3"
 			},
@@ -2422,6 +2442,7 @@
 			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
 			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"loose-envify": "^1.1.0"
 			}
@@ -2450,6 +2471,7 @@
 			"resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.7.tgz",
 			"integrity": "sha512-0tLRojf/1Go2JgEVm+3Frg9A3IW8bJgKgdO0BN5RkF//ufuz2joZM63Npau2ff3J6lUVYgDSNzNkR+aH3IVfjg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/dom": "^1.7.5"
 			},
@@ -2492,6 +2514,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
 			"integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3"
 			},
@@ -2515,6 +2538,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
 			"integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/primitive": "1.1.3",
 				"@radix-ui/react-compose-refs": "1.1.2",
@@ -2542,6 +2566,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
 			"integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-primitive": "2.1.3",
@@ -2605,6 +2630,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
 			"integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@floating-ui/react-dom": "^2.0.0",
 				"@radix-ui/react-arrow": "1.1.7",
@@ -2637,6 +2663,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
 			"integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-primitive": "2.1.3",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -2661,6 +2688,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
 			"integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -2685,6 +2713,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
 			"integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-slot": "1.2.3"
 			},
@@ -2776,6 +2805,7 @@
 			"resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
 			"integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"loose-envify": "^1.1.0"
 			}
@@ -2927,13 +2957,15 @@
 			"version": "1.1.3",
 			"resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
 			"integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/@radix-ui/react-compose-refs": {
 			"version": "1.1.2",
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz",
 			"integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==",
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"@types/react": "*",
 				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -2949,6 +2981,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz",
 			"integrity": "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==",
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"@types/react": "*",
 				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -2964,6 +2997,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz",
 			"integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==",
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"@types/react": "*",
 				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -2979,6 +3013,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz",
 			"integrity": "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-use-layout-effect": "1.1.1"
 			},
@@ -2997,6 +3032,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
 			"integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-compose-refs": "1.1.2"
 			},
@@ -3015,6 +3051,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
 			"integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"@types/react": "*",
 				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -3030,6 +3067,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
 			"integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-use-effect-event": "0.0.2",
 				"@radix-ui/react-use-layout-effect": "1.1.1"
@@ -3049,6 +3087,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
 			"integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-use-layout-effect": "1.1.1"
 			},
@@ -3067,6 +3106,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
 			"integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-use-callback-ref": "1.1.1"
 			},
@@ -3085,6 +3125,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
 			"integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
 			"license": "MIT",
+			"peer": true,
 			"peerDependencies": {
 				"@types/react": "*",
 				"react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
@@ -3100,6 +3141,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
 			"integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/rect": "1.1.1"
 			},
@@ -3118,6 +3160,7 @@
 			"resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
 			"integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@radix-ui/react-use-layout-effect": "1.1.1"
 			},
@@ -3135,7 +3178,8 @@
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
 			"integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/@shikijs/core": {
 			"version": "3.22.0",
@@ -3796,7 +3840,6 @@
 			"resolved": "https://registry.npmjs.org/@types/node/-/node-25.2.3.tgz",
 			"integrity": "sha512-m0jEgYlYz+mDJZ2+F4v8D1AyQb+QzsNqRuI7xg1VQX/KlKS0qT9r1Mo16yo5F/MtifXFgaofIFsdFMox2SxIbQ==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -3881,7 +3924,6 @@
 			"resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
 			"integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"acorn": "bin/acorn"
 			},
@@ -3946,7 +3988,6 @@
 			"resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
 			"integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"fast-deep-equal": "^3.1.3",
 				"fast-uri": "^3.0.1",
@@ -4073,6 +4114,7 @@
 			"resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz",
 			"integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"tslib": "^2.0.0"
 			},
@@ -4084,7 +4126,8 @@
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/arkregex": {
 			"version": "0.0.3",
@@ -5181,7 +5224,8 @@
 			"version": "3.2.3",
 			"resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
 			"integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/data-uri-to-buffer": {
 			"version": "6.0.2",
@@ -5452,7 +5496,8 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
 			"integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/detect-port": {
 			"version": "1.5.1",
@@ -5485,8 +5530,7 @@
 			"version": "0.0.1312386",
 			"resolved": "https://registry.npmjs.org/devtools-protocol/-/devtools-protocol-0.0.1312386.tgz",
 			"integrity": "sha512-DPnhUXvmvKT2dFA/j7B+riVLUt9Q6RKJlcppojL5CoRywJJKLDYnRlw0gTFKfgDPHP5E04UoB71SxoJlVZy8FA==",
-			"license": "BSD-3-Clause",
-			"peer": true
+			"license": "BSD-3-Clause"
 		},
 		"node_modules/didyoumean": {
 			"version": "1.2.2",
@@ -6576,6 +6620,7 @@
 			"resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz",
 			"integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==",
 			"license": "MIT",
+			"peer": true,
 			"engines": {
 				"node": ">=6"
 			}
@@ -7310,7 +7355,6 @@
 			"resolved": "https://registry.npmjs.org/ink/-/ink-6.3.0.tgz",
 			"integrity": "sha512-2CbJAa7XeziZYe6pDS5RVLirRY28iSGMQuEV8jRU5NQsONQNfcR/BZHHc9vkMg2lGYTHTM2pskxC1YmY28p6bQ==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@alcalzone/ansi-tokenize": "^0.2.0",
 				"ansi-escapes": "^7.0.0",
@@ -8090,7 +8134,6 @@
 			"resolved": "https://registry.npmjs.org/jsep/-/jsep-1.4.0.tgz",
 			"integrity": "sha512-B7qPcEVE3NVkmSJbaYxvv4cHkVW7DQsZz13pUMrfS8z8Q/BuShN+gcTXrUlPiGqM2/t/EEaI030bpxMqY8gMlw==",
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">= 10.16.0"
 			}
@@ -8246,6 +8289,7 @@
 			"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
 			"integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"js-tokens": "^3.0.0 || ^4.0.0"
 			},
@@ -10140,7 +10184,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"nanoid": "^3.3.11",
 				"picocolors": "^1.1.1",
@@ -10516,7 +10559,6 @@
 			"resolved": "https://registry.npmjs.org/react/-/react-19.2.3.tgz",
 			"integrity": "sha512-Ku/hhYbVjOQnXDZFv2+RibmLFGwFdeeKHFcOTlrt7xplBnya5OGn/hIRDsqDiSUcfORsDC7MPxwork8jBwsIWA==",
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=0.10.0"
 			}
@@ -10541,6 +10583,7 @@
 			"resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.2.tgz",
 			"integrity": "sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"react-remove-scroll-bar": "^2.3.7",
 				"react-style-singleton": "^2.2.3",
@@ -10566,6 +10609,7 @@
 			"resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz",
 			"integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"react-style-singleton": "^2.2.2",
 				"tslib": "^2.0.0"
@@ -10587,19 +10631,22 @@
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/react-remove-scroll/node_modules/tslib": {
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/react-style-singleton": {
 			"version": "2.2.3",
 			"resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz",
 			"integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"get-nonce": "^1.0.0",
 				"tslib": "^2.0.0"
@@ -10621,7 +10668,8 @@
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/read-cache": {
 			"version": "1.0.0",
@@ -12173,7 +12221,6 @@
 			"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
 			"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -12427,7 +12474,6 @@
 			"resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
 			"integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@types/unist": "^3.0.0",
 				"bail": "^2.0.0",
@@ -12654,6 +12700,7 @@
 			"resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz",
 			"integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"tslib": "^2.0.0"
 			},
@@ -12674,13 +12721,15 @@
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/use-sidecar": {
 			"version": "1.1.3",
 			"resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz",
 			"integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"detect-node-es": "^1.1.0",
 				"tslib": "^2.0.0"
@@ -12702,7 +12751,8 @@
 			"version": "2.8.1",
 			"resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
 			"integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-			"license": "0BSD"
+			"license": "0BSD",
+			"peer": true
 		},
 		"node_modules/util-deprecate": {
 			"version": "1.0.2",
@@ -13200,7 +13250,6 @@
 			"resolved": "https://registry.npmjs.org/zod/-/zod-3.21.4.tgz",
 			"integrity": "sha512-m46AKbrzKVzOzs/DZgVnG5H55N1sv1M8qZU3A8RIKbs3mrACDNeIOeilDymVb2HdmP8uwshOCF4uJ8uM9rCqJw==",
 			"license": "MIT",
-			"peer": true,
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
 			}

docs/troubleshooting/terminal-quick-fixes.mdx

@@ -4,38 +4,38 @@ sidebarTitle: "Terminal Quick Fixes"
 description: "Quick solutions for common terminal issues"
 ---
 
-## Try This First: Background Execution Mode
+## Try This First: Background Execution
 
-The simplest fix for most terminal issues is switching to **Background Execution Mode**:
+The simplest fix for most terminal issues is switching to **Background Execution**:
 
 1. Click **Settings** (top right of Cline chat)
 2. Go to **Terminal Settings**
 3. Set **Terminal Execution Mode** → **Background Exec**
 
-This runs commands in a background process instead of VSCode's terminal, bypassing most integration issues.
+This runs commands in a background process instead of VS Code's integrated terminal, bypassing most integration issues.
 
 ---
 
 ## Other Fixes
 
-If you need VSCode's integrated terminal, try these:
+If you still need VS Code's integrated terminal fallback, try these compatibility fixes:
 
 -   **Switch to bash** (solves most instances)
 
     1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
     2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Navigate to **"Default Terminal Profile"** and select **"bash"** from the drop-down
+    3. Navigate to **"Default Terminal Profile (terminal fallback)"** and select **"bash"** from the drop-down
 
 -   **Increase timeout**
 
     1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
     2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Navigate to "Shell integration timeout (seconds)" and enter **"10"** into the text field
+    3. Navigate to "Shell integration timeout for terminal fallback (seconds)" and enter **"10"** into the text field
 
 -   **Disable terminal reuse**
     1. Within Cline, left-click the **Settings** button in the top right-hand corner of the chat window
     2. Once in the **Settings** window, left-click the **"Terminal Settings"** tab from the left-hand column
-    3. Look for **"Enable aggressive terminal reuse"**, and **uncheck** this option
+    3. Look for **"Enable aggressive terminal reuse for terminal fallback"**, and **uncheck** this option
 
 ## Platform-Specific Fixes
 

evals/package-lock.json

@@ -9,7 +9,7 @@
 			"version": "2.0.0",
 			"license": "MIT",
 			"dependencies": {
-				"axios": "^1.12.0",
+				"axios": "1.13.6",
 				"better-sqlite3": "^12.4.1",
 				"chalk": "5.6.2",
 				"commander": "^9.4.1",
@@ -135,16 +135,17 @@
 		"node_modules/asynckit": {
 			"version": "0.4.0",
 			"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
-			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+			"license": "MIT"
 		},
 		"node_modules/axios": {
-			"version": "1.12.2",
-			"resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
-			"integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+			"version": "1.13.6",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.13.6.tgz",
+			"integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==",
 			"license": "MIT",
 			"dependencies": {
-				"follow-redirects": "^1.15.6",
-				"form-data": "^4.0.4",
+				"follow-redirects": "^1.15.11",
+				"form-data": "^4.0.5",
 				"proxy-from-env": "^1.1.0"
 			}
 		},
@@ -226,6 +227,7 @@
 			"version": "1.0.2",
 			"resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
 			"integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+			"license": "MIT",
 			"dependencies": {
 				"es-errors": "^1.3.0",
 				"function-bind": "^1.1.2"
@@ -256,6 +258,7 @@
 			"version": "1.0.8",
 			"resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
 			"integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+			"license": "MIT",
 			"dependencies": {
 				"delayed-stream": "~1.0.0"
 			},
@@ -303,6 +306,7 @@
 			"version": "1.0.0",
 			"resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
 			"integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+			"license": "MIT",
 			"engines": {
 				"node": ">=0.4.0"
 			}
@@ -339,6 +343,7 @@
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
 			"integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+			"license": "MIT",
 			"dependencies": {
 				"call-bind-apply-helpers": "^1.0.1",
 				"es-errors": "^1.3.0",
@@ -360,6 +365,7 @@
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
 			"integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4"
 			}
@@ -368,6 +374,7 @@
 			"version": "1.3.0",
 			"resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
 			"integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4"
 			}
@@ -376,6 +383,7 @@
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
 			"integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+			"license": "MIT",
 			"dependencies": {
 				"es-errors": "^1.3.0"
 			},
@@ -387,6 +395,7 @@
 			"version": "2.1.0",
 			"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
 			"integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+			"license": "MIT",
 			"dependencies": {
 				"es-errors": "^1.3.0",
 				"get-intrinsic": "^1.2.6",
@@ -411,15 +420,16 @@
 			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="
 		},
 		"node_modules/follow-redirects": {
-			"version": "1.15.9",
-			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
-			"integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+			"version": "1.15.11",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+			"integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
 			"funding": [
 				{
 					"type": "individual",
 					"url": "https://github.com/sponsors/RubenVerborgh"
 				}
 			],
+			"license": "MIT",
 			"engines": {
 				"node": ">=4.0"
 			},
@@ -430,9 +440,9 @@
 			}
 		},
 		"node_modules/form-data": {
-			"version": "4.0.4",
-			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
-			"integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+			"version": "4.0.5",
+			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+			"integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
 			"license": "MIT",
 			"dependencies": {
 				"asynckit": "^0.4.0",
@@ -455,6 +465,7 @@
 			"version": "1.1.2",
 			"resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
 			"integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+			"license": "MIT",
 			"funding": {
 				"url": "https://github.com/sponsors/ljharb"
 			}
@@ -463,6 +474,7 @@
 			"version": "1.3.0",
 			"resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
 			"integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+			"license": "MIT",
 			"dependencies": {
 				"call-bind-apply-helpers": "^1.0.2",
 				"es-define-property": "^1.0.1",
@@ -486,6 +498,7 @@
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
 			"integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+			"license": "MIT",
 			"dependencies": {
 				"dunder-proto": "^1.0.1",
 				"es-object-atoms": "^1.0.0"
@@ -503,6 +516,7 @@
 			"version": "1.2.0",
 			"resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
 			"integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4"
 			},
@@ -514,6 +528,7 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
 			"integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4"
 			},
@@ -525,6 +540,7 @@
 			"version": "1.0.2",
 			"resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
 			"integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+			"license": "MIT",
 			"dependencies": {
 				"has-symbols": "^1.0.3"
 			},
@@ -539,6 +555,7 @@
 			"version": "2.0.2",
 			"resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
 			"integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+			"license": "MIT",
 			"dependencies": {
 				"function-bind": "^1.1.2"
 			},
@@ -585,6 +602,7 @@
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
 			"integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.4"
 			}
@@ -593,6 +611,7 @@
 			"version": "1.52.0",
 			"resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
 			"integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+			"license": "MIT",
 			"engines": {
 				"node": ">= 0.6"
 			}
@@ -601,6 +620,7 @@
 			"version": "2.1.35",
 			"resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
 			"integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+			"license": "MIT",
 			"dependencies": {
 				"mime-db": "1.52.0"
 			},
@@ -1044,12 +1064,12 @@
 			"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
 		},
 		"axios": {
-			"version": "1.12.2",
-			"resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz",
-			"integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==",
+			"version": "1.13.6",
+			"resolved": "https://registry.npmjs.org/axios/-/axios-1.13.6.tgz",
+			"integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==",
 			"requires": {
-				"follow-redirects": "^1.15.6",
-				"form-data": "^4.0.4",
+				"follow-redirects": "^1.15.11",
+				"form-data": "^4.0.5",
 				"proxy-from-env": "^1.1.0"
 			}
 		},
@@ -1224,14 +1244,14 @@
 			"integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="
 		},
 		"follow-redirects": {
-			"version": "1.15.9",
-			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
-			"integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ=="
+			"version": "1.15.11",
+			"resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+			"integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ=="
 		},
 		"form-data": {
-			"version": "4.0.4",
-			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
-			"integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
+			"version": "4.0.5",
+			"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+			"integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
 			"requires": {
 				"asynckit": "^0.4.0",
 				"combined-stream": "^1.0.8",

evals/package.json

@@ -8,7 +8,7 @@
 	},
 	"license": "MIT",
 	"dependencies": {
-		"axios": "^1.12.0",
+		"axios": "1.13.6",
 		"better-sqlite3": "^12.4.1",
 		"chalk": "5.6.2",
 		"commander": "^9.4.1",

go.work.sum

@@ -1,39 +0,0 @@
-cel.dev/expr v0.24.0/go.mod h1:hLPLo1W4QUmuYdA72RBX06QTs6MXw941piREPl3Yfiw=
-cloud.google.com/go/compute/metadata v0.7.0/go.mod h1:j5MvL9PprKL39t166CoB1uVHfQMs4tFQZZcKwksXUjo=
-github.com/GoogleCloudPlatform/opentelemetry-operations-go/detectors/gcp v1.29.0/go.mod h1:Cz6ft6Dkn3Et6l2v2a9/RpN7epQ1GtDlO6lj8bEcOvw=
-github.com/bits-and-blooms/bitset v1.22.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/charmbracelet/harmonica v0.2.0/go.mod h1:KSri/1RMQOZLbw7AHqgcBycp8pgJnQMYYT8QZRqZ1Ao=
-github.com/cncf/xds/go v0.0.0-20250501225837-2ac532fd4443/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8=
-github.com/envoyproxy/go-control-plane v0.13.4/go.mod h1:kDfuBlDVsSj2MjrLEtRWtHlsWIFcGyB2RMO44Dc5GZA=
-github.com/envoyproxy/go-control-plane/envoy v1.32.4/go.mod h1:Gzjc5k8JcJswLjAx1Zm+wSYE20UrLtt7JZMWiWQXQEw=
-github.com/envoyproxy/go-control-plane/ratelimit v0.1.0/go.mod h1:Wk+tMFAFbCXaJPzVVHnPgRKdUdwW/KdbRt94AzgRee4=
-github.com/envoyproxy/protoc-gen-validate v1.2.1/go.mod h1:d/C80l/jxXLdfEIhX1W2TmLfsJ31lvEjwamM4DxlWXU=
-github.com/go-jose/go-jose/v4 v4.1.1/go.mod h1:BdsZGqgdO3b6tTc6LSE56wcDbMMLuPsw5d4ZD5f94kA=
-github.com/golang/glog v1.2.5/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8=
-github.com/klauspost/cpuid/v2 v2.2.3/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
-github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
-github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
-github.com/spiffe/go-spiffe/v2 v2.5.0/go.mod h1:P+NxobPc6wXhVtINNtFjNWGBTreew1GBUCwT2wPmb7g=
-github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4=
-go.opentelemetry.io/contrib/detectors/gcp v1.36.0/go.mod h1:IbBN8uAIIx734PTonTPxAxnjc2pQTxWNkwfstZ+6H2k=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
-google.golang.org/genproto/googleapis/api v0.0.0-20250707201910-8d1bb00bc6a7/go.mod h1:kXqgZtrWaf6qS3jZOCnCH7WYfrvFjkC51bM8fz3RsCA=
-lukechampine.com/uint128 v1.3.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk=
-modernc.org/cc/v3 v3.41.0/go.mod h1:Ni4zjJYJ04CDOhG7dn640WGfwBzfE0ecX8TyMB0Fv0Y=
-modernc.org/ccgo/v3 v3.16.15/go.mod h1:yT7B+/E2m43tmMOT51GMoM98/MtHIcQQSleGnddkUNI=
-modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM=
-modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0=
-modernc.org/strutil v1.2.0/go.mod h1:/mdcBmfOibveCTBxUl5B5l6W+TTH1FXPLHZE6bTosX0=
-modernc.org/tcl v1.15.2/go.mod h1:3+k/ZaEbKrC8ePv8zJWPtBSW0V7Gg9g8rkmhI1Kfs3c=
-modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
-modernc.org/z v1.7.3/go.mod h1:Ipv4tsdxZRbQyLq9Q1M6gdbkxYzdlrciF2Hi/lS7nWE=

migration.md

@@ -0,0 +1,267 @@
+# SDK Migration — Plan & Status
+
+Living implementation plan for migrating Cline to the ClineCore SDK.
+This document shrinks as work completes and is deleted when the
+migration is done.
+
+## Related Documents
+
+- **[ARCHITECTURE.md](ARCHITECTURE.md)** — Evergreen: features,
+  design decisions, research findings, architecture diagrams, SDK
+  capabilities, test strategy, QA guide.
+- **[CAVEATS.md](CAVEATS.md)** — Known issues and bugs found during
+  migration work. Check here before investigating a problem.
+- **[DEBUG-HARNESS.md](DEBUG-HARNESS.md)** — E2E debugging tool for
+  the VSCode extension (breakpoints, expression eval, UI automation).
+  See also `.clinerules/debug-harness.md` for quick reference and
+  `src/dev/debug-harness/README.md` for full API docs.
+
+---
+
+## Decisions
+
+- **Webview**: Keep the existing webview-ui codebase. Replace
+  gRPC-over-postMessage with typed JSON messages. Do NOT build a
+  new UI from scratch.
+
+- **Session persistence**: Custom `SessionPersistenceAdapter` over
+  existing JSON task history (`~/.cline/data/tasks/`). No SQLite.
+
+- **Task history**: Continue existing JSON format. New and old
+  sessions intermixed seamlessly.
+
+- **JetBrains sidecar**: New lightweight Node.js entry point using
+  JSON-RPC over stdio. Shares SDK adapter layer with VSCode.
+
+- **SDK packaging**: Published npm packages. `npm link` for local
+  development.
+
+- **Rollout**: VSCode first (from a branch). JetBrains last.
+
+- **Breaking changes**: Avoid. Only new on-disk formats where
+  strongly justified.
+
+---
+
+## Retrospective: What Went Wrong on `sdk-migration-port-check`
+
+The branch deleted ~138K lines (classic core) before having a working
+replacement, created stub webview components instead of adapting the
+existing ones, had zero tests for the new adapter layer, and provided
+no agent-accessible debugging. The result was 595 TypeScript errors
+and a non-functional extension.
+
+**Lessons:**
+- Don't create stub UI components. Adapt the existing webview by
+  making the backend speak its language.
+- Define and test the interface contract first.
+- Build observability before building features.
+
+---
+
+## What Remains to Be Done
+
+**Phase 2 (current):** Cut over webview from gRPC to typed messages,
+delete proto code. See Phase 2 details below.
+
+**Phase 3:** Delete classic core (`src/core/`, `src/standalone/`,
+`proto/cline/`, `src/generated/`). See "What Gets Deleted" below.
+
+**Phase 4:** JetBrains sidecar (JSON-RPC over stdio).
+
+**Phase 5:** Enterprise features (remote config, SSO, team controls),
+P1 features (checkpoints, MCP marketplace).
+
+## What Gets Deleted
+
+1. `src/core/task/` → `@clinebot/agents`
+2. `src/core/controller/` → SDK adapter layer
+3. `src/core/api/` → `@clinebot/llms`
+4. `src/core/prompts/system-prompt/` → SDK's prompt generation
+5. `src/services/mcp/McpHub.ts` → SDK MCP manager
+6. `src/standalone/` → SDK sidecar
+7. `proto/cline/*.proto` → typed message protocol
+8. `src/shared/proto-conversions/`, `src/generated/`
+9. Browser automation, IDE terminal, shadow git, memory bank,
+   focus chain, deep planning, workflows
+
+---
+
+## Implementation Plan
+
+### Phase 0: Preparation & Cleanup ✅
+
+Done. Deprecated features removed (browser automation, shadow git,
+focus chain, deep planning, `/reportbug`). SDK npm dependencies
+added.
+
+### Phase 1: VSCode Extension Backend ✅
+
+Done. SDK adapter layer implemented in `src/sdk/` with 234 tests
+passing across 10 test files:
+
+| Module | Tests | Description |
+|--------|-------|-------------|
+| `legacy-state-reader` | 42 | Reads `~/.cline/data/` settings |
+| `message-translator` | 50 | SDK events → ClineMessage[] |
+| `state-builder` | 29 | Controller state → ExtensionState |
+| `grpc-handler` | 26 | gRPC compat layer for webview |
+| `sdk-controller` | 25 | Full controller integration |
+| `inbound-handler` | 18 | Typed message routing |
+| `extension-sdk-smoke` | 13 | Extension entry point |
+| `provider-migration` | 11 | Credential migration |
+| `sdk-foundation` | 5 | SDK imports, test infra |
+| `webview-bridge` | 15 | SDK events → webview pushes |
+
+End-to-end verified: Cline/Anthropic inference works, Ollama
+local inference works, settings persist across restarts, task
+completion and "Start New Task" flow works.
+
+### Phase 2: Webview Simplification (current)
+
+Replace gRPC-over-postMessage with typed JSON messages. The typed
+message infrastructure is in place; the remaining work is to cut
+over from gRPC and delete the proto code.
+
+**Key architectural detail:** The webview has ~228 gRPC `ServiceClient`
+call sites across ~40 components. These all flow through `grpc-handler.ts`
+(`src/sdk/grpc-handler.ts`), which acts as a compatibility shim:
+
+```
+Webview → ServiceClient.method() → postMessage → grpc-handler.ts → SdkController → SDK
+```
+
+The grpc-handler currently has **~15 real implementations** (newTask,
+askResponse, clearTask, getTaskHistory, updateApiConfiguration, etc.)
+and **~130 stubbed methods** that return `{ data: {} }` — silent no-ops.
+Most open bugs (issues #8–#13 in CAVEATS.md) are caused by these stubs.
+The stubbed methods now log `[grpc-handler] STUB: <method>` to help
+identify which calls need real implementations.
+
+**Done:**
+- Typed message protocol (`src/shared/WebviewMessages.ts`)
+- WebviewBridge (`src/sdk/webview-bridge.ts`)
+- InboundMessageHandler (`src/sdk/inbound-handler.ts`)
+- Typed client (`webview-ui/src/services/typed-client.ts`)
+- Dual-listen pattern in `ExtensionStateContext.tsx`
+
+**Remaining:**
+- Wire up remaining stubbed gRPC methods in `grpc-handler.ts` (see CAVEATS.md
+  for priority list; use `[grpc-handler] STUB:` log to find which
+  methods each feature needs)
+- Remove gRPC subscriptions from webview (use typed messages only)
+- Delete `proto/cline/*.proto`, `src/shared/proto-conversions/`,
+  `src/generated/`
+- Remove proto build steps from `package.json`
+- Simplify/remove obsolete settings UI (see below)
+
+**Recently completed:**
+- ✅ **Cline OAuth login flow**: The "Sign up with Cline" button now performs
+  proper OAuth using the SDK's `loginClineOAuth()` API. Previously it just
+  opened `https://app.cline.bot/login` and hoped credentials would appear
+  on disk. Now it:
+  - Spawns a local callback server (ports 48801-48811)
+  - Opens the authorization URL in the browser
+  - Captures the redirect with authorization code
+  - Exchanges code for access/refresh tokens
+  - Saves credentials to `~/.cline/data/secrets.json`
+  
+  Implementation in `src/sdk/SdkController.ts` (`performClineOAuth()`),
+  `src/sdk/legacy-state-reader.ts` (`writeClineAuthInfo()`), and
+  `src/sdk/grpc-handler.ts` (delegates to controller).
+
+#### Terminal Settings — Radical Simplification Needed
+
+The SDK uses **background terminal execution** (`backgroundExec`)
+instead of the VSCode integrated terminal. The entire terminal
+settings page (`webview-ui/src/components/settings/sections/TerminalSettingsSection.tsx`)
+is built around integrated terminal concerns that no longer apply:
+
+| Current Setting | Status | Reason |
+|----------------|--------|--------|
+| Default Terminal Profile dropdown | **Remove** | Background exec doesn't use VSCode terminal profiles; the SDK runs commands via `child_process` |
+| Shell integration timeout | **Remove** | Shell integration is a VSCode terminal feature; background exec doesn't use it |
+| Enable aggressive terminal reuse | **Remove** | Terminal window reuse is a VSCode terminal concept |
+| Terminal Execution Mode (VSCode/Background) | **Remove** | There's only one mode now — background exec |
+| Terminal Output Line Limit slider | **Keep** | Still relevant for controlling how much output is captured/displayed |
+| Terminal troubleshooting links | **Remove** | Links to VSCode terminal troubleshooting docs |
+
+**Action:** Replace `TerminalSettingsSection` with a minimal section
+containing only the output line limit slider (and any future
+background-exec-specific settings like working directory, env vars,
+etc.). The `getAvailableTerminalProfiles` gRPC handler, the
+`TerminalProfile` proto messages, and `src/utils/shell.ts` terminal
+profile detection can all be deleted.
+
+Related files to remove/simplify:
+- `webview-ui/src/components/settings/sections/TerminalSettingsSection.tsx`
+- `src/utils/shell.ts` (terminal profile functions)
+- `src/core/controller/state/getAvailableTerminalProfiles.ts`
+- `proto/cline/state.proto` → `TerminalProfile`, `TerminalProfiles` messages
+- `src/sdk/grpc-handler.ts` → `handleGetAvailableTerminalProfiles()`
+- State keys: `defaultTerminalProfile`, `terminalReuseEnabled`,
+  `shellIntegrationTimeout`, `vscodeTerminalExecutionMode`,
+  `availableTerminalProfiles`
+
+### Phase 3: Delete Classic Core
+
+Remove `src/core/task/`, `src/core/controller/`, `src/core/api/`,
+`src/core/prompts/system-prompt/`, `src/services/mcp/McpHub.ts`,
+`src/standalone/`. Clean up `src/shared/`. Full test suite green.
+
+### Phase 4: JetBrains Migration
+
+SDK-based sidecar with JSON-RPC over stdio. See ARCHITECTURE.md
+"JetBrains IPC Design" for details.
+
+### Phase 5: Polish & Enterprise
+
+Enterprise features, checkpoint system (kanban-style git refs),
+MCP Marketplace, final cleanup.
+
+---
+
+## Risk Assessment
+
+| Risk | Mitigation |
+|------|------------|
+| Webview big-bang breaks everything | Work on branch; classic continues on main |
+| SDK tool behavior differs from classic | E2E tests before/after |
+| Provider migration loses credentials | SDK has migration code + tests; sentinel file |
+| Legacy sessions not resumable | Custom SessionPersistenceAdapter preserves format |
+| JetBrains sidecar complexity | Defer to Phase 4; get VSCode solid first |
+| SDK missing a feature | PRs to SDK repo; `npm link` for quick iteration |
+
+---
+
+## Implementation Checklist
+
+```
+Phase 0 — Preparation ✅
+Phase 1 — VSCode Backend (SDK Adapter) ✅ (234 tests passing)
+
+Phase 2 — Webview Simplification (current)
+  [x] Typed message protocol (WebviewMessages.ts)
+  [x] WebviewBridge + tests
+  [x] InboundMessageHandler + tests
+  [x] Dual-listen pattern in ExtensionStateContext
+  [ ] Simplify TerminalSettingsSection (remove integrated terminal settings, keep output limit)
+  [ ] Remove gRPC subscriptions from webview
+  [ ] Delete proto/cline/*.proto, proto-conversions, generated code
+  [ ] Remove proto build steps from package.json
+
+Phase 3 — Delete Classic Core
+  [ ] Remove src/core/task, controller, api, prompts
+  [ ] Remove src/standalone
+  [ ] Clean up src/shared
+  [ ] Full test suite green
+
+Phase 4 — JetBrains
+  [ ] SDK sidecar with JSON-RPC over stdio
+  [ ] Kotlin plugin changes
+
+Phase 5 — Polish & Enterprise
+  [ ] Enterprise features
+  [ ] P1 features (checkpoints, MCP marketplace)
+  [ ] Final cleanup
+```

package.json

@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "3.76.0",
+	"version": "3.77.0",
 	"icon": "assets/icons/icon.png",
 	"workspaces": [
 		".",
@@ -421,6 +421,8 @@
 		"test": "npx npm-run-all test:unit test:integration",
 		"test:integration": "vscode-test",
 		"test:unit": "cross-env TS_NODE_PROJECT=./tsconfig.unit-test.json mocha",
+		"test:sdk": "vitest run --config vitest.config.sdk.ts",
+		"test:sdk:watch": "vitest --config vitest.config.sdk.ts",
 		"test:coverage": "vscode-test --coverage",
 		"test:sca-server": "npx tsx watch scripts/test-standalone-core-api-server.ts",
 		"test:tp-orchestrator": "npx tsx scripts/testing-platform-orchestrator.ts",
@@ -503,7 +505,8 @@
 		"ts-node": "^10.9.2",
 		"ts-proto": "^2.6.1",
 		"tsconfig-paths": "^4.2.0",
-		"typescript": "^5.4.5"
+		"typescript": "^5.4.5",
+		"vitest": "^4.1.2"
 	},
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.37.0",
@@ -513,6 +516,10 @@
 		"@azure/identity": "^4.13.0",
 		"@bufbuild/protobuf": "^2.2.5",
 		"@cerebras/cerebras_cloud_sdk": "^1.35.0",
+		"@clinebot/agents": "^0.0.28",
+		"@clinebot/core": "^0.0.28",
+		"@clinebot/llms": "^0.0.28",
+		"@clinebot/shared": "^0.0.28",
 		"@google-cloud/vertexai": "^1.9.3",
 		"@google/genai": "^1.30.0",
 		"@grpc/grpc-js": "^1.9.15",
@@ -548,7 +555,7 @@
 		"@vscode/codicons": "^0.0.36",
 		"archiver": "^7.0.1",
 		"aws4fetch": "^1.0.20",
-		"axios": "^1.12.0",
+		"axios": "1.13.6",
 		"better-sqlite3": "^12.4.1",
 		"cheerio": "^1.0.0",
 		"chokidar": "^4.0.1",

proto/cline/account.proto

@@ -53,6 +53,10 @@ service AccountService {
 
   // Signs out of OpenAI Codex and clears stored credentials
   rpc openAiCodexSignOut(EmptyRequest) returns (Empty);
+
+  // Submits a spend limit increase request to the user's org admin.
+  // Called when the user hits a SPEND_LIMIT_EXCEEDED (429) error and clicks "Request Increase".
+  rpc submitLimitIncreaseRequest(EmptyRequest) returns (SubmitLimitIncreaseResponse);
 }
 
 message AuthStateChangedRequest {
@@ -125,6 +129,11 @@ message UsageTransaction {
   string operation = 13;
 }
 
+// Response from a spend limit increase request submission
+message SubmitLimitIncreaseResponse {
+  bool success = 1;
+}
+
 message PaymentTransaction {
   string paid_at = 1;
   string creator_id = 2;

proto/cline/file.proto

@@ -67,9 +67,6 @@ service FileService {
   // Open a file in editor by a relative path
   rpc openFileRelativePath(StringRequest) returns (Empty);
 
-  // Opens or creates a focus chain checklist markdown file for editing
-  rpc openFocusChainFile(StringRequest) returns (Empty);
-
   // Refreshes all hook toggles (discovers hooks and their enabled state)
   rpc refreshHooks(EmptyRequest) returns (HooksToggles);
 

proto/cline/slash.proto

@@ -11,7 +11,6 @@ option java_package = "bot.cline.proto";
 // SlashService provides methods for managing slash commands
 service SlashService {
   // Sends button click message
-  rpc reportBug(StringRequest) returns (Empty);
   rpc condense(StringRequest) returns (Empty);
 
   // Get available slash commands for autocomplete (used by CLI)

proto/cline/state.proto

@@ -286,6 +286,7 @@ message Settings {
   optional string act_mode_cline_model_id = 180;
   optional OpenRouterModelInfo act_mode_cline_model_info = 181;
   optional bool show_feature_tips = 182;
+  optional bool lazy_teammate_mode_enabled = 183;
 }
 
 message State {
@@ -428,6 +429,7 @@ message UpdateSettingsRequest {
   optional bool worktrees_enabled = 40;
   optional bool double_check_completion_enabled = 41;
   optional bool show_feature_tips = 42;
+  optional bool lazy_teammate_mode_enabled = 43;
 }
 
 message UpdateTerminalConnectionTimeoutRequest {

scripts/download-ripgrep.mjs

@@ -44,7 +44,7 @@ const PLATFORMS = [
 		isZip: false,
 	},
 	{
-		name: "linux-arm64",
+		name: "linux-aarch64",
 		archiveName: `ripgrep-${RIPGREP_VERSION}-aarch64-unknown-linux-gnu.tar.gz`,
 		url: `https://github.com/BurntSushi/ripgrep/releases/download/${RIPGREP_VERSION}/ripgrep-${RIPGREP_VERSION}-aarch64-unknown-linux-gnu.tar.gz`,
 		binaryPath: "rg",

scripts/package-standalone.mjs

@@ -22,6 +22,7 @@ const TARGET_PLATFORMS = [
 	{ platform: "darwin", arch: "x64", targetDir: "darwin-x64" },
 	{ platform: "darwin", arch: "arm64", targetDir: "darwin-arm64" },
 	{ platform: "linux", arch: "x64", targetDir: "linux-x64" },
+	{ platform: "linux", arch: "arm64", targetDir: "linux-aarch64" },
 ]
 const SUPPORTED_BINARY_MODULES = ["better-sqlite3"]
 

src/core/assistant-message/index.ts

@@ -54,6 +54,8 @@ export const toolParamNames = [
 	"prompt_3",
 	"prompt_4",
 	"prompt_5",
+	"start_line",
+	"end_line",
 ] as const
 
 export type ToolParamName = (typeof toolParamNames)[number]

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

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

src/core/context/instructions/user-instructions/workflows.ts

@@ -1,32 +1,7 @@
-import { synchronizeRuleToggles } from "@core/context/instructions/user-instructions/rule-helpers"
-import { ensureWorkflowsDirectoryExists, GlobalFileNames } from "@core/storage/disk"
-import { ClineRulesToggles } from "@shared/cline-rules"
-import path from "path"
-import { Controller } from "@/core/controller"
+// Workflows have been removed. Stub for compilation compatibility.
+import type { ClineRulesToggles } from "@shared/cline-rules"
 
-/**
- * Refresh the workflow toggles
- */
-export async function refreshWorkflowToggles(
-	controller: Controller,
-	workingDirectory: string,
-): Promise<{
-	globalWorkflowToggles: ClineRulesToggles
-	localWorkflowToggles: ClineRulesToggles
-}> {
-	// Global workflows
-	const globalWorkflowToggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles")
-	const globalClineWorkflowsFilePath = await ensureWorkflowsDirectoryExists()
-	const updatedGlobalWorkflowToggles = await synchronizeRuleToggles(globalClineWorkflowsFilePath, globalWorkflowToggles)
-	controller.stateManager.setGlobalState("globalWorkflowToggles", updatedGlobalWorkflowToggles)
-
-	const workflowRulesToggles = controller.stateManager.getWorkspaceStateKey("workflowToggles")
-	const workflowsDirPath = path.resolve(workingDirectory, GlobalFileNames.workflows)
-	const updatedWorkflowToggles = await synchronizeRuleToggles(workflowsDirPath, workflowRulesToggles)
-	controller.stateManager.setWorkspaceState("workflowToggles", updatedWorkflowToggles)
-
-	return {
-		globalWorkflowToggles: updatedGlobalWorkflowToggles,
-		localWorkflowToggles: updatedWorkflowToggles,
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function refreshWorkflowToggles(_controller: any, _cwd: string): Promise<{ localWorkflowToggles: ClineRulesToggles; globalWorkflowToggles: ClineRulesToggles }> {
+	return { localWorkflowToggles: {}, globalWorkflowToggles: {} }
 }

src/core/controller/account/submitLimitIncreaseRequest.ts

@@ -0,0 +1,28 @@
+import { SubmitLimitIncreaseResponse } from "@shared/proto/cline/account"
+import type { EmptyRequest } from "@shared/proto/cline/common"
+import { Logger } from "@/shared/services/Logger"
+import type { Controller } from "../index"
+
+/**
+ * Submits a spend limit increase request to the user's org admin.
+ * Called when the user clicks "Request Increase" on the SpendLimitError component.
+ * @param controller The controller instance
+ * @param _request Empty request
+ * @returns SubmitLimitIncreaseResponse indicating success or failure
+ */
+export async function submitLimitIncreaseRequest(
+	controller: Controller,
+	_request: EmptyRequest,
+): Promise<SubmitLimitIncreaseResponse> {
+	try {
+		if (!controller.accountService) {
+			throw new Error("Account service not available")
+		}
+
+		await controller.accountService.submitLimitIncreaseRequestRPC()
+		return SubmitLimitIncreaseResponse.create({ success: true })
+	} catch (error) {
+		Logger.error(`Failed to submit limit increase request: ${error}`)
+		throw error
+	}
+}

src/core/controller/browser/discoverBrowser.ts

@@ -1,45 +1,7 @@
-import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { BrowserConnection } from "@shared/proto/cline/browser"
-import { EmptyRequest } from "@shared/proto/cline/common"
+// Browser automation has been removed. Stub for generated protobus compatibility.
 import { Controller } from "../index"
 
-/**
- * Discover Chrome instances
- * @param controller The controller instance
- * @param request The request message
- * @returns The browser connection result
- */
-export async function discoverBrowser(controller: Controller, _request: EmptyRequest): Promise<BrowserConnection> {
-	try {
-		const discoveredHost = await discoverChromeInstances()
-
-		if (discoveredHost) {
-			// Don't update the remoteBrowserHost state when auto-discovering
-			// This way we don't override the user's preference
-
-			// Test the connection to get the endpoint
-			const browserSession = new BrowserSession(controller.stateManager)
-			const result = await browserSession.testConnection(discoveredHost)
-
-			return BrowserConnection.create({
-				success: true,
-				message: `Successfully discovered and connected to Chrome at ${discoveredHost}`,
-				endpoint: result.endpoint || "",
-			})
-		} else {
-			return BrowserConnection.create({
-				success: false,
-				message:
-					"No Chrome instances found. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
-				endpoint: "",
-			})
-		}
-	} catch (error) {
-		return BrowserConnection.create({
-			success: false,
-			message: `Error discovering browser: ${error instanceof Error ? error.message : String(error)}`,
-			endpoint: "",
-		})
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function discoverBrowser(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Browser automation has been removed")
 }

src/core/controller/browser/getBrowserConnectionInfo.ts

@@ -1,47 +1,7 @@
-import { BrowserConnectionInfo } from "@shared/proto/cline/browser"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { Logger } from "@/shared/services/Logger"
+// Browser automation has been removed. Stub for generated protobus compatibility.
 import { Controller } from "../index"
 
-/**
- * Get information about the current browser connection
- * @param controller The controller instance
- * @param request The request message
- * @returns The browser connection info
- */
-export async function getBrowserConnectionInfo(controller: Controller, _: EmptyRequest): Promise<BrowserConnectionInfo> {
-	try {
-		// Get browser settings from extension state
-		const browserSettings = controller.stateManager.getGlobalSettingsKey("browserSettings")
-
-		// Check if there's an active browser session by using the controller's handleWebviewMessage approach
-		// This is similar to what's done in controller/index.ts for the "getBrowserConnectionInfo" message
-		if (controller.task?.browserSession) {
-			// Access the browser session through the controller's task property
-			// Using indexer notation to access private property
-			const browserSession = controller.task.browserSession
-			const connectionInfo = browserSession.getConnectionInfo()
-
-			// Convert from BrowserSession.BrowserConnectionInfo to proto.BrowserConnectionInfo
-			return BrowserConnectionInfo.create({
-				isConnected: connectionInfo.isConnected,
-				isRemote: connectionInfo.isRemote,
-				host: connectionInfo.host || "", // Ensure host is never undefined
-			})
-		}
-
-		// Fallback to browser settings if no active browser session
-		return BrowserConnectionInfo.create({
-			isConnected: false,
-			isRemote: !!browserSettings.remoteBrowserEnabled,
-			host: browserSettings.remoteBrowserHost || "",
-		})
-	} catch (error: unknown) {
-		Logger.error("Error getting browser connection info:", error)
-		return BrowserConnectionInfo.create({
-			isConnected: false,
-			isRemote: false,
-			host: "",
-		})
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function getBrowserConnectionInfo(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Browser automation has been removed")
 }

src/core/controller/browser/getDetectedChromePath.ts

@@ -1,29 +1,7 @@
-import { ChromePath } from "@shared/proto/cline/browser"
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { Logger } from "@/shared/services/Logger"
-import { BrowserSession } from "../../../services/browser/BrowserSession"
+// Browser automation has been removed. Stub for generated protobus compatibility.
 import { Controller } from "../index"
 
-/**
- * Get the detected Chrome executable path
- * @param controller The controller instance
- * @param request The empty request message
- * @returns The detected Chrome path and whether it's bundled
- */
-export async function getDetectedChromePath(controller: Controller, _: EmptyRequest): Promise<ChromePath> {
-	try {
-		const browserSession = new BrowserSession(controller.stateManager)
-		const result = await browserSession.getDetectedChromePath()
-
-		return ChromePath.create({
-			path: result.path,
-			isBundled: result.isBundled,
-		})
-	} catch (error) {
-		Logger.error("Error getting detected Chrome path:", error)
-		return ChromePath.create({
-			path: "",
-			isBundled: false,
-		})
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function getDetectedChromePath(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Browser automation has been removed")
 }

src/core/controller/browser/relaunchChromeDebugMode.ts

@@ -1,24 +1,7 @@
-import { EmptyRequest, String as StringMessage } from "@shared/proto/cline/common"
-import { BrowserSession } from "../../../services/browser/BrowserSession"
+// Browser automation has been removed. Stub for generated protobus compatibility.
 import { Controller } from "../index"
 
-/**
- * Relaunch Chrome in debug mode
- * @param controller The controller instance
- * @param request The empty request message
- * @returns The browser relaunch result as a string message
- */
-export async function relaunchChromeDebugMode(controller: Controller, _: EmptyRequest): Promise<StringMessage> {
-	try {
-		const browserSession = new BrowserSession(controller.stateManager)
-
-		// Relaunch Chrome in debug mode
-		await browserSession.relaunchChromeDebugMode(controller)
-
-		// The actual result will be sent via the ProtoBus in the BrowserSession.relaunchChromeDebugMode method
-		// Here we just return a message as a placeholder
-		return { value: "Chrome relaunch initiated" }
-	} catch (error) {
-		throw new Error(`Error relaunching Chrome: ${error instanceof Error ? error.message : globalThis.String(error)}`)
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function relaunchChromeDebugMode(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Browser automation has been removed")
 }

src/core/controller/browser/testBrowserConnection.ts

@@ -1,61 +1,7 @@
-import { discoverChromeInstances } from "@services/browser/BrowserDiscovery"
-import { BrowserSession } from "@services/browser/BrowserSession"
-import { BrowserConnection } from "@shared/proto/cline/browser"
-import { StringRequest } from "@shared/proto/cline/common"
+// Browser automation has been removed. Stub for generated protobus compatibility.
 import { Controller } from "../index"
 
-/**
- * Test connection to a browser instance
- * @param controller The controller instance
- * @param request The request message
- * @returns The browser connection result
- */
-export async function testBrowserConnection(controller: Controller, request: StringRequest): Promise<BrowserConnection> {
-	try {
-		const browserSession = new BrowserSession(controller.stateManager)
-		const text = request.value || ""
-
-		// If no text is provided, try auto-discovery
-		if (!text) {
-			try {
-				const discoveredHost = await discoverChromeInstances()
-				if (discoveredHost) {
-					// Test the connection to the discovered host
-					const result = await browserSession.testConnection(discoveredHost)
-					return BrowserConnection.create({
-						success: result.success,
-						message: `Auto-discovered and tested connection to Chrome at ${discoveredHost}: ${result.message}`,
-						endpoint: result.endpoint || "",
-					})
-				} else {
-					return BrowserConnection.create({
-						success: false,
-						message:
-							"No Chrome instances found on the network. Make sure Chrome is running with remote debugging enabled (--remote-debugging-port=9222).",
-						endpoint: "",
-					})
-				}
-			} catch (error) {
-				return BrowserConnection.create({
-					success: false,
-					message: `Error during auto-discovery: ${error instanceof Error ? error.message : String(error)}`,
-					endpoint: "",
-				})
-			}
-		} else {
-			// Test the provided URL
-			const result = await browserSession.testConnection(text)
-			return BrowserConnection.create({
-				success: result.success,
-				message: result.message,
-				endpoint: result.endpoint || "",
-			})
-		}
-	} catch (error) {
-		return BrowserConnection.create({
-			success: false,
-			message: `Error testing connection: ${error instanceof Error ? error.message : String(error)}`,
-			endpoint: "",
-		})
-	}
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function testBrowserConnection(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Browser automation has been removed")
 }

src/core/controller/checkpoints/getCwdHash.ts

@@ -1,8 +1,12 @@
 import { PathHashMap } from "@shared/proto/cline/checkpoints"
 import { StringArrayRequest } from "@shared/proto/cline/common"
-import { hashWorkingDir } from "@/integrations/checkpoints/CheckpointUtils"
+import crypto from "crypto"
 import { Controller } from ".."
 
+function hashWorkingDir(dir: string): string {
+	return crypto.createHash("sha256").update(dir).digest("hex").slice(0, 16)
+}
+
 export async function getCwdHash(_controller: Controller, request: StringArrayRequest): Promise<PathHashMap> {
 	const pathHash: Record<string, string> = {}
 

src/core/controller/file/createRuleFile.ts

@@ -2,7 +2,6 @@ import { refreshClineRulesToggles } from "@core/context/instructions/user-instru
 import { createRuleFile as createRuleFileImpl } from "@core/context/instructions/user-instructions/rule-helpers"
 import { getWorkspaceBasename } from "@core/workspace"
 import { RuleFile, RuleFileRequest } from "@shared/proto/cline/file"
-import { refreshWorkflowToggles } from "@/core/context/instructions/user-instructions/workflows"
 import { HostProvider } from "@/hosts/host-provider"
 import { ShowMessageType } from "@/shared/proto/host/window"
 import { Logger } from "@/shared/services/Logger"
@@ -52,7 +51,6 @@ export async function createRuleFile(controller: Controller, request: RuleFileRe
 		await openFile(controller, { value: filePath })
 	} else {
 		if (request.type === "workflow") {
-			await refreshWorkflowToggles(controller, cwd)
 		} else {
 			await refreshClineRulesToggles(controller, cwd)
 		}

src/core/controller/file/openFocusChainFile.ts

@@ -1,40 +0,0 @@
-import { openFile as openFileIntegration } from "@integrations/misc/open-file"
-import { telemetryService } from "../../../services/telemetry"
-import { Empty, StringRequest } from "../../../shared/proto/cline/common"
-import { ensureFocusChainFile, extractFocusChainListFromText } from "../../task/focus-chain/file-utils"
-import { Controller } from ".."
-
-/**
- * Opens or creates a focus chain checklist markdown file for editing
- * The file is stored at <globalStorage>/tasks/<taskId>/focus_chain_taskid_<taskId>.md
- */
-export async function openFocusChainFile(controller: Controller, request: StringRequest): Promise<Empty> {
-	if (!request.value) {
-		throw new Error("Task ID is required")
-	}
-
-	const taskId = request.value
-
-	// Get the current focus chain list from the task's most recent task_progress message
-	let initialFocusChainContent: string | undefined
-	const currentTask = controller.task
-	if (currentTask) {
-		// Get the task's message history and find the most recent task_progress message
-		// TODO - can we decouple this from ClineMessages?
-		const clineMessages = currentTask.messageStateHandler.getClineMessages()
-		const lastProgressMessage = clineMessages
-			.slice()
-			.reverse()
-			.find((m) => m.say === "task_progress")
-
-		if (lastProgressMessage && lastProgressMessage.text) {
-			initialFocusChainContent = extractFocusChainListFromText(lastProgressMessage.text) || undefined
-		}
-	}
-
-	const focusChainFilePath = await ensureFocusChainFile(taskId, initialFocusChainContent)
-	telemetryService.captureFocusChainListOpened(taskId)
-	await openFileIntegration(focusChainFilePath)
-
-	return Empty.create()
-}

src/core/controller/file/refreshRules.ts

@@ -1,6 +1,5 @@
 import { refreshClineRulesToggles } from "@core/context/instructions/user-instructions/cline-rules"
 import { refreshExternalRulesToggles } from "@core/context/instructions/user-instructions/external-rules"
-import { refreshWorkflowToggles } from "@core/context/instructions/user-instructions/workflows"
 import { EmptyRequest } from "@shared/proto/cline/common"
 import { RefreshedRules } from "@shared/proto/cline/file"
 import { Logger } from "@/shared/services/Logger"
@@ -21,7 +20,6 @@ export async function refreshRules(controller: Controller, _request: EmptyReques
 			controller,
 			cwd,
 		)
-		const { localWorkflowToggles, globalWorkflowToggles } = await refreshWorkflowToggles(controller, cwd)
 
 		return RefreshedRules.create({
 			globalClineRulesToggles: { toggles: globalToggles },
@@ -29,8 +27,8 @@ export async function refreshRules(controller: Controller, _request: EmptyReques
 			localCursorRulesToggles: { toggles: cursorLocalToggles },
 			localWindsurfRulesToggles: { toggles: windsurfLocalToggles },
 			localAgentsRulesToggles: { toggles: agentsLocalToggles },
-			localWorkflowToggles: { toggles: localWorkflowToggles },
-			globalWorkflowToggles: { toggles: globalWorkflowToggles },
+			localWorkflowToggles: { toggles: {} },
+			globalWorkflowToggles: { toggles: {} },
 		})
 	} catch (error) {
 		Logger.error("Failed to refresh rules:", error)

src/core/controller/file/toggleWorkflow.ts

@@ -1,53 +1,7 @@
-import { ClineRulesToggles, RuleScope, ToggleWorkflowRequest } from "@shared/proto/cline/file"
-import { Logger } from "@/shared/services/Logger"
-import { Controller } from ".."
+// Workflows have been removed. Stub for generated protobus compatibility.
+import { Controller } from "../index"
 
-/**
- * Toggles a workflow on or off
- * @param controller The controller instance
- * @param request The request containing the workflow path and enabled state
- * @returns The updated workflow toggles
- */
-export async function toggleWorkflow(controller: Controller, request: ToggleWorkflowRequest): Promise<ClineRulesToggles> {
-	const { workflowPath, enabled, scope } = request
-
-	if (!workflowPath || typeof enabled !== "boolean" || scope === undefined) {
-		Logger.error("toggleWorkflow: Missing or invalid parameters", {
-			workflowPath,
-			scope,
-			enabled: typeof enabled === "boolean" ? enabled : `Invalid: ${typeof enabled}`,
-		})
-		throw new Error("Missing or invalid parameters for toggleWorkflow")
-	}
-
-	// Handle the three different scopes
-	let toggles: Record<string, boolean>
-
-	switch (scope) {
-		case RuleScope.GLOBAL: {
-			toggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles")
-			toggles[workflowPath] = enabled
-			controller.stateManager.setGlobalState("globalWorkflowToggles", toggles)
-			break
-		}
-		case RuleScope.LOCAL: {
-			toggles = controller.stateManager.getWorkspaceStateKey("workflowToggles")
-			toggles[workflowPath] = enabled
-			controller.stateManager.setWorkspaceState("workflowToggles", toggles)
-			break
-		}
-		case RuleScope.REMOTE: {
-			toggles = controller.stateManager.getGlobalStateKey("remoteWorkflowToggles")
-			toggles[workflowPath] = enabled
-			controller.stateManager.setGlobalState("remoteWorkflowToggles", toggles)
-			break
-		}
-		default:
-			throw new Error(`Invalid scope: ${scope}`)
-	}
-
-	await controller.postStateToWebview()
-
-	// Return the updated toggles
-	return ClineRulesToggles.create({ toggles: toggles })
+// biome-ignore lint/suspicious/noExplicitAny: stub for removed feature
+export async function toggleWorkflow(_controller: Controller, _request: any): Promise<any> {
+	throw new Error("Workflows have been removed")
 }

src/core/controller/index.ts

@@ -1,3 +1,4 @@
+import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
 import type { Anthropic } from "@anthropic-ai/sdk"
 import { buildApiHandler } from "@core/api"
 import { getHooksEnabledSafe } from "@core/hooks/hooks-utils"
@@ -5,7 +6,6 @@ import { tryAcquireTaskLockWithRetry } from "@core/task/TaskLockUtils"
 import { detectWorkspaceRoots } from "@core/workspace/detection"
 import { setupWorkspaceManager } from "@core/workspace/setup"
 import type { WorkspaceRootManager } from "@core/workspace/WorkspaceRootManager"
-import { cleanupLegacyCheckpoints } from "@integrations/checkpoints/CheckpointMigration"
 import { ClineAccountService } from "@services/account/ClineAccountService"
 import { McpHub } from "@services/mcp/McpHub"
 import type { ApiProvider, ModelInfo } from "@shared/api"
@@ -887,6 +887,7 @@ export class Controller {
 		const lastDismissedCliBannerVersion = this.stateManager.getGlobalStateKey("lastDismissedCliBannerVersion") || 0
 		const dismissedBanners = this.stateManager.getGlobalStateKey("dismissedBanners")
 		const doubleCheckCompletionEnabled = this.stateManager.getGlobalSettingsKey("doubleCheckCompletionEnabled")
+		const lazyTeammateModeEnabled = this.stateManager.getGlobalSettingsKey("lazyTeammateModeEnabled")
 		const showFeatureTips = this.stateManager.getGlobalSettingsKey("showFeatureTips")
 
 		const localClineRulesToggles = this.stateManager.getWorkspaceStateKey("localClineRulesToggles")
@@ -998,6 +999,7 @@ export class Controller {
 			backgroundEditEnabled: this.stateManager.getGlobalSettingsKey("backgroundEditEnabled"),
 			optOutOfRemoteConfig: this.stateManager.getGlobalSettingsKey("optOutOfRemoteConfig"),
 			doubleCheckCompletionEnabled,
+			lazyTeammateModeEnabled,
 			showFeatureTips,
 			banners,
 			welcomeBanners,

src/core/controller/slash/reportBug.ts

@@ -1,10 +0,0 @@
-import { Empty, StringRequest } from "@shared/proto/cline/common"
-import { Controller } from ".."
-
-/**
- * Report bug slash command logic
- */
-export async function reportBug(controller: Controller, _request: StringRequest): Promise<Empty> {
-	await controller.task?.handleWebviewAskResponse("yesButtonClicked")
-	return Empty.create()
-}

src/core/controller/state/updateSettings.ts

@@ -193,22 +193,14 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 
 		// Update focus chain settings
 		if (request.focusChainSettings !== undefined) {
-			{
-				const currentSettings = controller.stateManager.getGlobalSettingsKey("focusChainSettings")
-				const wasEnabled = currentSettings?.enabled ?? false
-				const isEnabled = request.focusChainSettings.enabled
+			const currentSettings = controller.stateManager.getGlobalSettingsKey("focusChainSettings")
 
-				const focusChainSettings = {
-					enabled: isEnabled,
-					remindClineInterval: request.focusChainSettings.remindClineInterval,
-				}
-				controller.stateManager.setGlobalState("focusChainSettings", focusChainSettings)
-
-				// Capture telemetry when setting changes
-				if (wasEnabled !== isEnabled) {
-					telemetryService.captureFocusChainToggle(isEnabled)
-				}
-			}
+			// Legacy compatibility only: preserve the stored shape without allowing new writes
+			// to re-activate Focus Chain behavior or emit fresh telemetry.
+			controller.stateManager.setGlobalState("focusChainSettings", {
+				enabled: currentSettings?.enabled ?? false,
+				remindClineInterval: currentSettings?.remindClineInterval ?? request.focusChainSettings.remindClineInterval,
+			})
 		}
 
 		// Update custom prompt choice
@@ -344,6 +336,10 @@ export async function updateSettings(controller: Controller, request: UpdateSett
 			controller.stateManager.setGlobalState("doubleCheckCompletionEnabled", request.doubleCheckCompletionEnabled)
 		}
 
+		if (request.lazyTeammateModeEnabled !== undefined) {
+			controller.stateManager.setGlobalState("lazyTeammateModeEnabled", request.lazyTeammateModeEnabled)
+		}
+
 		if (request.showFeatureTips !== undefined) {
 			controller.stateManager.setGlobalState("showFeatureTips", request.showFeatureTips)
 		}

src/core/controller/state/updateSettingsCli.ts

@@ -177,19 +177,13 @@ export async function updateSettingsCli(controller: Controller, request: UpdateS
 			// Update focus chain settings (requires telemetry on state change)
 			if (focusChainSettings !== undefined) {
 				const currentSettings = controller.stateManager.getGlobalSettingsKey("focusChainSettings")
-				const wasEnabled = currentSettings?.enabled ?? false
-				const isEnabled = focusChainSettings.enabled
 
-				const newFocusChainSettings = {
-					enabled: isEnabled,
-					remindClineInterval: focusChainSettings.remindClineInterval,
-				}
-				controller.stateManager.setGlobalState("focusChainSettings", newFocusChainSettings)
-
-				// Capture telemetry when setting changes
-				if (wasEnabled !== isEnabled) {
-					telemetryService.captureFocusChainToggle(isEnabled)
-				}
+				// Legacy compatibility only: keep the stored value shape intact without letting
+				// incoming writes toggle active Focus Chain behavior or generate new telemetry.
+				controller.stateManager.setGlobalState("focusChainSettings", {
+					enabled: currentSettings?.enabled ?? false,
+					remindClineInterval: currentSettings?.remindClineInterval ?? focusChainSettings.remindClineInterval,
+				})
 			}
 
 			// Update browser settings (requires careful merging to avoid protobuf defaults)

src/core/controller/task/explainChanges.ts

@@ -1,4 +1,4 @@
-import CheckpointTracker from "@integrations/checkpoints/CheckpointTracker"
+import { CheckpointTracker } from "@integrations/checkpoints/CheckpointTracker"
 import { findLast } from "@shared/array"
 import { Empty } from "@shared/proto/cline/common"
 import { ExplainChangesRequest } from "@shared/proto/cline/task"

src/core/controller/ui/subscribeToAddToInput.ts

@@ -34,11 +34,13 @@ export async function subscribeToAddToInput(
 }
 
 /**
- * Send an addToInput event to all active subscribers
+ * Send an addToInput event to all active subscribers.
+ * Falls back to the SDK bridge if no classic gRPC subscriptions are active
+ * (SDK mode uses typed messages instead of gRPC streaming subscriptions).
  * @param text The text to add to the input
  */
 export async function sendAddToInputEvent(text: string): Promise<void> {
-	// Send the event to all active subscribers
+	// Send the event to all active classic gRPC subscribers
 	const promises = Array.from(activeAddToInputSubscriptions).map(async (responseStream) => {
 		try {
 			const event: ProtoString = {
@@ -56,4 +58,19 @@ export async function sendAddToInputEvent(text: string): Promise<void> {
 	})
 
 	await Promise.all(promises)
+
+	// Fallback: if no classic subscriptions are active, try the SDK bridge.
+	// In SDK mode, the webview subscribes via typed messages, not gRPC streams,
+	// so activeAddToInputSubscriptions is empty. The SDK bridge sends a typed
+	// "addToInput" message that the webview's dual-listen pattern picks up.
+	if (activeAddToInputSubscriptions.size === 0) {
+		const bridge = (globalThis as any).__sdkBridge
+		if (bridge && typeof bridge.pushAddToInput === "function") {
+			try {
+				bridge.pushAddToInput(text)
+			} catch (error) {
+				Logger.error("Error sending addToInput via SDK bridge:", error)
+			}
+		}
+	}
 }

src/core/controller/worktree/deleteWorktree.ts

@@ -1,3 +1,4 @@
+import { hashWorkingDir } from "@/integrations/checkpoints/CheckpointUtils"
 import { DeleteWorktreeRequest, WorktreeResult } from "@shared/proto/cline/worktree"
 import { deleteWorktree as deleteWorktreeUtil } from "@utils/git-worktree"
 import { getWorkspacePath } from "@utils/path"
@@ -5,7 +6,6 @@ import { rm } from "fs/promises"
 import path from "path"
 import simpleGit from "simple-git"
 import { HostProvider } from "@/hosts/host-provider"
-import { hashWorkingDir } from "@/integrations/checkpoints/CheckpointUtils"
 import { Logger } from "@/shared/services/Logger"
 import { Controller } from ".."
 

src/core/prompts/commands.ts

@@ -1,6 +1,3 @@
-import type { ApiProviderInfo } from "@/core/api"
-import { getDeepPlanningPrompt } from "./commands/deep-planning"
-
 export const newTaskToolResponse = (willUseNativeTools: boolean) => {
 	const xmlExample = `
 Example:
@@ -75,20 +72,16 @@ Parameters:
   4. Relevant Files and Code: If applicable, enumerate specific files and code sections examined, modified, or created for the task continuation. Pay special attention to the most recent messages and changes.
   5. Problem Solving: Document problems solved thus far and any ongoing troubleshooting efforts.
   6. Pending Tasks and Next Steps: Outline all pending tasks that you have explicitly been asked to work on, as well as list the next steps you will take for all outstanding work, if applicable. Include code snippets where they add clarity. For any next steps, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no information loss in context between tasks.
-${
-	focusChainSettings?.enabled
-		? `- task_progress: (required) The current state of the task_progress list, with completed items marked. Important information on this parameter is as follows:
+${`- task_progress: (optional, but required if a task_progress list is already in use) The current state of the task_progress list, with completed items marked. Important information on this parameter is as follows:
   1. XML schema matches that of prior task_progress lists.
   2. All items are retained, with the exact same desciptive content as in prior occurences.
   3. All completed items are marked as completed.
-  4. The only compenent of this list that can be changed is the completion state of invidiual items in the list`
-		: ""
-}
+  4. The only compenent of this list that can be changed is the completion state of invidiual items in the list`}
 
 Usage:
 <condense>
 <context>Your detailed summary</context>
-${focusChainSettings?.enabled ? `<task_progress>task_progress list here</task_progress>` : ""}
+<task_progress>task_progress list here (include only if one already exists)</task_progress>
 </condense>
 
 Example:
@@ -122,16 +115,12 @@ Example:
   - [Task 2 details & next steps]
   - [...]
 </context>
-${
-	focusChainSettings?.enabled
-		? `<task_progress>
+${`<task_progress>
 - [x] Set up project structure
 - [x] Install dependencies
 - [ ] Create components
 - [ ] Test application
-</task_progress>`
-		: ""
-}
+</task_progress>`}
 </condense>
 
 </explicit_instructions>\n
@@ -195,37 +184,6 @@ Below is the user's input when they indicated that they wanted to create a new C
 </explicit_instructions>\n
 `
 
-export const reportBugToolResponse = () =>
-	`<explicit_instructions type="report_bug">
-The user has explicitly asked you to help them submit a bug to the Cline github page (you MUST now help them with this irrespective of what your conversation up to this point in time was). To do so you will use the report_bug tool which is defined below. However, you must first ensure that you have collected all required information to fill in all the parameters for the tool call. If any of the the required information is apparent through your previous conversation with the user, you can suggest how to fill in those entries. However you should NOT assume you know what the issue about unless it's clear.
-Otherwise, you should converse with the user until you are able to gather all the required details. When conversing with the user, make sure you ask for/reference all required information/fields. When referencing the required fields, use human friendly versions like "Steps to reproduce" rather than "steps_to_reproduce". Only then should you use the report_bug tool call.
-The report_bug tool can be used in either of the PLAN or ACT modes.
-
-The report_bug tool call is defined below:
-
-Description:
-Your task is to fill in all of the required fields for a issue/bug report on github. You should attempt to get the user to be as verbose as possible with their description of the bug/issue they encountered. Still, it's okay, when the user is unaware of some of the details, to set those fields as "N/A".
-
-Parameters:
-- title: (required) Concise description of the issue.
-- what_happened: (required) What happened and also what the user expected to happen instead.
-- steps_to_reproduce: (required) What steps are required to reproduce the bug.
-- api_request_output: (optional) Relevant API request output.
-- additional_context: (optional) Any other context about this bug not already mentioned.
-
-Usage:
-<report_bug>
-<title>Title of the issue</title>
-<what_happened>Description of the issue</what_happened>
-<steps_to_reproduce>Steps to reproduce the issue</steps_to_reproduce>
-<api_request_output>Output from the LLM API related to the bug</api_request_output>
-<additional_context>Other issue details not already covered</additional_context>
-</report_bug>
-
-Below is the user's input when they indicated that they wanted to submit a Github issue.
-</explicit_instructions>\n
-`
-
 export const explainChangesToolResponse = () =>
 	`<explicit_instructions type="explain_changes">
 The user has asked you to explain code changes. You have access to a tool called **generate_explanation** that opens a multi-file diff view with AI-generated inline comments explaining code changes between two git references.
@@ -303,18 +261,3 @@ Use the generate_explanation tool with:
 Below is the user's input describing what changes they want explained. If no input is provided, default to analyzing uncommitted changes in the working directory (may or may not be staged).
 </explicit_instructions>\n
 `
-
-/**
- * Generates the deep-planning slash command response with model-family-aware variant selection
- * @param focusChainSettings Optional focus chain settings to include in the prompt
- * @param providerInfo Optional API provider info for model family detection
- * @param enableNativeToolCalls Optional flag to determine if native tool calling is enabled
- * @returns The deep-planning prompt string with appropriate variant and focus chain settings applied
- */
-export const deepPlanningToolResponse = (
-	focusChainSettings?: { enabled: boolean },
-	providerInfo?: ApiProviderInfo,
-	enableNativeToolCalls?: boolean,
-) => {
-	return getDeepPlanningPrompt(focusChainSettings, providerInfo, enableNativeToolCalls)
-}

src/core/prompts/commands/deep-planning/index.ts

@@ -1,88 +0,0 @@
-import type { ApiProviderInfo } from "@/core/api"
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-import { getDeepPlanningRegistry } from "./registry"
-import { generateGemini3Template } from "./variants/gemini3"
-import { generateGPT51Template } from "./variants/gpt51"
-
-const focusChainIntro: string = `**Task Progress Parameter:**
-When creating the new task, you must include a task_progress parameter that breaks down the implementation into trackable steps. This parameter should be included inside the tool call, but not located inside of other content/argument blocks. This should follow the standard Markdown checklist format with "- [ ]" for incomplete items.`
-
-/**
- * Generates the deep-planning slash command response with model-family-aware variant selection
- * @param focusChainSettings Optional focus chain settings to include in the prompt
- * @param providerInfo Optional API provider info for model family detection
- * @param enableNativeToolCalls Optional flag to determine if native tool calling is enabled
- * @returns The deep-planning prompt string with appropriate variant and focus chain settings applied
- */
-export function getDeepPlanningPrompt(
-	focusChainSettings?: { enabled: boolean },
-	providerInfo?: ApiProviderInfo,
-	enableNativeToolCalls?: boolean,
-): string {
-	// Create context for variant selection
-	const context: SystemPromptContext = {
-		providerInfo: providerInfo || ({} as ApiProviderInfo),
-		ide: "vscode",
-	}
-
-	// Get the appropriate variant from registry
-	const registry = getDeepPlanningRegistry()
-	const variant = registry.get(context)
-	const newTaskInstructions = generateNewTaskInstructions(enableNativeToolCalls ?? false)
-	const focusChainParam = focusChainSettings?.enabled ? focusChainIntro : ""
-
-	// For variants with extensive focus chain prompting, generate template with focus chain flag
-	let template: string
-	if (variant.id === "gpt-51") {
-		template = generateGPT51Template(focusChainSettings?.enabled ?? false, enableNativeToolCalls ?? false)
-	} else if (variant.id === "gemini-3") {
-		template = generateGemini3Template(focusChainSettings?.enabled ?? false, enableNativeToolCalls ?? false)
-	} else {
-		template = variant.template
-		template = template.replace("{{FOCUS_CHAIN_PARAM}}", focusChainParam)
-		template = template.replace("{{NEW_TASK_INSTRUCTIONS}}", newTaskInstructions)
-	}
-
-	return template
-}
-
-/**
- * Generates the new_task tool instructions based on whether native tool calling is enabled
- * @param enableNativeToolCalls Whether native tool calling is enabled
- * @returns The new_task tool instructions string
- */
-function generateNewTaskInstructions(enableNativeToolCalls: boolean): string {
-	if (enableNativeToolCalls) {
-		return `
-**new_task Tool Definition:**
-
-When you are ready to create the implementation task, you must call the new_task tool with the following structure:
-
-\`\`\`json
-{
-  "name": "new_task",
-  "arguments": {
-    "context": "Your detailed context here following the 5-point structure..."
-  }
-}
-\`\`\`
-
-The context parameter should include all five sections as described above.`
-	} else {
-		return `
-**new_task Tool Definition:**
-
-When you are ready to create the implementation task, you must call the new_task tool with the following structure:
-
-\`\`\`xml
-<new_task>
-<context>Your detailed context here following the 5-point structure...</context>
-</new_task>
-\`\`\`
-
-The context parameter should include all five sections as described above.`
-	}
-}
-
-// Export types for external use
-export type { DeepPlanningRegistry, DeepPlanningVariant } from "./types"

src/core/prompts/commands/deep-planning/registry.ts

@@ -1,100 +0,0 @@
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-import { Logger } from "@/shared/services/Logger"
-import type { DeepPlanningVariant, DeepPlanningRegistry as IDeepPlanningRegistry } from "./types"
-import {
-	createAnthropicVariant,
-	createGemini3Variant,
-	createGeminiVariant,
-	createGenericVariant,
-	createGPT51Variant,
-} from "./variants"
-
-/**
- * Singleton registry for managing deep-planning prompt variants
- * Selects appropriate variant based on model family detection
- */
-class DeepPlanningRegistry implements IDeepPlanningRegistry {
-	private static instance: DeepPlanningRegistry | null = null
-	private variants: Map<string, DeepPlanningVariant> = new Map()
-	private genericVariant: DeepPlanningVariant
-
-	private constructor() {
-		// Initialize all variants
-		this.registerVariant(createAnthropicVariant())
-		this.registerVariant(createGeminiVariant())
-		this.registerVariant(createGemini3Variant())
-		this.registerVariant(createGPT51Variant())
-
-		// Generic variant must be registered last as fallback
-		const genericVariant = createGenericVariant()
-		this.registerVariant(genericVariant)
-		this.genericVariant = genericVariant
-	}
-
-	/**
-	 * Get the singleton instance of the registry
-	 */
-	public static getInstance(): DeepPlanningRegistry {
-		if (!DeepPlanningRegistry.instance) {
-			DeepPlanningRegistry.instance = new DeepPlanningRegistry()
-		}
-		return DeepPlanningRegistry.instance
-	}
-
-	/**
-	 * Register a new variant in the registry
-	 */
-	public register(variant: DeepPlanningVariant): void {
-		this.registerVariant(variant)
-	}
-
-	/**
-	 * Internal method to register a variant
-	 */
-	private registerVariant(variant: DeepPlanningVariant): void {
-		this.variants.set(variant.id, variant)
-	}
-
-	/**
-	 * Get the appropriate variant based on the system prompt context
-	 * Uses matcher functions to determine which variant to use
-	 * Falls back to generic variant if no match or on error
-	 */
-	public get(context: SystemPromptContext): DeepPlanningVariant {
-		try {
-			// Try each variant's matcher function (except generic which is last)
-			for (const variant of this.variants.values()) {
-				// Skip generic variant in iteration (it's the fallback)
-				if (variant.id === "generic") {
-					continue
-				}
-
-				// Test if this variant matches the context
-				if (variant.matcher(context)) {
-					return variant
-				}
-			}
-
-			// No match found, return generic variant
-			return this.genericVariant
-		} catch (error) {
-			// On any error, safely fall back to generic variant
-			Logger.warn("Error selecting deep-planning variant, falling back to generic:", error)
-			return this.genericVariant
-		}
-	}
-
-	/**
-	 * Get all registered variants
-	 */
-	public getAll(): DeepPlanningVariant[] {
-		return Array.from(this.variants.values())
-	}
-}
-
-/**
- * Export singleton instance getter
- */
-export function getDeepPlanningRegistry(): DeepPlanningRegistry {
-	return DeepPlanningRegistry.getInstance()
-}

src/core/prompts/commands/deep-planning/types.ts

@@ -1,38 +0,0 @@
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-
-/**
- * Configuration for a deep-planning prompt variant
- */
-export interface DeepPlanningVariant {
-	/** Unique identifier for this variant (e.g., "anthropic", "gemini", "gpt-5", "generic") */
-	id: string
-
-	/** Human-readable description of this variant */
-	description: string
-
-	/** The model family this variant is designed for */
-	family: string
-
-	/** Version number for this variant */
-	version: number
-
-	/** Matcher function to determine if this variant should be used */
-	matcher: (context: SystemPromptContext) => boolean
-
-	/** The complete prompt template string */
-	template: string
-}
-
-/**
- * Registry for deep-planning prompt variants
- */
-export interface DeepPlanningRegistry {
-	/** Get the appropriate variant based on context */
-	get(context: SystemPromptContext): DeepPlanningVariant
-
-	/** Register a new variant */
-	register(variant: DeepPlanningVariant): void
-
-	/** Get all registered variants */
-	getAll(): DeepPlanningVariant[]
-}

src/core/prompts/commands/deep-planning/variants/anthropic.ts

@@ -1,277 +0,0 @@
-import { isAnthropicModelId } from "@utils/model-utils"
-import { getShell } from "@utils/shell"
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-import type { DeepPlanningVariant } from "../types"
-
-/**
- * Creates the Anthropic Claude variant for deep-planning prompt
- * This variant is optimized for Claude models
- */
-export function createAnthropicVariant(): DeepPlanningVariant {
-	return {
-		id: "anthropic",
-		description: "Deep-planning variant optimized for Anthropic Claude models",
-		family: "anthropic",
-		version: 1,
-		matcher: (context: SystemPromptContext) => {
-			const modelId = context.providerInfo?.model?.id
-			if (!modelId) {
-				return false
-			}
-			return isAnthropicModelId(modelId)
-		},
-		template: generateTemplate(),
-	}
-}
-
-/**
- * Generates the deep-planning template with shell-specific commands
- */
-function generateTemplate(): string {
-	const detectedShell = getShell()
-
-	// FIXME: detectedShell returns a non-string value on some Windows machines
-	let isPowerShell = false
-	try {
-		isPowerShell =
-			detectedShell != null &&
-			typeof detectedShell === "string" &&
-			(detectedShell.toLowerCase().includes("powershell") || detectedShell.toLowerCase().includes("pwsh"))
-	} catch {}
-
-	return `<explicit_instructions type="deep-planning">
-Your task is to create a comprehensive implementation plan before writing any code. This process has four distinct steps that must be completed in order.
-
-Your behavior should be methodical and thorough - take time to understand the codebase completely before making any recommendations. The quality of your investigation directly impacts the success of the implementation.
-
-## STEP 1: Silent Investigation
-
-<important>
-until explicitly instructed by the user to proceed with coding.
-You must thoroughly understand the existing codebase before proposing any changes.
-Perform your research without commentary or narration. Execute commands and read files without explaining what you're about to do. Only speak up if you have specific questions for the user.
-</important>
-
-### Required Research Activities
-You must use the read_file tool to examine relevant source files, configuration files, and documentation. You must use terminal commands to gather information about the codebase structure and patterns. All terminal output must be piped to cat for visibility.
-
-### Essential Terminal Commands
-First, determine the language(s) used in the codebase, then execute these commands to build your understanding. You must tailor them to the codebase and ensure the output is not overly verbose. For example, you should exclude dependency folders such as node_modules, venv or php vendor, etc. These are only examples, the exact commands will differ depending on the codebase.
-
-${
-	isPowerShell
-		? // PowerShell-specific commands
-
-			`# Discover project structure and file types
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-Object -First 30 | Select-Object FullName
-
-# Find all class and function definitions
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "class|function|def|interface|struct"
-
-# Analyze import patterns and dependencies
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp" | Select-String -Pattern "import|from|require|#include" | Sort-Object | Get-Unique
-
-# Find dependency manifests
-Get-ChildItem -Recurse -Include "requirements*.txt","package.json","Cargo.toml","pom.xml","Gemfile","go.mod" | Get-Content
-
-# Identify technical debt and TODOs
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "TODO|FIXME|XXX|HACK|NOTE"
-`
-		: // bash/zsh-specific commands
-			`# Discover project structure and file types
-find . -type f -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.java" -o -name "*.cpp" -o -name "*.go" | head -30 | cat
-
-# Find all class and function definitions
-grep -r "class\\|function\\|def\\|interface\\|struct\\|func\\|type.*struct\\|type.*interface" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-
-# Analyze import patterns and dependencies
-grep -r "import\\|from\\|require\\|#include" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" . | sort | uniq | cat
-
-# Find dependency manifests
-find . -name "requirements*.txt" -o -name "package.json" -o -name "Cargo.toml" -o -name "pom.xml" -o -name "Gemfile" -o -name "go.mod" | xargs cat
-
-# Identify technical debt and TODOs
-grep -r "TODO\\|FIXME\\|XXX\\|HACK\\|NOTE" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-`
-}
-
-
-## STEP 2: Discussion and Questions
-
-Ask the user brief, targeted questions that will influence your implementation plan. Keep your questions concise and conversational. Ask only essential questions needed to create an accurate plan.
-
-**Ask questions only when necessary for:**
-- Clarifying ambiguous requirements or specifications
-- Choosing between multiple equally valid implementation approaches  
-- Confirming assumptions about existing system behavior or constraints
-- Understanding preferences for specific technical decisions that will affect the implementation
-
-Your questions should be direct and specific. Avoid long explanations or multiple questions in one response.
-
-## STEP 3: Create Implementation Plan Document
-
-Create a structured markdown document containing your complete implementation plan. The document must follow this exact format with clearly marked sections:
-
-### Document Structure Requirements
-
-Your implementation plan must be saved as implementation_plan.md, and *must* be structured as follows:
-
-
-# Implementation Plan
-
-[Overview]
-Single sentence describing the overall goal.
-
-Multiple paragraphs outlining the scope, context, and high-level approach. Explain why this implementation is needed and how it fits into the existing system.
-
-[Types]  
-Single sentence describing the type system changes.
-
-Detailed type definitions, interfaces, enums, or data structures with complete specifications. Include field names, types, validation rules, and relationships.
-
-[Files]
-Single sentence describing file modifications.
-
-Detailed breakdown:
-- New files to be created (with full paths and purpose)
-- Existing files to be modified (with specific changes)  
-- Files to be deleted or moved
-- Configuration file updates
-
-[Functions]
-Single sentence describing function modifications.
-
-Detailed breakdown:
-- New functions (name, signature, file path, purpose)
-- Modified functions (exact name, current file path, required changes)
-- Removed functions (name, file path, reason, migration strategy)
-
-[Classes]
-Single sentence describing class modifications.
-
-Detailed breakdown:
-- New classes (name, file path, key methods, inheritance)
-- Modified classes (exact name, file path, specific modifications)
-- Removed classes (name, file path, replacement strategy)
-
-[Dependencies]
-Single sentence describing dependency modifications.
-
-Details of new packages, version changes, and integration requirements.
-
-[Testing]
-Single sentence describing testing approach.
-
-Test file requirements, existing test modifications, and validation strategies.
-
-[Implementation Order]
-Single sentence describing the implementation sequence.
-
-Numbered steps showing the logical order of changes to minimize conflicts and ensure successful integration.
-
-
-## STEP 4: Create Implementation Task
-
-Use the new_task command to create a task for implementing the plan. The task must include a <task_progress> list that breaks down the implementation into trackable steps.
-
-### Task Creation Requirements
-
-Your new task should be self-contained and reference the plan document rather than requiring additional codebase investigation. Include these specific instructions in the task description:
-
-**Plan Document Navigation Commands:**
-The implementation agent should use these commands to read specific sections of the implementation plan. You should adapt these examples to conform to the structure of the .md file you created, and explicitly provide them when creating the new task:
-
-${
-	isPowerShell
-		? `
-# Read Overview section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Overview\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Types\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Types section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Types\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Files\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Files section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Files\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Functions\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Functions section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Functions\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Classes\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Classes section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Classes\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Dependencies\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Dependencies section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Dependencies\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Testing\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Testing section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Testing\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Implementation Order\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Implementation Order section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Implementation Order\\]').LineNumber; $content[($start-1)..($content.Length-1)]
-`
-		: `
-# Read Overview section
-sed -n '/\\[Overview\\]/,/\\[Types\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Types section  
-sed -n '/\\[Types\\]/,/\\[Files\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Files section
-sed -n '/\\[Files\\]/,/\\[Functions\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Functions section
-sed -n '/\\[Functions\\]/,/\\[Classes\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Classes section
-sed -n '/\\[Classes\\]/,/\\[Dependencies\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Dependencies section
-sed -n '/\\[Dependencies\\]/,/\\[Testing\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Testing section
-sed -n '/\\[Testing\\]/,/\\[Implementation Order\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Implementation Order section
-sed -n '/\\[Implementation Order\\]/,$p' implementation_plan.md | cat
-`
-}
-
-
-**Task Progress Format:**
-<IMPORTANT>
-You absolutely must include the task_progress contents in context when creating the new task. When providing it, do not wrap it in XML tags- instead provide it like this:
-
-
-task_progress Items:
-- [ ] Step 1: Brief description of first implementation step
-- [ ] Step 2: Brief description of second implementation step  
-- [ ] Step 3: Brief description of third implementation step
-- [ ] Step N: Brief description of final implementation step
-
-
-You also MUST include the path to the markdown file you have created in your new task prompt. You should do this as follows:
-
-Refer to @path/to/file/markdown.md for a complete breakdown of the task requirements and steps. You should periodically read this file again.
-
-{{FOCUS_CHAIN_PARAM}}
-
-{{NEW_TASK_INSTRUCTIONS}}
-
-### Mode Switching
-
-When creating the new task, request a switch to "act mode" if you are currently in "plan mode". This ensures the implementation agent operates in execution mode rather than planning mode.
-</IMPORTANT>
-
-## Quality Standards
-
-You must be specific with exact file paths, function names, and class names. You must be comprehensive and avoid assuming implicit understanding. You must be practical and consider real-world constraints and edge cases. You must use precise technical language and avoid ambiguity.
-
-Your implementation plan should be detailed enough that another developer could execute it without additional investigation.
-
----
-
-**Execute all four steps in sequence. Your role is to plan thoroughly, not to implement. Code creation begins only after the new task is created and you receive explicit instruction to proceed.**
-
-Below is the user's input when they indicated that they wanted to create a comprehensive implementation plan.
-</explicit_instructions>
-`
-}

src/core/prompts/commands/deep-planning/variants/gemini.ts

@@ -1,285 +0,0 @@
-import { isGemini2dot5ModelFamily } from "@utils/model-utils"
-import { getShell } from "@utils/shell"
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-import type { DeepPlanningVariant } from "../types"
-
-/**
- * Creates the Google Gemini 2.5 variant for deep-planning prompt
- * This variant is optimized for Gemini 2.5 models
- */
-export function createGeminiVariant(): DeepPlanningVariant {
-	return {
-		id: "gemini",
-		description: "Deep-planning variant optimized for Google Gemini 2.5 models",
-		family: "gemini",
-		version: 1,
-		matcher: (context: SystemPromptContext) => {
-			const modelId = context.providerInfo?.model?.id
-			if (!modelId) {
-				return false
-			}
-			return isGemini2dot5ModelFamily(modelId)
-		},
-		template: generateTemplate(),
-	}
-}
-
-/**
- * Generates the deep-planning template with shell-specific commands
- */
-function generateTemplate(): string {
-	const detectedShell = getShell()
-
-	// FIXME: detectedShell returns a non-string value on some Windows machines
-	let isPowerShell = false
-	try {
-		isPowerShell =
-			detectedShell != null &&
-			typeof detectedShell === "string" &&
-			(detectedShell.toLowerCase().includes("powershell") || detectedShell.toLowerCase().includes("pwsh"))
-	} catch {}
-
-	return `<explicit_instructions type="deep-planning">
-Your task is to create a comprehensive implementation plan before writing any code. This process has four distinct steps that must be completed in order.
-
-Your behavior should be methodical and thorough - take time to understand the codebase completely before making any recommendations. The quality of your investigation directly impacts the success of the implementation.
-
-## STEP 1: Silent Investigation
-
-<important>
-until explicitly instructed by the user to proceed with coding.
-You must thoroughly understand the existing codebase before proposing any changes.
-Perform your research without commentary or narration. Execute commands and read files without explaining what you're about to do. Only speak up if you have specific questions for the user.
-</important>
-
-### Required Research Activities
-You must first use the read_file tool to examine several source files, configuration files, and documentation to better inform subsequent research steps. You should only use read_file to prepare for more granular searching. Use this tool to determine the language(s) used in the codebase, and to identify the domain(s) relevant to the user's request.
-
-You must then use terminal commands to gather information about the codebase structure and patterns relevant to the user's request. All terminal output must be piped to cat for visibility.
-You will tailor these commands to explore and identify key functions, classes, methods, types, and variables that are directly, or indirectly related to the task.
-These commands must be crafted to not produce exceptionally long or verbose search results. For example, you should exclude dependency folders such as node_modules, venv or php vendor, etc. Carefully consider the scope of search patterns. Use the results of your read_file tool calls to tailor the commands for balanced search result lengths. If a command returns no results, you may loosen the search patterns or scope slightly. If a command returns hundreds or thousands of results, you should adjust subsequent commands to be more targeted.
-
-Execute these commands to build your understanding. Adjust subsequent commands based on the output you have received from each previous command, informing the scope and direction of your search.
-
-Here are some example commands, remember to adjust them as instructed previously:
-
-${
-	isPowerShell
-		? // PowerShell-specific commands
-			`
-# Discover project structure and file types
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-Object -First 30 | Select-Object FullName
-
-# Find all class and function definitions
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "class|function|def|interface|struct"
-
-# Analyze import patterns and dependencies
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp" | Select-String -Pattern "import|from|require|#include" | Sort-Object | Get-Unique
-
-# Find dependency manifests
-Get-ChildItem -Recurse -Include "requirements*.txt","package.json","Cargo.toml","pom.xml","Gemfile","go.mod" | Get-Content
-
-# Identify technical debt and TODOs
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "TODO|FIXME|XXX|HACK|NOTE"
-`
-		: // bash/zsh-specific commands
-			`
-# Discover project structure and file types
-find . -type f -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.java" -o -name "*.cpp" -o -name "*.go" | head -30 | cat
-
-# Find all class and function definitions
-grep -r "class\\|function\\|def\\|interface\\|struct\\|func\\|type.*struct\\|type.*interface" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-
-# Analyze import patterns and dependencies
-grep -r "import\\|from\\|require\\|#include" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" . | sort | uniq | cat
-
-# Find dependency manifests
-find . -name "requirements*.txt" -o -name "package.json" -o -name "Cargo.toml" -o -name "pom.xml" -o -name "Gemfile" -o -name "go.mod" | xargs cat
-
-# Identify technical debt and TODOs
-grep -r "TODO\\|FIXME\\|XXX\\|HACK\\|NOTE" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-`
-}
-
-
-## STEP 2: Discussion and Questions
-
-Ask the user brief, targeted questions that will influence your implementation plan. Keep your questions concise and conversational. Ask only essential questions needed to create an accurate plan.
-
-**Ask questions only when necessary for:**
-- Clarifying ambiguous requirements or specifications
-- Choosing between multiple equally valid implementation approaches  
-- Confirming assumptions about existing system behavior or constraints
-- Understanding preferences for specific technical decisions that will affect the implementation
-
-Your questions should be direct and specific. Avoid long explanations or multiple questions in one response.
-
-## STEP 3: Create Implementation Plan Document
-
-Create a structured markdown document containing your complete implementation plan. The document must follow this exact format with clearly marked sections:
-
-### Document Structure Requirements
-
-Your implementation plan must be saved as implementation_plan.md, and *must* be structured as follows:
-
-
-# Implementation Plan
-
-[Overview]
-Single sentence describing the overall goal.
-
-Multiple paragraphs outlining the scope, context, and high-level approach. Explain why this implementation is needed and how it fits into the existing system.
-
-[Types]  
-Single sentence describing the type system changes.
-
-Detailed type definitions, interfaces, enums, or data structures with complete specifications. Include field names, types, validation rules, and relationships.
-
-[Files]
-Single sentence describing file modifications.
-
-Detailed breakdown:
-- New files to be created (with full paths and purpose)
-- Existing files to be modified (with specific changes)  
-- Files to be deleted or moved
-- Configuration file updates
-
-[Functions]
-Single sentence describing function modifications.
-
-Detailed breakdown:
-- New functions (name, signature, file path, purpose)
-- Modified functions (exact name, current file path, required changes)
-- Removed functions (name, file path, reason, migration strategy)
-
-[Classes]
-Single sentence describing class modifications.
-
-Detailed breakdown:
-- New classes (name, file path, key methods, inheritance)
-- Modified classes (exact name, file path, specific modifications)
-- Removed classes (name, file path, replacement strategy)
-
-[Dependencies]
-Single sentence describing dependency modifications.
-
-Details of new packages, version changes, and integration requirements.
-
-[Testing]
-Single sentence describing testing approach.
-
-Test file requirements, existing test modifications, and validation strategies.
-
-[Implementation Order]
-Single sentence describing the implementation sequence.
-
-Numbered steps showing the logical order of changes to minimize conflicts and ensure successful integration.
-
-
-## STEP 4: Create Implementation Task
-
-Use the new_task command to create a task for implementing the plan. The task must include a <task_progress> list that breaks down the implementation into trackable steps.
-
-### Task Creation Requirements
-
-Your new task should be self-contained and reference the plan document rather than requiring additional codebase investigation. Include these specific instructions in the task description:
-
-**Plan Document Navigation Commands:**
-The implementation agent should use these commands to read specific sections of the implementation plan. You should adapt these examples to conform to the structure of the .md file you created, and explicitly provide them when creating the new task:
-
-${
-	isPowerShell
-		? // PowerShell-specific commands
-			`
-# Read Overview section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Overview\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Types\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Types section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Types\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Files\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Files section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Files\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Functions\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Functions section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Functions\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Classes\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Classes section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Classes\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Dependencies\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Dependencies section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Dependencies\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Testing\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Testing section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Testing\\]').LineNumber; $end = ($content | Select-String -Pattern '\\[Implementation Order\\]').LineNumber; $content[($start-1)..($end-2)]
-
-# Read Implementation Order section
-$content = Get-Content implementation_plan.md; $start = ($content | Select-String -Pattern '\\[Implementation Order\\]').LineNumber; $content[($start-1)..($content.Length-1)]
-`
-		: // bash/zsh-specific commands
-			`
-# Read Overview section
-sed -n '/\\[Overview\\]/,/\\[Types\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Types section  
-sed -n '/\\[Types\\]/,/\\[Files\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Files section
-sed -n '/\\[Files\\]/,/\\[Functions\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Functions section
-sed -n '/\\[Functions\\]/,/\\[Classes\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Classes section
-sed -n '/\\[Classes\\]/,/\\[Dependencies\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Dependencies section
-sed -n '/\\[Dependencies\\]/,/\\[Testing\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Testing section
-sed -n '/\\[Testing\\]/,/\\[Implementation Order\\]/p' implementation_plan.md | head -n 1 | cat
-
-# Read Implementation Order section
-sed -n '/\\[Implementation Order\\]/,$p' implementation_plan.md | cat
-`
-}
-
-
-**Task Progress Format:**
-<IMPORTANT>
-You absolutely must include the task_progress contents in context when creating the new task. When providing it, do not wrap it in XML tags- instead provide it like this:
-
-
-task_progress Items:
-- [ ] Step 1: Brief description of first implementation step
-- [ ] Step 2: Brief description of second implementation step  
-- [ ] Step 3: Brief description of third implementation step
-- [ ] Step N: Brief description of final implementation step
-
-
-You also MUST include the path to the markdown file you have created in your new task prompt. You should do this as follows:
-
-Refer to @path/to/file/markdown.md for a complete breakdown of the task requirements and steps. You should periodically read this file again.
-
-{{FOCUS_CHAIN_PARAM}}
-
-{{NEW_TASK_INSTRUCTIONS}}
-
-### Mode Switching
-
-When creating the new task, request a switch to "act mode" if you are currently in "plan mode". This ensures the implementation agent operates in execution mode rather than planning mode.
-</IMPORTANT>
-
-## Quality Standards
-
-You must be specific with exact file paths, function names, and class names. You must be comprehensive and avoid assuming implicit understanding. You must be practical and consider real-world constraints and edge cases. You must use precise technical language and avoid ambiguity.
-
-Your implementation plan should be detailed enough that another developer could execute it without additional investigation.
-
----
-
-**Execute all four steps in sequence. Your role is to plan thoroughly, not to implement. Code creation begins only after the new task is created and you receive explicit instruction to proceed.**
-
-Below is the user's input when they indicated that they wanted to create a comprehensive implementation plan.
-</explicit_instructions>
-`
-}

src/core/prompts/commands/deep-planning/variants/gemini3.ts

@@ -1,260 +0,0 @@
-import { isGemini3ModelFamily } from "@utils/model-utils"
-import { getShell } from "@utils/shell"
-import type { SystemPromptContext } from "@/core/prompts/system-prompt/types"
-import type { DeepPlanningVariant } from "../types"
-
-/**
- * Creates the Gemini 3 variant for deep-planning prompt
- */
-export function createGemini3Variant(): DeepPlanningVariant {
-	return {
-		id: "gemini-3",
-		description: "Deep-planning variant optimized for Gemini 3 models",
-		family: "gemini-3",
-		version: 1,
-		matcher: (context: SystemPromptContext) => {
-			const modelId = context.providerInfo?.model?.id
-			if (!modelId) {
-				return false
-			}
-			return isGemini3ModelFamily(modelId)
-		},
-		template: "", // Template is dynamically generated in getDeepPlanningPrompt() based on focus chain settings
-	}
-}
-
-/**
- * Generates the deep-planning template with shell-specific commands
- * @param focusChainEnabled Whether focus chain (task_progress) is enabled for this task
- * @param enableNativeToolCalls Whether native tool calling is enabled
- */
-export function generateGemini3Template(focusChainEnabled: boolean, enableNativeToolCalls: boolean): string {
-	const detectedShell = getShell()
-
-	let isPowerShell = false
-	try {
-		isPowerShell =
-			detectedShell != null &&
-			typeof detectedShell === "string" &&
-			(detectedShell.toLowerCase().includes("powershell") || detectedShell.toLowerCase().includes("pwsh"))
-	} catch {}
-
-	return `<explicit_instructions type="deep-planning">
-Your task is to create a comprehensive implementation plan before writing any code. This process has five distinct steps that must be completed in order:
-1. Silent Read Investigation
-2. Silent Terminal Investigation
-3. Discussion and Questions
-4. Create Implementation Plan Document
-5. Create new_task for Implementation Phase
-
-${focusChainEnabled ? `You should track these five steps in your task_progress parameter, and update it only when steps are completed.` : ""}
-Your behavior should be methodical and thorough - take time to understand the codebase completely before making any recommendations. The quality of your investigation and use of targeted reads/searches directly impacts the success of the implementation.
-
-<IMPORTANT>
-Execute only exploration and plan generation steps until explicitly instructed by the user to proceed with coding.
-You must thoroughly understand the existing codebase before proposing any changes.
-Perform your research without commentary or narration. Execute commands and read files without explaining what you're about to do. Only speak up if you have specific questions for the user.
-</IMPORTANT>
-
-## STEP 1: Silent Read Investigation
-
-### Required Research Activities
-You MUST first use the read_file tool to examine several source files, configuration files, and documentation to better inform subsequent research steps. You should only use read_file to prepare for more granular searching. Use this step to get the big picture, then you will use the next step for granular details by searching using terminal commands. Use this tool to determine the language(s) used in the codebase, and to identify the domain(s) relevant to the user's request.
-
-
-## STEP 2: Silent Terminal Investigation
-
-### Required Research Activities
-You MUST use terminal commands to gather information about the codebase structure and patterns relevant to the user's request.
-You will tailor these commands to explore and identify key functions, classes, methods, types, and variables that are directly, or indirectly related to the task.
-These commands must be crafted to not produce exceptionally long or verbose search results. For example, you should exclude dependency folders such as node_modules, venv or php vendor, etc. Carefully consider the scope of search patterns. Use the results of your read_file tool calls to tailor the commands for balanced search result lengths. If a command returns no results, you may loosen the search patterns or scope slightly. If a command returns hundreds or thousands of results, you should adjust subsequent commands to be more targeted.
-Execute these commands to build your understanding. Adjust subsequent commands based on the output you have received from each previous command, informing the scope and direction of your search.
-You should only execute one command at a time for the first 1-3 commands. Do not chain search commands until you have executed and interpreted the results of several search commands, then use the context you have gathered to inform more complex chained commands.
-
-Here are some example commands, remember to adjust them as instructed previously:
-${
-	isPowerShell
-		? // PowerShell-specific commands
-			`
-# Discover project structure and file types
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-Object -First 30 | Select-Object FullName
-
-# Find all class and function definitions
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "class|function|def|interface|struct"
-
-# Analyze import patterns and dependencies
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp" | Select-String -Pattern "import|from|require|#include" | Sort-Object | Get-Unique
-
-# Find dependency manifests
-Get-ChildItem -Recurse -Include "requirements*.txt","package.json","Cargo.toml","pom.xml","Gemfile","go.mod" | Get-Content
-
-# Identify technical debt and TODOs
-Get-ChildItem -Recurse -Include "*.py","*.js","*.ts","*.java","*.cpp","*.go" | Select-String -Pattern "TODO|FIXME|XXX|HACK|NOTE"
-`
-		: // bash/zsh-specific commands
-			`
-# Discover project structure and file types
-find . -type f -name "*.py" -o -name "*.js" -o -name "*.ts" -o -name "*.java" -o -name "*.cpp" -o -name "*.go" | head -30 | cat
-
-# Find all class and function definitions
-grep -r "class\\|function\\|def\\|interface\\|struct\\|func\\|type.*struct\\|type.*interface" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-
-# Analyze import patterns and dependencies
-grep -r "import\\|from\\|require\\|#include" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" . | sort | uniq | cat
-
-# Find dependency manifests
-find . -name "requirements*.txt" -o -name "package.json" -o -name "Cargo.toml" -o -name "pom.xml" -o -name "Gemfile" -o -name "go.mod" | xargs cat
-
-# Identify technical debt and TODOs
-grep -r "TODO\\|FIXME\\|XXX\\|HACK\\|NOTE" --include="*.py" --include="*.js" --include="*.ts" --include="*.java" --include="*.cpp" --include="*.go" . | cat
-`
-}
-
-
-## STEP 3: Discussion and Questions
-
-Ask the user brief, targeted questions that will influence your implementation plan. Keep your questions concise and conversational. Ask only essential questions needed to create an accurate plan.
-
-**Ask questions only when necessary for:**
-- Clarifying ambiguous requirements or unclear specifications
-- Choosing between multiple equally valid implementation approaches that have significant trade-offs
-- Confirming non-trivial assumptions about existing system behavior or constraints
-- Understanding preferences for specific technical decisions that will affect the final implementation's behavior or code maintainability
-
-Your questions should be direct and specific. Avoid long explanations or multiple questions in one response. Only ask one question at a time. You may ask several questions if required and within scope of the task.
-
-## STEP 4: Create Implementation Plan Document
-
-Once you have obtained sufficient context to understand all code modifications that will be required, create a structured markdown document containing your complete implementation plan. The document must follow this exact format with clearly marked sections:
-
-### Document Structure Requirements
-
-Your implementation plan must be saved as implementation_plan.md, and *must* be structured as follows:
-
-<example_implementation_plan>
-# Implementation Plan
-
-[Overview]
-Single sentence describing the overall goal.
-
-Multiple paragraphs outlining the scope, context, and high-level approach. Explain why this implementation is needed and how it fits into the existing system.
-
-[Types]  
-Single sentence describing the type system changes.
-
-Detailed type definitions, interfaces, enums, or data structures with complete specifications. Include field names, types, validation rules, and relationships.
-
-[Files]
-Single sentence describing file modifications.
-
-Detailed breakdown:
-- New files to be created (with full paths and purpose)
-- Existing files to be modified (with specific changes)  
-- Files to be deleted or moved
-- Configuration file updates
-
-[Functions]
-Single sentence describing function modifications.
-
-Detailed breakdown:
-- New functions (name, signature, file path, purpose)
-- Modified functions (exact name, current file path, required changes)
-- Removed functions (name, file path, reason, migration strategy)
-
-[Classes]
-Single sentence describing class modifications.
-
-Detailed breakdown:
-- New classes (name, file path, key methods, inheritance)
-- Modified classes (exact name, file path, specific modifications)
-- Removed classes (name, file path, replacement strategy)
-
-[Dependencies]
-Single sentence describing dependency modifications.
-
-Details of new packages, version changes, and integration requirements.
-
-[Implementation Order]
-Single sentence describing the implementation sequence.
-
-Numbered steps showing the logical order of changes to minimize conflicts and ensure successful integration.
-${focusChainEnabled ? "A task_progress list of steps that will need to be completed during the implementation" : ""}
-
-</example_implementation_plan>
-
-## STEP 5: Create Implementation new_task
-
-Use the new_task command to create a task for implementing the plan. ${focusChainEnabled ? "The task must include a <task_progress> list that breaks down the implementation into trackable steps." : ""}
-
-### Task Creation Requirements
-
-<IMPORTANT>
-**Standalone Product:**
-Your new task should be self-contained and reference the plan document rather than requiring additional codebase investigation. Include these specific instructions in the task description:
-
-${
-	focusChainEnabled
-		? `**Task Progress Format:**
-You absolutely MUST include the task_progress contents in context when creating the new task. When providing it, do not wrap it in XML tags- instead provide it like this:
-
-task_progress Items:
-- [ ] Step 1: Brief description of first implementation step
-- [ ] Step 2: Brief description of second implementation step  
-- [ ] Step 3: Brief description of third implementation step
-- [ ] Step N: Brief description of subsequent/final implementation step(s)
-
-**Markdown Implementation Plan Path:**
-You also MUST include the path to the markdown file you have created in your new task prompt. You should do this as follows:
-  Refer to @path/to/file/markdown.md for a complete breakdown of the task requirements and steps. You should periodically read this file again.`
-		: ""
-}
-</IMPORTANT>
-
-${
-	enableNativeToolCalls
-		? `**new_task Tool Definition:**
-
-When you are ready to create the implementation task, you must call the new_task tool with the following structure:
-
-{
-  "name": "new_task",
-  "arguments": {
-    "context": "Your detailed context here following the 5-point structure..."
-  }
-}
-
-The context parameter should include all five sections as described above.
-
-`
-		: `**new_task Tool Definition:**
-
-When you are ready to create the implementation task, you must call the new_task tool with the following structure:
-
-<new_task>
-<context>Your detailed context here following the 5-point structure...</context>
-</new_task>
-
-The context parameter should include all five sections as described above.
-
-`
-}
-### Mode Switching
-
-<IMPORTANT>
-When creating the new task, request a switch to "act mode" if you are currently in "plan mode". This ensures the implementation agent operates in execution mode rather than planning mode.
-</IMPORTANT>
-
-## Quality Standards
-
-You must be specific with exact file paths, function names, and class names. You must be comprehensive and avoid assuming implicit understanding. You must be practical and consider real-world constraints and edge cases. You must use precise technical language and avoid ambiguity.
-
-Your implementation plan should be detailed enough that another developer could execute it without additional investigation.
-
----
-
-**Execute all five steps in sequence. Your role is to plan thoroughly, not to implement. Code creation begins only after the new task is created and you receive explicit instruction to proceed.**
-
-Below is the user's input from when they indicated that they wanted to create this comprehensive implementation plan.
-</explicit_instructions>
-`
-}