strip maxTokens for openai-codex provider (client-side)

fix cline-pass options
fix(core): add OCA legacy reasoning effort (#11746 )
2026-09-04 20:02:30 +08:00 · 2026-06-23 14:46:32 -07:00 · 2026-06-23 13:39:35 -03:00 · 2026-06-23 09:24:42 -07:00 · 2026-06-23 02:39:42 -07:00 · 2026-06-23 17:20:00 +09:00
422 changed files with 8365 additions and 25232 deletions
@@ -1,294 +0,0 @@
-name: ext-vscode-publish-legacy
-
-# Publishes the legacy (pre-SDK-migration) VS Code extension from the
-# `legacy-extension` branch. This branch holds the npm-based 3.89.x codebase,
-# rolled forward under a 4.0.x version so existing 4.0.0 users still receive
-# the update. The main `ext-vscode-publish-stable.yml` workflow (bun-based)
-# stays the path for releasing main once the SDK migration is solid.
-#
-# This workflow lives on and is dispatched from `main` (so it satisfies the
-# default-branch dispatch requirement), but it checks out and builds the
-# `legacy-extension` branch.
-
-on:
-    workflow_dispatch:
-        inputs:
-            release-type:
-                description: "Choose release type (release or pre-release)"
-                required: true
-                default: "release"
-                type: choice
-                options:
-                    - pre-release
-                    - release
-            branch:
-                description: "Branch holding the legacy extension code"
-                required: true
-                default: "legacy-extension"
-                type: string
-
-permissions:
-    contents: write
-    packages: write
-    checks: write
-    pull-requests: write
-
-concurrency:
-    group: ext-vscode-publish-legacy-${{ github.event.inputs.branch }}
-    cancel-in-progress: false
-
-jobs:
-    # Gate the publish on the legacy branch's own npm-based test suite. We can't
-    # reuse ./.github/workflows/ext-vscode-test.yml here — on main that's the
-    # bun-based suite and it would test main, not the legacy branch — so the
-    # essential quality + test steps are inlined against the checked-out legacy
-    # branch.
-    test:
-        name: Test Legacy Extension
-        runs-on: ubuntu-latest
-        defaults:
-          run:
-            working-directory: apps/vscode
-        steps:
-            - uses: actions/checkout@v4
-              with:
-                  ref: ${{ github.event.inputs.branch }}
-
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: 22
-                  cache: 'npm'
-                  cache-dependency-path: |
-                      apps/vscode/package-lock.json
-                      apps/vscode/webview-ui/package-lock.json
-
-            - name: Install extension dependencies
-              working-directory: ${{ github.workspace }}
-              run: npm --prefix apps/vscode ci
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: Install webview-ui dependencies
-              working-directory: ${{ github.workspace }}
-              run: npm --prefix apps/vscode/webview-ui ci
-
-            - name: Run Quality Checks (lint + typecheck)
-              run: npm run ci:check-all
-
-            - name: Build Tests and Extension
-              id: build_step
-              run: npm run ci:build
-
-            - name: Unit Tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              run: npm run test:unit
-
-            - name: Extension Integration Tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              run: xvfb-run -a npm run test:coverage
-
-            - name: Webview Tests
-              if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              run: |
-                  cd webview-ui
-                  npm run test:coverage
-
-    publish:
-        needs: test
-        name: Publish Legacy Extension
-        runs-on: ubuntu-latest
-        environment: publish
-        defaults:
-          run:
-            working-directory: apps/vscode
-
-        steps:
-            # Check out the legacy branch (NOT main). fetch-depth: 0 + tags so we
-            # can create/push the release tag and compute the previous tag.
-            - uses: actions/checkout@v4
-              with:
-                  ref: ${{ github.event.inputs.branch }}
-                  fetch-depth: 0
-                  fetch-tags: true
-                  lfs: true
-
-            - name: Resolve Release Tag
-              id: resolve_tag
-              working-directory: ${{ github.workspace }}
-              env:
-                  BRANCH: ${{ github.event.inputs.branch }}
-              run: |
-                  # Tag is derived from the package version on the legacy branch.
-                  VERSION=$(node -p "require('./apps/vscode/package.json').version")
-                  TAG="v$VERSION"
-
-                  if [[ ! "$TAG" =~ ^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$ ]]; then
-                    echo "Error: derived tag '$TAG' does not match vX.Y.Z"
-                    exit 1
-                  fi
-                  TAG_REF="refs/tags/$TAG"
-                  HEAD_SHA=$(git rev-parse HEAD)
-
-                  if git show-ref --verify --quiet "$TAG_REF"; then
-                    TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
-                    if [[ "$TAG_SHA" != "$HEAD_SHA" ]]; then
-                      echo "Error: tag '$TAG' already exists at $TAG_SHA, not at branch head ($HEAD_SHA)"
-                      exit 1
-                    fi
-                    echo "Tag '$TAG' already exists at branch head. Continuing."
-                  else
-                    git config user.name "github-actions[bot]"
-                    git config user.email "github-actions[bot]@users.noreply.github.com"
-                    git tag "$TAG" "$HEAD_SHA"
-                    git push origin "$TAG_REF"
-                    echo "Created and pushed tag '$TAG' from $BRANCH head $HEAD_SHA."
-                  fi
-
-                  echo "tag=$TAG" >> $GITHUB_OUTPUT
-
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
-              with:
-                  node-version: 22
-
-            - name: Install extension dependencies
-              working-directory: ${{ github.workspace }}
-              run: npm --prefix apps/vscode install --include=optional
-
-            - name: Install webview-ui dependencies
-              working-directory: ${{ github.workspace }}
-              run: npm --prefix apps/vscode/webview-ui install --include=optional
-
-            - name: Install Publishing Tools
-              run: npm install -g @vscode/vsce ovsx
-
-            - name: Get Version
-              id: get_version
-              run: |
-                  VERSION=$(node -p "require('./package.json').version")
-                  echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-            - name: Verify Tag Matches Package Version
-              run: |
-                  TAG="${{ steps.resolve_tag.outputs.tag }}"
-                  VERSION="v${{ steps.get_version.outputs.version }}"
-                  if [[ "$TAG" != "$VERSION" ]]; then
-                    echo "Error: tag '$TAG' does not match package version '$VERSION'"
-                    exit 1
-                  fi
-                  echo "Tag and package version match: $TAG"
-
-            - name: Verify Changelog Entry
-              working-directory: ${{ github.workspace }}
-              run: |
-                  EXPECTED_HEADING="## [${{ steps.get_version.outputs.version }}]"
-                  FIRST_HEADING=$(grep -m 1 '^## \[' CHANGELOG.md || true)
-                  if [[ "$FIRST_HEADING" != "$EXPECTED_HEADING" ]]; then
-                    echo "Error: CHANGELOG.md must start with '$EXPECTED_HEADING' before publishing."
-                    echo "Current first release heading: ${FIRST_HEADING:-<none>}"
-                    exit 1
-                  fi
-                  echo "Found changelog entry for ${{ steps.get_version.outputs.version }}"
-
-            - name: Verify Marketplace Tokens
-              env:
-                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
-                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
-              run: |
-                  if [[ -z "$VSCE_PAT" ]]; then
-                    echo "Error: VSCE_PAT is required to publish the stable VS Code extension."
-                    exit 1
-                  fi
-                  if [[ -z "$OVSX_PAT" ]]; then
-                    echo "Error: OVSX_PAT is required to publish the stable Open VSX extension."
-                    exit 1
-                  fi
-                  echo "Marketplace publish tokens are configured."
-
-            - name: Package and Publish Extension
-              env:
-                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
-                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
-                  CLINE_ENVIRONMENT: production
-                  TELEMETRY_SERVICE_API_KEY: ${{ secrets.TELEMETRY_SERVICE_API_KEY }}
-                  ERROR_SERVICE_API_KEY: ${{ secrets.ERROR_SERVICE_API_KEY }}
-                  # OpenTelemetry production defaults (can be overridden at runtime)
-                  OTEL_TELEMETRY_ENABLED: ${{ secrets.OTEL_TELEMETRY_ENABLED }}
-                  OTEL_LOGS_EXPORTER: otlp
-                  OTEL_METRICS_EXPORTER: otlp
-                  OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
-                  OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
-                  OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-                  RELEASE_TYPE: ${{ github.event.inputs.release-type }}
-              run: |
-                  # Swap README.marketplace.md into README.md so both the GitHub
-                  # release artifact (vsce package below) and the marketplace
-                  # publish (npm run publish:marketplace below, which swaps
-                  # internally as an idempotent no-op) ship the same README.
-                  node scripts/marketplace-readme.mjs swap-in
-                  trap 'node scripts/marketplace-readme.mjs restore' EXIT
-
-                  # Required to generate the .vsix
-                  vsce package --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
-
-                  if [ "$RELEASE_TYPE" = "pre-release" ]; then
-                    npm run publish:marketplace:prerelease
-                    echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
-                  else
-                    npm run publish:marketplace
-                    echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
-                  fi
-
-            - name: Get Previous Tag
-              id: prev_tag
-              working-directory: ${{ github.workspace }}
-              run: |
-                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
-                  PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
-                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
-
-            - name: Get Changelog Entry
-              id: changelog
-              working-directory: ${{ github.workspace }}
-              run: |
-                  # Get content between first ## [ and second ## [
-                  CONTENT=$(awk '/^## \[/{if(found) exit; found=1; next} found{print}' CHANGELOG.md)
-                  echo "content<<EOF" >> $GITHUB_OUTPUT
-                  echo "$CONTENT" >> $GITHUB_OUTPUT
-                  echo "EOF" >> $GITHUB_OUTPUT
-
-            - name: Create GitHub Release
-              uses: softprops/action-gh-release@v1
-              with:
-                  tag_name: ${{ steps.resolve_tag.outputs.tag }}
-                  files: "apps/vscode/*.vsix"
-                  body: |
-                      ${{ steps.changelog.outputs.content }}
-
-                      **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}
-                  prerelease: ${{ github.event.inputs.release-type == 'pre-release' }}
-              env:
-                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: Post release to Slack
-              uses: slackapi/slack-github-action@v3.0.1
-              with:
-                  method: chat.postMessage
-                  token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
-                  payload: |
-                    channel: "C0APVKGGZFC"
-                    text: "Cline ${{ steps.resolve_tag.outputs.tag }} (legacy)"
-                    blocks:
-                      - type: "section"
-                        text:
-                          type: "mrkdwn"
-                          text: "*Cline ${{ steps.resolve_tag.outputs.tag }} (legacy)*"
-                      - type: "section"
-                        text:
-                          type: "mrkdwn"
-                          text: ${{ toJSON(steps.changelog.outputs.content) }}
-                      - type: "context"
-                        elements:
-                          - type: "mrkdwn"
-                            text: "Full Changelog: https://github.com/${{ github.repository }}/compare/${{ steps.prev_tag.outputs.prev_tag }}...${{ steps.resolve_tag.outputs.tag }}"
@@ -27,10 +27,6 @@ permissions:
    checks: write
    pull-requests: write

-concurrency:
-    group: ext-vscode-publish-stable-${{ github.event.inputs.tag }}
-    cancel-in-progress: false
-
 jobs:
    test:
        uses: ./.github/workflows/ext-vscode-test.yml
@@ -106,13 +102,7 @@ jobs:
                      echo "Error: tag '$TAG' does not exist in the repository"
                      exit 1
                    fi
-                    TAG_SHA=$(git rev-list -n 1 "$TAG_REF^{commit}")
-                    if [[ "$TAG_SHA" != "$TESTED_SHA" ]]; then
-                      echo "Error: existing tag '$TAG' points to $TAG_SHA, but this workflow tested $TESTED_SHA"
-                      echo "Dispatch from the tag ref, or from the exact main commit the tag points to."
-                      exit 1
-                    fi
-                    echo "Using existing tag '$TAG' at tested SHA $TESTED_SHA."
+                    echo "Using existing tag '$TAG'."
                  fi

                  git checkout --detach "$TAG_REF^{commit}"
@@ -180,60 +170,6 @@ jobs:
                  fi
                  echo "Tag and package version match: $TAG"

-            - name: Verify Changelog Entry
-              working-directory: ${{ github.workspace }}
-              run: |
-                  EXPECTED_HEADING="## [${{ steps.get_version.outputs.version }}]"
-                  FIRST_HEADING=$(grep -m 1 '^## \[' CHANGELOG.md || true)
-                  if [[ "$FIRST_HEADING" != "$EXPECTED_HEADING" ]]; then
-                    echo "Error: CHANGELOG.md must start with '$EXPECTED_HEADING' before publishing."
-                    echo "Current first release heading: ${FIRST_HEADING:-<none>}"
-                    exit 1
-                  fi
-                  echo "Found changelog entry for ${{ steps.get_version.outputs.version }}"
-
-            - name: Verify Marketplace Tokens
-              env:
-                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
-                  OVSX_PAT: ${{ secrets.OVSX_PAT }}
-              run: |
-                  if [[ -z "$VSCE_PAT" ]]; then
-                    echo "Error: VSCE_PAT is required to publish the stable VS Code extension."
-                    exit 1
-                  fi
-                  if [[ -z "$OVSX_PAT" ]]; then
-                    echo "Error: OVSX_PAT is required to publish the stable Open VSX extension."
-                    exit 1
-                  fi
-                  echo "Marketplace publish tokens are configured."
-
-            - name: Get Previous Tag
-              id: prev_tag
-              working-directory: ${{ github.workspace }}
-              run: |
-                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
-                  PREV_TAG=$(
-                    git tag --merged "$CURRENT_TAG^" --list 'v[0-9]*.[0-9]*.[0-9]*' --sort=-v:refname \
-                      | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+([-.][0-9A-Za-z.]+)?$' \
-                      | head -n 1 || true
-                  )
-                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
-
-            - name: Get Changelog Entry
-              id: changelog
-              working-directory: ${{ github.workspace }}
-              run: |
-                  # Get content between the matching version heading and the next release heading.
-                  CONTENT=$(awk -v version="${{ steps.get_version.outputs.version }}" '
-                    $0 == "## [" version "]" { found=1; next }
-                    found && /^## \[/ { exit }
-                    found { print }
-                    END { if (!found) exit 1 }
-                  ' CHANGELOG.md)
-                  echo "content<<EOF" >> $GITHUB_OUTPUT
-                  echo "$CONTENT" >> $GITHUB_OUTPUT
-                  echo "EOF" >> $GITHUB_OUTPUT
-
            - name: Package and Publish Extension
              env:
                  VSCE_PAT: ${{ secrets.VSCE_PAT }}
@@ -274,6 +210,24 @@ jobs:
                    echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                  fi

+            - name: Get Previous Tag
+              id: prev_tag
+              working-directory: ${{ github.workspace }}
+              run: |
+                  CURRENT_TAG="${{ steps.resolve_tag.outputs.tag }}"
+                  PREV_TAG=$(git describe --tags --abbrev=0 "$CURRENT_TAG^" 2>/dev/null || echo "")
+                  echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
+
+            - name: Get Changelog Entry
+              id: changelog
+              working-directory: ${{ github.workspace }}
+              run: |
+                  # Get content between first ## [ and second ## [
+                  CONTENT=$(awk '/^## \[/{if(found) exit; found=1; next} found{print}' CHANGELOG.md)
+                  echo "content<<EOF" >> $GITHUB_OUTPUT
+                  echo "$CONTENT" >> $GITHUB_OUTPUT
+                  echo "EOF" >> $GITHUB_OUTPUT
+
            - name: Create GitHub Release
              uses: softprops/action-gh-release@v1
              with:
@@ -22,24 +22,11 @@
 	},
 	// Enable Lint and format using Biome
 	"biome.enabled": true,
-	"biome.requireConfiguration": true,
-	"prettier.enable": false,
 	"editor.defaultFormatter": "biomejs.biome",
-	"[javascript]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[javascriptreact]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[typescript]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
-	"[typescriptreact]": {
-		"editor.defaultFormatter": "biomejs.biome"
-	},
 	"editor.codeActionsOnSave": {
 		"source.fixAll.biome": "explicit",
 		"source.removeUnused.biome": "always",
+		"source.removeUnusedImports": "always",
 		"source.organizeImports.biome": "always"
 	},
 	// Disable auto-forwarding ports to prevent Simple Browser from opening the Vite dev server
@@ -169,8 +169,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -209,8 +208,7 @@
 			"isBackground": true,
 			"label": "npm: watch:esbuild:test",
 			"dependsOn": [
-				"npm: protos",
-				"build-sdk:debug"
+				"npm: protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -313,24 +311,6 @@
 			"options": {
 				"cwd": "${workspaceFolder}"
 			}
-		},
-		{
-			"label": "build-sdk:debug",
-			"type": "shell",
-			"command": "bun run build:sdk",
-			"problemMatcher": [
-				"$tsc"
-			],
-			"presentation": {
-				"group": "watch",
-				"reveal": "always"
-			},
-			"options": {
-				"cwd": "${workspaceFolder}",
-				"env": {
-					"CLINE_SOURCEMAPS": "1"
-				}
-			}
 		}
 	],
 	"inputs": [
@@ -1,44 +1,5 @@
 # Changelog

-## [4.0.0]
-
-### Added
-
- Add the SDK-backed VS Code extension runtime. Cline now runs tasks through the shared Cline SDK session layer for agent turns, tools, Plan/Act mode coordination, MCP, checkpoints, telemetry, provider changes, compaction, mistake limits, and task history.
- Add ClinePass to the VS Code extension, including onboarding, provider selection, signup and subscription handoff, live model lists, entitlement and organization error states, out-of-credit prompts, and clearer ClinePass auth/error handling.
- Add the Customize marketplace for discovering and managing Skills, MCP servers, and Plugins from the extension, including installed/marketplace tabs, search and filtering, install/uninstall flows, enable/disable controls, and support for plugin-bundled skills.
- Cline Plugins: Plugins let you extend Cline with custom tools, workflows, skills, and MCP-powered capabilities tailored to your team or project. Install them from the new Customize marketplace to add specialized behavior, connect external services, and package reusable automations—so Cline can do more than code: it can adapt to the way you work.
- Add queued prompts in chat. Messages submitted while Cline is already working are now queued, shown while the current turn streams, and can be cancelled before they run.
- Add edit-and-regenerate support for previous user messages, with clearer Reset Chat and Reset Code actions.
- Add generic SDK provider settings and model-catalog support so more providers can share the same model picker, reasoning controls, dynamic model IDs, provider config persistence, and custom model handling.
- Add additional SDK-backed provider exposure and model/provider updates, including ClinePass models, refreshed Cline catalog data, Fireworks GLM 5.2, Kimi K2.6 Fast, Kimi K2.7 Code, Qwen 3.7 Plus, MiniMax M3 updates, SAP AI Core wiring, LiteLLM model fetching, Codex OAuth credentials, and OpenAI-compatible model settings.
- Add MCP support for plugins and shared marketplace install/uninstall plumbing used by the VS Code extension.
-
-### Changed
-
- Migrate the VS Code extension from the legacy task implementation to the shared Cline SDK and move the extension build/package workflow to Bun.
- Rework Plan/Act mode handling through SDK coordinators, including closer CLI parity and automatic continuation when switching from Plan to Act.
- Rework provider and model configuration around `providers.json`, the model catalog, and SDK session config so settings are preserved consistently across provider switches and active sessions can restart when the selected provider changes.
- Simplify provider settings UI by replacing many provider-specific views with shared generic settings components and consistent reasoning selectors.
- Simplify terminal execution through the SDK run-commands path, including clearer non-interactive command guidance and safer structured command formatting.
- Migrate legacy MCP files and formats into the shared settings file and protect MCP settings writes with safer locking/atomic updates.
- Refresh the MCP hub automatically after marketplace installs so newly installed servers are available without a manual restart.
- Reorganize MCP/Skills/Plugins entry points under Customize, hide workflows from the Customize menu, wrap Customize tabs on narrow screens, and allow the MCP Marketplace tab to be disabled remotely while installed MCP servers remain accessible.
- Simplify auto-approval settings. Command auto-approval is now disabled by default for safer new and reset configurations, and the auto-approval UI has been streamlined.
- Update task history handling for the SDK migration, including legacy task history visibility, metadata preservation on resume, and corrected deletion behavior.
- Route compacting and mistake-limit behavior through the SDK so the Compact button and mistake tracking affect the active SDK session.
- Remove the legacy Explain Changes feature as part of the SDK migration cleanup.
- Temporarily disable subagents in the VS Code extension while the SDK-backed experience is stabilized.
-
-### Fixed
-
- Fix marketplace edge cases, including refreshing MCP servers after marketplace installs, disabling the MCP Marketplace tab from remote config, hiding workflows from Customize, surfacing plugin-bundled skills, and uninstalling shared marketplace entries.
- Fix chat submission during active turns by queuing user messages instead of dropping or racing them, showing pending/queued states promptly, rendering direct user messages immediately, and removing delayed send behavior.
- Fix editing previous user messages so Escape cancels editing locally and reset action labels are clearer.
- Fix terminal reliability, including standalone Windows output capture, hardened PowerShell command handling, running-state display for in-progress commands, raw structured command preservation, single-quote handling, cwd setup timeouts, failing-command stdout capture, heredoc coalescing, and removal of duplicated command echoes in tool results.
- Fix SDK tool-result and provider-message budgeting by truncating large tool outputs by default, capping assistant text, limiting bash/file-read/search output ingestion, bounding media budgets, batching outdated-read rewrites to preserve provider prefix caches, and normalizing JSON-like tool inputs by schema.
- Fix login and feature-flag resolution by using the correct user/account identity on startup and simplifying the login UX.
-
 ## [3.89.2]

 ### Fixed
@@ -1,74 +1,5 @@
 # Cline CLI Changelog

-## 3.0.37
-
- Weaker models (e.g. DeepSeek) that emit malformed tool calls — wrong argument types or truncated JSON — are now handled gracefully and run instead of erroring out
- Plan/act mode switches are now visible to the model, so it knows when you change modes mid-session
- Fixed plan/act mode notices being dropped from prompts sent to the model
- Fixed a race where switching modes in an empty session could trigger an unexpected restart
-
-## 3.0.36
-
- Fixed plan mode's `switch_to_act_mode` tool not taking effect until the end of the turn: the model would keep running with plan-mode tools (no file editor) and fall back to editing files through shell commands. Switching to act mode now ends the plan-mode run and automatically continues with the approved plan using the full act-mode toolset. A Tab mode toggle racing a completing turn can no longer auto-start plan execution you didn't approve.
-
-## 3.0.35
-
- ClinePass is now enabled for all CLI users
- Recover missing interactive sessions when reading messages
- Format structured commands in history export
- Add the subscription promo code when linking to the dashboard subscription page
- Add Tencent TokenHub as a provider (from SDK v0.0.55)
- Fix first-prompt truncation on high-output models (e.g. MiniMax M3) that could immediately auto-compact and cut the initial task down to just the input wrapper (from SDK v0.0.55)
- Use a curated default when migrating legacy provider settings (from SDK v0.0.55)
- Advertise run commands as shell strings (from SDK v0.0.55)
- Refresh the bundled model catalog with the latest provider models (from SDK v0.0.55)
-
-## 3.0.34
-
- Fixed the ClinePass upgrade notice appearing immediately after completing onboarding.
- Improved the wording of the ClinePass onboarding step.
- Streamlined the Cline provider picker by merging the subscription and usage/billing options into one and removing the credits link.
-
-## 3.0.33
-
- Show a ClinePass subscription URL as a fallback during onboarding so you can still subscribe if the subscription screen can't open automatically
- Hide the ClinePass promo for users who already have a ClinePass subscription
- Use an adaptive plan accent color for ClinePass prompts so they fit the active theme
-
-## 3.0.32
-
- Improved the ClinePass onboarding experience
- Added an intermediate step before going to ClinePass model selection
- Made the ClinePass subscription screen selectable
- Promoted ClinePass in the startup notice
- Used "ClinePass" as one word consistently and refined the provider UI copy
- More accurate context compaction and clearer error messages (from SDK v0.0.54)
-
-## 3.0.31
-
- Show when request cost is covered by your Cline subscription
- Prompt to switch to ClinePass when you run out of credits, and list ClinePass features in the not-subscribed message
- Added an option to open the subscription page from the ClinePass options
- Added marketplace uninstall support and surfaced plugin-bundled skills
- Require quoted prompts for one-shot mode
- Capped MCP tool names at 64 characters for OpenAI-compatible providers
- Updated coupon code
-
-## 3.0.30
-
- Added a token count to the status bar, shown alongside cost
- Added organization-specific error messages
- Added SAP AI Core provider support
- Refreshed the model catalog with the latest provider models
- Preserved OpenRouter reasoning-disable behavior and improved OpenRouter prompt caching
- Routed LiteLLM model fetches through the SDK and stopped unrelated models from appearing in the LiteLLM model list
- Updated ClinePass models live, restored ClinePass models in onboarding, and improved ClinePass error messages
- Threaded proxy/CA-aware networking into the inference path
- Persisted Bedrock settings to providers.json
- Normalized JSON-like tool inputs by schema for more reliable tool calls
- Fixed an "ERROR: EMPTY CONTENT" message that could appear when an error occurred
- Fixed a packaging issue (createRequire) that could break the CLI at runtime
-
 ## 3.0.29

 - Costs are now hidden for Cline free models
@@ -121,7 +121,7 @@ const result = await Bun.build({
 	},
 	env: "OTEL_*",
 	banner:
-		'import { createRequire as __clineCreateRequire } from "node:module"; const require = __clineCreateRequire(import.meta.url);',
+		'import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);',
 });

 if (result.logs.length > 0) {
@@ -1,7 +1,7 @@
 {
 	"name": "@cline/cli",
 	"displayName": "cline",
-	"version": "3.0.37",
+	"version": "3.0.29",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"type": "module",
 	"publishConfig": {
@@ -313,45 +313,6 @@ describe("runHistoryExport", () => {
 		await expect(readFile(outputPath, "utf8")).resolves.toContain("world");
 	});

-	it("exports run_commands history with structured command objects", async () => {
-		tempDir = await mkdtemp(join(tmpdir(), "cline-history-export-"));
-		const outputPath = join(tempDir, "export.html");
-		const artifact = {
-			version: 1,
-			updated_at: "2026-04-22T17:42:10.123Z",
-			sessionId: "sess_1",
-			messages: [
-				{
-					id: "m1",
-					role: "assistant",
-					content: [
-						{
-							type: "tool_use",
-							id: "tool_1",
-							name: "run_commands",
-							input: {
-								commands: [{ command: "cmd", args: ["/c", "dir"] }],
-							},
-						},
-					],
-				},
-			],
-		} satisfies NonNullable<
-			Awaited<ReturnType<typeof readSessionMessagesArtifact>>
-		>;
-		mockedReadSessionMessagesArtifact.mockResolvedValue(artifact);
-		const io = {
-			writeln: vi.fn(),
-			writeErr: vi.fn(),
-		};
-
-		const code = await runHistoryExport("sess_1", outputPath, "text", io);
-
-		expect(code).toBe(0);
-		expect(io.writeErr).not.toHaveBeenCalled();
-		await expect(readFile(outputPath, "utf8")).resolves.toContain("cmd /c dir");
-	});
-
 	it("fails when the session artifact is missing", async () => {
 		mockedReadSessionMessagesArtifact.mockResolvedValue(undefined);
 		const io = {
@@ -1,27 +1,5 @@
-import { installMcpServer } from "@cline/core";
 import { describe, expect, it, vi } from "vitest";
-import {
-	buildMcpInstallDefaults,
-	buildMcpInstallTransport,
-	runMcpInstallCommand,
-} from "./mcp";
-
-vi.mock("@cline/core", async (importOriginal) => {
-	const actual = await importOriginal<typeof import("@cline/core")>();
-	return {
-		...actual,
-		installMcpServer: vi.fn((options) => {
-			const { name, transport, warnings } =
-				actual.buildMcpInstallTransport(options);
-			return {
-				name,
-				status: "installed",
-				transport,
-				warnings,
-			};
-		}),
-	};
-});
+import { buildMcpInstallDefaults, runMcpInstallCommand } from "./mcp";

 describe("mcp install command", () => {
 	it("builds stdio wizard defaults from command args", () => {
@@ -110,52 +88,6 @@ describe("mcp install command", () => {
 		).toThrow(/only http and https are supported/);
 	});

-	it("builds direct stdio installs without shell-joining args", () => {
-		expect(
-			buildMcpInstallTransport({
-				name: "fs",
-				targetArgs: [
-					"npx",
-					"-y",
-					"@modelcontextprotocol/server-filesystem",
-					"/tmp/my dir",
-				],
-			}),
-		).toEqual({
-			name: "fs",
-			transport: {
-				type: "stdio",
-				command: "npx",
-				args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp/my dir"],
-			},
-			warnings: [],
-		});
-	});
-
-	it("builds direct remote installs with headers and placeholder warnings", () => {
-		expect(
-			buildMcpInstallTransport({
-				name: "docs",
-				transport: "http",
-				headers: ["Authorization: Bearer <token>"],
-				targetArgs: ["https://example.com/mcp", "--header=X-Extra: yes"],
-			}),
-		).toEqual({
-			name: "docs",
-			transport: {
-				type: "streamableHttp",
-				url: "https://example.com/mcp",
-				headers: {
-					Authorization: "Bearer <token>",
-					"X-Extra": "yes",
-				},
-			},
-			warnings: [
-				'Header "Authorization" looks like it contains a placeholder. Update it in MCP settings before using this server.',
-			],
-		});
-	});
-
 	it("opens the add wizard with prefilled defaults", async () => {
 		const runWizard = vi.fn(async () => 0);

@@ -192,11 +124,11 @@ describe("mcp install command", () => {
 		expect(code).toBe(1);
 		expect(runWizard).not.toHaveBeenCalled();
 		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+			"cline mcp install opens the MCP wizard and requires a TTY.",
 		);
 	});

-	it("checks for TTY before validating wizard install arguments", async () => {
+	it("checks for TTY before validating install arguments", async () => {
 		const writeErr = vi.fn();

 		const code = await runMcpInstallCommand({
@@ -207,65 +139,7 @@ describe("mcp install command", () => {

 		expect(code).toBe(1);
 		expect(writeErr).toHaveBeenCalledWith(
-			"cline mcp install opens the MCP wizard and requires a TTY. Pass --yes to install noninteractively.",
+			"cline mcp install opens the MCP wizard and requires a TTY.",
 		);
 	});
-
-	it("installs directly with --yes without requiring a TTY", async () => {
-		const writeln = vi.fn();
-		const writeErr = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "docs",
-			transport: "http",
-			targetArgs: [
-				"https://example.com/mcp",
-				"--header",
-				"Authorization: Bearer token",
-			],
-			isTty: false,
-			yes: true,
-			io: { writeln, writeErr },
-		});
-
-		expect(code).toBe(0);
-		expect(installMcpServer).toHaveBeenCalledWith({
-			name: "docs",
-			transport: "http",
-			targetArgs: [
-				"https://example.com/mcp",
-				"--header",
-				"Authorization: Bearer token",
-			],
-			isTty: false,
-			yes: true,
-			io: { writeln, writeErr },
-		});
-		expect(writeln).toHaveBeenCalledWith("Installed MCP server docs.");
-		expect(writeErr).not.toHaveBeenCalled();
-	});
-
-	it("prints direct install JSON with --yes --json", async () => {
-		const writeln = vi.fn();
-
-		const code = await runMcpInstallCommand({
-			name: "fs",
-			targetArgs: ["node", "server.js"],
-			isTty: false,
-			yes: true,
-			json: true,
-			io: { writeln, writeErr: vi.fn() },
-		});
-
-		expect(code).toBe(0);
-		expect(JSON.parse(writeln.mock.calls[0]?.[0])).toMatchObject({
-			name: "fs",
-			status: "installed",
-			transport: {
-				type: "stdio",
-				command: "node",
-				args: ["server.js"],
-			},
-		});
-	});
 });
@@ -1,36 +1,21 @@
-import {
-	type McpInstallOptions as CoreMcpInstallOptions,
-	installMcpServer,
-	type McpInstallResult,
-	type McpServerTransportConfig,
-} from "@cline/core";
 import type { McpAddDefaults } from "../wizards/mcp";

-export { buildMcpInstallTransport } from "@cline/core";
-
 export interface McpCommandIo {
-	writeln?: (text: string) => void;
 	writeErr: (text: string) => void;
 }

-export interface McpInstallOptions extends CoreMcpInstallOptions {
+export interface McpInstallOptions {
+	name: string;
+	targetArgs?: string[];
+	transport?: string;
 	io?: McpCommandIo;
 	isTty?: boolean;
-	json?: boolean;
 	runWizard?: (defaults: McpAddDefaults) => Promise<number>;
-	yes?: boolean;
-}
-
-export interface McpInstallDirectResult {
-	name: string;
-	status: "installed";
-	transport: McpServerTransportConfig;
-	warnings: string[];
 }

 function normalizeTransportType(
 	value: string | undefined,
-): McpServerTransportConfig["type"] {
+): McpAddDefaults["type"] {
 	const normalized = (value ?? "stdio").trim();
 	if (normalized === "http" || normalized === "streamable-http") {
 		return "streamableHttp";
@@ -106,18 +91,6 @@ export function buildMcpInstallDefaults(options: {
 	};
 }

-export function installMcpServerDirect(
-	options: McpInstallOptions,
-): McpInstallDirectResult {
-	const result: McpInstallResult = installMcpServer(options);
-	return {
-		name: result.name,
-		status: result.status,
-		transport: result.transport,
-		warnings: result.warnings,
-	};
-}
-
 async function runPrefilledWizard(defaults: McpAddDefaults): Promise<number> {
 	const { runMcpWizard } = await import("../wizards/mcp");
 	return runMcpWizard({
@@ -131,23 +104,11 @@ export async function runMcpInstallCommand(
 	options: McpInstallOptions,
 ): Promise<number> {
 	try {
-		if (options.yes) {
-			const result = installMcpServerDirect(options);
-			if (options.json) {
-				options.io?.writeln?.(JSON.stringify(result));
-			} else {
-				options.io?.writeln?.(`Installed MCP server ${result.name}.`);
-				for (const warning of result.warnings) {
-					options.io?.writeErr(warning);
-				}
-			}
-			return 0;
-		}
 		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. Pass --yes to install noninteractively.",
+				"cline mcp install opens the MCP wizard and requires a TTY.",
 			);
 		}
 		const defaults = buildMcpInstallDefaults(options);
@@ -33,7 +33,7 @@ export function addRootOptions(cmd: Command): Command {
 			.option("-c, --cwd <path>", "Working directory")
 			.option(
 				"--thinking <level>",
-				"Set reasoning effort: none|low|medium|high|xhigh. Bare --thinking uses medium; omitted leaves provider default.",
+				"Set reasoning effort level between none|low|medium|high|xhigh (default: medium)",
 			)
 			.option("--compaction <mode>", CLI_COMPACTION_MODE_OPTION_DESCRIPTION)
 			.option(
@@ -101,7 +101,7 @@ describe("buildConnectorStartRequest", () => {
 		expect(request.apiKey).toBe("env-openrouter-key");
 		expect(request.model).toBe("anthropic/claude-sonnet-4.6");
 		expect(mockGetLastUsedProviderSettings).toHaveBeenCalledWith({
-			isClinePassEnabled: true,
+			isClinePassEnabled: false,
 		});
 	});

@@ -16,6 +16,7 @@ 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,7 +64,8 @@ export async function buildConnectorStartRequest(input: {
 	const providerSettingsManager = new ProviderSettingsManager();
 	const lastUsedProviderSettings =
 		providerSettingsManager.getLastUsedProviderSettings({
-			isClinePassEnabled: true,
+			isClinePassEnabled:
+				getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
 		});
 	const provider = normalizeProviderId(
 		input.options.provider?.trim() ||
@@ -1,10 +1,7 @@
 // @jsxImportSource @opentui/react
 import type { ChoiceContext } from "@opentui-ui/dialog";
 import { useDialogKeyboard } from "@opentui-ui/dialog/react";
-import open from "open";
-import { useCallback, useMemo, useState } from "react";
 import { palette } from "../tui/palette";
-import { getCliSubscriptionUrl } from "../utils/cline-pass-errors";
 import type { CliMigrationNotice } from "./notice";

 export function MigrationNoticeContent(
@@ -13,29 +10,10 @@ export function MigrationNoticeContent(
 	},
 ) {
 	const { dialogId, notice, resolve } = props;
-	const subscriptionUrl = useMemo(() => getCliSubscriptionUrl(), []);
-	const [status, setStatus] = useState<string | undefined>();
-
-	const openSubscriptionPage = useCallback(() => {
-		setStatus("Opening ClinePass in your browser...");
-		void open(subscriptionUrl, { wait: false })
-			.then(() => {
-				setStatus("Opened ClinePass in your browser.");
-			})
-			.catch(() => {
-				setStatus(
-					"Could not open the browser automatically. Use the URL below.",
-				);
-			});
-	}, [subscriptionUrl]);

 	useDialogKeyboard((key) => {
 		if (key.name === "escape") {
 			resolve(true);
-			return;
-		}
-		if (key.name === "return" || key.name === "enter") {
-			openSubscriptionPage();
 		}
 	}, dialogId);

@@ -44,24 +22,25 @@ export function MigrationNoticeContent(
 			<text fg={palette.act}>{notice.title}</text>
 			<box flexDirection="column">
 				<text selectable>
-					ClinePass is a $9.99/month subscription plan to get access to the
-					latest open-weight coding models with enough quota for day-to-day
-					work, at a much lower cost than paying API costs directly.
+					We rebuilt the CLI from the ground up using the new Cline SDK. Learn
+					more:{" "}
+					<a href="https://github.com/cline/cline">
+						<span fg={palette.act}>https://github.com/cline/cline</span>
+					</a>
 				</text>
-				<text selectable>Try it now with a limited-time promo for $1.99.</text>
-			</box>
-			<box flexDirection="row">
-				<text fg={palette.act} selectable>
-					<a href={subscriptionUrl}>{subscriptionUrl}</a>
+				<text selectable>
+					Running{" "}
+					<span fg="#98c379" bg="#1f2937">
+						{" cline "}
+					</span>{" "}
+					now opens the terminal UI. To open Kanban, use /quit and run{" "}
+					<span fg="#98c379" bg="#1f2937">
+						{" cline kanban "}
+					</span>{" "}
+					in your terminal
 				</text>
 			</box>
-			<box flexDirection="row">
-				<box paddingX={1} backgroundColor={palette.act}>
-					<text fg={palette.textOnSelection}>Open ClinePass</text>
-				</box>
-			</box>
-			{status && <text fg={palette.muted}>{status}</text>}
-			<text fg={palette.muted}>Press Enter to open, Esc to close</text>
+			<text fg={palette.muted}>Press Esc to close</text>
 		</box>
 	);
 }
@@ -1,18 +1,11 @@
-import {
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	rmSync,
-	writeFileSync,
-} from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 import {
 	getClineCliMigrationNotice,
 	markClineCliMigrationNoticeShown,
 	resolveCliNoticeStatePath,
-	shouldSuppressClineCliMigrationNoticeForActiveProvider,
 } from "./notice";

 const tempDirs: string[] = [];
@@ -33,25 +26,8 @@ describe("migration notice", () => {
 	it("returns the notice for a fresh data dir", () => {
 		const dataDir = createTempDataDir();

-		expect(getClineCliMigrationNotice(dataDir)?.title).toBe("Try ClinePass");
-	});
-
-	it("shows when only the old Kanban notice was marked as shown", () => {
-		const dataDir = createTempDataDir();
-		const noticePath = resolveCliNoticeStatePath(dataDir);
-		mkdirSync(dirname(noticePath), { recursive: true, mode: 0o700 });
-		writeFileSync(
-			noticePath,
-			`${JSON.stringify(
-				{ shown: { "cline-cli-tui-default": true } },
-				null,
-				2,
-			)}\n`,
-			"utf8",
-		);
-
-		expect(getClineCliMigrationNotice(dataDir)?.id).toBe(
-			"cline-cli-cline-pass-intro",
+		expect(getClineCliMigrationNotice(dataDir)?.title).toBe(
+			"Welcome to the new Cline CLI",
 		);
 	});

@@ -70,7 +46,7 @@ describe("migration notice", () => {

 		expect(
 			getClineCliMigrationNotice(dataDir, {
-				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
+				CLINE_FORCE_MIGRATION_NOTICE: "1",
 			}),
 		).toBeDefined();
 	});
@@ -80,56 +56,18 @@ describe("migration notice", () => {

 		expect(
 			getClineCliMigrationNotice(dataDir, {
-				CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
+				CLINE_DISABLE_MIGRATION_NOTICE: "1",
 			}),
 		).toBeUndefined();
 	});

-	it("does not show when ClinePass is already the active provider", () => {
-		const dataDir = createTempDataDir();
-
-		expect(
-			getClineCliMigrationNotice(
-				dataDir,
-				{},
-				{ activeProviderId: "cline-pass" },
-			),
-		).toBeUndefined();
-	});
-
-	it("suppresses the active ClinePass provider even when the provider id has surrounding whitespace", () => {
-		expect(
-			shouldSuppressClineCliMigrationNoticeForActiveProvider(" cline-pass "),
-		).toBe(true);
-	});
-
-	it("does not suppress the active ClinePass provider when forced", () => {
-		expect(
-			shouldSuppressClineCliMigrationNoticeForActiveProvider("cline-pass", {
-				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
-			}),
-		).toBe(false);
-	});
-
-	it("shows for the active ClinePass provider when forced", () => {
-		const dataDir = createTempDataDir();
-
-		expect(
-			getClineCliMigrationNotice(
-				dataDir,
-				{ CLINE_FORCE_CLINE_PASS_NOTICE: "1" },
-				{ activeProviderId: "cline-pass" },
-			),
-		).toBeDefined();
-	});
-
 	it("shows when forced even if disabled through the environment", () => {
 		const dataDir = createTempDataDir();

 		expect(
 			getClineCliMigrationNotice(dataDir, {
-				CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
-				CLINE_FORCE_CLINE_PASS_NOTICE: "1",
+				CLINE_DISABLE_MIGRATION_NOTICE: "1",
+				CLINE_FORCE_MIGRATION_NOTICE: "1",
 			}),
 		).toBeDefined();
 	});
@@ -140,7 +78,7 @@ describe("migration notice", () => {
 		markClineCliMigrationNoticeShown(dataDir);

 		const rawState = readFileSync(resolveCliNoticeStatePath(dataDir), "utf8");
-		expect(rawState).toContain("cline-cli-cline-pass-intro");
+		expect(rawState).toContain("cline-cli-tui-default");
 		expect(getClineCliMigrationNotice(dataDir)).toBeUndefined();
 	});
 });
@@ -2,19 +2,15 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { resolveClineDataDir } from "@cline/shared/storage";

-const NOTICE_ID = "cline-cli-cline-pass-intro";
-const FORCE_NOTICE_ENV = "CLINE_FORCE_CLINE_PASS_NOTICE";
-const DISABLE_NOTICE_ENV = "CLINE_DISABLE_CLINE_PASS_NOTICE";
+const NOTICE_ID = "cline-cli-tui-default";
+const FORCE_NOTICE_ENV = "CLINE_FORCE_MIGRATION_NOTICE";
+const DISABLE_NOTICE_ENV = "CLINE_DISABLE_MIGRATION_NOTICE";

 export interface CliMigrationNotice {
 	id: string;
 	title: string;
 }

-export interface CliMigrationNoticeOptions {
-	activeProviderId?: string;
-}
-
 interface CliNoticeState {
 	shown: Record<string, boolean>;
 }
@@ -53,19 +49,6 @@ function readNoticeState(filePath: string): CliNoticeState {
 	return { shown };
 }

-function isForceNoticeEnabled(env: NodeJS.ProcessEnv): boolean {
-	return env[FORCE_NOTICE_ENV]?.trim() === "1";
-}
-
-export function shouldSuppressClineCliMigrationNoticeForActiveProvider(
-	activeProviderId: string | undefined,
-	env: NodeJS.ProcessEnv = process.env,
-): boolean {
-	return (
-		activeProviderId?.trim() === "cline-pass" && !isForceNoticeEnabled(env)
-	);
-}
-
 export function resolveCliNoticeStatePath(
 	dataDir = resolveClineDataDir(),
 ): string {
@@ -75,29 +58,20 @@ export function resolveCliNoticeStatePath(
 export function getClineCliMigrationNotice(
 	dataDir = resolveClineDataDir(),
 	env: NodeJS.ProcessEnv = process.env,
-	options: CliMigrationNoticeOptions = {},
 ): CliMigrationNotice | undefined {
 	const noticePath = resolveCliNoticeStatePath(dataDir);
 	const noticeState = readNoticeState(noticePath);
-	const forceNotice = isForceNoticeEnabled(env);
+	const forceNotice = env[FORCE_NOTICE_ENV]?.trim() === "1";
 	const disableNotice = env[DISABLE_NOTICE_ENV]?.trim() === "1";
 	if (disableNotice && !forceNotice) {
 		return undefined;
 	}
-	if (
-		shouldSuppressClineCliMigrationNoticeForActiveProvider(
-			options.activeProviderId,
-			env,
-		)
-	) {
-		return undefined;
-	}
 	if (noticeState.shown[NOTICE_ID] && !forceNotice) {
 		return undefined;
 	}
 	return {
 		id: NOTICE_ID,
-		title: "Try ClinePass",
+		title: "Welcome to the new Cline CLI",
 	};
 }

@@ -1,9 +1,6 @@
 import { fstatSync } from "node:fs";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type {
-	CliMigrationNotice,
-	CliMigrationNoticeOptions,
-} from "./kanban-migration/notice";
+import type { CliMigrationNotice } from "./kanban-migration/notice";

 /** Real `fstatSync`: used when tests stub only stdin (fd 0); throwing for every fd breaks imports and session I/O. */
 const fsActual = vi.hoisted(() => ({
@@ -62,13 +59,9 @@ const dashboardMocks = vi.hoisted(() => ({
 	runDashboardCommand: vi.fn(),
 }));
 const migrationNoticeMocks = vi.hoisted(() => ({
-	getClineCliMigrationNotice: vi.fn<
-		(
-			dataDir?: string,
-			env?: NodeJS.ProcessEnv,
-			options?: CliMigrationNoticeOptions,
-		) => CliMigrationNotice | undefined
-	>(() => undefined),
+	getClineCliMigrationNotice: vi.fn<() => CliMigrationNotice | undefined>(
+		() => undefined,
+	),
 	markClineCliMigrationNoticeShown: vi.fn(),
 }));
 const updateMocks = vi.hoisted(() => ({
@@ -122,7 +115,6 @@ const telemetryMocks = vi.hoisted(() => ({
 const featureFlagMocks = vi.hoisted(() => ({
 	getBooleanFlagEnabled: vi.fn(() => false),
 	setCliFeatureFlagsAccountContext: vi.fn(),
-	refreshCliFeatureFlagsInBackground: vi.fn(),
 }));

 function forcePromptModeInput() {
@@ -187,8 +179,7 @@ vi.mock("./utils/feature-flags", () => ({
 	getCliFeatureFlagsService: () => ({
 		getBooleanFlagEnabled: featureFlagMocks.getBooleanFlagEnabled,
 	}),
-	refreshCliFeatureFlagsInBackground:
-		featureFlagMocks.refreshCliFeatureFlagsInBackground,
+	refreshCliFeatureFlagsInBackground: vi.fn(),
 	setCliFeatureFlagsAccountContext:
 		featureFlagMocks.setCliFeatureFlagsAccountContext,
 }));
@@ -267,7 +258,6 @@ describe("runCli lightweight command dispatch", () => {
 		featureFlagMocks.getBooleanFlagEnabled.mockReset();
 		featureFlagMocks.getBooleanFlagEnabled.mockReturnValue(false);
 		featureFlagMocks.setCliFeatureFlagsAccountContext.mockReset();
-		featureFlagMocks.refreshCliFeatureFlagsInBackground.mockReset();
 		kanbanMocks.launchKanban.mockReset();
 		kanbanMocks.launchKanban.mockResolvedValue(0);
 		dashboardMocks.runDashboardCommand.mockReset();
@@ -417,7 +407,7 @@ describe("runCli lightweight command dispatch", () => {

 	it("does not load interactive runtime for single-prompt mode", async () => {
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
+		process.argv = ["bun", "src/index.ts", "hello"];

 		const { runCli } = await import("./main");

@@ -427,30 +417,6 @@ describe("runCli lightweight command dispatch", () => {
 		expect(mockState.runInteractiveImports).toBe(0);
 	});

-	it("rejects a single bare positional prompt token", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "nonexistent-command"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining(
-				"Unknown command or unquoted prompt: nonexistent-command",
-			),
-		);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining('Use "cline --help"'),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
-		expect(mockState.runAgentImports).toBe(0);
-		expect(mockState.runInteractiveImports).toBe(0);
-	});
-
 	it("rejects multiple bare positional prompt tokens", async () => {
 		const consoleError = vi
 			.spyOn(console, "error")
@@ -464,7 +430,7 @@ describe("runCli lightweight command dispatch", () => {
 		expect(process.exitCode).toBe(1);
 		expect(consoleError).toHaveBeenCalledWith(
 			expect.stringContaining(
-				"Unknown command or unquoted prompt: hello world",
+				"Unknown command or extra arguments: hello world",
 			),
 		);
 		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
@@ -508,7 +474,7 @@ describe("runCli lightweight command dispatch", () => {

 	it("creates a worktree and runs prompt sessions from it", async () => {
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--worktree", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--worktree", "hello"];

 		const { runCli } = await import("./main");

@@ -517,7 +483,7 @@ describe("runCli lightweight command dispatch", () => {
 			cwd: process.cwd(),
 		});
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				cwd: "/tmp/cline-worktree",
 				workspaceRoot: "/tmp/cline-worktree",
@@ -640,8 +606,8 @@ describe("runCli lightweight command dispatch", () => {

 	it("passes the migration notice marker into interactive mode", async () => {
 		const notice = {
-			id: "cline-cli-cline-pass-intro",
-			title: "Try ClinePass",
+			id: "cline-cli-tui-default",
+			title: "Welcome to the new Cline CLI",
 		};
 		migrationNoticeMocks.getClineCliMigrationNotice.mockReturnValue(notice);
 		Object.defineProperty(process.stdout, "isTTY", {
@@ -672,37 +638,6 @@ describe("runCli lightweight command dispatch", () => {
 		).toHaveBeenCalledTimes(1);
 	});

-	it("passes the active ClinePass provider into the migration notice gate", async () => {
-		providerSettingsMocks.getLastUsedProviderSettings.mockReturnValue({
-			provider: "cline-pass",
-			model: "cline-pass/test-model",
-		});
-		Object.defineProperty(process.stdout, "isTTY", {
-			value: true,
-			configurable: true,
-		});
-		process.argv = ["bun", "src/index.ts"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(
-			migrationNoticeMocks.getClineCliMigrationNotice,
-		).toHaveBeenCalledWith(undefined, process.env, {
-			activeProviderId: "cline-pass",
-		});
-		expect(runtimeMocks.runInteractive).toHaveBeenCalledWith(
-			expect.objectContaining({
-				providerId: "cline-pass",
-			}),
-			expect.anything(),
-			undefined,
-			expect.objectContaining({
-				initialNotice: undefined,
-			}),
-		);
-	});
-
 	it("does not start OAuth before onboarding in interactive mode", async () => {
 		authMocks.isOAuthProvider.mockReturnValue(true);
 		authMocks.normalizeProviderId.mockReturnValue("cline");
@@ -792,7 +727,7 @@ describe("runCli lightweight command dispatch", () => {

 	it("uses the bundled catalog path for single-prompt runs", async () => {
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
+		process.argv = ["bun", "src/index.ts", "hello"];

 		const { runCli } = await import("./main");

@@ -983,7 +918,7 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});

-	it("seeds feature flag identity from persisted Cline account id before refreshing flags", async () => {
+	it("seeds feature flag identity from persisted Cline account id before checking flags", async () => {
 		const clineSettings = {
 			provider: "cline",
 			model: "anthropic/claude-sonnet-4.6",
@@ -1002,14 +937,11 @@ describe("runCli lightweight command dispatch", () => {
 		expect(
 			featureFlagMocks.setCliFeatureFlagsAccountContext,
 		).toHaveBeenCalledWith({ id: "acct-startup" });
-		// The account identity must be seeded before flags are refreshed/used so
-		// the background refresh resolves flags for the correct account.
 		expect(
 			featureFlagMocks.setCliFeatureFlagsAccountContext.mock
 				.invocationCallOrder[0],
 		).toBeLessThan(
-			featureFlagMocks.refreshCliFeatureFlagsInBackground.mock
-				.invocationCallOrder[0],
+			featureFlagMocks.getBooleanFlagEnabled.mock.invocationCallOrder[0],
 		);
 	});

@@ -1081,30 +1013,12 @@ describe("runCli lightweight command dispatch", () => {

 	it("skips hub prewarm for yolo runs", async () => {
 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--yolo", "say hello"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
-		expect(hubRuntimeMocks.ensureCliHubServer).not.toHaveBeenCalled();
-	});
-
-	it("rejects yolo runs with a single bare prompt token", async () => {
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
-		forcePromptModeInput();
 		process.argv = ["bun", "src/index.ts", "--yolo", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining("Unknown command or unquoted prompt: hello"),
-		);
-		expect(runtimeMocks.runAgent).not.toHaveBeenCalled();
+		expect(runtimeMocks.runAgent).toHaveBeenCalledTimes(1);
 		expect(hubRuntimeMocks.ensureCliHubServer).not.toHaveBeenCalled();
 	});

@@ -1128,12 +1042,12 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});

-	it("rejects /team without quoted task text", async () => {
+	it("shows /team usage in single-prompt mode when no task is provided", async () => {
 		mockState.runAgentCalls = 0;
 		runtimeMocks.runAgent.mockClear();
-		const consoleError = vi
-			.spyOn(console, "error")
-			.mockImplementation(() => undefined);
+		const stdoutWrite = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);

 		forcePromptModeInput();
 		process.argv = ["bun", "src/index.ts", "/team"];
@@ -1141,10 +1055,9 @@ describe("runCli lightweight command dispatch", () => {
 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
-		expect(process.exitCode).toBe(1);
 		expect(mockState.runAgentCalls).toBe(0);
-		expect(consoleError).toHaveBeenCalledWith(
-			expect.stringContaining("Unknown command or unquoted prompt: /team"),
+		expect(stdoutWrite).toHaveBeenCalledWith(
+			expect.stringContaining("Usage: /team <task description>"),
 		);
 	});

@@ -1153,14 +1066,14 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--thinking", "high", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--thinking", "high", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				thinking: true,
 				reasoningEffort: "high",
@@ -1169,40 +1082,19 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});

-	it("leaves thinking unset when --thinking is not provided", async () => {
+	it("leaves thinking disabled when --thinking is not provided", async () => {
 		mockState.runAgentCalls = 0;
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
+		process.argv = ["bun", "src/index.ts", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
-			expect.objectContaining({
-				thinking: undefined,
-				reasoningEffort: undefined,
-			}),
-			expect.anything(),
-		);
-	});
-
-	it("disables thinking when --thinking none is explicitly provided", async () => {
-		mockState.runAgentCalls = 0;
-		runtimeMocks.runAgent.mockClear();
-
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--thinking", "none", "say hello"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(mockState.runAgentCalls).toBe(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				thinking: false,
 				reasoningEffort: undefined,
@@ -1216,14 +1108,14 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--thinking", "--", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--thinking", "--", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				compaction: {
 					enabled: true,
@@ -1246,14 +1138,14 @@ describe("runCli lightweight command dispatch", () => {
 		});

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
+		process.argv = ["bun", "src/index.ts", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				thinking: true,
 				reasoningEffort: "high",
@@ -1262,32 +1154,6 @@ describe("runCli lightweight command dispatch", () => {
 		);
 	});

-	it("uses persisted disabled reasoning when --thinking is not provided", async () => {
-		mockState.runAgentCalls = 0;
-		runtimeMocks.runAgent.mockClear();
-		providerSettingsMocks.getProviderSettings.mockReturnValue({
-			provider: "cline",
-			model: "openai/gpt-5",
-			reasoning: { enabled: false },
-		});
-
-		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
-
-		const { runCli } = await import("./main");
-
-		await expect(runCli()).resolves.toBeUndefined();
-		expect(mockState.runAgentCalls).toBe(1);
-		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
-			expect.objectContaining({
-				thinking: false,
-				reasoningEffort: undefined,
-			}),
-			expect.anything(),
-		);
-	});
-
 	it("prefers explicit --thinking over persisted reasoning effort", async () => {
 		mockState.runAgentCalls = 0;
 		runtimeMocks.runAgent.mockClear();
@@ -1298,14 +1164,14 @@ describe("runCli lightweight command dispatch", () => {
 		});

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--thinking", "low", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--thinking", "low", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				thinking: true,
 				reasoningEffort: "low",
@@ -1319,13 +1185,13 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "say hello"];
+		process.argv = ["bun", "src/index.ts", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				compaction: {
 					enabled: true,
@@ -1341,19 +1207,13 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = [
-			"bun",
-			"src/index.ts",
-			"--compaction",
-			"basic",
-			"say hello",
-		];
+		process.argv = ["bun", "src/index.ts", "--compaction", "basic", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				compaction: {
 					enabled: true,
@@ -1369,19 +1229,13 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = [
-			"bun",
-			"src/index.ts",
-			"--compaction",
-			"agentic",
-			"say hello",
-		];
+		process.argv = ["bun", "src/index.ts", "--compaction", "agentic", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				compaction: {
 					enabled: true,
@@ -1431,13 +1285,13 @@ describe("runCli lightweight command dispatch", () => {
 		runtimeMocks.runAgent.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--compaction", "off", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--compaction", "off", "hello"];

 		const { runCli } = await import("./main");

 		await expect(runCli()).resolves.toBeUndefined();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				compaction: {
 					enabled: false,
@@ -1476,7 +1330,7 @@ describe("runCli lightweight command dispatch", () => {
 		authMocks.ensureOAuthProviderApiKey.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--json", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--json", "hello"];

 		const { runCli } = await import("./main");

@@ -1484,7 +1338,7 @@ describe("runCli lightweight command dispatch", () => {
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(authMocks.ensureOAuthProviderApiKey).not.toHaveBeenCalled();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				outputMode: "json",
 				apiKey: "",
@@ -1503,7 +1357,7 @@ describe("runCli lightweight command dispatch", () => {
 		authMocks.ensureOAuthProviderApiKey.mockClear();

 		forcePromptModeInput();
-		process.argv = ["bun", "src/index.ts", "--json", "say hello"];
+		process.argv = ["bun", "src/index.ts", "--json", "hello"];

 		const { runCli } = await import("./main");

@@ -1511,7 +1365,7 @@ describe("runCli lightweight command dispatch", () => {
 		expect(mockState.runAgentCalls).toBe(1);
 		expect(authMocks.ensureOAuthProviderApiKey).not.toHaveBeenCalled();
 		expect(runtimeMocks.runAgent).toHaveBeenCalledWith(
-			"say hello",
+			"hello",
 			expect.objectContaining({
 				outputMode: "json",
 				apiKey: "",
@@ -20,6 +20,7 @@ import {
 	CLI_COMPACTION_MODE_EXPECTED_TEXT,
 } from "./utils/compaction-mode";
 import {
+	getCliFeatureFlagsService,
 	refreshCliFeatureFlagsInBackground,
 	setCliFeatureFlagsAccountContext,
 } from "./utils/feature-flags";
@@ -41,7 +42,6 @@ import {
 	isOAuthProvider,
 	normalizeProviderId,
 } from "./utils/provider-auth";
-import { resolveCliReasoning } from "./utils/reasoning";
 import { rewriteTeamPrompt, TEAM_COMMAND_USAGE } from "./utils/team-command";
 import {
 	captureCliExtensionActivated,
@@ -112,23 +112,6 @@ export function resolveConfigDirArg(argv: string[]): string | undefined {
 	return undefined;
 }

-function collectOption(value: string, previous: string[] = []): string[] {
-	return [...previous, value];
-}
-
-// Shells strip quote characters before argv reaches us, so a prompt that was
-// typed in quotes is only observable when it remains one argv token with spaces.
-function promptArgLooksQuoted(arg: string | undefined): boolean {
-	return !!arg && /\s/.test(arg);
-}
-
-function writePromptArgError(args: string[]): void {
-	const renderedArgs = args.join(" ");
-	writeErr(
-		`Unknown command or unquoted prompt: ${renderedArgs}\nPrompt text must be passed as a single quoted argument, for example: cline "fix the tests". Use "cline --help" to see available commands and flags.`,
-	);
-}
-
 export async function runCli(): Promise<void> {
 	installStreamErrorGuards();
 	autoUpdateOnStartup();
@@ -421,24 +404,15 @@ export async function runCli(): Promise<void> {
 			"--transport <transport>",
 			"stdio, sse, http, streamable-http, or streamableHttp (default: stdio)",
 		)
-		.option("--header <header>", "Remote MCP request header", collectOption, [])
-		.option("--yes", "Install noninteractively without opening the wizard")
-		.option("--json", "Output as JSON")
 		.action(async (name: string, targetArgs: string[]) => {
 			const opts = mcpInstallCmd.opts<{
-				header?: string[];
-				json?: boolean;
 				transport?: string;
-				yes?: boolean;
 			}>();
 			const { runMcpInstallCommand } = await import("./commands/mcp");
 			ctx.exitCode = await runMcpInstallCommand({
 				name,
-				headers: opts.header,
 				targetArgs,
 				transport: opts.transport,
-				json: opts.json === true || program.opts().json === true,
-				yes: opts.yes === true,
 				io,
 			});
 		});
@@ -748,6 +722,13 @@ 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) {
@@ -834,13 +815,6 @@ export async function runCli(): Promise<void> {
 	if (args.hooksDir?.trim()) {
 		process.env.CLINE_HOOKS_DIR = args.hooksDir.trim();
 	}
-	if (args.prompt && !args.interactive) {
-		if (program.args.length > 1 || !promptArgLooksQuoted(program.args[0])) {
-			writePromptArgError(program.args);
-			process.exitCode = 1;
-			return;
-		}
-	}
 	setCurrentOutputMode(args.outputMode);
 	const defaultToolAutoApprove = true;
 	const effectiveToolAutoApprove =
@@ -955,7 +929,8 @@ export async function runCli(): Promise<void> {
 		refreshCliFeatureFlagsInBackground();
 		const lastUsedProviderSettings =
 			providerSettingsManager.getLastUsedProviderSettings({
-				isClinePassEnabled: true,
+				isClinePassEnabled:
+					getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
 			});
 		const provider = normalizeProviderId(
 			args.provider?.trim() || lastUsedProviderSettings?.provider || "cline",
@@ -1023,12 +998,19 @@ export async function runCli(): Promise<void> {
 			);
 		}
 		const knownModelIds = knownModels ? Object.keys(knownModels) : [];
-		const resolvedReasoning = resolveCliReasoning({
-			thinking: args.thinking,
-			thinkingExplicitlySet: args.thinkingExplicitlySet,
-			reasoningEffort: args.reasoningEffort,
-			persistedReasoning: selectedProviderSettings?.reasoning,
-		});
+		const persistedReasoning = selectedProviderSettings?.reasoning;
+		const persistedReasoningEffort = persistedReasoning?.effort;
+		const reasoningEffortFromSettings =
+			persistedReasoning?.enabled === false
+				? "none"
+				: persistedReasoningEffort && persistedReasoningEffort !== "none"
+					? persistedReasoningEffort
+					: persistedReasoning?.enabled === true
+						? "medium"
+						: "none";
+		const effectiveReasoningEffort = args.thinkingExplicitlySet
+			? (args.reasoningEffort ?? "none")
+			: (args.reasoningEffort ?? reasoningEffortFromSettings);
 		const { createCliLoggerAdapter } = await import("./logging/adapter");
 		const loggerAdapter = createCliLoggerAdapter({
 			runtime: "cli",
@@ -1064,8 +1046,11 @@ export async function runCli(): Promise<void> {
 			sandbox: sandboxEnabled,
 			sandboxDataDir,
 			verbose: args.verbose,
-			thinking: resolvedReasoning.thinking,
-			reasoningEffort: resolvedReasoning.reasoningEffort,
+			thinking: effectiveReasoningEffort !== "none",
+			reasoningEffort:
+				effectiveReasoningEffort === "none"
+					? undefined
+					: effectiveReasoningEffort,
 			outputMode: args.outputMode,
 			mode: args.mode,
 			logger: loggerAdapter.core,
@@ -1180,9 +1165,7 @@ export async function runCli(): Promise<void> {
 			if (!launchConfigView && process.stdin.isTTY && process.stdout.isTTY) {
 				const { getClineCliMigrationNotice, markClineCliMigrationNoticeShown } =
 					await import("./kanban-migration/notice");
-				initialNotice = getClineCliMigrationNotice(undefined, process.env, {
-					activeProviderId: provider,
-				});
+				initialNotice = getClineCliMigrationNotice();
 				if (initialNotice) {
 					markInitialNoticeShown = () => {
 						markClineCliMigrationNoticeShown();
@@ -2,15 +2,7 @@ import { createTool } from "@cline/shared";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { Config } from "../../utils/types";
 import { resolveSystemPrompt } from "../prompt";
-import {
-	ACT_MODE_CONTINUATION_PROMPT,
-	type AppliedModeChange,
-	applyInteractiveModeConfig,
-	createInteractiveModeSwitchTool,
-	createModeSwitchNoticeTracker,
-	type PendingModeChange,
-	sendTurnWithActModeContinuation,
-} from "./mode";
+import { applyInteractiveModeConfig } from "./mode";

 vi.mock("../prompt", () => ({
 	resolveSystemPrompt: vi.fn(async (input: { mode?: string }) => {
@@ -48,190 +40,6 @@ const switchToActModeTool = createTool({
 	execute: async () => "ok",
 });

-describe("createInteractiveModeSwitchTool", () => {
-	function makeSwitchTool(config: Config) {
-		const pendingModeChange: PendingModeChange = {
-			current: null,
-			source: null,
-		};
-		const tuiModeChanged: {
-			current: ((mode: "plan" | "act") => void) | null;
-		} = { current: vi.fn() };
-		const tool = createInteractiveModeSwitchTool({
-			config,
-			pendingModeChange,
-			tuiModeChanged,
-		});
-		return { tool, pendingModeChange, tuiModeChanged };
-	}
-
-	const toolContext = {
-		agentId: "agent-1",
-		iteration: 0,
-	} as const;
-
-	it("completes the run so the model never continues with plan-mode tools", () => {
-		const config = makeConfig();
-		config.mode = "plan";
-		const { tool } = makeSwitchTool(config);
-
-		// The act-mode tool set only exists after the session rebuild, which
-		// happens between runs; without completesRun the model keeps working
-		// with stale plan-mode tools after being told the switch succeeded.
-		expect(tool.lifecycle?.completesRun).toBe(true);
-	});
-
-	it("queues a tool-sourced mode change and notifies the TUI", async () => {
-		const config = makeConfig();
-		config.mode = "plan";
-		const { tool, pendingModeChange, tuiModeChanged } = makeSwitchTool(config);
-
-		const result = await tool.execute({}, toolContext);
-
-		expect(pendingModeChange).toEqual({ current: "act", source: "tool" });
-		expect(tuiModeChanged.current).toHaveBeenCalledWith("act");
-		expect(result).toContain("successfully switched to act mode");
-	});
-
-	it("errors instead of completing the run when already in act mode", async () => {
-		const config = makeConfig();
-		config.mode = "act";
-		const { tool, pendingModeChange } = makeSwitchTool(config);
-
-		// A successful result would end the run via completesRun even though
-		// nothing changed, so the no-op case must surface as a tool error.
-		await expect(tool.execute({}, toolContext)).rejects.toThrow(
-			"Already in act mode.",
-		);
-		expect(pendingModeChange.current).toBeNull();
-	});
-});
-
-describe("sendTurnWithActModeContinuation", () => {
-	type TurnResult = { finishReason: string; iterations: number };
-
-	function makeHarness(input: {
-		initial: TurnResult | undefined;
-		continuation?: TurnResult | undefined;
-		modeChanges: Array<AppliedModeChange | undefined>;
-	}) {
-		const applied = [...input.modeChanges];
-		const sendContinuationTurn = vi.fn(async () => input.continuation);
-		return {
-			sendContinuationTurn,
-			run: () =>
-				sendTurnWithActModeContinuation<TurnResult>({
-					sendInitialTurn: async () => input.initial,
-					sendContinuationTurn,
-					applyPendingModeChange: async () => applied.shift(),
-				}),
-		};
-	}
-
-	it("continues the plan after a tool-initiated switch completes the run", async () => {
-		const { run, sendContinuationTurn } = makeHarness({
-			initial: { finishReason: "completed", iterations: 2 },
-			continuation: { finishReason: "completed", iterations: 3 },
-			modeChanges: [{ mode: "act", source: "tool" }, undefined],
-		});
-
-		const result = await run();
-
-		expect(sendContinuationTurn).toHaveBeenCalledWith(
-			ACT_MODE_CONTINUATION_PROMPT,
-		);
-		expect(result).toEqual({ finishReason: "completed", iterations: 5 });
-	});
-
-	it("does not continue after a UI-initiated mode change", async () => {
-		// A Tab toggle can race a natural turn completion; a "ui" source must
-		// never start executing a plan the user did not approve.
-		const { run, sendContinuationTurn } = makeHarness({
-			initial: { finishReason: "completed", iterations: 2 },
-			modeChanges: [{ mode: "act", source: "ui" }],
-		});
-
-		const result = await run();
-
-		expect(sendContinuationTurn).not.toHaveBeenCalled();
-		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
-	});
-
-	it("does not continue when the switch turn was aborted", async () => {
-		const { run, sendContinuationTurn } = makeHarness({
-			initial: { finishReason: "aborted", iterations: 1 },
-			modeChanges: [{ mode: "act", source: "tool" }],
-		});
-
-		const result = await run();
-
-		expect(sendContinuationTurn).not.toHaveBeenCalled();
-		expect(result).toEqual({ finishReason: "aborted", iterations: 1 });
-	});
-
-	it("does not continue when no mode change was pending", async () => {
-		const { run, sendContinuationTurn } = makeHarness({
-			initial: { finishReason: "completed", iterations: 2 },
-			modeChanges: [undefined],
-		});
-
-		const result = await run();
-
-		expect(sendContinuationTurn).not.toHaveBeenCalled();
-		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
-	});
-
-	it("returns the switch turn result when the continuation yields nothing", async () => {
-		const { run } = makeHarness({
-			initial: { finishReason: "completed", iterations: 2 },
-			continuation: undefined,
-			modeChanges: [{ mode: "act", source: "tool" }, undefined],
-		});
-
-		const result = await run();
-
-		expect(result).toEqual({ finishReason: "completed", iterations: 2 });
-	});
-});
-
-describe("createModeSwitchNoticeTracker", () => {
-	it("records a switch and clears it on consume", () => {
-		const tracker = createModeSwitchNoticeTracker();
-
-		tracker.record("act", "plan");
-
-		expect(tracker.consume()).toEqual({ from: "act", to: "plan" });
-		expect(tracker.consume()).toBeNull();
-	});
-
-	it("cancels a round trip that returns to the mode the model last saw", () => {
-		const tracker = createModeSwitchNoticeTracker();
-
-		tracker.record("act", "plan");
-		tracker.record("plan", "act");
-
-		expect(tracker.consume()).toBeNull();
-	});
-
-	it("keeps the original starting mode across chained switches", () => {
-		const tracker = createModeSwitchNoticeTracker();
-
-		tracker.record("act", "plan");
-		tracker.record("plan", "act");
-		tracker.record("act", "plan");
-
-		expect(tracker.consume()).toEqual({ from: "act", to: "plan" });
-	});
-
-	it("ignores a no-op switch", () => {
-		const tracker = createModeSwitchNoticeTracker();
-
-		tracker.record("plan", "plan");
-
-		expect(tracker.consume()).toBeNull();
-	});
-});
-
 describe("applyInteractiveModeConfig", () => {
 	beforeEach(() => {
 		vi.mocked(resolveSystemPrompt).mockClear();
@@ -2,42 +2,17 @@ import { createTool } from "@cline/shared";
 import type { Config } from "../../utils/types";
 import { resolveSystemPrompt } from "../prompt";

-export type InteractiveUiMode = "plan" | "act";
-
-/**
- * Pending mode change plus who requested it. The switch_to_act_mode tool and
- * the TUI mode toggle share this slot, but only a tool-initiated switch means
- * "the user approved the plan" -- a UI toggle that lands as a turn finishes
- * must not trigger plan execution.
- */
-export type PendingModeChange = {
-	current: InteractiveUiMode | null;
-	source: "tool" | "ui" | null;
-};
-
-export type AppliedModeChange = {
-	mode: InteractiveUiMode;
-	source: "tool" | "ui";
-};
-
-/**
- * Canned prompt that drives the auto-continue turn after the model calls
- * switch_to_act_mode. It is a synthetic user message, so transcript hydration
- * filters it out of the chat display.
- */
-export const ACT_MODE_CONTINUATION_PROMPT =
-	"The user approved switching to act mode. Continue with the approved plan now.";
+type InteractiveUiMode = "plan" | "act";

 export function createInteractiveModeSwitchTool(input: {
 	config: Config;
-	pendingModeChange: PendingModeChange;
+	pendingModeChange: { current: InteractiveUiMode | null };
 	tuiModeChanged: { current: ((mode: InteractiveUiMode) => void) | null };
 }) {
 	return createTool({
 		name: "switch_to_act_mode",
 		description:
-			"Switch from plan mode to act mode. Switching to act mode immediately starts executing the plan, so only call this after the user has explicitly approved the plan in a message sent AFTER you presented it (e.g. 'looks good', 'go ahead', 'switch to act mode'). " +
-			"Never call this in the same turn you present a plan, never call it proactively, and never treat the original task request as approval.",
+			"Switch from plan mode to act mode. Call this after the user has confirmed they want to proceed with the plan. Do not call this proactively or before the user has agreed.",
 		inputSchema: {
 			type: "object",
 			properties: {},
@@ -45,101 +20,17 @@ export function createInteractiveModeSwitchTool(input: {
 		timeoutMs: 5000,
 		retryable: false,
 		maxRetries: 0,
-		// The act-mode tools only exist after the session is rebuilt with the
-		// new mode config, which can't happen mid-run. End the run right after
-		// the tool result so the model never keeps working with plan-mode tools
-		// it was just told it no longer has; run-interactive applies the pending
-		// change and auto-continues on the rebuilt session.
-		lifecycle: {
-			completesRun: true,
-		},
 		execute: async () => {
 			if (input.config.mode === "act") {
-				// Throw instead of returning: a successful result would end the
-				// run via completesRun even though nothing changed.
-				throw new Error("Already in act mode.");
+				return "Already in act mode.";
 			}
 			input.pendingModeChange.current = "act";
-			input.pendingModeChange.source = "tool";
 			input.tuiModeChanged.current?.("act");
 			return "You successfully switched to act mode, proceed with the plan. You now have access to editing files and running commands. (The switch_to_act_mode tool is only available in plan mode.)";
 		},
 	});
 }

-/**
- * Runs one interactive turn, and when the model ended it by calling
- * switch_to_act_mode, continues the approved plan on the rebuilt act-mode
- * session instead of waiting for the user to prompt again.
- *
- * The continuation only fires for a tool-initiated switch on a turn that
- * finished "completed": a UI toggle mid-run aborts the turn, and even if the
- * toggle races a natural completion its source is "ui", so the user's Tab
- * press can never start executing a plan they did not approve.
- */
-export async function sendTurnWithActModeContinuation<
-	T extends { finishReason: string; iterations: number },
->(input: {
-	sendInitialTurn: () => Promise<T | undefined>;
-	sendContinuationTurn: (prompt: string) => Promise<T | undefined>;
-	applyPendingModeChange: () => Promise<AppliedModeChange | undefined>;
-}): Promise<T | undefined> {
-	const result = await input.sendInitialTurn();
-	const switched = await input.applyPendingModeChange();
-	if (
-		switched?.mode !== "act" ||
-		switched.source !== "tool" ||
-		result?.finishReason !== "completed"
-	) {
-		return result;
-	}
-	const continuation = await input.sendContinuationTurn(
-		ACT_MODE_CONTINUATION_PROMPT,
-	);
-	// Honor a mode toggle made while the continuation was running.
-	await input.applyPendingModeChange();
-	if (!continuation) {
-		return result;
-	}
-	return {
-		...continuation,
-		iterations: result.iterations + continuation.iterations,
-	};
-}
-
-export type ModeSwitchNotice = {
-	from: InteractiveUiMode;
-	to: InteractiveUiMode;
-};
-
-/**
- * Tracks a user-initiated mode switch so the next user message can carry a
- * <mode_notice> marking it. Only UI toggles are recorded: the model-initiated
- * switch_to_act_mode path already announces itself via the continuation
- * prompt. A round trip (plan -> act -> plan before sending anything) cancels
- * out, since the mode the model last saw never effectively changed.
- */
-export function createModeSwitchNoticeTracker() {
-	let pending: ModeSwitchNotice | null = null;
-	return {
-		record(from: InteractiveUiMode, to: InteractiveUiMode): void {
-			if (from === to) {
-				return;
-			}
-			if (pending) {
-				pending = pending.from === to ? null : { from: pending.from, to };
-				return;
-			}
-			pending = { from, to };
-		},
-		consume(): ModeSwitchNotice | null {
-			const notice = pending;
-			pending = null;
-			return notice;
-		},
-	};
-}
-
 export async function applyInteractiveModeConfig(input: {
 	config: Config;
 	mode: InteractiveUiMode;
@@ -210,40 +210,6 @@ describe("createInteractiveSessionRuntime", () => {
 		expect(runtime.getActiveSessionId()).toBe("session-2");
 	});

-	it("holds concurrent ensureReady during a restart instead of booting an empty session", async () => {
-		const manager = makeManager();
-		const runtime = makeRuntime(manager);
-
-		await runtime.ensureReady();
-		expect(runtime.getActiveSessionId()).toBe("session-1");
-
-		// Keep the replacement session's start in flight so the restart window
-		// (old session stopped, no active session yet) stays open.
-		const gate = deferred<void>();
-		manager.start.mockImplementationOnce(async () => {
-			await gate.promise;
-			return {
-				sessionId: "session-restarted",
-				manifest: { session_id: "session-restarted" },
-			};
-		});
-
-		const restart = runtime.restartWithCurrentMessages();
-		await vi.waitFor(() => {
-			expect(manager.start).toHaveBeenCalledTimes(2);
-		});
-
-		// A message submitted mid-restart (e.g. right after a plan/act toggle)
-		// calls ensureReady; it must wait for the restart instead of booting a
-		// blank session that races the replacement for the active slot.
-		const ready = runtime.ensureReady();
-		gate.resolve();
-		await Promise.all([restart, ready]);
-
-		expect(manager.start).toHaveBeenCalledTimes(2);
-		expect(runtime.getActiveSessionId()).toBe("session-restarted");
-	});
-
 	it("adds a live interactive approval policy hook to started sessions", async () => {
 		const manager = makeManager();
 		const upstreamBeforeTool = vi.fn(async () => ({
@@ -399,48 +365,6 @@ describe("createInteractiveSessionRuntime", () => {
 		expect(runtime.getActiveSessionId()).toBe("session-2");
 	});

-	it("recovers empty read-driven restarts when the active interactive session disappeared", async () => {
-		const manager = makeManager();
-		manager.readMessages.mockRejectedValueOnce(
-			new SessionNotFoundError("session-1"),
-		);
-		const runtime = makeRuntime(manager);
-
-		await runtime.ensureReady();
-		await runtime.restartWithCurrentMessages();
-
-		expect(manager.readMessages).toHaveBeenCalledWith("session-1");
-		expect(manager.start).toHaveBeenCalledTimes(2);
-		expect(manager.start).toHaveBeenNthCalledWith(
-			2,
-			expect.objectContaining({
-				initialMessages: [],
-			}),
-		);
-		expect(runtime.getActiveSessionId()).toBe("session-2");
-	});
-
-	it("does not restart with stale messages when another operation changes the active session during a read", async () => {
-		const manager = makeManager();
-		let runtime!: ReturnType<typeof makeRuntime>;
-		manager.readMessages.mockImplementationOnce(async () => {
-			await runtime.restartEmpty();
-			return [
-				{
-					role: "user" as const,
-					content: [{ type: "text" as const, text: "stale" }],
-				},
-			];
-		});
-		runtime = makeRuntime(manager);
-
-		await runtime.ensureReady();
-		await runtime.restartWithCurrentMessages();
-
-		expect(manager.start).toHaveBeenCalledTimes(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[]>();
@@ -49,13 +49,6 @@ type CurrentTurnResult = Awaited<ReturnType<CliCore["send"]>>;
 type AskQuestionRef = {
 	current: ((question: string, options: string[]) => Promise<string>) | null;
 };
-type CurrentMessagesRead =
-	| { messages: Message[]; status: "read" }
-	| { messages: Message[]; status: "recovered" }
-	| { messages: Message[]; status: "stale" };
-type MissingSessionRecovery = {
-	messages: Message[];
-};
 type ToolPolicyResolver = (
 	toolName: string,
 ) => NonNullable<Config["toolPolicies"]>[string];
@@ -110,9 +103,7 @@ export function createInteractiveSessionRuntime(input: {
 	let shutdownRequested = false;
 	let activeSessionId = "";
 	let abortRequested = false;
-	let missingSessionRecoveryPromise:
-		| Promise<MissingSessionRecovery>
-		| undefined;
+	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;
@@ -284,34 +275,14 @@ export function createInteractiveSessionRuntime(input: {
 		return await startupPromise;
 	};

-	const readCurrentMessages = async (): Promise<CurrentMessagesRead> => {
-		const manager = sessionManager;
-		const sessionId = activeSessionId;
-		if (!manager || !sessionId) {
-			return { messages: [], status: "read" };
-		}
-		try {
-			const messages = (await manager.readMessages(sessionId)) ?? [];
-			return {
-				messages,
-				status: activeSessionId === sessionId ? "read" : "stale",
-			};
-		} catch (error) {
-			if (
-				abortRequested ||
-				shutdownRequested ||
-				!isSessionNotFoundError(error)
-			) {
-				throw error;
-			}
-			const recovery = await recoverMissingActiveSession(error);
-			return { messages: recovery.messages, status: "recovered" };
+	const readCurrentMessages = async (): Promise<Message[]> => {
+		if (!sessionManager || !activeSessionId) {
+			return [];
 		}
+		return (await sessionManager.readMessages(activeSessionId)) ?? [];
 	};

-	const recoverMissingActiveSession = async (
-		error: unknown,
-	): Promise<MissingSessionRecovery> => {
+	const recoverMissingActiveSession = async (error: unknown): Promise<void> => {
 		if (missingSessionRecoveryPromise) {
 			return await missingSessionRecoveryPromise;
 		}
@@ -319,7 +290,7 @@ export function createInteractiveSessionRuntime(input: {
 			const manager = sessionManager;
 			const missingSessionId = activeSessionId;
 			if (!manager || !missingSessionId || shutdownRequested) {
-				return { messages: [] };
+				return;
 			}
 			const messages = await manager
 				.readMessages(missingSessionId)
@@ -336,7 +307,6 @@ export function createInteractiveSessionRuntime(input: {
 			startupError = undefined;
 			clearActiveSession();
 			await startFreshSession(messages);
-			return { messages };
 		})().finally(() => {
 			missingSessionRecoveryPromise = undefined;
 		});
@@ -383,41 +353,15 @@ export function createInteractiveSessionRuntime(input: {
 	): Promise<void> => {
 		sessionStartGeneration += 1;
 		pendingResumeSessionId = undefined;
+		startupPromise = undefined;
 		startupError = undefined;
-		// Publish the restart as the in-flight startup. Teardown leaves a window
-		// with no active session, and without this barrier a concurrent
-		// ensureReady() (e.g. a message submitted right after a plan/act toggle)
-		// reads that window as "no session" and boots an empty session that then
-		// races the restarted one for the active slot.
-		const restart = (async () => {
-			await stopCurrentSession();
-			clearActiveSession();
-			await startFreshSession(messages, sessionMetadata);
-		})().catch((error) => {
-			startupError = error;
-			throw error;
-		});
-		startupPromise = restart;
-		try {
-			await restart;
-		} finally {
-			// Restore the pre-restart steady state (startupPromise unset) so a
-			// failed restart stays retryable by the next ensureReady(). A newer
-			// startup that already replaced the barrier is left alone.
-			if (startupPromise === restart) {
-				startupPromise = undefined;
-			}
-		}
+		await stopCurrentSession();
+		clearActiveSession();
+		await startFreshSession(messages, sessionMetadata);
 	};

 	const restartWithCurrentMessages = async (): Promise<void> => {
-		const { messages, status } = await readCurrentMessages();
-		if (status !== "read") {
-			// If reading recovered a missing hub session, the current messages are
-			// already in the replacement session. If the read is stale, another async
-			// operation changed the active session while this read was in flight.
-			return;
-		}
+		const messages = await readCurrentMessages();
 		await restartWithMessages(messages);
 	};

@@ -566,13 +510,7 @@ export function createInteractiveSessionRuntime(input: {
 		if (!sessionManager) {
 			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
 		}
-		const { messages, status } = await readCurrentMessages();
-		if (status === "stale" || (status === "recovered" && !activeSessionId)) {
-			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
-		}
-		// If reading messages recovered the session, `messages` are the same messages
-		// used to seed the replacement session, so it is safe to compact the current
-		// active session with them.
+		const messages = await readCurrentMessages();
 		const messagesBefore = messages.length;
 		if (messagesBefore === 0) {
 			return { messagesBefore: 0, messagesAfter: 0, compacted: false };
@@ -613,10 +551,7 @@ export function createInteractiveSessionRuntime(input: {
 			return undefined;
 		}
 		const checkpointHistory = readSessionCheckpointHistory(sessionRecord);
-		const { messages, status } = await readCurrentMessages();
-		if (status !== "read") {
-			return undefined;
-		}
+		const messages = await readCurrentMessages();
 		return { messages, checkpointHistory };
 	};

@@ -9,10 +9,6 @@ import {
 import { type AgentMode, buildClineSystemPrompt } from "@cline/shared";
 import { isImagePath, loadImageAsDataUrl } from "../utils/image-attachments";

-const MODE_TAG_INSTRUCTIONS = `# Plan / Act Modes
-
-User messages arrive wrapped in a <user_input mode="..."> tag. The mode attribute is the interaction mode the user was in when they sent that message: "plan" means plan-mode constraints applied (explore, analyze, and align on a plan -- no edits or state-changing commands), while "act" (or "yolo") means implementation was allowed. If the mode attribute changes between messages, the user switched modes -- the newest message's mode is what governs right now, regardless of what earlier messages allowed. A <mode_notice> block inside a message marks exactly when such a switch happened.`;
-
 const PLAN_MODE_INSTRUCTIONS = `# Plan Mode

 You are in Plan mode. Your role is to explore, analyze, and plan -- not to execute.
@@ -24,7 +20,7 @@ You are in Plan mode. Your role is to explore, analyze, and plan -- not to execu
 - Do NOT edit files, write code, run destructive commands, or make any changes
 - Do NOT implement anything -- focus on understanding and alignment first

-Once the user has reviewed your plan and explicitly approved it in a follow-up message, use the switch_to_act_mode tool to switch to act mode and begin implementation. Calling switch_to_act_mode immediately starts execution, so never call it in the same turn you present a plan and never treat the original task request as approval -- end your turn after presenting the plan and wait for the user's response.`;
+When the user aligns on a plan and is ready to proceed, use the switch_to_act_mode tool to switch to act mode and begin implementation.`;

 export async function resolveSystemPrompt(input: {
 	cwd: string;
@@ -35,13 +31,10 @@ export async function resolveSystemPrompt(input: {
 }): Promise<string> {
 	const metadata = await buildWorkspaceMetadata(input.cwd);
 	let rules = mergeRulesForSystemPrompt(undefined, input.rules);
-	// Both modes get the mode-tag explanation: after a switch, the transcript
-	// still contains messages tagged with the other mode.
-	rules = rules
-		? `${rules}\n\n${MODE_TAG_INSTRUCTIONS}`
-		: MODE_TAG_INSTRUCTIONS;
 	if (input.mode === "plan") {
-		rules = `${rules}\n\n${PLAN_MODE_INSTRUCTIONS}`;
+		rules = rules
+			? `${rules}\n\n${PLAN_MODE_INSTRUCTIONS}`
+			: PLAN_MODE_INSTRUCTIONS;
 	}
 	return buildClineSystemPrompt({
 		ide: "Terminal Shell",
@@ -39,10 +39,7 @@ const sessionEventsMocks = vi.hoisted(() => ({

 const CLINE_PASS_SUBSCRIPTION_URL =
 	"https://app.cline.bot/dashboard/subscription?personal=true";
-const CLI_SUBSCRIPTION_URL =
-	"https://app.cline.bot/promo?code=CLI-8OFF&personal=true";
-const SDK_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 CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${CLI_SUBSCRIPTION_URL}`;
+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";

@@ -552,7 +549,7 @@ describe("runAgent", () => {
 	});

 	it("renders ClinePass subscription errors with friendly copy when startup throws", async () => {
-		const error = new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE);
+		const error = new Error(CLINE_PASS_SUBSCRIPTION_MESSAGE);
 		error.name = "ClineNotSubscribedError";
 		sessionManagerMocks.start.mockRejectedValue(error);

@@ -580,7 +577,7 @@ describe("runAgent", () => {

 		expect(process.exitCode).toBe(1);
 		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+			CLINE_PASS_SUBSCRIPTION_MESSAGE,
 		);
 	});

@@ -658,7 +655,7 @@ describe("runAgent", () => {
 			messagesPath: "/tmp/messages.json",
 			manifest: { session_id: "session-1" },
 			result: {
-				text: SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+				text: CLINE_PASS_SUBSCRIPTION_MESSAGE,
 				usage: {
 					inputTokens: 0,
 					outputTokens: 0,
@@ -702,73 +699,10 @@ describe("runAgent", () => {

 		expect(process.exitCode).toBe(1);
 		expect(outputMocks.writeErr).toHaveBeenCalledWith(
-			CLI_CLINE_PASS_SUBSCRIPTION_MESSAGE,
+			CLINE_PASS_SUBSCRIPTION_MESSAGE,
 		);
 	});

-	it("does not duplicate ClinePass subscription errors already displayed by agent events", async () => {
-		const startedAt = new Date("2026-03-22T00:00:00.000Z");
-		const endedAt = new Date("2026-03-22T00:00:01.000Z");
-		sessionManagerMocks.start.mockImplementation(async () => {
-			sessionEventsMocks.listener?.({
-				type: "error",
-				error: new Error(SDK_CLINE_PASS_SUBSCRIPTION_MESSAGE),
-				recoverable: false,
-			});
-
-			return {
-				sessionId: "session-1",
-				manifestPath: "/tmp/manifest.json",
-				messagesPath: "/tmp/messages.json",
-				manifest: { session_id: "session-1" },
-				result: {
-					text: SDK_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).not.toHaveBeenCalled();
-	});
-
 	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");
@@ -204,9 +204,7 @@ export async function runAgent(
 			(!event.recoverable || config.verbose) &&
 			event.error.message.trim()
 		) {
-			displayedErrorMessages.add(
-				formatCliErrorMessage(event.error.message).trim(),
-			);
+			displayedErrorMessages.add(event.error.message.trim());
 		}
 		handleEvent(event, config);
 	};
@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveReasoningForModelChange } from "./run-interactive";
-
-describe("resolveReasoningForModelChange", () => {
-	it("persists disabled reasoning only when thinking is explicitly false", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: false, reasoningEffort: undefined },
-				{ reasoning: { enabled: true, effort: "high" } },
-			),
-		).toEqual({ enabled: false });
-	});
-
-	it("persists enabled reasoning with the selected effort", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: true, reasoningEffort: "low" },
-				{ reasoning: { enabled: false } },
-			),
-		).toEqual({ enabled: true, effort: "low" });
-	});
-
-	it("persists enabled reasoning when thinking is explicitly true without effort", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: true, reasoningEffort: undefined },
-				{ reasoning: { enabled: false } },
-			),
-		).toEqual({ enabled: true });
-	});
-
-	it("preserves existing reasoning when thinking is unset", () => {
-		expect(
-			resolveReasoningForModelChange(
-				{ thinking: undefined, reasoningEffort: undefined },
-				{ reasoning: { enabled: true, effort: "medium" } },
-			),
-		).toEqual({ enabled: true, effort: "medium" });
-	});
-});
@@ -4,12 +4,10 @@ import {
 	ProviderSettingsManager,
 	type UserInstructionConfigService,
 } from "@cline/core";
-import { formatModeSwitchNotice } from "@cline/shared";
 import type { CliMigrationNotice } from "../kanban-migration/notice";
 import { logCliError } from "../logging/errors";
 import {
 	loadClineAccountSnapshot,
-	loadIndividualSubscriptionPlans,
 	onProviderChange,
 	switchClineAccount,
 } from "../tui/cline-account";
@@ -53,35 +51,12 @@ import {
 	type InteractiveExitSummary,
 } from "./interactive/exit-summary";
 import { createMistakeLimitDecisionResolver } from "./interactive/mistakes";
-import {
-	type AppliedModeChange,
-	createInteractiveModeSwitchTool,
-	createModeSwitchNoticeTracker,
-	type PendingModeChange,
-	sendTurnWithActModeContinuation,
-} from "./interactive/mode";
+import { createInteractiveModeSwitchTool } from "./interactive/mode";
 import { assertInteractivePreflight } from "./interactive/preflight";
 import { createInteractiveSessionRuntime } from "./interactive/session-runtime";
 import { buildUserInputMessage } from "./prompt";
 import { getUIEventEmitter } from "./session-events";

-type ModelChangeReasoningConfig = {
-	thinking?: boolean;
-	reasoningEffort?: Config["reasoningEffort"];
-};
-
-export function resolveReasoningForModelChange(
-	config: ModelChangeReasoningConfig,
-	existing: Pick<ProviderSettings, "reasoning">,
-): ProviderSettings["reasoning"] {
-	if (config.thinking === false) return { enabled: false };
-	if (config.reasoningEffort) {
-		return { enabled: true, effort: config.reasoningEffort };
-	}
-	if (config.thinking === true) return { enabled: true };
-	return existing.reasoning;
-}
-
 export async function runInteractive(
 	config: Config,
 	userInstructionService?: UserInstructionConfigService,
@@ -156,9 +131,8 @@ export async function runInteractive(
 		tuiAskQuestion,
 	} = createInteractiveApprovalController(config);

-	const pendingModeChange: PendingModeChange = {
+	const pendingModeChange: { current: "plan" | "act" | null } = {
 		current: null,
-		source: null,
 	};
 	const tuiModeChanged: {
 		current: ((mode: "plan" | "act") => void) | null;
@@ -212,7 +186,6 @@ export async function runInteractive(
 	});
 	let modeChangePromise: Promise<void> | undefined;
 	let modeChangeTarget: "plan" | "act" | undefined;
-	const modeSwitchNotice = createModeSwitchNoticeTracker();

 	const isInteractiveMode = (mode: unknown): mode is "plan" | "act" =>
 		mode === "plan" || mode === "act";
@@ -227,11 +200,7 @@ export async function runInteractive(
 				await modeChangePromise;
 			}
 			await sessionRuntime.ensureReady();
-			const from = config.mode;
 			await sessionRuntime.applyMode(mode);
-			if (isInteractiveMode(from)) {
-				modeSwitchNotice.record(from, mode);
-			}
 		})().finally(() => {
 			if (modeChangePromise === next) {
 				modeChangePromise = undefined;
@@ -402,7 +371,7 @@ export async function runInteractive(
 		? async () => {
 				try {
 					await sessionRuntime.ensureReady();
-					const { messages } = await sessionRuntime.readCurrentMessages();
+					const messages = await sessionRuntime.readCurrentMessages();
 					const usage = await sessionRuntime.getAccumulatedUsage({
 						inputTokens: 0,
 						outputTokens: 0,
@@ -441,12 +410,6 @@ export async function runInteractive(
 				config,
 				clineApiBaseUrl: options?.clineApiBaseUrl,
 			}),
-		loadIndividualSubscriptionPlans: async () =>
-			await loadIndividualSubscriptionPlans({
-				config,
-				clineApiBaseUrl: options?.clineApiBaseUrl,
-				clineProviderSettings: options?.clineProviderSettings,
-			}),
 		switchClineAccount: async (organizationId) =>
 			await switchClineAccount({
 				config,
@@ -533,50 +496,27 @@ export async function runInteractive(
 					...(attachments?.userImages ?? []),
 					...userImages,
 				];
-				// Mark a preceding user-initiated mode switch on this message so
-				// the model sees exactly when the rules changed, instead of only
-				// inferring it from the user_input mode attribute flipping.
-				const switchNotice = modeSwitchNotice.consume();
-				const noticedUserInput = switchNotice
-					? `${formatModeSwitchNotice(switchNotice.from, switchNotice.to)}\n${userInput}`
-					: userInput;

-				const applyPendingModeChange = async (): Promise<
-					AppliedModeChange | undefined
-				> => {
+				const applyPendingModeChange = async () => {
 					if (!pendingModeChange.current) return undefined;
-					const applied: AppliedModeChange = {
-						mode: pendingModeChange.current,
-						source: pendingModeChange.source ?? "ui",
-					};
+					const newMode = pendingModeChange.current;
 					pendingModeChange.current = null;
-					pendingModeChange.source = null;
-					const from = config.mode;
-					await sessionRuntime.applyMode(applied.mode);
-					tuiModeChanged.current?.(applied.mode);
-					// The switch_to_act_mode path announces itself through the
-					// continuation prompt; only UI toggles need a notice.
-					if (applied.source === "ui" && isInteractiveMode(from)) {
-						modeSwitchNotice.record(from, applied.mode);
-					}
-					return applied;
+					await sessionRuntime.applyMode(newMode);
+					tuiModeChanged.current?.(newMode);
+					return newMode;
 				};

-				const result = await sendTurnWithActModeContinuation({
-					sendInitialTurn: () =>
-						sessionRuntime.sendCurrentTurn({
-							prompt: noticedUserInput,
-							mode,
-							userImages:
-								mergedUserImages.length > 0 ? mergedUserImages : undefined,
-							userFiles: userFiles.length > 0 ? userFiles : undefined,
-							delivery,
-						}),
-					sendContinuationTurn: (prompt) =>
-						sessionRuntime.sendCurrentTurn({ prompt, mode: "act" }),
-					applyPendingModeChange,
+				const result = await sessionRuntime.sendCurrentTurn({
+					prompt: userInput,
+					mode,
+					userImages:
+						mergedUserImages.length > 0 ? mergedUserImages : undefined,
+					userFiles: userFiles.length > 0 ? userFiles : undefined,
+					delivery,
 				});

+				await applyPendingModeChange();
+
 				if (!result) {
 					return {
 						usage: { inputTokens: 0, outputTokens: 0 },
@@ -678,7 +618,6 @@ export async function runInteractive(
 			if (!isInteractiveMode(mode)) return;
 			if (isRunning) {
 				pendingModeChange.current = mode;
-				pendingModeChange.source = "ui";
 				sessionRuntime.abortAll();
 				return;
 			}
@@ -698,11 +637,12 @@ export async function runInteractive(
 			) ?? {
 				provider: config.providerId,
 			};
-			const reasoning = resolveReasoningForModelChange(config, existing);
 			providerSettingsManager.saveProviderSettings({
 				...existing,
 				model: config.modelId,
-				...(reasoning === undefined ? {} : { reasoning }),
+				reasoning: config.reasoningEffort
+					? { enabled: true, effort: config.reasoningEffort }
+					: { enabled: false },
 			});
 			await sessionRuntime.restartWithCurrentMessages();
 		},
@@ -5,7 +5,6 @@ import {
 	type ToolResultContent,
 	type ToolUseContent,
 } from "@cline/shared";
-import { formatStructuredCommand } from "../utils/helpers";

 export interface ConversationHistory {
 	version: number;
@@ -846,15 +845,15 @@ function renderDiffHTML(
 }

 function renderCommandsHTML(
-	commands: unknown[],
+	commands: string[],
 	_result?: ToolResultContent,
 ): string {
 	return commands
 		.map(
-			(command, i) => `
+			(cmd, i) => `
    <div class="command-block">
      <div class="command-label">Command ${i + 1}</div>
-      <code>${escapeHtml(formatStructuredCommand(command))}</code>
+      <code>${escapeHtml(cmd)}</code>
    </div>
  `,
 		)
@@ -3,11 +3,7 @@ import { CLINE_BIN } from "./helpers/constants.js";
 import { clineEnv } from "./helpers/env.js";
 import { expectVisible } from "./helpers/terminal.js";

-// Wide enough that long option descriptions (e.g. --thinking) render on a
-// single line. At narrower widths commander wraps them, splitting phrases
-// like "omitted leaves provider default" across lines so the contiguous
-// getByText assertions below fail.
-const HELP_TERMINAL = { columns: 200, rows: 50 };
+const HELP_TERMINAL = { columns: 120, rows: 50 };

 // ===========================================================================
 // Root-level flag descriptions
@@ -27,9 +23,7 @@ test.describe("root flag descriptions", () => {
 			"verbose output",
 			"Working directory",
 			"Configuration directory",
-			"Set reasoning effort:",
-			"Bare --thinking uses medium",
-			"omitted leaves provider default",
+			"Set reasoning effort level",
 			"consecutive mistakes",
 			"Output messages as JSON",
 			"Check for updates and install if available",
@@ -124,7 +124,7 @@ export function clineEnv(
 				}),
 		CLINE_SESSION_DATA_DIR: path.join(dataDir, "sessions"),
 		CLINE_TEAM_DATA_DIR: path.join(dataDir, "teams"),
-		CLINE_DISABLE_CLINE_PASS_NOTICE: "1",
+		CLINE_DISABLE_MIGRATION_NOTICE: "1",
 		NO_UPDATE_NOTIFIER: "1",
 		CLINE_NO_AUTO_UPDATE: "1",
 		...extra,
@@ -12,8 +12,6 @@ const coreMocks = vi.hoisted(() => {
 		fetchMe: vi.fn(),
 		fetchBalance: vi.fn(),
 		fetchOrganizationBalance: vi.fn(),
-		fetchAvailableSubscriptionPlans: vi.fn(),
-		fetchCurrentUserPlan: vi.fn(),
 		serviceOptions,
 	};
 });
@@ -41,14 +39,6 @@ vi.mock("@cline/core", async (importOriginal) => {
 			fetchOrganizationBalance(organizationId: string) {
 				return coreMocks.fetchOrganizationBalance(organizationId);
 			}
-			fetchAvailableSubscriptionPlans(input?: {
-				type?: "individual" | "teams";
-			}) {
-				return coreMocks.fetchAvailableSubscriptionPlans(input);
-			}
-			fetchCurrentUserPlan() {
-				return coreMocks.fetchCurrentUserPlan();
-			}
 		},
 		ProviderSettingsManager: class {
 			getProviderSettings(providerId: string) {
@@ -110,8 +100,6 @@ describe("createClineAccountService", () => {
 		coreMocks.fetchMe.mockReset();
 		coreMocks.fetchBalance.mockReset();
 		coreMocks.fetchOrganizationBalance.mockReset();
-		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
-		coreMocks.fetchCurrentUserPlan.mockReset();
 		coreMocks.serviceOptions.length = 0;
 		telemetryMocks.identifyTelemetryAccount.mockReset();
 	});
@@ -208,8 +196,6 @@ describe("loadClineAccountSnapshot", () => {
 		coreMocks.fetchMe.mockReset();
 		coreMocks.fetchBalance.mockReset();
 		coreMocks.fetchOrganizationBalance.mockReset();
-		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
-		coreMocks.fetchCurrentUserPlan.mockReset();
 		coreMocks.serviceOptions.length = 0;
 		telemetryMocks.identifyTelemetryAccount.mockReset();
 	});
@@ -263,49 +249,3 @@ describe("loadClineAccountSnapshot", () => {
 		);
 	});
 });
-
-describe("loadIndividualSubscriptionPlans", () => {
-	beforeEach(() => {
-		vi.restoreAllMocks();
-		vi.unstubAllGlobals();
-		coreMocks.getProviderSettings.mockReset();
-		coreMocks.saveProviderSettings.mockReset();
-		coreMocks.fetchMe.mockReset();
-		coreMocks.fetchBalance.mockReset();
-		coreMocks.fetchOrganizationBalance.mockReset();
-		coreMocks.fetchAvailableSubscriptionPlans.mockReset();
-		coreMocks.fetchCurrentUserPlan.mockReset();
-		coreMocks.serviceOptions.length = 0;
-		telemetryMocks.identifyTelemetryAccount.mockReset();
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-		vi.unstubAllGlobals();
-	});
-
-	it("loads individual subscription plans through the authorized account service", async () => {
-		const plans = [
-			{
-				id: "plan-1",
-				interval: "Monthly",
-				features: { included: ["Major open-weights models"] },
-			},
-		];
-		coreMocks.getProviderSettings.mockReturnValue({
-			provider: "cline",
-			apiKey: "account-token",
-		});
-		coreMocks.fetchAvailableSubscriptionPlans.mockResolvedValue(plans);
-
-		const { loadIndividualSubscriptionPlans } = await import("./cline-account");
-		const result = await loadIndividualSubscriptionPlans({
-			config: makeConfig(),
-		});
-
-		expect(coreMocks.fetchAvailableSubscriptionPlans).toHaveBeenCalledWith({
-			type: "individual",
-		});
-		expect(result).toEqual(plans);
-	});
-});
@@ -2,8 +2,6 @@ import {
 	type ClineAccountBalance,
 	type ClineAccountOrganization,
 	type ClineAccountOrganizationBalance,
-	type ClineSubscriptionPlan,
-	type UserCurrentPlan,
 	ClineAccountService,
 	type ClineAccountUser,
 	formatProviderOAuthApiKey,
@@ -126,10 +124,8 @@ export async function createClineAccountService(input: {
 	config: ClineAccountConfig;
 	clineApiBaseUrl?: string;
 	clineProviderSettings?: ProviderSettings;
-	providerSettingsManager?: ProviderSettingsManager;
 }): Promise<ClineAccountService | undefined> {
-	const manager =
-		input.providerSettingsManager ?? new ProviderSettingsManager();
+	const manager = new ProviderSettingsManager();
 	const settings =
 		manager.getProviderSettings("cline") ?? input.clineProviderSettings;
 	const apiBaseUrl = resolveAccountApiBaseUrl({
@@ -207,60 +203,6 @@ export async function switchClineAccount(input: {
 	await service.switchAccount(input.organizationId);
 }

-export async function loadIndividualSubscriptionPlans(input: {
-	config: ClineAccountConfig;
-	clineApiBaseUrl?: string;
-	clineProviderSettings?: ProviderSettings;
-}): Promise<ClineSubscriptionPlan[]> {
-	const service = await createClineAccountService(input);
-	if (!service) {
-		throw new Error("No Cline account auth token found");
-	}
-	return service.fetchAvailableSubscriptionPlans({ type: "individual" });
-}
-
-export async function loadCurrentUserPlan(input: {
-	config: ClineAccountConfig;
-	clineApiBaseUrl?: string;
-	clineProviderSettings?: ProviderSettings;
-}): Promise<UserCurrentPlan | undefined> {
-	const service = await createClineAccountService(input);
-	if (!service) {
-		throw new Error("No Cline account auth token found");
-	}
-	return service.fetchCurrentUserPlan();
-}
-
-export async function loadCurrentUserPlanFromProviderSettings(input: {
-	providerSettingsManager: ProviderSettingsManager;
-	clineApiBaseUrl?: string;
-}): Promise<UserCurrentPlan | undefined> {
-	const service = await createClineAccountService({
-		config: { apiKey: "", logger: undefined, providerId: "cline" },
-		clineApiBaseUrl: input.clineApiBaseUrl,
-		providerSettingsManager: input.providerSettingsManager,
-	});
-	if (!service) {
-		throw new Error("No Cline account auth token found");
-	}
-	return service.fetchCurrentUserPlan();
-}
-
-export async function loadIndividualSubscriptionPlansFromProviderSettings(input: {
-	providerSettingsManager: ProviderSettingsManager;
-	clineApiBaseUrl?: string;
-}): Promise<ClineSubscriptionPlan[]> {
-	const service = await createClineAccountService({
-		config: { apiKey: "", logger: undefined, providerId: "cline" },
-		clineApiBaseUrl: input.clineApiBaseUrl,
-		providerSettingsManager: input.providerSettingsManager,
-	});
-	if (!service) {
-		throw new Error("No Cline account auth token found");
-	}
-	return service.fetchAvailableSubscriptionPlans({ type: "individual" });
-}
-
 async function onChangeToClinePass(config: ClineAccountConfig) {
 	try {
 		await switchClineAccount({
@@ -1,12 +1,10 @@
-import type { ClineSubscriptionPlan } from "@cline/core";
 import { useTerminalDimensions } from "@opentui/react";
 import type React from "react";
-import { useEffect, useState } from "react";
+import { useState } from "react";
 import "opentui-spinner/react";
 import {
 	getClineOrgIndividualInferenceSubscriptionMessage,
-	getCliSubscriptionUrl,
-	getIndividualPlanFeatures,
+	getClinePassSubscriptionUrl,
 	isClineOrgIndividualInferenceSubscriptionErrorMessage,
 	isClinePassSubscriptionError,
 } from "../../utils/cline-pass-errors";
@@ -17,7 +15,6 @@ import {
 import { useTerminalBackground } from "../hooks/use-terminal-background";
 import {
 	getDefaultForeground,
-	getModeAccent,
 	getModeInputBackground,
 	palette,
 	type TerminalTheme,
@@ -269,8 +266,7 @@ function ToolCallView(props: {
 	);
 }

-function ClineCreditsClinePassErrorView(props: { defaultFg?: string }) {
-	const subscriptionUrl = getCliSubscriptionUrl();
+function ClineCreditsErrorView(props: { defaultFg?: string }) {
 	return (
 		<box flexDirection="row">
 			<text fg="red" content="* " />
@@ -285,96 +281,39 @@ function ClineCreditsClinePassErrorView(props: { defaultFg?: string }) {
 				<text
 					fg={props.defaultFg}
 					selectable
-					content={
-						"You have run out of Cline credits. Add credits in the dashboard or purchase and switch to ClinePass to continue."
-					}
+					content="You have run out of Cline credits. Add credits in the dashboard to continue."
 				/>
 				<box flexDirection="row">
-					<text fg="gray">Purchase Credits: </text>
+					<text fg="gray">Dashboard: </text>
 					<text fg="cyan" selectable>
 						<a href={CLINE_CREDITS_DASHBOARD_URL}>
 							{CLINE_CREDITS_DASHBOARD_URL}
 						</a>
 					</text>
 				</box>
-				<box flexDirection="row">
-					<text fg="gray">Purchase ClinePass: </text>
-					<text fg="cyan" selectable>
-						<a href={subscriptionUrl}>{subscriptionUrl}</a>
-					</text>
-				</box>
-				<box flexDirection="row">
-					<text fg="gray">Switch to ClinePass: </text>
-					<text fg="gray">
-						type /settings in CLI and switch provider to ClinePass
-					</text>
-				</box>
 			</box>
 		</box>
 	);
 }

-function ClineCreditsErrorView(props: { defaultFg?: string }) {
-	return <ClineCreditsClinePassErrorView defaultFg={props.defaultFg} />;
-}
-
-function ClinePassSubscriptionErrorView(props: {
-	defaultFg?: string;
-	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
-	terminalTheme: TerminalTheme;
-}) {
-	const subscriptionUrl = getCliSubscriptionUrl();
-	const [planFeatures, setPlanFeatures] = useState<string[]>([]);
-	const planAccent = getModeAccent("plan", props.terminalTheme);
-
-	useEffect(() => {
-		if (!props.loadIndividualSubscriptionPlans) {
-			return;
-		}
-		let isMounted = true;
-		void props
-			.loadIndividualSubscriptionPlans()
-			.then((plans) => {
-				if (isMounted) {
-					setPlanFeatures(getIndividualPlanFeatures(plans));
-				}
-			})
-			.catch(() => {
-				// Keep the subscription error view usable if plan metadata is unavailable.
-			});
-
-		return () => {
-			isMounted = false;
-		};
-	}, [props.loadIndividualSubscriptionPlans]);
-
+function ClinePassSubscriptionErrorView(props: { defaultFg?: string }) {
+	const subscriptionUrl = getClinePassSubscriptionUrl();
 	return (
 		<box flexDirection="row">
-			<text fg={planAccent} content="* " />
+			<text fg="yellow" content="* " />
 			<box
 				flexDirection="column"
 				border
 				borderStyle="rounded"
-				borderColor={planAccent}
+				borderColor="yellow"
 				paddingX={1}
 			>
-				<text fg={planAccent}>ClinePass subscription required</text>
+				<text fg="yellow">ClinePass subscription required</text>
 				<text
 					fg={props.defaultFg}
 					selectable
 					content="No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan."
 				/>
-				{planFeatures.length > 0 && (
-					<box flexDirection="column" marginTop={1}>
-						<text fg={props.defaultFg}>ClinePass includes:</text>
-						{planFeatures.map((feature) => (
-							<text key={feature} fg={props.defaultFg} selectable>
-								<span fg="green">✓ </span>
-								<span>{feature}</span>
-							</text>
-						))}
-					</box>
-				)}
 				<box flexDirection="row">
 					<text fg="gray">Subscribe: </text>
 					<text fg="cyan" selectable>
@@ -394,21 +333,18 @@ function ClinePassSubscriptionErrorView(props: {

 function ClineOrgIndividualInferenceSubscriptionErrorView(props: {
 	defaultFg?: string;
-	terminalTheme: TerminalTheme;
 }) {
-	const planAccent = getModeAccent("plan", props.terminalTheme);
-
 	return (
 		<box flexDirection="row">
-			<text fg={planAccent} content="* " />
+			<text fg="yellow" content="* " />
 			<box
 				flexDirection="column"
 				border
 				borderStyle="rounded"
-				borderColor={planAccent}
+				borderColor="yellow"
 				paddingX={1}
 			>
-				<text fg={planAccent}>Personal ClinePass required</text>
+				<text fg="yellow">Personal ClinePass required</text>
 				<text
 					fg={props.defaultFg}
 					selectable
@@ -422,7 +358,6 @@ function ClineOrgIndividualInferenceSubscriptionErrorView(props: {
 export function ChatEntryView(props: {
 	entry: ChatEntry;
 	accent?: string;
-	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
 	terminalTheme: TerminalTheme;
 }) {
 	const { entry, accent = palette.act, terminalTheme } = props;
@@ -520,22 +455,11 @@ export function ChatEntryView(props: {
 			}
 			if (isClineOrgIndividualInferenceSubscriptionErrorMessage(entry.text)) {
 				return (
-					<ClineOrgIndividualInferenceSubscriptionErrorView
-						defaultFg={defaultFg}
-						terminalTheme={terminalTheme}
-					/>
+					<ClineOrgIndividualInferenceSubscriptionErrorView defaultFg={defaultFg} />
 				);
 			}
 			if (isClinePassSubscriptionError(entry.text)) {
-				return (
-					<ClinePassSubscriptionErrorView
-						defaultFg={defaultFg}
-						loadIndividualSubscriptionPlans={
-							props.loadIndividualSubscriptionPlans
-						}
-						terminalTheme={terminalTheme}
-					/>
-				);
+				return <ClinePassSubscriptionErrorView defaultFg={defaultFg} />;
 			}
 			return (
 				<box flexDirection="row">
@@ -1,5 +1,5 @@
 import "opentui-spinner/react";
-import type { AgentMode, ClineSubscriptionPlan } from "@cline/core";
+import type { AgentMode } from "@cline/core";
 import type { ScrollBoxRenderable } from "@opentui/core";
 import {
 	forwardRef,
@@ -21,7 +21,6 @@ export interface TranscriptScrollHandle {
 interface ChatMessageListProps {
 	entries: ChatEntry[];
 	isStreaming?: boolean;
-	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
 	uiMode?: AgentMode;
 }

@@ -101,9 +100,6 @@ export const ChatMessageList = forwardRef<
 							key={key}
 							entry={entry}
 							accent={accent}
-							loadIndividualSubscriptionPlans={
-								props.loadIndividualSubscriptionPlans
-							}
 							terminalTheme={terminalTheme}
 						/>
 					);
@@ -1,16 +0,0 @@
-import { CLI_PROMO_CODE } from "../../../utils/cline-pass-errors";
-
-const CLINE_PASS_SUBSCRIPTION_PATH = "/dashboard/subscription";
-const DEFAULT_APP_BASE_URL = "https://app.cline.bot";
-
-export function buildClinePassSubscriptionPageUrl(
-	appBaseUrl: string | undefined,
-): string {
-	const url = new URL(
-		CLINE_PASS_SUBSCRIPTION_PATH,
-		appBaseUrl || DEFAULT_APP_BASE_URL,
-	);
-	url.searchParams.set("personal", "true");
-	url.searchParams.set("code", CLI_PROMO_CODE);
-	return url.toString();
-}
@@ -1,18 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildClinePassSubscriptionPageUrl } from "./provider-picker-helpers";
-
-describe("buildClinePassSubscriptionPageUrl", () => {
-	it("opens the personal subscription page on production by default", () => {
-		expect(buildClinePassSubscriptionPageUrl(undefined)).toBe(
-			"https://app.cline.bot/dashboard/subscription?personal=true&code=CLI-8OFF",
-		);
-	});
-
-	it("keeps the configured app base URL", () => {
-		expect(
-			buildClinePassSubscriptionPageUrl("https://staging-app.cline.bot"),
-		).toBe(
-			"https://staging-app.cline.bot/dashboard/subscription?personal=true&code=CLI-8OFF",
-		);
-	});
-});
@@ -37,7 +37,6 @@ import {
 	getSearchableListRowsWindow,
 	type SearchableItem,
 } from "../searchable-list";
-import { buildClinePassSubscriptionPageUrl } from "./provider-picker-helpers";

 interface ProviderItem {
 	id: string;
@@ -249,33 +248,18 @@ export function ProviderPickerContent(
 	);
 }

-export type ExistingProviderAction =
-	| "use_existing"
-	| "reconfigure"
-	| "open_subscription_page"
-	| "open_usage_billing";
-
-export interface ExistingProviderOption {
-	value: ExistingProviderAction;
-	label: string;
-	onSelect?: () => Promise<void> | void;
-}
+export type ExistingProviderAction = "use_existing" | "reconfigure";

 export function UseExistingOrReconfigureContent(
-	props: ChoiceContext<ExistingProviderOption> & {
+	props: ChoiceContext<ExistingProviderAction> & {
 		providerName: string;
-		extraOptions?: ExistingProviderOption[];
 	},
 ) {
-	const { resolve, dismiss, dialogId, providerName, extraOptions } = props;
-	const options: ExistingProviderOption[] = useMemo(
-		() => [
-			{ value: "use_existing", label: "Use existing configuration" },
-			{ value: "reconfigure", label: "Configure again" },
-			...(extraOptions ?? []),
-		],
-		[extraOptions],
-	);
+	const { resolve, dismiss, dialogId, providerName } = props;
+	const options: { value: ExistingProviderAction; label: string }[] = [
+		{ value: "use_existing", label: "Use existing configuration" },
+		{ value: "reconfigure", label: "Configure again" },
+	];
 	const [selected, setSelected] = useState(0);

 	useDialogKeyboard((key) => {
@@ -285,7 +269,7 @@ export function UseExistingOrReconfigureContent(
 		}
 		if (key.name === "return" || key.name === "enter") {
 			const opt = options[selected];
-			if (opt) resolve(opt);
+			if (opt) resolve(opt.value);
 			return;
 		}
 		if (key.name === "up" || (key.ctrl && key.name === "p")) {
@@ -330,86 +314,6 @@ export function UseExistingOrReconfigureContent(
 	);
 }

-function ClinePassBrowserPageContent(
-	props: ChoiceContext<boolean> & {
-		providerName: string;
-		pageLabel: string;
-		url: string;
-		openedStatus: string;
-	},
-) {
-	const {
-		resolve,
-		dismiss,
-		dialogId,
-		providerName,
-		pageLabel,
-		url,
-		openedStatus,
-	} = props;
-	const [status, setStatus] = useState("Opening browser...");
-
-	useEffect(() => {
-		void open(url, { wait: false })
-			.then(() => {
-				setStatus(openedStatus);
-			})
-			.catch(() => {
-				setStatus("Could not open browser automatically. Open the URL below.");
-			});
-	}, [url, openedStatus]);
-
-	useDialogKeyboard((key) => {
-		if (key.name === "escape") {
-			dismiss();
-			return;
-		}
-		if (key.name === "return" || key.name === "enter") {
-			resolve(true);
-		}
-	}, dialogId);
-
-	return (
-		<box flexDirection="column" paddingX={1} gap={1}>
-			<text fg="cyan">
-				<strong>{providerName}</strong>
-			</text>
-
-			<text>{status}</text>
-
-			<text fg="gray">{pageLabel}:</text>
-			<text fg="cyan" selectable>
-				<a href={url}>{url}</a>
-			</text>
-
-			<text fg="gray">
-				<em>Enter or Esc to go back</em>
-			</text>
-		</box>
-	);
-}
-
-export function ClinePassSubscriptionContent(
-	props: ChoiceContext<boolean> & {
-		providerName: string;
-	},
-) {
-	const subscriptionUrl = useMemo(
-		() =>
-			buildClinePassSubscriptionPageUrl(getClineEnvironmentConfig().appBaseUrl),
-		[],
-	);
-
-	return (
-		<ClinePassBrowserPageContent
-			{...props}
-			pageLabel="Subscription page"
-			url={subscriptionUrl}
-			openedStatus="Opened subscription page in your browser."
-		/>
-	);
-}
-
 const DEFAULT_FIELD_LABELS: Partial<Record<ProviderConfigFieldKey, string>> = {
 	apiKey: "API key",
 	baseUrl: "Base URL",
@@ -3,7 +3,6 @@ import {
 	createContextBar,
 	formatStatusBarUsageText,
 	resolveContextBarFilledForeground,
-	resolveModelDisplayName,
 } from "./status-bar";

 vi.mock("@opentui/react", () => ({
@@ -56,44 +55,18 @@ describe("formatStatusBarUsageText", () => {
 			formatStatusBarUsageText({
 				totalTokens: 12_345,
 				totalCost: 0.123,
-				providerId: "cline",
+				showCost: true,
 			}),
-		).toBe("(12,345 tokens) $0.12");
+		).toBe("(12,345) $0.12");
 	});

-	it("displays subscription message when the provider is a subscription provider", () => {
+	it("omits cost when usage cost is hidden", () => {
 		expect(
 			formatStatusBarUsageText({
 				totalTokens: 12_345,
 				totalCost: 0.123,
-				providerId: "cline-pass",
+				showCost: false,
 			}),
-		).toBe("(12,345 tokens) $0.00 (included with subscription)");
-	});
-});
-
-describe("resolveModelDisplayName", () => {
-	it("keeps ClinePass visible when model ids have provider prefixes", () => {
-		expect(
-			resolveModelDisplayName({
-				providerId: "cline-pass",
-				modelId: "zai/glm-5.2",
-				knownModels: {
-					"zai/glm-5.2": { name: "GLM 5.2" },
-				},
-			}),
-		).toBe("ClinePass/glm-5.2");
-	});
-
-	it("uses the friendly model name for non-ClinePass providers", () => {
-		expect(
-			resolveModelDisplayName({
-				providerId: "cline",
-				modelId: "zai/glm-5.2",
-				knownModels: {
-					"zai/glm-5.2": { name: "GLM 5.2" },
-				},
-			}),
-		).toBe("GLM 5.2");
+		).toBe("(12,345)");
 	});
 });
@@ -1,9 +1,6 @@
 import type { AgentMode } from "@cline/core";
 import { useTerminalDimensions } from "@opentui/react";
-import {
-	shouldShowCliUsageCost,
-	shouldShowCliUsageCoveredBySubscription,
-} from "../../utils/usage-cost-display";
+import { shouldShowCliUsageCost } from "../../utils/usage-cost-display";
 import {
 	useTerminalBackground,
 	useTerminalTheme,
@@ -49,31 +46,14 @@ function formatCost(cost: number): string {
 	return `$${cost.toFixed(2)}`;
 }

-function formatCostText(providerId: string, totalCost: number): string {
-	if (shouldShowCliUsageCoveredBySubscription(providerId)) {
-		return "$0.00 (included with subscription)";
-	}
-
-	if (!shouldShowCliUsageCost(providerId)) {
-		return "";
-	}
-
-	return formatCost(totalCost);
-}
-
 export function formatStatusBarUsageText(input: {
 	totalTokens: number;
 	totalCost: number;
-	providerId: string;
+	showCost: boolean;
 }): string {
-	const tokens = `(${input.totalTokens.toLocaleString()} tokens)`;
-	const costText = formatCostText(input.providerId, input.totalCost);
-
-	if (!costText) {
-		return tokens;
-	}
-
-	return `${tokens} ${costText}`;
+	const tokens = `(${input.totalTokens.toLocaleString()})`;
+	if (!input.showCost) return tokens;
+	return `${tokens} ${formatCost(input.totalCost)}`;
 }

 // knownModels keys are bare IDs ("claude-sonnet-4-6") but config.modelId
@@ -94,22 +74,17 @@ function lookupModelInfo(
 }

 export function resolveModelDisplayName(config: {
-	providerId?: string;
 	modelId: string;
 	knownModels?: Record<string, unknown>;
 	thinking?: boolean;
 	reasoningEffort?: string;
 }): string {
 	const info = lookupModelInfo(config.modelId, config.knownModels);
-	const modelIdTail = config.modelId.split("/").pop() ?? config.modelId;
-	const displayName =
-		config.providerId === "cline-pass"
-			? `ClinePass/${modelIdTail}`
-			: (info?.name ?? modelIdTail);
+	const name = info?.name ?? config.modelId.split("/").pop() ?? config.modelId;
 	if (config.thinking && config.reasoningEffort) {
-		return `${displayName} (${config.reasoningEffort})`;
+		return `${name} (${config.reasoningEffort})`;
 	}
-	return displayName;
+	return name;
 }

 export function resolveModelMaxInputTokens(config: {
@@ -177,6 +152,7 @@ export function StatusBar(props: StatusBarProps) {
 	const bar = hasMaxInputTokens
 		? createContextBar(totalTokens, maxInputTokens)
 		: undefined;
+	const showUsageCost = shouldShowCliUsageCost(props.providerId);

 	// Available content width after accounting for padding.
 	// Home view: parent box is capped at 60 wide, status bar adds paddingX=1 (-2).
@@ -193,7 +169,7 @@ export function StatusBar(props: StatusBarProps) {
 	const usageText = formatStatusBarUsageText({
 		totalTokens,
 		totalCost,
-		providerId: props.providerId,
+		showCost: showUsageCost,
 	});
 	const contextText = bar
 		? ` ${bar.filled}${bar.empty} ${usageText}`
@@ -1,5 +1,4 @@
 import type { AgentEvent, TeamEvent } from "@cline/core";
-import { formatDisplayUserInput } from "@cline/shared";
 import { useCallback, useRef } from "react";
 import type {
 	PendingPromptSnapshot,
@@ -297,13 +296,7 @@ export function useAgentEventHandlers(deps: AgentEventDeps) {
 	const handlePendingPromptSubmitted = useCallback(
 		(event: PendingPromptSubmittedEvent) => {
 			knownPendingPromptIdsRef.current.delete(event.id);
-			// Display boundary: formatDisplayUserInput strips runtime-generated
-			// notice elements (e.g. mode_notice) that normalizeUserInput must
-			// preserve, since the latter also sanitizes model-bound prompts.
-			appendEntry({
-				kind: "user_submitted",
-				text: formatDisplayUserInput(event.prompt),
-			});
+			appendEntry({ kind: "user_submitted", text: event.prompt });
 		},
 		[appendEntry],
 	);
@@ -18,9 +18,8 @@ import {
 import type { Config } from "../../utils/types";
 import { withLoadingDialog } from "../components/dialogs/loading-dialog";
 import {
-	ClinePassSubscriptionContent,
 	CodexCliStatusContent,
-	type ExistingProviderOption,
+	type ExistingProviderAction,
 	OAuthLoginContent,
 	ProviderConfigInputContent,
 	ProviderPickerContent,
@@ -79,36 +78,6 @@ function usesModelIdInput(providerId: string): boolean {
 	return providerId === "openai-compatible";
 }

-function providerToExistingProviderOptions(input: {
-	providerId: string;
-	providerName: string;
-	dialog: DialogActions;
-	termHeight: number;
-}): ExistingProviderOption[] {
-	if (input.providerId !== "cline-pass") {
-		return [];
-	}
-
-	return [
-		{
-			value: "open_subscription_page",
-			label: "Manage subscription & see usage",
-			onSelect: async () => {
-				await input.dialog.choice<boolean>({
-					style: { maxHeight: input.termHeight - 2 },
-					closeOnEscape: false,
-					content: (ctx: ChoiceContext<boolean>) => (
-						<ClinePassSubscriptionContent
-							{...ctx}
-							providerName={input.providerName}
-						/>
-					),
-				});
-			},
-		},
-	];
-}
-
 async function runProviderChange(
 	dialog: DialogActions,
 	config: Config,
@@ -133,33 +102,14 @@ async function runProviderChange(

 	let needsAuth = true;
 	if (isProviderConfigured(newProviderId, existingSettings)) {
-		let option: ExistingProviderOption | undefined;
-		const extraOptions = providerToExistingProviderOptions({
-			providerId: newProviderId,
-			providerName: displayName,
-			dialog,
-			termHeight,
+		const action = await dialog.choice<ExistingProviderAction>({
+			style: { maxHeight: termHeight - 2 },
+			content: (ctx: ChoiceContext<ExistingProviderAction>) => (
+				<UseExistingOrReconfigureContent {...ctx} providerName={displayName} />
+			),
 		});
-		while (true) {
-			option = await dialog.choice<ExistingProviderOption>({
-				style: { maxHeight: termHeight - 2 },
-				content: (ctx: ChoiceContext<ExistingProviderOption>) => (
-					<UseExistingOrReconfigureContent
-						{...ctx}
-						providerName={displayName}
-						extraOptions={extraOptions}
-					/>
-				),
-			});
-			if (!option) return false;
-			if (option.onSelect) {
-				await option.onSelect();
-				option = undefined;
-				continue;
-			}
-			break;
-		}
-		needsAuth = option.value === "reconfigure";
+		if (!action) return false;
+		needsAuth = action === "reconfigure";
 	}

 	if (needsAuth) {
@@ -10,7 +10,6 @@ import {
 	useDialogState,
 } from "@opentui-ui/dialog/react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { shouldSuppressClineCliMigrationNoticeForActiveProvider } from "../kanban-migration/notice";
 import { MigrationNoticeContent } from "../kanban-migration/notice-dialog";
 import type { RepoStatus } from "../utils/repo-status";
 import { readRepoStatus } from "../utils/repo-status";
@@ -542,17 +541,10 @@ function App(props: TuiProps) {

 	const notice = props.initialNotice;
 	const onInitialNoticeShown = props.onInitialNoticeShown;
-	const currentProviderId = props.config.providerId;
 	useEffect(() => {
 		if (!notice) return;
 		if (initialNoticeShownRef.current) return;
 		if (appView !== "home") return;
-		if (
-			shouldSuppressClineCliMigrationNoticeForActiveProvider(currentProviderId)
-		) {
-			initialNoticeShownRef.current = true;
-			return;
-		}

 		initialNoticeShownRef.current = true;
 		const timeout = setTimeout(() => {
@@ -568,7 +560,7 @@ function App(props: TuiProps) {
 				});
 		}, 0);
 		return () => clearTimeout(timeout);
-	}, [appView, currentProviderId, dialog, notice, onInitialNoticeShown]);
+	}, [appView, dialog, notice, onInitialNoticeShown]);

 	const {
 		appendEntry: appendSessionEntry,
@@ -887,7 +879,6 @@ function App(props: TuiProps) {
 		repoStatus,
 		textareaRef: promptInput.textareaRef,
 		transcriptScrollRef,
-		loadIndividualSubscriptionPlans: props.loadIndividualSubscriptionPlans,
 		queuedPrompts,
 		selectedQueuedPromptId,
 		editingQueuedPrompt,
@@ -2,7 +2,6 @@ import type {
 	AgentEvent,
 	AgentMode,
 	CheckpointEntry,
-	ClineSubscriptionPlan,
 	TeamEvent,
 } from "@cline/core";
 import type {
@@ -130,7 +129,6 @@ export interface TuiProps {
 	loadAdditionalSlashCommands?: () => Promise<InteractiveSlashCommand[]>;
 	loadWelcomeLine?: () => Promise<string | undefined>;
 	loadClineAccount: () => Promise<ClineAccountSnapshot>;
-	loadIndividualSubscriptionPlans?: () => Promise<ClineSubscriptionPlan[]>;
 	switchClineAccount: (organizationId?: string | null) => Promise<void>;
 	loadConfigData: (
 		options?: LoadInteractiveConfigDataOptions,
@@ -1,45 +0,0 @@
-import type { Message } from "@cline/shared";
-import { describe, expect, it } from "vitest";
-import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
-import { hydrateSessionMessages } from "./hydrate-messages";
-
-describe("hydrateSessionMessages", () => {
-	it("renders regular user messages", () => {
-		const messages = [
-			{
-				role: "user",
-				content: '<user_input mode="plan">lets do it</user_input>',
-			},
-		] as Message[];
-
-		expect(hydrateSessionMessages(messages)).toEqual([
-			{ kind: "user_submitted", text: "lets do it" },
-		]);
-	});
-
-	it("hides the synthetic act-mode continuation prompt", () => {
-		const messages = [
-			{
-				role: "user",
-				content: `<user_input mode="act">${ACT_MODE_CONTINUATION_PROMPT}</user_input>`,
-			},
-			{
-				role: "user",
-				content: [
-					{
-						type: "text",
-						text: `<user_input mode="act">${ACT_MODE_CONTINUATION_PROMPT}</user_input>`,
-					},
-				],
-			},
-			{
-				role: "assistant",
-				content: "On it.",
-			},
-		] as Message[];
-
-		expect(hydrateSessionMessages(messages)).toEqual([
-			{ kind: "assistant_text", text: "On it.", streaming: false },
-		]);
-	});
-});
@@ -1,5 +1,4 @@
 import { formatDisplayUserInput, type Message } from "@cline/shared";
-import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
 import { formatToolInput } from "../../utils/helpers";
 import type { ChatEntry } from "../types";

@@ -12,12 +11,6 @@ function getDisplayRole(msg: PersistedMessage): string | undefined {
 	return typeof role === "string" ? role.trim().toLowerCase() : undefined;
 }

-// The act-mode continuation prompt is runtime-generated, not typed by the
-// user, so it should not surface as a user bubble in the transcript.
-function isSyntheticUserText(text: string): boolean {
-	return text === ACT_MODE_CONTINUATION_PROMPT;
-}
-
 function stringifyToolResult(
 	content: string | Array<{ type: string; text?: string; path?: string }>,
 ): string {
@@ -47,9 +40,7 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 		if (typeof msg.content === "string") {
 			if (msg.role === "user") {
 				const text = formatDisplayUserInput(msg.content);
-				if (text && !isSyntheticUserText(text)) {
-					entries.push({ kind: "user_submitted", text });
-				}
+				if (text) entries.push({ kind: "user_submitted", text });
 			} else {
 				entries.push({
 					kind: "assistant_text",
@@ -124,7 +115,7 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 		if (msg.role === "user" && userTextParts.length > 0) {
 			const combined = userTextParts.join("\n");
 			const text = formatDisplayUserInput(combined);
-			if (text && !isSyntheticUserText(text)) {
+			if (text) {
 				entries.push({ kind: "user_submitted", text });
 			}
 		}
@@ -50,7 +50,6 @@ export function ChatView(props: {
 	};
 	textareaRef?: React.MutableRefObject<TextareaHandle | null>;
 	transcriptScrollRef?: React.Ref<TranscriptScrollHandle>;
-	loadIndividualSubscriptionPlans?: TuiProps["loadIndividualSubscriptionPlans"];
 	autocomplete?: AutocompleteDropdownProps;
 	queuedPrompts?: QueuedPromptItem[];
 	selectedQueuedPromptId?: string | null;
@@ -90,7 +89,6 @@ export function ChatView(props: {
 				ref={props.transcriptScrollRef}
 				entries={session.entries}
 				isStreaming={session.isStreaming}
-				loadIndividualSubscriptionPlans={props.loadIndividualSubscriptionPlans}
 				uiMode={session.uiMode}
 			/>

@@ -10,24 +10,16 @@ import {
 	saveLocalProviderSettings,
 } from "@cline/core";
 import { isClineProvider } from "@cline/shared";
-import open from "open";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import {
-	getCliSubscriptionUrl,
-	getIndividualPlanFeatures,
-} from "../../../utils/cline-pass-errors";
 import {
 	type CodexCliStatus,
 	checkCodexCliInstalled,
 	isOpenAICodexCliProvider,
 } from "../../../utils/codex-cli";
+import { getCliFeatureFlagsService } from "../../../utils/feature-flags";
 import { getPersistedProviderApiKey } from "../../../utils/provider-auth";
 import { listLocalProviders } from "../../../utils/provider-catalog";
 import { getCliTelemetryService } from "../../../utils/telemetry";
-import {
-	loadCurrentUserPlanFromProviderSettings,
-	loadIndividualSubscriptionPlansFromProviderSettings,
-} from "../../cline-account";
 import {
 	buildClineModelEntries,
 	type ClineModelPickerEntry,
@@ -56,8 +48,6 @@ import {
 import { FIELD_ORDER } from "./fields";
 import { useOnboardingKeyboard } from "./keyboard";
 import {
-	CLINE_PASS_SUBSCRIPTION_OPTIONS,
-	type ClinePassSubscriptionStatus,
 	getMainMenuOptions,
 	type ModelEntry,
 	type OnboardingResult,
@@ -88,7 +78,8 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 	const menuOptions = useMemo(
 		() =>
 			getMainMenuOptions({
-				isClinePassEnabled: true,
+				isClinePassEnabled:
+					getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
 			}),
 		[],
 	);
@@ -159,19 +150,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 	const [modelsDefaultId, setModelsDefaultId] = useState("");
 	const [customModelId, setCustomModelId] = useState("");
 	const [customModelError, setCustomModelError] = useState("");
-	const [clinePassSubscriptionStatus, setClinePassSubscriptionStatus] =
-		useState<ClinePassSubscriptionStatus>("loading");
-	const [clinePassSubscriptionError, setClinePassSubscriptionError] =
-		useState("");
-	const [clinePassCurrentPlanName, setClinePassCurrentPlanName] = useState("");
-	const [clinePassPlanFeatures, setClinePassPlanFeatures] = useState<string[]>(
-		[],
-	);
-	const [clinePassSubscriptionSelected, setClinePassSubscriptionSelected] =
-		useState(0);
-	const [clinePassSubscriptionOpenStatus, setClinePassSubscriptionOpenStatus] =
-		useState("");
-	const clinePassSubscriptionUrl = useMemo(() => getCliSubscriptionUrl(), []);

 	const modelItems: SearchableItem[] = useMemo(
 		() =>
@@ -287,62 +265,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		[providerSettingsManager],
 	);

-	const refreshClinePassSubscriptionStatus = useCallback(() => {
-		setClinePassSubscriptionStatus("loading");
-		setClinePassSubscriptionError("");
-		setClinePassCurrentPlanName("");
-		setClinePassSubscriptionOpenStatus("");
-
-		loadCurrentUserPlanFromProviderSettings({ providerSettingsManager })
-			.then(
-				(value) => ({ status: "fulfilled" as const, value }),
-				(reason) => ({ status: "rejected" as const, reason }),
-			)
-			.then((currentPlanResult) =>
-				loadIndividualSubscriptionPlansFromProviderSettings({
-					providerSettingsManager,
-				})
-					.then(
-						(value) => ({ status: "fulfilled" as const, value }),
-						(reason) => ({ status: "rejected" as const, reason }),
-					)
-					.then((availablePlansResult) => ({
-						availablePlansResult,
-						currentPlanResult,
-					})),
-			)
-			.then(({ currentPlanResult, availablePlansResult }) => {
-				if (availablePlansResult.status === "fulfilled") {
-					setClinePassPlanFeatures(
-						getIndividualPlanFeatures(availablePlansResult.value),
-					);
-				}
-
-				if (currentPlanResult.status === "rejected") {
-					const error = currentPlanResult.reason;
-					const message =
-						error instanceof Error ? error.message : String(error);
-					if (message.trim().toLowerCase() === "no plan found for user") {
-						setClinePassSubscriptionStatus("unsubscribed");
-						return;
-					}
-					setClinePassSubscriptionError(message);
-					setClinePassSubscriptionStatus("error");
-					return;
-				}
-
-				const plan = currentPlanResult.value?.plan;
-				if (plan) {
-					setClinePassCurrentPlanName(
-						plan.displayName || plan.name || plan.id || "ClinePass",
-					);
-					setClinePassSubscriptionStatus("subscribed");
-				} else {
-					setClinePassSubscriptionStatus("unsubscribed");
-				}
-			});
-	}, [providerSettingsManager]);
-
 	const transitionToModelPicker = useCallback(
 		(providerId: string) => {
 			setActiveProviderId(providerId);
@@ -366,27 +288,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		[providers, loadModelsForProvider, providerSettingsManager],
 	);

-	const transitionToClinePassSubscription = useCallback(() => {
-		setActiveProviderId("cline-pass");
-		const provider = providers.find((p) => p.id === "cline-pass");
-		setActiveProviderName(provider?.name ?? "ClinePass");
-		setModelsDefaultId(provider?.defaultModelId ?? "");
-		setClinePassSubscriptionSelected(0);
-		setStep("cline_pass_subscription");
-		refreshClinePassSubscriptionStatus();
-	}, [providers, refreshClinePassSubscriptionStatus]);
-
-	const handleAuthComplete = useCallback(
-		(providerId: OnboardingOAuthProviderId) => {
-			if (providerId === "cline-pass") {
-				transitionToClinePassSubscription();
-				return;
-			}
-			transitionToModelPicker(providerId);
-		},
-		[transitionToClinePassSubscription, transitionToModelPicker],
-	);
-
 	const resetAuth = useCallback(() => {
 		setAuthStatus("");
 		setAuthUrl("");
@@ -412,11 +313,11 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 				setVerifyUrl: setDeviceVerifyUrl,
 				setStatus: setDeviceStatus,
 				setError: setDeviceError,
-				onComplete: handleAuthComplete,
+				onComplete: transitionToModelPicker,
 				telemetry: getCliTelemetryService(),
 			});
 		},
-		[providerSettingsManager, handleAuthComplete],
+		[providerSettingsManager, transitionToModelPicker],
 	);

 	const startOAuthFlow = useCallback(
@@ -438,46 +339,18 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 				setStatus: setAuthStatus,
 				setAuthUrl,
 				setError: setAuthError,
-				onComplete: handleAuthComplete,
+				onComplete: transitionToModelPicker,
 				telemetry: getCliTelemetryService(),
 			});
 		},
 		[
 			providerSettingsManager,
 			resetAuth,
-			handleAuthComplete,
+			transitionToModelPicker,
 			startDeviceCodeFlow,
 		],
 	);

-	const continueFromClinePassSubscription = useCallback(() => {
-		transitionToModelPicker("cline-pass");
-	}, [transitionToModelPicker]);
-
-	const openClinePassSubscriptionPage = useCallback(() => {
-		setClinePassSubscriptionOpenStatus("Opening subscription page...");
-		void open(clinePassSubscriptionUrl, { wait: false })
-			.then(() => {
-				setClinePassSubscriptionOpenStatus(
-					"Opened subscription page in your browser.",
-				);
-			})
-			.catch(() => {
-				setClinePassSubscriptionOpenStatus(
-					`Could not open browser automatically. Open ${clinePassSubscriptionUrl}`,
-				);
-			});
-	}, [clinePassSubscriptionUrl]);
-
-	useEffect(() => {
-		if (
-			step === "cline_pass_subscription" &&
-			clinePassSubscriptionStatus === "subscribed"
-		) {
-			transitionToModelPicker("cline-pass");
-		}
-	}, [step, clinePassSubscriptionStatus, transitionToModelPicker]);
-
 	const refreshCodexCliStatus = useCallback(() => {
 		setCodexCliStatus(undefined);
 		setCodexCliChecking(true);
@@ -759,9 +632,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		modelList,
 		clineEntries,
 		clineModelSelected,
-		clinePassSubscriptionStatus,
-		clinePassSubscriptionOptions: CLINE_PASS_SUBSCRIPTION_OPTIONS,
-		clinePassSubscriptionSelected,
 		thinkingSelected,
 		setStep,
 		setMenuSelected,
@@ -778,11 +648,7 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		setDeviceError,
 		setDeviceStatus,
 		setClineModelSelected,
-		setClinePassSubscriptionSelected,
 		setThinkingSelected,
-		continueFromClinePassSubscription,
-		refreshClinePassSubscriptionStatus,
-		openClinePassSubscriptionPage,
 		abortOAuth: () => {
 			authAbortRef.current = true;
 		},
@@ -804,7 +670,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {

 	return {
 		activeProviderName,
-		activeProviderId,
 		authError,
 		authStatus,
 		authUrl,
@@ -817,14 +682,6 @@ export function useOnboardingController(props: OnboardingControllerProps) {
 		clineEntries,
 		clineKnownModels,
 		clineModelSelected,
-		clinePassCurrentPlanName,
-		clinePassPlanFeatures,
-		clinePassSubscriptionError,
-		clinePassSubscriptionOpenStatus,
-		clinePassSubscriptionOptions: CLINE_PASS_SUBSCRIPTION_OPTIONS,
-		clinePassSubscriptionSelected,
-		clinePassSubscriptionStatus,
-		clinePassSubscriptionUrl,
 		deviceError,
 		deviceStatus,
 		deviceUserCode,
@@ -9,8 +9,6 @@ import {
 } from "./auth";
 import { FIELD_ORDER } from "./fields";
 import {
-	type ClinePassSubscriptionOption,
-	type ClinePassSubscriptionStatus,
 	type MenuOption,
 	type OnboardingStep,
 	THINKING_LEVELS,
@@ -28,9 +26,6 @@ export function useOnboardingKeyboard(input: {
 	modelList: SearchableListState;
 	clineEntries: ClineModelPickerEntry[];
 	clineModelSelected: number;
-	clinePassSubscriptionStatus: ClinePassSubscriptionStatus;
-	clinePassSubscriptionOptions: ClinePassSubscriptionOption[];
-	clinePassSubscriptionSelected: number;
 	thinkingSelected: number;
 	setStep: (step: OnboardingStep) => void;
 	setMenuSelected: Dispatch<SetStateAction<number>>;
@@ -43,11 +38,7 @@ export function useOnboardingKeyboard(input: {
 	setDeviceError: (value: string) => void;
 	setDeviceStatus: (value: string) => void;
 	setClineModelSelected: Dispatch<SetStateAction<number>>;
-	setClinePassSubscriptionSelected: Dispatch<SetStateAction<number>>;
 	setThinkingSelected: Dispatch<SetStateAction<number>>;
-	continueFromClinePassSubscription: () => void;
-	refreshClinePassSubscriptionStatus: () => void;
-	openClinePassSubscriptionPage: () => void;
 	abortOAuth: () => void;
 	abortDeviceCode: () => void;
 	resetAuth: () => void;
@@ -102,11 +93,6 @@ export function useOnboardingKeyboard(input: {
 				input.setStep("byo_provider");
 				return;
 			}
-			if (input.step === "cline_pass_subscription") {
-				input.setStep("menu");
-				input.setMenuSelected(0);
-				return;
-			}
 			if (input.step === "cline_model") {
 				input.setStep("menu");
 				input.setMenuSelected(0);
@@ -149,43 +135,6 @@ export function useOnboardingKeyboard(input: {

 		if (input.step === "device_code") return;

-		if (input.step === "cline_pass_subscription") {
-			const total = input.clinePassSubscriptionOptions.length;
-			if (total === 0) return;
-			if (key.name === "up" || (key.ctrl && key.name === "p")) {
-				input.setClinePassSubscriptionSelected((s) =>
-					s <= 0 ? total - 1 : s - 1,
-				);
-				return;
-			}
-			if (key.name === "down" || (key.ctrl && key.name === "n")) {
-				input.setClinePassSubscriptionSelected((s) =>
-					s >= total - 1 ? 0 : s + 1,
-				);
-				return;
-			}
-			if (key.name === "return" || key.name === "enter") {
-				const option =
-					input.clinePassSubscriptionOptions[
-						Math.min(input.clinePassSubscriptionSelected, total - 1)
-					];
-				if (!option) return;
-				if (option.value === "subscribe") {
-					input.openClinePassSubscriptionPage();
-				} else if (option.value === "refresh") {
-					if (input.clinePassSubscriptionStatus !== "loading") {
-						input.refreshClinePassSubscriptionStatus();
-					}
-				} else if (option.value === "skip") {
-					input.continueFromClinePassSubscription();
-				} else if (option.value === "back") {
-					input.setStep("menu");
-					input.setMenuSelected(0);
-				}
-			}
-			return;
-		}
-
 		if (input.step === "menu") {
 			if (key.name === "up") {
 				input.setMenuSelected((s) =>
@@ -8,7 +8,6 @@ export type OnboardingStep =
 	| "byo_provider"
 	| "byo_apikey"
 	| "codex_cli_setup"
-	| "cline_pass_subscription"
 	| "cline_model"
 	| "model_picker"
 	| "custom_model_id"
@@ -37,17 +36,6 @@ export interface MenuOption {
 	icon: string;
 }

-export type ClinePassSubscriptionAction =
-	| "subscribe"
-	| "refresh"
-	| "skip"
-	| "back";
-
-export interface ClinePassSubscriptionOption {
-	value: ClinePassSubscriptionAction;
-	label: string;
-}
-
 export const MAIN_MENU: MenuOption[] = [
 	{
 		label: "Sign in with Cline",
@@ -83,25 +71,6 @@ export function getMainMenuOptions(options?: {
 	);
 }

-export const CLINE_PASS_SUBSCRIPTION_OPTIONS: ClinePassSubscriptionOption[] = [
-	{
-		value: "subscribe",
-		label: "Subscribe to ClinePass",
-	},
-	{
-		value: "refresh",
-		label: "Re-check subscription status",
-	},
-	{
-		value: "skip",
-		label: "Skip for now",
-	},
-	{
-		value: "back",
-		label: "Go back",
-	},
-];
-
 export interface OnboardingResult {
 	providerId: string;
 	modelId: string;
@@ -127,12 +96,6 @@ export interface ModelEntry {
 	supportsReasoning: boolean;
 }

-export type ClinePassSubscriptionStatus =
-	| "loading"
-	| "subscribed"
-	| "unsubscribed"
-	| "error";
-
 export interface ProviderCatalogItem {
 	id: string;
 	name: string;
@@ -1,7 +1,5 @@
 import "opentui-spinner/react";
-import type { ScrollBoxRenderable } from "@opentui/core";
 import type { ReactNode } from "react";
-import { useEffect, useRef } from "react";
 import {
 	CODEX_CLI_INSTALL_URL,
 	type CodexCliStatus,
@@ -19,18 +17,10 @@ import {
 	TrackedRobot,
 	type useMouseTracker,
 } from "../../components/tracked-robot";
-import {
-	useTerminalBackground,
-	useTerminalTheme,
-} from "../../hooks/use-terminal-background";
-import { getDefaultForeground, getModeAccent, palette } from "../../palette";
+import { useTerminalBackground } from "../../hooks/use-terminal-background";
+import { getDefaultForeground, palette } from "../../palette";
 import { FIELD_ORDER } from "./fields";
-import {
-	type ClinePassSubscriptionOption,
-	type ClinePassSubscriptionStatus,
-	type MenuOption,
-	THINKING_LEVELS,
-} from "./model";
+import { type MenuOption, THINKING_LEVELS } from "./model";

 type MouseTrackerState = ReturnType<typeof useMouseTracker>;

@@ -39,10 +29,6 @@ function useDefaultFg(): string | undefined {
 	return getDefaultForeground(terminalBg);
 }

-function getClinePassSubscriptionOptionId(index: number): string {
-	return `cline-pass-subscription-option-${index}`;
-}
-
 interface OnboardingFrameProps {
 	children: ReactNode;
 	compact: boolean;
@@ -482,198 +468,6 @@ export function OnboardingClineModelScreen(props: {
 	);
 }

-export function OnboardingClinePassSubscriptionScreen(props: {
-	compact: boolean;
-	contentWidth: number;
-	currentPlanName: string;
-	error: string;
-	mouse: MouseTrackerState;
-	openStatus: string;
-	options: ClinePassSubscriptionOption[];
-	planFeatures: string[];
-	selected: number;
-	status: ClinePassSubscriptionStatus;
-	subscriptionUrl: string;
-}) {
-	const defaultFg = useDefaultFg();
-	const terminalTheme = useTerminalTheme();
-	const planAccent = getModeAccent("plan", terminalTheme);
-	const scrollRef = useRef<ScrollBoxRenderable | null>(null);
-	const isLoading = props.status === "loading";
-	const isSubscribed = props.status === "subscribed";
-	const isError = props.status === "error";
-	const bodyHeight = props.compact ? 17 : 19;
-
-	useEffect(() => {
-		if (isSubscribed) {
-			return;
-		}
-		const scrollSelectedOptionIntoView = () => {
-			scrollRef.current?.scrollChildIntoView(
-				getClinePassSubscriptionOptionId(props.selected),
-			);
-		};
-		scrollSelectedOptionIntoView();
-		queueMicrotask(scrollSelectedOptionIntoView);
-		const timeout = setTimeout(scrollSelectedOptionIntoView, 0);
-		return () => clearTimeout(timeout);
-	}, [isSubscribed, props.selected]);
-
-	return (
-		<OnboardingFrame
-			compact={props.compact}
-			contentWidth={props.contentWidth}
-			mouse={props.mouse}
-		>
-			<box
-				flexDirection="column"
-				border
-				borderStyle="rounded"
-				borderColor={isSubscribed ? palette.success : planAccent}
-				paddingX={1}
-				paddingY={1}
-				height={bodyHeight}
-				overflow="hidden"
-			>
-				<scrollbox
-					ref={scrollRef}
-					width="100%"
-					height="100%"
-					scrollY
-					scrollX={false}
-					viewportOptions={{ overflow: "hidden" }}
-					contentOptions={{ flexDirection: "column" }}
-				>
-					<box flexDirection="column" width="100%" flexShrink={0}>
-						<text
-							fg={isSubscribed ? palette.success : planAccent}
-							flexShrink={0}
-						>
-							{isSubscribed
-								? "ClinePass subscription active"
-								: "ClinePass subscription required"}
-						</text>
-
-						{isLoading ? (
-							<box flexDirection="row" gap={1} flexShrink={0}>
-								<spinner name="dots" color="gray" />
-								<text fg="gray">Checking your ClinePass subscription...</text>
-							</box>
-						) : isSubscribed ? (
-							<text fg={defaultFg} selectable flexShrink={0}>
-								Current plan: {props.currentPlanName || "ClinePass"}
-							</text>
-						) : isError ? (
-							<text
-								fg={defaultFg}
-								selectable
-								flexShrink={0}
-								content="Could not verify your ClinePass subscription. Re-check before choosing a ClinePass model."
-							/>
-						) : (
-							<text
-								fg={defaultFg}
-								selectable
-								flexShrink={0}
-								content="No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan."
-							/>
-						)}
-
-						{props.status === "error" &&
-							props.error &&
-							props.error !== "no plan found for user" && (
-								<text fg="red" selectable flexShrink={0}>
-									{props.error}
-								</text>
-							)}
-
-						{!isSubscribed && props.planFeatures.length > 0 && (
-							<box flexDirection="column" marginTop={1} flexShrink={0}>
-								{props.planFeatures.map((feature) => {
-									if (
-										feature === "Low cost subscription pricing" ||
-										feature === "Generous limits and reliable access" ||
-										feature === "Built for as many programmers as possible"
-									) {
-										return null;
-									}
-
-									return (
-										<text
-											key={feature}
-											fg={defaultFg}
-											selectable
-											flexShrink={0}
-										>
-											<span fg="green">✓ </span>
-											<span>{feature}</span>
-										</text>
-									);
-								})}
-							</box>
-						)}
-
-						{!isSubscribed && (
-							<box flexDirection="column" marginTop={1} flexShrink={0}>
-								{props.options.map((option, i) => {
-									const isSel = i === props.selected;
-									return (
-										<box
-											id={getClinePassSubscriptionOptionId(i)}
-											key={option.value}
-											paddingX={1}
-											flexDirection="row"
-											gap={1}
-											backgroundColor={isSel ? palette.selection : undefined}
-											height={1}
-											flexShrink={0}
-											overflow="hidden"
-										>
-											<text
-												fg={isSel ? palette.textOnSelection : "gray"}
-												flexShrink={0}
-											>
-												{isSel ? "\u276f" : " "}
-											</text>
-											<text
-												fg={isSel ? palette.textOnSelection : defaultFg}
-												flexShrink={0}
-											>
-												{option.label}
-											</text>
-										</box>
-									);
-								})}
-							</box>
-						)}
-
-						{props.openStatus && (
-							<text fg="gray" selectable flexShrink={0}>
-								{props.openStatus}
-							</text>
-						)}
-
-						{!isSubscribed && (
-							<box flexDirection="column" marginTop={1} flexShrink={0}>
-								<text fg="gray" flexShrink={0}>
-									If the browser button does not work:
-								</text>
-								<text fg={palette.act} selectable flexShrink={0}>
-									<a href={props.subscriptionUrl}>{props.subscriptionUrl}</a>
-								</text>
-							</box>
-						)}
-					</box>
-				</scrollbox>
-			</box>
-
-			<text fg="gray" paddingX={1}>
-				<em>↑/↓ navigate, Enter to select, Esc to go back, Ctrl+C to exit</em>
-			</text>
-		</OnboardingFrame>
-	);
-}
-
 export function OnboardingModelPickerScreen(props: {
 	activeProviderName: string;
 	compact: boolean;
@@ -6,7 +6,6 @@ import { useOnboardingController } from "./controller";
 import { getOAuthProviderLabel, type OnboardingResult } from "./model";
 import {
 	OnboardingClineModelScreen,
-	OnboardingClinePassSubscriptionScreen,
 	OnboardingCodexCliScreen,
 	OnboardingCustomModelIdScreen,
 	OnboardingDeviceCodeScreen,
@@ -122,24 +121,6 @@ export function OnboardingView(props: OnboardingViewProps) {
 		);
 	}

-	if (state.step === "cline_pass_subscription") {
-		return (
-			<OnboardingClinePassSubscriptionScreen
-				compact={compact}
-				contentWidth={contentWidth}
-				currentPlanName={state.clinePassCurrentPlanName}
-				error={state.clinePassSubscriptionError}
-				mouse={mouse}
-				openStatus={state.clinePassSubscriptionOpenStatus}
-				options={state.clinePassSubscriptionOptions}
-				planFeatures={state.clinePassPlanFeatures}
-				selected={state.clinePassSubscriptionSelected}
-				status={state.clinePassSubscriptionStatus}
-				subscriptionUrl={state.clinePassSubscriptionUrl}
-			/>
-		);
-	}
-
 	if (state.step === "model_picker") {
 		return (
 			<OnboardingModelPickerScreen
@@ -1,9 +1,8 @@
 import { describe, expect, it } from "vitest";
 import {
 	formatCliErrorMessage,
-	getCliNotSubscribedMessage,
 	getClineOrgIndividualInferenceSubscriptionMessage,
-	getCliSubscriptionUrl,
+	getClinePassSubscriptionUrl,
 	isClineOrgIndividualInferenceSubscriptionErrorMessage,
 	isClinePassSubscriptionError,
 } from "./cline-pass-errors";
@@ -16,18 +15,14 @@ describe("cline-pass-errors", () => {
 			),
 		).toBe(true);

-		const sdkFormatted =
-			"No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: https://app.cline.bot/dashboard/subscription?personal=true";
-		const formatted = getCliNotSubscribedMessage();
-		expect(isClinePassSubscriptionError(sdkFormatted)).toBe(true);
+		const formatted = `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getClinePassSubscriptionUrl()}`;
 		expect(isClinePassSubscriptionError(formatted)).toBe(true);
-		expect(formatCliErrorMessage(new Error(sdkFormatted))).toBe(formatted);
 		expect(formatCliErrorMessage(new Error(formatted))).toBe(formatted);
 	});

 	it("formats the ClinePass subscription URL", () => {
-		expect(getCliSubscriptionUrl()).toBe(
-			"https://app.cline.bot/promo?code=CLI-8OFF&personal=true",
+		expect(getClinePassSubscriptionUrl()).toBe(
+			"https://app.cline.bot/dashboard/subscription?personal=true",
 		);
 	});

@@ -1,36 +1,16 @@
 import {
-	type ClineSubscriptionPlan,
 	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
 	isClineNotSubscribedError,
 	isClineNotSubscribedMessage,
 	isClineOrgIndividualInferenceSubscriptionError,
 	isClineOrgIndividualInferenceSubscriptionMessage,
 } from "@cline/core";

-import { getClineEnvironmentConfig } from "@cline/shared";
-
-export { getClineOrgIndividualInferenceSubscriptionMessage };
-
-export const CLI_PROMO_CODE = "CLI-8OFF";
-
-export function getCliSubscriptionUrl(): string {
-	return `${new URL(
-		`/promo?code=${CLI_PROMO_CODE}&personal=true`,
-		getClineEnvironmentConfig().appBaseUrl,
-	).toString()}`;
-}
-
-export function getCliNotSubscribedMessage(): string {
-	return `No access to ClinePass subscription models yet. Subscribe to ClinePass, the low cost open weights model coding plan: ${getCliSubscriptionUrl()}`;
-}
-
-export function getIndividualPlanFeatures(
-	plans: ClineSubscriptionPlan[],
-): string[] {
-	const planWithFeatures = plans.find((plan) => plan.interval === "Monthly");
-
-	return planWithFeatures?.features?.included ?? [];
-}
+export {
+	getClineOrgIndividualInferenceSubscriptionMessage,
+	getClinePassSubscriptionUrl,
+};

 function isFormattedClinePassSubscriptionMessage(message: string): boolean {
 	const normalized = message.trim().toLowerCase();
@@ -79,9 +59,6 @@ export function isClineOrgIndividualInferenceSubscriptionErrorMessage(
 }

 export function formatCliErrorMessage(error: unknown): string {
-	if (isClinePassSubscriptionError(error)) {
-		return getCliNotSubscribedMessage();
-	}
 	if (isClineOrgIndividualInferenceSubscriptionErrorMessage(error)) {
 		return getClineOrgIndividualInferenceSubscriptionMessage();
 	}
@@ -61,7 +61,7 @@ export function truncate(str: string, maxLen: number): string {
 	return `${oneLine.slice(0, maxLen - 3)}...`;
 }

-export function formatStructuredCommand(cmd: unknown): string {
+function formatStructuredCommand(cmd: unknown): string {
 	if (typeof cmd === "string") {
 		return cmd;
 	}
@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "vitest";

 const mocks = vi.hoisted(() => ({
 	listLocalProviders: vi.fn(async () => ({ providers: [], settingsPath: "" })),
+	getBooleanFlagEnabled: vi.fn(() => true),
 }));

 vi.mock("@cline/core", async (importOriginal) => {
@@ -12,13 +13,20 @@ vi.mock("@cline/core", async (importOriginal) => {
 	};
 });

+vi.mock("./feature-flags", () => ({
+	getCliFeatureFlagsService: () => ({
+		getBooleanFlagEnabled: mocks.getBooleanFlagEnabled,
+	}),
+}));
+
 describe("listLocalProviders", () => {
-	it("enables ClinePass when listing the SDK provider list", async () => {
+	it("passes the ClinePass feature flag into the SDK provider list", async () => {
 		const { listLocalProviders } = await import("./provider-catalog");
 		const manager = {} as never;

 		await listLocalProviders(manager);

+		expect(mocks.getBooleanFlagEnabled).toHaveBeenCalledWith("ext-cline-pass");
 		expect(mocks.listLocalProviders).toHaveBeenCalledWith(manager, {
 			isClinePassEnabled: true,
 		});
@@ -2,11 +2,13 @@ import {
 	listLocalProviders as internalListLocalProviders,
 	type ProviderSettingsManager,
 } from "@cline/core";
+import { getCliFeatureFlagsService } from "./feature-flags";

 export async function listLocalProviders(
 	manager: ProviderSettingsManager,
 ): ReturnType<typeof internalListLocalProviders> {
 	return await internalListLocalProviders(manager, {
-		isClinePassEnabled: true,
+		isClinePassEnabled:
+			getCliFeatureFlagsService().getBooleanFlagEnabled("ext-cline-pass"),
 	});
 }
@@ -1,89 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveCliReasoning } from "./reasoning";
-
-describe("resolveCliReasoning", () => {
-	it("leaves reasoning unset when neither CLI nor persisted settings specify it", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-			}),
-		).toEqual({
-			thinking: undefined,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("preserves explicit --thinking none as disabled reasoning", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				thinkingExplicitlySet: true,
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("prefers explicit --thinking over persisted reasoning settings", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: true,
-				thinkingExplicitlySet: true,
-				reasoningEffort: "low",
-				persistedReasoning: { enabled: false },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "low",
-		});
-	});
-
-	it("uses persisted disabled reasoning when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: false },
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("uses persisted effort none as disabled reasoning when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { effort: "none" },
-			}),
-		).toEqual({
-			thinking: false,
-			reasoningEffort: undefined,
-		});
-	});
-
-	it("uses persisted active effort when --thinking is unset", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: true, effort: "high" },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "high",
-		});
-	});
-
-	it("uses medium effort when persisted reasoning is enabled without an effort", () => {
-		expect(
-			resolveCliReasoning({
-				thinking: false,
-				persistedReasoning: { enabled: true },
-			}),
-		).toEqual({
-			thinking: true,
-			reasoningEffort: "medium",
-		});
-	});
-});
@@ -1,65 +0,0 @@
-import type { ProviderSettings } from "@cline/core";
-import type { CliReasoningEffort } from "./types";
-
-type ActiveCliReasoningEffort = Exclude<CliReasoningEffort, "none">;
-
-const ACTIVE_REASONING_EFFORTS = new Set<ActiveCliReasoningEffort>([
-	"low",
-	"medium",
-	"high",
-	"xhigh",
-]);
-
-export interface ResolveCliReasoningInput {
-	thinking: boolean;
-	thinkingExplicitlySet?: boolean;
-	reasoningEffort?: CliReasoningEffort;
-	persistedReasoning?: ProviderSettings["reasoning"];
-}
-
-export interface ResolvedCliReasoning {
-	thinking?: boolean;
-	reasoningEffort?: ActiveCliReasoningEffort;
-}
-
-function isActiveReasoningEffort(
-	effort: unknown,
-): effort is ActiveCliReasoningEffort {
-	return (
-		typeof effort === "string" &&
-		ACTIVE_REASONING_EFFORTS.has(effort as ActiveCliReasoningEffort)
-	);
-}
-
-export function resolveCliReasoning({
-	thinking,
-	thinkingExplicitlySet,
-	reasoningEffort,
-	persistedReasoning,
-}: ResolveCliReasoningInput): ResolvedCliReasoning {
-	if (thinkingExplicitlySet) {
-		return {
-			thinking,
-			reasoningEffort: isActiveReasoningEffort(reasoningEffort)
-				? reasoningEffort
-				: undefined,
-		};
-	}
-
-	if (
-		persistedReasoning?.enabled === false ||
-		persistedReasoning?.effort === "none"
-	) {
-		return { thinking: false, reasoningEffort: undefined };
-	}
-
-	if (isActiveReasoningEffort(persistedReasoning?.effort)) {
-		return { thinking: true, reasoningEffort: persistedReasoning.effort };
-	}
-
-	if (persistedReasoning?.enabled === true) {
-		return { thinking: true, reasoningEffort: "medium" };
-	}
-
-	return { thinking: undefined, reasoningEffort: undefined };
-}
@@ -25,7 +25,7 @@ export interface Config extends Omit<CoreSessionConfig, "apiKey" | "mode"> {
 	timeoutSeconds?: number;
 	sandbox: boolean;
 	sandboxDataDir?: string;
-	thinking?: boolean;
+	thinking: boolean;
 	outputMode: CliOutputMode;
 	mode: CliAgentMode;
 	defaultToolAutoApprove: boolean;
@@ -3,9 +3,3 @@ import { Llms } from "@cline/core";
 export function shouldShowCliUsageCost(providerId: string): boolean {
 	return Llms.shouldShowProviderUsageCost(providerId);
 }
-
-export function shouldShowCliUsageCoveredBySubscription(
-	providerId: string,
-): boolean {
-	return Llms.resolveProviderUsageCostDisplay(providerId) === "subscription";
-}
@@ -77,17 +77,12 @@ function getOwnServerRecord(
 * than once to verify deterministic output. Throw McpSettingsUpdateSkippedError
 * for normal no-op cases instead of returning a boolean that callers can ignore.
 */
-function mutateServers(
-	mutate: (servers: Record<string, unknown>) => void,
-): void {
+function mutateServers(mutate: (servers: Record<string, unknown>) => void): void {
 	updateMcpSettingsFileSync(getSettingsPath(), (settings) => {
 		const serversValue = settings.mcpServers;
-		const servers =
-			serversValue &&
-			typeof serversValue === "object" &&
-			!Array.isArray(serversValue)
-				? { ...(serversValue as Record<string, unknown>) }
-				: {};
+		const servers = serversValue && typeof serversValue === "object" && !Array.isArray(serversValue)
+			? { ...(serversValue as Record<string, unknown>) }
+			: {};
 		mutate(servers);
 		settings.mcpServers = servers;
 	});
@@ -103,9 +98,7 @@ export function removeServer(name: string): boolean {
 	try {
 		mutateServers((servers) => {
 			if (!(name in servers)) {
-				throw new McpSettingsUpdateSkippedError(
-					`MCP server not found: ${name}`,
-				);
+				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
 			}
 			delete servers[name];
 		});
@@ -133,9 +126,7 @@ export function clearServerOAuth(name: string): void {
 		mutateServers((servers) => {
 			const existing = getOwnServerRecord(servers, name);
 			if (!existing) {
-				throw new McpSettingsUpdateSkippedError(
-					`MCP server not found: ${name}`,
-				);
+				throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
 			}
 			delete existing.oauth;
 			servers[name] = existing;
@@ -1,5 +1,3 @@
-import { isIP } from "node:net";
-
 export interface ClineHubServerOptions {
 	host: string;
 	port: number;
@@ -49,9 +47,6 @@ function normalizePublicUrl(
 			`PUBLIC_URL must use http: or https:, got ${parsed.protocol}`,
 		);
 	}
-	if (shouldAddDashboardPortToPublicUrl(parsed, port)) {
-		parsed.port = String(port);
-	}
 	parsed.hash = "";
 	return parsed.toString().replace(/\/$/, "");
 }
@@ -90,26 +85,12 @@ export function resolveClineHubServerOptions(
 	};
 }

-function isDefaultProtocolPort(url: URL, port: number): boolean {
-	return (
-		(url.protocol === "http:" && port === 80) ||
-		(url.protocol === "https:" && port === 443)
-	);
-}
-
-function shouldAddDashboardPortToPublicUrl(url: URL, port: number): boolean {
-	if (url.port || isDefaultProtocolPort(url, port)) return false;
-	const hostname = url.hostname.replace(/^\[|\]$/g, "");
-	return hostname === "localhost" || isIP(hostname) !== 0;
-}
-
 export function buildInviteUrl(
 	publicUrl: string,
 	roomSecret: string | undefined,
 ): string {
+	if (!roomSecret) return publicUrl;
 	const url = new URL(publicUrl);
-	if (roomSecret) {
-		url.searchParams.set("roomSecret", roomSecret);
-	}
+	url.searchParams.set("roomSecret", roomSecret);
 	return url.toString();
 }
@@ -4,7 +4,6 @@ import {
 	handleToolApprovalResponse,
 	rejectOrphanedApprovals,
 } from "./server/approvals";
-import { isAuthorizedBrowserToDesktopRequest } from "./server/browser-auth";
 import {
 	browserConfig,
 	host,
@@ -15,11 +14,7 @@ import {
 	webviewDistDir,
 } from "./server/deps";
 import { handleDesktopCommand } from "./server/desktop-commands";
-import {
-	createJsonResponse,
-	isWebviewRoute,
-	WebviewAssets,
-} from "./server/http";
+import { createJsonResponse, WebviewAssets } from "./server/http";
 import {
 	attachHub,
 	detachHub,
@@ -58,33 +53,17 @@ export interface ClineHubDashboardServer {
 	stop: () => Promise<void>;
 }

-const PUBLIC_BROWSER_PATHS = new Set([
-	"/version",
-	"/health",
-	"/config.json",
-	"/api/marketplace/catalog",
-	"/icon.png",
-	"/icon.svg",
-	"/icon.ico",
-	"/32x32.png",
-	"/cline-logo-filled.svg",
-	"/favicon.svg",
-]);
-
-function isPublicStaticAssetPath(pathname: string): boolean {
-	return pathname.startsWith("/assets/") || PUBLIC_BROWSER_PATHS.has(pathname);
-}
-
-function isPublicBrowserRoute(_req: Request, url: URL): boolean {
-	return isWebviewRoute(url.pathname) || isPublicStaticAssetPath(url.pathname);
-}
-
 export async function startClineHubDashboardServer(): Promise<ClineHubDashboardServer> {
 	const ctx = new HubContext();
 	const assets = new WebviewAssets(webviewDistDir);
 	const syncClientsAndSessions = () => syncHubClientsAndSessions(ctx);
 	let stopped = false;

+	function isAuthorizedBrowserRequest(url: URL): boolean {
+		if (!roomSecret) return true;
+		return url.searchParams.get("roomSecret") === roomSecret;
+	}
+
 	await attachHub(ctx);
 	const healthInterval = setInterval(() => {
 		void (async () => {
@@ -98,21 +77,6 @@ export async function startClineHubDashboardServer(): Promise<ClineHubDashboardS
 		hostname: host,
 		async fetch(req, server) {
 			const url = new URL(req.url);
-			if (
-				!isAuthorizedBrowserToDesktopRequest(
-					req,
-					url,
-					{
-						bindHost: host,
-						port,
-						publicUrl,
-						roomSecret,
-					},
-					isPublicBrowserRoute,
-				)
-			) {
-				return createJsonResponse({ error: "unauthorized_browser" }, 403);
-			}
 			if (url.pathname === "/version") {
 				return createJsonResponse({ coreVersion: CORE_BUILD_VERSION });
 			}
@@ -121,6 +85,9 @@ export async function startClineHubDashboardServer(): Promise<ClineHubDashboardS
 				return createJsonResponse(hubStatusPayload(ctx));
 			}
 			if (url.pathname === "/browser") {
+				if (!isAuthorizedBrowserRequest(url)) {
+					return createJsonResponse({ error: "invalid_room_secret" }, 401);
+				}
 				const displayName = `Browser ${Math.random().toString(36).slice(2, 6)}`;
 				const data = {
 					socket: undefined as never,
@@ -1,359 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	allowedBrowserHosts,
-	allowedBrowserOrigins,
-	isAuthorizedBrowserRequest,
-	isAuthorizedBrowserToDesktopRequest,
-	requiresBrowserRequestAuth,
-} from "./browser-auth";
-
-const defaultOptions = {
-	bindHost: "127.0.0.1",
-	port: 8787,
-	publicUrl: "http://127.0.0.1:8787",
-};
-
-const publicRoute = (_req: Request, url: URL) => url.pathname === "/public";
-
-function browserRequest(
-	origin?: string,
-	init?: Omit<RequestInit, "headers"> & {
-		headers?: Record<string, string>;
-	},
-): Request {
-	return new Request("http://127.0.0.1:8787/browser", {
-		...init,
-		headers: {
-			host: "127.0.0.1:8787",
-			...(origin === undefined ? {} : { origin }),
-			...(init?.headers ?? {}),
-		},
-	});
-}
-
-describe("allowedBrowserOrigins", () => {
-	it("allows the configured public URL origin and local aliases for local binds", () => {
-		expect([...allowedBrowserOrigins(defaultOptions)].sort()).toEqual([
-			"http://127.0.0.1:8787",
-			"http://[::1]:8787",
-			"http://localhost:8787",
-		]);
-	});
-
-	it("uses the configured public URL scheme for local aliases", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					...defaultOptions,
-					publicUrl: "https://127.0.0.1:8787",
-				}),
-			].sort(),
-		).toEqual([
-			"https://127.0.0.1:8787",
-			"https://[::1]:8787",
-			"https://localhost:8787",
-		]);
-	});
-
-	it("omits default protocol ports for local alias origins", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "127.0.0.1",
-					port: 80,
-					publicUrl: "http://localhost",
-				}),
-			].sort(),
-		).toEqual(["http://127.0.0.1", "http://[::1]", "http://localhost"]);
-
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "127.0.0.1",
-					port: 443,
-					publicUrl: "https://localhost",
-				}),
-			].sort(),
-		).toEqual(["https://127.0.0.1", "https://[::1]", "https://localhost"]);
-	});
-
-	it("allows the configured public URL origin and explicit bind origin for non-local binds", () => {
-		expect(
-			[
-				...allowedBrowserOrigins({
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "https://example.ngrok-free.app",
-					roomSecret: "secret",
-				}),
-			].sort(),
-		).toEqual(["https://0.0.0.0:8787", "https://example.ngrok-free.app"]);
-	});
-});
-
-describe("allowedBrowserHosts", () => {
-	it("allows the configured public URL host and local aliases for local binds", () => {
-		expect([...allowedBrowserHosts(defaultOptions)].sort()).toEqual([
-			"127.0.0.1:8787",
-			"[::1]:8787",
-			"localhost:8787",
-		]);
-	});
-
-	it("omits default protocol ports for local alias hosts", () => {
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "127.0.0.1",
-					port: 80,
-					publicUrl: "http://localhost",
-				}),
-			].sort(),
-		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
-
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "127.0.0.1",
-					port: 443,
-					publicUrl: "https://localhost",
-				}),
-			].sort(),
-		).toEqual(["127.0.0.1", "[::1]", "localhost"]);
-	});
-
-	it("allows the configured public URL host and explicit bind host for non-local binds", () => {
-		expect(
-			[
-				...allowedBrowserHosts({
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "https://example.ngrok-free.app",
-					roomSecret: "secret",
-				}),
-			].sort(),
-		).toEqual(["0.0.0.0:8787", "example.ngrok-free.app"]);
-	});
-});
-
-describe("requiresBrowserRequestAuth", () => {
-	it("does not require browser auth for public GET routes", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/public"),
-				new URL("http://127.0.0.1:8787/public"),
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("requires browser auth for unknown paths even when they use GET", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-api"),
-				new URL("http://127.0.0.1:8787/future-api"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for privileged paths even when they use GET", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/browser"),
-				new URL("http://127.0.0.1:8787/browser"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for every WebSocket upgrade path", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-socket", {
-					headers: { upgrade: "websocket" },
-				}),
-				new URL("http://127.0.0.1:8787/future-socket"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("requires browser auth for every unsafe HTTP method", () => {
-		expect(
-			requiresBrowserRequestAuth(
-				new Request("http://127.0.0.1:8787/future-api", { method: "POST" }),
-				new URL("http://127.0.0.1:8787/future-api"),
-				publicRoute,
-			),
-		).toBe(true);
-	});
-});
-
-describe("isAuthorizedBrowserRequest", () => {
-	it.each([
-		"http://127.0.0.1:8787",
-		"http://localhost:8787",
-		"http://[::1]:8787",
-	])("accepts local dashboard origin %s without a room secret", (origin) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest(origin),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(true);
-	});
-
-	it.each([
-		undefined,
-		"",
-		"null",
-		"not a url",
-		"http://evil.attacker.example.com",
-		"http://127.0.0.1:9999",
-		"https://127.0.0.1:8787",
-	])("rejects untrusted origin %s", (origin) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest(origin),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(false);
-	});
-
-	it.each([
-		undefined,
-		"",
-		"evil.attacker.example.com",
-		"127.0.0.1:9999",
-		"localhost:9999",
-	])("rejects untrusted host %s", (host) => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787", {
-					headers: host === undefined ? { host: "" } : { host },
-				}),
-				new URL("http://127.0.0.1:8787/browser"),
-				defaultOptions,
-			),
-		).toBe(false);
-	});
-
-	it("allows explicit wildcard bind host and origin when a room secret is configured", () => {
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://0.0.0.0:8787", {
-					headers: { host: "0.0.0.0:8787" },
-				}),
-				new URL("http://0.0.0.0:8787/browser?roomSecret=invite-123"),
-				{
-					bindHost: "0.0.0.0",
-					port: 8787,
-					publicUrl: "http://127.0.0.1:8787",
-					roomSecret: "invite-123",
-				},
-			),
-		).toBe(true);
-	});
-
-	it("requires trusted origin, trusted host, and room secret when a room secret is configured", () => {
-		const options = { ...defaultOptions, roomSecret: "invite-123" };
-
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787"),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(true);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787"),
-				new URL("http://127.0.0.1:8787/browser"),
-				options,
-			),
-		).toBe(false);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://evil.attacker.example.com"),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(false);
-		expect(
-			isAuthorizedBrowserRequest(
-				browserRequest("http://127.0.0.1:8787", {
-					headers: { host: "evil.attacker.example.com" },
-				}),
-				new URL("http://127.0.0.1:8787/browser?roomSecret=invite-123"),
-				options,
-			),
-		).toBe(false);
-	});
-});
-
-describe("isAuthorizedBrowserToDesktopRequest", () => {
-	it("allows safe public GET routes without an origin", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/public"),
-				new URL("http://127.0.0.1:8787/public"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(true);
-	});
-
-	it("rejects future WebSocket paths from untrusted origins by default", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-socket", {
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://evil.attacker.example.com",
-						upgrade: "websocket",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-socket"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("rejects future unsafe HTTP routes from untrusted origins by default", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-api", {
-					method: "POST",
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://evil.attacker.example.com",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-api"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(false);
-	});
-
-	it("allows future unsafe HTTP routes from trusted origins", () => {
-		expect(
-			isAuthorizedBrowserToDesktopRequest(
-				new Request("http://127.0.0.1:8787/future-api", {
-					method: "POST",
-					headers: {
-						host: "127.0.0.1:8787",
-						origin: "http://127.0.0.1:8787",
-					},
-				}),
-				new URL("http://127.0.0.1:8787/future-api"),
-				defaultOptions,
-				publicRoute,
-			),
-		).toBe(true);
-	});
-});
@@ -1,134 +0,0 @@
-import { isNonLocalBindHost } from "../options";
-
-export interface BrowserRequestAuthOptions {
-	bindHost: string;
-	port: number;
-	publicUrl: string;
-	roomSecret?: string;
-}
-
-const SAFE_HTTP_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
-
-export type PublicBrowserRoutePredicate = (req: Request, url: URL) => boolean;
-
-function isWebSocketUpgrade(req: Request): boolean {
-	return req.headers.get("upgrade")?.toLowerCase() === "websocket";
-}
-
-function parseOrigin(value: string | null): string | undefined {
-	const origin = parseHeader(value);
-	try {
-		return new URL(origin ?? "").origin;
-	} catch {
-		return undefined;
-	}
-}
-
-function parseHeader(value: string | null): string | undefined {
-	const host = value?.trim().toLowerCase();
-	return host || undefined;
-}
-
-function formatHostForOrigin(host: string): string {
-	return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-}
-
-function isDefaultProtocolPort(protocol: string, port: number): boolean {
-	return (
-		(protocol === "http:" && port === 80) ||
-		(protocol === "https:" && port === 443)
-	);
-}
-
-function originForHost(protocol: string, host: string, port: number): string {
-	return new URL(`${protocol}//${formatHostForOrigin(host)}:${port}`).origin;
-}
-
-function hostHeaderForHost(
-	protocol: string,
-	host: string,
-	port: number,
-): string {
-	const formattedHost = formatHostForOrigin(host).toLowerCase();
-	return isDefaultProtocolPort(protocol, port)
-		? formattedHost
-		: `${formattedHost}:${port}`;
-}
-
-export function allowedBrowserOrigins({
-	bindHost,
-	port,
-	publicUrl,
-}: BrowserRequestAuthOptions): Set<string> {
-	const publicUrlParts = new URL(publicUrl);
-	const origins = new Set<string>();
-	origins.add(publicUrlParts.origin);
-
-	origins.add(originForHost(publicUrlParts.protocol, bindHost, port));
-
-	if (!isNonLocalBindHost(bindHost)) {
-		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
-			origins.add(originForHost(publicUrlParts.protocol, hostname, port));
-		}
-	}
-
-	return origins;
-}
-
-export function allowedBrowserHosts({
-	bindHost,
-	port,
-	publicUrl,
-}: BrowserRequestAuthOptions): Set<string> {
-	const publicUrlParts = new URL(publicUrl);
-	const hosts = new Set<string>();
-	const publicHost = publicUrlParts.host.toLowerCase();
-	hosts.add(publicHost);
-
-	hosts.add(hostHeaderForHost(publicUrlParts.protocol, bindHost, port));
-
-	if (!isNonLocalBindHost(bindHost)) {
-		for (const hostname of ["127.0.0.1", "localhost", "[::1]"]) {
-			hosts.add(hostHeaderForHost(publicUrlParts.protocol, hostname, port));
-		}
-	}
-
-	return hosts;
-}
-
-export function requiresBrowserRequestAuth(
-	req: Request,
-	url: URL,
-	isPublicBrowserRoute: PublicBrowserRoutePredicate,
-): boolean {
-	if (isWebSocketUpgrade(req)) return true;
-	if (!SAFE_HTTP_METHODS.has(req.method.toUpperCase())) return true;
-	return !isPublicBrowserRoute(req, url);
-}
-
-export function isAuthorizedBrowserRequest(
-	req: Request,
-	url: URL,
-	options: BrowserRequestAuthOptions,
-): boolean {
-	const host = parseHeader(req.headers.get("host"));
-	if (!host || !allowedBrowserHosts(options).has(host)) return false;
-
-	const origin = parseOrigin(req.headers.get("origin"));
-	if (!origin || !allowedBrowserOrigins(options).has(origin)) return false;
-
-	if (!options.roomSecret) return true;
-	return url.searchParams.get("roomSecret") === options.roomSecret;
-}
-
-export function isAuthorizedBrowserToDesktopRequest(
-	req: Request,
-	url: URL,
-	options: BrowserRequestAuthOptions,
-	isPublicBrowserRoute: PublicBrowserRoutePredicate,
-): boolean {
-	return (
-		!requiresBrowserRequestAuth(req, url, isPublicBrowserRoute) ||
-		isAuthorizedBrowserRequest(req, url, options)
-	);
-}
@@ -51,53 +51,18 @@ describe("marketplace installer", () => {
 		vi.restoreAllMocks();
 	});

-	function createInstalledOfficialPlugin(
-		clineDir: string,
-		slug: string,
-	): string {
-		const sourceKey = `official:https://github.com/cline/plugins.git#plugins/${slug}`;
-		const hash = createHash("sha256")
-			.update(sourceKey)
-			.digest("hex")
-			.slice(0, 12);
-		const installPath = join(
-			clineDir,
-			"plugins",
-			"_installed",
-			"official",
-			`${slug}-${hash}`,
-		);
-		mkdirSync(join(installPath, "package"), { recursive: true });
-		writeFileSync(
-			join(installPath, "package.json"),
-			JSON.stringify({ name: slug }, null, 2),
-			"utf8",
-		);
-		writeFileSync(
-			join(installPath, "package", "index.ts"),
-			`export default { name: "${slug}", manifest: { capabilities: ["tools"] } };`,
-			"utf8",
-		);
-		return installPath;
-	}
-
-	it("maps remote MCP catalog args to MCP settings shape", () => {
+	it("maps remote MCP catalog args to the hub MCP upsert shape", () => {
 		expect(
 			buildMarketplaceMcpInput([
 				"context7",
 				"--transport",
 				"http",
 				"https://mcp.context7.com/mcp",
-				"--header",
-				"Authorization: Bearer <token>",
 			]),
 		).toEqual({
 			name: "context7",
 			transportType: "streamableHttp",
 			url: "https://mcp.context7.com/mcp",
-			headers: {
-				Authorization: "Bearer <token>",
-			},
 			disabled: false,
 		});
 	});
@@ -318,6 +283,8 @@ describe("marketplace installer", () => {
 			"remove",
 			"cline-sdk",
 			"-g",
+			"-a",
+			"cline",
 			"-y",
 		]);
 	});
@@ -381,7 +348,7 @@ describe("marketplace installer", () => {
 		const spawnCommand = vi.fn(async () => ({
 			exitCode: 1,
 			stdout:
-				"Authorization: Bearer stdout-token\nAuthorization: Basic basic-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
+				"Authorization: Bearer stdout-token\napi key stdout-key\nOPENAI_API_KEY=compound-key",
 			stderr:
 				"TOKEN=stderr-token\npassword is stderr-password\nANTHROPIC_SECRET_KEY=anthropic-secret",
 		}));
@@ -403,16 +370,13 @@ describe("marketplace installer", () => {
 			message = error instanceof Error ? error.message : String(error);
 		}

-		expect(message).toContain("Authorization: Bearer [redacted]");
 		expect(message).toContain("Authorization: [redacted]");
-		expect(message).not.toContain("Authorization: Bearer [redacted]]");
 		expect(message).toContain("api key [redacted]");
 		expect(message).toContain("OPENAI_API_KEY=[redacted]");
 		expect(message).toContain("TOKEN=[redacted]");
 		expect(message).toContain("password is [redacted]");
 		expect(message).toContain("ANTHROPIC_SECRET_KEY=[redacted]");
 		expect(message).not.toContain("stdout-token");
-		expect(message).not.toContain("basic-token");
 		expect(message).not.toContain("stdout-key");
 		expect(message).not.toContain("compound-key");
 		expect(message).not.toContain("stderr-token");
@@ -501,78 +465,19 @@ describe("marketplace installer", () => {
 		]);
 	});

-	it("runs MCP installs through the current Cline CLI without prompts", async () => {
+	it("runs official plugin uninstalls through the current Cline CLI", async () => {
 		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
 		const spawnCommand = vi.fn(async () => ({
 			exitCode: 0,
 			stdout: JSON.stringify({
-				name: "context7",
-				status: "installed",
-				transport: {
-					type: "streamableHttp",
-					url: "https://mcp.context7.com/mcp",
-					headers: {
-						Authorization: "Bearer token",
-					},
-				},
+				name: "goal",
+				installPath: "/tmp/plugin",
+				removedPaths: ["/tmp/plugin"],
+				entryPaths: [],
 			}),
 			stderr: "",
 		}));

-		await expect(
-			installMarketplaceEntry(
-				{
-					entry: {
-						id: "context7",
-						type: "mcp",
-						name: "Context7",
-						install: {
-							args: [
-								"context7",
-								"--transport",
-								"http",
-								"https://mcp.context7.com/mcp",
-								"--header",
-								"Authorization: Bearer token",
-							],
-						},
-					},
-				},
-				{ spawnCommand },
-			),
-		).resolves.toMatchObject({
-			status: "installed",
-			message: "Installed Context7.",
-			details: {
-				name: "context7",
-				status: "installed",
-			},
-		});
-
-		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
-			"mcp",
-			"install",
-			"--yes",
-			"--json",
-			"context7",
-			"--transport",
-			"http",
-			"https://mcp.context7.com/mcp",
-			"--header",
-			"Authorization: Bearer token",
-		]);
-	});
-
-	it("uninstalls official marketplace plugins through the shared core service", async () => {
-		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-plugin-"));
-		process.env.CLINE_DIR = clineDir;
-		const installPath = createInstalledOfficialPlugin(clineDir, "goal");
-		const spawnCommand = vi.fn(async () => ({
-			exitCode: 0,
-			stdout: "",
-			stderr: "",
-		}));
-
 		await expect(
 			uninstallMarketplaceEntry(
 				{
@@ -590,8 +495,12 @@ describe("marketplace installer", () => {
 			message: "Uninstalled Goal.",
 		});

-		expect(spawnCommand).not.toHaveBeenCalled();
-		expect(existsSync(installPath)).toBe(false);
+		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
+			"plugin",
+			"uninstall",
+			"goal",
+			"--json",
+		]);
 	});

 	it("resolves desktop installs from the server catalog instead of browser-sent args", async () => {
@@ -635,12 +544,15 @@ describe("marketplace installer", () => {
 	});

 	it("resolves desktop uninstalls from the server catalog instead of browser-sent args", async () => {
-		const clineDir = mkdtempSync(join(tmpdir(), "cline-marketplace-plugin-"));
-		process.env.CLINE_DIR = clineDir;
-		const installPath = createInstalledOfficialPlugin(clineDir, "goal");
+		process.env.CLINE_WRAPPER_PATH = "/usr/local/bin/cline";
 		const spawnCommand = vi.fn(async () => ({
 			exitCode: 0,
-			stdout: "",
+			stdout: JSON.stringify({
+				name: "goal",
+				installPath: "/tmp/plugin",
+				removedPaths: ["/tmp/plugin"],
+				entryPaths: [],
+			}),
 			stderr: "",
 		}));

@@ -668,8 +580,12 @@ describe("marketplace installer", () => {
 			},
 		);

-		expect(spawnCommand).not.toHaveBeenCalled();
-		expect(existsSync(installPath)).toBe(false);
+		expect(spawnCommand).toHaveBeenCalledWith("/usr/local/bin/cline", [
+			"plugin",
+			"uninstall",
+			"goal",
+			"--json",
+		]);
 	});

 	it("uninstalls MCP marketplace entries from Cline MCP settings", async () => {
@@ -8,7 +8,7 @@ import {
 	unlinkSync,
 	writeFileSync,
 } from "node:fs";
-import { homedir as osHomedir, platform } from "node:os";
+import { homedir, platform } from "node:os";
 import {
 	basename,
 	dirname,
@@ -18,15 +18,16 @@ import {
 	resolve,
 } from "node:path";
 import {
-	type MarketplaceActionResult,
-	type MarketplaceEntryInput,
 	resolveSkillsConfigSearchPaths,
 	resolveWorkflowsConfigSearchPaths,
-	uninstallMarketplaceEntry as uninstallCoreMarketplaceEntry,
 	uninstallPlugin as uninstallLocalPlugin,
 } from "@cline/core";
 import { resolveClineDir } from "@cline/shared/storage";
-import { deleteMcpServer, readMcpServersResponse } from "./mcp";
+import {
+	deleteMcpServer,
+	readMcpServersResponse,
+	upsertMcpServer,
+} from "./mcp";
 import type { JsonRecord } from "./types";

 type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
@@ -89,12 +90,6 @@ const MARKETPLACE_CATALOG_URL =
 	"https://cline.github.io/marketplace/catalog.json";
 const SECRET_PATTERN =
 	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i;
-const SECRET_KEY_VALUE_PATTERN =
-	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi;
-const SECRET_BEARER_VALUE_PATTERN =
-	/((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi;
-const SECRET_AUTHORIZATION_VALUE_PATTERN =
-	/((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi;

 export async function fetchMarketplaceCatalog(
 	fetchImpl: CatalogFetch = fetch,
@@ -275,10 +270,11 @@ function redactOutput(value: string): string {
 	const lines = value.split(/\r?\n/).map((line) => {
 		if (!SECRET_PATTERN.test(line)) return line;
 		return line
-			.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
-			.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
-			.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
-			.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
+			.replace(
+				/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi,
+				"$1[redacted]",
+			)
+			.replace(/\b(Bearer)\s+\S+/gi, "$1 [redacted]")
 			.replace(
 				/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
 				"$1[redacted]",
@@ -378,7 +374,6 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 		throw new Error("MCP marketplace install requires a server name");
 	}
 	let transportType = "stdio";
-	const headers: Record<string, string> = {};
 	const targetArgs: string[] = [];
 	let parsingMarketplaceOptions = true;
 	for (let index = 0; index < rest.length; index++) {
@@ -394,40 +389,11 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 			index++;
 			continue;
 		}
-		const shouldParseHeader =
-			parsingMarketplaceOptions ||
-			normalizeTransport(transportType) !== "stdio";
-		if (
-			shouldParseHeader &&
-			(arg === "--header" || arg?.startsWith("--header="))
-		) {
-			const rawHeader =
-				arg === "--header" ? rest[++index] : arg.slice("--header=".length);
-			if (!rawHeader) throw new Error("--header requires a value");
-			const separatorIndex = rawHeader.indexOf(":");
-			if (separatorIndex <= 0) {
-				throw new Error(
-					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
-				);
-			}
-			const headerName = rawHeader.slice(0, separatorIndex).trim();
-			const headerValue = rawHeader.slice(separatorIndex + 1).trim();
-			if (!headerName || !headerValue) {
-				throw new Error(
-					`Invalid MCP header "${rawHeader}". Expected "Header-Name: header value".`,
-				);
-			}
-			headers[headerName] = headerValue;
-			continue;
-		}
 		parsingMarketplaceOptions = false;
 		targetArgs.push(arg);
 	}
 	transportType = normalizeTransport(transportType);
 	if (transportType === "stdio") {
-		if (Object.keys(headers).length > 0) {
-			throw new Error("Stdio MCP installs do not support request headers.");
-		}
 		const [command, ...commandArgs] = targetArgs;
 		if (!command?.trim()) {
 			throw new Error("Stdio MCP install requires a command");
@@ -449,7 +415,6 @@ export function buildMarketplaceMcpInput(args: string[]): JsonRecord {
 		name,
 		transportType,
 		url,
-		headers: Object.keys(headers).length > 0 ? headers : undefined,
 		disabled: false,
 	};
 }
@@ -605,12 +570,6 @@ function isOfficialPluginInstalled(entry: MarketplaceInstallInput): boolean {
 	return Boolean(installPath && existsSync(installPath));
 }

-function resolveHomeDir(): string {
-	return (
-		process.env.HOME?.trim() || process.env.USERPROFILE?.trim() || osHomedir()
-	);
-}
-
 function normalizeMatchValue(value: string | undefined): string {
 	return (value ?? "")
 		.toLowerCase()
@@ -647,12 +606,12 @@ function getSkillInstallCandidates(entry: MarketplaceInstallInput): string[] {
 function getGlobalSkillPaths(skillName: string): string[] {
 	return [
 		join(resolveClineDir(), "skills", skillName, "SKILL.md"),
-		join(resolveHomeDir(), ".agents", "skills", skillName, "SKILL.md"),
+		join(homedir(), ".agents", "skills", skillName, "SKILL.md"),
 	].filter((path, index, paths) => paths.indexOf(path) === index);
 }

 function ensureGlobalSkillsDirWritable(): void {
-	const skillsDir = join(resolveHomeDir(), ".agents", "skills");
+	const skillsDir = join(homedir(), ".agents", "skills");
 	try {
 		mkdirSync(skillsDir, { recursive: true });
 		const probePath = join(
@@ -795,6 +754,50 @@ async function installSkill(
 	};
 }

+async function uninstallSkill(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	const installedName = findInstalledGlobalSkillName(entry);
+	if (!installedName) {
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `${entry.name ?? entry.id} is not installed.`,
+		};
+	}
+	const result = await spawnCommand("npx", [
+		"-y",
+		"skills@latest",
+		"remove",
+		installedName,
+		"-g",
+		"-a",
+		"cline",
+		"-y",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Skill uninstall failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	const output = commandOutput(result);
+	if (isGlobalSkillInstalled(entry)) {
+		throw new Error(
+			`Skill uninstall completed, but ${entry.name ?? entry.id} is still present in Cline's global skills directories.`,
+		);
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "uninstalled",
+		message: `Uninstalled ${entry.name ?? entry.id}.`,
+		output,
+	};
+}
+
 async function installPlugin(
 	entry: MarketplaceInstallInput,
 	spawnCommand: SpawnCommand,
@@ -845,6 +848,47 @@ async function installPlugin(
 	};
 }

+async function uninstallPlugin(
+	entry: MarketplaceInstallInput,
+	spawnCommand: SpawnCommand,
+): Promise<MarketplaceInstallResult> {
+	const installArgs = entry.install.args ?? [];
+	const target = installArgs[0]?.trim() || entry.id;
+	if (!target) {
+		throw new Error("Plugin marketplace uninstalls require a plugin name.");
+	}
+	const { command, argsPrefix } = resolveClineInvocation();
+	const result = await spawnCommand(command, [
+		...argsPrefix,
+		"plugin",
+		"uninstall",
+		target,
+		"--json",
+	]);
+	if (result.exitCode !== 0) {
+		const output = commandOutput(result);
+		throw new Error(
+			`Plugin uninstall failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
+		);
+	}
+	let details: JsonRecord | undefined;
+	try {
+		details = result.stdout.trim()
+			? (JSON.parse(result.stdout.trim()) as JsonRecord)
+			: undefined;
+	} catch {
+		details = undefined;
+	}
+	return {
+		id: entry.id,
+		type: entry.type,
+		status: "uninstalled",
+		message: `Uninstalled ${entry.name ?? entry.id}.`,
+		details,
+		output: commandOutput(result),
+	};
+}
+
 export async function installMarketplaceEntry(
 	args?: Record<string, unknown>,
 	options: { spawnCommand?: SpawnCommand } = {},
@@ -852,38 +896,14 @@ export async function installMarketplaceEntry(
 	const entry = readInstallInput(args);
 	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
 	if (entry.type === "mcp") {
-		// Validate marketplace args before handing them to the CLI-backed installer.
-		buildMarketplaceMcpInput(entry.install.args ?? []);
-		const { command, argsPrefix } = resolveClineInvocation();
-		const result = await spawnCommand(command, [
-			...argsPrefix,
-			"mcp",
-			"install",
-			"--yes",
-			"--json",
-			...(entry.install.args ?? []),
-		]);
-		if (result.exitCode !== 0) {
-			const output = commandOutput(result);
-			throw new Error(
-				`MCP install failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`,
-			);
-		}
-		let details: JsonRecord | undefined;
-		try {
-			details = result.stdout.trim()
-				? (JSON.parse(result.stdout.trim()) as JsonRecord)
-				: undefined;
-		} catch {
-			details = undefined;
-		}
+		const input = buildMarketplaceMcpInput(entry.install.args ?? []);
+		const response = upsertMcpServer(input);
 		return {
 			id: entry.id,
 			type: entry.type,
 			status: "installed",
-			message: `Installed ${entry.name ?? entry.id}.`,
-			details,
-			output: commandOutput(result),
+			message: `Installed ${entry.name ?? input.name ?? entry.id}.`,
+			details: { mcp: response },
 		};
 	}
 	if (entry.type === "skill") {
@@ -901,21 +921,24 @@ export async function uninstallMarketplaceEntry(
 ): Promise<MarketplaceInstallResult> {
 	const entry = readInstallInput(args);
 	const spawnCommand = options.spawnCommand ?? defaultSpawnCommand;
-	let mcpDetails: JsonRecord | undefined;
-	const result = await uninstallCoreMarketplaceEntry(
-		entry satisfies MarketplaceEntryInput,
-		{
-			deleteMcpServer: (name) => {
-				mcpDetails = deleteMcpServer(name);
-			},
-			spawnCommand: (command, commandArgs) =>
-				spawnCommand(command, commandArgs),
-		},
-	);
-	return {
-		...(result satisfies MarketplaceActionResult),
-		details: mcpDetails ? { mcp: mcpDetails } : undefined,
-	};
+	if (entry.type === "mcp") {
+		const input = buildMarketplaceMcpInput(entry.install.args ?? []);
+		const response = deleteMcpServer(String(input.name ?? ""));
+		return {
+			id: entry.id,
+			type: entry.type,
+			status: "uninstalled",
+			message: `Uninstalled ${entry.name ?? input.name ?? entry.id}.`,
+			details: { mcp: response },
+		};
+	}
+	if (entry.type === "skill") {
+		return uninstallSkill(entry, spawnCommand);
+	}
+	if (entry.type === "plugin") {
+		return uninstallPlugin(entry, spawnCommand);
+	}
+	throw new Error(`Unsupported marketplace entry type: ${entry.type}`);
 }

 export async function installMarketplaceEntryFromCatalog(
@@ -85,8 +85,7 @@ export function setMcpServerDisabled(
 	// Hold the cross-process lock across read-modify-write so a concurrent writer
 	// (the extension, the CLI) cannot clobber this change.
 	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-			{}) as JsonRecord;
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 		const current = servers[name];
 		if (!current || typeof current !== "object") {
 			throw new Error(`unknown MCP server: ${name}`);
@@ -129,8 +128,7 @@ export function upsertMcpServer(input: JsonRecord): JsonRecord {
 	// Hold the cross-process lock across read-modify-write so a concurrent writer
 	// cannot clobber this upsert.
 	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-			{}) as JsonRecord;
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 		if (previousName && previousName !== name) {
 			delete servers[previousName];
 		}
@@ -145,8 +143,7 @@ export function deleteMcpServer(name: string): JsonRecord {
 	// Hold the cross-process lock across read-modify-write so a concurrent writer
 	// cannot resurrect the deleted server from a stale snapshot.
 	updateMcpSettingsFileSync(resolveMcpSettingsPath(), (settings) => {
-		const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-			{}) as JsonRecord;
+		const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 		delete servers[name];
 		settings.mcpServers = servers;
 	});
@@ -1,231 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mapHistoryToWebviewMessages } from "./session-mapping";
-
-describe("mapHistoryToWebviewMessages", () => {
-	it("hydrates assistant tool uses with following user tool results", () => {
-		const messages = mapHistoryToWebviewMessages([
-			{
-				id: "assistant-1",
-				role: "assistant",
-				content: [
-					{ type: "text", text: "I'll inspect the file." },
-					{
-						type: "tool_use",
-						id: "toolu_1",
-						name: "read_file",
-						input: { path: "src/index.ts" },
-					},
-				],
-			},
-			{
-				id: "user-1",
-				role: "user",
-				content: [
-					{
-						type: "tool_result",
-						id: "result-block-1",
-						tool_use_id: "toolu_1",
-						name: "read_file",
-						content: "export const value = 1;",
-					},
-				],
-			},
-		]);
-
-		expect(messages).toHaveLength(1);
-		expect(messages[0]).toMatchObject({
-			id: "assistant-1",
-			role: "assistant",
-			text: "I'll inspect the file.",
-			toolEvents: [
-				{
-					toolCallId: "toolu_1",
-					name: "read_file",
-					state: "output-available",
-					input: { path: "src/index.ts" },
-					output: "export const value = 1;",
-				},
-			],
-		});
-		expect(messages[0].blocks).toEqual([
-			{
-				id: "assistant-1:text:0",
-				type: "text",
-				text: "I'll inspect the file.",
-			},
-			{
-				id: "assistant-1:tool:toolu_1",
-				type: "tool",
-				toolEvent: expect.objectContaining({
-					toolCallId: "toolu_1",
-					name: "read_file",
-					state: "output-available",
-					output: "export const value = 1;",
-				}),
-			},
-		]);
-	});
-
-	it("hydrates error tool results", () => {
-		const messages = mapHistoryToWebviewMessages([
-			{
-				id: "assistant-1",
-				role: "assistant",
-				content: [
-					{
-						type: "tool_use",
-						id: "toolu_1",
-						name: "read_file",
-						input: { path: "missing.ts" },
-					},
-				],
-			},
-			{
-				id: "user-1",
-				role: "user",
-				content: [
-					{
-						type: "tool_result",
-						tool_use_id: "toolu_1",
-						name: "read_file",
-						content: "File not found",
-						is_error: true,
-					},
-				],
-			},
-		]);
-
-		expect(messages).toHaveLength(1);
-		expect(messages[0].toolEvents).toEqual([
-			expect.objectContaining({
-				toolCallId: "toolu_1",
-				name: "read_file",
-				state: "output-error",
-				output: "File not found",
-				error: "File not found",
-			}),
-		]);
-		expect(messages[0].blocks?.[0]).toMatchObject({
-			type: "tool",
-			toolEvent: {
-				toolCallId: "toolu_1",
-				state: "output-error",
-				error: "File not found",
-			},
-		});
-	});
-
-	it("hydrates orphan tool results as standalone meta tool blocks", () => {
-		const messages = mapHistoryToWebviewMessages([
-			{
-				id: "user-1",
-				role: "user",
-				content: [
-					{
-						type: "tool_result",
-						tool_use_id: "toolu_orphan",
-						name: "read_file",
-						content: "orphan output",
-					},
-				],
-			},
-		]);
-
-		expect(messages).toHaveLength(1);
-		expect(messages[0]).toMatchObject({
-			id: "user-1",
-			role: "meta",
-			text: "",
-			toolEvents: [
-				{
-					toolCallId: "toolu_orphan",
-					name: "read_file",
-					state: "output-available",
-					input: undefined,
-					output: "orphan output",
-				},
-			],
-		});
-		expect(messages[0].blocks).toEqual([
-			{
-				id: "user-1:tool:toolu_orphan",
-				type: "tool",
-				toolEvent: expect.objectContaining({
-					toolCallId: "toolu_orphan",
-					input: undefined,
-					output: "orphan output",
-				}),
-			},
-		]);
-	});
-
-	it("hydrates plain string content as a text block", () => {
-		const messages = mapHistoryToWebviewMessages([
-			{
-				id: "assistant-1",
-				role: "assistant",
-				content: "Plain response",
-			},
-		]);
-
-		expect(messages).toEqual([
-			{
-				id: "assistant-1",
-				role: "assistant",
-				text: "Plain response",
-				reasoning: undefined,
-				reasoningRedacted: undefined,
-				toolEvents: undefined,
-				blocks: [
-					{
-						id: "assistant-1:text:0",
-						type: "text",
-						text: "Plain response",
-					},
-				],
-			},
-		]);
-	});
-
-	it("hydrates same-message tool-call and tool-result blocks", () => {
-		const messages = mapHistoryToWebviewMessages([
-			{
-				id: "assistant-1",
-				role: "assistant",
-				content: [
-					{
-						type: "tool-call",
-						toolCallId: "call_1",
-						toolName: "search",
-						input: { query: "cline" },
-					},
-					{
-						type: "tool-result",
-						toolCallId: "call_1",
-						toolName: "search",
-						output: [{ query: "cline", result: "found", success: true }],
-					},
-				],
-			},
-		]);
-
-		expect(messages).toHaveLength(1);
-		expect(messages[0].toolEvents).toEqual([
-			expect.objectContaining({
-				toolCallId: "call_1",
-				name: "search",
-				state: "output-available",
-				input: { query: "cline" },
-				output: [{ query: "cline", result: "found", success: true }],
-			}),
-		]);
-		expect(messages[0].blocks).toHaveLength(1);
-		expect(messages[0].blocks?.[0]).toMatchObject({
-			type: "tool",
-			toolEvent: {
-				toolCallId: "call_1",
-				state: "output-available",
-			},
-		});
-	});
-});
@@ -9,7 +9,6 @@ import type { HubContext } from "./state";
 import type { SessionContext, TrackedClient, TrackedSession } from "./types";
 import {
 	asNumber,
-	asRecord,
 	asString,
 	asTimestamp,
 	basename,
@@ -89,291 +88,27 @@ function summarizeClient(client: TrackedClient): {
 	};
 }

-type HistoryToolLocation = {
-	messageIndex: number;
-	blockIndex: number;
-};
-
-function historyContentParts(content: unknown): Record<string, unknown>[] {
-	if (Array.isArray(content)) {
-		return content
-			.map((part) => asRecord(part))
-			.filter((part): part is Record<string, unknown> => Boolean(part));
-	}
-	if (typeof content === "string" && content.trim()) {
-		return [{ type: "text", text: content }];
-	}
-	return [];
-}
-
-function blockType(block: Record<string, unknown>): string {
-	return asString(block.type)?.toLowerCase() ?? "";
-}
-
-function toolCallIdForCall(block: Record<string, unknown>): string | undefined {
-	return (
-		asString(block.id) ??
-		asString(block.toolCallId) ??
-		asString(block.tool_call_id)
-	);
-}
-
-function toolCallIdForResult(
-	block: Record<string, unknown>,
-): string | undefined {
-	return (
-		asString(block.tool_use_id) ??
-		asString(block.toolCallId) ??
-		asString(block.tool_call_id)
-	);
-}
-
-function toolNameFor(block: Record<string, unknown>): string {
-	return (
-		asString(block.name) ??
-		asString(block.toolName) ??
-		asString(block.tool_name) ??
-		"tool"
-	);
-}
-
-function toolInputFor(block: Record<string, unknown>): unknown {
-	return block.input ?? block.args ?? block.arguments;
-}
-
-function toolOutputFor(block: Record<string, unknown>): unknown {
-	return block.output ?? block.result ?? block.content;
-}
-
-function isErrorToolResult(block: Record<string, unknown>): boolean {
-	return (
-		block.is_error === true || block.isError === true || block.error === true
-	);
-}
-
-function pushTextBlock(
-	blocks: NonNullable<WebviewChatMessage["blocks"]>,
-	textParts: string[],
-	messageKey: string | number,
-	partIndex: number,
-	text: string,
-): void {
-	if (!text) return;
-	textParts.push(text);
-	blocks.push({
-		id: `${messageKey}:text:${partIndex}`,
-		type: "text",
-		text,
-	});
-}
-
-function pushReasoningBlock(
-	blocks: NonNullable<WebviewChatMessage["blocks"]>,
-	reasoningParts: string[],
-	messageKey: string | number,
-	partIndex: number,
-	text: string,
-	redacted?: boolean,
-): boolean {
-	if (!text) return false;
-	reasoningParts.push(text);
-	blocks.push({
-		id: `${messageKey}:reasoning:${partIndex}`,
-		type: "reasoning",
-		text,
-		redacted,
-	});
-	return redacted === true;
-}
-
 export function mapHistoryToWebviewMessages(
 	history: unknown[],
 ): WebviewChatMessage[] {
-	const mapped: WebviewChatMessage[] = [];
-	const toolLocations = new Map<string, HistoryToolLocation>();
-
-	for (const [index, entry] of history.entries()) {
+	return history.map((entry, index) => {
 		const record =
 			entry && typeof entry === "object"
 				? (entry as Record<string, unknown>)
 				: { content: entry };
-		const messageKey = asString(record.id) ?? `history-${index}`;
 		const rawRole = asString(record.role)?.toLowerCase();
-		let role: WebviewChatMessage["role"] =
+		const role: WebviewChatMessage["role"] =
 			rawRole === "user" || rawRole === "assistant" || rawRole === "error"
 				? rawRole
 				: "meta";
-		const blocks: NonNullable<WebviewChatMessage["blocks"]> = [];
-		const textParts: string[] = [];
-		const reasoningParts: string[] = [];
-		const toolEvents = new Map<
-			string,
-			NonNullable<WebviewChatMessage["toolEvents"]>[number]
-		>();
-		const currentToolBlockIndexes = new Map<string, number>();
-		let reasoningRedacted = false;
-
-		const contentParts = historyContentParts(record.content);
-		if (contentParts.length === 0) {
-			const text = stringifyContent(record.content ?? record.text ?? record);
-			pushTextBlock(blocks, textParts, messageKey, 0, text);
-		}
-
-		for (const [partIndex, part] of contentParts.entries()) {
-			const type = blockType(part);
-			if (type === "text") {
-				pushTextBlock(
-					blocks,
-					textParts,
-					messageKey,
-					partIndex,
-					asString(part.text) ?? asString(part.content) ?? "",
-				);
-				continue;
-			}
-
-			if (type === "thinking" || type === "reasoning") {
-				reasoningRedacted =
-					pushReasoningBlock(
-						blocks,
-						reasoningParts,
-						messageKey,
-						partIndex,
-						asString(part.thinking) ??
-							asString(part.reasoning) ??
-							asString(part.text) ??
-							"",
-						part.redacted === true,
-					) || reasoningRedacted;
-				continue;
-			}
-
-			if (type === "redacted_thinking") {
-				reasoningRedacted =
-					pushReasoningBlock(
-						blocks,
-						reasoningParts,
-						messageKey,
-						partIndex,
-						"[redacted]",
-						true,
-					) || reasoningRedacted;
-				continue;
-			}
-
-			if (type === "tool_use" || type === "tool-call") {
-				const toolCallId =
-					toolCallIdForCall(part) ?? `${messageKey}:${partIndex}`;
-				const name = toolNameFor(part);
-				const toolEvent = {
-					id: `${messageKey}:${toolCallId}`,
-					toolCallId,
-					name,
-					text: `Running ${name}...`,
-					state: "input-available" as const,
-					input: toolInputFor(part),
-				};
-				toolEvents.set(toolCallId, toolEvent);
-				blocks.push({
-					id: `${messageKey}:tool:${toolCallId}`,
-					type: "tool",
-					toolEvent,
-				});
-				currentToolBlockIndexes.set(toolCallId, blocks.length - 1);
-				toolLocations.set(toolCallId, {
-					messageIndex: mapped.length,
-					blockIndex: blocks.length - 1,
-				});
-				continue;
-			}
-
-			if (type === "tool_result" || type === "tool-result") {
-				const toolCallId =
-					toolCallIdForResult(part) ?? `${messageKey}:${partIndex}`;
-				const name = toolNameFor(part);
-				const output = toolOutputFor(part);
-				const isError = isErrorToolResult(part);
-				const currentBlockIndex = currentToolBlockIndexes.get(toolCallId);
-				const existingLocation = toolLocations.get(toolCallId);
-				const existing =
-					currentBlockIndex !== undefined
-						? blocks[currentBlockIndex]
-						: existingLocation !== undefined
-							? mapped[existingLocation.messageIndex]?.blocks?.[
-									existingLocation.blockIndex
-								]
-							: undefined;
-				const existingToolEvent =
-					existing?.type === "tool" ? existing.toolEvent : undefined;
-				const toolEvent = {
-					id: existingToolEvent?.id ?? `${messageKey}:${toolCallId}`,
-					toolCallId,
-					name: existingToolEvent?.name ?? name,
-					text: isError
-						? `${existingToolEvent?.name ?? name} failed`
-						: `${existingToolEvent?.name ?? name} completed`,
-					state: isError
-						? ("output-error" as const)
-						: ("output-available" as const),
-					input: existingToolEvent?.input,
-					output,
-					error: isError ? stringifyContent(output) : undefined,
-				};
-
-				if (currentBlockIndex !== undefined && existing?.type === "tool") {
-					blocks[currentBlockIndex] = {
-						...existing,
-						toolEvent,
-					};
-					toolEvents.set(toolCallId, toolEvent);
-				} else if (
-					existingLocation !== undefined &&
-					existing?.type === "tool"
-				) {
-					const target = mapped[existingLocation.messageIndex];
-					const targetBlocks = target.blocks;
-					const targetBlock = targetBlocks?.[existingLocation.blockIndex];
-					if (targetBlocks && targetBlock?.type === "tool") {
-						targetBlocks[existingLocation.blockIndex] = {
-							...targetBlock,
-							toolEvent,
-						};
-					}
-					target.toolEvents = (target.toolEvents ?? []).map((event) =>
-						event.toolCallId === toolCallId ? toolEvent : event,
-					);
-				} else {
-					toolEvents.set(toolCallId, toolEvent);
-					blocks.push({
-						id: `${messageKey}:tool:${toolCallId}`,
-						type: "tool",
-						toolEvent,
-					});
-				}
-			}
-		}
-
-		const text = textParts.join("\n");
-		const toolEventList = [...toolEvents.values()];
-		if (!text && reasoningParts.length === 0 && toolEventList.length === 0) {
-			continue;
-		}
-		if (!text && role === "user" && toolEventList.length > 0) {
-			role = "meta";
-		}
-		mapped.push({
-			id: messageKey,
+		const text = stringifyContent(record.content ?? record.text ?? record);
+		return {
+			id: asString(record.id) ?? `history-${index}`,
 			role,
 			text,
-			reasoning:
-				reasoningParts.length > 0 ? reasoningParts.join("\n") : undefined,
-			reasoningRedacted: reasoningRedacted || undefined,
-			toolEvents: toolEventList.length > 0 ? toolEventList : undefined,
-			blocks,
-		});
-	}
-
-	return mapped;
+			blocks: text ? [{ id: `history-${index}-text`, type: "text", text }] : [],
+		};
+	});
 }

 export function trackSession(record: unknown): TrackedSession | undefined {
@@ -41,23 +41,6 @@ expectEqual(
 	"invite URL",
 );

-const tailscale = resolveClineHubServerOptions({
-	HOST: "0.0.0.0",
-	CLINE_HUB_DASHBOARD_PORT: "8787",
-	PUBLIC_URL: "http://100.82.5.118",
-	ROOM_SECRET: "invite-123",
-});
-expectEqual(
-	tailscale.publicUrl,
-	"http://100.82.5.118:8787",
-	"direct IP public URL gets dashboard port",
-);
-expectEqual(
-	buildInviteUrl(tailscale.publicUrl, tailscale.roomSecret),
-	"http://100.82.5.118:8787/?roomSecret=invite-123",
-	"invite URL for direct IP public URL",
-);
-
 expectThrows(
 	() => resolveClineHubServerOptions({ HOST: "0.0.0.0" }),
 	"non-local bind without ROOM_SECRET",
@@ -21,7 +21,7 @@ export function PageFrame({
 					className,
 				)}
 			>
-				<div className={cn("max-w-344", contentClassName)}>{children}</div>
+				<div className={cn("max-w-[86rem]", contentClassName)}>{children}</div>
 			</div>
 		</ScrollArea>
 	);
@@ -134,7 +134,7 @@ export function ProviderListContent({
 								isPanel ? "text-[24px]" : "text-[32px]",
 							)}
 						>
-							Model Providers
+							Models
 						</h1>
 						<p className="mt-3 text-[15px] leading-6 text-muted-foreground">
 							Configure model providers and choose which ones are available.{" "}
@@ -1,5 +1,10 @@
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import {
+	existsSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+} from "node:fs";
 import { basename, dirname, extname, join } from "node:path";
 import type {
 	ClineAccountActionRequest,
@@ -1038,8 +1043,7 @@ export async function handleCommand(
 	if (command === "set_mcp_server_disabled") {
 		const path = ensureMcpSettingsFile();
 		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-				{}) as JsonRecord;
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 			const name = String(args?.name ?? "").trim();
 			const current = servers[name];
 			if (!current || typeof current !== "object") {
@@ -1090,8 +1094,7 @@ export async function handleCommand(
 					};
 		const path = ensureMcpSettingsFile();
 		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-				{}) as JsonRecord;
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 			if (previousName && previousName !== name) {
 				delete servers[previousName];
 			}
@@ -1103,8 +1106,7 @@ export async function handleCommand(
 	if (command === "delete_mcp_server") {
 		const path = ensureMcpSettingsFile();
 		updateMcpSettingsFileSync(path, (settings) => {
-			const servers = ((settings.mcpServers as JsonRecord | undefined) ??
-				{}) as JsonRecord;
+			const servers = ((settings.mcpServers as JsonRecord | undefined) ?? {}) as JsonRecord;
 			delete servers[String(args?.name ?? "")];
 			settings.mcpServers = servers;
 		});
@@ -2,7 +2,7 @@
 	"name": "claude-dev",
 	"displayName": "Cline",
 	"description": "Autonomous coding agent right in your IDE, capable of creating/editing files, running commands, using the browser, and more with your permission every step of the way.",
-	"version": "4.0.0",
+	"version": "3.89.0",
 	"icon": "assets/icons/icon.png",
 	"engines": {
 		"vscode": "^1.84.0"
@@ -42,7 +42,8 @@
 	"activationEvents": [
 		"onLanguage",
 		"onUri",
-		"onStartupFinished"
+		"onStartupFinished",
+		"workspaceContains:evals.env"
 	],
 	"main": "./dist/extension.js",
 	"contributes": {
@@ -137,11 +138,6 @@
 				"title": "MCP Servers",
 				"icon": "$(server)"
 			},
-			{
-				"command": "cline.marketplaceButtonClicked",
-				"title": "Customize",
-				"icon": "$(wrench)"
-			},
 			{
 				"command": "cline.historyButtonClicked",
 				"title": "History",
@@ -265,7 +261,7 @@
 					"when": "view == claude-dev.SidebarProvider"
 				},
 				{
-					"command": "cline.marketplaceButtonClicked",
+					"command": "cline.mcpButtonClicked",
 					"group": "navigation@2",
 					"when": "view == claude-dev.SidebarProvider"
 				},
@@ -395,7 +391,7 @@
 		"test:e2e:ui": "bun scripts/interactive-playwright.ts",
 		"install:all": "bun install",
 		"dev:webview": "cd webview-ui && bun run dev",
-		"build:webview": "bun run protos && cd webview-ui && bun run build",
+		"build:webview": "cd webview-ui && bun run build",
 		"test:webview": "cd webview-ui && bun run test",
 		"publish:marketplace": "node scripts/publish-marketplace.mjs",
 		"publish:marketplace:prerelease": "node scripts/publish-marketplace.mjs --pre-release",
@@ -3,13 +3,17 @@ syntax = "proto3";
 package cline;

 import "cline/common.proto";
+import "google/protobuf/timestamp.proto";

 option go_package = "github.com/cline/grpc-go/cline";
 option java_multiple_files = true;
 option java_package = "bot.cline.proto";

 service CheckpointsService {
+  rpc checkpointDiff(Int64Request) returns (Empty);
  rpc checkpointRestore(CheckpointRestoreRequest) returns (Empty);
+  rpc subscribeToCheckpoints(CheckpointSubscriptionRequest) returns (stream CheckpointEvent);
+  rpc getCwdHash(StringArrayRequest) returns (PathHashMap);
 }

 message CheckpointRestoreRequest {
@@ -18,3 +22,26 @@ message CheckpointRestoreRequest {
  string restore_type = 3;
  optional int64 offset = 4;
 }
+
+message CheckpointSubscriptionRequest {
+  string cwd_hash = 1;
+}
+
+message CheckpointEvent {
+  enum OperationType {
+    CHECKPOINT_INIT = 0;
+    CHECKPOINT_COMMIT = 1;
+    CHECKPOINT_RESTORE = 2;
+  }
+
+  OperationType operation = 1;
+  string cwd_hash = 2;
+  bool is_active = 3;
+  google.protobuf.Timestamp timestamp = 4;
+  optional string task_id = 5;
+  optional string commit_hash = 6;
+}
+
+message PathHashMap {
+  map<string, string> path_hash = 1;
+}
@@ -1,106 +0,0 @@
-syntax = "proto3";
-
-package cline;
-
-import "cline/common.proto";
-
-option go_package = "github.com/cline/grpc-go/cline";
-option java_multiple_files = true;
-option java_package = "bot.cline.proto";
-
-service MarketplaceService {
-  rpc getMarketplaceCatalog(EmptyRequest) returns (MarketplaceCatalog);
-  rpc listMarketplaceLocalInstalledEntries(EmptyRequest) returns (MarketplaceLocalInstalledEntries);
-  rpc listMarketplaceInstalledEntries(MarketplaceEntriesRequest) returns (MarketplaceInstalledEntries);
-  rpc installMarketplaceEntry(MarketplaceEntryRequest) returns (MarketplaceInstallResult);
-  rpc uninstallMarketplaceEntry(MarketplaceEntryRequest) returns (MarketplaceInstallResult);
-  rpc toggleMarketplaceLocalInstalledEntry(ToggleMarketplaceLocalInstalledEntryRequest) returns (MarketplaceLocalInstalledEntries);
-  rpc uninstallMarketplaceLocalInstalledEntry(MarketplaceLocalInstalledEntryRequest) returns (MarketplaceInstallResult);
-}
-
-message MarketplaceTag {
-  string label = 1;
-  optional string color = 2;
-}
-
-message MarketplaceCounts {
-  optional int32 tools = 1;
-  optional int32 prompts = 2;
-  optional int32 resources = 3;
-}
-
-message MarketplaceEnvVar {
-  string name = 1;
-  bool required = 2;
-  optional string description = 3;
-  optional string url = 4;
-}
-
-message MarketplaceInstall {
-  repeated string args = 1;
-  repeated MarketplaceEnvVar env = 2;
-  optional string command = 3;
-  optional string notes = 4;
-}
-
-message MarketplaceEntry {
-  string id = 1;
-  string type = 2;
-  string name = 3;
-  optional string tagline = 4;
-  optional string description = 5;
-  repeated string tags = 6;
-  repeated MarketplaceTag tag_objects = 7;
-  optional string author = 8;
-  optional string source_url = 9;
-  optional string homepage_url = 10;
-  optional MarketplaceCounts counts = 11;
-  optional MarketplaceInstall install = 12;
-}
-
-message MarketplaceCatalog {
-  repeated MarketplaceEntry entries = 1;
-}
-
-message MarketplaceEntriesRequest {
-  repeated MarketplaceEntry entries = 1;
-}
-
-message MarketplaceInstalledEntries {
-  repeated string installed_keys = 1;
-}
-
-message MarketplaceLocalInstalledEntry {
-  string id = 1;
-  string type = 2;
-  string name = 3;
-  optional string description = 4;
-  optional string path = 5;
-  optional string source = 6;
-  bool enabled = 7;
-}
-
-message MarketplaceLocalInstalledEntries {
-  repeated MarketplaceLocalInstalledEntry entries = 1;
-}
-
-message ToggleMarketplaceLocalInstalledEntryRequest {
-  MarketplaceLocalInstalledEntry entry = 1;
-  bool enabled = 2;
-}
-
-message MarketplaceLocalInstalledEntryRequest {
-  MarketplaceLocalInstalledEntry entry = 1;
-}
-
-message MarketplaceEntryRequest {
-  MarketplaceEntry entry = 1;
-}
-
-message MarketplaceInstallResult {
-  string id = 1;
-  string type = 2;
-  string status = 3;
-  string message = 4;
-  optional string output = 5;
-}
@@ -397,7 +397,7 @@ message ModelsApiOptions {
  optional bool azure_identity = 44;

  // Plan mode configurations
-  optional string plan_mode_api_provider = 100;
+  optional ApiProvider plan_mode_api_provider = 100;
  optional string plan_mode_api_model_id = 101;
  optional int64 plan_mode_thinking_budget_tokens = 102;
  optional string plan_mode_reasoning_effort = 103;
@@ -438,7 +438,7 @@ message ModelsApiOptions {
  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 138;

  // Act mode configurations
-  optional string act_mode_api_provider = 200;
+  optional ApiProvider act_mode_api_provider = 200;
  optional string act_mode_api_model_id = 201;
  optional int64 act_mode_thinking_budget_tokens = 202;
  optional string act_mode_reasoning_effort = 203;
@@ -568,6 +568,59 @@ message OcaCompatibleModelInfo {
  optional string error = 2;
 }

+// API Provider enumeration
+enum ApiProvider {
+  ANTHROPIC = 0;
+  OPENROUTER = 1;
+  BEDROCK = 2;
+  VERTEX = 3;
+  OPENAI = 4;
+  OLLAMA = 5;
+  LMSTUDIO = 6;
+  GEMINI = 7;
+  OPENAI_NATIVE = 8;
+  REQUESTY = 9;
+  TOGETHER = 10;
+  DEEPSEEK = 11;
+  QWEN = 12;
+  DOUBAO = 13;
+  MISTRAL = 14;
+  VSCODE_LM = 15;
+  CLINE = 16;
+  LITELLM = 17;
+  NEBIUS = 18;
+  FIREWORKS = 19;
+  ASKSAGE = 20;
+  XAI = 21;
+  SAMBANOVA = 22;
+  CEREBRAS = 23;
+  GROQ = 24;
+  SAPAICORE = 25;
+  CLAUDE_CODE = 26;
+  MOONSHOT = 27;
+  HUGGINGFACE = 28;
+  HUAWEI_CLOUD_MAAS = 29;
+  BASETEN = 30;
+  ZAI = 31;
+  VERCEL_AI_GATEWAY = 32;
+  QWEN_CODE = 33;
+  DIFY = 34;
+  OCA = 35;
+  MINIMAX = 36;
+  HICAP = 37;
+  AIHUBMIX = 38;
+  NOUSRESEARCH = 39;
+  OPENAI_CODEX = 40;
+  WANDB = 41;
+  CLINE_PASS = 42;
+  POOLSIDE = 45;
+  V0 = 46;
+  XIAOMI = 47;
+  ZAI_CODING_PLAN = 49;
+  reserved 43, 44, 48;
+  reserved "OPENAI_CODEX_CLI", "OPENCODE", "KILO";
+}
+
 enum ApiFormat {
  ANTHROPIC_CHAT = 0;
  GEMINI_CHAT = 1;
@@ -707,7 +760,7 @@ message ModelsApiConfiguration {
  optional string wandb_api_key = 87;

  // Plan mode configurations
-  optional string plan_mode_api_provider = 100;
+  optional ApiProvider plan_mode_api_provider = 100;
  optional string plan_mode_api_model_id = 101;
  optional int64 plan_mode_thinking_budget_tokens = 102;
  optional string plan_mode_reasoning_effort = 103;
@@ -753,7 +806,7 @@ message ModelsApiConfiguration {
  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 143;

  // Act mode configurations
-  optional string act_mode_api_provider = 200;
+  optional ApiProvider act_mode_api_provider = 200;
  optional string act_mode_api_model_id = 201;
  optional int64 act_mode_thinking_budget_tokens = 202;
  optional string act_mode_reasoning_effort = 203;
@@ -112,9 +112,6 @@ message Secrets {
 // in src/shared/storage/state-keys.ts and use the scripts/generate-state-proto.mjs
 // script to regenerate this list.
 message Settings {
-  reserved 144, 154, 176;
-  reserved "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";
-
  optional string lite_llm_base_url = 1;
  optional bool lite_llm_use_prompt_cache = 2;
  optional string anthropic_base_url = 4;
@@ -237,8 +234,8 @@ message Settings {
  optional string act_mode_nous_research_model_id = 121;
  optional string act_mode_vercel_ai_gateway_model_id = 122;
  optional OpenRouterModelInfo act_mode_vercel_ai_gateway_model_info = 123;
-  optional string plan_mode_api_provider = 124;
-  optional string act_mode_api_provider = 125;
+  optional ApiProvider plan_mode_api_provider = 124;
+  optional ApiProvider act_mode_api_provider = 125;
  optional string hicap_model_id = 126;
  optional string lm_studio_model_id = 127;
  optional AutoApprovalSettings auto_approval_settings = 128;
@@ -251,15 +248,18 @@ message Settings {
  optional bool enable_checkpoints_setting = 135;
  optional int32 shell_integration_timeout = 136;
  optional string default_terminal_profile = 137;
+  optional int32 terminal_output_line_limit = 138;
  optional int32 max_consecutive_mistakes = 139;
  optional bool yolo_mode_toggled = 142;
  optional bool use_auto_condense = 143;
+  optional bool cline_web_tools_enabled = 144;
  optional string preferred_language = 145;
  optional PlanActMode mode = 147;
  optional FocusChainSettings focus_chain_settings = 149;
  optional string custom_prompt = 150;
  optional bool hooks_enabled = 152;
  optional bool subagents_enabled = 153;
+  optional bool enable_parallel_tool_calling = 154;
  optional bool background_edit_enabled = 155;
  optional bool opt_out_of_remote_config = 157;
  optional bool open_telemetry_enabled = 158;
@@ -278,16 +278,13 @@ message Settings {
  optional int32 open_telemetry_log_max_queue_size = 171;
  optional bool worktrees_enabled = 172;
  optional bool auto_approve_all_toggled = 174;
+  optional bool double_check_completion_enabled = 176;
  map<string, string> open_ai_headers = 177;
  optional string plan_mode_cline_model_id = 178;
  optional OpenRouterModelInfo plan_mode_cline_model_info = 179;
  optional string act_mode_cline_model_id = 180;
  optional OpenRouterModelInfo act_mode_cline_model_info = 181;
  optional bool show_feature_tips = 182;
-  optional string plan_mode_cline_pass_model_id = 183;
-  optional OpenRouterModelInfo plan_mode_cline_pass_model_info = 184;
-  optional string act_mode_cline_pass_model_id = 185;
-  optional OpenRouterModelInfo act_mode_cline_pass_model_info = 186;
 }

 message State {
@@ -391,11 +388,8 @@ message UpdateTaskSettingsRequest {
 message UpdateSettingsRequest {
  reserved 15; // was openai_reasoning_effort (moved to mode-scoped reasoning effort)
  reserved 23; // was dictation_settings (dictation removed)
-  reserved 32, 34, 35, 41;
  reserved 38; // was skills_enabled (removed - now always enabled)
  reserved 43; // was lazy_teammate_mode_enabled (removed)
-  reserved 12; // was terminal_output_line_limit (removed; SDK command output limits are character-based)
-  reserved "native_tool_call_enabled", "cline_web_tools_enabled", "enable_parallel_tool_calling", "double_check_completion_enabled";

  Metadata metadata = 1;
  optional ModelsApiConfiguration api_configuration = 2;
@@ -407,6 +401,7 @@ message UpdateSettingsRequest {
  optional bool terminal_reuse_enabled = 9;
  optional bool mcp_responses_collapsed = 10;
  optional McpDisplayMode mcp_display_mode = 11;
+  optional int32 terminal_output_line_limit = 12;
  optional PlanActMode mode = 13;
  optional string preferred_language = 14;
  reserved 16; // was strict_plan_mode_enabled (removed)
@@ -423,13 +418,16 @@ message UpdateSettingsRequest {
  optional bool subagents_enabled = 29;
  optional int32 subagent_terminal_output_line_limit = 30;
  optional string cline_env = 31;
+  optional bool native_tool_call_enabled = 32;
  optional OnboardingModelGroup onboarding_models = 33;
+  optional bool cline_web_tools_enabled = 34;
+  optional bool enable_parallel_tool_calling = 35;
  optional bool background_edit_enabled = 36;
  optional string oca_reasoning_effort = 37;
  optional bool opt_out_of_remote_config = 39;
  optional bool worktrees_enabled = 40;
+  optional bool double_check_completion_enabled = 41;
  optional bool show_feature_tips = 42;
-  optional string compaction_strategy = 44;
 }

 message UpdateTerminalConnectionTimeoutRequest {
@@ -12,8 +12,6 @@ option java_package = "bot.cline.proto";
 service TaskService {
  // Cancels the currently running task
  rpc cancelTask(EmptyRequest) returns (Empty);
-  // Cancels a queued prompt by ID
-  rpc cancelQueuedPrompt(StringRequest) returns (Empty);
  // Cancels the currently running background command
  rpc cancelBackgroundCommand(EmptyRequest) returns (Empty);
  // Clears the current task
@@ -38,6 +36,8 @@ service TaskService {
  rpc editMessageAndRegenerate(EditMessageAndRegenerateRequest) returns (Empty);
  // Records task feedback (thumbs up/down)
  rpc taskFeedback(StringRequest) returns (Empty);
+  // Shows task completion changes diff in a view
+  rpc taskCompletionViewChanges(Int64Request) returns (Empty);
  // Executes a quick win task with command and title
  rpc executeQuickWin(ExecuteQuickWinRequest) returns (Empty);
  // Deletes all task history
@@ -237,16 +237,6 @@ message ShowWebviewEvent {
  bool preserve_editor_focus = 1; // When true, webview should not steal focus from editor
 }

-message IntentEvent {
-  string action = 1;
-  string source = 2;
-  bool has_text = 3;
-  bool has_images = 4;
-  bool has_files = 5;
-  bool has_active_task = 6;
-  int32 text_length = 7;
-}
-
 // UiService provides methods for managing UI interactions
 service UiService {
  // Scrolls to a specific settings section in the settings view
@@ -264,9 +254,6 @@ service UiService {
  // Subscribe to MCP button clicked events
  rpc subscribeToMcpButtonClicked(EmptyRequest) returns (stream Empty);

-  // Subscribe to customize button clicked events
-  rpc subscribeToMarketplaceButtonClicked(EmptyRequest) returns (stream Empty);
-
  // Subscribe to history button click events
  rpc subscribeToHistoryButtonClicked(EmptyRequest) returns (stream Empty);

@@ -302,7 +289,4 @@ service UiService {

  // Opens the Cline walkthrough
  rpc openWalkthrough(EmptyRequest) returns (Empty);
-
-  // Tracks intent signals before task creation or first model activity
-  rpc trackIntent(IntentEvent) returns (Empty);
 }
@@ -14,66 +14,18 @@ import { main as generateProtoBusSetup } from "./generate-protobus-setup.mjs"

 const require = createRequire(import.meta.url)
 const isWindows = process.platform === "win32"
-// Resolve the grpc-tools package root via its package.json (stable regardless of `main`), so we
-// can both locate the bundled protoc and re-run its install script when the binary is missing.
-const GRPC_TOOLS_DIR = path.dirname(require.resolve("grpc-tools/package.json"))
-const GRPC_TOOLS_PROTOC = path.join(GRPC_TOOLS_DIR, "bin", isWindows ? "protoc.exe" : "protoc")
+const GRPC_TOOLS_PROTOC = path.join(require.resolve("grpc-tools"), "../bin", isWindows ? "protoc.exe" : "protoc")
 // Legacy compatibility: some older/local Windows setups provision protoc into tmp-protoc.
 // Prefer that path when present, but fall back to the grpc-tools bundled binary used by CI/npm installs.
 const LEGACY_WINDOWS_PROTOC = path.resolve("tmp-protoc/bin/protoc.exe")
 const PROTOC = isWindows && fsSync.existsSync(LEGACY_WINDOWS_PROTOC) ? LEGACY_WINDOWS_PROTOC : GRPC_TOOLS_PROTOC

-// `bun install` skips grpc-tools' `install` lifecycle script (`node-pre-gyp install`), so the prebuilt
-// protoc is never downloaded into bin/. When it's missing, run that same command here to fetch it.
-// grpc-tools depends on @mapbox/node-pre-gyp, which exposes the `node-pre-gyp` CLI.
-function resolveNodePreGypCli() {
-	const candidates = ["@mapbox/node-pre-gyp/bin/node-pre-gyp", "node-pre-gyp/bin/node-pre-gyp"]
-	for (const candidate of candidates) {
-		try {
-			// Resolve from the grpc-tools package (its direct dependency).
-			return require.resolve(candidate, { paths: [GRPC_TOOLS_DIR] })
-		} catch {
-			// Fall back to resolving from this script's location (covers hoisted installs).
-			try {
-				return require.resolve(candidate)
-			} catch {
-				// try the next candidate
-			}
-		}
-	}
-	return null
-}
-
-function ensureProtocBinary() {
-	console.warn(chalk.yellow(`protoc not found at ${GRPC_TOOLS_PROTOC}; downloading the grpc-tools prebuilt binary...`))
-	const nodePreGypCli = resolveNodePreGypCli()
-	if (!nodePreGypCli) {
-		console.error(
-			chalk.red(
-				`Could not resolve the node-pre-gyp CLI from ${GRPC_TOOLS_DIR}. Run \`bun install\`, then retry \`bun run protos\`.`,
-			),
-		)
-		process.exit(1)
-	}
-	try {
-		// Mirrors grpc-tools' `scripts.install` ("node-pre-gyp install"): downloads the prebuilt
-		// protoc for the current platform/arch into grpc-tools/bin.
-		execFileSync(process.execPath, [nodePreGypCli, "install"], { cwd: GRPC_TOOLS_DIR, stdio: "inherit" })
-	} catch (error) {
-		console.error(chalk.red(`Failed to download protoc via node-pre-gyp: ${error?.message ?? error}`))
-		process.exit(1)
-	}
-	if (!fsSync.existsSync(GRPC_TOOLS_PROTOC)) {
-		console.error(chalk.red(`protoc still not found at ${GRPC_TOOLS_PROTOC} after node-pre-gyp install.`))
-		process.exit(1)
-	}
-	console.log(chalk.green("✓ protoc binary installed."))
-}
-
 if (!fsSync.existsSync(PROTOC)) {
-	// PROTOC only differs from GRPC_TOOLS_PROTOC when the legacy Windows path exists, so a missing
-	// PROTOC always means the grpc-tools-bundled protoc needs to be fetched.
-	ensureProtocBinary()
+	const windowsHint = isWindows
+		? ` Neither ${LEGACY_WINDOWS_PROTOC} nor the grpc-tools bundled protoc at ${GRPC_TOOLS_PROTOC} exists.`
+		: ""
+	console.error(chalk.red(`protoc not found at ${PROTOC}.${windowsHint}`))
+	process.exit(1)
 }

 const PROTO_DIR = path.resolve("proto")
@@ -61,36 +61,33 @@ async function main() {
 fs.rmSync(path.join(__dirname, "..", "out", "src"), { recursive: true, force: true })
 fs.rmSync(path.join(__dirname, "..", "out", "packages"), { recursive: true, force: true })

-// Single source of truth for the test-runner split: any *.test.ts that imports
-// from "bun:test" is owned by the bun runner (scripts/run-bun-unit-tests.ts),
-// and any that imports from "vitest" is owned by the vitest runner (test:vitest,
-// see vitest.config.ts). Neither may be compiled into the Node-based
-// @vscode/test-cli `out/` tree: Node cannot load `bun:test`, and vitest suites
-// use vitest-only APIs/matchers (e.g. `toHaveBeenCalledWith`) that the mocha
-// runner does not provide. Generate a tsconfig that excludes them so the
+// Single source of truth for the bun-vs-integration test split: any *.test.ts that
+// imports from "bun:test" is owned by the bun runner (scripts/run-bun-unit-tests.ts)
+// and must NOT be compiled into the Node-based @vscode/test-cli `out/` tree (Node
+// cannot load the `bun:test` builtin, and these files use bun-only APIs like
+// `mock.module` / 3-arg `it`). Generate a tsconfig that excludes them so the
 // integration compile only ever sees mocha-owned tests.
 const projectRoot = path.join(__dirname, "..")
-const nonMochaTestImport =
-	/from\s+["'](?:bun:test|vitest(?:\/[^"']*)?|@vitest\/[^"']*)["']/
-function collectNonMochaTestFiles(dir, acc) {
+const bunTestImport = /from\s+["']bun:test["']/
+function collectBunTestFiles(dir, acc) {
 	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
 		if (entry.name === "node_modules") continue
 		const full = path.join(dir, entry.name)
 		if (entry.isDirectory()) {
-			collectNonMochaTestFiles(full, acc)
+			collectBunTestFiles(full, acc)
 		} else if (entry.isFile() && entry.name.endsWith(".test.ts")) {
-			if (nonMochaTestImport.test(fs.readFileSync(full, "utf-8"))) {
+			if (bunTestImport.test(fs.readFileSync(full, "utf-8"))) {
 				acc.push(path.relative(projectRoot, full).split(path.sep).join("/"))
 			}
 		}
 	}
 	return acc
 }
-const nonMochaOwnedTests = collectNonMochaTestFiles(path.join(projectRoot, "src"), [])
+const bunOwnedTests = collectBunTestFiles(path.join(projectRoot, "src"), [])
 // tsconfig.test.json is JSONC (contains comments); parse with json5 (a project dep).
 const JSON5 = require("json5")
 const baseTestConfig = JSON5.parse(fs.readFileSync(path.join(projectRoot, "tsconfig.test.json"), "utf-8"))
-baseTestConfig.exclude = [...(baseTestConfig.exclude ?? []), ...nonMochaOwnedTests]
+baseTestConfig.exclude = [...(baseTestConfig.exclude ?? []), ...bunOwnedTests]
 const generatedConfigPath = path.join(projectRoot, "tsconfig.test.generated.json")
 fs.writeFileSync(generatedConfigPath, JSON.stringify(baseTestConfig, null, "\t"))

@@ -85,7 +85,7 @@ function inferProtoType(typeText, fieldName) {
 		["FocusChainSettings", "FocusChainSettings"],
 		["OpenaiReasoningEffort", "OpenaiReasoningEffort"],
 		["PlanActMode", "PlanActMode"],
-		["ApiProvider", "string"],
+		["ApiProvider", "ApiProvider"],
 		["LanguageModelChatSelector", "LanguageModelChatSelector"], // Must come before "Mode" check
 	]

@@ -17,6 +17,7 @@ import { getDistinctId } from "./services/logging/distinctId"
 import { telemetryService } from "./services/telemetry"
 import { PostHogClientProvider } from "./services/telemetry/providers/posthog/PostHogClientProvider"
 import { ClineTempManager } from "./services/temp"
+import { cleanupTestMode } from "./services/test/TestMode"
 import { ShowMessageType } from "./shared/proto/host/window"
 import { syncWorker } from "./shared/services/worker/sync"
 import { getBlobStoreSettingsFromEnv } from "./shared/services/worker/worker"
@@ -153,28 +154,23 @@ async function checkWorktreeAutoOpen(stateManager: StateManager): Promise<void>
 * Performs cleanup when Cline is deactivated that is common to all platforms.
 */
 export async function tearDown(): Promise<void> {
-	try {
-		AgentConfigLoader.getInstance()?.dispose()
-		PostHogClientProvider.getInstance().dispose()
-		telemetryService.dispose()
-		ErrorService.get().dispose()
-		featureFlagsService.dispose()
-		// Dispose all webview instances
-		await WebviewProvider.disposeAllInstances()
-		syncWorker().dispose()
-		clearOnboardingModelsCache()
+	AgentConfigLoader.getInstance()?.dispose()
+	PostHogClientProvider.getInstance().dispose()
+	telemetryService.dispose()
+	ErrorService.get().dispose()
+	featureFlagsService.dispose()
+	// Dispose all webview instances
+	await WebviewProvider.disposeAllInstances()
+	syncWorker().dispose()
+	clearOnboardingModelsCache()

-		// Kill any running hook processes to prevent zombies
-		await HookProcessRegistry.terminateAll()
-		// Clean up hook discovery cache
-		HookDiscoveryCache.getInstance().dispose()
-		// Stop periodic temp file cleanup
-		ClineTempManager.stopPeriodicCleanup()
-	} finally {
-		try {
-			await StateManager.get().flushPendingState()
-		} catch (error) {
-			Logger.error("[Cline] Failed to flush pending state during teardown:", error)
-		}
-	}
+	// Kill any running hook processes to prevent zombies
+	await HookProcessRegistry.terminateAll()
+	// Clean up hook discovery cache
+	HookDiscoveryCache.getInstance().dispose()
+	// Stop periodic temp file cleanup
+	ClineTempManager.stopPeriodicCleanup()
+
+	// Clean up test mode
+	cleanupTestMode()
 }
@@ -0,0 +1,9 @@
+import { Empty, Int64Request } from "@shared/proto/cline/common"
+import { Controller } from ".."
+
+export async function checkpointDiff(controller: Controller, request: Int64Request): Promise<Empty> {
+	if (request.value) {
+		await controller.task?.checkpointManager?.presentMultifileDiff?.(request.value, false)
+	}
+	return Empty.create()
+}
@@ -1,23 +1,34 @@
 import { CheckpointRestoreRequest } from "@shared/proto/cline/checkpoints"
 import { Empty } from "@shared/proto/cline/common"
+import pWaitFor from "p-wait-for"
+import { HostProvider } from "@/hosts/host-provider"
+import { ShowMessageType } from "@/shared/proto/index.host"
+import { Logger } from "@/shared/services/Logger"
 import { ClineCheckpointRestore } from "../../../shared/WebviewMessage"
 import { Controller } from ".."

 export async function checkpointRestore(controller: Controller, request: CheckpointRestoreRequest): Promise<Empty> {
-	const sdkRestoreCheckpoint = (
-		controller as Controller & {
-			restoreCheckpoint?: (input: { checkpointRunCount: number; restoreType: ClineCheckpointRestore }) => Promise<void>
-		}
-	).restoreCheckpoint
-	if (sdkRestoreCheckpoint) {
-		if (request.number) {
-			await sdkRestoreCheckpoint.call(controller, {
-				checkpointRunCount: Number(request.number),
-				restoreType: request.restoreType as ClineCheckpointRestore,
-			})
-		}
-		return Empty.create({})
-	}
+	await controller.cancelTask() // we cannot alter message history say if the task is active, as it could be in the middle of editing a file or running a command, which expect the ask to be responded to rather than being superseded by a new message eg add deleted_api_reqs

+	if (request.number) {
+		// wait for messages to be loaded
+		await pWaitFor(() => controller.task?.taskState.isInitialized === true, {
+			timeout: 3_000,
+		}).catch((error) => {
+			Logger.log("Failed to init new Cline instance to restore checkpoint", error)
+			HostProvider.window.showMessage({
+				type: ShowMessageType.ERROR,
+				message: "Failed to restore checkpoint",
+			})
+			throw error
+		})
+
+		// NOTE: cancelTask awaits abortTask, which awaits diffViewProvider.revertChanges, which reverts any edited files, allowing us to reset to a checkpoint rather than running into a state where the revertChanges function is called alongside or after the checkpoint reset
+		await controller.task?.checkpointManager?.restoreCheckpoint(
+			request.number,
+			request.restoreType as ClineCheckpointRestore,
+			request.offset,
+		)
+	}
 	return Empty.create({})
 }
@@ -0,0 +1,18 @@
+import { PathHashMap } from "@shared/proto/cline/checkpoints"
+import { StringArrayRequest } from "@shared/proto/cline/common"
+import { hashWorkingDir } from "@/integrations/checkpoints/CheckpointUtils"
+import { Controller } from ".."
+
+export async function getCwdHash(_controller: Controller, request: StringArrayRequest): Promise<PathHashMap> {
+	const pathHash: Record<string, string> = {}
+
+	for (const path of request.value) {
+		try {
+			pathHash[path] = hashWorkingDir(path)
+		} catch {
+			pathHash[path] = ""
+		}
+	}
+
+	return PathHashMap.create({ pathHash })
+}
@@ -0,0 +1,61 @@
+import { CheckpointEvent, CheckpointSubscriptionRequest } from "@shared/proto/cline/checkpoints"
+import { getRequestRegistry, StreamingResponseHandler } from "../grpc-handler"
+import { Controller } from "../index"
+
+/**
+ * Track active checkpoint subscriptions per workspace.
+ * Map structure: cwdHash -> Set of response streams
+ */
+const activeCheckpointSubscriptions = new Map<string, Set<StreamingResponseHandler<CheckpointEvent>>>()
+
+/**
+ * Subscribe to checkpoint events for a specific workspace.
+ *
+ * Clients receive real-time notifications about checkpoint operations:
+ * - Shadow git initialization
+ * - Commit creation
+ * - Checkpoint restoration
+ *
+ * Each operation generates two events (start and completion).
+ *
+ * @param controller The controller instance
+ * @param request The subscription request containing cwdHash
+ * @param responseStream The streaming response handler
+ * @param requestId The ID of the request
+ */
+export async function subscribeToCheckpoints(
+	_controller: Controller,
+	request: CheckpointSubscriptionRequest,
+	responseStream: StreamingResponseHandler<CheckpointEvent>,
+	requestId?: string,
+): Promise<void> {
+	const { cwdHash } = request
+
+	if (!activeCheckpointSubscriptions.has(cwdHash)) {
+		activeCheckpointSubscriptions.set(cwdHash, new Set())
+	}
+
+	const subscriptions = activeCheckpointSubscriptions.get(cwdHash)
+	if (!subscriptions) {
+		throw new Error(`Failed to retrieve subscriptions for cwdHash: ${cwdHash}`)
+	}
+
+	subscriptions.add(responseStream)
+
+	// Register cleanup when the connection is closed
+	const cleanup = () => {
+		subscriptions.delete(responseStream)
+		if (subscriptions.size === 0) {
+			activeCheckpointSubscriptions.delete(cwdHash)
+		}
+	}
+
+	if (requestId) {
+		getRequestRegistry().registerRequest(
+			requestId,
+			cleanup,
+			{ type: "checkpoint_subscription" as const, cwdHash },
+			responseStream,
+		)
+	}
+}
@@ -1,16 +1,65 @@
-import { type CoreSettingsItem, createCoreSettingsService } from "@cline/core"
 import { parseRemoteSkillEntries } from "@core/context/instructions/user-instructions/skills"
 import { RefreshedSkills, SkillInfo } from "@shared/proto/cline/file"
+import fs from "fs/promises"
+import path from "path"
+import { parseYamlFrontmatter } from "@/core/context/instructions/user-instructions/frontmatter"
+import { getSkillsDirectoriesForScan } from "@/core/storage/disk"
 import { HostProvider } from "@/hosts/host-provider"
+import { Logger } from "@/shared/services/Logger"
+import { fileExistsAtPath, isDirectory } from "@/utils/fs"
 import { Controller } from ".."

-function coreSkillToSkillInfo(skill: CoreSettingsItem): SkillInfo {
-	return SkillInfo.create({
-		name: skill.name,
-		description: skill.description ?? "",
-		path: skill.path,
-		enabled: skill.enabled !== false,
-	})
+/**
+ * Scan a directory for skill subdirectories containing SKILL.md files.
+ */
+async function scanSkillsDirectory(dirPath: string): Promise<SkillInfo[]> {
+	const skills: SkillInfo[] = []
+
+	if (!(await fileExistsAtPath(dirPath)) || !(await isDirectory(dirPath))) {
+		return skills
+	}
+
+	try {
+		const entries = await fs.readdir(dirPath)
+
+		for (const entryName of entries) {
+			const entryPath = path.join(dirPath, entryName)
+			const stats = await fs.stat(entryPath).catch(() => null)
+			if (!stats?.isDirectory()) continue
+
+			const skillMdPath = path.join(entryPath, "SKILL.md")
+			if (!(await fileExistsAtPath(skillMdPath))) continue
+
+			try {
+				const fileContent = await fs.readFile(skillMdPath, "utf-8")
+				const result = parseYamlFrontmatter(fileContent)
+				if (result.parseError) {
+					Logger.warn("Failed to parse YAML frontmatter:", result.parseError)
+				}
+				const frontmatter = result.data
+
+				// Validate required fields
+				if (!frontmatter.name || typeof frontmatter.name !== "string") continue
+				if (!frontmatter.description || typeof frontmatter.description !== "string") continue
+				if (frontmatter.name !== entryName) continue
+
+				skills.push(
+					SkillInfo.create({
+						name: entryName,
+						description: frontmatter.description,
+						path: skillMdPath,
+						enabled: true, // Will be updated with toggle state
+					}),
+				)
+			} catch {
+				// Skip invalid skills
+			}
+		}
+	} catch {
+		// Directory read error, skip
+	}
+
+	return skills
 }

 /**
@@ -21,15 +70,33 @@ export async function refreshSkills(controller: Controller): Promise<RefreshedSk
 	const workspacePaths = await HostProvider.workspace.getWorkspacePaths({})
 	const primaryWorkspace = workspacePaths.paths[0]

-	const settingsSnapshot = await createCoreSettingsService().list({
-		workspaceRoot: primaryWorkspace,
-	})
-	const globalSkills = settingsSnapshot.skills
-		.filter((skill) => skill.source === "global" || skill.source === "global-plugin")
-		.map(coreSkillToSkillInfo)
-	const localSkills = settingsSnapshot.skills
-		.filter((skill) => skill.source === "workspace" || skill.source === "workspace-plugin")
-		.map(coreSkillToSkillInfo)
+	const globalSkills: SkillInfo[] = []
+	const localSkills: SkillInfo[] = []
+
+	if (primaryWorkspace) {
+		const scanDirs = getSkillsDirectoriesForScan(primaryWorkspace)
+		for (const dir of scanDirs) {
+			const skills = await scanSkillsDirectory(dir.path)
+			if (dir.source === "global") {
+				globalSkills.push(...skills)
+			} else {
+				localSkills.push(...skills)
+			}
+		}
+	} else {
+		const scanDirs = getSkillsDirectoriesForScan("")
+		for (const dir of scanDirs) {
+			if (dir.source !== "global") continue
+			const skills = await scanSkillsDirectory(dir.path)
+			globalSkills.push(...skills)
+		}
+	}
+
+	// Get global toggles and apply them
+	const globalToggles = controller.stateManager.getGlobalSettingsKey("globalSkillsToggles") || {}
+	for (const skill of globalSkills) {
+		skill.enabled = globalToggles[skill.path] !== false
+	}

 	// Add remote skills from remote config.
 	// Precedence: remote (enterprise) > disk-global (user) > project (workspace).
@@ -53,6 +120,12 @@ export async function refreshSkills(controller: Controller): Promise<RefreshedSk
 		)
 	}

+	// Get local toggles and apply them
+	const localToggles = controller.stateManager.getWorkspaceStateKey("localSkillsToggles") || {}
+	for (const skill of localSkills) {
+		skill.enabled = localToggles[skill.path] !== false
+	}
+
 	return RefreshedSkills.create({
 		globalSkills,
 		localSkills,
@@ -1,51 +0,0 @@
-import { afterEach, describe, it, mock } from "bun:test"
-import * as assert from "assert"
-import sinon from "sinon"
-import type { Controller } from "../../index"
-
-const installMarketplaceEntryFromCatalogStub: sinon.SinonStub = sinon.stub()
-const marketplaceHelpersMock = () => ({
-	installMarketplaceEntryFromCatalog: installMarketplaceEntryFromCatalogStub,
-})
-
-mock.module("../marketplace-helpers", marketplaceHelpersMock)
-mock.module("./marketplace-helpers", marketplaceHelpersMock)
-
-describe("installMarketplaceEntry", () => {
-	afterEach(() => {
-		installMarketplaceEntryFromCatalogStub.reset()
-	})
-
-	it("reconciles the MCP hub after installing an MCP marketplace entry", async () => {
-		const { installMarketplaceEntry } = await import("../installMarketplaceEntry")
-		const reconcileMcpServersFromSettingsRPC = sinon.stub().resolves([])
-		const invalidateUserInstructionService = sinon.stub().resolves()
-		const controller = {
-			mcpHub: { reconcileMcpServersFromSettingsRPC },
-			invalidateUserInstructionService,
-		} as unknown as Controller
-		installMarketplaceEntryFromCatalogStub.resolves({
-			id: "chrome-devtools",
-			type: "mcp",
-			status: "installed",
-		})
-
-		await installMarketplaceEntry(controller, {
-			entry: {
-				id: "chrome-devtools",
-				type: "mcp",
-				name: "Chrome DevTools",
-				install: {
-					args: ["chrome-devtools", "--", "npx", "chrome-devtools-mcp@1.2.0"],
-					env: [],
-				},
-				tags: [],
-				tagObjects: [],
-			},
-		})
-
-		assert.equal(installMarketplaceEntryFromCatalogStub.callCount, 1)
-		assert.equal(reconcileMcpServersFromSettingsRPC.callCount, 1)
-		assert.equal(invalidateUserInstructionService.callCount, 0)
-	})
-})
@@ -1,8 +0,0 @@
-import type { EmptyRequest } from "@shared/proto/cline/common"
-import type { MarketplaceCatalog } from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { fetchMarketplaceCatalog } from "./marketplace-helpers"
-
-export async function getMarketplaceCatalog(_controller: Controller, _request: EmptyRequest): Promise<MarketplaceCatalog> {
-	return fetchMarketplaceCatalog()
-}
@@ -1,20 +0,0 @@
-import { type MarketplaceEntryRequest, MarketplaceInstallResult } from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { installMarketplaceEntryFromCatalog } from "./marketplace-helpers"
-
-export async function installMarketplaceEntry(
-	controller: Controller,
-	request: MarketplaceEntryRequest,
-): Promise<MarketplaceInstallResult> {
-	if (!request.entry) {
-		throw new Error("Marketplace entry is required.")
-	}
-	const result = await installMarketplaceEntryFromCatalog(request.entry)
-	if (request.entry.type === "mcp") {
-		await controller.mcpHub?.reconcileMcpServersFromSettingsRPC()
-	}
-	if (request.entry.type === "skill" || request.entry.type === "plugin") {
-		await controller.invalidateUserInstructionService()
-	}
-	return result
-}
@@ -1,10 +0,0 @@
-import type { MarketplaceEntriesRequest, MarketplaceInstalledEntries } from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { listInstalledMarketplaceEntries } from "./marketplace-helpers"
-
-export async function listMarketplaceInstalledEntries(
-	controller: Controller,
-	request: MarketplaceEntriesRequest,
-): Promise<MarketplaceInstalledEntries> {
-	return listInstalledMarketplaceEntries(controller, request.entries)
-}
@@ -1,11 +0,0 @@
-import type { EmptyRequest } from "@shared/proto/cline/common"
-import type { MarketplaceLocalInstalledEntries } from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { listLocalMarketplaceInstalledEntries } from "./marketplace-helpers"
-
-export async function listMarketplaceLocalInstalledEntries(
-	controller: Controller,
-	_request: EmptyRequest,
-): Promise<MarketplaceLocalInstalledEntries> {
-	return listLocalMarketplaceInstalledEntries(controller)
-}
@@ -1,635 +0,0 @@
-import { spawn } from "node:child_process"
-import { createHash } from "node:crypto"
-import { existsSync, readFileSync } from "node:fs"
-import { homedir, platform } from "node:os"
-import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path"
-import {
-	disablePluginMcpServersInSettings,
-	discoverPluginModulePaths,
-	installMcpServer,
-	installPlugin,
-	isMarketplaceSkillInstalled,
-	type MarketplaceActionResult,
-	type MarketplaceEntryInput,
-	type MarketplacePrimitiveType,
-	parseMcpInstallArgs,
-	readGlobalSettings,
-	resolvePluginConfigSearchPaths,
-	setDisabledPlugin,
-	syncPluginMcpServersToSettings,
-	uninstallMarketplaceEntry as uninstallCoreMarketplaceEntry,
-	uninstallPlugin,
-} from "@cline/core"
-import { deleteSkillFile } from "@core/controller/file/deleteSkillFile"
-import { refreshSkills } from "@core/controller/file/refreshSkills"
-import { toggleSkill } from "@core/controller/file/toggleSkill"
-import { resolveActiveModelIdFromApiConfiguration } from "@core/controller/models/taskApiModel"
-import { DeleteSkillRequest, ToggleSkillRequest } from "@shared/proto/cline/file"
-import {
-	MarketplaceCatalog,
-	MarketplaceEntry,
-	MarketplaceInstalledEntries,
-	MarketplaceInstallResult,
-	MarketplaceLocalInstalledEntries,
-	MarketplaceLocalInstalledEntry,
-	MarketplaceLocalInstalledEntryRequest,
-	ToggleMarketplaceLocalInstalledEntryRequest,
-} from "@shared/proto/cline/marketplace"
-import { HostProvider } from "@/hosts/host-provider"
-import type { Controller } from "../index"
-
-type MarketplaceType = "mcp" | "skill" | "plugin"
-
-type SpawnResult = {
-	exitCode: number
-	stdout: string
-	stderr: string
-}
-
-const MARKETPLACE_CATALOG_URL = "https://cline.github.io/marketplace/catalog.json"
-const OFFICIAL_PLUGINS_REPO = "https://github.com/cline/plugins.git"
-const INSTALL_COMMAND_TIMEOUT_MS = 120_000
-const MAX_OUTPUT_CHARS = 12_000
-const SECRET_PATTERN =
-	/(api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|authorization|credential)/i
-const SECRET_KEY_VALUE_PATTERN =
-	/((?:^|[^\w])(?:[a-z0-9_]*?(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|auth(?:orization)?[_ -]?token|token|secret|password|credential)[a-z0-9_]*)\s*[:=]\s*)(.+)$/gi
-const SECRET_BEARER_VALUE_PATTERN = /((?:^|[^\w])authorization\s*[:=]\s*)bearer\s+([^\s,"'}\]]+)/gi
-const SECRET_AUTHORIZATION_VALUE_PATTERN = /((?:^|[^\w])authorization\s*[:=])(?!\s*bearer\b)\s*(.+)$/gi
-
-function isMarketplaceType(value: string): value is MarketplaceType {
-	return value === "mcp" || value === "skill" || value === "plugin"
-}
-
-function asStringArray(value: unknown): string[] {
-	return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
-}
-
-function sanitizeEntry(raw: unknown): MarketplaceEntry | undefined {
-	if (!raw || typeof raw !== "object") return undefined
-	const record = raw as Record<string, unknown>
-	const id = typeof record.id === "string" ? record.id.trim() : ""
-	const type = typeof record.type === "string" ? record.type.trim() : ""
-	const name = typeof record.name === "string" ? record.name.trim() : id
-	if (!id || !isMarketplaceType(type) || !name) return undefined
-	const install = record.install && typeof record.install === "object" ? (record.install as Record<string, unknown>) : undefined
-	return MarketplaceEntry.create({
-		id,
-		type,
-		name,
-		tagline: typeof record.tagline === "string" ? record.tagline : undefined,
-		description: typeof record.description === "string" ? record.description : undefined,
-		tags: asStringArray(record.tags),
-		author: typeof record.author === "string" ? record.author : undefined,
-		sourceUrl: typeof record.sourceUrl === "string" ? record.sourceUrl : undefined,
-		homepageUrl: typeof record.homepageUrl === "string" ? record.homepageUrl : undefined,
-		install: install
-			? {
-					args: asStringArray(install.args),
-					env: Array.isArray(install.env)
-						? install.env
-								.map((item) => {
-									if (!item || typeof item !== "object") return undefined
-									const env = item as Record<string, unknown>
-									if (typeof env.name !== "string") return undefined
-									return {
-										name: env.name,
-										required: env.required === true,
-										description: typeof env.description === "string" ? env.description : undefined,
-										url: typeof env.url === "string" ? env.url : undefined,
-									}
-								})
-								.filter((item): item is NonNullable<typeof item> => item !== undefined)
-						: [],
-					command: typeof install.command === "string" ? install.command : undefined,
-					notes: typeof install.notes === "string" ? install.notes : undefined,
-				}
-			: undefined,
-	})
-}
-
-export async function fetchMarketplaceCatalog(): Promise<MarketplaceCatalog> {
-	const response = await fetch(MARKETPLACE_CATALOG_URL, {
-		headers: { Accept: "application/json" },
-	})
-	if (!response.ok) {
-		throw new Error(`Failed to fetch marketplace catalog: ${response.status} ${response.statusText}`.trim())
-	}
-	const json = (await response.json()) as Record<string, unknown>
-	const entries = Array.isArray(json.entries)
-		? json.entries.map(sanitizeEntry).filter((entry): entry is MarketplaceEntry => entry !== undefined)
-		: []
-	return MarketplaceCatalog.create({ entries })
-}
-
-function normalizeMatchValue(value: string | undefined): string {
-	return (value ?? "")
-		.toLowerCase()
-		.replace(/[^a-z0-9]+/g, "-")
-		.replace(/^-+|-+$/g, "")
-}
-
-function marketplaceKey(entry: MarketplaceEntry): string {
-	return `${entry.type}:${entry.id}`
-}
-
-function getEntryArgs(entry: MarketplaceEntry): string[] {
-	return entry.install?.args ?? []
-}
-
-function isMcpInstalled(controller: Controller, entry: MarketplaceEntry): boolean {
-	if (entry.type !== "mcp") return false
-	const [name] = getEntryArgs(entry)
-	const candidates = new Set([normalizeMatchValue(name), normalizeMatchValue(entry.id), normalizeMatchValue(entry.name)])
-	candidates.delete("")
-	return (controller.mcpHub?.getServers() ?? []).some((server) => candidates.has(normalizeMatchValue(server.name)))
-}
-
-function hashSource(source: string): string {
-	return createHash("sha256").update(source).digest("hex").slice(0, 12)
-}
-
-function resolveClineHome(): string {
-	return process.env.CLINE_DIR?.trim() || join(homedir(), ".cline")
-}
-
-function sanitizeSegment(value: string): string {
-	const sanitized = value
-		.replace(/^@/, "")
-		.replace(/[^a-zA-Z0-9._-]+/g, "-")
-		.replace(/^-+|-+$/g, "")
-		.slice(0, 80)
-	return sanitized || "plugin"
-}
-
-function isOfficialPluginInstalled(entry: MarketplaceEntry): boolean {
-	if (entry.type !== "plugin") return false
-	const [source] = getEntryArgs(entry)
-	if (!source || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(source.trim())) return false
-	const sourceKey = `official:${OFFICIAL_PLUGINS_REPO}#plugins/${source.trim()}`
-	const installPath = join(
-		resolveClineHome(),
-		"plugins",
-		"_installed",
-		"official",
-		`${sanitizeSegment(source)}-${hashSource(sourceKey)}`,
-	)
-	return existsSync(installPath)
-}
-
-function isSkillInstalled(entry: MarketplaceEntry): boolean {
-	if (entry.type !== "skill") return false
-	return isMarketplaceSkillInstalled(toCoreMarketplaceEntry(entry))
-}
-
-export function listInstalledMarketplaceEntries(
-	controller: Controller,
-	entries: MarketplaceEntry[],
-): MarketplaceInstalledEntries {
-	return MarketplaceInstalledEntries.create({
-		installedKeys: entries
-			.filter((entry) => isMcpInstalled(controller, entry) || isSkillInstalled(entry) || isOfficialPluginInstalled(entry))
-			.map(marketplaceKey),
-	})
-}
-
-function redactOutput(value: string): string {
-	return value
-		.split(/\r?\n/)
-		.map((line) => {
-			if (!SECRET_PATTERN.test(line)) return line
-			return line
-				.replace(SECRET_KEY_VALUE_PATTERN, "$1[redacted]")
-				.replace(SECRET_BEARER_VALUE_PATTERN, "$1Bearer [redacted]")
-				.replace(/\b(Bearer)\s+(?!\[redacted\])([^\s,"'}\]]+)/gi, "$1 [redacted]")
-				.replace(SECRET_AUTHORIZATION_VALUE_PATTERN, "$1 [redacted]")
-				.replace(
-					/((?:^|[^\w])(?:api\s+key|access\s+token|refresh\s+token|auth(?:orization)?\s+token|secret|password|credential)\s+(?:is\s+)?)(\S+)/gi,
-					"$1[redacted]",
-				)
-		})
-		.join("\n")
-		.slice(-MAX_OUTPUT_CHARS)
-}
-
-function quoteCommandPart(value: string): string {
-	if (value === "") return '""'
-	if (/^[a-zA-Z0-9_./:=@%+,-]+$/.test(value)) return value
-	return JSON.stringify(value)
-}
-
-function formatCommand(command: string, args: string[]): string {
-	return [command, ...args].map((part) => quoteCommandPart(redactOutput(part).trim())).join(" ")
-}
-
-function extractJsonErrorMessage(value: unknown): string | undefined {
-	if (typeof value === "string") return value.trim() || undefined
-	if (!value || typeof value !== "object") return undefined
-	if (Array.isArray(value)) {
-		return value.map(extractJsonErrorMessage).filter(Boolean).join("\n") || undefined
-	}
-	const record = value as Record<string, unknown>
-	for (const key of ["message", "error", "details", "detail", "reason", "stderr", "stdout"]) {
-		const message = extractJsonErrorMessage(record[key])
-		if (message) return message
-	}
-	return undefined
-}
-
-function parseJsonErrorMessage(output: string): string | undefined {
-	const trimmed = output.trim()
-	if (!trimmed || (!trimmed.startsWith("{") && !trimmed.startsWith("["))) return undefined
-	try {
-		return extractJsonErrorMessage(JSON.parse(trimmed))
-	} catch {
-		return undefined
-	}
-}
-
-function commandOutput(result: SpawnResult): string | undefined {
-	const stdout = redactOutput(result.stdout).trim()
-	const stderr = redactOutput(result.stderr).trim()
-	const parsedMessages = [stdout, stderr].map(parseJsonErrorMessage).filter((message): message is string => Boolean(message))
-	if (parsedMessages.length > 0) return parsedMessages.join("\n")
-	const parts = [stderr ? `stderr:\n${stderr}` : undefined, stdout ? `stdout:\n${stdout}` : undefined].filter(
-		(part): part is string => Boolean(part),
-	)
-	return parts.join("\n\n") || undefined
-}
-
-async function runCommand(command: string, args: string[]): Promise<SpawnResult> {
-	return new Promise((resolveResult, reject) => {
-		let settled = false
-		let timedOut = false
-		const child = spawn(command, args, {
-			env: process.env,
-			shell: platform() === "win32",
-			stdio: ["ignore", "pipe", "pipe"],
-			windowsHide: true,
-		})
-		let stdout = ""
-		let stderr = ""
-		const forceKillTimeout = setTimeout(() => {
-			if (!settled) child.kill("SIGKILL")
-		}, INSTALL_COMMAND_TIMEOUT_MS + 5_000)
-		const timeout = setTimeout(() => {
-			timedOut = true
-			stderr += `\nTimed out after ${INSTALL_COMMAND_TIMEOUT_MS / 1000}s.`
-			child.kill("SIGTERM")
-		}, INSTALL_COMMAND_TIMEOUT_MS)
-		forceKillTimeout.unref?.()
-		timeout.unref?.()
-		child.stdout?.on("data", (chunk) => {
-			stdout += String(chunk)
-			if (stdout.length > MAX_OUTPUT_CHARS * 2) stdout = stdout.slice(-MAX_OUTPUT_CHARS)
-		})
-		child.stderr?.on("data", (chunk) => {
-			stderr += String(chunk)
-			if (stderr.length > MAX_OUTPUT_CHARS * 2) stderr = stderr.slice(-MAX_OUTPUT_CHARS)
-		})
-		child.once("error", reject)
-		child.once("close", (code, signal) => {
-			settled = true
-			clearTimeout(timeout)
-			clearTimeout(forceKillTimeout)
-			resolveResult({
-				exitCode: timedOut ? 124 : (code ?? (signal === "SIGINT" ? 130 : 1)),
-				stdout,
-				stderr,
-			})
-		})
-	})
-}
-
-function installMcpMarketplaceEntry(entry: MarketplaceEntry, args: string[]): MarketplaceInstallResult {
-	const parsed = parseMcpInstallArgs(args)
-	const result = installMcpServer(parsed)
-	return MarketplaceInstallResult.create({
-		id: entry.id,
-		type: entry.type,
-		status: "installed",
-		message: `Installed ${entry.name || entry.id}.`,
-		output: result.warnings.join("\n") || undefined,
-	})
-}
-
-async function installPluginMarketplaceEntry(entry: MarketplaceEntry, args: string[]): Promise<MarketplaceInstallResult> {
-	const [source] = args
-	if (!source) throw new Error("Marketplace plugin install args must start with a plugin source.")
-	const result = await installPlugin({ source })
-	const warnings = result.mcpSyncFailures.map(
-		(failure) => `Failed to sync plugin MCP servers for ${failure.pluginName ?? failure.pluginPath}: ${failure.message}`,
-	)
-	return MarketplaceInstallResult.create({
-		id: entry.id,
-		type: entry.type,
-		status: "installed",
-		message: `Installed ${entry.name || entry.id}.`,
-		output: [`Path: ${result.installPath}`, ...warnings].join("\n"),
-	})
-}
-
-async function installSkillMarketplaceEntry(entry: MarketplaceEntry, args: string[]): Promise<MarketplaceInstallResult> {
-	const command = "npx"
-	const commandArgs = ["-y", "skills@latest", "add", ...args, "-g", "-a", "cline", "-y"]
-	const displayCommand = formatCommand(command, commandArgs)
-	let result: SpawnResult
-	try {
-		result = await runCommand(command, commandArgs)
-	} catch (error) {
-		throw new Error(
-			`Failed to start ${entry.name || entry.id} install command:\n${displayCommand}\n${
-				error instanceof Error ? error.message : String(error)
-			}`,
-		)
-	}
-	const output = commandOutput(result)
-	if (result.exitCode !== 0) {
-		throw new Error(
-			`${entry.name || entry.id} install failed with exit code ${result.exitCode}.\nCommand:\n${displayCommand}${
-				output ? `\n\n${output}` : ""
-			}`,
-		)
-	}
-	return MarketplaceInstallResult.create({
-		id: entry.id,
-		type: entry.type,
-		status: "installed",
-		message: `Installed ${entry.name || entry.id}.`,
-		output,
-	})
-}
-
-export async function installMarketplaceEntryFromCatalog(entry: MarketplaceEntry): Promise<MarketplaceInstallResult> {
-	const args = getEntryArgs(entry)
-	if (args.length === 0) throw new Error("Marketplace install args are required.")
-	if (entry.type === "mcp") return installMcpMarketplaceEntry(entry, args)
-	if (entry.type === "plugin") return installPluginMarketplaceEntry(entry, args)
-	return installSkillMarketplaceEntry(entry, args)
-}
-
-function toCoreMarketplaceEntry(entry: MarketplaceEntry): MarketplaceEntryInput {
-	if (entry.type !== "mcp" && entry.type !== "skill" && entry.type !== "plugin") {
-		throw new Error(`Unsupported marketplace entry type: ${entry.type}`)
-	}
-	return {
-		id: entry.id,
-		type: entry.type as MarketplacePrimitiveType,
-		name: entry.name,
-		install: {
-			args: getEntryArgs(entry),
-		},
-	}
-}
-
-function toProtoMarketplaceInstallResult(result: MarketplaceActionResult): MarketplaceInstallResult {
-	return MarketplaceInstallResult.create({
-		id: result.id,
-		type: result.type,
-		status: result.status,
-		message: result.message,
-		output: result.output,
-	})
-}
-
-export async function uninstallMarketplaceEntryFromCatalog(
-	controller: Controller,
-	entry: MarketplaceEntry,
-): Promise<MarketplaceInstallResult> {
-	const workspaceRoot = await getWorkspacePath()
-	const result = await uninstallCoreMarketplaceEntry(toCoreMarketplaceEntry(entry), {
-		deleteMcpServer: async (name) => {
-			await controller.mcpHub?.deleteServerRPC(name)
-		},
-		workspaceRoot,
-	})
-	return toProtoMarketplaceInstallResult(result)
-}
-
-function readPackageName(packageJsonPath: string): string | undefined {
-	try {
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as { name?: unknown }
-		return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name.trim() : undefined
-	} catch {
-		return undefined
-	}
-}
-
-function isPathWithin(parentPath: string, childPath: string): boolean {
-	const relativePath = relative(resolve(parentPath), resolve(childPath))
-	return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath))
-}
-
-function isGlobalClinePath(filePath: string | undefined): boolean {
-	if (!filePath || filePath.startsWith("remote:")) return false
-	return [resolveClineHome(), join(homedir(), ".agents", "skills")].some((root) => isPathWithin(root, filePath))
-}
-
-function getPluginDisplayName(filePath: string, searchRoot: string): string {
-	let current = dirname(filePath)
-	const root = resolve(searchRoot)
-	while (isPathWithin(root, current)) {
-		const packageJsonPath = join(current, "package.json")
-		if (existsSync(packageJsonPath)) {
-			const packageName = readPackageName(packageJsonPath)
-			if (packageName) return packageName
-			break
-		}
-		const parent = resolve(current, "..")
-		if (parent === current) break
-		current = parent
-	}
-	return basename(filePath, extname(filePath))
-}
-
-async function listPluginLocalEntries(): Promise<MarketplaceLocalInstalledEntry[]> {
-	const workspacePath = HostProvider.isInitialized() ? (await HostProvider.workspace.getWorkspacePaths({})).paths[0] : undefined
-	const roots = resolvePluginConfigSearchPaths(workspacePath).filter((directory) => existsSync(directory))
-	const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? [])
-	const entries: MarketplaceLocalInstalledEntry[] = []
-	for (const root of roots) {
-		for (const pluginPath of discoverPluginModulePaths(root)) {
-			entries.push(
-				MarketplaceLocalInstalledEntry.create({
-					id: pluginPath,
-					type: "plugin",
-					name: getPluginDisplayName(pluginPath, root),
-					path: pluginPath,
-					source: isGlobalClinePath(pluginPath) ? "global" : "workspace",
-					enabled: !disabledPlugins.has(pluginPath),
-				}),
-			)
-		}
-	}
-	return entries
-}
-
-export async function listLocalMarketplaceInstalledEntries(controller: Controller): Promise<MarketplaceLocalInstalledEntries> {
-	const mcpEntries = (controller.mcpHub?.getServers() ?? []).map((server) =>
-		MarketplaceLocalInstalledEntry.create({
-			id: server.name,
-			type: "mcp",
-			name: server.name,
-			description: server.status,
-			enabled: server.disabled !== true,
-		}),
-	)
-	const refreshedSkills = await refreshSkills(controller)
-	const skillEntries = [
-		...refreshedSkills.globalSkills.map((skill) =>
-			MarketplaceLocalInstalledEntry.create({
-				id: skill.name,
-				type: "skill",
-				name: skill.name,
-				description: skill.description,
-				path: skill.path,
-				source: skill.path.startsWith("remote:") ? "remote" : "global",
-				enabled: skill.enabled,
-			}),
-		),
-		...refreshedSkills.localSkills.map((skill) =>
-			MarketplaceLocalInstalledEntry.create({
-				id: skill.name,
-				type: "skill",
-				name: skill.name,
-				description: skill.description,
-				path: skill.path,
-				source: isGlobalClinePath(skill.path) ? "global" : "workspace",
-				enabled: skill.enabled,
-			}),
-		),
-	]
-	const pluginEntries = await listPluginLocalEntries()
-	return MarketplaceLocalInstalledEntries.create({ entries: [...mcpEntries, ...skillEntries, ...pluginEntries] })
-}
-
-async function getWorkspacePath(): Promise<string | undefined> {
-	return HostProvider.isInitialized() ? (await HostProvider.workspace.getWorkspacePaths({})).paths[0] : undefined
-}
-
-function getActiveProviderAndModel(controller: Controller): { providerId?: string; modelId?: string } {
-	const mode = controller.stateManager.getGlobalSettingsKey("mode") === "plan" ? "plan" : "act"
-	const apiConfiguration = controller.stateManager.getApiConfiguration()
-	const providerId = mode === "plan" ? apiConfiguration.planModeApiProvider : apiConfiguration.actModeApiProvider
-	const modelId = resolveActiveModelIdFromApiConfiguration(apiConfiguration, mode)
-	return { providerId, modelId }
-}
-
-async function togglePluginLocalEntry(
-	controller: Controller,
-	entry: MarketplaceLocalInstalledEntry,
-	enabled: boolean,
-): Promise<void> {
-	if (!entry.path) throw new Error("Plugin path is required.")
-	if (!enabled) {
-		disablePluginMcpServersInSettings({ pluginPaths: [entry.path] })
-		setDisabledPlugin(entry.path, true)
-		return
-	}
-
-	const workspacePath = await getWorkspacePath()
-	const { providerId, modelId } = getActiveProviderAndModel(controller)
-	const ownedMcpMutations = disablePluginMcpServersInSettings({ pluginPaths: [entry.path] })
-	const result = await syncPluginMcpServersToSettings({
-		pluginPaths: [entry.path],
-		cwd: workspacePath,
-		workspacePath,
-		providerId,
-		modelId,
-	})
-	if (ownedMcpMutations.length > 0 && result.failures.length > 0) {
-		throw new Error(
-			`Failed to sync plugin MCP servers: ${result.failures
-				.map((failure) => `${failure.pluginName ?? failure.pluginPath}: ${failure.message}`)
-				.join("; ")}`,
-		)
-	}
-	setDisabledPlugin(entry.path, false)
-}
-
-export async function toggleLocalMarketplaceInstalledEntry(
-	controller: Controller,
-	request: ToggleMarketplaceLocalInstalledEntryRequest,
-): Promise<MarketplaceLocalInstalledEntries> {
-	const { entry, enabled } = request
-	if (!entry) throw new Error("Installed marketplace entry is required.")
-	if (entry.type === "mcp") {
-		const name = entry.name || entry.id
-		if (!name) throw new Error("MCP server name is required.")
-		await controller.mcpHub?.toggleServerDisabledRPC(name, !enabled)
-		return listLocalMarketplaceInstalledEntries(controller)
-	}
-	if (entry.type === "skill") {
-		await toggleSkill(
-			controller,
-			ToggleSkillRequest.create({
-				skillPath: entry.path || entry.id,
-				isGlobal: entry.source === "global",
-				enabled,
-			}),
-		)
-		return listLocalMarketplaceInstalledEntries(controller)
-	}
-	if (entry.type === "plugin") {
-		await togglePluginLocalEntry(controller, entry, enabled)
-		await controller.invalidateUserInstructionService()
-		return listLocalMarketplaceInstalledEntries(controller)
-	}
-	throw new Error(`Marketplace toggle is not supported for ${entry.type}.`)
-}
-
-export async function uninstallLocalMarketplaceInstalledEntry(
-	controller: Controller,
-	request: MarketplaceLocalInstalledEntryRequest,
-): Promise<MarketplaceInstallResult> {
-	const { entry } = request
-	if (!entry) throw new Error("Installed marketplace entry is required.")
-	const name = entry.name || entry.id
-	if (entry.type === "mcp") {
-		if (!name) throw new Error("MCP server name is required.")
-		await controller.mcpHub?.deleteServerRPC(name)
-		return MarketplaceInstallResult.create({
-			id: entry.id,
-			type: entry.type,
-			status: "uninstalled",
-			message: `Uninstalled ${name}.`,
-		})
-	}
-	if (entry.type === "skill") {
-		if (entry.path?.startsWith("remote:")) {
-			throw new Error("Remote-managed skills cannot be uninstalled from Customize.")
-		}
-		if (!entry.path) throw new Error("Skill path is required for uninstall.")
-		await deleteSkillFile(
-			controller,
-			DeleteSkillRequest.create({
-				skillPath: entry.path,
-				isGlobal: entry.source === "global",
-			}),
-		)
-		await controller.invalidateUserInstructionService()
-		return MarketplaceInstallResult.create({
-			id: entry.id,
-			type: entry.type,
-			status: "uninstalled",
-			message: `Uninstalled ${name || entry.id}.`,
-		})
-	}
-	if (entry.type === "plugin") {
-		const workspaceRoot = await getWorkspacePath()
-		const result = await uninstallPlugin({
-			name: entry.path ? undefined : name,
-			path: entry.path,
-			workspaceRoot,
-		})
-		await controller.invalidateUserInstructionService()
-		return MarketplaceInstallResult.create({
-			id: entry.id,
-			type: entry.type,
-			status: "uninstalled",
-			message: `Uninstalled ${result.name}.`,
-			output: [`Path: ${result.installPath}`, ...result.removedPaths.map((path) => `Removed: ${path}`)].join("\n"),
-		})
-	}
-	throw new Error(`Marketplace uninstall is not supported for ${entry.type}.`)
-}
@@ -1,13 +0,0 @@
-import type {
-	MarketplaceLocalInstalledEntries,
-	ToggleMarketplaceLocalInstalledEntryRequest,
-} from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { toggleLocalMarketplaceInstalledEntry } from "./marketplace-helpers"
-
-export async function toggleMarketplaceLocalInstalledEntry(
-	controller: Controller,
-	request: ToggleMarketplaceLocalInstalledEntryRequest,
-): Promise<MarketplaceLocalInstalledEntries> {
-	return toggleLocalMarketplaceInstalledEntry(controller, request)
-}
@@ -1,17 +0,0 @@
-import { type MarketplaceEntryRequest, MarketplaceInstallResult } from "@shared/proto/cline/marketplace"
-import type { Controller } from "../index"
-import { uninstallMarketplaceEntryFromCatalog } from "./marketplace-helpers"
-
-export async function uninstallMarketplaceEntry(
-	controller: Controller,
-	request: MarketplaceEntryRequest,
-): Promise<MarketplaceInstallResult> {
-	if (!request.entry) {
-		throw new Error("Marketplace entry is required.")
-	}
-	const result = await uninstallMarketplaceEntryFromCatalog(controller, request.entry)
-	if (request.entry.type === "skill" || request.entry.type === "plugin") {
-		await controller.invalidateUserInstructionService()
-	}
-	return result
-}
--- a/Show More
+++ b/Show More