fix(deps): pin diff to 8.0.3 to mitigate CVE-2026-24001

.clinerules/general.md

@@ -140,10 +140,12 @@ Adding a new key to global state requires updates in multiple places. Missing an
 
 Required steps:
 1. Type definition in `src/shared/storage/state-keys.ts` - Add to `GlobalState` or `Settings` interface
-2. Add any default value or transform in `src/shared/storage/state-keys.ts` if the key needs one
-3. Read and write the value through `StateManager` (`setGlobalState()` / `getGlobalStateKey()`) after initialization
+2. Read from globalState in `src/core/storage/utils/state-helpers.ts`:
+   - Add `const myKey = context.globalState.get<GlobalStateAndSettings["myKey"]>("myKey")` in `readGlobalStateFromDisk()`
+   - Add to the return object: `myKey: myKey ?? defaultValue,`
+3. StateManager handles read/write via `setGlobalState()`/`getGlobalStateKey()` after initialization
 
-Persistent state is file-backed through `StateManager`; do not add new runtime reads or writes against VS Code `ExtensionContext` storage. That storage is only a legacy migration source.
+Common mistake: Adding only the return value without the `context.globalState.get()` call. This compiles but the value is always `undefined` on load.
 
 Settings plumbing gotcha: if a key is user-toggleable from settings, wire both controller update paths:
 - `src/core/controller/state/updateSettings.ts` for webview `updateSetting(...)`
@@ -157,20 +159,22 @@ Webview toggle gotcha: settings changes must also round-trip back in state paylo
 If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
 
 ## StateManager Cache vs Direct globalState Access
-StateManager uses an in-memory cache populated during `StateManager.initialize()` from file-backed storage. For most state, use `controller.stateManager.setGlobalState()`/`getGlobalStateKey()`.
+StateManager uses an in-memory cache populated during `StateManager.initialize(context)` in `common.ts`. For most state, use `controller.stateManager.setGlobalState()`/`getGlobalStateKey()`.
 
-Exception: host migration code may read legacy VS Code storage before file-backed storage is initialized.
+Exception: State needed immediately at extension startup (before cache is ready)
 
-Example pattern:
+When Window A sets state and immediately opens Window B, the new window's StateManager cache is populated from `context.globalState` during initialization. If you need to read state in Window B right at startup (e.g., in `common.ts` during `initialize()`), read directly from `context.globalState.get()` instead of StateManager's cache.
+
+Example pattern (see `lastShownAnnouncementId` and `worktreeAutoOpenPath`):
 ```typescript
 // Writing (normal pattern)
 controller.stateManager.setGlobalState("myKey", value)
 
-// Reading after initialization
-const value = controller.stateManager.getGlobalStateKey("myKey")
+// Reading at startup in common.ts (bypass cache)
+const value = context.globalState.get<string>("myKey")
 ```
 
-Use `context.globalState` only in VS Code migration code that copies legacy ExtensionContext values into the shared file-backed stores.
+This is only needed for cross-window state read during the brief startup window before StateManager cache is fully usable. Normal state access after initialization should use StateManager.
 
 ## ChatRow Cancelled/Interrupted States
 When a ChatRow displays a loading/in-progress state (spinner), you must handle what happens when the task is cancelled. This is non-obvious because cancellation doesn't update the message content—you have to infer it from context.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -7,10 +7,10 @@ body:
       value: |
         **Important:** All bug reports must be reproducible using Claude Sonnet 4.5. Cline uses complex prompts so less capable models may not work as expected.
   - type: dropdown
-    id: cline-surface
+    id: plugin-type
     attributes:
-      label: Cline Surface
-      description: Which Cline surface are you reporting a bug for?
+      label: Plugin Type
+      description: Which plugin are you reporting a bug for?
       options:
         - VSCode Extension
         - JetBrains Plugin
@@ -59,18 +59,6 @@ body:
       placeholder: 'e.g., cline:anthropic/claude-sonnet-4.5, gemini:gemini-2.5-pro-exp-03-25'
     validations:
       required: false
-  - type: textarea
-    id: ide-diagnostics
-    attributes:
-      label: IDE / CLI Diagnostics
-      description: |
-        Paste the "About" diagnostics for your Cline surface. This captures the IDE build, runtime, and host details we need.
-        - VSCode Extension: open `Help → About` (Windows/Linux) or `Code → About Visual Studio Code` (macOS), then copy the info.
-        - JetBrains Plugin: open `Help → About` (Windows/Linux) or `<IDE name> → About` (macOS), then click `Copy` to grab build, runtime, OS, memory, and cores.
-        - CLI: there is no About dialog. Run `cline --version` and paste the output.
-      placeholder: Paste the copied About info or `cline --version` output here.
-    validations:
-      required: false
   - type: textarea
     id: system-info
     attributes:

.github/copilot-instructions.md

@@ -44,7 +44,7 @@ For Responses API providers: add to `isNextGenModelProvider()` in `src/utils/mod
 Modular: `components/` (shared) + `variants/` (model-specific) + `templates/` (`{{PLACEHOLDER}}`). Variants override components via `componentOverrides` in `config.ts` or custom `template.ts`. XS variant is heavily condensed inline. Always regenerate snapshots after changes.
 
 ## Global State Keys (silent failure risk)
-Adding a key requires updating the typed storage definitions in `src/shared/storage/state-keys.ts`; runtime reads and writes should go through `StateManager`, not VS Code `ExtensionContext` storage. Persistent state is file-backed so it works across VS Code, CLI, and JetBrains hosts.
+Adding a key requires: type in `src/shared/storage/state-keys.ts`, read via `context.globalState.get()` in `src/core/storage/utils/state-helpers.ts` `readGlobalStateFromDisk()`, and add to return object. Missing the `.get()` call compiles fine but value is always `undefined`.
 
 ## Slash Commands (3 places)
 - `src/core/slash-commands/index.ts` — definitions.

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

@@ -17,7 +17,7 @@ jobs:
             const labels = context.payload.issue.labels.map(l => l.name);
 
             // Check if JetBrains Plugin is selected
-            if (body.match(/###\s*Cline Surface\s*\n+JetBrains Plugin/i)) {
+            if (body.match(/###\s*Plugin Type\s*\n+JetBrains Plugin/i)) {
               if (!labels.includes('JetBrains')) {
                 await github.rest.issues.addLabels({
                   owner: context.repo.owner,
@@ -29,7 +29,7 @@ jobs:
             }
 
             // Check if VSCode Extension is selected
-            if (body.match(/###\s*Cline Surface\s*\n+VSCode Extension/i)) {
+            if (body.match(/###\s*Plugin Type\s*\n+VSCode Extension/i)) {
               if (!labels.includes('VS Code')) {
                 await github.rest.issues.addLabels({
                   owner: context.repo.owner,
@@ -41,7 +41,7 @@ jobs:
             }
 
             // Check if CLI is selected
-            if (body.match(/###\s*Cline Surface\s*\n+CLI/i)) {
+            if (body.match(/###\s*Plugin Type\s*\n+CLI/i)) {
               if (!labels.includes('CLI')) {
                 await github.rest.issues.addLabels({
                   owner: context.repo.owner,

CHANGELOG.md

@@ -1,58 +1,5 @@
 # Changelog
 
-## [3.89.2]
-
-### Fixed
-
-- Complete the fix for the Anthropic provider on VS Code 1.123 and later by upgrading the bundled Anthropic SDK to a release compatible with the Node 24 runtime.
-- Update the Vertex AI provider to a compatible Anthropic Vertex SDK release so it works with the upgraded Anthropic SDK.
-
-## [3.89.1]
-
-### Fixed
-
-- Restore the Anthropic provider on VS Code 1.123 and later, where the updated Node 24 runtime broke the bundled Anthropic SDK.
-- Handle the DeepSeek V4 reasoning format.
-
-## [3.89.0]
-
-### Added
-
-- Add Claude Fable 5 model support.
-
-### Fixed
-
-- Fix MiniMax M3 thinking controls across gateways.
-
-### Changed
-
-- Clean up the Codex model list.
-
-## [3.88.1]
-
-### Added
-
-- Add a debug section in settings for Cline testers.
-
-### Fixed
-
-- Include the walkthrough markdown files in the VS Code extension package so the first-run walkthrough steps load correctly.
-
-## [3.88.0]
-
-### Added
-
-- Add the latest Fireworks AI serverless models and update the default Fireworks model to Kimi K2.6.
-
-### Fixed
-
-- Fix MCP server delete/add flows so settings writes do not cause the MCP server list to be emptied by the file watcher.
-- Remove stale Fireworks AI models and correct Fireworks model metadata and cache pricing.
-
-### Changed
-
-- Always use the upstream Cline recommended models endpoint instead of gating it behind a feature flag.
-
 ## [3.87.0]
 
 ### Added

README.md

@@ -212,12 +212,8 @@ cline schedule create "PR summary" \
 Chat with your agent from any messaging platform: Telegram, Slack, Discord, Google Chat, WhatsApp, and Linear. Each conversation thread maps to an agent session with full context. Set up access control to restrict who can interact with your agent.
 
 ```bash
-# Connect to Telegram
 cline connect telegram -k $BOT_TOKEN
-# Connect to Slack through webhook
-cline connect slack --bot-token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
-# Connect to Slack using socket mode
-cline connect slack --bot-token $SLACK_TOKEN --app-token $SLACK_APP_TOKEN
+cline connect slack --token $SLACK_TOKEN --signing-secret $SECRET --base-url $URL
 ```
 
 ## Headless CLI for CI/CD

apps/biome.json

@@ -1,9 +1,7 @@
 {
 	"$schema": "https://biomejs.dev/schemas/2.4.5/schema.json",
 	"root": false,
-	"extends": [
-		"../sdk/biome.json"
-	],
+	"extends": ["../sdk/biome.json"],
 	"linter": {
 		"rules": {
 			"a11y": {

apps/cli/.cline/skills/publish-cli/SKILL.md

@@ -9,13 +9,12 @@ Use this skill when the user asks to release the CLI, publish `cline`, bump the
 
 The CLI is npm-only. Do not add alternate distribution or signing steps.
 
-> Working directory: run every command below from the repository root. Paths and scripts (e.g. `apps/cli/package.json`, `sdk/packages/`, `bun release cli`, `bun run version`) are written relative to the repo root.
+> Working directory: this skill lives in the SDK sub-monorepo. Run `cd sdk` (from the repo root) before any of the shell commands below. Paths in commands and instructions (e.g. `apps/cli/package.json`, `bun release cli`) are written relative to `sdk/`.
 
 The skill should guide the user through one release preparation flow, then offer the publish path options. The two normal publish paths are GitHub Actions and local publishing from an authenticated machine.
 
 ## Release contract
 
-- SDK prerequisite: the CLI depends on the SDK via `workspace:*` (`@cline/core`, `@cline/shared`, and friends). If the SDK changed since its last release, release the SDK first and wait for it to finish publishing before releasing the CLI. See "Step 0: Release the SDK first if it changed" below.
 - Version source: `apps/cli/package.json`.
 - Main release tag: `cli-vX.Y.Z`, where `X.Y.Z` matches `apps/cli/package.json`.
 - Nightly release version: `X.Y.Z-nightly.TIMESTAMP`.
@@ -31,93 +30,8 @@ The skill should guide the user through one release preparation flow, then offer
 - Always ask before pushing commits or tags.
 - Do not amend commits unless explicitly requested.
 
-## Step 0: Release the SDK first if it changed
-
-Do this before anything else in the Workflow below.
-
-The CLI builds and ships against the SDK source in the monorepo (`workspace:*` for `@cline/core`, `@cline/shared`, and the rest), so a CLI release always contains the latest SDK code whether or not the SDK was released. The build and tests use that source too, not anything from npm. Releasing the SDK alongside the CLI is still worth doing for two reasons:
-
-- Hub freshness. The hub daemon lives in `@cline/core` and stamps a `buildId` that defaults to the `@cline/core` package version (`resolveHubBuildId` in `sdk/packages/core/src/hub/discovery/index.ts`). A running hub is only retired and respawned when that `buildId` changes (`isCompatibleHubRecord` / `retireIncompatibleHub` in `sdk/packages/core/src/hub/daemon/index.ts`). So if the SDK code changed but the version did not, a user who upgrades the CLI keeps talking to their already-running hub, which is still executing the old SDK code. Bumping the SDK version makes the new CLI's `buildId` differ, so the stale hub is detected as incompatible and respawned with the fresh code.
-- Release hygiene. We want regular SDK releases; cutting one whenever we cut a CLI release keeps the published SDK in step with what the CLI ships.
-
-So when the SDK has changed, release it first (which bumps the `@cline/core` version), then cut the CLI release on top of that bump. Leave the CLI's SDK dependency as `workspace:*` — the fix is to release the SDK, not to pin the CLI.
-
-1. Check for unreleased SDK changes.
-
-```sh
-git fetch origin --tags
-git tag --list 'sdk/sdk/v*' 'sdk-v*' --sort=-v:refname | head -1
-git log <last-sdk-tag>..origin/main --oneline --no-merges -- sdk/packages
-```
-
-`sdk/<pkg>/v*` tags are created by the `sdk-publish.yml` workflow; `sdk-v*` tags are created by the local `bun release sdk` helper. Use whichever is newest as the baseline.
-
-If `git log` prints no commits, the SDK is already up to date. Skip the rest of Step 0 and continue with the Workflow below.
-
-If it prints commits, sanity-check the diff (ignore entries that are only the previous version-bump commit's lockfile or generated files), then release the SDK.
-
-2. Decide the SDK version bump.
-
-All SDK packages share one version, read from `sdk/packages/llms/package.json`. Ask whether this is patch, minor, major, or an explicit version. Patch is the default. Do not guess if the user has not made it clear.
-
-3. Draft the SDK release notes and update the changelog.
-
-Draft user-facing notes from the SDK commits found in step 1, translating commit messages into user-facing language (same approach as the CLI release notes below). Prepend a new `## <version>` section with those notes to the top of `sdk/CHANGELOG.md`, using the header format `## <version>` with no date — the same flat, newest-on-top format as `apps/cli/CHANGELOG.md`. This is the SDK changelog (all SDK packages share one version) and it is maintained by hand; the `sdk-publish.yml` workflow does not read it.
-
-4. Bump versions and regenerate.
-
-```sh
-bun run version <version>
-```
-
-This bumps every SDK `package.json` to the new version, regenerates the lockfile and the generated model catalog, formats, and builds. Review the result.
-
-5. Commit and push the bump to `main`.
-
-The `sdk-publish.yml` workflow publishes the version that is committed on `main` and tags that commit, so the bump must land on `main` before the workflow runs.
-
-```sh
-git add -A
-git commit -m "chore(sdk): release v<version>"
-```
-
-Ask before pushing:
-
-```sh
-git push origin HEAD
-```
-
-6. Trigger the SDK publish workflow on the `latest` channel.
-
-```sh
-gh workflow run sdk-publish.yml -f channel=latest -f confirm_publish=publish
-gh run list --workflow=sdk-publish.yml --limit=1 --json databaseId,url,status,createdAt --jq '.[0]'
-```
-
-The workflow runs the SDK tests, publishes `@cline/shared`, `@cline/llms`, `@cline/agents`, `@cline/core`, and `@cline/sdk` to npm with the `latest` dist-tag in dependency order, and pushes `sdk/<pkg>/v<version>` git tags.
-
-7. Wait for the SDK workflow to succeed before starting the CLI release.
-
-```sh
-gh run watch <run-id> --exit-status
-```
-
-Do not start the CLI release until this run has finished successfully. The CLI does not install the SDK from npm, but cutting the CLI release on top of a clean, completed SDK release keeps the two in step: the CLI release commit then sits on top of the `@cline/core` version bump, so the shipped CLI carries the new version that forces a running hub to respawn with the new code, and you are not building a CLI release on top of an SDK release that failed midway.
-
-After the SDK release succeeds, pull `main` so the CLI release is prepared on top of the SDK version bump:
-
-```sh
-git checkout main && git pull --ff-only
-```
-
-Then continue with the Workflow below.
-
-For a local SDK publish from an authenticated machine instead of the workflow, `bun release sdk <version>` exists, but prefer the `sdk-publish.yml` workflow for normal releases so the CLI release can gate on a single GitHub Actions run.
-
 ## Workflow
 
-Complete Step 0 first. Only proceed once the SDK is released (or you confirmed no SDK release was needed).
-
 1. Gather context.
 
 ```sh
@@ -132,10 +46,10 @@ Find the latest CLI tag. If there is no `cli-v*` tag, use the first relevant CLI
 2. Collect release commits.
 
 ```sh
-git log <last-cli-tag>..HEAD --oneline --no-merges -- apps/cli sdk/packages sdk/scripts .github/workflows/cli-publish.yml
+git log <last-cli-tag>..HEAD --oneline --no-merges -- apps/cli packages scripts .github/workflows/cli-publish.yml
 ```
 
-The `sdk/packages` commits matter here even though the SDK was released separately in Step 0: the CLI bundles the SDK, so SDK changes ship in this CLI release too. Read those commits and fold anything user-relevant to the CLI into the release notes (provider/model updates, behavior changes, fixes the CLI inherits). Skip SDK changes that are purely internal or have no CLI-visible effect.
+If the release includes broader SDK changes that affect the CLI, also inspect commits outside `apps/cli`.
 
 3. Draft user-facing release notes.
 

apps/cli/CHANGELOG.md

@@ -1,114 +1,5 @@
 # Cline CLI Changelog
 
-## 3.0.29
-
-- Costs are now hidden for Cline free models
-- Fixed Z.ai model metadata resolution for Z.ai models accessed through the Cline provider
-- Reverted the model-name-only display change from v3.0.28; the model picker, selector, and status bar return to their previous display behavior
-
-## 3.0.28
-
-- Added a ClinePass onboarding flow with selectable ClinePass models, plus improved ClinePass error handling
-- Added hub primitive catalogs and refreshed the hub dashboard design with a dedicated customizations breakout
-- Auto-approve toggles now apply immediately when changed
-- Feature flags now resolve using your user ID on startup
-- Fixed Cline model display names so they resolve by model name
-- Truncate large tool results by default (including MCP and custom tool output) to keep requests within context budget
-- Hardened parallel tool-call guidance for faster, more reliable multi-tool execution
-
-## 3.0.27
-
-- Added a `cline skill` command to install and manage skills, matching `cline plugin install` and `cline mcp` (installs default to the Cline agent directory)
-- Added a prefilled MCP install wizard command for quicker MCP server setup
-- Improved error handling and messaging when plugin MCP OAuth authorization fails
-- The CLI now rejects unknown commands and unquoted multi-word input with a clear error instead of silently treating bad arguments as a prompt
-
-## 3.0.26
-
-- Reverted the expandable model picker sections and ClinePass models, restoring the previous model-selection UI
-
-## 3.0.25
-
-- Added ClinePass support, with selectable ClinePass models in the model picker
-- Made model picker sections expandable
-- Added MCP server support to plugins, including authorizing plugin MCP OAuth during install
-- Encouraged parallel tool calls for faster task execution
-- Capped tool output for bash commands and file reads to keep large output within context limits
-- Allowed ranged reads on large files
-- Fixed apply_patch to fail when a hunk is skipped
-- Fixed run_commands to return captured stdout on failure and handle split heredocs
-- Fixed search tools to treat zero results as success
-- Fixed disabled-reasoning handling for StepFun flash
-- Fixed history resume rendering isolation
-- Fixed the Hugging Face URL
-- Fixed Cline OAuth token formatting in provider config
-
-## 3.0.24
-
-- Plugin commands can now submit prompts to the agent
-- Added support for overriding the API base URL
-- Open the verification URL automatically when starting device authentication
-- Enforced a single shared Cline Hub, so a stale hub is respawned after an upgrade
-- Suppressed flickering console windows on Windows
-- Fixed truncation of structured tool operation result strings so oversized tool output stays within limits
-- Stopped echoing the full command text in run_commands tool results
-
-## 3.0.23
-
-- Fixed Vertex AI GCP settings configuration
-- Fixed the Azure Foundry API version
-- Added support for configured agents as subagent tools
-- Centralized OAuth management into the SDK
-- Fixed an error caused by disabled reasoning on Fable 5
-
-## 3.0.22
-
-- Added support for the Claude Fable 5 model
-- Fixed MiniMax M3 thinking controls so they route correctly across gateways
-
-## 3.0.21
-
-- Added a global auto-update setting that controls automatic updates on CLI startup
-- Added a Cline credits refill link
-- Fixed scrolling for inline ask-question responses
-- Fixed connector thread session routing and stale hub session handling
-- Added support for Vertex AI Application Default Credentials (ADC) with tool use
-- Fixed empty message content replay for Bedrock
-- Cleaned up the OpenAI Codex model list
-
-## 3.0.20
-
-- Installed plugin wrappers are now named from their source (npm package name, git repo, remote filename, official slug, or local directory) instead of an opaque hash, making installed plugins easier to identify.
-
-## 3.0.19
-
-- Fixed CLI auto-update to use `npm update` so updates apply reliably, while preserving the installed release channel (e.g. nightly).
-
-## 3.0.18
-
-- Fix Slack channel mentions so replies post in the original message's thread.
-- Fix the abort indicator to clear immediately when a task is cancelled.
-- Sync the Fireworks AI model registry and refresh the bundled model catalog with current platform offerings.
-- Bump the bundled SDK to v0.0.43, which forces a running Cline Hub to restart so it picks up the latest SDK code.
-
-## 3.0.17
-
-- Fix a regression introduced in 3.0.15 where the interactive CLI could get stuck after stopping and restarting Cline Hub and then pressing Escape to cancel a request. The CLI now detects stale or missing sessions, recovers any pending messages, and starts a fresh session instead of failing with "session not found".
-- Fix Ctrl+C and Hub shutdown races that surfaced as "hook dispatch failed" and WebSocket connection errors from late hook events racing against Hub shutdown.
-- Fix the Hub daemon being shut down prematurely when a runtime request was aborted, so the daemon now stays alive.
-- Improve the Telegram connector with a new `--allowed-user-id` flag to restrict which Telegram users are authorized to interact with the agent.
-
-## 3.0.16
-
-- Install official Cline plugins by slug off the new github.com/cline/plugins collection.
-- Uninstall plugins using `cline plugin uninstall <plugin>` or in the TUI.
-- Plugins can now bundle skills, and plugin skills are grouped together in settings.
-- Add Slack socket mode support.
-- Allow a custom base URL for Anthropic vendor-type providers.
-- Fix OAuth token migration for users signed in through the old extension.
-- Use a union schema for read-files tool input validation.
-- Add a `CLINE_PLUGIN_IMPORT_TIMEOUT_MS` env override to control the plugin import timeout.
-
 ## 3.0.15
 
 - Add Cline Hub, a web app for monitoring connected clients, viewing and driving sessions, streaming assistant output, and restarting the local hub, with local, LAN, and tunnel usage gated by a room secret.

apps/cli/DEVELOPMENT.md

@@ -416,7 +416,7 @@ Then attach VS Code or Chrome DevTools to `ws://127.0.0.1:6499`.
 
 ## Publishing
 
-The CLI is published as the `cline` wrapper package on npm with platform-specific binaries under `@cline/cli-*`. The release flow lives in the `publish-cli` skill (`.cline/skills/publish-cli/SKILL.md` at the repo root).
+The CLI is published as the `cline` wrapper package on npm with platform-specific binaries under `@cline/cli-*`. The release flow lives in the `publish-cli` skill (`apps/cli/.cline/skills/publish-cli/SKILL.md`).
 
 From the `apps/cli` workspace:
 

apps/cli/README.md

@@ -163,30 +163,6 @@ cline auth --provider anthropic --apikey sk-... --modelid claude-sonnet-4-6
 cline auth --provider openai-native --apikey sk-... --modelid gpt-5 --baseurl https://api.example.com/v1
 ```
 
-### MCP servers
-
-Manage MCP servers with the interactive wizard:
-
-```sh
-cline mcp
-cline config mcp
-```
-
-Open the add-server wizard with the name, transport, and command or URL already filled in with `cline mcp install` (`cline mcp add` also works). Stdio servers use everything after `--` as the command and arguments:
-
-```sh
-cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp
-```
-
-Remote HTTP and SSE servers take a name, transport, and URL. The wizard still asks for auth details before saving:
-
-```sh
-cline mcp install ctx7 --transport http https://mcp.context7.com/mcp
-cline mcp install events --transport sse https://example.com/sse
-```
-
-Because this command opens the wizard, it requires a TTY.
-
 ### Connectors
 
 Bridge a chat surface into RPC-backed Cline sessions. Each conversation thread maps to a session with full context. Supported platforms: Telegram, Slack, Google Chat, WhatsApp, and Linear.
@@ -198,9 +174,6 @@ cline connect telegram -k 123456:ABCDEF...
 # Slack (webhook mode)
 cline connect slack --bot-token $SLACK_BOT_TOKEN --signing-secret $SLACK_SIGNING_SECRET --base-url https://your-domain.com
 
-# Slack (socket mode)
-cline connect slack --bot-token $SLACK_BOT_TOKEN --app-token $SLACK_APP_TOKEN
-
 # Google Chat (webhook mode)
 cline connect gchat --base-url https://your-domain.com
 

apps/cli/bun.mts

@@ -85,20 +85,6 @@ const result = await Bun.build({
 	],
 	define: {
 		"process.env.NODE_ENV": '"production"',
-		...(process.env.TELEMETRY_SERVICE_API_KEY
-			? {
-					"process.env.TELEMETRY_SERVICE_API_KEY": defineProcessEnv(
-						"TELEMETRY_SERVICE_API_KEY",
-					),
-				}
-			: {}),
-		...(process.env.ERROR_SERVICE_API_KEY
-			? {
-					"process.env.ERROR_SERVICE_API_KEY": defineProcessEnv(
-						"ERROR_SERVICE_API_KEY",
-					),
-				}
-			: {}),
 		"process.env.OTEL_TELEMETRY_ENABLED": defineProcessEnv(
 			"OTEL_TELEMETRY_ENABLED",
 		),

apps/cli/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cline/cli",
 	"displayName": "cline",
-	"version": "3.0.29",
+	"version": "3.0.15",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"type": "module",
 	"publishConfig": {
@@ -87,7 +87,6 @@
 		"open": "^10.2.0",
 		"opentui-spinner": "^0.0.6",
 		"pino": "^10.3.1",
-		"posthog-node": "^5.8.0",
 		"react": "19.2.4",
 		"react-devtools-core": "^7.0.1",
 		"react-reconciler": "0.32.0",

apps/cli/src/acp/auth.ts

@@ -1,6 +1,11 @@
-import type { ProviderSettingsManager } from "@cline/core";
-import { loginAndSaveProviderOAuthCredentials } from "@cline/core";
-import { getPersistedProviderApiKey } from "../commands/auth";
+import type { ProviderSettings, ProviderSettingsManager } from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
+import type { OAuthCredentials } from "../commands/auth";
+import {
+	getPersistedProviderApiKey,
+	saveOAuthProviderSettings,
+	toProviderApiKey,
+} from "../commands/auth";
 import { writeDiagnostic } from "../utils/output";
 
 /**
@@ -25,13 +30,37 @@ export function isAcpAuthMethodId(id: string): id is AcpAuthMethodId {
  * If the OAuth flow requires interactive prompts (rare), defaults are used
  * when available; otherwise an error is thrown.
  */
-async function performOAuthLogin(input: {
-	providerId: AcpAuthMethodId;
-	providerSettingsManager: ProviderSettingsManager;
-}): Promise<string> {
-	const [{ createOAuthClientCallbacks }, { default: open }] = await Promise.all(
-		[import("@cline/core"), import("open")],
-	);
+async function performOAuthLogin(
+	providerId: AcpAuthMethodId,
+	existingSettings: ProviderSettings | undefined,
+): Promise<OAuthCredentials> {
+	const [{ createOAuthClientCallbacks }, { default: open }, coreOAuth] =
+		await Promise.all([
+			import("@cline/core"),
+			import("open"),
+			import("@cline/core").then((m) => ({
+				loginClineOAuth: m.loginClineOAuth as (input: {
+					useWorkOSDeviceAuth?: boolean;
+					apiBaseUrl: string;
+					callbacks: {
+						onAuth: (info: { url: string; instructions?: string }) => void;
+						onPrompt: (prompt: {
+							message: string;
+							defaultValue?: string;
+						}) => Promise<string>;
+						onManualCodeInput?: () => Promise<string>;
+					};
+				}) => Promise<OAuthCredentials>,
+				loginOpenAICodex: m.loginOpenAICodex as (input: {
+					onAuth: (info: { url: string; instructions?: string }) => void;
+					onPrompt: (prompt: {
+						message: string;
+						defaultValue?: string;
+					}) => Promise<string>;
+					onManualCodeInput?: () => Promise<string>;
+				}) => Promise<OAuthCredentials>,
+			})),
+		]);
 
 	const callbacks = createOAuthClientCallbacks({
 		onPrompt: ({ defaultValue }) => {
@@ -53,18 +82,18 @@ async function performOAuthLogin(input: {
 		},
 	});
 
-	const settings = await loginAndSaveProviderOAuthCredentials(
-		input.providerSettingsManager,
-		input.providerId,
-		{ callbacks },
-	);
-	const apiKey = getPersistedProviderApiKey(input.providerId, settings);
-	if (!apiKey) {
-		throw new Error(
-			`OAuth login did not persist credentials for ${input.providerId}`,
-		);
+	if (providerId === "cline") {
+		return coreOAuth.loginClineOAuth({
+			apiBaseUrl:
+				existingSettings?.baseUrl?.trim() ||
+				getClineEnvironmentConfig().apiBaseUrl,
+			callbacks,
+			useWorkOSDeviceAuth: true,
+		});
 	}
-	return apiKey;
+
+	// openai-codex
+	return coreOAuth.loginOpenAICodex(callbacks);
 }
 
 export interface AcpAuthResult {
@@ -93,10 +122,16 @@ export async function authenticateAcpProvider(
 
 	// Perform a fresh OAuth login.
 	writeDiagnostic(`[acp/auth] Starting OAuth login for ${methodId}…`);
-	const apiKey = await performOAuthLogin({
-		providerId: methodId,
+	const credentials = await performOAuthLogin(methodId, existing);
+
+	saveOAuthProviderSettings(
 		providerSettingsManager,
-	});
+		methodId,
+		existing,
+		credentials,
+	);
+
+	const apiKey = toProviderApiKey(methodId, credentials);
 	writeDiagnostic(`[acp/auth] Successfully authenticated with ${methodId}`);
 	return { providerId: methodId, apiKey };
 }

apps/cli/src/cli.e2e.test.ts

@@ -746,27 +746,6 @@ Break work into clear steps.`,
 		).toBe(true);
 	});
 
-	it("routes mcp install and requires a TTY for the prefilled wizard", () => {
-		const result = runCli(
-			[
-				"mcp",
-				"install",
-				"fs",
-				"--",
-				"npx",
-				"-y",
-				"@modelcontextprotocol/server-filesystem",
-				"/tmp",
-			],
-			{ env: createIsolatedEnv() },
-		);
-
-		expect(result.status).toBe(1);
-		expect(asText(result.stderr)).toContain(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-
 	it("lists available tools", () => {
 		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
 		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));

apps/cli/src/cli.interactive.e2e.test.ts

@@ -18,8 +18,6 @@ interface KeyStep {
 const INITIAL_RENDER_DELAY_SECONDS = 2.5;
 const POST_ACTION_SETTLE_SECONDS = 1.0;
 const INTERACTIVE_TEST_TIMEOUT_MS = 40_000;
-const HISTORY_PICKER_READY_DELAY_SECONDS = 8.0;
-const HISTORY_RESUME_READY_DELAY_SECONDS = 15.0;
 
 function normalizeTerminalOutput(output: string): string {
 	// biome-ignore lint/suspicious/noControlCharactersInRegex: this regex intentionally strips ANSI escape sequences
@@ -53,40 +51,16 @@ function buildScriptCommand(scriptedInput: string, launchArgs: string): string {
 	return `(${scriptedInput}) | script ${quietFlag} /dev/null ${toShellSingleQuotedLiteral(bunExec)} ${launchArgs}`;
 }
 
-function createCliEnv(): NodeJS.ProcessEnv {
+function runInteractiveCli(
+	steps: KeyStep[],
+	options?: { launchConfigView?: boolean },
+): CliResult {
 	const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-home-"));
 	const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-data-"));
 	const sessionDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-sessions-"));
 	const teamDir = mkdtempSync(path.join(os.tmpdir(), "cli-int-teams-"));
 	tempDirs.push(homeDir, dataDir, sessionDir, teamDir);
 
-	return {
-		...process.env,
-		HOME: homeDir,
-		CLINE_DATA_DIR: dataDir,
-		CLINE_DB_DATA_DIR: path.join(dataDir, "db"),
-		CLINE_SESSION_DATA_DIR: sessionDir,
-		CLINE_TEAM_DATA_DIR: teamDir,
-		CLINE_SESSION_BACKEND_MODE: "local",
-		CLINE_PROVIDER_SETTINGS_PATH: path.join(
-			dataDir,
-			"settings",
-			"providers.json",
-		),
-		CLINE_HOOKS_LOG_PATH: path.join(dataDir, "logs", "hooks.jsonl"),
-	};
-}
-
-function runInteractiveCli(
-	steps: KeyStep[],
-	options?: {
-		launchConfigView?: boolean;
-		launchArgs?: string[];
-		env?: NodeJS.ProcessEnv;
-	},
-): CliResult {
-	const env = options?.env ?? createCliEnv();
-
 	const scriptedInput = [
 		...steps,
 		// Exit each interactive run explicitly so tests do not idle until timeout.
@@ -106,13 +80,9 @@ function runInteractiveCli(
 		"-k",
 		"test-key",
 	];
-	const launchArgs = (
-		options?.launchArgs
-			? [cliEntry, ...options.launchArgs]
-			: options?.launchConfigView
-				? [...baseArgs, "config"]
-				: baseArgs
-	)
+	const launchArgs = [
+		...(options?.launchConfigView ? [...baseArgs, "config"] : baseArgs),
+	]
 		.map((arg) => toShellSingleQuotedLiteral(arg))
 		.join(" ");
 	const command = buildScriptCommand(scriptedInput, launchArgs);
@@ -120,7 +90,21 @@ function runInteractiveCli(
 	return spawnSync("bash", ["-lc", command], {
 		cwd: cliRoot,
 		encoding: "utf8",
-		env,
+		env: {
+			...process.env,
+			HOME: homeDir,
+			CLINE_DATA_DIR: dataDir,
+			CLINE_DB_DATA_DIR: path.join(dataDir, "db"),
+			CLINE_SESSION_DATA_DIR: sessionDir,
+			CLINE_TEAM_DATA_DIR: teamDir,
+			CLINE_SESSION_BACKEND_MODE: "local",
+			CLINE_PROVIDER_SETTINGS_PATH: path.join(
+				dataDir,
+				"settings",
+				"providers.json",
+			),
+			CLINE_HOOKS_LOG_PATH: path.join(dataDir, "logs", "hooks.jsonl"),
+		},
 		timeout: INTERACTIVE_TEST_TIMEOUT_MS,
 		maxBuffer: 10 * 1024 * 1024,
 	});
@@ -204,62 +188,6 @@ describe("cli interactive e2e", () => {
 		expect(output).toContain("/ for commands · @ for files");
 	});
 
-	it("resumes a history-picked session and survives Ctrl+C without a native crash", {
-		timeout: 120_000,
-	}, () => {
-		const env = createCliEnv();
-		// Seed one session; the invalid key makes the run fail fast while
-		// still persisting a resumable session record.
-		const seed = spawnSync(
-			bunExec,
-			[
-				cliEntry,
-				"--provider",
-				"anthropic",
-				"-m",
-				"claude-sonnet-4-6",
-				"-k",
-				"test-key",
-				"hello",
-			],
-			{ cwd: cliRoot, encoding: "utf8", env, timeout: 60_000 },
-		);
-		expect(seed.error).toBeUndefined();
-		const history = spawnSync(bunExec, [cliEntry, "history", "--json"], {
-			cwd: cliRoot,
-			encoding: "utf8",
-			env,
-			timeout: 60_000,
-		});
-		expect(history.error).toBeUndefined();
-		expect(history.status).toBe(0);
-		const historyRows = JSON.parse(history.stdout) as unknown[];
-		expect(historyRows.length).toBeGreaterThan(0);
-
-		// history picker -> Enter resumes the seeded session in the
-		// interactive TUI -> double Ctrl+C exits it. Regression guard for
-		// the Bun "panic(main thread): Segmentation fault" that occurred
-		// when the resumed TUI shared the picker's process (a second
-		// OpenTUI renderer in one process crashes natively on teardown).
-		const result = runInteractiveCli(
-			[
-				// Select the seeded session in the picker.
-				{ delaySeconds: HISTORY_PICKER_READY_DELAY_SECONDS, input: "\r" },
-				// Give the resumed TUI time to start, then double-press
-				// Ctrl+C; the harness appends the final press 0.2s later.
-				{ delaySeconds: HISTORY_RESUME_READY_DELAY_SECONDS, input: "\u0003" },
-			],
-			{ launchArgs: ["history"], env },
-		);
-		const output = outputOf(result);
-		// The exit summary only prints after the resumed interactive TUI ran
-		// and shut down cleanly; the history picker alone never prints it.
-		expect(output).toContain("Session Summary");
-		expect(output).not.toContain("panic(");
-		expect(output).not.toContain("Segmentation fault");
-		expect(result.status).toBe(0);
-	});
-
 	it("launches config view directly with `cline config`", () => {
 		const result = runInteractiveCli(
 			[{ delaySeconds: INITIAL_RENDER_DELAY_SECONDS, input: "" }],

apps/cli/src/commands/auth.test.ts

@@ -2,37 +2,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import type { ProviderSettingsManager } from "@cline/core";
 import { describe, expect, it, vi } from "vitest";
-import {
-	getPersistedProviderApiKey,
-	normalizeAuthProviderId,
-	parseAuthCommandArgs,
-	saveOAuthProviderSettings,
-} from "./auth";
-
-describe("parseAuthCommandArgs", () => {
-	it("parses Azure API version quick setup option", () => {
-		expect(
-			parseAuthCommandArgs([
-				"--provider",
-				"openai-compatible",
-				"--apikey",
-				"key",
-				"--modelid",
-				"gpt-4.1",
-				"--baseurl",
-				"https://example.openai.azure.com/openai/deployments/gpt-4.1",
-				"--azure-api-version",
-				"2025-01-01-preview",
-			]),
-		).toMatchObject({
-			explicitProvider: "openai-compatible",
-			apikey: "key",
-			modelid: "gpt-4.1",
-			baseurl: "https://example.openai.azure.com/openai/deployments/gpt-4.1",
-			azureApiVersion: "2025-01-01-preview",
-		});
-	});
-});
+import { getPersistedProviderApiKey, saveOAuthProviderSettings } from "./auth";
 
 describe("saveOAuthProviderSettings", () => {
 	it("preserves existing manual apiKey while updating OAuth tokens", () => {
@@ -97,12 +67,6 @@ describe("getPersistedProviderApiKey", () => {
 	});
 });
 
-describe("normalizeAuthProviderId", () => {
-	it("keeps CLI-only codex shorthand in CLI parsing", () => {
-		expect(normalizeAuthProviderId("codex")).toBe("openai-codex");
-	});
-});
-
 describe("loadAuthTuiRuntime", () => {
 	it("loads OpenTUI React after provider catalog initialization", async () => {
 		const cliRoot = fileURLToPath(new URL("../..", import.meta.url));

apps/cli/src/commands/auth.ts

@@ -3,12 +3,11 @@ import {
 	BUILT_IN_PROVIDER,
 	createOAuthClientCallbacks,
 	ensureCustomProvidersLoaded,
-	getProviderAuthHandler,
-	loginAndSaveProviderOAuthCredentials,
+	listLocalProviders,
 	type ProviderSettings,
 	type ProviderSettingsManager,
-	saveProviderOAuthCredentials,
 } from "@cline/core";
+import { getClineEnvironmentConfig } from "@cline/shared";
 import { Command } from "commander";
 import open from "open";
 import React from "react";
@@ -21,8 +20,6 @@ import {
 	type OAuthCredentials,
 	toProviderApiKey,
 } from "../utils/provider-auth";
-import { listLocalProviders } from "../utils/provider-catalog";
-import { identifyTelemetryAccount } from "../utils/telemetry";
 
 export {
 	getPersistedProviderApiKey,
@@ -40,6 +37,40 @@ const c = {
 	green: "\x1b[32m",
 };
 
+type CoreOAuthApi = {
+	loginClineOAuth: (input: {
+		apiBaseUrl: string;
+		useWorkOSDeviceAuth?: boolean;
+		callbacks: {
+			onAuth: (info: { url: string; instructions?: string }) => void;
+			onPrompt: (prompt: {
+				message: string;
+				defaultValue?: string;
+			}) => Promise<string>;
+			onManualCodeInput?: () => Promise<string>;
+		};
+	}) => Promise<OAuthCredentials>;
+	loginOcaOAuth: (input: {
+		mode?: "internal" | "external";
+		callbacks: {
+			onAuth: (info: { url: string; instructions?: string }) => void;
+			onPrompt: (prompt: {
+				message: string;
+				defaultValue?: string;
+			}) => Promise<string>;
+			onManualCodeInput?: () => Promise<string>;
+		};
+	}) => Promise<OAuthCredentials>;
+	loginOpenAICodex: (input: {
+		onAuth: (info: { url: string; instructions?: string }) => void;
+		onPrompt: (prompt: {
+			message: string;
+			defaultValue?: string;
+		}) => Promise<string>;
+		onManualCodeInput?: () => Promise<string>;
+	}) => Promise<OAuthCredentials>;
+};
+
 type AuthIo = {
 	writeln: (text?: string) => void;
 	writeErr: (text: string) => void;
@@ -50,7 +81,6 @@ type AuthQuickSetupInput = {
 	apikey: string;
 	modelid: string;
 	baseurl?: string;
-	azureApiVersion?: string;
 };
 
 type AuthCommandInput = {
@@ -60,7 +90,6 @@ type AuthCommandInput = {
 	apikey?: string;
 	modelid?: string;
 	baseurl?: string;
-	azureApiVersion?: string;
 };
 
 type ParsedAuthCommandArgs = {
@@ -68,10 +97,30 @@ type ParsedAuthCommandArgs = {
 	apikey?: string;
 	modelid?: string;
 	baseurl?: string;
-	azureApiVersion?: string;
 	parseError?: string;
 };
 
+let cachedCoreOAuthApi: Promise<CoreOAuthApi> | undefined;
+
+async function getCoreOAuthApi(): Promise<CoreOAuthApi> {
+	if (!cachedCoreOAuthApi) {
+		cachedCoreOAuthApi = import("@cline/core").then((module) => {
+			const runtimeApi = module as Partial<CoreOAuthApi>;
+			if (
+				typeof runtimeApi.loginClineOAuth !== "function" ||
+				typeof runtimeApi.loginOcaOAuth !== "function" ||
+				typeof runtimeApi.loginOpenAICodex !== "function"
+			) {
+				throw new Error(
+					"Installed @cline/core does not expose OAuth login helpers required by the CLI",
+				);
+			}
+			return runtimeApi as CoreOAuthApi;
+		});
+	}
+	return cachedCoreOAuthApi;
+}
+
 /**
  * Create the `auth` subcommand for Commander.
  *
@@ -88,8 +137,7 @@ export function createAuthCommand(): Command {
 		.option("-p, --provider <id>", "provider id")
 		.option("-k, --apikey <key>", "API key")
 		.option("-m, --modelid <id>", "model id")
-		.option("-b, --baseurl <url>", "base URL")
-		.option("--azure-api-version <version>", "Azure API version");
+		.option("-b, --baseurl <url>", "base URL");
 	return cmd;
 }
 
@@ -106,7 +154,6 @@ export function parseAuthCommandArgs(args: string[]): ParsedAuthCommandArgs {
 		apikey?: string;
 		modelid?: string;
 		baseurl?: string;
-		azureApiVersion?: string;
 	}>();
 	const positionalProvider = cmd.args[0];
 	return {
@@ -114,7 +161,6 @@ export function parseAuthCommandArgs(args: string[]): ParsedAuthCommandArgs {
 		apikey: opts.apikey,
 		modelid: opts.modelid,
 		baseurl: opts.baseurl,
-		azureApiVersion: opts.azureApiVersion,
 	};
 }
 
@@ -154,12 +200,6 @@ async function ensureQuickSetupInputValid(
 	) {
 		return "base URL is only supported for OpenAI and OpenAI-compatible providers";
 	}
-	if (
-		input.azureApiVersion?.trim() &&
-		normalizedProvider !== BUILT_IN_PROVIDER.OPENAI_COMPATIBLE
-	) {
-		return "Azure API version is only supported for OpenAI-compatible providers";
-	}
 	return undefined;
 }
 
@@ -169,7 +209,6 @@ function saveQuickAuthProviderSettings(input: {
 	apikey: string;
 	modelid: string;
 	baseurl?: string;
-	azureApiVersion?: string;
 }): void {
 	const existing = input.providerSettingsManager.getProviderSettings(
 		input.providerId,
@@ -185,12 +224,6 @@ function saveQuickAuthProviderSettings(input: {
 	if (input.baseurl?.trim()) {
 		nextSettings.baseUrl = input.baseurl.trim();
 	}
-	if (input.azureApiVersion?.trim()) {
-		nextSettings.azure = {
-			...(nextSettings.azure ?? {}),
-			apiVersion: input.azureApiVersion.trim(),
-		};
-	}
 	input.providerSettingsManager.saveProviderSettings(nextSettings);
 }
 
@@ -239,18 +272,64 @@ function createOAuthCallbacks(io: AuthIo): {
 	});
 }
 
+async function loginWithOAuthProvider(
+	providerId: string,
+	existing: ProviderSettings | undefined,
+	io: AuthIo,
+): Promise<OAuthCredentials> {
+	const oauthApi = await getCoreOAuthApi();
+	const callbacks = createOAuthCallbacks(io);
+
+	if (providerId === "cline") {
+		return oauthApi.loginClineOAuth({
+			apiBaseUrl:
+				existing?.baseUrl?.trim() || getClineEnvironmentConfig().apiBaseUrl,
+			useWorkOSDeviceAuth: true,
+			callbacks,
+		});
+	}
+
+	if (providerId === "oca") {
+		const mode = existing?.oca?.mode;
+		return oauthApi.loginOcaOAuth({
+			mode,
+			callbacks,
+		});
+	}
+
+	if (providerId === "openai-codex") {
+		return oauthApi.loginOpenAICodex(callbacks);
+	}
+
+	throw new Error(
+		`Provider "${providerId}" does not support CLI OAuth flow (supported: cline, openai-codex, oca)`,
+	);
+}
+
 export function saveOAuthProviderSettings(
 	providerSettingsManager: ProviderSettingsManager,
 	providerId: string,
 	existing: ProviderSettings | undefined,
 	credentials: OAuthCredentials,
 ): ProviderSettings {
-	return saveProviderOAuthCredentials({
-		manager: providerSettingsManager,
-		providerId,
-		settings: existing,
-		credentials,
+	const auth = {
+		...(existing?.auth ?? {}),
+		accessToken: toProviderApiKey(providerId, credentials),
+		refreshToken: credentials.refresh,
+		accountId: credentials.accountId,
+	} as ProviderSettings["auth"] & { expiresAt?: number };
+	auth.expiresAt = credentials.expires;
+	const merged: ProviderSettings = {
+		...(existing ?? {
+			provider: providerId as ProviderSettings["provider"],
+		}),
+		provider: providerId as ProviderSettings["provider"],
+		auth,
+	};
+	providerSettingsManager.saveProviderSettings(merged, {
+		tokenSource: "oauth",
 	});
+	return merged;
 }
 
 export async function ensureOAuthProviderApiKey(input: {
@@ -269,14 +348,19 @@ export async function ensureOAuthProviderApiKey(input: {
 			selectedProviderSettings: input.existingSettings,
 		};
 	}
-	const selectedProviderSettings = await loginAndSaveProviderOAuthCredentials(
+	const credentials = await loginWithOAuthProvider(
+		input.providerId,
+		input.existingSettings,
+		input.io,
+	);
+	const selectedProviderSettings = saveOAuthProviderSettings(
 		input.providerSettingsManager,
 		input.providerId,
-		{ callbacks: createOAuthCallbacks(input.io) },
+		input.existingSettings,
+		credentials,
 	);
-	const handler = getProviderAuthHandler(input.providerId);
 	return {
-		apiKey: handler?.getApiKey(selectedProviderSettings),
+		apiKey: toProviderApiKey(input.providerId, credentials),
 		selectedProviderSettings,
 	};
 }
@@ -286,14 +370,12 @@ async function runQuickAuthSetup(input: AuthCommandInput): Promise<number> {
 	const apikey = input.apikey?.trim() ?? "";
 	const modelid = input.modelid?.trim() ?? "";
 	const baseurl = input.baseurl?.trim();
-	const azureApiVersion = input.azureApiVersion?.trim();
 	const validationError = await ensureQuickSetupInputValid(
 		{
 			provider: providerId,
 			apikey,
 			modelid,
 			baseurl,
-			azureApiVersion,
 		},
 		input.providerSettingsManager,
 	);
@@ -307,7 +389,6 @@ async function runQuickAuthSetup(input: AuthCommandInput): Promise<number> {
 		apikey,
 		modelid,
 		baseurl,
-		azureApiVersion,
 	});
 	input.io.writeln(
 		`${c.green}Provider configured:${c.reset} ${c.cyan}${providerId}${c.reset} (${modelid})`,
@@ -392,13 +473,12 @@ export async function runAuthCommand(input: AuthCommandInput): Promise<number> {
 	const hasQuickSetupFlags =
 		typeof input.apikey === "string" ||
 		typeof input.modelid === "string" ||
-		typeof input.baseurl === "string" ||
-		typeof input.azureApiVersion === "string";
+		typeof input.baseurl === "string";
 
 	if (hasQuickSetupFlags) {
 		if (!input.explicitProvider?.trim()) {
 			input.io.writeErr(
-				"auth quick setup requires --provider <id> when using --apikey/--modelid/--baseurl/--azure-api-version",
+				"auth quick setup requires --provider <id> when using --apikey/--modelid/--baseurl",
 			);
 			return 1;
 		}
@@ -435,15 +515,14 @@ export async function runAuthProviderCommand(
 		return 1;
 	}
 	try {
-		const settings = await loginAndSaveProviderOAuthCredentials(
+		const existing = providerSettingsManager.getProviderSettings(providerId);
+		const credentials = await loginWithOAuthProvider(providerId, existing, io);
+		saveOAuthProviderSettings(
 			providerSettingsManager,
 			providerId,
-			{ callbacks: createOAuthCallbacks(io) },
+			existing,
+			credentials,
 		);
-		identifyTelemetryAccount({
-			id: settings.auth?.accountId,
-			provider: providerId,
-		});
 		io.writeln(
 			`${c.green}You are now logged in to ${c.cyan}${providerId}${c.reset}`,
 		);

apps/cli/src/commands/dashboard.test.ts

@@ -6,15 +6,6 @@ import { runDashboardCommand, waitForProcessShutdown } from "./dashboard";
 
 const ENV_KEYS = [
 	"WORKSPACE_ROOT",
-	"CLINE_DIR",
-	"CLINE_SANDBOX",
-	"CLINE_SANDBOX_DATA_DIR",
-	"CLINE_DATA_DIR",
-	"CLINE_DB_DATA_DIR",
-	"CLINE_SESSION_DATA_DIR",
-	"CLINE_TEAM_DATA_DIR",
-	"CLINE_PROVIDER_SETTINGS_PATH",
-	"CLINE_HOOKS_LOG_PATH",
 	"HOST",
 	"CLINE_HUB_DASHBOARD_PORT",
 	"PUBLIC_URL",
@@ -47,9 +38,6 @@ describe("runDashboardCommand", () => {
 		let observedEnv:
 			| {
 					workspaceRoot: string | undefined;
-					clineDir: string | undefined;
-					clineDataDir: string | undefined;
-					providerSettingsPath: string | undefined;
 					host: string | undefined;
 					port: string | undefined;
 					publicUrl: string | undefined;
@@ -62,9 +50,7 @@ describe("runDashboardCommand", () => {
 		process.env.CLINE_HUB_WEBVIEW_DIST_DIR = webviewDistDir;
 
 		const exitCode = await runDashboardCommand({
-			configDir: "/tmp/cline-config",
 			cwd: "sdk",
-			dataDir: ".cline-dashboard-data",
 			host: "127.0.0.1",
 			port: "9090",
 			publicUrl: "http://127.0.0.1:9090",
@@ -76,9 +62,6 @@ describe("runDashboardCommand", () => {
 			startServer: async () => {
 				observedEnv = {
 					workspaceRoot: process.env.WORKSPACE_ROOT,
-					clineDir: process.env.CLINE_DIR,
-					clineDataDir: process.env.CLINE_DATA_DIR,
-					providerSettingsPath: process.env.CLINE_PROVIDER_SETTINGS_PATH,
 					host: process.env.HOST,
 					port: process.env.CLINE_HUB_DASHBOARD_PORT,
 					publicUrl: process.env.PUBLIC_URL,
@@ -104,13 +87,6 @@ describe("runDashboardCommand", () => {
 		expect(exitCode).toBe(0);
 		expect(observedEnv).toEqual({
 			workspaceRoot: resolve("sdk"),
-			clineDir: "/tmp/cline-config",
-			clineDataDir: resolve("sdk", ".cline-dashboard-data"),
-			providerSettingsPath: join(
-				resolve("sdk", ".cline-dashboard-data"),
-				"settings",
-				"providers.json",
-			),
 			host: "127.0.0.1",
 			port: "9090",
 			publicUrl: "http://127.0.0.1:9090",

apps/cli/src/commands/dashboard.ts

@@ -3,7 +3,6 @@ import { arch, platform } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import open from "open";
-import { configureSandboxEnvironment } from "../utils/helpers";
 import { c } from "../utils/output";
 
 export interface DashboardServerHandle {
@@ -20,9 +19,7 @@ interface DashboardCommandIo {
 }
 
 export interface RunDashboardCommandOptions {
-	configDir?: string;
 	cwd?: string;
-	dataDir?: string;
 	host?: string;
 	port?: string;
 	publicUrl?: string;
@@ -39,9 +36,10 @@ const WEBVIEW_DIST_ENV = "CLINE_HUB_WEBVIEW_DIST_DIR";
 
 function setEnvValue(name: string, value: string | undefined): () => void {
 	const previous = process.env[name];
-	if (value !== undefined) {
-		process.env[name] = value;
+	if (value === undefined) {
+		return () => {};
 	}
+	process.env[name] = value;
 	return () => {
 		if (previous === undefined) {
 			delete process.env[name];
@@ -51,39 +49,21 @@ function setEnvValue(name: string, value: string | undefined): () => void {
 	};
 }
 
-const SANDBOX_ENV_KEYS = [
-	"CLINE_SANDBOX",
-	"CLINE_SANDBOX_DATA_DIR",
-	"CLINE_DATA_DIR",
-	"CLINE_DB_DATA_DIR",
-	"CLINE_SESSION_DATA_DIR",
-	"CLINE_TEAM_DATA_DIR",
-	"CLINE_PROVIDER_SETTINGS_PATH",
-	"CLINE_HOOKS_LOG_PATH",
-] as const;
-
 async function withDashboardEnvironment<T>(
 	options: RunDashboardCommandOptions,
 	fn: () => Promise<T>,
 ): Promise<T> {
-	const cwd = options.cwd ? resolve(options.cwd) : process.cwd();
 	const restore = [
-		setEnvValue("WORKSPACE_ROOT", options.cwd ? cwd : undefined),
-		setEnvValue("CLINE_DIR", options.configDir?.trim() || undefined),
+		setEnvValue(
+			"WORKSPACE_ROOT",
+			options.cwd ? resolve(options.cwd) : undefined,
+		),
 		setEnvValue("HOST", options.host),
 		setEnvValue(DASHBOARD_PORT_ENV, options.port),
 		setEnvValue("PUBLIC_URL", options.publicUrl),
 		setEnvValue("ROOM_SECRET", options.roomSecret),
 		setEnvValue(WEBVIEW_DIST_ENV, resolveDefaultWebviewDistDir()),
-		...SANDBOX_ENV_KEYS.map((key) => setEnvValue(key, undefined)),
 	];
-	if (options.dataDir || process.env.CLINE_SANDBOX?.trim() === "1") {
-		configureSandboxEnvironment({
-			enabled: true,
-			cwd,
-			explicitDir: options.dataDir,
-		});
-	}
 	try {
 		return await fn();
 	} finally {

apps/cli/src/commands/doctor.test.ts

@@ -14,7 +14,6 @@ import { getCliBuildInfo } from "../utils/common";
 const {
 	mockSpawnSync,
 	mockResolveClineDataDir,
-	mockResolveProductionHubOwnerContext,
 	mockResolveSharedHubOwnerContext,
 	mockReadHubDiscovery,
 	mockProbeHubServer,
@@ -25,15 +24,6 @@ const {
 } = vi.hoisted(() => ({
 	mockSpawnSync: vi.fn(),
 	mockResolveClineDataDir: vi.fn(() => "/tmp/cline-data"),
-	mockResolveProductionHubOwnerContext: vi.fn(() => ({
-		ownerId: "hub-production",
-		discoveryPath: path.join(
-			"/tmp/cline-data",
-			"locks",
-			"hub",
-			"production.json",
-		),
-	})),
 	mockResolveSharedHubOwnerContext: vi.fn(() => ({
 		ownerId: "hub-owner",
 		discoveryPath: path.join(
@@ -62,7 +52,6 @@ vi.mock("node:child_process", () => ({
 
 vi.mock("@cline/core", () => ({
 	resolveClineDataDir: mockResolveClineDataDir,
-	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
 	clearHubDiscovery: mockClearHubDiscovery,
 	probeHubServer: mockProbeHubServer,
@@ -87,15 +76,6 @@ describe("runDoctorCommand", () => {
 	afterEach(() => {
 		vi.clearAllMocks();
 		mockResolveClineDataDir.mockReturnValue("/tmp/cline-data");
-		mockResolveProductionHubOwnerContext.mockReturnValue({
-			ownerId: "hub-production",
-			discoveryPath: path.join(
-				"/tmp/cline-data",
-				"locks",
-				"hub",
-				"production.json",
-			),
-		});
 		mockStopLocalHubServerGracefully.mockResolvedValue(false);
 		mockStopAllConnectors.mockResolvedValue({
 			stoppedProcesses: 0,
@@ -130,8 +110,7 @@ describe("runDoctorCommand", () => {
 				command === "pgrep" &&
 				Array.isArray(args) &&
 				args[0] === "-fal" &&
-				args[1] === "--" &&
-				args[2] === "/apps/cli/src/index.ts"
+				args[1] === "/apps/cli/src/index.ts"
 			) {
 				return {
 					status: 0,
@@ -282,8 +261,7 @@ describe("runDoctorCommand", () => {
 				command === "pgrep" &&
 				Array.isArray(args) &&
 				args[0] === "-fal" &&
-				args[1] === "--" &&
-				args[2] === "/src-tauri/bin/code-sidecar"
+				args[1] === "/src-tauri/bin/code-sidecar"
 			) {
 				return {
 					status: 0,

apps/cli/src/commands/doctor.ts

@@ -7,11 +7,10 @@ import {
 	probeHubServer,
 	readHubDiscovery,
 	resolveClineDataDir,
-	resolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext,
 	stopLocalHubServerGracefully,
 } from "@cline/core";
-import { formatUptime, resolveClineBuildEnv } from "@cline/shared";
+import { formatUptime } from "@cline/shared";
 import { Command } from "commander";
 import open from "open";
 import { isProcessRunning } from "../connectors/common";
@@ -55,7 +54,6 @@ type DoctorStatus = {
 	hubStartedAt?: string;
 	hubUptime?: string;
 	listeningPids: number[];
-	staleHubPids: number[];
 	hubStartupLocks: StartupArtifact[];
 	staleCliPids: number[];
 	staleSidecarPids: number[];
@@ -79,11 +77,7 @@ function listMatchingProcesses(pattern: string): ProcessRecord[] {
 	if (process.platform === "win32") {
 		return [];
 	}
-	// "--" stops pgrep's option parsing so patterns that start with dashes
-	// (e.g. the "--cline-hub-daemon" marker) are treated as patterns.
-	const result = spawnSync("pgrep", ["-fal", "--", pattern], {
-		encoding: "utf8",
-	});
+	const result = spawnSync("pgrep", ["-fal", pattern], { encoding: "utf8" });
 	if (result.status !== 0 && result.status !== 1) {
 		return [];
 	}
@@ -154,25 +148,6 @@ function listStaleCliPids(): number[] {
 		.map((record) => record.pid);
 }
 
-function listStaleHubPids(currentHubPids: number[]): number[] {
-	const current = new Set(currentHubPids.filter((pid) => pid > 0));
-	const patterns = [
-		"/sdk/packages/core/src/hub/daemon/entry.ts",
-		"/sdk/packages/core/dist/hub/daemon/entry.js",
-		"--cline-hub-daemon",
-	];
-	const records = new Map<number, ProcessRecord>();
-	for (const pattern of patterns) {
-		for (const record of listMatchingProcesses(pattern)) {
-			if (current.has(record.pid) || /\bpgrep\s+-fal\b/.test(record.command)) {
-				continue;
-			}
-			records.set(record.pid, record);
-		}
-	}
-	return [...records.values()].map((record) => record.pid);
-}
-
 function listStaleSidecarPids(): number[] {
 	const patterns = [
 		"/apps/examples/desktop-app/sidecar/index.ts",
@@ -260,7 +235,7 @@ function readStartupArtifact(path: string): StartupArtifact | undefined {
 }
 
 function listHubStartupLocks(_cwd: string): StartupArtifact[] {
-	const owner = resolveCliHubOwnerContext();
+	const owner = resolveSharedHubOwnerContext();
 	const ownerPath = join(`${owner.discoveryPath}.lock`, "owner.json");
 	if (!existsSync(ownerPath)) {
 		return [];
@@ -284,7 +259,7 @@ async function clearHubStartupArtifacts(
 	_cwd: string,
 	options?: { clearDiscovery?: boolean },
 ): Promise<{ startupLocks: number; discovery: number }> {
-	const owner = resolveCliHubOwnerContext();
+	const owner = resolveSharedHubOwnerContext();
 	const startupLocks = listHubStartupLocks(_cwd);
 	let clearedStartupLocks = 0;
 	for (const artifact of startupLocks) {
@@ -316,25 +291,14 @@ function formatHubUptimeFromStartedAt(
 	return formatUptime(Date.now() - timestamp);
 }
 
-function resolveCliHubOwnerContext() {
-	return resolveClineBuildEnv() === "production"
-		? resolveProductionHubOwnerContext()
-		: resolveSharedHubOwnerContext();
-}
-
 async function collectDoctorStatus(cwd: string): Promise<DoctorStatus> {
-	const owner = resolveCliHubOwnerContext();
+	const owner = resolveSharedHubOwnerContext();
 	const discovery = await readHubDiscovery(owner.discoveryPath);
 	const health = discovery?.url
-		? await probeHubServer(discovery.url, { authToken: discovery.authToken })
+		? await probeHubServer(discovery.url)
 		: undefined;
 	const current = health ?? discovery;
 	const hubUptime = formatHubUptimeFromStartedAt(health?.startedAt);
-	const listeningPids = listListeningPids(current?.port);
-	const currentHubPids = [
-		...(current?.pid ? [current.pid] : []),
-		...listeningPids,
-	];
 	return {
 		cwd,
 		hubUrl: current?.url,
@@ -342,8 +306,7 @@ async function collectDoctorStatus(cwd: string): Promise<DoctorStatus> {
 		hubPid: current?.pid,
 		hubStartedAt: health?.startedAt,
 		hubUptime,
-		listeningPids,
-		staleHubPids: listStaleHubPids(currentHubPids),
+		listeningPids: listListeningPids(current?.port),
 		hubStartupLocks: listHubStartupLocks(cwd),
 		staleCliPids: listStaleCliPids(),
 		staleSidecarPids: listStaleSidecarPids(),
@@ -425,7 +388,6 @@ export async function runDoctorCommand(
 		);
 		writeln(`hub uptime ${c.dim}${before.hubUptime ?? "n/a"}${c.reset}`);
 		writeln(formatPidList("hub listeners", before.listeningPids));
-		writeln(formatPidList("stale hub daemons", before.staleHubPids));
 		writeln(
 			formatPidList(
 				"hub startup locks",
@@ -450,7 +412,6 @@ export async function runDoctorCommand(
 		}
 		if (
 			before.listeningPids.length > 0 ||
-			before.staleHubPids.length > 0 ||
 			before.staleCliPids.length > 0 ||
 			before.staleSidecarPids.length > 0
 		) {
@@ -462,9 +423,7 @@ export async function runDoctorCommand(
 	}
 
 	const gracefullyStoppedHub = before.hubHealthy
-		? await stopLocalHubServerGracefully(resolveCliHubOwnerContext()).catch(
-				() => false,
-			)
+		? await stopLocalHubServerGracefully().catch(() => false)
 		: false;
 	const refreshedAfterGracefulStop = gracefullyStoppedHub
 		? await collectDoctorStatus(opts.cwd)
@@ -472,20 +431,13 @@ export async function runDoctorCommand(
 	const killedHub = gracefullyStoppedHub
 		? 0
 		: killPids(refreshedAfterGracefulStop.listeningPids);
-	const staleHubTargets = before.staleHubPids.filter(
-		(pid) => !refreshedAfterGracefulStop.listeningPids.includes(pid),
-	);
-	const killedStaleHubs = killPids(staleHubTargets);
 	const staleCliTargets = before.staleCliPids.filter(
-		(pid) =>
-			!refreshedAfterGracefulStop.listeningPids.includes(pid) &&
-			!staleHubTargets.includes(pid),
+		(pid) => !refreshedAfterGracefulStop.listeningPids.includes(pid),
 	);
 	const killedCli = killPids(staleCliTargets);
 	const staleSidecarTargets = before.staleSidecarPids.filter(
 		(pid) =>
 			!refreshedAfterGracefulStop.listeningPids.includes(pid) &&
-			!staleHubTargets.includes(pid) &&
 			!staleCliTargets.includes(pid),
 	);
 	const killedSidecars = killPids(staleSidecarTargets);
@@ -507,7 +459,6 @@ export async function runDoctorCommand(
 				after,
 				killed: {
 					hubListeners: killedHub,
-					staleHubDaemons: killedStaleHubs,
 					cliProcesses: killedCli,
 					sidecarProcesses: killedSidecars,
 					connectorProcesses: stoppedConnectors.stoppedProcesses,
@@ -520,7 +471,6 @@ export async function runDoctorCommand(
 		return 0;
 	}
 	writeln(`killed hub listeners ${c.dim}${killedHub}${c.reset}`);
-	writeln(`killed stale hub daemons ${c.dim}${killedStaleHubs}${c.reset}`);
 	writeln(`killed cli processes ${c.dim}${killedCli}${c.reset}`);
 	writeln(`killed sidecar processes ${c.dim}${killedSidecars}${c.reset}`);
 	writeln(
@@ -537,7 +487,6 @@ export async function runDoctorCommand(
 	);
 	writeln(`hub healthy after fix: ${after.hubHealthy ? "yes" : "no"}`);
 	writeln(formatPidList("remaining hub listeners", after.listeningPids));
-	writeln(formatPidList("remaining stale hub daemons", after.staleHubPids));
 	writeln(
 		formatPidList(
 			"remaining hub startup locks",

apps/cli/src/commands/hub.test.ts

@@ -1,11 +1,10 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 const {
 	mockClearHubDiscovery,
 	mockEnsureDetachedHubServer,
 	mockProbeHubServer,
 	mockReadHubDiscovery,
-	mockResolveProductionHubOwnerContext,
 	mockResolveSharedHubOwnerContext,
 	mockStopLocalHubServerGracefully,
 } = vi.hoisted(() => ({
@@ -13,10 +12,6 @@ const {
 	mockEnsureDetachedHubServer: vi.fn(),
 	mockProbeHubServer: vi.fn(),
 	mockReadHubDiscovery: vi.fn(),
-	mockResolveProductionHubOwnerContext: vi.fn(() => ({
-		ownerId: "hub-production",
-		discoveryPath: "/tmp/cline-data/locks/hub/production.json",
-	})),
 	mockResolveSharedHubOwnerContext: vi.fn(() => ({
 		ownerId: "hub-owner",
 		discoveryPath: "/tmp/cline-data/locks/hub/owners/hub-owner.json",
@@ -29,25 +24,13 @@ vi.mock("@cline/core", () => ({
 	ensureDetachedHubServer: mockEnsureDetachedHubServer,
 	probeHubServer: mockProbeHubServer,
 	readHubDiscovery: mockReadHubDiscovery,
-	resolveProductionHubOwnerContext: mockResolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext: mockResolveSharedHubOwnerContext,
 	stopLocalHubServerGracefully: mockStopLocalHubServerGracefully,
 }));
 
 import { createHubCommand } from "./hub";
 
-const originalBuildEnv = process.env.CLINE_BUILD_ENV;
-
 describe("createHubCommand", () => {
-	afterEach(() => {
-		vi.clearAllMocks();
-		if (originalBuildEnv === undefined) {
-			delete process.env.CLINE_BUILD_ENV;
-		} else {
-			process.env.CLINE_BUILD_ENV = originalBuildEnv;
-		}
-	});
-
 	it("includes uptime in hub status output", async () => {
 		vi.spyOn(Date, "now").mockReturnValue(
 			new Date("2026-01-01T00:01:05.000Z").getTime(),
@@ -90,37 +73,4 @@ describe("createHubCommand", () => {
 			uptime: "1m 5s",
 		});
 	});
-
-	it("passes the selected owner to graceful stop", async () => {
-		process.env.CLINE_BUILD_ENV = "development";
-		mockReadHubDiscovery.mockResolvedValue({
-			url: "ws://127.0.0.1:25466/hub",
-			port: 25466,
-			pid: 50174,
-		});
-		mockStopLocalHubServerGracefully.mockResolvedValue(true);
-
-		const output: string[] = [];
-		let exitCode = 0;
-		const cmd = createHubCommand(
-			{
-				writeln: (text) => {
-					output.push(text ?? "");
-				},
-				writeErr: () => {},
-			},
-			(code) => {
-				exitCode = code;
-			},
-		);
-
-		await cmd.parseAsync(["stop"], { from: "user" });
-
-		expect(exitCode).toBe(0);
-		expect(mockStopLocalHubServerGracefully).toHaveBeenCalledWith({
-			ownerId: "hub-owner",
-			discoveryPath: "/tmp/cline-data/locks/hub/owners/hub-owner.json",
-		});
-		expect(JSON.parse(output[0] || "")).toEqual({ stopped: true });
-	});
 });

apps/cli/src/commands/hub.ts

@@ -3,11 +3,10 @@ import {
 	ensureDetachedHubServer,
 	probeHubServer,
 	readHubDiscovery,
-	resolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext,
 	stopLocalHubServerGracefully,
 } from "@cline/core";
-import { formatUptime, resolveClineBuildEnv } from "@cline/shared";
+import { formatUptime } from "@cline/shared";
 import { Command } from "commander";
 
 interface HubCommandIo {
@@ -16,9 +15,9 @@ interface HubCommandIo {
 }
 
 async function stopHubServer(_workspaceRoot: string): Promise<boolean> {
-	const owner = resolveCliHubOwnerContext();
+	const owner = resolveSharedHubOwnerContext();
 	const discovery = await readHubDiscovery(owner.discoveryPath);
-	if (await stopLocalHubServerGracefully(owner)) {
+	if (await stopLocalHubServerGracefully()) {
 		await clearHubDiscovery(owner.discoveryPath);
 		return true;
 	}
@@ -47,12 +46,6 @@ function formatHubUptimeFromStartedAt(
 	return formatUptime(Date.now() - timestamp);
 }
 
-function resolveCliHubOwnerContext() {
-	return resolveClineBuildEnv() === "production"
-		? resolveProductionHubOwnerContext()
-		: resolveSharedHubOwnerContext();
-}
-
 export function createHubCommand(
 	io: HubCommandIo,
 	setExitCode: (code: number) => void,
@@ -119,12 +112,10 @@ export function createHubCommand(
 
 	hub.command("status").action(
 		action(async () => {
-			const owner = resolveCliHubOwnerContext();
+			const owner = resolveSharedHubOwnerContext();
 			const discovery = await readHubDiscovery(owner.discoveryPath);
 			const health = discovery?.url
-				? await probeHubServer(discovery.url, {
-						authToken: discovery.authToken,
-					})
+				? await probeHubServer(discovery.url)
 				: undefined;
 			const uptime = formatHubUptimeFromStartedAt(health?.startedAt);
 			io.writeln(

apps/cli/src/commands/kanban.ts

@@ -168,8 +168,6 @@ export function buildKanbanSpawnOptions(
 		detached: shouldDetachKanbanProcess(platform),
 		...(platform === "win32" ? { shell: true } : {}),
 		...options,
-		// Prevent a console window from flashing on Windows.
-		windowsHide: true,
 	};
 }
 
@@ -180,8 +178,6 @@ function buildKanbanInstallSpawnOptions(
 	return {
 		detached: false,
 		stdio: "inherit",
-		// Prevent a console window from flashing on Windows.
-		windowsHide: true,
 		...(platform === "win32" ? { shell: true } : {}),
 		...options,
 	};
@@ -207,8 +203,6 @@ export function getInstalledKanbanVersion(): string | null {
 		const result = spawnSync(getKanbanCommand(), ["--version"], {
 			encoding: "utf8",
 			shell: process.platform === "win32",
-			// Prevent a console window from flashing on Windows.
-			windowsHide: true,
 		});
 		if (result.status !== 0) {
 			return null;

apps/cli/src/commands/mcp.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { buildMcpInstallDefaults, runMcpInstallCommand } from "./mcp";
-
-describe("mcp install command", () => {
-	it("builds stdio wizard defaults from command args", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "fs",
-				targetArgs: [
-					"npx",
-					"-y",
-					"@modelcontextprotocol/server-filesystem",
-					"/tmp/my dir",
-				],
-			}),
-		).toEqual({
-			name: "fs",
-			type: "stdio",
-			command: 'npx -y @modelcontextprotocol/server-filesystem "/tmp/my dir"',
-		});
-	});
-
-	it("builds remote wizard defaults and normalizes http transport", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "ctx7",
-				transport: "http",
-				targetArgs: ["https://mcp.context7.com/mcp"],
-			}),
-		).toEqual({
-			name: "ctx7",
-			type: "streamableHttp",
-			url: "https://mcp.context7.com/mcp",
-		});
-	});
-
-	it("normalizes streamable-http transport", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "docs",
-				transport: "streamable-http",
-				targetArgs: ["https://example.com/mcp"],
-			}),
-		).toEqual({
-			name: "docs",
-			type: "streamableHttp",
-			url: "https://example.com/mcp",
-		});
-	});
-
-	it("builds SSE wizard defaults", () => {
-		expect(
-			buildMcpInstallDefaults({
-				name: "events",
-				transport: "sse",
-				targetArgs: ["https://example.com/sse"],
-			}),
-		).toEqual({
-			name: "events",
-			type: "sse",
-			url: "https://example.com/sse",
-		});
-	});
-
-	it("rejects missing stdio command and invalid remote URL", () => {
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "fs",
-			}),
-		).toThrow(/requires a command/);
-
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "bad",
-				transport: "http",
-				targetArgs: ["not-a-url"],
-			}),
-		).toThrow(/Invalid MCP server URL/);
-	});
-
-	it("rejects remote URL schemes other than http and https", () => {
-		expect(() =>
-			buildMcpInstallDefaults({
-				name: "bad",
-				transport: "http",
-				targetArgs: ["file:///etc/passwd"],
-			}),
-		).toThrow(/only http and https are supported/);
-	});
-
-	it("opens the add wizard with prefilled defaults", async () => {
-		const runWizard = vi.fn(async () => 0);
-
-		const code = await runMcpInstallCommand({
-			name: "ctx7",
-			transport: "http",
-			targetArgs: ["https://mcp.context7.com/mcp"],
-			isTty: true,
-			runWizard,
-			io: { writeErr: vi.fn() },
-		});
-
-		expect(code).toBe(0);
-		expect(runWizard).toHaveBeenCalledWith({
-			name: "ctx7",
-			type: "streamableHttp",
-			url: "https://mcp.context7.com/mcp",
-		});
-	});
-
-	it("requires a TTY because it opens the wizard", async () => {
-		const writeErr = vi.fn();
-		const runWizard = vi.fn(async () => 0);
-
-		const code = await runMcpInstallCommand({
-			name: "ctx7",
-			transport: "http",
-			targetArgs: ["https://mcp.context7.com/mcp"],
-			isTty: false,
-			runWizard,
-			io: { writeErr },
-		});
-
-		expect(code).toBe(1);
-		expect(runWizard).not.toHaveBeenCalled();
-		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-
-	it("checks for TTY before validating install arguments", async () => {
-		const writeErr = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "fs",
-			isTty: false,
-			io: { writeErr },
-		});
-
-		expect(code).toBe(1);
-		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY.",
-		);
-	});
-});

apps/cli/src/commands/mcp.ts

@@ -1,121 +0,0 @@
-import type { McpAddDefaults } from "../wizards/mcp";
-
-export interface McpCommandIo {
-	writeErr: (text: string) => void;
-}
-
-export interface McpInstallOptions {
-	name: string;
-	targetArgs?: string[];
-	transport?: string;
-	io?: McpCommandIo;
-	isTty?: boolean;
-	runWizard?: (defaults: McpAddDefaults) => Promise<number>;
-}
-
-function normalizeTransportType(
-	value: string | undefined,
-): McpAddDefaults["type"] {
-	const normalized = (value ?? "stdio").trim();
-	if (normalized === "http" || normalized === "streamable-http") {
-		return "streamableHttp";
-	}
-	if (
-		normalized === "stdio" ||
-		normalized === "sse" ||
-		normalized === "streamableHttp"
-	) {
-		return normalized;
-	}
-	throw new Error(
-		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
-	);
-}
-
-function assertValidUrl(url: string): void {
-	let parsed: URL;
-	try {
-		parsed = new URL(url);
-	} catch {
-		throw new Error(`Invalid MCP server URL: ${url}`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error(
-			`Invalid MCP server URL: ${url} (only http and https are supported)`,
-		);
-	}
-}
-
-function quoteCommandArg(arg: string): string {
-	if (/^[^\s"'\\]+$/.test(arg)) {
-		return arg;
-	}
-	return `"${arg.replace(/(["\\])/g, "\\$1")}"`;
-}
-
-export function buildMcpInstallDefaults(options: {
-	name: string;
-	targetArgs?: string[];
-	transport?: string;
-}): McpAddDefaults {
-	const name = options.name.trim();
-	if (!name) {
-		throw new Error("MCP server name is required");
-	}
-	const type = normalizeTransportType(options.transport);
-	const targetArgs = options.targetArgs ?? [];
-	if (type === "stdio") {
-		if (targetArgs.length === 0) {
-			throw new Error(
-				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp",
-			);
-		}
-		return {
-			name,
-			type,
-			command: targetArgs.map(quoteCommandArg).join(" "),
-		};
-	}
-
-	if (targetArgs.length !== 1) {
-		throw new Error(
-			"Remote MCP install requires exactly one URL argument after the server name.",
-		);
-	}
-	const url = targetArgs[0]?.trim() ?? "";
-	assertValidUrl(url);
-	return {
-		name,
-		type,
-		url,
-	};
-}
-
-async function runPrefilledWizard(defaults: McpAddDefaults): Promise<number> {
-	const { runMcpWizard } = await import("../wizards/mcp");
-	return runMcpWizard({
-		initialAction: "add",
-		addDefaults: defaults,
-		exitAfterInitialAction: true,
-	});
-}
-
-export async function runMcpInstallCommand(
-	options: McpInstallOptions,
-): Promise<number> {
-	try {
-		const isTty =
-			options.isTty ?? (process.stdin.isTTY && process.stdout.isTTY);
-		if (!isTty) {
-			throw new Error(
-				"cline mcp install opens the MCP wizard and requires a TTY.",
-			);
-		}
-		const defaults = buildMcpInstallDefaults(options);
-		return await (options.runWizard ?? runPrefilledWizard)(defaults);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		options.io?.writeErr(message);
-		return 1;
-	}
-}

apps/cli/src/commands/plugin.test.ts

@@ -17,12 +17,10 @@ import {
 } from "@cline/shared/storage";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
-	collectPluginMcpOAuthCandidates,
 	installPlugin,
 	isOfficialPluginSlug,
 	parsePluginSource,
 	runPluginInstallCommand,
-	runPluginUninstallCommand,
 } from "./plugin";
 
 type FetchCall = (
@@ -36,7 +34,6 @@ describe("plugin install command", () => {
 	let originalHome: string | undefined;
 	let originalClineDir: string | undefined;
 	let originalClineDataDir: string | undefined;
-	let originalMcpSettingsPath: string | undefined;
 
 	beforeEach(() => {
 		root = mkdtempSync(join(tmpdir(), "cli-plugin-install-"));
@@ -45,7 +42,6 @@ describe("plugin install command", () => {
 		originalHome = process.env.HOME;
 		originalClineDir = process.env.CLINE_DIR;
 		originalClineDataDir = process.env.CLINE_DATA_DIR;
-		originalMcpSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
 		process.env.HOME = home;
 		process.env.CLINE_DIR = join(home, ".cline");
 		process.env.CLINE_DATA_DIR = join(home, ".cline", "data");
@@ -94,11 +90,6 @@ describe("plugin install command", () => {
 		} else {
 			process.env.CLINE_DATA_DIR = originalClineDataDir;
 		}
-		if (originalMcpSettingsPath === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = originalMcpSettingsPath;
-		}
 		rmSync(root, { recursive: true, force: true });
 	});
 
@@ -247,10 +238,6 @@ describe("plugin install command", () => {
 		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
 			"official-web-search",
 		);
-		const wrapperManifest = JSON.parse(
-			readFileSync(join(result.installPath, "package.json"), "utf8"),
-		) as { name?: string };
-		expect(wrapperManifest.name).toBe("web-search");
 		expect(existsSync(join(result.installPath, "repo"))).toBe(false);
 		expect(
 			existsSync(join(result.installPath, "package", "other-plugin")),
@@ -340,10 +327,6 @@ describe("plugin install command", () => {
 		expect(result.installPath).toContain(
 			join(workspace, ".cline", "plugins", "_installed", "local"),
 		);
-		const wrapperManifest = JSON.parse(
-			readFileSync(join(result.installPath, "package.json"), "utf8"),
-		) as { name?: string };
-		expect(wrapperManifest.name).toBe("web-search");
 		expect(readFileSync(result.entryPaths[0] ?? "", "utf8")).toContain(
 			"local-web-search",
 		);
@@ -472,8 +455,7 @@ describe("plugin install command", () => {
 
 		const wrapperManifest = JSON.parse(
 			readFileSync(join(result.installPath, "package.json"), "utf8"),
-		) as { name?: string; cline?: { plugins?: Array<{ paths?: string[] }> } };
-		expect(wrapperManifest.name).toBe("plugin-package");
+		) as { cline?: { plugins?: Array<{ paths?: string[] }> } };
 		expect(wrapperManifest.cline?.plugins?.[0]?.paths).toHaveLength(1);
 		expect(wrapperManifest.cline?.plugins?.[0]?.paths?.[0]).toContain(
 			"package/index.ts",
@@ -611,54 +593,6 @@ describe("plugin install command", () => {
 		).toContain("installed-v1");
 	});
 
-	it("uninstalls a package plugin by package name", async () => {
-		const source = join(root, "uninstall-package");
-		const npmCommandPath = join(root, "fake-npm.sh");
-		await mkdir(source, { recursive: true });
-		await writeFile(
-			join(source, "package.json"),
-			JSON.stringify(
-				{
-					name: "cli-uninstall-plugin",
-					cline: {
-						plugins: [{ paths: ["./index.ts"], capabilities: ["tools"] }],
-					},
-				},
-				null,
-				2,
-			),
-			"utf8",
-		);
-		await writeFile(
-			join(source, "index.ts"),
-			"export default { name: 'cli-uninstall-plugin', manifest: { capabilities: ['tools'] } };",
-			"utf8",
-		);
-		writeFileSync(npmCommandPath, "#!/bin/sh\nexit 0\n", {
-			encoding: "utf8",
-			mode: 0o755,
-		});
-
-		const installed = await installPlugin({
-			source,
-			npmCommand: npmCommandPath,
-		});
-		const output: string[] = [];
-		const code = await runPluginUninstallCommand({
-			name: "cli-uninstall-plugin",
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(existsSync(installed.installPath)).toBe(false);
-		expect(output.join("\n")).toContain(
-			"Uninstalled plugin cli-uninstall-plugin",
-		);
-	});
-
 	it("prints JSON output for command callers", async () => {
 		const source = join(root, "json.ts");
 		writeFileSync(
@@ -684,341 +618,11 @@ describe("plugin install command", () => {
 			expect(code).toBe(0);
 			const parsed = JSON.parse(stdout.join("")) as { installPath: string };
 			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
-			expect("mcpOAuthCandidates" in parsed).toBe(false);
 		} finally {
 			process.stdout.write = originalWrite;
 		}
 	});
 
-	it("does not run MCP OAuth follow-up for JSON plugin installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "json-oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "json-oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "json-oauth-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const stdout: string[] = [];
-		const originalWrite = process.stdout.write;
-		const authorize = vi.fn();
-		process.stdout.write = ((chunk: string | Uint8Array) => {
-			stdout.push(String(chunk));
-			return true;
-		}) as typeof process.stdout.write;
-		try {
-			const code = await runPluginInstallCommand({
-				source,
-				json: true,
-				io: {
-					writeln: () => {},
-					writeErr: () => {},
-				},
-				mcpOAuth: {
-					interactive: true,
-					selectCandidates: async (candidates) => candidates,
-					authorize,
-				},
-			});
-			expect(code).toBe(0);
-			expect(authorize).not.toHaveBeenCalled();
-			const parsed = JSON.parse(stdout.join("")) as {
-				installPath: string;
-				mcpOAuthCandidates?: unknown;
-			};
-			expect(parsed.installPath).toContain(join(home, ".cline", "plugins"));
-			expect(parsed.mcpOAuthCandidates).toBeUndefined();
-		} finally {
-			process.stdout.write = originalWrite;
-		}
-	});
-
-	it("warns when plugin MCP settings sync fails after install", async () => {
-		const source = join(root, "mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "mcp-plugin",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const blockedDirectory = join(root, "not-a-directory");
-		writeFileSync(blockedDirectory, "file", "utf8");
-		const originalSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
-		process.env.CLINE_MCP_SETTINGS_PATH = join(
-			blockedDirectory,
-			"cline_mcp_settings.json",
-		);
-		const output: string[] = [];
-		try {
-			const code = await runPluginInstallCommand({
-				source,
-				io: {
-					writeln: (text = "") => output.push(text),
-					writeErr: (text) => output.push(text),
-				},
-			});
-
-			expect(code).toBe(0);
-			expect(output.join("\n")).toContain("Installed plugin from");
-			expect(output.join("\n")).toContain(
-				"Warning: failed to sync plugin MCP servers",
-			);
-			expect(output.join("\n")).toContain("mcp-plugin");
-		} finally {
-			if (originalSettingsPath === undefined) {
-				delete process.env.CLINE_MCP_SETTINGS_PATH;
-			} else {
-				process.env.CLINE_MCP_SETTINGS_PATH = originalSettingsPath;
-			}
-		}
-	});
-
-	it("detects plugin-owned remote MCP servers as OAuth candidates", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "oauth-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-
-		const result = await installPlugin({ source });
-
-		expect(result.mcpOAuthCandidates).toEqual([
-			expect.objectContaining({
-				name: "oauth-docs",
-				pluginName: "oauth-mcp-plugin",
-				transportType: "streamableHttp",
-			}),
-		]);
-	});
-
-	it("does not treat remote MCP servers with static headers as OAuth candidates", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "headers-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "headers-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "headers-docs",
-      transport: {
-        type: "streamableHttp",
-        url: "https://example.com/mcp",
-        headers: { Authorization: "Bearer token" },
-      },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-
-		const result = await installPlugin({ source });
-
-		expect(result.mcpOAuthCandidates).toEqual([]);
-	});
-
-	it("skips plugin MCP OAuth candidates that already have tokens", async () => {
-		const settingsPath = join(root, "mcp-settings.json");
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const source = join(root, "authorized-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "authorized-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "authorized-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const result = await installPlugin({ source });
-		const settings = JSON.parse(readFileSync(settingsPath, "utf8")) as {
-			mcpServers?: Record<string, { oauth?: unknown }>;
-		};
-		const server = settings.mcpServers?.["authorized-docs"];
-		if (!server) {
-			throw new Error("Expected authorized-docs MCP server to be written");
-		}
-		server.oauth = { tokens: { access_token: "oauth-token" } };
-		writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
-
-		expect(
-			collectPluginMcpOAuthCandidates({
-				pluginPaths: result.entryPaths,
-				settingsPath,
-			}),
-		).toEqual([]);
-	});
-
-	it("authorizes selected plugin MCP OAuth candidates during interactive installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "interactive-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "interactive-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "interactive-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const authorized: string[] = [];
-		const output: string[] = [];
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: true,
-				selectCandidates: async (candidates) => candidates,
-				authorize: async (candidate) => {
-					authorized.push(candidate.name);
-				},
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(authorized).toEqual(["interactive-docs"]);
-		expect(output.join("\n")).toContain("Installed plugin from");
-	});
-
-	it("keeps plugin install successful when MCP OAuth authorization fails", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "failing-oauth-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "failing-oauth-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "failing-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const output: string[] = [];
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: true,
-				selectCandidates: async (candidates) => candidates,
-				authorize: async () => {
-					throw new Error("oauth unavailable");
-				},
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(output.join("\n")).toContain(
-			"Warning: failed to authorize MCP server failing-docs: oauth unavailable",
-		);
-	});
-
-	it("prints guidance for plugin MCP OAuth candidates in non-interactive installs", async () => {
-		process.env.CLINE_MCP_SETTINGS_PATH = join(root, "mcp-settings.json");
-		const source = join(root, "non-interactive-mcp-plugin.js");
-		writeFileSync(
-			source,
-			`
-export default {
-  name: "non-interactive-mcp-plugin",
-  manifest: { capabilities: ["mcp"] },
-  setup(api) {
-    api.registerMcpServer({
-      name: "non-interactive-docs",
-      transport: { type: "streamableHttp", url: "https://example.com/mcp" },
-    })
-  },
-}
-`,
-			"utf8",
-		);
-		const output: string[] = [];
-		const authorize = vi.fn();
-
-		const code = await runPluginInstallCommand({
-			source,
-			io: {
-				writeln: (text = "") => output.push(text),
-				writeErr: (text) => output.push(text),
-			},
-			mcpOAuth: {
-				interactive: false,
-				authorize,
-			},
-		});
-
-		expect(code).toBe(0);
-		expect(authorize).not.toHaveBeenCalled();
-		expect(output.join("\n")).toContain(
-			"Plugin MCP servers may require OAuth authorization",
-		);
-		expect(output.join("\n")).toContain("non-interactive-docs");
-		expect(output.join("\n")).toContain('Run "cline mcp"');
-	});
-
 	it("prints JSON output for official plugin installs", async () => {
 		const officialPluginsRepo = await createOfficialPluginsRepo({
 			"json-plugin": {

apps/cli/src/commands/plugin.ts

@@ -12,24 +12,7 @@ import {
 } from "node:fs";
 import { cp, mkdir, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import {
-	basename,
-	dirname,
-	extname,
-	join,
-	relative,
-	resolve,
-	sep,
-} from "node:path";
-import {
-	type McpServerRegistration,
-	type PluginMcpSettingsSyncResult,
-	type PluginUninstallOptions,
-	resolveDefaultMcpSettingsPath,
-	resolveMcpServerRegistrations,
-	syncPluginMcpServersToSettings,
-	uninstallPlugin,
-} from "@cline/core";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import {
 	isPluginModulePath,
 	resolveClineDir,
@@ -44,31 +27,12 @@ export interface PluginInstallOptions {
 	npmCommand?: string;
 	officialPluginsRepo?: string;
 	io?: PluginInstallIo;
-	mcpOAuth?: PluginInstallMcpOAuthOptions;
 }
 
 export interface PluginInstallResult {
 	source: string;
 	installPath: string;
 	entryPaths: string[];
-	mcpSyncFailures: PluginMcpSettingsSyncResult["failures"];
-	mcpOAuthCandidates: PluginMcpOAuthCandidate[];
-}
-
-export interface PluginMcpOAuthCandidate {
-	name: string;
-	pluginName: string;
-	pluginPath: string;
-	transportType: "sse" | "streamableHttp";
-	lastError?: string;
-}
-
-export interface PluginInstallMcpOAuthOptions {
-	interactive?: boolean;
-	selectCandidates?: (
-		candidates: PluginMcpOAuthCandidate[],
-	) => Promise<PluginMcpOAuthCandidate[]>;
-	authorize?: (candidate: PluginMcpOAuthCandidate) => Promise<void>;
 }
 
 export interface PluginInstallIo {
@@ -504,25 +468,6 @@ function getInstallSourceKey(
 	return `local:${resolve(cwd, resolveHomePath(parsed.path))}`;
 }
 
-function getWrapperPackageName(
-	parsed: ParsedPluginSource,
-	cwd: string,
-): string {
-	if (parsed.type === "npm") {
-		return parsed.name;
-	}
-	if (parsed.type === "git") {
-		return sanitizeSegment(basename(parsed.path));
-	}
-	if (parsed.type === "remote") {
-		return sanitizeSegment(basename(parsed.filename, extname(parsed.filename)));
-	}
-	if (parsed.type === "official") {
-		return parsed.slug;
-	}
-	return sanitizeSegment(basename(resolve(cwd, resolveHomePath(parsed.path))));
-}
-
 async function runCommand(
 	command: string,
 	args: string[],
@@ -533,8 +478,6 @@ async function runCommand(
 			cwd: options.cwd,
 			stdio: ["ignore", "ignore", "pipe"],
 			env: process.env,
-			// Prevent a console window from flashing on Windows.
-			windowsHide: true,
 		});
 		let stderr = "";
 		child.stderr.on("data", (chunk) => {
@@ -721,7 +664,6 @@ function toWrapperEntryPaths(
 async function writeWrapperManifest(
 	wrapperRoot: string,
 	packageRoot: string,
-	packageName: string,
 ): Promise<string[]> {
 	const entryPaths = toWrapperEntryPaths(wrapperRoot, packageRoot);
 	await writeFile(
@@ -729,7 +671,7 @@ async function writeWrapperManifest(
 		JSON.stringify(
 			{
 				...WRAPPER_PACKAGE_JSON,
-				name: packageName,
+				name: `cline-installed-plugin-${hashSource(wrapperRoot)}`,
 				cline: {
 					plugins: [{ paths: entryPaths }],
 				},
@@ -1032,81 +974,6 @@ function replaceInstallPath(
 	}
 }
 
-function hasStaticHeaders(registration: McpServerRegistration): boolean {
-	const transport = registration.transport;
-	if (transport.type === "stdio") {
-		return false;
-	}
-	return (
-		transport.headers !== undefined && Object.keys(transport.headers).length > 0
-	);
-}
-
-function hasOAuthAccessToken(registration: McpServerRegistration): boolean {
-	const accessToken = registration.oauth?.tokens?.access_token;
-	return typeof accessToken === "string" && accessToken.trim().length > 0;
-}
-
-function getPluginOwner(
-	registration: McpServerRegistration,
-): { pluginName: string; pluginPath: string } | undefined {
-	const metadata = registration.metadata;
-	if (
-		!metadata ||
-		metadata.source !== "plugin" ||
-		typeof metadata.pluginName !== "string" ||
-		typeof metadata.pluginPath !== "string"
-	) {
-		return undefined;
-	}
-	return {
-		pluginName: metadata.pluginName,
-		pluginPath: metadata.pluginPath,
-	};
-}
-
-export function collectPluginMcpOAuthCandidates(input: {
-	pluginPaths: readonly string[];
-	settingsPath?: string;
-}): PluginMcpOAuthCandidate[] {
-	const pluginPaths = new Set(input.pluginPaths.map((path) => resolve(path)));
-	if (pluginPaths.size === 0) {
-		return [];
-	}
-
-	let registrations: McpServerRegistration[];
-	try {
-		registrations = resolveMcpServerRegistrations({
-			filePath: input.settingsPath ?? resolveDefaultMcpSettingsPath(),
-		});
-	} catch {
-		return [];
-	}
-
-	const candidates: PluginMcpOAuthCandidate[] = [];
-	for (const registration of registrations) {
-		const owner = getPluginOwner(registration);
-		if (!owner || !pluginPaths.has(resolve(owner.pluginPath))) {
-			continue;
-		}
-		const transportType = registration.transport.type;
-		if (transportType === "stdio") {
-			continue;
-		}
-		if (hasStaticHeaders(registration) || hasOAuthAccessToken(registration)) {
-			continue;
-		}
-		candidates.push({
-			name: registration.name,
-			pluginName: owner.pluginName,
-			pluginPath: owner.pluginPath,
-			transportType,
-			lastError: registration.oauth?.lastError,
-		});
-	}
-	return candidates.sort((left, right) => left.name.localeCompare(right.name));
-}
-
 export async function installPlugin(
 	options: PluginInstallOptions,
 ): Promise<PluginInstallResult> {
@@ -1120,7 +987,6 @@ export async function installPlugin(
 	);
 	const sourceKey = getInstallSourceKey(parsed, cwd, officialPluginsRepo);
 	const installPath = getInstallPath(pluginRoot, parsed, sourceKey);
-	const wrapperPackageName = getWrapperPackageName(parsed, cwd);
 	const stagingParent = join(pluginRoot, INSTALLS_DIRECTORY_NAME, ".tmp");
 	const stagingRoot = join(
 		stagingParent,
@@ -1163,190 +1029,34 @@ export async function installPlugin(
 				? collectPluginEntries(stagingRoot).map(
 						(entry) => `./${toPosixPath(relative(stagingRoot, entry))}`,
 					)
-				: await writeWrapperManifest(
-						stagingRoot,
-						packageRoot,
-						wrapperPackageName,
-					);
+				: await writeWrapperManifest(stagingRoot, packageRoot);
 		if (entryPaths.length === 0) {
 			throw new Error(`No plugin entry files found for ${source}`);
 		}
 
 		replaceInstallPath(stagingRoot, installPath, force);
-		const result = {
+		return {
 			source,
 			installPath,
 			entryPaths: entryPaths.map((entry) => resolve(installPath, entry)),
-			mcpSyncFailures: [] as PluginMcpSettingsSyncResult["failures"],
-			mcpOAuthCandidates: [] as PluginMcpOAuthCandidate[],
 		};
-		const syncResult = await syncPluginMcpServersToSettings({
-			pluginPaths: result.entryPaths,
-			cwd,
-			workspacePath: cwd,
-		});
-		result.mcpSyncFailures = syncResult.failures;
-		result.mcpOAuthCandidates = collectPluginMcpOAuthCandidates({
-			pluginPaths: result.entryPaths,
-		});
-		return result;
 	} catch (error) {
 		rmSync(stagingRoot, { recursive: true, force: true });
 		throw error;
 	}
 }
 
-function serializePluginInstallResult(
-	result: PluginInstallResult,
-): Omit<PluginInstallResult, "mcpOAuthCandidates"> {
-	return {
-		source: result.source,
-		installPath: result.installPath,
-		entryPaths: result.entryPaths,
-		mcpSyncFailures: result.mcpSyncFailures,
-	};
-}
-
-function isInteractivePluginInstall(options: PluginInstallOptions): boolean {
-	return (
-		options.mcpOAuth?.interactive ??
-		(process.stdin.isTTY && process.stdout.isTTY)
-	);
-}
-
-async function selectMcpOAuthCandidatesWithClack(
-	candidates: PluginMcpOAuthCandidate[],
-): Promise<PluginMcpOAuthCandidate[]> {
-	const p = await import("@clack/prompts");
-	const action = await p.select({
-		message: "Authorize plugin MCP servers now?",
-		options: [
-			{
-				value: "all",
-				label: "Authorize all",
-				hint: "open browser authorization for each server",
-			},
-			{
-				value: "choose",
-				label: "Choose servers",
-				hint: "select which servers to authorize",
-			},
-			{
-				value: "skip",
-				label: "Skip",
-			},
-		],
-	});
-	if (p.isCancel(action) || action === "skip") {
-		return [];
-	}
-	if (action === "all") {
-		return candidates;
-	}
-
-	const selectedNames = await p.multiselect({
-		message: "Select MCP servers to authorize",
-		options: candidates.map((candidate) => ({
-			value: candidate.name,
-			label: candidate.name,
-			hint: `${candidate.transportType} [${candidate.pluginName}]`,
-		})),
-		required: false,
-	});
-	if (p.isCancel(selectedNames) || !Array.isArray(selectedNames)) {
-		return [];
-	}
-	const selected = new Set(selectedNames);
-	return candidates.filter((candidate) => selected.has(candidate.name));
-}
-
-async function authorizeMcpOAuthCandidate(
-	candidate: PluginMcpOAuthCandidate,
-): Promise<void> {
-	const { authorizeMcpServerOAuthWithBrowser } = await import(
-		"../wizards/mcp/oauth"
-	);
-	await authorizeMcpServerOAuthWithBrowser(candidate.name, {
-		throwOnError: true,
-	});
-}
-
-async function runPluginMcpOAuthFollowup(
-	candidates: PluginMcpOAuthCandidate[],
-	options: PluginInstallOptions,
-): Promise<void> {
-	if (candidates.length === 0) {
-		return;
-	}
-
-	if (!isInteractivePluginInstall(options)) {
-		options.io?.writeln("Plugin MCP servers may require OAuth authorization:");
-		for (const candidate of candidates) {
-			options.io?.writeln(
-				`  ${candidate.name} (${candidate.transportType}, plugin: ${candidate.pluginName})`,
-			);
-		}
-		options.io?.writeln(
-			'Run "cline mcp" and choose "Authorize OAuth" to authorize them.',
-		);
-		return;
-	}
-
-	const selected =
-		options.mcpOAuth?.selectCandidates !== undefined
-			? await options.mcpOAuth.selectCandidates(candidates)
-			: await selectMcpOAuthCandidatesWithClack(candidates);
-	const authorize = options.mcpOAuth?.authorize ?? authorizeMcpOAuthCandidate;
-	for (const candidate of selected) {
-		try {
-			await authorize(candidate);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			options.io?.writeErr(
-				`Warning: failed to authorize MCP server ${candidate.name}: ${message}. Run "cline mcp" and choose "Authorize OAuth" to retry.`,
-			);
-		}
-	}
-}
-
 export async function runPluginInstallCommand(
 	options: PluginInstallOptions & { json?: boolean },
 ): Promise<number> {
 	try {
 		const result = await installPlugin(options);
 		if (options.json) {
-			process.stdout.write(
-				JSON.stringify(serializePluginInstallResult(result)),
-			);
+			process.stdout.write(JSON.stringify(result));
 			return 0;
 		}
 		options.io?.writeln(`Installed plugin from ${result.source}`);
 		options.io?.writeln(`  Path: ${result.installPath}`);
-		for (const failure of result.mcpSyncFailures) {
-			options.io?.writeErr(
-				`Warning: failed to sync plugin MCP servers for ${failure.pluginName ?? failure.pluginPath}: ${failure.message}`,
-			);
-		}
-		await runPluginMcpOAuthFollowup(result.mcpOAuthCandidates, options);
-		return 0;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		options.io?.writeErr(message);
-		return 1;
-	}
-}
-
-export async function runPluginUninstallCommand(
-	options: PluginUninstallOptions & { json?: boolean; io?: PluginInstallIo },
-): Promise<number> {
-	try {
-		const result = await uninstallPlugin(options);
-		if (options.json) {
-			process.stdout.write(JSON.stringify(result));
-			return 0;
-		}
-		options.io?.writeln(`Uninstalled plugin ${result.name}`);
-		options.io?.writeln(`  Removed: ${result.installPath}`);
 		return 0;
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);

apps/cli/src/commands/program.ts

@@ -116,6 +116,7 @@ export function createProgram(): Command {
 			writeOut: () => {}, // suppress by default; main.ts re-enables for routing
 			writeErr: () => {},
 		})
+		.allowUnknownOption()
 		.allowExcessArguments()
 		.enablePositionalOptions()
 		.argument(

apps/cli/src/commands/rpc-runtime/provider-registry.test.ts

@@ -78,74 +78,6 @@ describe("saveLocalProviderSettings", () => {
 		);
 	});
 
-	it("merges and clears Azure provider settings", () => {
-		const save = vi.fn();
-		const manager = {
-			read: vi.fn().mockReturnValue({
-				providers: {},
-			}),
-			write: vi.fn(),
-			getFilePath: vi.fn().mockReturnValue("/tmp/providers.json"),
-			getProviderSettings: vi.fn().mockReturnValue({
-				provider: "openai-compatible",
-				azure: {
-					apiVersion: "2024-10-21",
-					useIdentity: true,
-				},
-			}),
-			saveProviderSettings: save,
-		};
-
-		saveLocalProviderSettings(
-			manager as unknown as ProviderSettingsManager,
-			{
-				action: "saveProviderSettings",
-				providerId: "openai-compatible",
-				azure: {
-					apiVersion: "2025-01-01-preview",
-				},
-			} as SaveProviderSettingsActionRequest,
-		);
-
-		expect(save).toHaveBeenCalledTimes(1);
-		expect(save).toHaveBeenCalledWith(
-			{
-				provider: "openai-compatible",
-				azure: {
-					apiVersion: "2025-01-01-preview",
-					useIdentity: true,
-				},
-			},
-			{ setLastUsed: false },
-		);
-
-		save.mockClear();
-		manager.getProviderSettings.mockReturnValue({
-			provider: "openai-compatible",
-			azure: {
-				apiVersion: "2025-01-01-preview",
-			},
-		});
-
-		saveLocalProviderSettings(
-			manager as unknown as ProviderSettingsManager,
-			{
-				action: "saveProviderSettings",
-				providerId: "openai-compatible",
-				azure: {
-					apiVersion: "",
-				},
-			} as SaveProviderSettingsActionRequest,
-		);
-
-		expect(save).toHaveBeenCalledWith(
-			{
-				provider: "openai-compatible",
-			},
-			{ setLastUsed: false },
-		);
-	});
-
 	it("keeps OAuth auth fields when updating manual apiKey", () => {
 		const save = vi.fn();
 		const manager = {

apps/cli/src/commands/skill.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildSkillsArgs } from "./skill";
-
-describe("buildSkillsArgs", () => {
-	it("runs the skills package through npx with -y", () => {
-		expect(buildSkillsArgs(["list"])).toEqual(["-y", "skills@latest", "list"]);
-	});
-
-	it("injects --agent cline for install-style subcommands", () => {
-		expect(buildSkillsArgs(["install", "owner/repo"])).toEqual([
-			"-y",
-			"skills@latest",
-			"add",
-			"owner/repo",
-			"--agent",
-			"cline",
-		]);
-		expect(buildSkillsArgs(["add", "owner/repo"])).toContain("cline");
-		expect(buildSkillsArgs(["i", "owner/repo"])).toContain("cline");
-		expect(buildSkillsArgs(["update", "owner/repo"])).toContain("cline");
-	});
-
-	it("aliases uninstall to the skills remove subcommand", () => {
-		expect(buildSkillsArgs(["uninstall", "my-skill"])).toEqual([
-			"-y",
-			"skills@latest",
-			"remove",
-			"my-skill",
-			"--agent",
-			"cline",
-		]);
-	});
-
-	it("does not inject when the user already targeted an agent", () => {
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "--agent", "cursor"]),
-		).not.toContain("cline");
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "-a", "cursor"]),
-		).not.toContain("cline");
-		expect(
-			buildSkillsArgs(["install", "owner/repo", "--agent=cursor"]),
-		).not.toContain("cline");
-	});
-
-	it("aliases install and uninstall when agent options come before the subcommand", () => {
-		expect(
-			buildSkillsArgs(["--agent", "cursor", "install", "owner/repo"]),
-		).toEqual([
-			"-y",
-			"skills@latest",
-			"--agent",
-			"cursor",
-			"add",
-			"owner/repo",
-		]);
-		expect(
-			buildSkillsArgs(["--agent=cursor", "uninstall", "my-skill"]),
-		).toEqual(["-y", "skills@latest", "--agent=cursor", "remove", "my-skill"]);
-	});
-
-	it("does not scope non-install subcommands to cline", () => {
-		expect(buildSkillsArgs(["use", "owner/repo"])).not.toContain("--agent");
-		expect(buildSkillsArgs(["list"])).not.toContain("--agent");
-	});
-
-	it("scopes remove-style subcommands to cline", () => {
-		expect(buildSkillsArgs(["remove"])).toEqual([
-			"-y",
-			"skills@latest",
-			"remove",
-			"--agent",
-			"cline",
-		]);
-		expect(buildSkillsArgs(["rm", "my-skill"])).toContain("cline");
-		expect(buildSkillsArgs(["r", "my-skill"])).toContain("cline");
-	});
-
-	it("ignores leading flags when detecting the subcommand", () => {
-		expect(buildSkillsArgs(["--global", "install", "owner/repo"])).toContain(
-			"cline",
-		);
-	});
-
-	it("forwards an empty arg list unchanged", () => {
-		expect(buildSkillsArgs([])).toEqual(["-y", "skills@latest"]);
-	});
-});

apps/cli/src/commands/skill.ts

@@ -1,160 +0,0 @@
-import { type SpawnOptions, spawn } from "node:child_process";
-
-export interface SkillCommandIo {
-	writeln: (text?: string) => void;
-	writeErr: (text: string) => void;
-}
-
-// `cline skill` is a thin wrapper around the open skills CLI
-// (https://www.npmjs.com/package/skills). We run it through `npx` so users
-// don't need a separate global install. Pin the version here if we ever need to
-// lock behavior to a known-good release.
-const SKILLS_PACKAGE = "skills@latest";
-
-// Subcommands that write skill files into an agent's skills directory. For a
-// `cline skill` command we default these to Cline unless the user picked their
-// own agent. `use` is intentionally excluded: without --agent it prints the
-// generated prompt to stdout, whereas adding --agent would launch that agent
-// interactively instead — not what someone scoping to Cline would expect.
-const CLINE_SCOPED_SUBCOMMANDS = new Set([
-	"add",
-	"install",
-	"i",
-	"update",
-	"remove",
-	"rm",
-	"r",
-	"uninstall",
-]);
-
-const SKILLS_SUBCOMMAND_ALIASES = new Map([
-	["install", "add"],
-	["uninstall", "remove"],
-]);
-
-function hasAgentFlag(args: readonly string[]): boolean {
-	return args.some(
-		(arg) => arg === "-a" || arg === "--agent" || arg.startsWith("--agent="),
-	);
-}
-
-function optionConsumesNextValue(arg: string): boolean {
-	return arg === "-a" || arg === "--agent";
-}
-
-function findSubcommandIndex(args: readonly string[]): number {
-	for (let index = 0; index < args.length; index++) {
-		const arg = args[index];
-		if (arg.startsWith("-")) {
-			if (optionConsumesNextValue(arg)) {
-				index++;
-			}
-			continue;
-		}
-		return index;
-	}
-	return -1;
-}
-
-function findSubcommand(args: readonly string[]): string | undefined {
-	const index = findSubcommandIndex(args);
-	return index >= 0 ? args[index] : undefined;
-}
-
-function normalizeSkillsSubcommandAliases(args: string[]): void {
-	const index = findSubcommandIndex(args);
-	if (index < 0) return;
-	const alias = SKILLS_SUBCOMMAND_ALIASES.get(args[index]);
-	if (alias) {
-		args[index] = alias;
-	}
-}
-
-/**
- * Build the argument list passed to `npx`, injecting `--agent cline` for
- * install-style subcommands unless the user already targeted an agent.
- */
-export function buildSkillsArgs(userArgs: readonly string[]): string[] {
-	const args = [...userArgs];
-	const subcommand = findSubcommand(args);
-	normalizeSkillsSubcommandAliases(args);
-	if (
-		subcommand &&
-		CLINE_SCOPED_SUBCOMMANDS.has(subcommand) &&
-		!hasAgentFlag(args)
-	) {
-		args.push("--agent", "cline");
-	}
-	return ["-y", SKILLS_PACKAGE, ...args];
-}
-
-function resolveExitCode(
-	code: number | null,
-	signal: NodeJS.Signals | null,
-): number {
-	if (code !== null) {
-		return code;
-	}
-	switch (signal) {
-		case "SIGINT":
-			return 130;
-		case "SIGTERM":
-			return 143;
-		default:
-			return 1;
-	}
-}
-
-/**
- * Forward all arguments to the open skills CLI via `npx skills`.
- *
- * Returns the child process exit code, or 1 if npx is unavailable or fails to
- * spawn. stdio is inherited so the skills CLI's interactive prompts and output
- * pass straight through to the user's terminal.
- */
-export async function runSkillCommand(
-	userArgs: readonly string[],
-	io: SkillCommandIo,
-): Promise<number> {
-	const args = buildSkillsArgs(userArgs);
-	const isWindows = process.platform === "win32";
-	const options: SpawnOptions = {
-		stdio: "inherit",
-		env: process.env,
-		// Prevent a console window from flashing on Windows.
-		windowsHide: true,
-		...(isWindows ? { shell: true } : {}),
-	};
-
-	return new Promise<number>((resolve) => {
-		const child = spawn("npx", args, options);
-
-		const forward = (signal: NodeJS.Signals) => {
-			child.kill(signal);
-		};
-		const handleSigint = () => forward("SIGINT");
-		const handleSigterm = () => forward("SIGTERM");
-		process.on("SIGINT", handleSigint);
-		process.on("SIGTERM", handleSigterm);
-		const cleanup = () => {
-			process.off("SIGINT", handleSigint);
-			process.off("SIGTERM", handleSigterm);
-		};
-
-		child.once("error", (error: NodeJS.ErrnoException) => {
-			cleanup();
-			if (error.code === "ENOENT") {
-				io.writeErr(
-					'npx was not found. Install Node.js (which includes npx) to use "cline skill".',
-				);
-			} else {
-				io.writeErr(`Failed to run npx ${SKILLS_PACKAGE}: ${error.message}`);
-			}
-			resolve(1);
-		});
-		child.once("close", (code, signal) => {
-			cleanup();
-			resolve(resolveExitCode(code, signal));
-		});
-	});
-}

apps/cli/src/commands/update.test.ts

@@ -1,24 +1,15 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it } from "vitest";
 import {
-	autoUpdateOnStartup,
-	checkForUpdates,
 	getInstallationInfo,
 	PackageManager,
-	resolveCliHubOwnerContext,
 	withMinimumReleaseAgeBypass,
 } from "./update";
 
 const originalArgv = [...process.argv];
-const originalBuildEnv = process.env.CLINE_BUILD_ENV;
-const originalDataDir = process.env.CLINE_DATA_DIR;
-const originalHubDiscoveryPath = process.env.CLINE_HUB_DISCOVERY_PATH;
 const originalWrapperPath = process.env.CLINE_WRAPPER_PATH;
-const originalGlobalSettingsPath = process.env.CLINE_GLOBAL_SETTINGS_PATH;
-const originalIsDev = process.env.IS_DEV;
-const originalNoAutoUpdate = process.env.CLINE_NO_AUTO_UPDATE;
 const tempDirs: string[] = [];
 
 function createFile(path: string): string {
@@ -36,42 +27,11 @@ function createTempFile(pathSuffix: string): string {
 describe("getInstallationInfo", () => {
 	afterEach(() => {
 		process.argv = [...originalArgv];
-		if (originalBuildEnv === undefined) {
-			delete process.env.CLINE_BUILD_ENV;
-		} else {
-			process.env.CLINE_BUILD_ENV = originalBuildEnv;
-		}
-		if (originalDataDir === undefined) {
-			delete process.env.CLINE_DATA_DIR;
-		} else {
-			process.env.CLINE_DATA_DIR = originalDataDir;
-		}
-		if (originalHubDiscoveryPath === undefined) {
-			delete process.env.CLINE_HUB_DISCOVERY_PATH;
-		} else {
-			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
-		}
 		if (originalWrapperPath === undefined) {
 			delete process.env.CLINE_WRAPPER_PATH;
 		} else {
 			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
 		}
-		if (originalGlobalSettingsPath === undefined) {
-			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_GLOBAL_SETTINGS_PATH = originalGlobalSettingsPath;
-		}
-		if (originalIsDev === undefined) {
-			delete process.env.IS_DEV;
-		} else {
-			process.env.IS_DEV = originalIsDev;
-		}
-		if (originalNoAutoUpdate === undefined) {
-			delete process.env.CLINE_NO_AUTO_UPDATE;
-		} else {
-			process.env.CLINE_NO_AUTO_UPDATE = originalNoAutoUpdate;
-		}
-		vi.restoreAllMocks();
 		for (const dir of tempDirs.splice(0)) {
 			rmSync(dir, { recursive: true, force: true });
 		}
@@ -85,7 +45,7 @@ describe("getInstallationInfo", () => {
 		expect(getInstallationInfo("1.2.3")).toEqual({
 			packageManager: PackageManager.NPM,
 			packageName: "cline",
-			updateCommand: "npm update -g cline --tag latest",
+			updateCommand: "npm install -g cline@latest",
 		});
 	});
 
@@ -97,7 +57,7 @@ describe("getInstallationInfo", () => {
 		expect(getInstallationInfo("1.2.3-nightly.456")).toEqual({
 			packageManager: PackageManager.NPM,
 			packageName: "cline",
-			updateCommand: "npm update -g cline --tag nightly",
+			updateCommand: "npm install -g cline@nightly",
 		});
 	});
 
@@ -112,122 +72,14 @@ describe("getInstallationInfo", () => {
 	});
 });
 
-describe("auto update settings", () => {
-	afterEach(() => {
-		process.argv = [...originalArgv];
-		if (originalBuildEnv === undefined) {
-			delete process.env.CLINE_BUILD_ENV;
-		} else {
-			process.env.CLINE_BUILD_ENV = originalBuildEnv;
-		}
-		if (originalDataDir === undefined) {
-			delete process.env.CLINE_DATA_DIR;
-		} else {
-			process.env.CLINE_DATA_DIR = originalDataDir;
-		}
-		if (originalHubDiscoveryPath === undefined) {
-			delete process.env.CLINE_HUB_DISCOVERY_PATH;
-		} else {
-			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
-		}
-		if (originalWrapperPath === undefined) {
-			delete process.env.CLINE_WRAPPER_PATH;
-		} else {
-			process.env.CLINE_WRAPPER_PATH = originalWrapperPath;
-		}
-		if (originalGlobalSettingsPath === undefined) {
-			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_GLOBAL_SETTINGS_PATH = originalGlobalSettingsPath;
-		}
-		if (originalIsDev === undefined) {
-			delete process.env.IS_DEV;
-		} else {
-			process.env.IS_DEV = originalIsDev;
-		}
-		if (originalNoAutoUpdate === undefined) {
-			delete process.env.CLINE_NO_AUTO_UPDATE;
-		} else {
-			process.env.CLINE_NO_AUTO_UPDATE = originalNoAutoUpdate;
-		}
-		vi.restoreAllMocks();
-		for (const dir of tempDirs.splice(0)) {
-			rmSync(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("skips startup auto update when disabled globally", () => {
-		const settingsPath = createTempFile("data/global-settings.json");
-		writeFileSync(settingsPath, JSON.stringify({ autoUpdateEnabled: false }));
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
-		delete process.env.IS_DEV;
-		delete process.env.CLINE_NO_AUTO_UPDATE;
-		const fetchSpy = vi
-			.spyOn(globalThis, "fetch")
-			.mockRejectedValue(new Error("should not fetch"));
-
-		autoUpdateOnStartup();
-
-		expect(fetchSpy).not.toHaveBeenCalled();
-	});
-
-	it("still lets manual update checks run when startup auto update is disabled", async () => {
-		const settingsPath = createTempFile("data/global-settings.json");
-		writeFileSync(settingsPath, JSON.stringify({ autoUpdateEnabled: false }));
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = settingsPath;
-		delete process.env.CLINE_NO_AUTO_UPDATE;
-		const fetchSpy = vi.spyOn(globalThis, "fetch").mockResolvedValue({
-			ok: true,
-			json: async () => ({ version: "0.0.0" }),
-		} as Response);
-
-		await checkForUpdates({ includeKanban: false });
-
-		expect(fetchSpy).toHaveBeenCalled();
-	});
-});
-
-describe("hub restart owner selection", () => {
-	afterEach(() => {
-		if (originalBuildEnv === undefined) {
-			delete process.env.CLINE_BUILD_ENV;
-		} else {
-			process.env.CLINE_BUILD_ENV = originalBuildEnv;
-		}
-		if (originalDataDir === undefined) {
-			delete process.env.CLINE_DATA_DIR;
-		} else {
-			process.env.CLINE_DATA_DIR = originalDataDir;
-		}
-		if (originalHubDiscoveryPath === undefined) {
-			delete process.env.CLINE_HUB_DISCOVERY_PATH;
-		} else {
-			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
-		}
-	});
-
-	it("uses the shared hub owner outside production builds", () => {
-		process.env.CLINE_BUILD_ENV = "development";
-		process.env.CLINE_DATA_DIR = "/tmp/cline-update-test-data";
-		delete process.env.CLINE_HUB_DISCOVERY_PATH;
-
-		const owner = resolveCliHubOwnerContext();
-
-		expect(owner.discoveryPath).toContain("/locks/hub/owners/");
-		expect(owner.discoveryPath).not.toBe(
-			"/tmp/cline-update-test-data/locks/hub/production.json",
-		);
-	});
-});
-
 describe("withMinimumReleaseAgeBypass", () => {
 	it("adds the package-manager-specific cooldown bypass", () => {
 		expect(
 			withMinimumReleaseAgeBypass(
-				"npm update -g cline --tag latest",
+				"npm install -g cline@latest",
 				PackageManager.NPM,
 			).command,
-		).toBe("npm update -g cline --tag latest --min-release-age=0");
+		).toBe("npm install -g cline@latest --min-release-age=0");
 		expect(
 			withMinimumReleaseAgeBypass("bun add -g cline@latest", PackageManager.BUN)
 				.command,

apps/cli/src/commands/update.ts

@@ -2,14 +2,11 @@ import { type ChildProcess, spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import {
 	clearHubDiscovery,
-	isAutoUpdateEnabledGlobally,
 	probeHubServer,
 	readHubDiscovery,
-	resolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext,
 	stopLocalHubServerGracefully,
 } from "@cline/core";
-import { resolveClineBuildEnv } from "@cline/shared";
 import { version } from "../../package.json";
 import { ensureCliHubServer } from "../utils/hub-runtime";
 import { c, writeErr, writeln } from "../utils/output";
@@ -129,7 +126,7 @@ export function getInstallationInfo(currentVersion: string): InstallationInfo {
 			return {
 				packageManager: PackageManager.NPM,
 				packageName: DEFAULT_PACKAGE_NAME,
-				updateCommand: `npm update -g ${DEFAULT_PACKAGE_NAME} --tag ${tag}`,
+				updateCommand: `npm install -g ${DEFAULT_PACKAGE_NAME}@${tag}`,
 			};
 		}
 	} catch {
@@ -271,22 +268,13 @@ export function getPreferredKanbanInstaller(
 
 const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
-export function resolveCliHubOwnerContext() {
-	return resolveClineBuildEnv() === "production"
-		? resolveProductionHubOwnerContext()
-		: resolveSharedHubOwnerContext();
-}
-
 async function waitForHubToStop(
 	url: string,
-	authToken: string | undefined,
 	timeoutMs: number,
 ): Promise<boolean> {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		const check = await probeHubServer(url, { authToken }).catch(
-			() => undefined,
-		);
+		const check = await probeHubServer(url).catch(() => undefined);
 		if (!check?.url) return true;
 		await sleep(100);
 	}
@@ -299,22 +287,20 @@ async function waitForHubToStop(
  * clears stale discovery, then re-ensures a fresh instance is spawned.
  */
 async function restartHubServerIfRunning(): Promise<void> {
-	const owner = resolveCliHubOwnerContext();
+	const owner = resolveSharedHubOwnerContext();
 	const discovery = await readHubDiscovery(owner.discoveryPath).catch(
 		() => undefined,
 	);
 
 	const health = discovery?.url
-		? await probeHubServer(discovery.url, {
-				authToken: discovery.authToken,
-			}).catch(() => undefined)
+		? await probeHubServer(discovery.url).catch(() => undefined)
 		: undefined;
-	if (!discovery || !health?.url) return;
+	if (!health?.url) return;
 
 	const pid = discovery?.pid;
 	writeln(`${c.dim}[hub] restarting server…${c.reset}`);
 
-	let stopped = await stopLocalHubServerGracefully(owner).catch(() => false);
+	let stopped = await stopLocalHubServerGracefully().catch(() => false);
 	if (!stopped && pid) {
 		try {
 			process.kill(pid, "SIGTERM");
@@ -323,14 +309,14 @@ async function restartHubServerIfRunning(): Promise<void> {
 		}
 	}
 
-	stopped = await waitForHubToStop(health.url, discovery.authToken, 3_000);
+	stopped = await waitForHubToStop(health.url, 3_000);
 	if (!stopped && pid) {
 		try {
 			process.kill(pid, "SIGKILL");
 		} catch {
 			// best-effort
 		}
-		stopped = await waitForHubToStop(health.url, discovery.authToken, 2_000);
+		stopped = await waitForHubToStop(health.url, 2_000);
 	}
 
 	await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
@@ -354,30 +340,19 @@ async function restartHubServerIfRunning(): Promise<void> {
 export function autoUpdateOnStartup(): void {
 	if (process.env.IS_DEV === "true") return;
 	if (process.env.CLINE_NO_AUTO_UPDATE === "1") return;
-	if (!isAutoUpdateEnabledGlobally()) return;
 
-	const { packageName, packageManager, updateCommand } =
-		getInstallationInfo(version);
+	const { packageName, updateCommand } = getInstallationInfo(version);
 	if (!updateCommand) return;
 
 	void (async () => {
 		try {
 			const latest = await getLatestVersion(packageName, version);
 			if (!latest || compareVersions(version, latest) >= 0) return;
-			const autoUpdateCommand = withMinimumReleaseAgeBypass(
-				updateCommand,
-				packageManager,
-			);
-			const child = spawn(autoUpdateCommand.command, {
+			const child = spawn(updateCommand, {
 				shell: true,
 				detached: true,
 				stdio: "ignore",
-				env: autoUpdateCommand.env
-					? { ...process.env, ...autoUpdateCommand.env }
-					: process.env,
-				// Prevent a console window from flashing on Windows; detached
-				// processes otherwise allocate a new visible console.
-				windowsHide: true,
+				env: process.env,
 			});
 			const exitCode = await waitForProcessExit(child);
 			if (exitCode === 0) {

apps/cli/src/connectors/adapters/discord.test.ts

@@ -228,7 +228,7 @@ describe("discordConnector", () => {
 		});
 	});
 
-	it("updates Discord participant metadata without changing the thread session", async () => {
+	it("switches Discord thread state to the incoming participant without reusing the previous participant session", async () => {
 		const dir = await mkdtemp(join(tmpdir(), "discord-participants-"));
 		const bindingsPath = join(dir, "threads.json");
 		const thread = createThread({
@@ -278,13 +278,11 @@ describe("discordConnector", () => {
 			errorLabel: "Discord",
 		});
 
-		const binding =
-			readBindings<TestDiscordState>(bindingsPath)[
-				"discord:guild:channel:thread"
-			];
-		expect(binding?.state?.participantKey).toBe("discord:user:bob");
-		expect(binding?.state?.participantLabel).toBe("Bob");
-		expect(binding?.state?.sessionId).toBe("session-alice");
+		const bob =
+			readBindings<TestDiscordState>(bindingsPath)["discord:user:bob"];
+		expect(bob?.state?.participantKey).toBe("discord:user:bob");
+		expect(bob?.state?.participantLabel).toBe("Bob");
+		expect(bob?.state?.sessionId).toBeUndefined();
 		expect(
 			readBindings<TestDiscordState>(bindingsPath)["discord:user:alice"]?.state
 				?.sessionId,

apps/cli/src/connectors/adapters/discord.ts

@@ -50,9 +50,10 @@ import {
 	type ConnectorMuteTarget,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
+	mergeThreadState,
 	persistMergedThreadState,
 	readBindings,
 } from "../thread-bindings";
@@ -563,17 +564,45 @@ async function postDiscordResolvedText(input: {
 	});
 }
 
-function resolveCurrentStateWithParticipant(input: {
-	currentState: DiscordThreadState;
+function resolveParticipantState(input: {
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
 	participant: DiscordParticipant;
 }): DiscordThreadState {
+	const existing = findBindingForParticipantKey(
+		readBindings<DiscordThreadState>(input.bindingsPath),
+		input.participant.key,
+	)?.binding.state;
 	return {
-		...input.currentState,
+		...mergeThreadState<DiscordThreadState>(
+			undefined,
+			existing,
+			input.baseStartRequest,
+		),
 		participantKey: input.participant.key,
 		participantLabel: input.participant.label,
 	};
 }
 
+function resolveCurrentStateWithParticipant(input: {
+	currentState: DiscordThreadState;
+	bindingsPath: string;
+	baseStartRequest: ChatStartSessionRequest;
+	participant: DiscordParticipant;
+}): DiscordThreadState {
+	if (input.currentState.participantKey === input.participant.key) {
+		return {
+			...input.currentState,
+			participantLabel: input.participant.label,
+		};
+	}
+	return resolveParticipantState({
+		bindingsPath: input.bindingsPath,
+		baseStartRequest: input.baseStartRequest,
+		participant: input.participant,
+	});
+}
+
 async function persistDiscordThreadContext(input: {
 	thread: Thread<DiscordThreadState>;
 	bindingsPath: string;
@@ -595,6 +624,8 @@ async function persistDiscordThreadContext(input: {
 	);
 	const nextState = resolveCurrentStateWithParticipant({
 		currentState,
+		bindingsPath: input.bindingsPath,
+		baseStartRequest: input.baseStartRequest,
 		participant,
 	});
 	if (
@@ -638,20 +669,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<DiscordThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	if (!binding?.serializedThread) {
 		return;
@@ -1102,7 +1133,9 @@ class DiscordConnector extends ConnectorBase<
 				isSubscribedThreadMessage?: boolean;
 			},
 		) => {
-			const queueKey = thread.id;
+			const queueKey =
+				(await loadThreadState(thread, bindingsPath, startRequest))
+					.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await handleConnectorUserTurn({

apps/cli/src/connectors/adapters/gchat.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { __test__ } from "./gchat";
 
 describe("gchat binding lookup", () => {
-	it("does not fall back to channel identity for a different space thread id", () => {
+	it("falls back to channel identity when a restarted connector gets a new thread id", () => {
 		const result = __test__.findBindingForThread(
 			{
 				legacy_thread_id: {
@@ -21,7 +21,17 @@ describe("gchat binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result).toEqual({
+			key: "legacy_thread_id",
+			binding: {
+				channelId: "space-123",
+				isDM: false,
+				serializedThread: "{}",
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
 	});
 
 	it("prefers an exact thread id match over a channel fallback", () => {
@@ -55,7 +65,7 @@ describe("gchat binding lookup", () => {
 		expect(result?.binding.sessionId).toBe("sess-2");
 	});
 
-	it("does not reuse a binding by participant key across different spaces", () => {
+	it("reuses a binding by participant key across different spaces", () => {
 		const result = __test__.findBindingForThread(
 			{
 				"gchat:email:alice@example.com": {
@@ -81,6 +91,7 @@ describe("gchat binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result?.key).toBe("gchat:email:alice@example.com");
+		expect(result?.binding.sessionId).toBe("sess-1");
 	});
 });

apps/cli/src/connectors/adapters/gchat.ts

@@ -46,7 +46,7 @@ import {
 	type ConnectorBindingStore,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
 	persistMergedThreadState,
@@ -191,20 +191,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<GoogleChatThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	if (!binding?.serializedThread) {
 		return;
@@ -590,7 +590,9 @@ class GoogleChatConnector extends ConnectorBase<
 			thread: Thread<GoogleChatThreadState>,
 			text: string,
 		) => {
-			const queueKey = thread.id;
+			const queueKey =
+				(await loadThreadState(thread, bindingsPath, startRequest))
+					.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await handleConnectorUserTurn({

apps/cli/src/connectors/adapters/linear.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { __test__ } from "./linear";
 
 describe("linear binding lookup", () => {
-	it("does not fall back to channel identity for a different issue thread id", () => {
+	it("falls back to channel identity when a restarted connector gets a new thread id", () => {
 		const result = __test__.findBindingForThread(
 			{
 				legacy_thread_id: {
@@ -21,7 +21,17 @@ describe("linear binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result).toEqual({
+			key: "legacy_thread_id",
+			binding: {
+				channelId: "linear:issue:ISS-123",
+				isDM: false,
+				serializedThread: "{}",
+				sessionId: "sess-1",
+				state: { sessionId: "sess-1", cwd: "/tmp/work" },
+				updatedAt: "2026-03-17T00:00:00.000Z",
+			},
+		});
 	});
 
 	it("prefers an exact thread id match over a channel fallback", () => {
@@ -55,7 +65,7 @@ describe("linear binding lookup", () => {
 		expect(result?.binding.sessionId).toBe("sess-2");
 	});
 
-	it("does not reuse a binding by participant key across different issue threads", () => {
+	it("reuses a binding by participant key across different issue threads", () => {
 		const result = __test__.findBindingForThread(
 			{
 				"linear:user:user_123": {
@@ -81,6 +91,7 @@ describe("linear binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result?.key).toBe("linear:user:user_123");
+		expect(result?.binding.sessionId).toBe("sess-1");
 	});
 });

apps/cli/src/connectors/adapters/linear.ts

@@ -42,7 +42,7 @@ import {
 	type ConnectorBindingStore,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
 	persistMergedThreadState,
@@ -229,20 +229,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<LinearThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	if (!binding?.serializedThread) {
 		return;
@@ -625,7 +625,9 @@ class LinearConnector extends ConnectorBase<
 			thread: Thread<LinearThreadState>,
 			text: string,
 		) => {
-			const queueKey = thread.id;
+			const queueKey =
+				(await loadThreadState(thread, bindingsPath, startRequest))
+					.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await handleConnectorUserTurn({

apps/cli/src/connectors/adapters/prompts.ts

@@ -29,7 +29,7 @@ export function getConnectorSystemRules(
 }
 
 const CONNECTOR_FIRST_CONTACT_MESSAGE = [
-	"Connected to Cline.",
+	"Connected.",
 	"Your chat history is kept separately for your account.",
 	"Send /new to start a fresh session or /whereami for thread details.",
 ].join("\n");

apps/cli/src/connectors/adapters/slack.test.ts

@@ -1,74 +1,15 @@
-import type { ConnectSlackOptions } from "@cline/shared";
-import { type Message, ThreadImpl } from "chat";
 import { describe, expect, it } from "vitest";
-import { __test__, slackConnector } from "./slack";
-
-const parseSlackArgs = (rawArgs: string[]): ConnectSlackOptions =>
-	(
-		slackConnector as unknown as {
-			parseArgs(rawArgs: string[]): ConnectSlackOptions;
-		}
-	).parseArgs(rawArgs);
+import { __test__ } from "./slack";
 
 describe("slack binding lookup", () => {
 	const participantKey = __test__.buildSlackParticipantKey("T123", "U123");
 
-	it("infers Slack webhook mode from a base URL", () => {
-		expect(__test__.inferSlackConnectionMode("https://example.test")).toBe(
-			"webhook",
-		);
-		expect(__test__.inferSlackConnectionMode("  ")).toBe("socket");
-		expect(__test__.inferSlackConnectionMode(undefined)).toBe("socket");
-	});
-
-	it("uses webhook mode when Slack args include a base URL", () => {
-		const options = parseSlackArgs([
-			"--bot-token",
-			"xoxb-token",
-			"--signing-secret",
-			"secret",
-			"--app-token",
-			"xapp-ignored",
-			"--base-url",
-			"https://example.test",
-		]);
-
-		expect(options.connectionMode).toBe("webhook");
-		expect(options.baseUrl).toBe("https://example.test");
-		expect(options.signingSecret).toBe("secret");
-		expect(options.appToken).toBeUndefined();
-	});
-
-	it("uses socket mode when Slack args omit a base URL", () => {
-		const previousBaseUrl = process.env.BASE_URL;
-		delete process.env.BASE_URL;
-		let options: ConnectSlackOptions;
-		try {
-			options = parseSlackArgs([
-				"--bot-token",
-				"xoxb-token",
-				"--app-token",
-				"xapp-token",
-			]);
-		} finally {
-			if (previousBaseUrl === undefined) {
-				delete process.env.BASE_URL;
-			} else {
-				process.env.BASE_URL = previousBaseUrl;
-			}
-		}
-
-		expect(options.connectionMode).toBe("socket");
-		expect(options.baseUrl).toBeUndefined();
-		expect(options.appToken).toBe("xapp-token");
-	});
-
-	it("falls back to DM channel identity when a restarted connector gets a new thread id", () => {
+	it("falls back to channel identity when a restarted connector gets a new thread id", () => {
 		const result = __test__.findBindingForThread(
 			{
 				legacy_thread_id: {
 					channelId: "slack:C123",
-					isDM: true,
+					isDM: false,
 					serializedThread: "{}",
 					sessionId: "sess-1",
 					state: { sessionId: "sess-1", cwd: "/tmp/work", teamId: "T123" },
@@ -78,7 +19,7 @@ describe("slack binding lookup", () => {
 			{
 				id: "new_thread_id",
 				channelId: "slack:C123",
-				isDM: true,
+				isDM: false,
 			},
 		);
 
@@ -86,7 +27,7 @@ describe("slack binding lookup", () => {
 			key: "legacy_thread_id",
 			binding: {
 				channelId: "slack:C123",
-				isDM: true,
+				isDM: false,
 				serializedThread: "{}",
 				sessionId: "sess-1",
 				state: { sessionId: "sess-1", cwd: "/tmp/work", teamId: "T123" },
@@ -126,7 +67,7 @@ describe("slack binding lookup", () => {
 		expect(result?.binding.sessionId).toBe("sess-2");
 	});
 
-	it("does not reuse a binding by participant key across different threads", () => {
+	it("reuses a binding by participant key across different threads", () => {
 		const result = __test__.findBindingForThread(
 			{
 				[participantKey]: {
@@ -153,7 +94,8 @@ describe("slack binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result?.key).toBe(participantKey);
+		expect(result?.binding.sessionId).toBe("sess-1");
 	});
 
 	it("builds Slack participant keys with a team scope", () => {
@@ -215,105 +157,6 @@ describe("slack binding lookup", () => {
 		);
 	});
 
-	it("normalizes top-level channel mentions to the original Slack post thread", () => {
-		const original = new ThreadImpl({
-			adapterName: "slack",
-			channelId: "slack:C123",
-			id: "slack:C123:",
-			isDM: false,
-		});
-		const message = {
-			raw: {
-				channel: "C123",
-				text: "<@U999> help",
-				ts: "1710000000.123456",
-				type: "app_mention",
-				user: "U123",
-			},
-		} as Message;
-
-		const normalized = __test__.resolveSlackChannelMentionThread(
-			original,
-			message,
-		);
-
-		expect(normalized.id).toBe("slack:C123:1710000000.123456");
-		expect(normalized.channelId).toBe("slack:C123");
-		expect(normalized.isDM).toBe(false);
-	});
-
-	it("uses Slack thread_ts instead of reply ts for in-thread mentions", () => {
-		const original = new ThreadImpl({
-			adapterName: "slack",
-			channelId: "slack:C123",
-			id: "slack:C123:1710000001.654321",
-			isDM: false,
-		});
-		const message = {
-			raw: {
-				channel: "C123",
-				text: "<@U999> follow up",
-				thread_ts: "1710000000.123456",
-				ts: "1710000001.654321",
-				type: "app_mention",
-				user: "U123",
-			},
-		} as Message;
-
-		const normalized = __test__.resolveSlackChannelMentionThread(
-			original,
-			message,
-		);
-
-		expect(normalized.id).toBe("slack:C123:1710000000.123456");
-		expect(normalized.channelId).toBe("slack:C123");
-		expect(normalized.isDM).toBe(false);
-	});
-
-	it("keeps Slack mention threads that already target the original post", () => {
-		const original = new ThreadImpl({
-			adapterName: "slack",
-			channelId: "slack:C123",
-			id: "slack:C123:1710000000.123456",
-			isDM: false,
-		});
-		const message = {
-			raw: {
-				channel: "C123",
-				text: "<@U999> help",
-				ts: "1710000000.123456",
-				type: "app_mention",
-				user: "U123",
-			},
-		} as Message;
-
-		expect(__test__.resolveSlackChannelMentionThread(original, message)).toBe(
-			original,
-		);
-	});
-
-	it("does not rewrite Slack DM mention threads", () => {
-		const original = new ThreadImpl({
-			adapterName: "slack",
-			channelId: "slack:D123",
-			id: "slack:D123:",
-			isDM: true,
-		});
-		const message = {
-			raw: {
-				channel: "D123",
-				text: "help",
-				ts: "1710000000.123456",
-				type: "message",
-				user: "U123",
-			},
-		} as Message;
-
-		expect(__test__.resolveSlackChannelMentionThread(original, message)).toBe(
-			original,
-		);
-	});
-
 	it("routes Slack posts through the installation bot token for a team", async () => {
 		const calls: string[] = [];
 		const result = await __test__.withSlackTeamBotToken({

apps/cli/src/connectors/adapters/slack.ts

@@ -9,7 +9,6 @@ import {
 	type Adapter,
 	Chat,
 	ConsoleLogger,
-	type Message,
 	type Thread,
 	ThreadImpl,
 } from "chat";
@@ -51,7 +50,7 @@ import {
 	type ConnectorThreadBinding,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
 	persistMergedThreadState,
@@ -80,14 +79,6 @@ type SlackThreadState = ConnectorThreadState & {
 	teamId?: string;
 };
 
-type SlackConnectionMode = ConnectSlackOptions["connectionMode"];
-
-function inferSlackConnectionMode(
-	baseUrl: string | undefined,
-): SlackConnectionMode {
-	return baseUrl?.trim() ? "webhook" : "socket";
-}
-
 function truncateText(value: string, maxLength = 160): string {
 	return truncateConnectorText(value, maxLength);
 }
@@ -193,56 +184,6 @@ function extractSlackTeamId(raw: unknown): string | undefined {
 	return value?.trim() || undefined;
 }
 
-function extractSlackMessageRecord(
-	raw: unknown,
-): Record<string, unknown> | undefined {
-	const record = asRecord(raw);
-	return asRecord(record?.event) ?? asRecord(record?.message) ?? record;
-}
-
-function extractSlackChannelFromId(id: string): string | undefined {
-	const parts = id.split(":");
-	return parts[0] === "slack" ? readString(parts[1]) : undefined;
-}
-
-function resolveSlackChannelMentionThread(
-	thread: Thread<SlackThreadState>,
-	message: Message,
-): Thread<SlackThreadState> {
-	if (thread.isDM) {
-		return thread;
-	}
-	const event = extractSlackMessageRecord(message.raw);
-	const threadTs = readString(event?.thread_ts) ?? readString(event?.ts);
-	if (!threadTs) {
-		return thread;
-	}
-	const channel =
-		readString(event?.channel) ??
-		extractSlackChannelFromId(thread.id) ??
-		extractSlackChannelFromId(thread.channelId);
-	if (!channel) {
-		return thread;
-	}
-	const threadId = `slack:${channel}:${threadTs}`;
-	const channelId = `slack:${channel}`;
-	if (thread.id === threadId && thread.channelId === channelId) {
-		return thread;
-	}
-	return new ThreadImpl<SlackThreadState>({
-		adapterName: "slack",
-		channelId,
-		channelVisibility: thread.channelVisibility,
-		currentMessage: message,
-		fallbackStreamingPlaceholderText: null,
-		id: threadId,
-		initialMessage: message,
-		isDM: false,
-		isSubscribedContext: false,
-		streamingUpdateIntervalMs: 500,
-	});
-}
-
 async function withSlackBindingBotToken<T>(input: {
 	slack: Pick<SlackAdapter, "getInstallation" | "withBotToken">;
 	binding: ConnectorThreadBinding<SlackThreadState>;
@@ -376,20 +317,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<SlackThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	const deliveryThreadId = match?.key || threadId || bindingKey;
 	if (!binding?.serializedThread) {
@@ -439,10 +380,7 @@ class SlackConnector extends ConnectorBase<
 	SlackConnectorState
 > {
 	constructor() {
-		super(
-			"slack",
-			"Slack webhook/socket bridge backed by RPC runtime sessions",
-		);
+		super("slack", "Slack webhook bridge backed by RPC runtime sessions");
 	}
 
 	protected override createCommand(): Command {
@@ -455,7 +393,6 @@ class SlackConnector extends ConnectorBase<
 				"Slack bot token for single-workspace mode",
 			)
 			.option("--signing-secret <secret>", "Slack signing secret")
-			.option("--app-token <token>", "Slack app-level token for socket mode")
 			.option("--client-id <id>", "Slack OAuth client id")
 			.option("--client-secret <secret>", "Slack OAuth client secret")
 			.option(
@@ -496,7 +433,6 @@ class SlackConnector extends ConnectorBase<
 					"Environment:",
 					"  SLACK_BOT_TOKEN             Single-workspace bot token",
 					"  SLACK_SIGNING_SECRET        Slack signing secret",
-					"  SLACK_APP_TOKEN             App-level token for socket mode",
 					"  SLACK_CLIENT_ID             OAuth client id",
 					"  SLACK_CLIENT_SECRET         OAuth client secret",
 					"  SLACK_ENCRYPTION_KEY        Optional installation encryption key",
@@ -509,7 +445,6 @@ class SlackConnector extends ConnectorBase<
 			userName?: string;
 			botToken?: string;
 			signingSecret?: string;
-			appToken?: string;
 			clientId?: string;
 			clientSecret?: string;
 			encryptionKey?: string;
@@ -532,50 +467,17 @@ class SlackConnector extends ConnectorBase<
 			this.parseOptionalInteger(opts.port, "port") ??
 			Number.parseInt(process.env.PORT ?? "8787", 10);
 		const port = Number.isFinite(parsedPort) ? parsedPort : 8787;
-		const baseUrl = opts.baseUrl?.trim() || process.env.BASE_URL?.trim();
-		const connectionMode = inferSlackConnectionMode(baseUrl);
-		const isSocketMode = connectionMode === "socket";
-		if (isSocketMode && (opts.clientId?.trim() || opts.clientSecret?.trim())) {
-			throw new Error(
-				"Slack socket mode does not support --client-id or --client-secret",
-			);
-		}
-		const botToken =
-			opts.botToken?.trim() || process.env.SLACK_BOT_TOKEN?.trim();
-		const appToken = isSocketMode
-			? opts.appToken?.trim() || process.env.SLACK_APP_TOKEN?.trim()
-			: undefined;
-		if (isSocketMode && !appToken) {
-			throw new Error(
-				"Slack socket mode requires --app-token or SLACK_APP_TOKEN",
-			);
-		}
-		if (isSocketMode && !botToken) {
-			throw new Error(
-				"Slack socket mode requires --bot-token or SLACK_BOT_TOKEN",
-			);
-		}
 		return {
 			userName:
 				opts.userName?.trim() ||
 				process.env.SLACK_BOT_USERNAME?.trim() ||
 				"cline-slack",
-			connectionMode,
-			botToken,
+			botToken: opts.botToken?.trim() || process.env.SLACK_BOT_TOKEN?.trim(),
 			signingSecret:
-				connectionMode === "webhook"
-					? opts.signingSecret?.trim() ||
-						process.env.SLACK_SIGNING_SECRET?.trim()
-					: opts.signingSecret?.trim(),
-			appToken,
-			clientId:
-				connectionMode === "webhook"
-					? opts.clientId?.trim() || process.env.SLACK_CLIENT_ID?.trim()
-					: undefined,
+				opts.signingSecret?.trim() || process.env.SLACK_SIGNING_SECRET?.trim(),
+			clientId: opts.clientId?.trim() || process.env.SLACK_CLIENT_ID?.trim(),
 			clientSecret:
-				connectionMode === "webhook"
-					? opts.clientSecret?.trim() || process.env.SLACK_CLIENT_SECRET?.trim()
-					: undefined,
+				opts.clientSecret?.trim() || process.env.SLACK_CLIENT_SECRET?.trim(),
 			encryptionKey:
 				opts.encryptionKey?.trim() || process.env.SLACK_ENCRYPTION_KEY?.trim(),
 			installationKeyPrefix:
@@ -598,7 +500,10 @@ class SlackConnector extends ConnectorBase<
 				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
 			port,
 			host: opts.host?.trim() || process.env.HOST?.trim() || "0.0.0.0",
-			baseUrl,
+			baseUrl:
+				opts.baseUrl?.trim() ||
+				process.env.BASE_URL?.trim() ||
+				`http://127.0.0.1:${port}`,
 		};
 	}
 
@@ -694,11 +599,9 @@ class SlackConnector extends ConnectorBase<
 				readState: (path) => this.readConnectorState(path),
 				isRunning: (state) => isProcessRunning(state.pid),
 				formatAlreadyRunningMessage: (state) =>
-					state.connectionMode === "socket"
-						? `[slack] connector already running pid=${state.pid} rpc=${state.rpcAddress} mode=socket`
-						: `[slack] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
+					`[slack] connector already running pid=${state.pid} rpc=${state.rpcAddress} url=${state.baseUrl}`,
 				formatBackgroundStartMessage: (pid) =>
-					`[slack] starting background connector pid=${pid} user=${options.userName} mode=${options.connectionMode}`,
+					`[slack] starting background connector pid=${pid} user=${options.userName}`,
 				foregroundHint:
 					"[slack] use `cline connect slack -i ...` to run in the foreground",
 				launchFailureMessage: "failed to launch Slack connector in background",
@@ -715,7 +618,6 @@ class SlackConnector extends ConnectorBase<
 		const consoleLogger = new ConsoleLogger("info", "slack-connect");
 		const slackConfig: Record<string, unknown> = {
 			logger: consoleLogger,
-			mode: options.connectionMode,
 			userName: options.userName,
 		};
 		if (options.botToken?.trim()) {
@@ -724,9 +626,6 @@ class SlackConnector extends ConnectorBase<
 		if (options.signingSecret?.trim()) {
 			slackConfig.signingSecret = options.signingSecret.trim();
 		}
-		if (options.appToken?.trim()) {
-			slackConfig.appToken = options.appToken.trim();
-		}
 		if (options.clientId?.trim()) {
 			slackConfig.clientId = options.clientId.trim();
 		}
@@ -795,12 +694,10 @@ class SlackConnector extends ConnectorBase<
 		await client.connect();
 		this.writeConnectorState(statePath, {
 			userName: options.userName,
-			connectionMode: options.connectionMode,
 			pid: process.pid,
 			rpcAddress,
-			...(options.connectionMode === "webhook"
-				? { port: options.port, baseUrl: options.baseUrl }
-				: {}),
+			port: options.port,
+			baseUrl: options.baseUrl,
 			startedAt: new Date().toISOString(),
 		});
 
@@ -826,7 +723,7 @@ class SlackConnector extends ConnectorBase<
 				bindingsPath,
 				startRequest,
 			);
-			const queueKey = thread.id;
+			const queueKey = currentState.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await withSlackTeamBotToken({
@@ -945,10 +842,9 @@ class SlackConnector extends ConnectorBase<
 		};
 
 		bot.onNewMention(async (thread, message) => {
-			const mentionThread = resolveSlackChannelMentionThread(thread, message);
-			await mentionThread.subscribe();
+			await thread.subscribe();
 			await persistSlackThreadContext({
-				thread: mentionThread,
+				thread,
 				bindingsPath,
 				baseStartRequest: startRequest,
 				rawMessage: message.raw,
@@ -956,7 +852,7 @@ class SlackConnector extends ConnectorBase<
 			});
 			if (
 				await maybeHandleConnectorApprovalReply({
-					thread: mentionThread,
+					thread,
 					text: message.text,
 					client,
 					clientId,
@@ -966,7 +862,7 @@ class SlackConnector extends ConnectorBase<
 			) {
 				return;
 			}
-			await handleTurn(mentionThread, message.text);
+			await handleTurn(thread, message.text);
 		});
 
 		bot.onSubscribedMessage(async (thread, message) => {
@@ -1052,64 +948,48 @@ class SlackConnector extends ConnectorBase<
 				},
 			});
 
-		let webhookUrl: string | undefined;
-		let oauthCallbackUrl: string | undefined;
-		const server =
-			options.connectionMode === "webhook"
-				? await (async () => {
-						const baseUrl = options.baseUrl?.trim();
-						if (!baseUrl) {
-							throw new Error(
-								"Slack webhook mode requires --base-url or BASE_URL",
-							);
-						}
-						webhookUrl = `${baseUrl.replace(/\/$/, "")}/api/webhooks/slack`;
-						oauthCallbackUrl = `${baseUrl.replace(/\/$/, "")}/api/oauth/slack/callback`;
-						return startConnectorWebhookServer({
-							host: options.host,
-							port: options.port,
-							routes: {
-								"/api/webhooks/slack": async (request) =>
-									bot.webhooks.slack(request),
-								"/api/oauth/slack/callback": async (request) => {
-									try {
-										const result = await slack.handleOAuthCallback(request);
-										return new Response(
-											`Slack installation stored for team ${result.teamId}. You can return to Slack.`,
-										);
-									} catch (error) {
-										const message =
-											error instanceof Error ? error.message : String(error);
-										loggerAdapter.core.log("Slack OAuth callback failed", {
-											severity: "warn",
-											transport: "slack",
-											error: message,
-										});
-										return new Response(`Slack OAuth error: ${message}`, {
-											status: 500,
-										});
-									}
-								},
-								"/health": () => new Response("ok"),
-								"/": () =>
-									new Response(
-										[
-											"Slack connector is running.",
-											"Connection mode: webhook",
-											`Webhook URL: ${webhookUrl}`,
-											`OAuth callback URL: ${oauthCallbackUrl}`,
-											options.botToken?.trim()
-												? "Auth mode: single workspace"
-												: options.clientId?.trim() &&
-														options.clientSecret?.trim()
-													? "Auth mode: multi-workspace OAuth"
-													: "Auth mode: incomplete (set bot token or OAuth credentials)",
-										].join("\n"),
-									),
-							},
+		const webhookUrl = `${options.baseUrl.replace(/\/$/, "")}/api/webhooks/slack`;
+		const oauthCallbackUrl = `${options.baseUrl.replace(/\/$/, "")}/api/oauth/slack/callback`;
+		const server = await startConnectorWebhookServer({
+			host: options.host,
+			port: options.port,
+			routes: {
+				"/api/webhooks/slack": async (request) => bot.webhooks.slack(request),
+				"/api/oauth/slack/callback": async (request) => {
+					try {
+						const result = await slack.handleOAuthCallback(request);
+						return new Response(
+							`Slack installation stored for team ${result.teamId}. You can return to Slack.`,
+						);
+					} catch (error) {
+						const message =
+							error instanceof Error ? error.message : String(error);
+						loggerAdapter.core.log("Slack OAuth callback failed", {
+							severity: "warn",
+							transport: "slack",
+							error: message,
 						});
-					})()
-				: undefined;
+						return new Response(`Slack OAuth error: ${message}`, {
+							status: 500,
+						});
+					}
+				},
+				"/health": () => new Response("ok"),
+				"/": () =>
+					new Response(
+						[
+							"Slack connector is running.",
+							`Webhook URL: ${webhookUrl}`,
+							`OAuth callback URL: ${oauthCallbackUrl}`,
+							options.botToken?.trim()
+								? "Auth mode: single workspace"
+								: options.clientId?.trim() && options.clientSecret?.trim()
+									? "Auth mode: multi-workspace OAuth"
+									: "Auth mode: incomplete (set bot token or OAuth credentials)",
+						].join("\n"),
+					),
+			},
+		});
 
 		const stopEventStream = client.streamEvents(
 			{ clientId: `${clientId}-server-events` },
@@ -1172,22 +1052,17 @@ class SlackConnector extends ConnectorBase<
 		process.once("SIGINT", () => requestStop("sigint"));
 		process.once("SIGTERM", () => requestStop("sigterm"));
 
-		if (options.connectionMode === "webhook") {
-			io.writeln(`[slack] listening on ${options.host}:${options.port}`);
-			io.writeln(`[slack] configure Slack webhook URL: ${webhookUrl}`);
-			io.writeln(
-				`[slack] configure Slack OAuth callback URL: ${oauthCallbackUrl}`,
-			);
-		} else {
-			io.writeln("[slack] socket mode connected");
-		}
+		io.writeln(`[slack] listening on ${options.host}:${options.port}`);
+		io.writeln(`[slack] configure Slack webhook URL: ${webhookUrl}`);
+		io.writeln(
+			`[slack] configure Slack OAuth callback URL: ${oauthCallbackUrl}`,
+		);
 
 		await stopPromise;
 		clearBindingSessionIds<SlackThreadState>(bindingsPath);
 		stopTaskUpdateStream();
 		stopEventStream();
-		await server?.close();
-		await bot.shutdown();
+		await server.close();
 		userInstructionService.stop();
 		client.close();
 		this.removeStateFile(statePath);
@@ -1198,11 +1073,9 @@ class SlackConnector extends ConnectorBase<
 export const slackConnector: ConnectCommandDefinition = new SlackConnector();
 
 export const __test__ = {
-	inferSlackConnectionMode,
 	buildSlackParticipantKey,
 	resolveSlackParticipant,
 	normalizeSlackMessageEventChannelType,
-	resolveSlackChannelMentionThread,
 	withSlackTeamBotToken,
 	isSlackInvalidThreadTsError,
 	findBindingForThread: (

apps/cli/src/connectors/adapters/telegram.md

@@ -76,15 +76,7 @@ cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --no-tools
 
 When the connector starts with `--no-tools`, chat commands such as `/tools on` and `/yolo on` cannot re-enable tools for that connector run.
 
-For participant restrictions, run the interactive connector wizard with `cline connect`. The Telegram wizard asks whether to restrict access, points you to `@userinfobot`, and configures your numeric Telegram user ID.
-
-You can also pass the user ID directly:
-
-```bash
-cline connect telegram -k "$TELEGRAM_BOT_TOKEN" --allowed-user-id 12345
-```
-
-You can also pass a manual `--hook-command` that returns `{"action":"deny"}` for unauthorized `session.authorize` events. If neither access option is configured, messages are allowed.
+For participant restrictions, run the interactive connector wizard with `cline connect` or pass a `--hook-command` that returns `{"action":"deny"}` for unauthorized `session.authorize` events. If no hook is configured, messages are allowed.
 
 ## Message Delivery
 

apps/cli/src/connectors/adapters/telegram.test.ts

@@ -62,72 +62,6 @@ describe("telegramConnector", () => {
 		expect(options.enableTools).toBe(true);
 	});
 
-	it("builds an authorization hook from --allowed-user-id", () => {
-		const options = parseTelegramArgs([
-			"--bot-token",
-			"123:test",
-			"--cwd",
-			"/tmp/work",
-			"--allowed-user-id",
-			"1201547643",
-		]);
-
-		expect(options.hookCommand).toBe(
-			`jq -r ".payload.actor.participantKey" | grep -qx "telegram:id:1201547643" && echo '{"action":"allow"}' || echo '{"action":"deny","message":"unauthorized","reason":"not_on_allowlist"}'`,
-		);
-	});
-
-	it("rejects unsafe --allowed-user-id values", () => {
-		expect(() =>
-			parseTelegramArgs([
-				"--bot-token",
-				"123:test",
-				"--cwd",
-				"/tmp/work",
-				"--allowed-user-id",
-				"123; rm -rf /",
-			]),
-		).toThrow("digits only");
-	});
-
-	it("rejects mixing --allowed-user-id with --hook-command", () => {
-		expect(() =>
-			parseTelegramArgs([
-				"--bot-token",
-				"123:test",
-				"--cwd",
-				"/tmp/work",
-				"--allowed-user-id",
-				"1201547643",
-				"--hook-command",
-				"echo noop",
-			]),
-		).toThrow("either --allowed-user-id or --hook-command");
-	});
-
-	it("rejects mixing --allowed-user-id with the hook command env var", () => {
-		const originalHookCommand = process.env.CLINE_CONNECT_HOOK_COMMAND;
-		process.env.CLINE_CONNECT_HOOK_COMMAND = "echo noop";
-		try {
-			expect(() =>
-				parseTelegramArgs([
-					"--bot-token",
-					"123:test",
-					"--cwd",
-					"/tmp/work",
-					"--allowed-user-id",
-					"1201547643",
-				]),
-			).toThrow("either --allowed-user-id or --hook-command");
-		} finally {
-			if (originalHookCommand === undefined) {
-				delete process.env.CLINE_CONNECT_HOOK_COMMAND;
-			} else {
-				process.env.CLINE_CONNECT_HOOK_COMMAND = originalHookCommand;
-			}
-		}
-	});
-
 	it("does not require the bot username", () => {
 		const options = parseTelegramArgs([
 			"--bot-token",
@@ -363,7 +297,7 @@ describe("telegram binding lookup", () => {
 		expect(result?.binding.sessionId).toBe("sess-2");
 	});
 
-	it("does not reuse a binding by participant key across different chats", () => {
+	it("reuses a binding by participant key across different chats", () => {
 		const result = __test__.findBindingForThread(
 			{
 				"telegram:user:alice": {
@@ -389,6 +323,7 @@ describe("telegram binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result?.key).toBe("telegram:user:alice");
+		expect(result?.binding.sessionId).toBe("sess-1");
 	});
 });

apps/cli/src/connectors/adapters/telegram.ts

@@ -42,7 +42,7 @@ import {
 	type ConnectorBindingStore,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
 	persistMergedThreadState,
@@ -89,20 +89,6 @@ function readTelegramBotId(botToken: string): string | undefined {
 	return /^\d+$/.test(botId) ? botId : undefined;
 }
 
-function normalizeAllowedTelegramUserId(value: string): string {
-	const userId = value.trim();
-	if (!/^\d+$/.test(userId)) {
-		throw new Error(
-			"connect telegram --allowed-user-id must contain digits only",
-		);
-	}
-	return userId;
-}
-
-function buildTelegramAllowedUserHookCommand(userId: string): string {
-	return `jq -r ".payload.actor.participantKey" | grep -qx "telegram:id:${userId}" && echo '{"action":"allow"}' || echo '{"action":"deny","message":"unauthorized","reason":"not_on_allowlist"}'`;
-}
-
 function describeTelegramGetMeFailure(
 	response: Response,
 	body: string,
@@ -293,20 +279,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<TelegramThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	const deliveryThreadId = match?.key || threadId;
 	if (!binding?.serializedThread) {
@@ -432,10 +418,6 @@ class TelegramConnector extends ConnectorBase<
 			.option("--mode <act|plan>", "Agent mode", "act")
 			.option("-i, --interactive", "Keep connector in foreground")
 			.option("--no-tools", "Disable tools for Telegram sessions")
-			.option(
-				"--allowed-user-id <id>",
-				"Only allow this Telegram user ID to use the bot",
-			)
 			.option(
 				"--hook-command <command>",
 				"Run a shell command for connector events",
@@ -452,7 +434,6 @@ class TelegramConnector extends ConnectorBase<
 					"Notes:",
 					"  - Without -i, the connector is launched in the background.",
 					"  - Tools are enabled by default for Telegram sessions.",
-					"  - Use --allowed-user-id or `cline connect` to restrict Telegram access.",
 					"  - Bot username is discovered from the Telegram bot token when omitted.",
 					"  - Provider/model default to the CLI's last-used provider settings.",
 				].join("\n"),
@@ -473,7 +454,6 @@ class TelegramConnector extends ConnectorBase<
 			tools?: boolean;
 			rpcAddress?: string;
 			hookCommand?: string;
-			allowedUserId?: string;
 		}>();
 		const botUsername =
 			normalizeTelegramBotUsername(opts.botUsername ?? "") ||
@@ -485,15 +465,6 @@ class TelegramConnector extends ConnectorBase<
 		if (!botToken) {
 			throw new Error("connect telegram requires -k/--bot-token <token>");
 		}
-		const hookCommand =
-			opts.hookCommand?.trim() ||
-			process.env.CLINE_CONNECT_HOOK_COMMAND?.trim();
-		const allowedUserId = opts.allowedUserId?.trim();
-		if (hookCommand && allowedUserId) {
-			throw new Error(
-				"connect telegram accepts either --allowed-user-id or --hook-command, not both",
-			);
-		}
 		return {
 			botToken,
 			...(botUsername ? { botUsername } : {}),
@@ -509,11 +480,9 @@ class TelegramConnector extends ConnectorBase<
 				opts.rpcAddress?.trim() ||
 				process.env.CLINE_RPC_ADDRESS?.trim() ||
 				resolveDefaultCliRpcAddress(),
-			hookCommand: allowedUserId
-				? buildTelegramAllowedUserHookCommand(
-						normalizeAllowedTelegramUserId(allowedUserId),
-					)
-				: hookCommand,
+			hookCommand:
+				opts.hookCommand?.trim() ||
+				process.env.CLINE_CONNECT_HOOK_COMMAND?.trim(),
 		};
 	}
 
@@ -788,7 +757,9 @@ class TelegramConnector extends ConnectorBase<
 			thread: Thread<TelegramThreadState>,
 			text: string,
 		) => {
-			const queueKey = thread.id;
+			const queueKey =
+				(await loadThreadState(thread, bindingsPath, startRequest))
+					.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await handleConnectorUserTurn({

apps/cli/src/connectors/adapters/whatsapp.test.ts

@@ -65,7 +65,7 @@ describe("whatsapp binding lookup", () => {
 		expect(result?.binding.sessionId).toBe("sess-2");
 	});
 
-	it("does not reuse a binding by participant key across different threads", () => {
+	it("reuses a binding by participant key across different threads", () => {
 		const result = __test__.findBindingForThread(
 			{
 				"whatsapp:user:15551234567": {
@@ -91,6 +91,7 @@ describe("whatsapp binding lookup", () => {
 			},
 		);
 
-		expect(result).toBeUndefined();
+		expect(result?.key).toBe("whatsapp:user:15551234567");
+		expect(result?.binding.sessionId).toBe("sess-1");
 	});
 });

apps/cli/src/connectors/adapters/whatsapp.ts

@@ -46,7 +46,7 @@ import {
 	type ConnectorBindingStore,
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
+	findBindingForParticipantKey,
 	findBindingForThread,
 	loadThreadState,
 	persistMergedThreadState,
@@ -226,20 +226,20 @@ async function deliverScheduledResult(input: {
 	const threadId =
 		typeof delivery.threadId === "string" ? delivery.threadId.trim() : "";
 	const bindingKey =
-		typeof delivery.bindingKey === "string" ? delivery.bindingKey.trim() : "";
-	const participantKey =
-		typeof delivery.participantKey === "string"
-			? delivery.participantKey.trim()
-			: "";
-	if (!threadId && !bindingKey && !participantKey) {
+		typeof delivery.bindingKey === "string"
+			? delivery.bindingKey.trim()
+			: typeof delivery.participantKey === "string"
+				? delivery.participantKey.trim()
+				: "";
+	if (!threadId && !bindingKey) {
 		return;
 	}
 	const bindings = readBindings<WhatsAppThreadState>(input.bindingsPath);
-	const match = findBindingForDeliveryTarget(bindings, {
-		bindingKey,
-		threadId,
-		participantKey,
-	});
+	const match = bindingKey
+		? findBindingForParticipantKey(bindings, bindingKey)
+		: threadId
+			? { key: threadId, binding: bindings[threadId] }
+			: undefined;
 	const binding = match?.binding;
 	if (!binding?.serializedThread) {
 		return;
@@ -597,7 +597,9 @@ class WhatsAppConnector extends ConnectorBase<
 			thread: Thread<WhatsAppThreadState>,
 			text: string,
 		) => {
-			const queueKey = thread.id;
+			const queueKey =
+				(await loadThreadState(thread, bindingsPath, startRequest))
+					.participantKey || thread.id;
 			const runTurn = async () => {
 				try {
 					await handleConnectorUserTurn({

apps/cli/src/connectors/catalog.ts

@@ -1,2 +1,36 @@
-export type { ConnectorCatalogEntry } from "@cline/shared";
-export { CONNECTOR_CATALOG, listConnectorCatalog } from "@cline/shared";
+export type ConnectorCatalogEntry = {
+	name: string;
+	description: string;
+};
+
+export const CONNECTOR_CATALOG: ConnectorCatalogEntry[] = [
+	{
+		name: "discord",
+		description:
+			"Discord interactions and gateway bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "gchat",
+		description: "Google Chat webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "linear",
+		description: "Linear webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "slack",
+		description: "Slack webhook bridge backed by RPC runtime sessions",
+	},
+	{
+		name: "telegram",
+		description: "Bridge Telegram bot messages into RPC chat sessions",
+	},
+	{
+		name: "whatsapp",
+		description: "Bridge WhatsApp webhook messages into RPC chat sessions",
+	},
+];
+
+export function listConnectorCatalog(): ConnectorCatalogEntry[] {
+	return CONNECTOR_CATALOG.map((entry) => ({ ...entry }));
+}

apps/cli/src/connectors/common.ts

@@ -194,9 +194,6 @@ export function spawnDetachedConnector(
 				...withResolvedClineBuildEnv(process.env),
 				[childEnvKey]: "1",
 			},
-			// Prevent a console window from appearing on Windows; detached
-			// processes otherwise allocate a new visible console.
-			windowsHide: true,
 		});
 		logSpawnedProcess({
 			component: options?.component ?? "connectors",

apps/cli/src/connectors/connector-host.test.ts

@@ -92,11 +92,6 @@ function createRuntimeClient(
 ) {
 	const startRuntimeSession = vi.fn(async () => ({ sessionId: "session-1" }));
 	const updateSession = vi.fn(async () => undefined);
-	const getSession = vi.fn(
-		async (sessionId: string): Promise<{ sessionId: string } | undefined> => ({
-			sessionId,
-		}),
-	);
 	const abortRuntimeSession = vi.fn(async () => undefined);
 	const deleteSession = vi.fn(async () => undefined);
 	const sendRuntimeSession = vi.fn(async () => ({
@@ -111,7 +106,6 @@ function createRuntimeClient(
 		client: {
 			startRuntimeSession,
 			updateSession,
-			getSession,
 			abortRuntimeSession,
 			stopRuntimeSession: abortRuntimeSession,
 			deleteSession,
@@ -121,7 +115,6 @@ function createRuntimeClient(
 		},
 		startRuntimeSession,
 		updateSession,
-		getSession,
 		sendRuntimeSession,
 		readMessages,
 	};
@@ -600,8 +593,7 @@ describe("handleConnectorUserTurn", () => {
 				metadata: expect.objectContaining({
 					delivery: expect.objectContaining({
 						adapter: "telegram",
-						bindingKey: "thread-1",
-						participantKey: "telegram:user:alice",
+						bindingKey: "telegram:user:alice",
 					}),
 				}),
 			}),
@@ -635,8 +627,7 @@ describe("handleConnectorUserTurn", () => {
 				metadata: {
 					delivery: {
 						adapter: "telegram",
-						bindingKey: "thread-1",
-						participantKey: "telegram:user:alice",
+						bindingKey: "telegram:user:alice",
 						threadId: "thread-1",
 					},
 				},
@@ -649,8 +640,7 @@ describe("handleConnectorUserTurn", () => {
 				metadata: {
 					delivery: {
 						adapter: "telegram",
-						bindingKey: "thread-2",
-						participantKey: "telegram:user:bob",
+						bindingKey: "telegram:user:bob",
 						threadId: "thread-2",
 					},
 				},
@@ -709,8 +699,7 @@ describe("handleConnectorUserTurn", () => {
 					delivery: expect.objectContaining({
 						adapter: "telegram",
 						threadId: "thread-1",
-						bindingKey: "thread-1",
-						participantKey: "telegram:user:alice",
+						bindingKey: "telegram:user:alice",
 						userName: "ClineAdapterBot",
 					}),
 				}),
@@ -1453,7 +1442,7 @@ describe("handleConnectorUserTurn", () => {
 		});
 		const runtime = createRuntimeClient("unused");
 		const activeTurns = new Map([
-			["other-turn-key", { sessionId: "session-1", threadId: "thread-1" }],
+			["other-turn-key", { sessionId: "session-1" }],
 		]);
 
 		await handleConnectorUserTurn({
@@ -1489,105 +1478,4 @@ describe("handleConnectorUserTurn", () => {
 		);
 		expect(posts.at(-1)).toEqual({ raw: "Steering current task." });
 	});
-
-	it("starts a normal turn when the active session is in a different thread", async () => {
-		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
-		tempDirs.push(dir);
-		const bindingsPath = join(dir, "threads.json");
-		const { thread, posts } = createThread({
-			enableTools: true,
-			autoApproveTools: true,
-			cwd: "/tmp/work",
-			workspaceRoot: "/tmp/work",
-			welcomeSentAt: new Date().toISOString(),
-		});
-		const runtime = createRuntimeClient("normal reply");
-		const activeTurns = new Map([
-			["other-thread", { sessionId: "session-1", threadId: "other-thread" }],
-		]);
-
-		await handleConnectorUserTurn({
-			thread: thread as never,
-			text: "start work in this thread",
-			client: runtime.client as never,
-			pendingApprovals: new Map(),
-			baseStartRequest: baseStartRequest() as never,
-			explicitSystemPrompt: undefined,
-			clientId: "client-1",
-			logger: {
-				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
-			} as never,
-			transport: "telegram",
-			botUserName: "ClineAdapterBot",
-			requestStop: vi.fn(),
-			bindingsPath,
-			systemRules: "rules",
-			errorLabel: "Telegram",
-			getSessionMetadata: () => ({}),
-			reusedLogMessage: "reused",
-			activeTurns,
-			turnKey: "thread-1",
-		});
-
-		expect(runtime.startRuntimeSession).toHaveBeenCalled();
-		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
-			"session-1",
-			expect.not.objectContaining({
-				delivery: "steer",
-			}),
-			{ timeoutMs: null },
-		);
-		expect(posts.at(-1)).toEqual({ raw: "normal reply" });
-	});
-
-	it("starts a fresh session when persisted thread session is missing from the hub", async () => {
-		const dir = mkdtempSync(join(tmpdir(), "connector-host-test-"));
-		tempDirs.push(dir);
-		const bindingsPath = join(dir, "threads.json");
-		const { thread, posts, getState } = createThread({
-			sessionId: "stale-session",
-			enableTools: true,
-			autoApproveTools: true,
-			cwd: "/tmp/work",
-			workspaceRoot: "/tmp/work",
-			welcomeSentAt: new Date().toISOString(),
-		});
-		const runtime = createRuntimeClient("fresh reply");
-		runtime.getSession.mockResolvedValueOnce(undefined);
-
-		await handleConnectorUserTurn({
-			thread: thread as never,
-			text: "continue after hub restart",
-			client: runtime.client as never,
-			pendingApprovals: new Map(),
-			baseStartRequest: baseStartRequest() as never,
-			explicitSystemPrompt: undefined,
-			clientId: "client-1",
-			logger: {
-				core: { debug: vi.fn(), log: vi.fn(), error: vi.fn() },
-			} as never,
-			transport: "telegram",
-			botUserName: "ClineAdapterBot",
-			requestStop: vi.fn(),
-			bindingsPath,
-			systemRules: "rules",
-			errorLabel: "Telegram",
-			getSessionMetadata: () => ({}),
-			reusedLogMessage: "reused",
-			startedLogMessage: "started",
-			turnKey: "thread-1",
-		});
-
-		expect(runtime.getSession).toHaveBeenCalledWith("stale-session");
-		expect(runtime.startRuntimeSession).toHaveBeenCalled();
-		expect(runtime.sendRuntimeSession).toHaveBeenCalledWith(
-			"session-1",
-			expect.not.objectContaining({
-				delivery: "steer",
-			}),
-			{ timeoutMs: null },
-		);
-		expect(getState().sessionId).toBe("session-1");
-		expect(posts.at(-1)).toEqual({ raw: "fresh reply" });
-	});
 });

apps/cli/src/connectors/connector-host.ts

@@ -749,7 +749,9 @@ export async function handleConnectorUserTurn<
 					`channelId=${input.thread.channelId}`,
 					`deliveryAdapter=${input.transport}`,
 					`deliveryThread=${input.thread.id}`,
-					`deliveryBindingKey=${input.thread.id}`,
+					...(effectiveCurrent.participantKey
+						? [`deliveryBindingKey=${effectiveCurrent.participantKey}`]
+						: []),
 					`deliveryChannel=${input.thread.channelId}`,
 					...(input.botUserName
 						? [`deliveryUserName=${input.botUserName}`]
@@ -787,9 +789,11 @@ export async function handleConnectorUserTurn<
 						delivery: {
 							adapter: input.transport,
 							threadId: input.thread.id,
-							bindingKey: input.thread.id,
 							...(current.participantKey
-								? { participantKey: current.participantKey }
+								? {
+										bindingKey: current.participantKey,
+										participantKey: current.participantKey,
+									}
 								: {}),
 							...(current.participantLabel
 								? { participantLabel: current.participantLabel }
@@ -828,6 +832,11 @@ export async function handleConnectorUserTurn<
 					].join("\n");
 				},
 				list: async () => {
+					const current = await loadThreadState(
+						input.thread,
+						input.bindingsPath,
+						input.baseStartRequest,
+					);
 					const schedules = await input.client.listSchedules({ limit: 200 });
 					const matching = schedules.filter((schedule) => {
 						const delivery = schedule.metadata?.delivery;
@@ -837,9 +846,17 @@ export async function handleConnectorUserTurn<
 							!Array.isArray(delivery)
 								? (delivery as Record<string, unknown>)
 								: undefined;
+						const deliveryBindingKey =
+							typeof deliveryRecord?.bindingKey === "string"
+								? deliveryRecord.bindingKey
+								: typeof deliveryRecord?.participantKey === "string"
+									? deliveryRecord.participantKey
+									: undefined;
 						return (
 							deliveryRecord?.adapter === input.transport &&
-							deliveryRecord.threadId === input.thread.id
+							(current.participantKey
+								? deliveryBindingKey === current.participantKey
+								: deliveryRecord.threadId === input.thread.id)
 						);
 					});
 					if (matching.length === 0) {
@@ -896,9 +913,7 @@ export async function handleConnectorUserTurn<
 		input.activeTurns?.get(turnKey) ??
 		(input.activeTurns && currentState.sessionId?.trim()
 			? Array.from(input.activeTurns.values()).find(
-					(turn) =>
-						turn.sessionId === currentState.sessionId?.trim() &&
-						turn.threadId === input.thread.id,
+					(turn) => turn.sessionId === currentState.sessionId?.trim(),
 				)
 			: undefined);
 	if (activeTurn?.sessionId?.trim()) {

apps/cli/src/connectors/session-runtime.test.ts

@@ -1,17 +1,15 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
 const {
 	mockGetLastUsedProviderSettings,
 	mockGetProviderSettings,
 	mockResolveSystemPrompt,
 	mockGetProviderCollection,
-	mockGetBooleanFlagEnabled,
 } = vi.hoisted(() => ({
 	mockGetLastUsedProviderSettings: vi.fn(),
 	mockGetProviderSettings: vi.fn(),
 	mockResolveSystemPrompt: vi.fn(),
 	mockGetProviderCollection: vi.fn(),
-	mockGetBooleanFlagEnabled: vi.fn(),
 }));
 
 vi.mock("@cline/core", async () => {
@@ -20,8 +18,8 @@ vi.mock("@cline/core", async () => {
 	return {
 		...actual,
 		ProviderSettingsManager: class {
-			getLastUsedProviderSettings(options?: unknown) {
-				return mockGetLastUsedProviderSettings(options);
+			getLastUsedProviderSettings() {
+				return mockGetLastUsedProviderSettings();
 			}
 
 			getProviderSettings(providerId: string) {
@@ -45,12 +43,6 @@ vi.mock("../utils/helpers", () => ({
 	resolveWorkspaceRoot: vi.fn((cwd: string) => cwd),
 }));
 
-vi.mock("../utils/feature-flags", () => ({
-	getCliFeatureFlagsService: () => ({
-		getBooleanFlagEnabled: mockGetBooleanFlagEnabled,
-	}),
-}));
-
 vi.mock("../commands/auth", async () => {
 	const actual =
 		await vi.importActual<typeof import("../commands/auth")>(
@@ -65,10 +57,6 @@ vi.mock("../commands/auth", async () => {
 import { buildConnectorStartRequest } from "./session-runtime";
 
 describe("buildConnectorStartRequest", () => {
-	beforeEach(() => {
-		mockGetBooleanFlagEnabled.mockReturnValue(false);
-	});
-
 	afterEach(() => {
 		vi.clearAllMocks();
 		delete process.env.OPENROUTER_API_KEY;
@@ -100,64 +88,5 @@ describe("buildConnectorStartRequest", () => {
 		expect(request.provider).toBe("openrouter");
 		expect(request.apiKey).toBe("env-openrouter-key");
 		expect(request.model).toBe("anthropic/claude-sonnet-4.6");
-		expect(mockGetLastUsedProviderSettings).toHaveBeenCalledWith({
-			isClinePassEnabled: false,
-		});
-	});
-
-	it("uses auth material resolved by provider settings manager", async () => {
-		mockGetLastUsedProviderSettings.mockReturnValue({ provider: "cline-pass" });
-		mockGetProviderSettings.mockReturnValue({
-			provider: "cline-pass",
-			auth: { accessToken: "workos:resolved-token" },
-		});
-		mockGetProviderCollection.mockReturnValue({
-			provider: { env: ["CLINE_API_KEY"] },
-		});
-		mockResolveSystemPrompt.mockResolvedValue("system");
-
-		const request = await buildConnectorStartRequest({
-			options: {
-				cwd: "/tmp/work",
-				mode: "act",
-				enableTools: false,
-			},
-			io: { writeln: vi.fn(), writeErr: vi.fn() },
-			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
-			systemRules: "Rules",
-			defaultModel: "cline-pass/glm-5.1",
-		});
-
-		expect(request.provider).toBe("cline-pass");
-		expect(request.apiKey).toBe("workos:resolved-token");
-		expect(request.model).toBe("cline-pass/glm-5.1");
-	});
-
-	it("uses auth material resolved by provider settings manager", async () => {
-		mockGetLastUsedProviderSettings.mockReturnValue({ provider: "cline-pass" });
-		mockGetProviderSettings.mockReturnValue({
-			provider: "cline-pass",
-			auth: { accessToken: "workos:resolved-token" },
-		});
-		mockGetProviderCollection.mockReturnValue({
-			provider: { env: ["CLINE_API_KEY"] },
-		});
-		mockResolveSystemPrompt.mockResolvedValue("system");
-
-		const request = await buildConnectorStartRequest({
-			options: {
-				cwd: "/tmp/work",
-				mode: "act",
-				enableTools: false,
-			},
-			io: { writeln: vi.fn(), writeErr: vi.fn() },
-			loggerConfig: { enabled: false, level: "info", destination: "stdout" },
-			systemRules: "Rules",
-			defaultModel: "cline-pass/glm-5.1",
-		});
-
-		expect(request.provider).toBe("cline-pass");
-		expect(request.apiKey).toBe("workos:resolved-token");
-		expect(request.model).toBe("cline-pass/glm-5.1");
 	});
 });

apps/cli/src/connectors/session-runtime.ts

@@ -16,7 +16,6 @@ import {
 import type { CliLoggerAdapter } from "../logging/adapter";
 import { resolveSystemPrompt } from "../runtime/prompt";
 import { resolveCliSessionMetadata } from "../utils/enterprise";
-import { getCliFeatureFlagsService } from "../utils/feature-flags";
 import { resolveWorkspaceRoot } from "../utils/helpers";
 import {
 	parseLocalRowMetadata,
@@ -63,10 +62,7 @@ export async function buildConnectorStartRequest(input: {
 }): Promise<ChatStartSessionRequest> {
 	const providerSettingsManager = new ProviderSettingsManager();
 	const lastUsedProviderSettings =
-		providerSettingsManager.getLastUsedProviderSettings({
-			isClinePassEnabled:
-				getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
-		});
+		providerSettingsManager.getLastUsedProviderSettings();
 	const provider = normalizeProviderId(
 		input.options.provider?.trim() ||
 			lastUsedProviderSettings?.provider ||
@@ -163,57 +159,36 @@ export async function getOrCreateSessionId<
 	);
 	const existing = threadState.sessionId?.trim();
 	if (existing) {
-		const existingSession = await input.client.getSession(existing);
-		if (existingSession) {
-			await persistMergedThreadState(
-				input.thread,
-				input.bindingsPath,
-				{
-					...threadState,
-					sessionId: existing,
-				},
-				input.errorLabel,
-			);
-			input.logger.core.log(input.reusedLogMessage, {
-				transport: input.transport,
-				threadId: input.thread.id,
-				sessionId: existing,
-			});
-			await dispatchConnectorHook(
-				input.hookCommand,
-				{
-					adapter: input.transport,
-					botUserName: input.hookBotUserName,
-					event: "session.reused",
-					payload: {
-						threadId: input.thread.id,
-						channelId: input.thread.channelId,
-						sessionId: existing,
-					},
-					ts: new Date().toISOString(),
-				},
-				input.logger,
-			);
-			return existing;
-		}
 		await persistMergedThreadState(
 			input.thread,
 			input.bindingsPath,
 			{
 				...threadState,
-				sessionId: undefined,
+				sessionId: existing,
 			},
 			input.errorLabel,
 		);
-		input.logger.core.log(
-			"Connector thread session missing; starting a new session",
+		input.logger.core.log(input.reusedLogMessage, {
+			transport: input.transport,
+			threadId: input.thread.id,
+			sessionId: existing,
+		});
+		await dispatchConnectorHook(
+			input.hookCommand,
 			{
-				severity: "warn",
-				transport: input.transport,
-				threadId: input.thread.id,
-				sessionId: existing,
+				adapter: input.transport,
+				botUserName: input.hookBotUserName,
+				event: "session.reused",
+				payload: {
+					threadId: input.thread.id,
+					channelId: input.thread.channelId,
+					sessionId: existing,
+				},
+				ts: new Date().toISOString(),
 			},
+			input.logger,
 		);
+		return existing;
 	}
 
 	const started = await input.client.startRuntimeSession(input.startRequest);

apps/cli/src/connectors/status.ts

@@ -26,7 +26,6 @@ export type ActiveConnectorRecord = {
 	phoneNumberId?: string;
 	port?: number;
 	baseUrl?: string;
-	connectionMode?: string;
 };
 
 function listConnectorStatePaths(
@@ -69,8 +68,6 @@ const connectorFieldExtractors: Record<
 	startedAt: (p) => (typeof p.startedAt === "string" ? p.startedAt : undefined),
 	port: (p) => (typeof p.port === "number" ? p.port : undefined),
 	baseUrl: (p) => (typeof p.baseUrl === "string" ? p.baseUrl : undefined),
-	connectionMode: (p) =>
-		typeof p.connectionMode === "string" ? p.connectionMode : undefined,
 	userName: (p) => (typeof p.userName === "string" ? p.userName : undefined),
 	botUsername: (p) =>
 		typeof p.botUsername === "string" ? p.botUsername : undefined,
@@ -94,10 +91,7 @@ const connectorConfigs: Record<
 		required: ["userName"],
 		optional: ["startedAt", "port", "baseUrl"],
 	},
-	slack: {
-		required: ["userName"],
-		optional: ["startedAt", "connectionMode", "port", "baseUrl"],
-	},
+	slack: { required: ["userName"], optional: ["startedAt", "port", "baseUrl"] },
 	whatsapp: {
 		required: ["userName"],
 		optional: ["startedAt", "phoneNumberId", "port", "baseUrl"],

apps/cli/src/connectors/thread-bindings.test.ts

@@ -6,7 +6,6 @@ import { afterEach, describe, expect, it } from "vitest";
 import {
 	type ConnectorThreadState,
 	clearBindingSessionIds,
-	findBindingForDeliveryTarget,
 	isParticipantMuted,
 	isThreadMuted,
 	readBindingForThread,
@@ -53,16 +52,16 @@ afterEach(() => {
 });
 
 describe("thread binding refresh", () => {
-	it("refreshes the serialized thread immediately when DM channel fallback rebinds a thread id", () => {
+	it("refreshes the serialized thread immediately when channel fallback rebinds a thread id", () => {
 		const path = createBindingsPath();
 		writeBindings<TestState>(path, {
 			legacy_thread_id: {
 				channelId: "slack:C123",
-				isDM: true,
+				isDM: false,
 				serializedThread: JSON.stringify({
 					id: "legacy_thread_id",
 					channelId: "slack:C123",
-					isDM: true,
+					isDM: false,
 				}),
 				sessionId: "sess-1",
 				state: { sessionId: "sess-1", teamId: "T123" },
@@ -75,7 +74,7 @@ describe("thread binding refresh", () => {
 			createThread({
 				id: "new_thread_id",
 				channelId: "slack:C123",
-				isDM: true,
+				isDM: false,
 			}),
 			"Slack",
 		);
@@ -86,7 +85,7 @@ describe("thread binding refresh", () => {
 		expect(bindings.new_thread_id?.serializedThread).toContain("new_thread_id");
 	});
 
-	it("does not rebind a different thread by participant key", () => {
+	it("refreshes the serialized thread when a participant-key binding matches a new thread id", () => {
 		const path = createBindingsPath();
 		const participantKey = "slack:team:T123:user:U123";
 		writeBindings<TestState>(path, {
@@ -120,69 +119,10 @@ describe("thread binding refresh", () => {
 			participantKey,
 		);
 
-		expect(binding).toBeUndefined();
+		expect(binding?.serializedThread).toContain("new_thread_id");
 		expect(
 			readBindings<TestState>(path)[participantKey]?.serializedThread,
-		).toContain("legacy_thread_id");
-	});
-
-	it("resolves schedule delivery targets by exact binding key before participant metadata", () => {
-		const path = createBindingsPath();
-		writeBindings<TestState>(path, {
-			"slack:C123:111.222": {
-				kind: "conversation",
-				channelId: "slack:C123",
-				isDM: false,
-				participantKey: "slack:team:T123:user:U123",
-				serializedThread: "{}",
-				sessionId: "sess-thread",
-				state: {
-					sessionId: "sess-thread",
-					participantKey: "slack:team:T123:user:U123",
-				},
-				updatedAt: "2026-03-17T00:00:00.000Z",
-			},
-		});
-
-		const match = findBindingForDeliveryTarget<TestState>(
-			readBindings<TestState>(path),
-			{
-				bindingKey: "slack:C123:111.222",
-				threadId: "slack:C123:111.222",
-				participantKey: "slack:team:T123:user:U123",
-			},
-		);
-
-		expect(match?.key).toBe("slack:C123:111.222");
-		expect(match?.binding.sessionId).toBe("sess-thread");
-	});
-
-	it("resolves schedule delivery targets by participant key when no exact thread binding exists", () => {
-		const path = createBindingsPath();
-		writeBindings<TestState>(path, {
-			"slack:team:T123:user:U123": {
-				channelId: "slack:C123",
-				isDM: true,
-				participantKey: "slack:team:T123:user:U123",
-				serializedThread: "{}",
-				sessionId: "sess-participant",
-				state: {
-					sessionId: "sess-participant",
-					participantKey: "slack:team:T123:user:U123",
-				},
-				updatedAt: "2026-03-17T00:00:00.000Z",
-			},
-		});
-
-		const match = findBindingForDeliveryTarget<TestState>(
-			readBindings<TestState>(path),
-			{
-				participantKey: "slack:team:T123:user:U123",
-			},
-		);
-
-		expect(match?.key).toBe("slack:team:T123:user:U123");
-		expect(match?.binding.sessionId).toBe("sess-participant");
+		).toContain("new_thread_id");
 	});
 
 	it("stores mute state at thread scope instead of participant scope", () => {

apps/cli/src/connectors/thread-bindings.ts

@@ -14,7 +14,7 @@ export type ConnectorThreadState = {
 };
 
 export type ConnectorThreadBinding<TState extends ConnectorThreadState> = {
-	kind?: "conversation" | "participant" | "thread" | "thread-participant-mute";
+	kind?: "participant" | "thread" | "thread-participant-mute";
 	channelId: string;
 	isDM: boolean;
 	participantKey?: string;
@@ -134,9 +134,12 @@ function clearSerializedThreadSessionId(serializedThread: string | undefined): {
 
 export function resolveThreadBindingKey(
 	thread: ConnectorBindingThreadIdentity,
-	_state?: ConnectorThreadState | null,
+	state?: ConnectorThreadState | null,
 ): string {
-	return thread.id;
+	return (
+		normalizeParticipantKey(state?.participantKey ?? thread.participantKey) ??
+		thread.id
+	);
 }
 
 export function readBindings<TState extends ConnectorThreadState>(
@@ -157,13 +160,40 @@ export function findBindingForThread<TState extends ConnectorThreadState>(
 	bindings: ConnectorBindingStore<TState>,
 	thread: ConnectorBindingThreadIdentity,
 ): { binding: ConnectorThreadBinding<TState>; key: string } | undefined {
+	const participantKey = normalizeParticipantKey(thread.participantKey);
+	if (participantKey) {
+		const exactThread = bindings[thread.id];
+		const exactThreadParticipantKey = normalizeParticipantKey(
+			exactThread?.participantKey ?? exactThread?.state?.participantKey,
+		);
+		if (
+			exactThread &&
+			!isControlBinding(exactThread) &&
+			exactThreadParticipantKey === participantKey
+		) {
+			return { key: thread.id, binding: exactThread };
+		}
+		const exactParticipant = bindings[participantKey];
+		if (exactParticipant && !isControlBinding(exactParticipant)) {
+			return { key: participantKey, binding: exactParticipant };
+		}
+		for (const [key, binding] of Object.entries(bindings)) {
+			if (isControlBinding(binding)) {
+				continue;
+			}
+			const bindingParticipantKey = normalizeParticipantKey(
+				binding.participantKey ?? binding.state?.participantKey,
+			);
+			if (bindingParticipantKey === participantKey) {
+				return { key, binding };
+			}
+		}
+		return undefined;
+	}
 	const exact = bindings[thread.id];
 	if (exact && !isControlBinding(exact)) {
 		return { key: thread.id, binding: exact };
 	}
-	if (!thread.isDM) {
-		return undefined;
-	}
 	for (const [key, binding] of Object.entries(bindings)) {
 		if (isControlBinding(binding)) {
 			continue;
@@ -252,8 +282,29 @@ export function persistThreadBinding<TState extends ConnectorThreadState>(
 		thread as ConnectorBindingThreadIdentity,
 		state,
 	);
+	for (const [key, binding] of Object.entries(bindings)) {
+		if (isControlBinding(binding)) {
+			continue;
+		}
+		const bindingParticipantKey = normalizeParticipantKey(
+			binding.participantKey ?? binding.state?.participantKey,
+		);
+		const matchesParticipant =
+			participantKey && bindingParticipantKey === participantKey;
+		const matchesLegacyKey = participantKey && key === thread.id;
+		const matchesLegacyThread =
+			!participantKey &&
+			binding.channelId === thread.channelId &&
+			binding.isDM === thread.isDM;
+		if (
+			key !== bindingKey &&
+			(matchesParticipant || matchesLegacyKey || matchesLegacyThread)
+		) {
+			delete bindings[key];
+		}
+	}
 	bindings[bindingKey] = {
-		kind: "conversation",
+		kind: "participant",
 		channelId: thread.channelId,
 		isDM: thread.isDM,
 		participantKey,
@@ -480,37 +531,6 @@ export function findBindingForParticipantKey<
 	return undefined;
 }
 
-export function findBindingForDeliveryTarget<
-	TState extends ConnectorThreadState,
->(
-	bindings: ConnectorBindingStore<TState>,
-	input: {
-		bindingKey?: string;
-		threadId?: string;
-		participantKey?: string;
-	},
-): { binding: ConnectorThreadBinding<TState>; key: string } | undefined {
-	const bindingKey = normalizeParticipantKey(input.bindingKey);
-	if (bindingKey) {
-		const exact = bindings[bindingKey];
-		if (exact && !isControlBinding(exact)) {
-			return { key: bindingKey, binding: exact };
-		}
-		const participantMatch = findBindingForParticipantKey(bindings, bindingKey);
-		if (participantMatch) {
-			return participantMatch;
-		}
-	}
-	const threadId = input.threadId?.trim();
-	if (threadId) {
-		const exact = bindings[threadId];
-		if (exact && !isControlBinding(exact)) {
-			return { key: threadId, binding: exact };
-		}
-	}
-	return findBindingForParticipantKey(bindings, input.participantKey);
-}
-
 export async function persistMergedThreadState<
 	TState extends ConnectorThreadState,
 >(

apps/cli/src/main.test.ts

@@ -29,9 +29,7 @@ const authMocks = vi.hoisted(() => ({
 	runAuthCommand: vi.fn(),
 }));
 const providerSettingsMocks = vi.hoisted(() => ({
-	getLastUsedProviderSettings: vi.fn<(options?: unknown) => unknown>(
-		() => undefined,
-	),
+	getLastUsedProviderSettings: vi.fn<() => unknown>(() => undefined),
 	getProviderConfig: vi.fn<(providerId: string, options?: unknown) => unknown>(
 		() => undefined,
 	),
@@ -84,11 +82,6 @@ const historyMocks = vi.hoisted(() => ({
 	runHistoryExport: vi.fn(async () => 0),
 	runHistoryUpdate: vi.fn(async () => 0),
 }));
-const historyResumeMocks = vi.hoisted(() => ({
-	spawnHistoryResume: vi.fn<() => Promise<number | undefined>>(
-		async () => undefined,
-	),
-}));
 const loggingMocks = vi.hoisted(() => ({
 	createCliLoggerAdapter: vi.fn(() => ({
 		core: {
@@ -108,14 +101,10 @@ const hubRuntimeMocks = vi.hoisted(() => ({
 }));
 const telemetryMocks = vi.hoisted(() => ({
 	captureCliExtensionActivated: vi.fn(),
-	identifyTelemetryAccount: vi.fn(),
+	identifyCliTelemetryAccount: vi.fn(),
 	getCliTelemetryService: vi.fn(),
 	disposeCliTelemetryService: vi.fn(async () => {}),
 }));
-const featureFlagMocks = vi.hoisted(() => ({
-	getBooleanFlagEnabled: vi.fn(() => false),
-	setCliFeatureFlagsAccountContext: vi.fn(),
-}));
 
 function forcePromptModeInput() {
 	Object.defineProperty(process.stdin, "isTTY", {
@@ -159,8 +148,8 @@ vi.mock("@cline/core", () => {
 			stop: vi.fn(),
 		})),
 		ProviderSettingsManager: class {
-			getLastUsedProviderSettings(options?: unknown) {
-				return providerSettingsMocks.getLastUsedProviderSettings(options);
+			getLastUsedProviderSettings() {
+				return providerSettingsMocks.getLastUsedProviderSettings();
 			}
 			getProviderSettings(providerId: string) {
 				return providerSettingsMocks.getProviderSettings(providerId);
@@ -175,14 +164,6 @@ vi.mock("@cline/core", () => {
 	};
 });
 vi.mock("./utils/provider-auth", () => authMocks);
-vi.mock("./utils/feature-flags", () => ({
-	getCliFeatureFlagsService: () => ({
-		getBooleanFlagEnabled: featureFlagMocks.getBooleanFlagEnabled,
-	}),
-	refreshCliFeatureFlagsInBackground: vi.fn(),
-	setCliFeatureFlagsAccountContext:
-		featureFlagMocks.setCliFeatureFlagsAccountContext,
-}));
 vi.mock("./runtime/prompt", () => ({
 	resolveSystemPrompt: promptMocks.resolveSystemPrompt,
 }));
@@ -191,7 +172,6 @@ vi.mock("./commands/dashboard", () => dashboardMocks);
 vi.mock("./kanban-migration/notice", () => migrationNoticeMocks);
 vi.mock("./commands/update", () => updateMocks);
 vi.mock("./commands/history", () => historyMocks);
-vi.mock("./utils/history-resume", () => historyResumeMocks);
 vi.mock("./logging/adapter", () => loggingMocks);
 vi.mock("./utils/hub-runtime", () => hubRuntimeMocks);
 vi.mock("./utils/telemetry", () => telemetryMocks);
@@ -211,8 +191,6 @@ describe("runCli lightweight command dispatch", () => {
 		historyMocks.runHistoryExport.mockResolvedValue(0);
 		historyMocks.runHistoryUpdate.mockReset();
 		historyMocks.runHistoryUpdate.mockResolvedValue(0);
-		historyResumeMocks.spawnHistoryResume.mockReset();
-		historyResumeMocks.spawnHistoryResume.mockResolvedValue(undefined);
 		sessionMocks.getSessionRow.mockReset();
 		sessionMocks.getSessionRow.mockResolvedValue({
 			sessionId: "sess_123",
@@ -255,9 +233,6 @@ describe("runCli lightweight command dispatch", () => {
 		providerSettingsMocks.getProviderSettings.mockReset();
 		providerSettingsMocks.getProviderSettings.mockReturnValue(undefined);
 		providerSettingsMocks.saveProviderSettings.mockReset();
-		featureFlagMocks.getBooleanFlagEnabled.mockReset();
-		featureFlagMocks.getBooleanFlagEnabled.mockReturnValue(false);
-		featureFlagMocks.setCliFeatureFlagsAccountContext.mockReset();
 		kanbanMocks.launchKanban.mockReset();
 		kanbanMocks.launchKanban.mockResolvedValue(0);
 		dashboardMocks.runDashboardCommand.mockReset();
@@ -271,7 +246,7 @@ describe("runCli lightweight command dispatch", () => {
 		updateMocks.getPreferredKanbanInstaller.mockReset();
 		updateMocks.getPreferredKanbanInstaller.mockReturnValue(undefined);
 		telemetryMocks.captureCliExtensionActivated.mockReset();
-		telemetryMocks.identifyTelemetryAccount.mockReset();
+		telemetryMocks.identifyCliTelemetryAccount.mockReset();
 		telemetryMocks.getCliTelemetryService.mockReset();
 		telemetryMocks.disposeCliTelemetryService.mockReset();
 		telemetryMocks.disposeCliTelemetryService.mockResolvedValue(undefined);
@@ -417,61 +392,6 @@ describe("runCli lightweight command dispatch", () => {
 		expect(mockState.runInteractiveImports).toBe(0);
 	});
 
-	it("rejects multiple bare positional prompt tokens", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "hello", "world"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining(
-				"Unknown command or extra arguments: hello world",
-			),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
-		expect(mockState.runAgentImports).toBe(0);
-		expect(mockState.runInteractiveImports).toBe(0);
-	});
-
-	it("runs quoted positional prompt text", async () => {
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "hello world"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"hello world",
-			expect.any(Object),
-			expect.anything(),
-		);
-	});
-
-	it("rejects unknown root flags before loading runtime modules", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--made-up-flag"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining("unknown option '--made-up-flag'"),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
-		expect(mockState.runAgentImports).toBe(0);
-		expect(mockState.runInteractiveImports).toBe(0);
-	});
-
 	it("creates a worktree and runs prompt sessions from it", async () => {
 		forcePromptModeInput();
 		process.argv = ["bun", "src/index.ts", "--worktree", "hello"];
@@ -799,47 +719,10 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});
 
-	it("resumes a history-picked session in a child process", async () => {
+	it("forces chat view when resuming from history picker", async () => {
 		historyMocks.runHistoryList.mockImplementationOnce(
 			async () => "sess_from_history",
 		);
-		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(0);
-		process.argv = ["bun", "src/index.ts", "history"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(historyResumeMocks.spawnHistoryResume).toHaveBeenCalledTimes(1);
-		expect(historyResumeMocks.spawnHistoryResume).toHaveBeenCalledWith(
-			expect.objectContaining({
-				sessionId: "sess_from_history",
-				normalizedArgs: ["history"],
-				remainingArgs: ["history"],
-			}),
-		);
-		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
-		expect(process.exitCode).toBe(0);
-	});
-
-	it("propagates the child exit code when resuming from history picker", async () => {
-		historyMocks.runHistoryList.mockImplementationOnce(
-			async () => "sess_from_history",
-		);
-		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(3);
-		process.argv = ["bun", "src/index.ts", "history"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(3);
-		expect(runtimeMocks.runInteractive).not.toHaveBeenCalled();
-	});
-
-	it("forces chat view when the history-picker child cannot launch", async () => {
-		historyMocks.runHistoryList.mockImplementationOnce(
-			async () => "sess_from_history",
-		);
-		historyResumeMocks.spawnHistoryResume.mockResolvedValueOnce(undefined);
 		process.argv = ["bun", "src/index.ts", "history"];
 
 		const { runCli } = await import("./main");
@@ -918,33 +801,6 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});
 
-	it("seeds feature flag identity from persisted Cline account id before checking flags", async () => {
-		const clineSettings = {
-			provider: "cline",
-			model: "anthropic/claude-sonnet-4.6",
-			auth: {
-				accountId: "acct-startup",
-				accessToken: "workos:token",
-				refreshToken: "refresh-token",
-			},
-		};
-		providerSettingsMocks.getProviderSettings.mockReturnValue(clineSettings);
-		process.argv = ["bun", "src/index.ts"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(
-			featureFlagMocks.setCliFeatureFlagsAccountContext,
-		).toHaveBeenCalledWith({ id: "acct-startup" });
-		expect(
-			featureFlagMocks.setCliFeatureFlagsAccountContext.mock
-				.invocationCallOrder[0],
-		).toBeLessThan(
-			featureFlagMocks.getBooleanFlagEnabled.mock.invocationCallOrder[0],
-		);
-	});
-
 	it("runs kanban before loading runtime modules", async () => {
 		process.argv = ["bun", "src/index.ts", "kanban"];
 
@@ -962,10 +818,6 @@ describe("runCli lightweight command dispatch", () => {
 			"bun",
 			"src/index.ts",
 			"dashboard",
-			"--config",
-			"/tmp/cline-config",
-			"--data-dir",
-			".cline-dashboard-data",
 			"--port",
 			"9090",
 			"--no-open",
@@ -976,8 +828,6 @@ describe("runCli lightweight command dispatch", () => {
 		await expect(runCli()).resolves.toBeUndefined();
 		expect(dashboardMocks.runDashboardCommand).toHaveBeenCalledWith(
 			expect.objectContaining({
-				configDir: "/tmp/cline-config",
-				dataDir: ".cline-dashboard-data",
 				port: "9090",
 				openBrowser: false,
 				io: expect.any(Object),
@@ -1026,7 +876,7 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();
 
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "/team find the bug"];
+		process.argv = ["bun", "src/index.ts", "/team", "find", "the", "bug"];
 
 		const { runCli } = await import("./main");
 

apps/cli/src/main.ts

@@ -19,11 +19,6 @@ import {
 	buildCliCompactionConfig,
 	CLI_COMPACTION_MODE_EXPECTED_TEXT,
 } from "./utils/compaction-mode";
-import {
-	getCliFeatureFlagsService,
-	refreshCliFeatureFlagsInBackground,
-	setCliFeatureFlagsAccountContext,
-} from "./utils/feature-flags";
 import {
 	configureSandboxEnvironment,
 	normalizeAutoApproveArgs,
@@ -140,7 +135,7 @@ export async function runCli(): Promise<void> {
 	// Re-enable built-in help/version output for the routing program
 	program.configureOutput({
 		writeOut: (str: string) => process.stdout.write(str),
-		writeErr: () => {},
+		writeErr: (str: string) => process.stderr.write(str),
 	});
 	// Default action handles non-subcommand args (e.g. prompt text)
 	program.action(() => {});
@@ -157,7 +152,6 @@ export async function runCli(): Promise<void> {
 		.option("-k, --apikey <key>", "API key")
 		.option("-m, --modelid <id>", "Model ID")
 		.option("-b, --baseurl <url>", "Base URL")
-		.option("--azure-api-version <version>", "Azure API version")
 		.option("--config <dir>", "configuration directory")
 		.option("-c, --cwd <path>", "Working directory")
 		.option(
@@ -171,7 +165,6 @@ export async function runCli(): Promise<void> {
 				apikey?: string;
 				modelid?: string;
 				baseurl?: string;
-				azureApiVersion?: string;
 				config?: string;
 				cwd?: string;
 				dataDir?: string;
@@ -202,7 +195,6 @@ export async function runCli(): Promise<void> {
 				apikey: opts.apikey,
 				modelid: opts.modelid,
 				baseurl: opts.baseurl,
-				azureApiVersion: opts.azureApiVersion,
 				io,
 			});
 		});
@@ -292,52 +284,6 @@ export async function runCli(): Promise<void> {
 				io,
 			});
 		});
-	const pluginUninstallCmd = pluginCmd
-		.command("uninstall")
-		.alias("remove")
-		.alias("rm")
-		.description("Uninstall a Cline Plugin by name or path")
-		.argument("<name>", "plugin package name, installed slug, or plugin path")
-		.option("--json", "Output as JSON")
-		.option(
-			"--cwd <path>",
-			"Search <path>/.cline/plugins before global plugins",
-		)
-		.action(async (name: string) => {
-			const opts = pluginUninstallCmd.opts<{
-				json?: boolean;
-				cwd?: string;
-			}>();
-			const { runPluginUninstallCommand } = await import("./commands/plugin");
-			ctx.exitCode = await runPluginUninstallCommand({
-				name,
-				cwd: opts.cwd,
-				json: opts.json === true || program.opts().json === true,
-				io,
-			});
-		});
-	const skillCmd = program
-		.command("skill")
-		.description("Manage Cline Skills via the open skills CLI (npx skills)")
-		.allowUnknownOption()
-		.passThroughOptions()
-		.argument("[args...]", "arguments forwarded to the skills CLI")
-		.addHelpText(
-			"after",
-			"\nForwards to the open skills CLI via npx. Examples:\n" +
-				"  cline skill add <owner/repo>       Add a skill into Cline\n" +
-				"  cline skill install <owner/repo>   Alias for add\n" +
-				"  cline skill list                   List installed skills\n" +
-				"  cline skill remove                 Remove installed skills\n" +
-				"  cline skill uninstall              Alias for remove\n" +
-				"\nadd/install and remove/uninstall default to '--agent cline' unless you pass your own --agent.\n" +
-				"Run 'npx skills --help' for the full command reference.",
-		)
-		.action(async () => {
-			const { runSkillCommand } = await import("./commands/skill");
-			ctx.exitCode = await runSkillCommand(skillCmd.args, io);
-		});
-
 	const connectCmd = program
 		.command("connect")
 		.description("Connect to an external channel")
@@ -379,7 +325,7 @@ export async function runCli(): Promise<void> {
 			}
 		});
 
-	const mcpCmd = program
+	program
 		.command("mcp")
 		.description("Manage MCP servers")
 		.action(async () => {
@@ -391,31 +337,6 @@ export async function runCli(): Promise<void> {
 				);
 			}
 		});
-	const mcpInstallCmd = mcpCmd
-		.command("install")
-		.alias("add")
-		.description("Open the MCP add wizard with server fields prefilled")
-		.argument("<name>", "MCP server name")
-		.argument(
-			"[targetArgs...]",
-			"URL for remote transports, or command and args after -- for stdio",
-		)
-		.option(
-			"--transport <transport>",
-			"stdio, sse, http, streamable-http, or streamableHttp (default: stdio)",
-		)
-		.action(async (name: string, targetArgs: string[]) => {
-			const opts = mcpInstallCmd.opts<{
-				transport?: string;
-			}>();
-			const { runMcpInstallCommand } = await import("./commands/mcp");
-			ctx.exitCode = await runMcpInstallCommand({
-				name,
-				targetArgs,
-				transport: opts.transport,
-				io,
-			});
-		});
 
 	const createDoctorRuntimeCommand = async () => {
 		const { createDoctorCommand } = await import("./commands/doctor");
@@ -596,12 +517,7 @@ export async function runCli(): Promise<void> {
 	const dashboardCmd = program
 		.command("dashboard")
 		.description("Start the Cline Hub dashboard and open it in a browser")
-		.option("--config <dir>", "configuration directory")
 		.option("-c, --cwd <path>", "Workspace root", process.cwd())
-		.option(
-			"--data-dir <dir>",
-			"Use isolated local state at <dir> instead of ~/.cline (enables sandbox mode)",
-		)
 		.option("--host <host>", "Dashboard bind host")
 		.option("--port <port>", "Dashboard HTTP/WebSocket port")
 		.option("--public-url <url>", "Public dashboard URL")
@@ -609,9 +525,7 @@ export async function runCli(): Promise<void> {
 		.option("--no-open", "Start the dashboard without opening a browser")
 		.action(async () => {
 			const opts = dashboardCmd.opts<{
-				config?: string;
 				cwd?: string;
-				dataDir?: string;
 				host?: string;
 				port?: string;
 				publicUrl?: string;
@@ -620,9 +534,7 @@ export async function runCli(): Promise<void> {
 			}>();
 			const { runDashboardCommand } = await import("./commands/dashboard");
 			ctx.exitCode = await runDashboardCommand({
-				configDir: opts.config,
 				cwd: opts.cwd,
-				dataDir: opts.dataDir,
 				host: opts.host,
 				port: opts.port,
 				publicUrl: opts.publicUrl,
@@ -671,7 +583,6 @@ export async function runCli(): Promise<void> {
 		if (err instanceof CommanderError) {
 			if (err.exitCode !== 0) {
 				writeErr(err.message);
-				process.exitCode = err.exitCode;
 				return;
 			}
 			return;
@@ -722,31 +633,9 @@ export async function runCli(): Promise<void> {
 
 	// Default flow: no subcommand matched, or fall-through from config/history.
 	let args = commanderToParsedArgs(program);
-	if (program.args.length > 1) {
-		writeErr(
-			`Unknown command or extra arguments: ${program.args.join(" ")}\nPrompt text with spaces must be quoted as a single argument, for example: cline "fix the tests". Use "cline --help" to see available commands and flags.`,
-		);
-		process.exitCode = 1;
-		return;
-	}
 
 	let resumeSessionId: string | undefined = ctx.resumeSessionId;
 	if (resumeSessionId) {
-		// The history picker already created (and tore down) an OpenTUI renderer
-		// in this process; starting the interactive TUI here would create a
-		// second one, which can crash natively during teardown. Resume in a
-		// fresh `cline --id <session-id>` child process instead.
-		const { spawnHistoryResume } = await import("./utils/history-resume");
-		const childExitCode = await spawnHistoryResume({
-			sessionId: resumeSessionId,
-			normalizedArgs,
-			remainingArgs: program.args,
-			configDir,
-		});
-		if (childExitCode !== undefined) {
-			process.exitCode = childExitCode;
-			return;
-		}
 		args = {
 			...args,
 			interactive: true,
@@ -920,18 +809,8 @@ export async function runCli(): Promise<void> {
 	};
 	registerDisposable(stopUserInstructionService);
 	try {
-		const persistedClineAccountId = providerSettingsManager
-			.getProviderSettings("cline")
-			?.auth?.accountId?.trim();
-		if (persistedClineAccountId) {
-			setCliFeatureFlagsAccountContext({ id: persistedClineAccountId });
-		}
-		refreshCliFeatureFlagsInBackground();
 		const lastUsedProviderSettings =
-			providerSettingsManager.getLastUsedProviderSettings({
-				isClinePassEnabled:
-					getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
-			});
+			providerSettingsManager.getLastUsedProviderSettings();
 		const provider = normalizeProviderId(
 			args.provider?.trim() || lastUsedProviderSettings?.provider || "cline",
 		);

apps/cli/src/runtime/interactive/approvals.test.ts

@@ -61,20 +61,6 @@ describe("createInteractiveApprovalController", () => {
 		).resolves.toEqual({ approved: false, reason: "no" });
 	});
 
-	it("approves stale required-approval requests after auto-approve is enabled", async () => {
-		const controller = createInteractiveApprovalController(makeConfig(false));
-		controller.tuiToolApprover.current = async () => ({
-			approved: false,
-			reason: "stale prompt",
-		});
-
-		controller.setInteractiveAutoApprove(true);
-
-		await expect(
-			controller.requestToolApproval(makeRequest({ autoApprove: false })),
-		).resolves.toEqual({ approved: true });
-	});
-
 	it("denies approval-required requests when no TUI approver is available", async () => {
 		const controller = createInteractiveApprovalController(makeConfig(false));
 
@@ -91,7 +77,6 @@ describe("createInteractiveApprovalController", () => {
 
 		expect(controller.autoApproveAllRef.current).toBe(true);
 		expect(config.defaultToolAutoApprove).toBe(false);
-		expect(config.toolPolicies["*"]?.autoApprove).toBe(true);
-		expect(controller.resolveToolPolicy("run_commands").autoApprove).toBe(true);
+		expect(config.toolPolicies["*"]?.autoApprove).toBe(false);
 	});
 });

apps/cli/src/runtime/interactive/approvals.ts

@@ -3,7 +3,6 @@ import type { Config } from "../../utils/types";
 import {
 	applyInteractiveAutoApproveOverride,
 	cloneToolPolicies,
-	resolveInteractiveAutoApprovePolicy,
 } from "../tool-policies";
 
 export interface InteractiveRuntimeRefs {
@@ -39,10 +38,10 @@ export function createInteractiveApprovalController(config: Config) {
 	const requestToolApproval = async (
 		request: ToolApprovalRequest,
 	): Promise<ToolApprovalResult> => {
-		if (autoApproveAllRef.current) {
+		if (request.policy?.autoApprove === true) {
 			return { approved: true };
 		}
-		if (request.policy?.autoApprove === true) {
+		if (autoApproveAllRef.current && request.policy?.autoApprove !== false) {
 			return { approved: true };
 		}
 		if (refs.tuiToolApprover.current) {
@@ -55,12 +54,6 @@ export function createInteractiveApprovalController(config: Config) {
 		autoApproveAllRef,
 		setInteractiveAutoApprove,
 		requestToolApproval,
-		resolveToolPolicy: (toolName: string) =>
-			resolveInteractiveAutoApprovePolicy({
-				toolName,
-				baselinePolicies: baselineToolPolicies,
-				enabled: autoApproveAllRef.current,
-			}),
 		...refs,
 	};
 }

apps/cli/src/runtime/interactive/chat-command-runner.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, it, vi } from "vitest";
 import {
 	type ChatCommandState,
 	chatCommandHost,
-	createChatCommandHost,
 } from "../../utils/chat-commands";
 import type { Config } from "../../utils/types";
 import {
@@ -163,37 +162,4 @@ describe("runInteractiveChatCommand", () => {
 		expect(state.autoApproveTools).toBe(true);
 		expect(setInteractiveAutoApprove).toHaveBeenCalledWith(true);
 	});
-
-	it("returns plugin command submit prompts as model input", async () => {
-		const config = makeConfig();
-		const runtime = makeRuntime();
-		const onCommandOutput = vi.fn();
-		const host = createChatCommandHost().register("command", {
-			names: ["/goal"],
-			run: async ({ args }, context) => {
-				await context.reply(`Goal guard set: ${args.join(" ")}`);
-				await context.submitPrompt?.(args.join(" "));
-			},
-		});
-
-		const result = await runInteractiveChatCommand({
-			prompt: "/goal fix tests",
-			enabled: true,
-			config,
-			host,
-			chatCommandState: makeState(config),
-			autoApproveAllRef: { current: false },
-			setInteractiveAutoApprove: () => {},
-			sessionRuntime: runtime,
-			stop: () => {},
-			onCommandOutput,
-		});
-
-		expect(result).toEqual({
-			handled: false,
-			input: "fix tests",
-			commandOutput: "Goal guard set: fix tests",
-		});
-		expect(onCommandOutput).toHaveBeenCalledWith("Goal guard set: fix tests");
-	});
 });

apps/cli/src/runtime/interactive/chat-command-runner.ts

@@ -26,7 +26,7 @@ export type InteractiveChatCommandRuntime = Pick<
 
 export type InteractiveChatCommandResult =
 	| { handled: true; turnResult: InteractiveTurnResult }
-	| { handled: false; input: string; commandOutput?: string };
+	| { handled: false; input: string };
 
 function commandTurnResult(commandOutput?: string): InteractiveTurnResult {
 	return {
@@ -46,7 +46,6 @@ export async function runInteractiveChatCommand(input: {
 	setInteractiveAutoApprove: (enabled: boolean) => void;
 	sessionRuntime: InteractiveChatCommandRuntime;
 	stop: () => void;
-	onCommandOutput?: (text: string) => void;
 }): Promise<InteractiveChatCommandResult> {
 	let prompt = input.prompt;
 	const rewrittenTeamPrompt = rewriteTeamPrompt(prompt);
@@ -65,7 +64,6 @@ export async function runInteractiveChatCommand(input: {
 	}
 
 	let commandOutput: string | undefined;
-	let submitPrompt: string | undefined;
 	const handled = await maybeHandleChatCommand(prompt, {
 		enabled: input.enabled,
 		host: input.host,
@@ -82,13 +80,6 @@ export async function runInteractiveChatCommand(input: {
 		},
 		reply: async (text) => {
 			commandOutput = text;
-			input.onCommandOutput?.(text);
-		},
-		submitPrompt: async (text) => {
-			const trimmed = text.trim();
-			if (trimmed) {
-				submitPrompt = trimmed;
-			}
 		},
 		reset: async () => {
 			await input.sessionRuntime.resetForNewSession();
@@ -107,13 +98,6 @@ export async function runInteractiveChatCommand(input: {
 		fork: input.sessionRuntime.forkCurrentSession,
 	});
 	if (handled) {
-		if (submitPrompt) {
-			return {
-				handled: false,
-				input: submitPrompt,
-				...(commandOutput ? { commandOutput } : {}),
-			};
-		}
 		return {
 			handled: true,
 			turnResult: commandTurnResult(commandOutput),

apps/cli/src/runtime/interactive/config-data.test.ts

@@ -1,11 +1,4 @@
-import {
-	chmod,
-	mkdir,
-	mkdtemp,
-	readFile,
-	rm,
-	writeFile,
-} from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { UserInstructionConfigService } from "@cline/core";
@@ -50,17 +43,9 @@ describe("interactive config data loader", () => {
 	};
 
 	afterEach(async () => {
-		if (envSnapshot.CLINE_GLOBAL_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_GLOBAL_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_GLOBAL_SETTINGS_PATH =
-				envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
-		}
-		if (envSnapshot.CLINE_MCP_SETTINGS_PATH === undefined) {
-			delete process.env.CLINE_MCP_SETTINGS_PATH;
-		} else {
-			process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
-		}
+		process.env.CLINE_GLOBAL_SETTINGS_PATH =
+			envSnapshot.CLINE_GLOBAL_SETTINGS_PATH;
+		process.env.CLINE_MCP_SETTINGS_PATH = envSnapshot.CLINE_MCP_SETTINGS_PATH;
 		await Promise.all(
 			tempRoots.map((dir) => rm(dir, { recursive: true, force: true })),
 		);
@@ -91,28 +76,6 @@ describe("interactive config data loader", () => {
 		return pluginPath;
 	}
 
-	async function writeMcpSettingsPlugin(tempRoot: string): Promise<string> {
-		const pluginsDir = join(tempRoot, ".cline", "plugins");
-		await mkdir(pluginsDir, { recursive: true });
-		const pluginPath = join(pluginsDir, "settings-mcp-plugin.js");
-		await writeFile(
-			pluginPath,
-			[
-				"export default {",
-				"  name: 'settings-mcp-plugin',",
-				"  manifest: { capabilities: ['mcp'] },",
-				"  setup(api) {",
-				"    api.registerMcpServer({",
-				"      name: 'smoke',",
-				"      transport: { type: 'stdio', command: process.execPath, args: ['-e', 'process.exit(0)'] },",
-				"    });",
-				"  },",
-				"};",
-			].join("\n"),
-		);
-		return pluginPath;
-	}
-
 	it("toggles a skill item to the opposite enabled state and refreshes before reload", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);
@@ -348,70 +311,6 @@ Find installable skills.`,
 		).toBe(true);
 	});
 
-	it("loads plugin-owned MCP servers from settings", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		await writeFile(
-			settingsPath,
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						smoke: {
-							transport: {
-								type: "stdio",
-								command: process.execPath,
-								args: ["-e", "process.exit(0)"],
-							},
-							metadata: {
-								source: "plugin",
-								pluginName: "settings-mcp-plugin",
-								pluginPath,
-							},
-						},
-					},
-				},
-				null,
-				2,
-			)}\n`,
-		);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-
-		const data = await loader.loadConfigData({ includePluginTools: true });
-
-		expect(
-			data.mcp.some(
-				(item) =>
-					item.name === "smoke" &&
-					item.pluginName === "settings-mcp-plugin" &&
-					item.pluginPath === pluginPath &&
-					item.kind === "mcp",
-			),
-		).toBe(true);
-	});
-
-	it("does not load plugin MCP rows directly from plugin diagnostics", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
-			tempRoot,
-			"global-settings.json",
-		);
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-
-		const data = await loader.loadConfigData({ includePluginTools: true });
-
-		expect(data.plugins.some((item) => item.path === pluginPath)).toBe(true);
-		expect(data.mcp.some((item) => item.pluginPath === pluginPath)).toBe(false);
-	});
-
 	it("keeps failed plugins visible with their load error", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);
@@ -556,112 +455,6 @@ Find installable skills.`,
 		).toBe(true);
 	});
 
-	it("deletes a package-backed plugin and refreshes bundled slash commands", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
-			tempRoot,
-			"global-settings.json",
-		);
-		const packageDir = join(tempRoot, ".cline", "plugins", "delete-plugin");
-		const pluginPath = join(packageDir, "index.ts");
-		const skillPath = join(packageDir, "skills", "erase", "SKILL.md");
-		await mkdir(join(packageDir, "skills", "erase"), { recursive: true });
-		await writeFile(
-			join(packageDir, "package.json"),
-			JSON.stringify(
-				{
-					name: "delete-plugin",
-					cline: {
-						plugins: [{ paths: ["./index.ts"] }],
-					},
-				},
-				null,
-				2,
-			),
-		);
-		await writeFile(pluginPath, "export default {};\n");
-		await writeFile(
-			skillPath,
-			`---
-name: erase
----
-Erase stale plugin commands.`,
-		);
-		await writeFile(
-			process.env.CLINE_GLOBAL_SETTINGS_PATH,
-			JSON.stringify({ disabledPlugins: [pluginPath] }, null, 2),
-		);
-		const refreshCalls: string[] = [];
-		let refreshed = false;
-		const userInstructionService = {
-			async refreshType(type: string) {
-				refreshCalls.push(type);
-				refreshed = true;
-			},
-			listRuntimeCommands() {
-				return refreshed
-					? []
-					: [
-							{
-								name: "erase",
-								instructions: "Erase stale plugin commands.",
-								description: "Erase",
-								kind: "skill",
-							},
-						];
-			},
-			listRecords(type: string) {
-				if (type !== "skill") {
-					return [];
-				}
-				return [
-					{
-						id: "erase",
-						type: "skill",
-						filePath: skillPath,
-						item: {
-							name: "erase",
-							disabled: false,
-							description: "Erase",
-							instructions: "Erase stale plugin commands.",
-							frontmatter: {},
-						},
-					},
-				];
-			},
-		} as unknown as UserInstructionConfigService;
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-			userInstructionService,
-		});
-		const data = await loader.loadConfigData({ includePluginTools: false });
-		const plugin = data.plugins.find((item) => item.path === pluginPath);
-		if (!plugin) {
-			throw new Error("Expected package plugin to be listed");
-		}
-
-		const nextData = await loader.onDeleteConfigItem(plugin, {
-			includePluginTools: false,
-		});
-		const settings = JSON.parse(
-			await readFile(process.env.CLINE_GLOBAL_SETTINGS_PATH, "utf8"),
-		) as { disabledPlugins?: string[] };
-
-		await expect(readFile(pluginPath, "utf8")).rejects.toThrow();
-		await expect(readFile(skillPath, "utf8")).rejects.toThrow();
-		expect(settings.disabledPlugins).toBeUndefined();
-		expect(refreshCalls).toEqual(
-			expect.arrayContaining(["workflow", "rule", "skill"]),
-		);
-		expect(nextData?.plugins.some((item) => item.path === pluginPath)).toBe(
-			false,
-		);
-		expect(
-			nextData?.workflowSlashCommands.map((command) => command.name),
-		).not.toContain("erase");
-	});
-
 	it("uses the package name for package-backed plugin entries", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);
@@ -832,142 +625,6 @@ Review with the bundled skill.`,
 		).toBe(false);
 	});
 
-	it("disables and re-syncs plugin-owned MCP servers when toggling plugins", async () => {
-		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-		tempRoots.push(tempRoot);
-		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-		process.env.CLINE_GLOBAL_SETTINGS_PATH = join(
-			tempRoot,
-			"global-settings.json",
-		);
-		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-		const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-		await writeFile(
-			settingsPath,
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						smoke: {
-							transport: {
-								type: "stdio",
-								command: process.execPath,
-								args: ["-e", "process.exit(0)"],
-							},
-							oauth: {
-								tokens: {
-									access_token: "token",
-								},
-							},
-							metadata: {
-								source: "plugin",
-								pluginName: "settings-mcp-plugin",
-								pluginPath,
-							},
-						},
-					},
-				},
-				null,
-				2,
-			)}\n`,
-		);
-		const loader = createInteractiveConfigDataLoader({
-			config: createConfig(tempRoot),
-		});
-		const item: InteractiveConfigItem = {
-			id: pluginPath,
-			name: "settings-mcp-plugin",
-			path: pluginPath,
-			enabled: true,
-			source: "workspace-plugin",
-			kind: "plugin",
-		};
-
-		await loader.onToggleConfigItem(item);
-		let settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<
-				string,
-				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
-			>;
-		};
-		expect(settings.mcpServers?.smoke?.disabled).toBe(true);
-		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
-			"token",
-		);
-
-		await loader.onToggleConfigItem({ ...item, enabled: false });
-		settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-			mcpServers?: Record<
-				string,
-				{ disabled?: boolean; oauth?: { tokens?: Record<string, string> } }
-			>;
-		};
-		expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
-		expect(settings.mcpServers?.smoke?.oauth?.tokens?.access_token).toBe(
-			"token",
-		);
-	});
-
-	it.skipIf(process.platform === "win32")(
-		"does not mark plugin disabled when MCP disable write fails",
-		async () => {
-			const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
-			tempRoots.push(tempRoot);
-			const settingsPath = join(tempRoot, "cline_mcp_settings.json");
-			const globalSettingsPath = join(tempRoot, "global-settings.json");
-			process.env.CLINE_GLOBAL_SETTINGS_PATH = globalSettingsPath;
-			process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
-			const pluginPath = await writeMcpSettingsPlugin(tempRoot);
-			await writeFile(
-				settingsPath,
-				`${JSON.stringify(
-					{
-						mcpServers: {
-							smoke: {
-								transport: {
-									type: "stdio",
-									command: process.execPath,
-									args: ["-e", "process.exit(0)"],
-								},
-								metadata: {
-									source: "plugin",
-									pluginName: "settings-mcp-plugin",
-									pluginPath,
-								},
-							},
-						},
-					},
-					null,
-					2,
-				)}\n`,
-			);
-			await chmod(settingsPath, 0o444);
-			const loader = createInteractiveConfigDataLoader({
-				config: createConfig(tempRoot),
-			});
-
-			try {
-				await expect(
-					loader.onToggleConfigItem({
-						id: pluginPath,
-						name: "settings-mcp-plugin",
-						path: pluginPath,
-						enabled: true,
-						source: "workspace-plugin",
-						kind: "plugin",
-					}),
-				).rejects.toThrow();
-			} finally {
-				await chmod(settingsPath, 0o644);
-			}
-
-			await expect(readFile(globalSettingsPath, "utf8")).rejects.toThrow();
-			const settings = JSON.parse(await readFile(settingsPath, "utf8")) as {
-				mcpServers?: Record<string, { disabled?: boolean }>;
-			};
-			expect(settings.mcpServers?.smoke?.disabled).toBeUndefined();
-		},
-	);
-
 	it("surfaces MCP OAuth status and errors", async () => {
 		const tempRoot = await mkdtemp(join(tmpdir(), "cli-config-data-"));
 		tempRoots.push(tempRoot);

apps/cli/src/runtime/interactive/config-data.ts

@@ -1,11 +1,8 @@
 import {
 	createCoreSettingsService,
-	disablePluginMcpServersInSettings,
 	setDisabledPlugin,
 	setDisabledTools,
-	syncPluginMcpServersToSettings,
 	type UserInstructionConfigService,
-	uninstallPlugin,
 } from "@cline/core";
 import {
 	type InteractiveConfigData,
@@ -39,18 +36,6 @@ export function createInteractiveConfigDataLoader(input: {
 			includePluginTools: options.includePluginTools,
 		});
 
-	const refreshUserInstructionConfigs = async (): Promise<void> => {
-		const service = input.userInstructionService;
-		if (!service) {
-			return;
-		}
-		await Promise.all([
-			service.refreshType("workflow"),
-			service.refreshType("rule"),
-			service.refreshType("skill"),
-		]);
-	};
-
 	const onToggleConfigItem = async (
 		item: InteractiveConfigItem,
 		options: LoadInteractiveConfigDataOptions = {},
@@ -72,32 +57,7 @@ export function createInteractiveConfigDataLoader(input: {
 		}
 
 		if (item.kind === "plugin" && typeof item.enabled === "boolean") {
-			if (item.enabled) {
-				disablePluginMcpServersInSettings({ pluginPaths: [item.path] });
-				setDisabledPlugin(item.path, true);
-			} else {
-				const ownedMcpMutations = disablePluginMcpServersInSettings({
-					pluginPaths: [item.path],
-				});
-				const result = await syncPluginMcpServersToSettings({
-					pluginPaths: [item.path],
-					cwd: input.config.cwd,
-					workspacePath: workspaceRoot(),
-					providerId: input.config.providerId,
-					modelId: input.config.modelId,
-				});
-				if (ownedMcpMutations.length > 0 && result.failures.length > 0) {
-					throw new Error(
-						`Failed to sync plugin MCP servers: ${result.failures
-							.map((failure) => {
-								const plugin = failure.pluginName ?? failure.pluginPath;
-								return `${plugin}: ${failure.message}`;
-							})
-							.join("; ")}`,
-					);
-				}
-				setDisabledPlugin(item.path, false);
-			}
+			setDisabledPlugin(item.path, item.enabled);
 			return undefined;
 		}
 
@@ -146,26 +106,8 @@ export function createInteractiveConfigDataLoader(input: {
 		return undefined;
 	};
 
-	const onDeleteConfigItem = async (
-		item: InteractiveConfigItem,
-		options: LoadInteractiveConfigDataOptions = {},
-	): Promise<InteractiveConfigData | undefined> => {
-		if (item.kind !== "plugin") {
-			return undefined;
-		}
-		await uninstallPlugin({
-			path: item.path,
-			name: item.name,
-			cwd: input.config.cwd,
-			workspaceRoot: workspaceRoot(),
-		});
-		await refreshUserInstructionConfigs();
-		return await loadConfigData(options);
-	};
-
 	return {
 		loadConfigData,
 		onToggleConfigItem,
-		onDeleteConfigItem,
 	};
 }

apps/cli/src/runtime/interactive/session-runtime.test.ts

@@ -5,8 +5,7 @@ import type {
 	ToolApprovalRequest,
 	ToolApprovalResult,
 } from "@cline/core";
-import { SessionNotFoundError } from "@cline/core";
-import type { AgentTool, Message } from "@cline/shared";
+import type { AgentTool } from "@cline/shared";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { ChatCommandState } from "../../utils/chat-commands";
 import type { Config } from "../../utils/types";
@@ -113,7 +112,7 @@ function makeManager() {
 		abort: vi.fn(),
 		dispose: vi.fn(),
 		get: vi.fn(),
-		readMessages: vi.fn(async (): Promise<Message[]> => []),
+		readMessages: vi.fn(async () => []),
 		readTranscript: vi.fn(),
 		ingestHookEvent: vi.fn(),
 		subscribe: vi.fn(),
@@ -125,37 +124,9 @@ function makeManager() {
 	};
 }
 
-function makeTurnResult() {
-	return {
-		text: "ok",
-		usage: { inputTokens: 0, outputTokens: 0 },
-		messages: [],
-		toolCalls: [],
-		iterations: 1,
-		finishReason: "completed" as const,
-		model: { id: "openai/gpt-5.3-codex", provider: "cline" },
-		startedAt: new Date("2026-01-01T00:00:00.000Z"),
-		endedAt: new Date("2026-01-01T00:00:00.100Z"),
-		durationMs: 100,
-	};
-}
-
-function deferred<T>() {
-	let resolve!: (value: T) => void;
-	let reject!: (error?: unknown) => void;
-	const promise = new Promise<T>((resolvePromise, rejectPromise) => {
-		resolve = resolvePromise;
-		reject = rejectPromise;
-	});
-	return { promise, resolve, reject };
-}
-
 function makeRuntime(
 	manager: ReturnType<typeof makeManager>,
-	options: {
-		resumeSessionId?: string;
-		resolveToolPolicy?: (toolName: string) => Config["toolPolicies"][string];
-	} = {},
+	options: { resumeSessionId?: string } = {},
 ) {
 	mockCreateCliCore.mockResolvedValue(manager);
 	const config = makeConfig();
@@ -167,8 +138,6 @@ function makeRuntime(
 		requestToolApproval: async (
 			_request: ToolApprovalRequest,
 		): Promise<ToolApprovalResult> => ({ approved: true }),
-		resolveToolPolicy:
-			options.resolveToolPolicy ?? (() => ({ autoApprove: true })),
 		askQuestionRef: { current: null },
 		resolveMistakeLimitDecision: undefined,
 		switchToActModeTool: makeSwitchToActModeTool(),
@@ -210,68 +179,6 @@ describe("createInteractiveSessionRuntime", () => {
 		expect(runtime.getActiveSessionId()).toBe("session-2");
 	});
 
-	it("adds a live interactive approval policy hook to started sessions", async () => {
-		const manager = makeManager();
-		const upstreamBeforeTool = vi.fn(async () => ({
-			input: { text: "updated" },
-		}));
-		mockCreateRuntimeHooks.mockReturnValueOnce({
-			hooks: {
-				beforeTool: upstreamBeforeTool,
-			},
-			shutdown: vi.fn(async () => {}),
-		});
-		const runtime = makeRuntime(manager, {
-			resolveToolPolicy: (toolName) => ({
-				autoApprove: toolName === "echo",
-			}),
-		});
-
-		await runtime.ensureReady();
-
-		const startInput = manager.start.mock.calls[0]?.[0] as
-			| { config?: Config }
-			| undefined;
-		const beforeTool = startInput?.config?.hooks?.beforeTool;
-		expect(beforeTool).toBeTypeOf("function");
-
-		const result = await beforeTool?.({
-			snapshot: {
-				agentId: "agent-1",
-				conversationId: "conversation-1",
-				status: "running",
-				iteration: 1,
-				messages: [],
-				pendingToolCalls: [],
-				usage: {
-					inputTokens: 0,
-					outputTokens: 0,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-				},
-			},
-			tool: {
-				name: "echo",
-				description: "",
-				inputSchema: {},
-				execute: async () => "ok",
-			},
-			toolCall: {
-				type: "tool-call",
-				toolCallId: "call-1",
-				toolName: "echo",
-				input: { text: "original" },
-			},
-			input: { text: "original" },
-		});
-
-		expect(upstreamBeforeTool).toHaveBeenCalledOnce();
-		expect(result).toEqual({
-			input: { text: "updated" },
-			policy: { autoApprove: true },
-		});
-	});
-
 	it("starts fresh after resetting an initially resumed session", async () => {
 		const manager = makeManager();
 		const runtime = makeRuntime(manager, {
@@ -324,84 +231,4 @@ describe("createInteractiveSessionRuntime", () => {
 		expect(manager.start).toHaveBeenCalledTimes(2);
 		expect(runtime.getActiveSessionId()).toBe("session-2");
 	});
-
-	it("recovers and retries when the active interactive session disappeared", async () => {
-		const manager = makeManager();
-		const messages = [
-			{
-				role: "user" as const,
-				content: [{ type: "text" as const, text: "hi" }],
-			},
-		];
-		manager.readMessages.mockResolvedValue(messages);
-		manager.send
-			.mockRejectedValueOnce(new SessionNotFoundError("session-1"))
-			.mockResolvedValueOnce(makeTurnResult());
-		const runtime = makeRuntime(manager);
-
-		await runtime.ensureReady();
-		const result = await runtime.sendCurrentTurn({
-			prompt: "second hi",
-			mode: "act",
-		});
-
-		expect(result?.finishReason).toBe("completed");
-		expect(manager.readMessages).toHaveBeenCalledWith("session-1");
-		expect(manager.start).toHaveBeenCalledTimes(2);
-		expect(manager.start).toHaveBeenNthCalledWith(
-			2,
-			expect.objectContaining({
-				initialMessages: messages,
-			}),
-		);
-		expect(manager.send).toHaveBeenNthCalledWith(
-			1,
-			expect.objectContaining({ sessionId: "session-1" }),
-		);
-		expect(manager.send).toHaveBeenNthCalledWith(
-			2,
-			expect.objectContaining({ sessionId: "session-2" }),
-		);
-		expect(runtime.getActiveSessionId()).toBe("session-2");
-	});
-
-	it("waits for missing-session recovery before cleanup disposes the manager", async () => {
-		const manager = makeManager();
-		const recoveryRead = deferred<Message[]>();
-		manager.readMessages
-			.mockImplementationOnce(() => recoveryRead.promise)
-			.mockResolvedValue([]);
-		manager.get.mockResolvedValue(undefined);
-		manager.getAccumulatedUsage.mockResolvedValue(undefined);
-		manager.send.mockRejectedValueOnce(new SessionNotFoundError("session-1"));
-		const runtime = makeRuntime(manager);
-
-		await runtime.ensureReady();
-		const sendPromise = runtime
-			.sendCurrentTurn({
-				prompt: "second hi",
-				mode: "act",
-			})
-			.catch((error) => error);
-		await vi.waitFor(() => {
-			expect(manager.readMessages).toHaveBeenCalledWith("session-1");
-		});
-
-		let cleanupSettled = false;
-		const cleanupPromise = runtime.cleanup().finally(() => {
-			cleanupSettled = true;
-		});
-		await new Promise((resolve) => setTimeout(resolve, 0));
-
-		expect(cleanupSettled).toBe(false);
-		expect(manager.get).not.toHaveBeenCalled();
-		expect(manager.dispose).not.toHaveBeenCalled();
-
-		recoveryRead.resolve([]);
-		await cleanupPromise;
-		const sendError = await sendPromise;
-
-		expect(sendError).toBeInstanceOf(SessionNotFoundError);
-		expect(manager.dispose).toHaveBeenCalledWith("cli_interactive_shutdown");
-	});
 });

apps/cli/src/runtime/interactive/session-runtime.ts

@@ -1,8 +1,6 @@
 import {
 	type AgentEvent,
-	type AgentHooks,
 	type CheckpointEntry,
-	isSessionNotFoundError,
 	type PendingPromptMutationResult,
 	type ProviderSettingsManager,
 	readSessionCheckpointHistory,
@@ -49,32 +47,6 @@ type CurrentTurnResult = Awaited<ReturnType<CliCore["send"]>>;
 type AskQuestionRef = {
 	current: ((question: string, options: string[]) => Promise<string>) | null;
 };
-type ToolPolicyResolver = (
-	toolName: string,
-) => NonNullable<Config["toolPolicies"]>[string];
-
-function withInteractiveApprovalPolicyHook(
-	hooks: AgentHooks | undefined,
-	resolveToolPolicy: ToolPolicyResolver,
-): AgentHooks {
-	return {
-		...hooks,
-		beforeTool: async (ctx) => {
-			const result = await hooks?.beforeTool?.(ctx);
-			if (result?.stop || result?.skip) {
-				return result;
-			}
-			const policy = resolveToolPolicy(ctx.toolCall.toolName);
-			return {
-				...result,
-				policy: {
-					...result?.policy,
-					autoApprove: policy.autoApprove,
-				},
-			};
-		},
-	};
-}
 
 export function createInteractiveSessionRuntime(input: {
 	config: Config;
@@ -85,7 +57,6 @@ export function createInteractiveSessionRuntime(input: {
 	requestToolApproval: (
 		request: ToolApprovalRequest,
 	) => Promise<ToolApprovalResult>;
-	resolveToolPolicy: ToolPolicyResolver;
 	askQuestionRef: AskQuestionRef;
 	resolveMistakeLimitDecision: Config["onConsecutiveMistakeLimitReached"];
 	switchToActModeTool: NonNullable<Config["extraTools"]>[number];
@@ -103,7 +74,6 @@ export function createInteractiveSessionRuntime(input: {
 	let shutdownRequested = false;
 	let activeSessionId = "";
 	let abortRequested = false;
-	let missingSessionRecoveryPromise: Promise<void> | undefined;
 	// A reset can happen while an earlier manager.start() is still in flight.
 	// Bump this before resets and restarts so stale starts cannot become active.
 	let sessionStartGeneration = 0;
@@ -180,14 +150,10 @@ export function createInteractiveSessionRuntime(input: {
 		if (!runtimeHooks) {
 			throw new Error("interactive runtime hooks are unavailable");
 		}
-		const hooks = withInteractiveApprovalPolicyHook(
-			runtimeHooks.hooks,
-			input.resolveToolPolicy,
-		);
 		return buildInteractiveSessionConfig({
 			config: input.config,
 			chatCommandState: input.chatCommandState,
-			runtimeHooks: { hooks },
+			runtimeHooks,
 			onTeamEvent: input.onTeamEvent,
 			resolveMistakeLimitDecision: input.resolveMistakeLimitDecision,
 		});
@@ -282,37 +248,6 @@ export function createInteractiveSessionRuntime(input: {
 		return (await sessionManager.readMessages(activeSessionId)) ?? [];
 	};
 
-	const recoverMissingActiveSession = async (error: unknown): Promise<void> => {
-		if (missingSessionRecoveryPromise) {
-			return await missingSessionRecoveryPromise;
-		}
-		missingSessionRecoveryPromise = (async () => {
-			const manager = sessionManager;
-			const missingSessionId = activeSessionId;
-			if (!manager || !missingSessionId || shutdownRequested) {
-				return;
-			}
-			const messages = await manager
-				.readMessages(missingSessionId)
-				.catch(() => []);
-			input.config.logger?.log("Recovering missing interactive session", {
-				sessionId: missingSessionId,
-				messageCount: messages.length,
-				error,
-				severity: "warn",
-			});
-			sessionStartGeneration += 1;
-			pendingResumeSessionId = undefined;
-			startupPromise = undefined;
-			startupError = undefined;
-			clearActiveSession();
-			await startFreshSession(messages);
-		})().finally(() => {
-			missingSessionRecoveryPromise = undefined;
-		});
-		return await missingSessionRecoveryPromise;
-	};
-
 	const stopCurrentSession = async (): Promise<void> => {
 		const sessionId = activeSessionId;
 		if (sessionManager && sessionId) {
@@ -399,29 +334,10 @@ export function createInteractiveSessionRuntime(input: {
 				? startupError
 				: new Error("interactive session manager is unavailable");
 		}
-		const manager = sessionManager;
-		try {
-			return await manager.send({
-				sessionId: activeSessionId,
-				...turnInput,
-			});
-		} catch (error) {
-			if (
-				abortRequested ||
-				shutdownRequested ||
-				!isSessionNotFoundError(error)
-			) {
-				throw error;
-			}
-			await recoverMissingActiveSession(error);
-			if (!activeSessionId || abortRequested || shutdownRequested) {
-				throw error;
-			}
-			return await manager.send({
-				sessionId: activeSessionId,
-				...turnInput,
-			});
-		}
+		return await sessionManager.send({
+			sessionId: activeSessionId,
+			...turnInput,
+		});
 	};
 
 	const updatePendingPrompt = async (input: {
@@ -634,20 +550,20 @@ export function createInteractiveSessionRuntime(input: {
 			let exitSummary: InteractiveExitSummary | undefined;
 			try {
 				await startupPromise?.catch(() => {});
-				await missingSessionRecoveryPromise?.catch(() => {});
 			} finally {
 				unsubscribeAgent();
 				unsubscribePendingPrompts();
 			}
 			try {
 				exitSummary = await getExitSummary();
-				// Mark hooks shut down before session disposal so late abort/stop
-				// emissions cannot dispatch over a closing hub transport.
-				await runtimeHooks?.shutdown();
 				await stopCurrentSession();
 			} finally {
-				if (sessionManager) {
-					await sessionManager.dispose("cli_interactive_shutdown");
+				try {
+					if (sessionManager) {
+						await sessionManager.dispose("cli_interactive_shutdown");
+					}
+				} finally {
+					await runtimeHooks?.shutdown();
 				}
 			}
 			return exitSummary;

apps/cli/src/runtime/run-agent.test.ts

@@ -27,41 +27,7 @@ const outputMocks = vi.hoisted(() => ({
 	c: { dim: "", reset: "" },
 }));
 
-const sessionEventsMocks = vi.hoisted(() => ({
-	listener: undefined as ((event: unknown) => void) | undefined,
-	subscribeToAgentEvents: vi.fn(
-		(_: unknown, listener: (event: unknown) => void) => {
-			sessionEventsMocks.listener = listener;
-			return () => {};
-		},
-	),
-}));
-
-const CLINE_PASS_SUBSCRIPTION_URL =
-	"https://app.cline.bot/dashboard/subscription?personal=true";
-const CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLINE_PASS_SUBSCRIPTION_URL}`;
-const CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE =
-	"Organization accounts cannot use ClinePass subscriptions. Go to /account -> change account to switch to your personal account for ClinePass";
-
 vi.mock("@cline/core", () => ({
-	getClineOrgIndividualInferenceSubscriptionMessage: () =>
-		CLINE_ORG_INDIVIDUAL_INFERENCE_SUBSCRIPTION_MESSAGE,
-	getClinePassSubscriptionUrl: () => CLINE_PASS_SUBSCRIPTION_URL,
-	isClineNotSubscribedError: (error: unknown) =>
-		error instanceof Error && error.name === "ClineNotSubscribedError",
-	isClineNotSubscribedMessage: (text: string) =>
-		text
-			.toLowerCase()
-			.includes("the user is not subscribed to required model plan"),
-	isClineOrgIndividualInferenceSubscriptionError: (error: unknown) =>
-		error instanceof Error &&
-		error.name === "ClineOrgIndividualInferenceSubscriptionError",
-	isClineOrgIndividualInferenceSubscriptionMessage: (text: string) =>
-		text
-			.toLowerCase()
-			.includes(
-				"organization accounts cannot use individual model inference subscriptions",
-			),
 	prewarmFileIndex: vi.fn(async () => undefined),
 	SessionSource: {
 		CLI: "cli",
@@ -111,7 +77,7 @@ vi.mock("./prompt", () => ({
 }));
 
 vi.mock("./session-events", () => ({
-	subscribeToAgentEvents: sessionEventsMocks.subscribeToAgentEvents,
+	subscribeToAgentEvents: vi.fn(() => () => {}),
 }));
 
 describe("runAgent", () => {
@@ -135,9 +101,6 @@ describe("runAgent", () => {
 		outputMocks.writeln.mockReset();
 		outputMocks.emitJsonLine.mockReset();
 		outputMocks.setActiveCliSession.mockReset();
-		sessionEventsMocks.listener = undefined;
-		sessionEventsMocks.subscribeToAgentEvents.mockClear();
-		vi.unstubAllGlobals();
 	});
 
 	afterEach(() => {
@@ -548,39 +511,6 @@ describe("runAgent", () => {
 		expect(outputMocks.writeErr).toHaveBeenCalledWith("Missing API key");
 	});
 
-	it("renders ClinePass subscription errors with friendly copy when startup throws", async () => {
-		const error = new Error(CLINE_PASS_SUBSCRIPTION_MESSAGE);
-		error.name = "ClineNotSubscribedError";
-		sessionManagerMocks.start.mockRejectedValue(error);
-
-		const { runAgent } = await import("./run-agent");
-
-		await expect(
-			runAgent("test prompt", {
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: { maxConsecutiveMistakes: 3 },
-				logger: undefined,
-				mode: "yolo",
-				modelId: "premium-model",
-				outputMode: "text",
-				providerId: "cline-pass",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		expect(process.exitCode).toBe(1);
-		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLINE_PASS_SUBSCRIPTION_MESSAGE,
-		);
-	});
-
 	it("emits JSON error lines for non-completed results", async () => {
 		const startedAt = new Date("2026-03-22T00:00:00.000Z");
 		const endedAt = new Date("2026-03-22T00:00:01.000Z");
@@ -646,63 +576,6 @@ describe("runAgent", () => {
 		);
 	});
 
-	it("renders ClinePass subscription errors with friendly copy for failed results", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		sessionManagerMocks.start.mockResolvedValue({
-			sessionId: "session-1",
-			manifestPath: "/tmp/manifest.json",
-			messagesPath: "/tmp/messages.json",
-			manifest: { session_id: "session-1" },
-			result: {
-				text: CLINE_PASS_SUBSCRIPTION_MESSAGE,
-				usage: {
-					inputTokens: 0,
-					outputTokens: 0,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-					totalCost: 0,
-				},
-				messages: [],
-				toolCalls: [],
-				iterations: 1,
-				finishReason: "error",
-				model: { id: "premium-model", provider: "cline-pass", info: {} },
-				startedAt,
-				endedAt,
-				durationMs: 1000,
-			},
-		});
-		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue(undefined);
-
-		const { runAgent } = await import("./run-agent");
-
-		await expect(
-			runAgent("test prompt", {
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: { maxConsecutiveMistakes: 3 },
-				logger: undefined,
-				mode: "yolo",
-				modelId: "premium-model",
-				outputMode: "text",
-				providerId: "cline-pass",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		expect(process.exitCode).toBe(1);
-		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLINE_PASS_SUBSCRIPTION_MESSAGE,
-		);
-	});
-
 	it("surfaces post-run bookkeeping failures after a completed result", async () => {
 		const startedAt = new Date("2026-03-22T00:00:00.000Z");
 		const endedAt = new Date("2026-03-22T00:00:01.000Z");
@@ -964,121 +837,4 @@ describe("runAgent", () => {
 			expect.stringContaining("est. cost"),
 		);
 	});
-
-	it("zeros Cline free model costs in JSON results and agent events", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		vi.stubGlobal(
-			"fetch",
-			vi.fn(async () => {
-				return new Response(
-					JSON.stringify({
-						free: [{ id: "deepseek/deepseek-v4-flash" }],
-					}),
-					{ status: 200, headers: { "content-type": "application/json" } },
-				);
-			}),
-		);
-		sessionManagerMocks.start.mockResolvedValue({
-			sessionId: "session-1",
-			manifestPath: "/tmp/manifest.json",
-			messagesPath: "/tmp/messages.json",
-			manifest: {
-				session_id: "session-1",
-			},
-			result: {
-				text: "completed text",
-				usage: {
-					inputTokens: 1,
-					outputTokens: 1,
-					cacheReadTokens: 0,
-					cacheWriteTokens: 0,
-					totalCost: 0.25,
-				},
-				messages: [],
-				toolCalls: [],
-				iterations: 1,
-				finishReason: "completed",
-				model: {
-					id: "deepseek/deepseek-v4-flash",
-					provider: "cline",
-					info: {},
-				},
-				startedAt,
-				endedAt,
-				durationMs: 1000,
-			},
-		});
-		sessionManagerMocks.getAccumulatedUsage.mockResolvedValue({
-			usage: {
-				inputTokens: 1,
-				outputTokens: 1,
-				cacheReadTokens: 0,
-				cacheWriteTokens: 0,
-				totalCost: 0.25,
-			},
-			aggregateUsage: {
-				inputTokens: 1,
-				outputTokens: 1,
-				cacheReadTokens: 0,
-				cacheWriteTokens: 0,
-				totalCost: 0.25,
-			},
-		});
-
-		const { runAgent } = await import("./run-agent");
-		const { handleEvent } = await import("../utils/events");
-
-		await expect(
-			runAgent("test prompt", {
-				baseUrl: "https://cline.test/api/v1",
-				cwd: process.cwd(),
-				enableAgentTeams: false,
-				enableSpawnAgent: false,
-				enableTools: [],
-				execution: {
-					maxConsecutiveMistakes: 3,
-				},
-				logger: undefined,
-				mode: "yolo",
-				modelId: "deepseek/deepseek-v4-flash",
-				outputMode: "json",
-				providerId: "cline",
-				systemPrompt: "system",
-				thinking: false,
-				toolPolicies: { "*": { autoApprove: true } },
-				verbose: false,
-				workspaceRoot: process.cwd(),
-			} as never),
-		).resolves.toBeUndefined();
-
-		const runResult = outputMocks.emitJsonLine.mock.calls.find(
-			([, payload]) =>
-				(payload as { type?: string } | undefined)?.type === "run_result",
-		)?.[1] as
-			| {
-					usage?: { totalCost?: number };
-					aggregateUsage?: { totalCost?: number };
-			  }
-			| undefined;
-		expect(runResult?.usage?.totalCost).toBe(0);
-		expect(runResult?.aggregateUsage?.totalCost).toBe(0);
-
-		sessionEventsMocks.listener?.({
-			type: "usage",
-			inputTokens: 1,
-			outputTokens: 1,
-			cost: 0.25,
-			totalCost: 0.25,
-		});
-
-		expect(handleEvent).toHaveBeenLastCalledWith(
-			expect.objectContaining({
-				type: "usage",
-				cost: 0,
-				totalCost: 0,
-			}),
-			expect.any(Object),
-		);
-	});
 });

apps/cli/src/runtime/run-agent.ts

@@ -16,13 +16,7 @@ import {
 	requestToolApproval,
 	submitAndExitInTerminal,
 } from "../utils/approval";
-import { formatCliErrorMessage } from "../utils/cline-pass-errors";
 import { handleEvent, handleTeamEvent } from "../utils/events";
-import {
-	shouldZeroClineFreeModelCost,
-	zeroCliAgentEventCost,
-	zeroCliUsageCost,
-} from "../utils/free-model-cost";
 import { createRuntimeHooks } from "../utils/hooks";
 import {
 	c,
@@ -189,10 +183,8 @@ export async function runAgent(
 	let reasoningChunkCount = 0;
 	let redactedReasoningChunkCount = 0;
 	const displayedErrorMessages = new Set<string>();
-	const shouldZeroCost = await shouldZeroClineFreeModelCost(config);
 
-	const onAgentEvent = (rawEvent: AgentEvent): void => {
-		const event = zeroCliAgentEventCost(rawEvent, shouldZeroCost);
+	const onAgentEvent = (event: AgentEvent): void => {
 		if (event.type === "content_start" && event.contentType === "reasoning") {
 			reasoningChunkCount += 1;
 			if (event.redacted) {
@@ -236,11 +228,11 @@ export async function runAgent(
 			process.off("SIGINT", handleSigint);
 			process.off("SIGTERM", handleSigterm);
 			unsubscribe();
-			await runtimeHooks.shutdown().catch(() => {});
 			if (activeSessionId) {
 				await sessionManager.stop(activeSessionId).catch(() => {});
 			}
 			await sessionManager.dispose("cli_run_shutdown").catch(() => {});
+			await runtimeHooks.shutdown().catch(() => {});
 			setActiveRuntimeAbort(undefined);
 		})();
 		return cleanupDone;
@@ -346,14 +338,8 @@ export async function runAgent(
 		const usageSummary = await sessionManager.getAccumulatedUsage(
 			started.sessionId,
 		);
-		const aggregateUsage = zeroCliUsageCost(
-			usageSummary?.aggregateUsage,
-			shouldZeroCost,
-		);
-		const usage = zeroCliUsageCost(
-			aggregateUsage ?? usageSummary?.usage ?? result.usage,
-			shouldZeroCost,
-		);
+		const aggregateUsage = usageSummary?.aggregateUsage;
+		const usage = aggregateUsage ?? usageSummary?.usage ?? result.usage;
 
 		if (config.outputMode === "json") {
 			emitJsonLine("stdout", {
@@ -388,7 +374,7 @@ export async function runAgent(
 		}
 
 		if (result.finishReason !== "completed") {
-			const errorText = formatCliErrorMessage(result.text).trim();
+			const errorText = result.text.trim();
 			if (
 				errorText &&
 				(config.outputMode === "json" || !displayedErrorMessages.has(errorText))
@@ -409,7 +395,7 @@ export async function runAgent(
 		);
 		process.exitCode = 0;
 	} catch (err) {
-		const message = formatCliErrorMessage(err);
+		const message = err instanceof Error ? err.message : String(err);
 		logCliError(config.logger, "CLI task run failed", { error: err });
 		writeErr(message);
 		process.exitCode = 1;

apps/cli/src/runtime/run-interactive.ts

@@ -8,7 +8,6 @@ import type { CliMigrationNotice } from "../kanban-migration/notice";
 import { logCliError } from "../logging/errors";
 import {
 	loadClineAccountSnapshot,
-	onProviderChange,
 	switchClineAccount,
 } from "../tui/cline-account";
 import type {
@@ -24,11 +23,6 @@ import { disableOpenTuiGraphicsProbe } from "../tui/opentui-env";
 import type { QueuedPromptItem } from "../tui/types";
 import { type ChatCommandState, chatCommandHost } from "../utils/chat-commands";
 import { applyCliCompactionMode } from "../utils/compaction-mode";
-import {
-	shouldZeroClineFreeModelCost,
-	zeroCliAgentEventCost,
-	zeroCliUsageCost,
-} from "../utils/free-model-cost";
 import {
 	prepareTerminalForPostTuiOutput,
 	writeErr,
@@ -126,7 +120,6 @@ export async function runInteractive(
 		autoApproveAllRef,
 		setInteractiveAutoApprove,
 		requestToolApproval,
-		resolveToolPolicy,
 		tuiToolApprover,
 		tuiAskQuestion,
 	} = createInteractiveApprovalController(config);
@@ -158,7 +151,6 @@ export async function runInteractive(
 		askQuestionRef: tuiAskQuestion,
 	});
 	const providerSettingsManager = new ProviderSettingsManager();
-	let zeroCurrentTurnCost = false;
 
 	const sessionRuntime = createInteractiveSessionRuntime({
 		config,
@@ -167,12 +159,11 @@ export async function runInteractive(
 		resumeSessionId,
 		chatCommandState,
 		requestToolApproval,
-		resolveToolPolicy,
 		askQuestionRef: tuiAskQuestion,
 		resolveMistakeLimitDecision,
 		switchToActModeTool,
 		onAgentEvent: (event) => {
-			uiEvents.emit("agent", zeroCliAgentEventCost(event, zeroCurrentTurnCost));
+			uiEvents.emit("agent", event);
 		},
 		onTeamEvent: (event) => {
 			uiEvents.emit("team", event);
@@ -331,18 +322,6 @@ export async function runInteractive(
 		}
 		return data;
 	};
-	const onDeleteConfigItem = async (
-		item: InteractiveConfigItem,
-		options: LoadInteractiveConfigDataOptions = {},
-	): Promise<
-		Awaited<ReturnType<typeof configDataLoader.onDeleteConfigItem>>
-	> => {
-		const data = await configDataLoader.onDeleteConfigItem(item, options);
-		if (data && shouldRefreshInteractiveSessionForConfigItem(item)) {
-			await refreshInteractiveSessionPolicies();
-		}
-		return data;
-	};
 	const toQueuedPromptItem = (prompt: {
 		id: string;
 		prompt: string;
@@ -418,7 +397,6 @@ export async function runInteractive(
 			}),
 		loadConfigData: configDataLoader.loadConfigData,
 		onToggleConfigItem,
-		onDeleteConfigItem,
 		subscribeToEvents: ({
 			onAgentEvent: onAgent,
 			onTeamEvent: onTeam,
@@ -436,9 +414,7 @@ export async function runInteractive(
 				uiEvents.off("pending-prompt-submitted", onPendingPromptSubmitted);
 			};
 		},
-		onSubmit: async (input, mode, delivery, attachments, onCommandOutput) => {
-			let commandOutput: string | undefined;
-			let zeroTurnCost = false;
+		onSubmit: async (input, mode, delivery, attachments) => {
 			try {
 				await sessionRuntime.ensureReady();
 				await waitForSubmittedMode(mode);
@@ -457,7 +433,6 @@ export async function runInteractive(
 					setInteractiveAutoApprove,
 					sessionRuntime,
 					stop: () => tuiApp?.destroy(),
-					onCommandOutput,
 				});
 				if (chatCommandResult.handled) {
 					return chatCommandResult.turnResult;
@@ -477,16 +452,12 @@ export async function runInteractive(
 						setInteractiveAutoApprove,
 						sessionRuntime,
 						stop: () => tuiApp?.destroy(),
-						onCommandOutput,
 					});
 					if (chatCommandResult.handled) {
 						return chatCommandResult.turnResult;
 					}
 				}
 				input = chatCommandResult.input;
-				commandOutput = chatCommandResult.commandOutput;
-				zeroTurnCost = await shouldZeroClineFreeModelCost(config);
-				zeroCurrentTurnCost = zeroTurnCost;
 				const {
 					prompt: userInput,
 					userImages,
@@ -523,21 +494,18 @@ export async function runInteractive(
 						iterations: 0,
 						finishReason: "queued",
 						queued: delivery === "queue" || delivery === "steer",
-						commandOutput,
 					};
 				}
 				if (result.finishReason !== "completed") {
 					if (result.finishReason === "aborted" || isAbortInProgress()) {
-						const usage = zeroCliUsageCost(
-							await sessionRuntime.getAccumulatedUsage(result.usage),
-							zeroTurnCost,
+						const usage = await sessionRuntime.getAccumulatedUsage(
+							result.usage,
 						);
 						return {
 							usage,
 							currentContextSize: getCurrentContextSize(result.messages),
 							iterations: result.iterations,
 							finishReason: "aborted",
-							commandOutput,
 						};
 					}
 					const errorText = result.text.trim();
@@ -545,16 +513,12 @@ export async function runInteractive(
 						errorText || `Turn finished with ${result.finishReason}`,
 					);
 				}
-				const usage = zeroCliUsageCost(
-					await sessionRuntime.getAccumulatedUsage(result.usage),
-					zeroTurnCost,
-				);
+				const usage = await sessionRuntime.getAccumulatedUsage(result.usage);
 				return {
 					usage,
 					currentContextSize: getCurrentContextSize(result.messages),
 					iterations: result.iterations,
 					finishReason: result.finishReason,
-					commandOutput,
 				};
 			} catch (error) {
 				if (isAbortInProgress()) {
@@ -562,7 +526,6 @@ export async function runInteractive(
 						usage: { inputTokens: 0, outputTokens: 0 },
 						iterations: 0,
 						finishReason: "aborted",
-						commandOutput,
 					};
 				}
 				logCliError(config.logger, "Interactive turn failed", {
@@ -572,7 +535,6 @@ export async function runInteractive(
 				});
 				throw error;
 			} finally {
-				zeroCurrentTurnCost = false;
 				if (!delivery) {
 					isRunning = false;
 					clearAbortInProgress();
@@ -628,10 +590,6 @@ export async function runInteractive(
 		},
 		onModelChange: async () => {
 			await sessionRuntime.ensureReady();
-			await onProviderChange({
-				config,
-				providerId: config.providerId,
-			});
 			const existing = providerSettingsManager.getProviderSettings(
 				config.providerId,
 			) ?? {
@@ -652,16 +610,6 @@ export async function runInteractive(
 		},
 		onAccountChange: async () => {
 			await sessionRuntime.ensureReady();
-			await loadClineAccountSnapshot({
-				config,
-				clineApiBaseUrl: options?.clineApiBaseUrl,
-			}).catch((error) => {
-				logCliError(
-					config.logger,
-					"Cline account refresh after account change failed",
-					{ error },
-				);
-			});
 			await sessionRuntime.restartWithCurrentMessages();
 		},
 		onResumeSession: async (sessionId: string) => {