Merge PR #13069 head (cloud models, prompt dedupe, org scope fixes) into desktop-experimental

# Conflicts:
#	apps/examples/desktop-app/sidecar/chat-session.ts

.changeset/response-header-copy-button.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Bring back a copy button on turn-final response rows, under a new subtle "Completed" / "Plan" header

.changeset/view-changes-hidden-until-changes.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Hide the "View Changes" button on completion rows until there are actually changes to show, instead of rendering it faded and disabled. Turns that changed nothing, non-git workspaces, and repos without commits no longer show a dead button with a misleading tooltip.

.cline/skills/publish-desktop/SKILL.md

@@ -1,28 +1,34 @@
 ---
 name: publish-desktop
-description: Use when preparing, tagging, and publishing a Cline Code desktop app (apps/examples/desktop-app) release. Guides changelog drafting, version bumps in package.json + tauri.conf.json, desktop-vX.Y.Z tags, and the desktop-publish GitHub workflow that builds, signs, notarizes, and updates the auto-update feed.
+description: Use when preparing, tagging, and publishing a Cline Code desktop app (apps/examples/desktop-app) release — stable (desktop-vX.Y.Z from main) or beta (desktop-vX.Y.Z-beta.N from desktop-experimental, shipped as the side-by-side "Cline Code Beta" app). Guides changelog drafting, version bumps in package.json + tauri.conf.json, tagging, and the desktop-publish GitHub workflow that builds, signs, notarizes, and updates the per-channel auto-update feed.
 ---
 
 # Desktop App Release
 
-Use this skill when the user asks to release the desktop app, publish Cline Code, bump the desktop version, create a `desktop-vX.Y.Z` tag, or trigger the desktop publish workflow.
+Use this skill when the user asks to release the desktop app, publish Cline Code, cut a desktop beta, bump the desktop version, create a `desktop-vX.Y.Z` (or `desktop-vX.Y.Z-beta.N`) tag, or trigger the desktop publish workflow.
 
 > Working directory: run every command below from the repository root.
 
-Desktop releases are macOS-only today (a single signed + notarized universal DMG that runs natively on both Apple Silicon and Intel) and are built entirely in GitHub Actions — there is no local publish path. Installed apps discover new releases automatically through the Tauri updater, so publishing a release is what ships the update to every existing user.
+Desktop releases are macOS-only today (a single signed + notarized universal DMG that runs natively on both Apple Silicon and Intel) and are built entirely in GitHub Actions — there is no local publish path. Installed apps discover new releases automatically through the Tauri updater, so publishing a release is what ships the update to every existing user **on that channel**.
 
 ## Release contract
 
+- Two channels, one workflow (`channel` input on `desktop-publish.yml`):
+  - **stable** — tag `desktop-vX.Y.Z` (no suffix; the workflow rejects prerelease suffixes on this channel), cut from `main`, feeds the rolling `desktop-latest` release, ships as "Cline Code".
+  - **beta** — tag `desktop-vX.Y.Z-beta.N`, cut from `desktop-experimental`, feeds the rolling `desktop-beta` release, ships as "Cline Code Beta" (separate bundle identifier `bot.cline.app.beta`; installs side by side with stable). Built with the extra `src-tauri/tauri.beta.conf.json` overlay. Process background: `apps/examples/desktop-app/EXPERIMENTAL.md`.
 - Version sources (must match each other and the tag): `apps/examples/desktop-app/package.json` and `apps/examples/desktop-app/src-tauri/tauri.conf.json`. (`src-tauri/Cargo.toml` has its own version but `tauri.conf.json` overrides it; no need to touch it.)
-- Release tag: `desktop-vX.Y.Z`, where `X.Y.Z` matches both version files.
-- Release prep includes approved release notes, the version bumps, and an `apps/examples/desktop-app/CHANGELOG.md` update.
-- Publish path: `.github/workflows/desktop-publish.yml` (workflow_dispatch, requires the tag to exist, point at the checked-out commit, and be reachable from `origin/main`).
-- The workflow creates the `desktop-vX.Y.Z` GitHub release (universal DMG + updater artifact + `latest.json`) and refreshes the rolling `desktop-latest` release, which is the static auto-update feed every installed app polls. Never delete the `desktop-latest` release or tag.
-- The changelog's top `## X.Y.Z` section is extracted verbatim into the GitHub release body, the Slack announcement, and the updater manifest notes.
+- Beta versions are prereleases of the **next** stable: stable `0.0.13` → betas `0.0.14-beta.1`, `-beta.2`, … Once a stable ≥ the beta base ships, the next beta bumps its base (`0.0.15-beta.1`).
+- Release prep includes approved release notes, the version bumps, and an `apps/examples/desktop-app/CHANGELOG.md` update — committed on `main` for stable, on `desktop-experimental` for beta.
+- Publish path: `.github/workflows/desktop-publish.yml` (workflow_dispatch, requires the tag to exist, point at the checked-out commit, and be reachable from the channel's branch — `origin/main` for stable, `origin/desktop-experimental` for beta).
+- **Both channels dispatch from `main`.** This is a security invariant, not a convenience: the run executes `main`'s workflow copy and only the checkout points at the tag, so the signing-secret gates (the `github.ref == main` check and the PublishDesktop environment's main-only deployment-branch policy) hold for beta too. Never add `desktop-experimental` to the PublishDesktop deployment-branch policy.
+- The workflow creates the tag's GitHub release (universal DMG + updater artifact + `latest.json`; marked prerelease for beta) and refreshes the channel's rolling feed release, which is the static auto-update feed every installed app on that channel polls. Never delete the `desktop-latest` or `desktop-beta` release or tag.
+- The changelog's `## <version>` section (exact-match, not "topmost") is extracted verbatim into the GitHub release body, the Slack announcement, and the updater manifest notes.
 - Always ask before pushing commits or tags.
 
 ## Workflow
 
+0. Ask which channel this release is for — **stable or beta** — if the user has not said. Everything below branches on it; never guess.
+
 1. Gather context.
 
 ```sh
@@ -35,10 +41,15 @@ node -p "require('./apps/examples/desktop-app/src-tauri/tauri.conf.json').versio
 
 If there is no `desktop-v*` tag yet, this is the first release; use the desktop app's first commit as the baseline and say the baseline is inferred.
 
+For a **beta** release, work on `desktop-experimental` (check out `origin/desktop-experimental`; merge `origin/main` into it first if it is behind — see EXPERIMENTAL.md for the conflict policy) and read the version files from that branch. The last-tag baseline is the newest `desktop-v*` tag of either channel that is an ancestor of the branch.
+
 2. Collect release commits.
 
 ```sh
+# stable (on main):
 git log <last-desktop-tag>..HEAD --oneline --no-merges -- apps/examples/desktop-app sdk/packages .github/workflows/desktop-publish.yml
+# beta (on desktop-experimental):
+git log <last-desktop-tag>..origin/desktop-experimental --oneline --no-merges -- apps/examples/desktop-app sdk/packages .github/workflows/desktop-publish.yml
 ```
 
 The sidecar bundles `@cline/core` and friends from the monorepo, so SDK changes ship inside the desktop app too. Fold user-visible SDK changes (providers, models, behavior fixes) into the notes; skip purely internal ones.
@@ -49,13 +60,15 @@ Flat bullet list, user-facing language. Present the draft and wait for approval
 
 4. Decide the version bump.
 
-Ask whether this is patch, minor, major, or an explicit version. Do not guess if the user has not made it clear.
+Stable: ask whether this is patch, minor, major, or an explicit version. Do not guess if the user has not made it clear.
 
-5. Update release files.
+Beta: apply the versioning rule — base = next stable version, increment `N` (`0.0.14-beta.1` → `0.0.14-beta.2`; after stable `0.0.14` ships, next is `0.0.15-beta.1`). Confirm the computed version with the user.
+
+5. Update release files (on `main` for stable, on `desktop-experimental` for beta).
 
 - `apps/examples/desktop-app/package.json` → new version
 - `apps/examples/desktop-app/src-tauri/tauri.conf.json` → same version
-- Prepend `## X.Y.Z` (no date) to `apps/examples/desktop-app/CHANGELOG.md` with the approved notes.
+- Prepend `## X.Y.Z` (no date; `## X.Y.Z-beta.N` for beta) to `apps/examples/desktop-app/CHANGELOG.md` with the approved notes.
 
 6. Verify before committing.
 
@@ -77,16 +90,20 @@ Ask before pushing the release commit, then before creating and pushing the tag:
 
 ```sh
 git push origin HEAD
-git tag -a desktop-vX.Y.Z -m "Desktop vX.Y.Z"
+git tag -a desktop-vX.Y.Z -m "Desktop vX.Y.Z"       # beta: desktop-vX.Y.Z-beta.N / "Desktop vX.Y.Z-beta.N"
 git push origin refs/tags/desktop-vX.Y.Z
 ```
 
 8. Publish.
 
-The release commit must be on `main` and the tag pushed first.
+The release commit must be on the channel's branch (`main` for stable, `desktop-experimental` for beta) and the tag pushed first. Dispatch from `main` for **both** channels (see the release contract for why).
 
 ```sh
-gh workflow run desktop-publish.yml -f git_tag=desktop-vX.Y.Z -f confirm_publish=publish
+# stable:
+gh workflow run desktop-publish.yml --ref main -f git_tag=desktop-vX.Y.Z -f channel=stable -f confirm_publish=publish
+# beta:
+gh workflow run desktop-publish.yml --ref main -f git_tag=desktop-vX.Y.Z-beta.N -f channel=beta -f confirm_publish=publish
+
 gh run list --workflow=desktop-publish.yml --limit=1 --json url,status,conclusion,createdAt --jq '.[0]'
 ```
 
@@ -103,21 +120,24 @@ gh api repos/cline/cline/actions/runs/<run-id>/pending_deployments \
 
 Nothing after `validate` runs — and no signing key is readable — until then.
 
-The workflow builds one universal macOS bundle (`tauri build --target universal-apple-darwin` lipos the aarch64 + x86_64 Rust binaries; the Bun sidecar is lipo'd by `build-sidecar-bin.ts`), verifies every Mach-O in the bundle carries both slices, signs with the Developer ID certificate, notarizes with the App Store Connect API key, signs the updater artifact with the Tauri updater key, creates the GitHub release, refreshes `desktop-latest/latest.json`, and posts to Slack. Notarization typically adds 2–10 minutes.
+The workflow builds one universal macOS bundle (`tauri build --target universal-apple-darwin` lipos the aarch64 + x86_64 Rust binaries; the Bun sidecar is lipo'd by `build-sidecar-bin.ts`; beta adds the `tauri.beta.conf.json` overlay), verifies every Mach-O in the bundle carries both slices and that the compiled binary embeds exactly its own channel's feed URL, signs with the Developer ID certificate, notarizes with the App Store Connect API key, signs the updater artifact with the Tauri updater key, creates the GitHub release (prerelease for beta), refreshes the channel's feed (`desktop-latest/latest.json` or `desktop-beta/latest.json`), and posts to Slack. Notarization typically adds 2–10 minutes.
 
 If the workflow fails on missing credentials, see "Publish secrets (one-time setup)" below.
 
 9. Verify the update feed after the run succeeds.
 
 ```sh
-curl -sL https://github.com/cline/cline/releases/download/desktop-latest/latest.json | head -30
+curl -sL https://github.com/cline/cline/releases/download/desktop-latest/latest.json | head -30   # stable
+curl -sL https://github.com/cline/cline/releases/download/desktop-beta/latest.json | head -30    # beta
 ```
 
-The `version` field must be the new release and both `darwin-aarch64` and `darwin-x86_64` entries must point at the same new `desktop-vX.Y.Z` universal `.app.tar.gz` asset (each slice of the fat binary requests its own arch key at runtime, so both keys serve the one artifact). Installed apps — including older per-arch installs — pick the update up on next launch or within 2 hours.
+The `version` field must be the new release and both `darwin-aarch64` and `darwin-x86_64` entries must point at the same new universal `.app.tar.gz` asset under the release tag (each slice of the fat binary requests its own arch key at runtime, so both keys serve the one artifact). Installed apps on that channel — including older per-arch installs — pick the update up on next launch or within 2 hours.
+
+After a **beta** publish, also confirm the stable feed was not touched: `desktop-latest/latest.json` must still serve the previous stable version. (The workflow guards this fail-closed, but it is cheap to verify and catastrophic to miss — the updater comparator is a plain semver "newer than", so a beta manifest on `desktop-latest` would auto-update every stable install onto the beta.)
 
 10. Final response.
 
-Report: version, tag, changelog updated, commit hash, what was pushed, workflow URL, and the feed verification result.
+Report: channel, version, tag, changelog updated, commit hash, what was pushed, workflow URL, and the feed verification result.
 
 ## Publish secrets (one-time setup)
 

.github/workflows/desktop-publish.yml

@@ -11,6 +11,14 @@ on:
         description: 'Type "publish" to confirm the desktop release.'
         required: true
         type: string
+      channel:
+        description: "Release channel"
+        required: true
+        type: choice
+        options:
+          - stable
+          - beta
+        default: stable
 
 permissions:
   contents: read
@@ -30,6 +38,9 @@ jobs:
     outputs:
       version: ${{ steps.version.outputs.version }}
       tag: ${{ steps.version.outputs.tag }}
+      channel: ${{ steps.version.outputs.channel }}
+      feed: ${{ steps.version.outputs.feed }}
+      product: ${{ steps.version.outputs.product }}
     steps:
       # Companion to the presence check in `build`, and the half that actually
       # establishes scope. This job declares no environment, so a signing secret
@@ -81,11 +92,41 @@ jobs:
         id: version
         env:
           TAG: ${{ github.event.inputs.git_tag }}
+          # inputs.* (not github.event.inputs.*) so the declared default
+          # applies when an API dispatch omits the channel input entirely.
+          CHANNEL: ${{ inputs.channel }}
         run: |
-          if ! printf "%s\n" "$TAG" | grep -Eq '^desktop-v[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?$'; then
-            echo "git_tag must look like desktop-vX.Y.Z, got: ${TAG}"
-            exit 1
-          fi
+          # Fail-closed channel mapping: every channel defines its tag shape,
+          # its ancestry source, its feed, and its product name, and an unknown
+          # channel dies here. The feed assignment is the load-bearing one —
+          # the updater comparator is a plain semver "newer than", so a beta
+          # manifest landing on desktop-latest would auto-update every stable
+          # install onto the beta. The stable regex rejects prerelease
+          # suffixes for the same reason.
+          case "$CHANNEL" in
+            stable)
+              if ! printf "%s\n" "$TAG" | grep -Eq '^desktop-v[0-9]+\.[0-9]+\.[0-9]+$'; then
+                echo "stable git_tag must look like desktop-vX.Y.Z with no suffix, got: ${TAG}"
+                exit 1
+              fi
+              ANCESTOR_REF=main
+              FEED=desktop-latest
+              PRODUCT="Cline Code"
+              ;;
+            beta)
+              if ! printf "%s\n" "$TAG" | grep -Eq '^desktop-v[0-9]+\.[0-9]+\.[0-9]+-beta\.[0-9]+$'; then
+                echo "beta git_tag must look like desktop-vX.Y.Z-beta.N, got: ${TAG}"
+                exit 1
+              fi
+              ANCESTOR_REF=desktop-experimental
+              FEED=desktop-beta
+              PRODUCT="Cline Code Beta"
+              ;;
+            *)
+              echo "unknown channel: ${CHANNEL}"
+              exit 1
+              ;;
+          esac
 
           VERSION="${TAG#desktop-v}"
           PACKAGE_VERSION=$(node -p "require('./apps/examples/desktop-app/package.json').version")
@@ -108,14 +149,17 @@ jobs:
             exit 1
           fi
 
-          git fetch origin +main:refs/remotes/origin/main
-          if ! git merge-base --is-ancestor "$HEAD_COMMIT" origin/main; then
-            echo "${TAG} is not reachable from origin/main"
+          git fetch origin "+${ANCESTOR_REF}:refs/remotes/origin/${ANCESTOR_REF}"
+          if ! git merge-base --is-ancestor "$HEAD_COMMIT" "origin/${ANCESTOR_REF}"; then
+            echo "${TAG} is not reachable from origin/${ANCESTOR_REF}"
             exit 1
           fi
 
           echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
           echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+          echo "channel=${CHANNEL}" >> "$GITHUB_OUTPUT"
+          echo "feed=${FEED}" >> "$GITHUB_OUTPUT"
+          echo "product=${PRODUCT}" >> "$GITHUB_OUTPUT"
 
   build:
     name: Build macOS (universal)
@@ -126,6 +170,25 @@ jobs:
     # run. Defense in depth: this `if` is advisory because a dispatched branch
     # runs its own copy of this file; the enforced gate is the PublishDesktop
     # environment's deployment-branch policy, which must also allow only main.
+    #
+    # Beta releases do not weaken this: a beta publish is ALSO dispatched from
+    # main (so this gate, the branch policy, and the workflow file executed all
+    # stay main's) — only the checked-out tag points into desktop-experimental,
+    # which validate pins via the ancestry check. A workflow copy edited on
+    # desktop-experimental can therefore never reach the signing secrets.
+    #
+    # What dispatch-from-main does NOT protect: the checked-out tag's own
+    # build scripts (bun install hooks, build:sdk, Tauri's beforeBuildCommand,
+    # build.rs) run inside this job with the signing secrets in scope, for
+    # stable and beta alike. The control for that is this environment's
+    # required-reviewer approval — the approver is vouching for the code the
+    # tag points at, not just for "a release happening". Two consequences:
+    # desktop-experimental must keep main-grade merge controls (branch
+    # protection, maintainer-only pushes), and an approval should only follow
+    # a look at what the tag actually contains. Building betas without these
+    # secrets is not an option: unsigned bundles fail Gatekeeper and updater
+    # artifacts must be signed with the same key or beta installs cannot
+    # verify their updates.
     if: github.ref == 'refs/heads/main'
     environment: PublishDesktop
     runs-on: macos-latest
@@ -223,8 +286,13 @@ jobs:
 
       - name: Build, sign, and notarize desktop bundle
         working-directory: apps/examples/desktop-app
-        run: bunx tauri build --target universal-apple-darwin --config src-tauri/tauri.release.conf.json
+        # Tauri merges repeated --config flags in order, so the beta overlay
+        # (product name, bundle identifier, beta update feed) layers on top of
+        # the release overlay without duplicating it. $CONFIG_ARGS is
+        # deliberately unquoted: it must word-split into separate flags.
+        run: bunx tauri build --target universal-apple-darwin $CONFIG_ARGS
         env:
+          CONFIG_ARGS: ${{ needs.validate.outputs.channel == 'beta' && '--config src-tauri/tauri.release.conf.json --config src-tauri/tauri.beta.conf.json' || '--config src-tauri/tauri.release.conf.json' }}
           # Telemetry config for the sidecar binary. Tauri's beforeBuildCommand
           # (`bun run build` -> build:sidecar:bin) compiles the sidecar during
           # this step and inlines these values into the binary via `--define`
@@ -258,8 +326,10 @@ jobs:
       # sidecar would otherwise ship fine and only crash on the other arch.
       - name: Verify bundle is a universal binary
         working-directory: apps/examples/desktop-app
+        env:
+          PRODUCT: ${{ needs.validate.outputs.product }}
         run: |
-          APP="src-tauri/target/universal-apple-darwin/release/bundle/macos/Cline Code.app"
+          APP="src-tauri/target/universal-apple-darwin/release/bundle/macos/${PRODUCT}.app"
           if [ ! -d "$APP" ]; then
             echo "app bundle not found at $APP"
             exit 1
@@ -276,6 +346,57 @@ jobs:
             esac
           done
 
+      # Guardrail: the updater endpoint is compiled into the main binary as a
+      # string literal (tauri-build embeds the merged config via codegen), so
+      # assert the bundle carries this channel's feed URL and not the other
+      # channel's, before anything gets signed into a release. This catches a
+      # --config overlay that silently failed to apply: a beta bundle polling
+      # desktop-latest would pull its users onto stable builds, and a stable
+      # bundle polling desktop-beta would push betas to every stable install.
+      - name: Verify updater feed endpoint
+        working-directory: apps/examples/desktop-app
+        env:
+          CHANNEL: ${{ needs.validate.outputs.channel }}
+          PRODUCT: ${{ needs.validate.outputs.product }}
+        run: |
+          APP="src-tauri/target/universal-apple-darwin/release/bundle/macos/${PRODUCT}.app"
+          case "$CHANNEL" in
+            stable)
+              WANT="releases/download/desktop-latest/latest.json"
+              FORBID="releases/download/desktop-beta/latest.json"
+              ;;
+            beta)
+              WANT="releases/download/desktop-beta/latest.json"
+              FORBID="releases/download/desktop-latest/latest.json"
+              ;;
+            *)
+              echo "unknown channel: ${CHANNEL}"
+              exit 1
+              ;;
+          esac
+
+          # Plain grep >/dev/null rather than grep -q: -q exits at the first
+          # match, SIGPIPEs strings, and would read as a failed pipeline under
+          # pipefail.
+          found=0
+          for bin in "$APP/Contents/MacOS/"*; do
+            if strings -a "$bin" | grep "$FORBID" >/dev/null; then
+              echo "$bin embeds the other channel's feed URL (${FORBID})"
+              exit 1
+            fi
+            if strings -a "$bin" | grep "$WANT" >/dev/null; then
+              found=1
+            fi
+          done
+
+          if [ "$found" -ne 1 ]; then
+            echo "No binary in ${APP}/Contents/MacOS embeds ${WANT}."
+            echo "The updater endpoint overlay did not apply; check the"
+            echo "--config flags on the build step and tauri.beta.conf.json."
+            exit 1
+          fi
+          echo "Updater endpoint verified: ${WANT}"
+
       # Guardrail: assert the telemetry config actually made it into the
       # compiled sidecar. Missing env on the build step (or a regression in
       # the --define inlining) would otherwise ship a release with telemetry
@@ -308,25 +429,29 @@ jobs:
         working-directory: apps/examples/desktop-app
         env:
           VERSION: ${{ needs.validate.outputs.version }}
+          PRODUCT: ${{ needs.validate.outputs.product }}
         run: |
           BUNDLE_DIR="src-tauri/target/universal-apple-darwin/release/bundle"
           OUT="dist/publish"
           mkdir -p "$OUT"
 
+          # "Cline Code" -> Cline-Code, "Cline Code Beta" -> Cline-Code-Beta
+          PREFIX="${PRODUCT// /-}"
+
           DMG=$(find "$BUNDLE_DIR/dmg" -name '*.dmg' -print -quit)
           if [ -z "$DMG" ]; then
             echo "no DMG produced under $BUNDLE_DIR/dmg"
             exit 1
           fi
-          cp "$DMG" "$OUT/Cline-Code_${VERSION}_universal.dmg"
+          cp "$DMG" "$OUT/${PREFIX}_${VERSION}_universal.dmg"
 
           TARBALL=$(find "$BUNDLE_DIR/macos" -name '*.app.tar.gz' -print -quit)
           if [ -z "$TARBALL" ] || [ ! -f "${TARBALL}.sig" ]; then
             echo "updater artifact or signature missing under $BUNDLE_DIR/macos"
             exit 1
           fi
-          cp "$TARBALL" "$OUT/Cline-Code_${VERSION}_universal.app.tar.gz"
-          cp "${TARBALL}.sig" "$OUT/Cline-Code_${VERSION}_universal.app.tar.gz.sig"
+          cp "$TARBALL" "$OUT/${PREFIX}_${VERSION}_universal.app.tar.gz"
+          cp "${TARBALL}.sig" "$OUT/${PREFIX}_${VERSION}_universal.app.tar.gz.sig"
 
           ls -lh "$OUT"
 
@@ -364,9 +489,18 @@ jobs:
 
       - name: Get Changelog Entry
         id: changelog
+        env:
+          VERSION: ${{ needs.validate.outputs.version }}
         run: |
-          # Grab content between the first "## " header and the next one
-          CONTENT=$(awk '/^## [0-9]/{if(found) exit; found=1; next} found{print}' apps/examples/desktop-app/CHANGELOG.md)
+          # Grab content between this release's "## <version>" header and the
+          # next one. Exact match, not "first section": once main and
+          # desktop-experimental cross-merge, stable and beta sections
+          # interleave and the top section may belong to the other channel.
+          CONTENT=$(awk -v ver="$VERSION" '$0 == "## " ver {found=1; next} /^## [0-9]/ {if (found) exit} found {print}' apps/examples/desktop-app/CHANGELOG.md)
+          if [ -z "$CONTENT" ]; then
+            echo "No '## ${VERSION}' section found in apps/examples/desktop-app/CHANGELOG.md"
+            exit 1
+          fi
           echo "content<<EOF" >> $GITHUB_OUTPUT
           echo "$CONTENT" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
@@ -390,8 +524,15 @@ jobs:
         id: prev_tag
         env:
           CURRENT_TAG: ${{ needs.validate.outputs.tag }}
+          CHANNEL: ${{ needs.validate.outputs.channel }}
         run: |
-          PREV_TAG=$(git describe --tags --abbrev=0 --match 'desktop-v*' "$CURRENT_TAG^" 2>/dev/null || echo "")
+          # Stable compare links skip beta tags so they read stable -> stable;
+          # beta compares against whatever shipped last on either channel.
+          if [ "$CHANNEL" = "stable" ]; then
+            PREV_TAG=$(git describe --tags --abbrev=0 --match 'desktop-v*' --exclude 'desktop-v*-beta*' "$CURRENT_TAG^" 2>/dev/null || echo "")
+          else
+            PREV_TAG=$(git describe --tags --abbrev=0 --match 'desktop-v*' "$CURRENT_TAG^" 2>/dev/null || echo "")
+          fi
           echo "prev_tag=$PREV_TAG" >> $GITHUB_OUTPUT
 
       - name: Create GitHub Release
@@ -402,6 +543,7 @@ jobs:
           # The repo-wide "latest" release stays owned by CLI releases; the
           # desktop auto-update feed is the rolling desktop-latest release.
           make_latest: "false"
+          prerelease: ${{ needs.validate.outputs.channel == 'beta' }}
           files: dist/desktop/*
           body: |
             ${{ steps.changelog.outputs.content }}
@@ -410,27 +552,58 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Update auto-update feed (desktop-latest)
+      - name: Update auto-update feed
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CHANNEL: ${{ needs.validate.outputs.channel }}
+          FEED: ${{ needs.validate.outputs.feed }}
         run: |
-          if ! gh release view desktop-latest >/dev/null 2>&1; then
-            gh release create desktop-latest \
-              --title "Cline Code desktop (auto-update feed)" \
-              --notes "Rolling release backing the desktop app auto-updater. The latest.json asset points at the newest desktop-vX.Y.Z release. Do not delete." \
-              --latest=false \
-              --target "$(git rev-parse HEAD)"
+          # Belt and braces: recompute the feed from the channel and require it
+          # to agree with validate's output, so no single threading bug can
+          # point a publish at the other channel's feed. Stable installs poll
+          # desktop-latest and beta installs poll desktop-beta; crossing the
+          # streams either pushes betas to every stable user or strands beta
+          # users on stale builds.
+          case "$CHANNEL" in
+            stable) EXPECTED_FEED=desktop-latest ;;
+            beta) EXPECTED_FEED=desktop-beta ;;
+            *)
+              echo "unknown channel: ${CHANNEL}"
+              exit 1
+              ;;
+          esac
+          if [ "$FEED" != "$EXPECTED_FEED" ]; then
+            echo "feed mismatch: validate says '${FEED}' but channel '${CHANNEL}' expects '${EXPECTED_FEED}'"
+            exit 1
           fi
-          gh release upload desktop-latest dist/desktop/latest.json --clobber
+
+          if ! gh release view "$FEED" >/dev/null 2>&1; then
+            if [ "$CHANNEL" = "beta" ]; then
+              gh release create "$FEED" \
+                --title "Cline Code desktop beta (auto-update feed)" \
+                --notes "Rolling release backing the beta desktop app auto-updater. The latest.json asset points at the newest desktop-vX.Y.Z-beta.N release. Only beta installs poll this feed; stable installs use desktop-latest. Do not delete." \
+                --latest=false \
+                --prerelease \
+                --target "$(git rev-parse HEAD)"
+            else
+              gh release create "$FEED" \
+                --title "Cline Code desktop (auto-update feed)" \
+                --notes "Rolling release backing the desktop app auto-updater. The latest.json asset points at the newest desktop-vX.Y.Z release. Do not delete." \
+                --latest=false \
+                --target "$(git rev-parse HEAD)"
+            fi
+          fi
+          gh release upload "$FEED" dist/desktop/latest.json --clobber
 
       - name: Summary
         env:
           VERSION: ${{ needs.validate.outputs.version }}
           TAG: ${{ needs.validate.outputs.tag }}
+          FEED: ${{ needs.validate.outputs.feed }}
         run: |
           echo "Published Cline Code desktop v${VERSION}"
           echo "Release: https://github.com/${GITHUB_REPOSITORY}/releases/tag/${TAG}"
-          echo "Auto-update feed refreshed: https://github.com/${GITHUB_REPOSITORY}/releases/download/desktop-latest/latest.json"
+          echo "Auto-update feed refreshed: https://github.com/${GITHUB_REPOSITORY}/releases/download/${FEED}/latest.json"
 
       - name: Post release to Slack
         uses: slackapi/slack-github-action@v3.0.1
@@ -439,12 +612,12 @@ jobs:
           token: ${{ secrets.SLACK_RELEASE_BOT_TOKEN }}
           payload: |
             channel: "C0APVKGGZFC"
-            text: "Cline Code desktop v${{ needs.validate.outputs.version }}"
+            text: "Cline Code desktop v${{ needs.validate.outputs.version }}${{ needs.validate.outputs.channel == 'beta' && ' (beta)' || '' }}"
             blocks:
               - type: "section"
                 text:
                   type: "mrkdwn"
-                  text: "Cline Code desktop v${{ needs.validate.outputs.version }}"
+                  text: "Cline Code desktop v${{ needs.validate.outputs.version }}${{ needs.validate.outputs.channel == 'beta' && ' (beta)' || '' }}"
               - type: "section"
                 text:
                   type: "mrkdwn"
@@ -452,4 +625,4 @@ jobs:
               - type: "context"
                 elements:
                   - type: "mrkdwn"
-                    text: "<https://github.com/${{ github.repository }}/releases/tag/${{ needs.validate.outputs.tag }}|Download DMG> — installed apps auto-update on next launch${{ steps.prev_tag.outputs.prev_tag != '' && format(' | Full Changelog: https://github.com/{0}/compare/{1}...{2}', github.repository, steps.prev_tag.outputs.prev_tag, needs.validate.outputs.tag) || '' }}"
+                    text: "<https://github.com/${{ github.repository }}/releases/tag/${{ needs.validate.outputs.tag }}|Download DMG> — ${{ needs.validate.outputs.channel == 'beta' && 'beta channel: installs side by side with the stable app and only beta installs auto-update; stable users are unaffected' || 'installed apps auto-update on next launch' }}${{ steps.prev_tag.outputs.prev_tag != '' && format(' | Full Changelog: https://github.com/{0}/compare/{1}...{2}', github.repository, steps.prev_tag.outputs.prev_tag, needs.validate.outputs.tag) || '' }}"

.gitignore

@@ -92,3 +92,4 @@ apps/examples/desktop-app/webview/.next
 
 # Next.js generated type shim (churns between dev and build)
 apps/examples/desktop-app/webview/next-env.d.ts
+apps/examples/desktop-app/.cursor/settings.json

CHANGELOG.md

@@ -1,5 +1,142 @@
 # Changelog
 
+## [4.1.10]
+
+Everything in this release lands through the SDK bundle, so it applies to windows running that bundle and not the legacy one. The legacy bundle is unchanged from 4.1.9.
+
+### Added
+
+- Let models that support it search the web during a task, with a toggle in Feature Settings to turn it on. Search calls and their results appear in the conversation and persist across reloads.
+
+### Fixed
+
+- Stop two Cline installations on different builds from shutting each other's Hub daemon down in a loop, which killed live sessions with an abnormal socket close. Build identity is now compared through a total order, so at most one side of a pair can decide to retire the other.
+- Leave a Hub that is still serving sessions in place instead of replacing it mid-handshake; the swap happens once it goes idle.
+- Reclaim idle plugin sandbox processes instead of leaving them running for the life of the session.
+
+### Changed
+
+- Refresh the model catalog, which adds Crusoe as a provider and updates model lists and per-provider default models across the board.
+
+## [4.1.9]
+
+### Changed
+
+- Use the editor's foreground color for diff block text, so diffs stay legible in themes where the previous hardcoded color washed them out.
+- Switch the interface to Inter and Geist Mono.
+
+### Fixed
+
+- Don't discard a successfully refreshed Cline token when the old one was already past expiry, which made the first request after a long idle period fail despite valid credentials.
+- Stop the legacy-task migration backlog from spamming telemetry, and record a migration outcome only once the seeded session actually persists, so a failed migration is no longer reported as a success.
+- Report involuntary Cline logouts (a rejected refresh token) instead of clearing credentials silently.
+
+### Fixed (SDK bundle only)
+
+These land through SDK v0.0.74 and therefore apply to windows running the SDK bundle, not the legacy one.
+
+- Fix the Claude Code provider being unusable for agentic work: it now runs its own native tools instead of receiving tool definitions it cannot bridge, anchors the session on your workspace directory, and loads `~/.claude` plus project settings so your permission rules apply.
+- Reject truncated tool-call JSON instead of silently "repairing" it into wrong arguments.
+- Fix strict providers rejecting a turn with "user message must have content" when a message's content held only empty text parts.
+- Fix a mid-turn crash on streamed tool calls with non-zero or non-contiguous indexes, hit through LiteLLM's Anthropic passthrough.
+- Report disjoint per-request token buckets instead of re-counting the whole cached conversation on every request, which inflated per-task totals roughly 5x on cache-heavy sessions.
+
+## [4.1.8]
+
+### Added
+
+- Enter any Vertex model ID by hand, including models the catalog doesn't list yet.
+- Support Fable 5 on Vertex.
+
+### Changed
+
+- Show the full model catalog for every Vertex region instead of filtering the picker down to a hardcoded list of global-endpoint models, which lagged behind every model launch. Picking a model the region doesn't serve now fails at request time with recovery guidance in the error row.
+- Report Fable 5 cost on Vertex as unknown rather than applying Anthropic's list price, which understated what Vertex actually bills — its rates are region-dependent.
+- Make the auto-approve menu the single source of truth for unattended runs and remove the Yolo Mode toggle, which was cosmetic: nothing in the approval path read it. Setups that had Yolo Mode (or auto-approve-all) turned on are migrated to auto-approving every action, so they keep running unattended.
+
+### Fixed
+
+- Respect your configured max output tokens when the compaction summarizer requests a summary.
+- Remove the stale "Double-Check Completion" feature tip.
+
+## [4.1.7]
+
+### Added
+
+- Restore the "View Changes" button on completion rows, backed by SDK checkpoints, so you can review everything a task touched from the completion card.
+- Bring back a copy button on turn-final response rows.
+- Support pre-registered OAuth clients for remote MCP servers, for setups where dynamic client registration isn't available.
+
+### Changed
+
+- Fade the "View Changes" button until changes since the last message are confirmed, and hide it entirely when there is nothing to show.
+- Centralize plugin settings and contributions, with host-aware snapshots and atomic plugin toggles.
+- Carry execution context in scheduled run reports — readable headers, schedule metadata, durations, and lifecycle error details.
+
+### Fixed
+
+- Preserve prompts queued during a turn when that turn is interrupted: they survive aborts, are drained after a turn aborts itself, and the stop is surfaced instead of the queue being silently dropped.
+- Keep session context durable across aborts and hub restarts, so an interrupted session resumes with the state it had.
+- Settle the turn phase when a mode switch aborts a running turn.
+- Report queued-turn failures as `run.failed` instead of letting them complete silently.
+- Keep a hung MCP server from taking down session creation, and give stdio servers that were never configured a 30-second initialize budget instead of blocking indefinitely.
+- Surface OAuth authorization for SSE MCP servers on a 401 instead of failing outright.
+- Route LiteLLM through Chat Completions instead of the Responses API, fixing requests against LiteLLM proxies.
+- Retry network interruptions that happen mid-stream but before any model output, instead of failing the turn.
+- Use the configured fetch for Vertex ADC token refreshes, so they work behind proxies and custom transports.
+- Include files that were untracked when a snapshot was taken in checkpoint diffs, and pick up checkpoints when git is initialized part-way through a session.
+- Fall back to the session cwd or Desktop for @-mention file search in empty windows.
+- Never run a foreign compiled plugin-sandbox bootstrap for a source host.
+
+## [4.1.6]
+
+### Added
+
+- Offer `meta/muse-spark-1.2-contributor` on the Cline provider, alongside a refreshed model catalog.
+
+### Fixed
+
+- Attribute error telemetry to the model actually in use for a run, so failures are no longer reported against the wrong model.
+
+## [4.1.5]
+
+### Added
+
+- Explain when a free model promotion ends. Requests to a retired free model now show a dedicated notice with a button to pick another model, instead of a generic error with nothing but a Retry prompt.
+
+### Changed
+
+- Map reasoning settings onto a shared path across AI SDK providers, so effort levels and enable/disable toggles behave consistently (including on Ollama) instead of relying on per-provider overrides.
+
+## [4.1.4]
+
+### Added
+
+- Recognize Chutes as a provider.
+- Show skills alongside workflows in the slash command menu, and disambiguate commands that share a name instead of letting one shadow the other.
+
+### Changed
+
+- Remove model-initiated plan-to-act switching. Switching out of plan mode is now driven by you, not by the model deciding mid-turn.
+- Hard-block file-editing shell commands in plan mode instead of relying on prompting alone. Read-only investigation still works, but file manipulation, in-place editors, redirection to files, mutating git subcommands, and package installs are refused.
+
+### Fixed
+
+- Stop treating a turn that completes with a plan as a failed turn when a plan-blocked command was its only tool call. The turn no longer ends in the error state with a Retry footer, and toggling to Act correctly re-runs the presented plan instead of appearing to do nothing.
+- Show tool paths relative to the workspace in the chat view instead of absolute paths.
+- Reset pending attachments when starting a new task, so images from the previous task no longer carry over.
+- Surface a clear error when the selected provider has no API key configured, instead of a generic failure.
+- Refresh MCP tool and resource lists when a server sends a `list_changed` notification, instead of only showing a toast.
+- Show installed plugins under their real package names instead of all appearing as "index".
+- Correct the Linux keybinding label in the Plan/Act mode tooltip.
+- Recover from running out of context instead of failing with a raw provider error — the run compacts and retries once, and the cases that genuinely cannot be recovered explain why.
+- Retry empty model responses on every provider rather than only Ollama, fixing hard "Model returned empty response" failures on OpenRouter, Cline, and OpenAI-compatible endpoints.
+- Stop Claude 4.6+ and 5.x models being rejected with "thinking.type.enabled is not supported" when they resolve from the offline catalog or from a hand-typed model id.
+- Restore Bedrock prompt caching, which reported zero cache reads and writes because the provider sent a cache format Bedrock discards, and route Bedrock foundation models through geo inference profiles.
+- Send `max_completion_tokens` for reasoning models on OpenAI-compatible endpoints, and substitute image content for models without image support instead of failing the request.
+- Inherit the MiniMax default model from models.dev, and refresh the bundled catalog, which adds Infomaniak and SCX.ai.
+- Report the same provider failure once instead of twice in error telemetry, and rate-limit repeated failures from unattended retry loops.
+
 ## [4.1.3]
 
 ### Fixed

apps/cli/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Cline CLI Changelog
 
+## 3.0.55
+
+- Auto-updates no longer install while a CLI is attached to the Hub. The update is recorded at startup and installed on exit, once the Hub confirms nothing else is attached, so a background update can no longer swap the package out from under a live session and kill it with `Hub connection closed (code=1006)`. `cline update` still installs immediately and now tells you the update applies on next start
+- Added protections for an update landing under CLI 3.0.54 and earlier, whose updater restarts the Hub mid-session and then rejects every replacement, bricking a running session. The newly installed package defuses that path during install instead of leaving it to fire
+- Fixed two Cline installations on different builds shutting each other's Hub daemon down in a loop, which killed every live session with an abnormal socket close. Build identity is now compared through a total order, so at most one side of a pair can ever decide to retire the other (from SDK v0.0.75)
+- A newer build no longer replaces a Hub that is still serving sessions — it attaches to it and the swap happens on a later launch, instead of the sessions dying mid-handshake (from SDK v0.0.75)
+- Removed the "outdated Hub" notice. It reported a state you cannot act on, and the toast was capped narrower than the message, so it rendered cut off before the reassuring half of the sentence at every terminal width. The prompt for a genuine build mismatch, where there is something to do, is unchanged
+- Streaming assistant markdown no longer flashes back to raw text. Settled headings, links, and code stay rendered as new chunks arrive instead of the whole message being rebuilt and re-highlighted on every chunk, which also stops the transcript from jumping vertically mid-stream
+- Web search calls and their results from models that run search natively now render in the transcript (from SDK v0.0.75)
+- Idle plugin sandbox processes are now reclaimed instead of lingering for the life of the session (from SDK v0.0.75)
+- `cline doctor fix` now reports honestly: processes that survived a kill are separated from ones that appeared while the fix ran, a live parent respawning a daemon is named, and a startup lock held by a running process is reported as held rather than leaked (from SDK v0.0.75)
+- Refreshed the model catalog, which adds Crusoe as a provider and updates model lists and per-provider default models across the board (from SDK v0.0.75)
+
+## 3.0.54
+
+- Fixed the Claude Code provider being unusable for agentic work: the provider now runs its own native tools instead of receiving tool definitions it cannot bridge, the session is anchored on your workspace directory instead of inheriting the host's cwd, and `~/.claude` plus project settings are loaded so your permission rules apply. File edits under the workspace are auto-approved; command execution stays gated by your own Claude settings (from SDK v0.0.74)
+- Fixed truncated tool-call JSON being silently "repaired" into wrong arguments — a payload with an unterminated string is now rejected rather than getting an invented terminator (from SDK v0.0.74)
+- Fixed strict providers rejecting a turn with "user message must have content" when a message's content held only empty text parts (from SDK v0.0.74)
+- Fixed a mid-turn crash on streamed tool calls with non-zero or non-contiguous indexes, hit through LiteLLM's Anthropic passthrough (from SDK v0.0.74)
+- Managed Hub daemons now upgrade directionally: when another Cline install ships a newer Hub build, the CLI attaches to the newer daemon and prompts you to update and restart instead of the two installs repeatedly retiring each other's daemons. Yolo and sandbox sessions, which never attach to the shared Hub, are not interrupted by that prompt (from SDK v0.0.74)
+- Fixed the Hub daemon logging an unhandled `hub server close failed` error and exiting non-zero whenever a client was still connected at shutdown (from SDK v0.0.74)
+- Fixed per-task token totals being inflated roughly 5x on cache-heavy sessions — token telemetry now reports disjoint uncached-input, cache-read, and cache-write buckets instead of re-counting the whole cached conversation on every request (from SDK v0.0.74)
+- Upgrading the CLI now retires an already-running Hub daemon and respawns it on the new code, instead of the upgraded CLI continuing to talk to a daemon executing the previous release
+
+## 3.0.53
+
+- Fixed the CLI reconnecting to a stale Hub daemon after an upgrade. Hub daemons now carry a runtime build fingerprint, so an upgraded CLI retires and respawns a daemon still running older code instead of attaching to it (from SDK v0.0.73)
+- Fixed compaction being silently skipped on reasoning models. The summarizer no longer hardcodes a 1024-token output cap — it honors your max output tokens setting, defaults to 4096 (lowered when the model reports less), and logs a diagnostic when a summary comes back empty (from SDK v0.0.73)
+- Added Fable 5 (`claude-fable-5`) to the Vertex model catalog. Pricing is intentionally omitted because Vertex bills region-dependently, so cost shows as unknown rather than wrong (from SDK v0.0.73)
+- Custom Vertex model IDs are now passed through unchanged, routing Claude-style IDs to the Anthropic-on-Vertex path (from SDK v0.0.73)
+
+## 3.0.52
+
+- Added `cline mcp uninstall` for removing an installed MCP server
+- Schedules now reuse your saved provider settings instead of needing provider configuration of their own
+- Queued messages are legible on light-theme terminals — they were previously rendered in a color that washed out against a light background
+- MCP tool results render as readable text in the TUI instead of escaped JSON, and binary payloads survive being expanded instead of being mangled
+- Malformed tool input/output payloads no longer break rendering — the formatters degrade gracefully instead of throwing
+- Prompts queued during a turn now survive being interrupted: they are preserved across aborts, drained after a turn aborts itself, and the stop is surfaced instead of leaving the queue silently dropped (from SDK v0.0.72)
+- Session context stays durable across aborts and hub restarts, so an interrupted session resumes with the state it had (from SDK v0.0.72)
+- A hung MCP server no longer takes down session creation, and stdio servers that were never configured get a 30-second initialize budget instead of blocking indefinitely (from SDK v0.0.72)
+- Remote SSE MCP servers surface an OAuth authorization prompt on a 401 instead of failing outright, and pre-registered OAuth clients are supported for setups without dynamic client registration (from SDK v0.0.72)
+- LiteLLM requests route through Chat Completions instead of the Responses API, fixing calls against LiteLLM proxies (from SDK v0.0.72)
+- Network interruptions that happen mid-stream but before any model output are retried instead of failing the turn (from SDK v0.0.72)
+- Vertex ADC token refreshes use the configured fetch, so they work behind proxies and custom transports (from SDK v0.0.72)
+- Checkpoint diffs include files that were untracked when the snapshot was taken, and checkpoints are picked up when git is initialized part-way through a session (from SDK v0.0.72)
+- Scheduled run reports carry execution context — readable headers, schedule metadata, durations, and lifecycle error details (from SDK v0.0.72)
+
+## 3.0.51
+
+- Reasoning effort now applies consistently across providers instead of going through per-provider thinking overrides, including Ollama, and asking for reasoning to be off is respected everywhere (from SDK v0.0.71)
+- `meta/muse-spark-1.2-contributor` is now selectable on the Cline provider, alongside a refreshed model catalog (from SDK v0.0.71)
+- Error telemetry now reports the model that was actually in use for the run (from SDK v0.0.71)
+
+## 3.0.50
+
+- Added user-selectable color themes to the interactive TUI. Pick one with `/theme`, the command palette, or the Theme row in `/settings` — the picker previews each theme live. Built-in themes are Auto (terminal-adaptive, the default), Cline Dark, Cline Light, Tokyo Night, Gruvbox Dark, Nord, Dracula, Catppuccin Mocha, One Dark, Solarized Dark, and Solarized Light. Named themes paint the background, foreground, accents, syntax highlighting, and diff colors, and `CLINE_THEME` overrides the persisted choice at startup
+- The git branch shown below the prompt now updates when you switch branches from another terminal or your editor, instead of showing whatever was checked out when the TUI started
+- Telegram slash commands such as `/clear` now reach the connector command host — the Telegram library was intercepting them and they were silently dropped
+- Racing connector launches no longer collide: an instance is claimed before it opens socket mode, the hub supervises connector processes, and `doctor`/`connect` skip connectors that are already starting. Connector tools are also enabled by default, and the Slack greeting is no longer replayed on reconnect
+- Auto-approval settings are now honored over ACP
+- Plan mode now hard-blocks file-editing shell commands instead of relying on prompting alone — `run_commands` stays available for read-only investigation, but file-manipulation commands, in-place editors (`sed -i`, `perl -i`), redirection to files, mutating git subcommands, package installs, and nested command strings (`sh -c`, `eval`, `sudo`) are rejected, on Windows and PowerShell too (from SDK v0.0.70)
+- A turn that ends with a completed plan is no longer rendered as a failed turn when a plan-blocked command was its only tool call
+- Running out of context is now recovered from instead of failing with a raw provider error: the run force-compacts and retries once, and the cases that genuinely cannot be recovered report why (from SDK v0.0.70)
+- Empty model responses are now retried on every provider, not just Ollama — OpenRouter, Cline, and OpenAI-compatible endpoints previously failed the task outright with "Model returned empty response" (from SDK v0.0.70)
+- Claude 4.6+ and 5.x models are no longer rejected with "thinking.type.enabled is not supported" when they resolve from the offline catalog or from a hand-typed model id (from SDK v0.0.70)
+- Bedrock prompt caching works again — the provider was sending a cache format Bedrock silently discards, so cache reads and writes were always 0 — and Bedrock foundation models are now routed through geo inference profiles (from SDK v0.0.70)
+- Reasoning models on OpenAI-compatible endpoints now receive `max_completion_tokens` instead of the rejected `max_tokens`, and requests to models without image support substitute the image content instead of failing (from SDK v0.0.70)
+- MiniMax now inherits its default model from models.dev, and the model catalog picked up two new providers, Infomaniak and SCX.ai (from SDK v0.0.70)
+- Upgraded the model layer to AI SDK 7 and switched Ollama to the native AI SDK provider (from SDK v0.0.70)
+- Error telemetry no longer reports the same provider failure twice, and repeated failures from unattended retry loops are rate-limited (from SDK v0.0.70)
+
 ## 3.0.49
 
 - `/undo` works again once the agent has used tools — the checkpoint picker counted tool results as user turns, so restore aborted with "Could not find user message for run N"

apps/cli/README.md

@@ -221,13 +221,15 @@ In chat surfaces, connector slash commands include `/help`, `/start`, `/new`, `/
 
 Schedule agents on cron-like intervals or external events.
 
+If `--provider` and `--model` are omitted, schedules use the last configured
+provider and model. If only `--provider` is given, the schedule uses that
+provider's saved model.
+
 ```sh
 cline schedule create "Daily code review" \
   --cron "0 9 * * MON-FRI" \
   --prompt "Review PRs opened yesterday and summarize issues." \
   --workspace /path/to/repo \
-  --provider cline \
-  --model openai/gpt-5.3-codex \
   --timeout 3600 \
   --tags automation,review
 

apps/cli/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@cline/cli",
 	"displayName": "cline",
-	"version": "3.0.49",
+	"version": "3.0.55",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"type": "module",
 	"publishConfig": {

apps/cli/script/postinstall.mjs

@@ -17,6 +17,35 @@ import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
+// CLI versions <= 3.0.54 restart the hub daemon after a background
+// auto-update even while it is serving live sessions, killing those sessions
+// mid-turn — and their build-fingerprint check then rejects every replacement
+// hub, bricking the running TUI. That restart code is the *old* version's, so
+// it cannot be patched here; but it bails out harmlessly when no hub
+// discovery record exists, and it runs only after this install (and this
+// script) completes. Setting the record aside protects any attached clients:
+// a running hub keeps serving its established connections, clients that share
+// its build fingerprint rebuild the record from a port probe, and the next
+// fresh launch retires stale hubs regardless of the record.
+function shieldRunningHubDiscovery() {
+	const explicitPath = process.env.CLINE_HUB_DISCOVERY_PATH?.trim();
+	const dataDir =
+		process.env.CLINE_DATA_DIR?.trim() ||
+		path.join(
+			process.env.CLINE_DIR?.trim() || path.join(os.homedir(), ".cline"),
+			"data",
+		);
+	const recordPath =
+		explicitPath || path.join(dataDir, "locks", "hub", "production.json");
+	if (!fs.existsSync(recordPath)) {
+		return;
+	}
+	const asidePath = `${recordPath}.superseded`;
+	fs.rmSync(asidePath, { force: true });
+	fs.renameSync(recordPath, asidePath);
+	console.log("Set aside hub discovery record for the updated CLI");
+}
+
 function main() {
 	if (os.platform() === "win32") {
 		// On Windows, npm creates .cmd shims from the bin field.
@@ -79,6 +108,14 @@ function main() {
 	console.log(`Cached cline binary at ${target}`);
 }
 
+try {
+	shieldRunningHubDiscovery();
+} catch (error) {
+	// Best-effort: without the shield the worst case is the pre-3.0.55
+	// restart-while-busy behavior, never a broken install.
+	console.error(`postinstall: hub discovery shield skipped: ${error.message}`);
+}
+
 try {
 	main();
 } catch (error) {

apps/cli/src/acp/acpAgent.ts

@@ -30,7 +30,7 @@ import {
 	ProviderSettingsManager,
 	SessionSource,
 } from "@cline/core";
-import { isLikelyAuthError, type Message } from "@cline/shared";
+import { isLikelyAuthError, type MessageWithMetadata } from "@cline/shared";
 import { getPersistedProviderApiKey } from "../commands/auth";
 import { resolveSystemPrompt } from "../runtime/prompt";
 import { subscribeToAgentEvents } from "../runtime/session-events";
@@ -100,7 +100,7 @@ interface SessionState {
 	 */
 	fatalError?: Error;
 	/** Messages to inject into the next session manager for conversation continuity. */
-	pendingInitialMessages?: Message[];
+	pendingInitialMessages?: MessageWithMetadata[];
 }
 
 export class AcpAgent implements Agent {
@@ -240,7 +240,7 @@ export class AcpAgent implements Agent {
 		this.isSessionReady();
 
 		let session = this.sessions.get(params.sessionId);
-		let messages: Message[];
+		let messages: MessageWithMetadata[];
 
 		if (session?.sessionManager && session.activeSessionId) {
 			// The session is still live in this connection — replay its current
@@ -676,7 +676,7 @@ export class AcpAgent implements Agent {
 		session: SessionState,
 		acpSessionId: string,
 		options?: { resume?: boolean },
-	): Promise<Message[] | undefined> {
+	): Promise<MessageWithMetadata[] | undefined> {
 		if (session.sessionManager) {
 			return undefined;
 		}
@@ -695,7 +695,7 @@ export class AcpAgent implements Agent {
 			workspaceRoot: config.workspaceRoot,
 		});
 
-		let initialMessages: Message[] | undefined;
+		let initialMessages: MessageWithMetadata[] | undefined;
 		if (options?.resume) {
 			initialMessages = await sessionManager
 				.readMessages(acpSessionId)

apps/cli/src/acp/session-load.test.ts

@@ -225,6 +225,76 @@ describe("translateHistoricalMessage", () => {
 			},
 		]);
 	});
+
+	it("replays provider model tools with the ordinary ACP tool updates", () => {
+		expect(
+			translateHistoricalMessage({
+				role: "assistant",
+				content: "Found it",
+				metadata: {
+					modelToolActivities: [
+						{
+							toolCallId: "search-1",
+							toolName: "web_search",
+							execution: "provider",
+							input: { query: "latest Bun release" },
+							output: "Bun 1.3.14",
+						},
+					],
+				},
+			} as Parameters<typeof translateHistoricalMessage>[0]),
+		).toEqual([
+			{
+				sessionUpdate: "tool_call",
+				toolCallId: "search-1",
+				title: expect.any(String),
+				kind: "search",
+				status: "pending",
+				rawInput: { query: "latest Bun release" },
+			},
+			{
+				sessionUpdate: "tool_call_update",
+				toolCallId: "search-1",
+				status: "completed",
+				rawOutput: "Bun 1.3.14",
+			},
+			{
+				sessionUpdate: "agent_message_chunk",
+				content: { type: "text", text: "Found it" },
+			},
+		]);
+	});
+
+	it("preserves structured native web-search results", () => {
+		const nativeResult = {
+			type: "web_search_result",
+			url: "https://bun.sh/blog/bun-v1.3.14",
+			title: "Bun v1.3.14",
+			pageAge: "2026-08-12",
+			encryptedContent: "encrypted",
+		};
+		const updates = translateHistoricalMessage({
+			role: "assistant",
+			content: "Found it",
+			metadata: {
+				modelToolActivities: [
+					{
+						toolCallId: "search-native",
+						toolName: "web_search",
+						execution: "provider",
+						input: { query: "latest Bun" },
+						output: [nativeResult],
+					},
+				],
+			},
+		} as Parameters<typeof translateHistoricalMessage>[0]);
+
+		expect(updates[1]).toMatchObject({
+			sessionUpdate: "tool_call_update",
+			toolCallId: "search-native",
+			rawOutput: JSON.stringify(nativeResult),
+		});
+	});
 });
 
 describe("replaySessionHistory", () => {

apps/cli/src/acp/session-load.ts

@@ -2,10 +2,11 @@ import type {
 	AgentSideConnection,
 	SessionUpdate,
 } from "@agentclientprotocol/sdk";
+import { projectSessionMessagesForDisplay } from "@cline/core";
 import {
 	type ContentBlock,
 	formatDisplayUserInput,
-	type Message,
+	type MessageWithMetadata,
 	type ToolResultContent,
 } from "@cline/shared";
 import { ACT_MODE_CONTINUATION_PROMPT } from "../runtime/interactive/mode";
@@ -29,7 +30,7 @@ function isSyntheticUserText(text: string): boolean {
 export async function replaySessionHistory(
 	conn: AgentSideConnection,
 	sessionId: string,
-	messages: Message[],
+	messages: MessageWithMetadata[],
 ): Promise<void> {
 	for (const message of messages) {
 		for (const update of translateHistoricalMessage(message)) {
@@ -38,7 +39,17 @@ export async function replaySessionHistory(
 	}
 }
 
-export function translateHistoricalMessage(message: Message): SessionUpdate[] {
+export function translateHistoricalMessage(
+	message: MessageWithMetadata,
+): SessionUpdate[] {
+	return projectSessionMessagesForDisplay([message]).flatMap(({ message }) =>
+		translateProjectedHistoricalMessage(message),
+	);
+}
+
+function translateProjectedHistoricalMessage(
+	message: MessageWithMetadata,
+): SessionUpdate[] {
 	const blocks: ContentBlock[] =
 		typeof message.content === "string"
 			? [{ type: "text", text: message.content }]
@@ -92,6 +103,31 @@ export function translateHistoricalMessage(message: Message): SessionUpdate[] {
 				);
 				break;
 			}
+			case "media": {
+				const media = block.media;
+				if (media.modality === "image" && media.source.type === "base64") {
+					updates.push({
+						sessionUpdate:
+							message.role === "user"
+								? "user_message_chunk"
+								: "agent_message_chunk",
+						content: {
+							type: "image",
+							data: media.source.data,
+							mimeType: media.mediaType,
+						},
+					});
+				} else {
+					updates.push({
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `[Generated ${media.modality}: ${media.mediaType}]`,
+						},
+					});
+				}
+				break;
+			}
 			case "tool_use": {
 				updates.push({
 					sessionUpdate: "tool_call",
@@ -133,8 +169,14 @@ function flattenToolResultContent(
 					return part.text;
 				case "file":
 					return part.content;
-				default:
+				case "image":
 					return "[image]";
+				default:
+					try {
+						return JSON.stringify(part);
+					} catch {
+						return String(part);
+					}
 			}
 		})
 		.join("\n");

apps/cli/src/acp/session-updates.test.ts

@@ -0,0 +1,34 @@
+import type { AgentSideConnection } from "@agentclientprotocol/sdk";
+import type { AgentEvent } from "@cline/core";
+import { describe, expect, it, vi } from "vitest";
+import { forwardAgentEvent } from "./session-updates";
+
+describe("forwardAgentEvent", () => {
+	it("forwards generated images as ACP agent message chunks", () => {
+		const sessionUpdate = vi.fn().mockResolvedValue(undefined);
+		const connection = { sessionUpdate } as unknown as AgentSideConnection;
+
+		forwardAgentEvent(connection, "session-1", {
+			type: "content_end",
+			contentType: "media",
+			media: {
+				id: "generated-1",
+				modality: "image",
+				mediaType: "image/png",
+				source: { type: "base64", data: "aGVsbG8=" },
+			},
+		} as AgentEvent);
+
+		expect(sessionUpdate).toHaveBeenCalledWith({
+			sessionId: "session-1",
+			update: {
+				sessionUpdate: "agent_message_chunk",
+				content: {
+					type: "image",
+					data: "aGVsbG8=",
+					mimeType: "image/png",
+				},
+			},
+		});
+	});
+});

apps/cli/src/acp/session-updates.ts

@@ -4,6 +4,7 @@ import type {
 	SessionUpdate,
 } from "@agentclientprotocol/sdk";
 import type { AgentEvent } from "@cline/core";
+import type { GeneratedMedia } from "@cline/shared";
 import { getErrorMessage } from "@cline/shared";
 import { buildToolTitle, mapToolKind } from "./tool-utils";
 
@@ -100,6 +101,7 @@ function translateContentEnd(
 		output?: unknown;
 		error?: string;
 		durationMs?: number;
+		media?: GeneratedMedia;
 	};
 
 	switch (e.contentType) {
@@ -109,6 +111,29 @@ function translateContentEnd(
 		case "reasoning":
 			// Reasoning was already streamed via content_start chunks; don't re-send.
 			return [];
+		case "media":
+			if (!e.media) return [];
+			if (e.media.modality !== "image" || e.media.source.type !== "base64") {
+				return [
+					{
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `[Generated ${e.media.modality}: ${e.media.mediaType}]`,
+						},
+					},
+				];
+			}
+			return [
+				{
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "image",
+						data: e.media.source.data,
+						mimeType: e.media.mediaType,
+					},
+				},
+			];
 		case "tool": {
 			const toolCallId = e.toolCallId ?? "unknown";
 			const failed = !!e.error;

apps/cli/src/acp/tool-utils.ts

@@ -17,6 +17,7 @@ const TOOL_KIND_MAP: Record<string, ToolKind> = {
 	WebFetch: "fetch",
 	fetch_web_content: "fetch",
 	WebSearch: "search",
+	web_search: "search",
 	Agent: "think",
 	spawn_agent: "think",
 	NotebookEdit: "edit",

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

@@ -767,6 +767,71 @@ Break work into clear steps.`,
 		);
 	});
 
+	it("routes mcp uninstall and its rm alias", () => {
+		const tempRoot = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-mcp-rm-"));
+		tempDirs.push(tempRoot);
+		const settingsPath = path.join(tempRoot, "cline_mcp_settings.json");
+		const writeSettings = () => {
+			writeFileSync(
+				settingsPath,
+				JSON.stringify(
+					{
+						mcpServers: {
+							docs: { transport: { type: "stdio", command: "node" } },
+							remote: {
+								transport: {
+									type: "streamableHttp",
+									url: "https://mcp.example.com",
+								},
+							},
+						},
+						customTopLevelKey: true,
+					},
+					null,
+					2,
+				),
+				"utf8",
+			);
+		};
+		const readServers = () =>
+			(
+				JSON.parse(readFileSync(settingsPath, "utf8")) as {
+					mcpServers?: Record<string, unknown>;
+				}
+			).mcpServers ?? {};
+
+		writeSettings();
+		const uninstallResult = runCli(["mcp", "uninstall", "docs"], {
+			env: { ...createIsolatedEnv(), CLINE_MCP_SETTINGS_PATH: settingsPath },
+		});
+		expect(uninstallResult.status).toBe(0);
+		expect(asText(uninstallResult.stdout)).toContain(
+			"Uninstalled MCP server docs.",
+		);
+		expect(Object.keys(readServers())).toEqual(["remote"]);
+
+		writeSettings();
+		const aliasResult = runCli(["mcp", "rm", "remote", "--json"], {
+			env: { ...createIsolatedEnv(), CLINE_MCP_SETTINGS_PATH: settingsPath },
+		});
+		expect(aliasResult.status).toBe(0);
+		expect(JSON.parse(asText(aliasResult.stdout).trim())).toEqual({
+			name: "remote",
+			status: "uninstalled",
+		});
+		expect(Object.keys(readServers())).toEqual(["docs"]);
+
+		writeSettings();
+		const missingResult = runCli(["mcp", "remove", "missing"], {
+			env: { ...createIsolatedEnv(), CLINE_MCP_SETTINGS_PATH: settingsPath },
+		});
+		expect(missingResult.status).toBe(1);
+		expect(asText(missingResult.stderr)).toContain(
+			'MCP server "missing" is not installed.',
+		);
+		expect(Object.keys(readServers())).toEqual(["docs", "remote"]);
+	});
+
 	it("lists available tools", () => {
 		const homeDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-home-"));
 		const dataDir = mkdtempSync(path.join(os.tmpdir(), "cli-e2e-data-"));

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

@@ -18,6 +18,7 @@ const {
 	mockResolveProductionHubOwnerContext,
 	mockResolveSharedHubOwnerContext,
 	mockReadHubDiscovery,
+	mockReadSupersededHubDiscovery,
 	mockProbeHubServer,
 	mockClearHubDiscovery,
 	mockStopLocalHubServerGracefully,
@@ -48,6 +49,7 @@ const {
 		),
 	})),
 	mockReadHubDiscovery: vi.fn(),
+	mockReadSupersededHubDiscovery: vi.fn(() => undefined as unknown),
 	mockProbeHubServer: vi.fn(),
 	mockClearHubDiscovery: vi.fn(),
 	mockStopLocalHubServerGracefully: vi.fn(async () => false),
@@ -73,6 +75,7 @@ vi.mock("@cline/core", () => ({
 	clearHubDiscovery: mockClearHubDiscovery,
 	probeHubServer: mockProbeHubServer,
 	readHubDiscovery: mockReadHubDiscovery,
+	readSupersededHubDiscovery: mockReadSupersededHubDiscovery,
 	stopLocalHubServerGracefully: mockStopLocalHubServerGracefully,
 	ensureFileExists: mockEnsureFileExists,
 	listActiveConnectors: mockListActiveConnectors,
@@ -186,6 +189,65 @@ describe("runDoctorCommand", () => {
 		);
 	});
 
+	it("sees the hub through the set-aside record during the shielded update window", async () => {
+		const cwd = "/workspace";
+		// The npm postinstall shield renamed the discovery record aside; the
+		// hub is alive and serving an old client's sessions.
+		mockReadHubDiscovery.mockResolvedValue(undefined);
+		mockReadSupersededHubDiscovery.mockReturnValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "shielded-token",
+			pid: 50174,
+		});
+		mockProbeHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			port: 25463,
+			pid: 50174,
+		});
+		mockSpawnSync.mockImplementation((command: string, args?: string[]) => {
+			if (command === "lsof") {
+				return { status: 0, stdout: "50174\n" };
+			}
+			if (
+				command === "pgrep" &&
+				Array.isArray(args) &&
+				args[2] === "--cline-hub-daemon"
+			) {
+				return {
+					status: 0,
+					stdout: "50174 /usr/local/bin/cline --cline-hub-daemon\n",
+				};
+			}
+			return { status: 1, stdout: "" };
+		});
+
+		const output: string[] = [];
+		const code = await runDoctorCommand(
+			{ cwd, json: true },
+			{
+				writeln: (text) => {
+					output.push(text ?? "");
+				},
+				writeErr: () => {},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(mockProbeHubServer).toHaveBeenCalledWith(
+			"ws://127.0.0.1:25463/hub",
+			{
+				authToken: "shielded-token",
+			},
+		);
+		// Without the fallback the live daemon reads as stale and doctor's
+		// advice (\"run doctor fix\") would kill the sessions the shield exists
+		// to protect.
+		expect(JSON.parse(output[0] || "")).toMatchObject({
+			hubHealthy: true,
+			staleHubPids: [],
+		});
+	});
+
 	it("reports CLI and running hub Core versions", async () => {
 		const cwd = "/workspace";
 		mockReadHubDiscovery.mockResolvedValue({
@@ -624,3 +686,42 @@ describe("doctor supervision reporting", () => {
 		);
 	});
 });
+
+describe("describeProcessesStartedDuringFix", () => {
+	const { describeProcessesStartedDuringFix } = __test__;
+	const liveParents = new Map([
+		[100, 10],
+		[200, 20],
+	]);
+	const resolveLiveParent = (pid: number) => liveParents.get(pid);
+
+	it("says nothing when no process started during the fix", () => {
+		expect(
+			describeProcessesStartedDuringFix([], resolveLiveParent),
+		).toBeUndefined();
+	});
+
+	it("blames the parent only when every process has a live one", () => {
+		expect(
+			describeProcessesStartedDuringFix([100, 200], resolveLiveParent),
+		).toBe(
+			"\nThese processes were respawned by a live parent. Stop the parent process listed above, then re-run.",
+		);
+	});
+
+	// A process can start on its own mid-repair - a user opening a new session,
+	// say - and telling them to go kill an unrelated parent would be wrong.
+	it("states the facts when no process has a live parent", () => {
+		expect(describeProcessesStartedDuringFix([777], resolveLiveParent)).toBe(
+			"\nThese processes started after the fix began, so they were not targeted. Re-run to see whether they persist.",
+		);
+	});
+
+	it("separates respawns from independent starts in a mixed batch", () => {
+		expect(
+			describeProcessesStartedDuringFix([100, 777], resolveLiveParent),
+		).toBe(
+			"\nSome of these were respawned by a live parent (100); stop the parent process listed above, then re-run. The rest started after the fix began and were not targeted.",
+		);
+	});
+});

apps/cli/src/commands/doctor.ts

@@ -7,6 +7,7 @@ import {
 	listActiveConnectors,
 	probeHubServer,
 	readHubDiscovery,
+	readSupersededHubDiscovery,
 	resolveClineDataDir,
 	resolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext,
@@ -384,6 +385,12 @@ async function clearHubStartupArtifacts(
 		await clearHubDiscovery(owner.discoveryPath);
 		clearedDiscovery = 1;
 	}
+	if (options?.clearDiscovery) {
+		// The set-aside copy the npm postinstall shield leaves behind. Once
+		// doctor has deliberately stopped everything, keeping it risks a much
+		// later launch SIGTERMing whatever process has recycled its pid.
+		clearPathIfExists(`${owner.discoveryPath}.superseded`);
+	}
 	return {
 		startupLocks: clearedStartupLocks,
 		discovery: clearedDiscovery,
@@ -411,7 +418,25 @@ function resolveCliHubOwnerContext() {
 
 async function collectDoctorStatus(cwd: string): Promise<DoctorStatus> {
 	const owner = resolveCliHubOwnerContext();
-	const discovery = await readHubDiscovery(owner.discoveryPath);
+	// The npm postinstall shield sets the discovery record aside (see
+	// readSupersededHubDiscovery) while an older hub finishes serving its
+	// sessions. Without the fallback, doctor cannot see that hub, classifies
+	// the live daemon as stale, and its "run doctor fix" advice kills the
+	// sessions the shield exists to protect.
+	const recorded = await readHubDiscovery(owner.discoveryPath);
+	// The set-aside record carries only url/token/pid; widen so the two
+	// sources read uniformly below.
+	const discovery:
+		| {
+				url?: string;
+				authToken?: string;
+				pid?: number;
+				port?: number;
+				coreVersion?: string;
+		  }
+		| undefined = recorded?.url
+		? recorded
+		: readSupersededHubDiscovery(owner.discoveryPath);
 	const health = discovery?.url
 		? await probeHubServer(discovery.url, { authToken: discovery.authToken })
 		: undefined;
@@ -449,6 +474,80 @@ function formatPidList(label: string, pids: number[]): string {
 	return `${label} ${c.dim}${pids.join(", ")}${c.reset}`;
 }
 
+function readParentPid(pid: number): number | undefined {
+	try {
+		const output = spawnSync("ps", ["-o", "ppid=", "-p", String(pid)], {
+			encoding: "utf8",
+		});
+		const parsed = Number(output.stdout?.trim());
+		return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function liveParentPid(pid: number): number | undefined {
+	const parent = readParentPid(pid);
+	return parent && isProcessRunning(parent) ? parent : undefined;
+}
+
+/**
+ * A daemon whose parent is still running was almost certainly just spawned by
+ * that parent, and killing it only invites the parent to spawn another. Naming
+ * the parent points at the process the user actually has to stop.
+ */
+function formatDaemonPidList(label: string, pids: number[]): string {
+	if (pids.length === 0) {
+		return `${label} ${c.dim}0${c.reset}`;
+	}
+	const described = pids.map((pid) => {
+		const parent = liveParentPid(pid);
+		return parent ? `${pid} (spawned by ${parent})` : String(pid);
+	});
+	return `${label} ${c.dim}${described.join(", ")}${c.reset}`;
+}
+
+/**
+ * Advice for processes first seen during the fix. Only a process with a live
+ * parent is known to have been respawned by it; anything else may have been
+ * started independently (a user opening a new session mid-repair), so it gets
+ * a statement of fact rather than an instruction to go kill something.
+ */
+export function describeProcessesStartedDuringFix(
+	pids: number[],
+	resolveLiveParent: (pid: number) => number | undefined,
+): string | undefined {
+	if (pids.length === 0) {
+		return undefined;
+	}
+	const respawned = pids.filter((pid) => resolveLiveParent(pid) !== undefined);
+	if (respawned.length === 0) {
+		return "\nThese processes started after the fix began, so they were not targeted. Re-run to see whether they persist.";
+	}
+	if (respawned.length === pids.length) {
+		return "\nThese processes were respawned by a live parent. Stop the parent process listed above, then re-run.";
+	}
+	return `\nSome of these were respawned by a live parent (${respawned.join(", ")}); stop the parent process listed above, then re-run. The rest started after the fix began and were not targeted.`;
+}
+
+function formatStartupLockList(
+	label: string,
+	locks: StartupArtifact[],
+): string {
+	const described = locks
+		.map((lock) => {
+			if (lock.pid === undefined) {
+				return "unreadable";
+			}
+			return lock.stale ? `${lock.pid} (stale)` : `${lock.pid} (held, live)`;
+		})
+		.filter((entry) => entry.length > 0);
+	if (described.length === 0) {
+		return `${label} ${c.dim}0${c.reset}`;
+	}
+	return `${label} ${c.dim}${described.join(", ")}${c.reset}`;
+}
+
 function formatRecentSpawnedProcess(record: SpawnedProcessRecord): string {
 	const pieces = [
 		record.timestamp ?? "unknown-time",
@@ -531,6 +630,7 @@ function killPids(pids: number[]): number {
 export const __test__ = {
 	decideForeignContainer,
 	CONTAINER_CGROUP_PATTERN,
+	describeProcessesStartedDuringFix,
 	formatSupervisedConnector,
 };
 
@@ -556,13 +656,8 @@ export async function runDoctorCommand(
 		);
 		writeln(`hub uptime ${c.dim}${before.hubUptime ?? "n/a"}${c.reset}`);
 		writeln(formatPidList("hub listeners", before.listeningPids));
-		writeln(formatPidList("stale hub daemons", before.staleHubPids));
-		writeln(
-			formatPidList(
-				"hub startup locks",
-				before.hubStartupLocks.map((a) => a.pid ?? -1).filter((pid) => pid > 0),
-			),
-		);
+		writeln(formatDaemonPidList("stale hub daemons", before.staleHubPids));
+		writeln(formatStartupLockList("hub startup locks", before.hubStartupLocks));
 		writeln(formatPidList("cli processes", before.staleCliPids));
 		writeln(formatPidList("sidecar processes", before.staleSidecarPids));
 		if (before.activeConnectors.length === 0) {
@@ -673,16 +768,56 @@ export async function runDoctorCommand(
 		`cleared hub discovery records ${c.dim}${clearedArtifacts.discovery}${c.reset}`,
 	);
 	writeln(`hub healthy after fix: ${after.hubHealthy ? "yes" : "no"}`);
-	writeln(formatPidList("remaining hub listeners", after.listeningPids));
-	writeln(formatPidList("remaining stale hub daemons", after.staleHubPids));
+	// "Remaining" means a process this run tried to kill and failed to. A
+	// re-scan alone cannot tell that apart from a process that appeared while
+	// the fix was running, and reporting the two together reads as a failure
+	// to kill something that was never targeted.
+	const survived = (targets: number[], remaining: number[]) =>
+		remaining.filter((pid) => targets.includes(pid));
+	const appeared = (targets: number[], remaining: number[]) =>
+		remaining.filter((pid) => !targets.includes(pid));
 	writeln(
 		formatPidList(
-			"remaining hub startup locks",
-			after.hubStartupLocks.map((a) => a.pid ?? -1).filter((pid) => pid > 0),
+			"remaining hub listeners",
+			survived(refreshedAfterGracefulStop.listeningPids, after.listeningPids),
 		),
 	);
-	writeln(formatPidList("remaining cli processes", after.staleCliPids));
-	writeln(formatPidList("remaining sidecar processes", after.staleSidecarPids));
+	writeln(
+		formatDaemonPidList(
+			"remaining stale hub daemons",
+			survived(staleHubTargets, after.staleHubPids),
+		),
+	);
+	writeln(
+		formatStartupLockList("remaining hub startup locks", after.hubStartupLocks),
+	);
+	writeln(
+		formatPidList(
+			"remaining cli processes",
+			survived(staleCliTargets, after.staleCliPids),
+		),
+	);
+	writeln(
+		formatPidList(
+			"remaining sidecar processes",
+			survived(staleSidecarTargets, after.staleSidecarPids),
+		),
+	);
+	const spawnedDuringFix = [
+		...appeared(staleHubTargets, after.staleHubPids),
+		...appeared(staleCliTargets, after.staleCliPids),
+		...appeared(staleSidecarTargets, after.staleSidecarPids),
+	];
+	if (spawnedDuringFix.length > 0) {
+		writeln(formatDaemonPidList("started during fix", spawnedDuringFix));
+		const advice = describeProcessesStartedDuringFix(
+			spawnedDuringFix,
+			liveParentPid,
+		);
+		if (advice) {
+			io.writeln(advice);
+		}
+	}
 	return 0;
 }
 

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

@@ -1,9 +1,13 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { installMcpServer } from "@cline/core";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
 	buildMcpInstallDefaults,
 	buildMcpInstallTransport,
 	runMcpInstallCommand,
+	runMcpUninstallCommand,
 } from "./mcp";
 
 vi.mock("@cline/core", async (importOriginal) => {
@@ -56,6 +60,19 @@ describe("mcp install command", () => {
 		});
 	});
 
+	it("shows mcp-remote marketplace entries as native remote servers", () => {
+		expect(
+			buildMcpInstallDefaults({
+				name: "linear",
+				targetArgs: ["npx", "-y", "mcp-remote", "https://mcp.linear.app/mcp"],
+			}),
+		).toEqual({
+			name: "linear",
+			type: "streamableHttp",
+			url: "https://mcp.linear.app/mcp",
+		});
+	});
+
 	it("normalizes streamable-http transport", () => {
 		expect(
 			buildMcpInstallDefaults({
@@ -269,3 +286,131 @@ describe("mcp install command", () => {
 		});
 	});
 });
+
+describe("mcp uninstall command", () => {
+	let root = "";
+
+	beforeEach(() => {
+		root = mkdtempSync(join(tmpdir(), "cli-mcp-uninstall-"));
+	});
+
+	afterEach(() => {
+		rmSync(root, { recursive: true, force: true });
+	});
+
+	function writeSettings(): string {
+		const settingsPath = join(root, "cline_mcp_settings.json");
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						docs: {
+							transport: {
+								type: "streamableHttp",
+								url: "https://example.com/mcp",
+							},
+						},
+						keep: {
+							transport: { type: "stdio", command: "node" },
+							disabled: true,
+						},
+					},
+					customTopLevelKey: true,
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+		return settingsPath;
+	}
+
+	function readSettings(settingsPath: string): Record<string, unknown> & {
+		mcpServers?: Record<string, unknown>;
+	} {
+		return JSON.parse(readFileSync(settingsPath, "utf8")) as Record<
+			string,
+			unknown
+		> & { mcpServers?: Record<string, unknown> };
+	}
+
+	it("uninstalls the requested server and reports success", async () => {
+		const settingsPath = writeSettings();
+		const writeln = vi.fn();
+		const writeErr = vi.fn();
+
+		const code = await runMcpUninstallCommand({
+			name: "docs",
+			settingsPath,
+			io: { writeln, writeErr },
+		});
+
+		expect(code).toBe(0);
+		expect(writeln).toHaveBeenCalledWith("Uninstalled MCP server docs.");
+		expect(writeErr).not.toHaveBeenCalled();
+
+		const written = readSettings(settingsPath);
+		expect(Object.keys(written.mcpServers ?? {})).toEqual(["keep"]);
+		expect(written.mcpServers?.keep).toEqual({
+			transport: { type: "stdio", command: "node" },
+			disabled: true,
+		});
+		expect(written.customTopLevelKey).toBe(true);
+	});
+
+	it("prints uninstall JSON with --json", async () => {
+		const settingsPath = writeSettings();
+		const writeln = vi.fn();
+
+		const code = await runMcpUninstallCommand({
+			name: "docs",
+			settingsPath,
+			json: true,
+			io: { writeln, writeErr: vi.fn() },
+		});
+
+		expect(code).toBe(0);
+		expect(JSON.parse(writeln.mock.calls[0]?.[0])).toEqual({
+			name: "docs",
+			status: "uninstalled",
+		});
+		expect(writeln).toHaveBeenCalledTimes(1);
+	});
+
+	it("reports an error and leaves settings intact for an unknown server", async () => {
+		const settingsPath = writeSettings();
+		const before = readFileSync(settingsPath, "utf8");
+		const writeln = vi.fn();
+		const writeErr = vi.fn();
+
+		const code = await runMcpUninstallCommand({
+			name: "missing",
+			settingsPath,
+			io: { writeln, writeErr },
+		});
+
+		expect(code).toBe(1);
+		expect(writeErr).toHaveBeenCalledWith(
+			'MCP server "missing" is not installed.',
+		);
+		expect(writeln).not.toHaveBeenCalled();
+		expect(readFileSync(settingsPath, "utf8")).toBe(before);
+	});
+
+	it("rejects a blank name without rewriting settings", async () => {
+		const settingsPath = writeSettings();
+		const before = readFileSync(settingsPath, "utf8");
+		const writeErr = vi.fn();
+
+		const code = await runMcpUninstallCommand({
+			name: "   ",
+			settingsPath,
+			io: { writeErr },
+		});
+
+		expect(code).toBe(1);
+		expect(writeErr).toHaveBeenCalledWith("MCP server name is required");
+		expect(readFileSync(settingsPath, "utf8")).toBe(before);
+	});
+});

apps/cli/src/commands/mcp.ts

@@ -1,12 +1,16 @@
 import {
+	buildMcpInstallTransport as buildCoreMcpInstallTransport,
 	type McpInstallOptions as CoreMcpInstallOptions,
 	installMcpServer,
 	type McpInstallResult,
 	type McpServerTransportConfig,
+	type McpUninstallOptions as CoreMcpUninstallOptions,
+	type McpUninstallResult as CoreMcpUninstallResult,
+	uninstallMcpServer,
 } from "@cline/core";
 import type { McpAddDefaults } from "../wizards/mcp";
 
-export { buildMcpInstallTransport } from "@cline/core";
+export { buildMcpInstallTransport, uninstallMcpServer } from "@cline/core";
 
 export interface McpCommandIo {
 	writeln?: (text: string) => void;
@@ -28,39 +32,6 @@ export interface McpInstallDirectResult {
 	warnings: string[];
 }
 
-function normalizeTransportType(
-	value: string | undefined,
-): McpServerTransportConfig["type"] {
-	const normalized = (value ?? "stdio").trim();
-	if (normalized === "http" || normalized === "streamable-http") {
-		return "streamableHttp";
-	}
-	if (
-		normalized === "stdio" ||
-		normalized === "sse" ||
-		normalized === "streamableHttp"
-	) {
-		return normalized;
-	}
-	throw new Error(
-		`Unsupported MCP transport "${normalized}". Expected stdio, sse, http, streamable-http, or streamableHttp.`,
-	);
-}
-
-function assertValidUrl(url: string): void {
-	let parsed: URL;
-	try {
-		parsed = new URL(url);
-	} catch {
-		throw new Error(`Invalid MCP server URL: ${url}`);
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error(
-			`Invalid MCP server URL: ${url} (only http and https are supported)`,
-		);
-	}
-}
-
 function quoteCommandArg(arg: string): string {
 	if (/^[^\s"'\\]+$/.test(arg)) {
 		return arg;
@@ -73,36 +44,20 @@ export function buildMcpInstallDefaults(options: {
 	targetArgs?: string[];
 	transport?: string;
 }): McpAddDefaults {
-	const name = options.name.trim();
-	if (!name) {
-		throw new Error("MCP server name is required");
-	}
-	const type = normalizeTransportType(options.transport);
-	const targetArgs = options.targetArgs ?? [];
-	if (type === "stdio") {
-		if (targetArgs.length === 0) {
-			throw new Error(
-				"Stdio MCP install requires a command after the server name, for example: cline mcp install fs -- npx -y @modelcontextprotocol/server-filesystem /tmp",
-			);
-		}
+	const { name, transport } = buildCoreMcpInstallTransport(options);
+	if (transport.type === "stdio") {
 		return {
 			name,
-			type,
-			command: targetArgs.map(quoteCommandArg).join(" "),
+			type: transport.type,
+			command: [transport.command, ...(transport.args ?? [])]
+				.map(quoteCommandArg)
+				.join(" "),
 		};
 	}
-
-	if (targetArgs.length !== 1) {
-		throw new Error(
-			"Remote MCP install requires exactly one URL argument after the server name.",
-		);
-	}
-	const url = targetArgs[0]?.trim() ?? "";
-	assertValidUrl(url);
 	return {
 		name,
-		type,
-		url,
+		type: transport.type,
+		url: transport.url,
 	};
 }
 
@@ -158,3 +113,42 @@ export async function runMcpInstallCommand(
 		return 1;
 	}
 }
+
+export interface McpUninstallOptions extends CoreMcpUninstallOptions {
+	io?: McpCommandIo;
+	json?: boolean;
+}
+
+export interface McpUninstallDirectResult extends CoreMcpUninstallResult {}
+
+export function uninstallMcpServerDirect(
+	options: McpUninstallOptions,
+): McpUninstallDirectResult {
+	const result: CoreMcpUninstallResult = uninstallMcpServer(options);
+	return {
+		name: result.name,
+		status: result.status,
+	};
+}
+
+export async function runMcpUninstallCommand(
+	options: McpUninstallOptions,
+): Promise<number> {
+	try {
+		const name = options.name?.trim() ?? "";
+		if (!name) {
+			throw new Error("MCP server name is required");
+		}
+		const result = uninstallMcpServerDirect({ ...options, name });
+		if (options.json) {
+			options.io?.writeln?.(JSON.stringify(result));
+		} else {
+			options.io?.writeln?.(`Uninstalled MCP server ${result.name}.`);
+		}
+		return 0;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		options.io?.writeErr(message);
+		return 1;
+	}
+}

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

@@ -6,11 +6,29 @@ import { createScheduleCommand } from "./schedule";
 
 const mockSendHubCommand = vi.hoisted(() => vi.fn());
 const mockEnsureCliHubServer = vi.hoisted(() => vi.fn());
-
-vi.mock("@cline/core", () => ({
-	sendHubCommand: mockSendHubCommand,
+const mockProviderSettings = vi.hoisted(() => ({
+	lastUsed: undefined as { provider?: string; model?: string } | undefined,
+	providers: {} as Record<string, { provider?: string; model?: string }>,
 }));
 
+vi.mock("@cline/core", async () => {
+	const actual =
+		await vi.importActual<typeof import("@cline/core")>("@cline/core");
+	return {
+		...actual,
+		sendHubCommand: mockSendHubCommand,
+		ProviderSettingsManager: class {
+			getLastUsedProviderSettings() {
+				return mockProviderSettings.lastUsed;
+			}
+
+			getProviderSettings(providerId: string) {
+				return mockProviderSettings.providers[providerId];
+			}
+		},
+	};
+});
+
 vi.mock("../utils/hub-runtime", () => ({
 	ensureCliHubServer: mockEnsureCliHubServer,
 	parseHubEndpointOverride: (rawAddress: string | undefined) => {
@@ -47,6 +65,8 @@ async function runScheduleCommand(
 describe("runScheduleCommand list output", () => {
 	afterEach(() => {
 		vi.clearAllMocks();
+		mockProviderSettings.lastUsed = undefined;
+		mockProviderSettings.providers = {};
 	});
 
 	it('prints "No schedules found." for empty non-json list output', async () => {
@@ -121,9 +141,158 @@ describe("runScheduleCommand list output", () => {
 	});
 });
 
-describe("runScheduleCommand create delivery metadata", () => {
+describe("runScheduleCommand create", () => {
 	afterEach(() => {
 		vi.clearAllMocks();
+		mockProviderSettings.lastUsed = undefined;
+		mockProviderSettings.providers = {};
+	});
+
+	it("uses the last used provider and model when both flags are omitted", async () => {
+		mockProviderSettings.lastUsed = {
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+		};
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: { scheduleId: "sched_123" } },
+		});
+
+		const output: string[] = [];
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			[
+				"create",
+				"Health check",
+				"--cron",
+				"0 */6 * * *",
+				"--prompt",
+				"Run tests",
+				"--workspace",
+				"/tmp/workspace",
+				"--address",
+				"127.0.0.1:25463",
+			],
+			{
+				writeln: (text?: string) => {
+					output.push(text ?? "");
+				},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(mockSendHubCommand).toHaveBeenCalledWith(
+			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+			expect.objectContaining({
+				clientId: "cline-schedule",
+				command: "schedule.create",
+				payload: expect.objectContaining({
+					provider: "anthropic",
+					model: "claude-sonnet-4-6",
+				}),
+			}),
+		);
+	});
+
+	it("uses an explicit provider with that provider's configured model", async () => {
+		mockProviderSettings.lastUsed = {
+			provider: "cline",
+			model: "openai/gpt-5.3-codex",
+		};
+		mockProviderSettings.providers.anthropic = {
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+		};
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+		mockSendHubCommand.mockResolvedValue({
+			ok: true,
+			payload: { schedule: { scheduleId: "sched_123" } },
+		});
+
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			[
+				"create",
+				"Health check",
+				"--cron",
+				"0 */6 * * *",
+				"--prompt",
+				"Run tests",
+				"--workspace",
+				"/tmp/workspace",
+				"--provider",
+				"anthropic",
+				"--address",
+				"127.0.0.1:25463",
+			],
+			{
+				writeln: () => {},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(0);
+		expect(errors).toEqual([]);
+		expect(mockSendHubCommand).toHaveBeenCalledWith(
+			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+			expect.objectContaining({
+				command: "schedule.create",
+				payload: expect.objectContaining({
+					provider: "anthropic",
+					model: "claude-sonnet-4-6",
+				}),
+			}),
+		);
+	});
+
+	it("fails when an explicit provider has no configured model and no model flag", async () => {
+		mockEnsureCliHubServer.mockResolvedValue({
+			url: "ws://127.0.0.1:25463/hub",
+			authToken: "test-token",
+		});
+
+		const errors: string[] = [];
+		const code = await runScheduleCommand(
+			[
+				"create",
+				"Health check",
+				"--cron",
+				"0 */6 * * *",
+				"--prompt",
+				"Run tests",
+				"--workspace",
+				"/tmp/workspace",
+				"--provider",
+				"anthropic",
+				"--address",
+				"127.0.0.1:25463",
+			],
+			{
+				writeln: () => {},
+				writeErr: (text: string) => {
+					errors.push(text);
+				},
+			},
+		);
+
+		expect(code).toBe(1);
+		expect(errors).toEqual([
+			'No model is configured for provider "anthropic". Pass --model or save a model for that provider before creating the schedule.',
+		]);
+		expect(mockSendHubCommand).not.toHaveBeenCalled();
 	});
 
 	it("maps --delivery-bot to delivery.userName", async () => {
@@ -192,6 +361,8 @@ describe("runScheduleCommand create delivery metadata", () => {
 describe("runScheduleCommand import", () => {
 	afterEach(() => {
 		vi.clearAllMocks();
+		mockProviderSettings.lastUsed = undefined;
+		mockProviderSettings.providers = {};
 	});
 
 	it("preserves exported modelSelection providerId/modelId values", async () => {
@@ -257,6 +428,8 @@ describe("runScheduleCommand import", () => {
 describe("runScheduleCommand export", () => {
 	afterEach(() => {
 		vi.clearAllMocks();
+		mockProviderSettings.lastUsed = undefined;
+		mockProviderSettings.providers = {};
 	});
 
 	it("writes JSON content to the --to file path", async () => {

apps/cli/src/commands/schedule/handlers.ts

@@ -1,4 +1,3 @@
-import { CLINE_DEFAULT_MODEL_ID } from "@cline/shared";
 import type { Command } from "commander";
 import { ensureSchedulerHub } from "./client";
 import {
@@ -19,6 +18,7 @@ import {
 	registerScheduleImportCommand,
 	registerScheduleUpdateCommand,
 } from "./import-export";
+import { resolveScheduleModelSelection } from "./model-selection";
 import type { CommandIo, ScheduleActionWrapper } from "./types";
 
 export function registerScheduleCommands(
@@ -66,8 +66,8 @@ export function registerScheduleCommands(
 		.option("--max-parallel <n>", "Max parallel executions", "1")
 		.option("--metadata-json <json>", "Metadata as JSON object")
 		.option("--mode <act|plan|yolo>", "Execution mode", "yolo")
-		.option("--model <model>", "Model to use", CLINE_DEFAULT_MODEL_ID)
-		.option("--provider <id>", "Provider ID", "cline")
+		.option("--model <model>", "Model to use")
+		.option("--provider <id>", "Provider ID")
 		.option("--system-prompt <text>", "System prompt override")
 		.option("--tags <list>", "Comma-separated tags")
 		.option("--timeout <seconds>", "Timeout in seconds");
@@ -92,12 +92,16 @@ export function registerScheduleCommands(
 					parseJsonObjectFlag(opts.metadataJson),
 					opts,
 				);
+				const modelSelection = resolveScheduleModelSelection({
+					provider: opts.provider,
+					model: opts.model,
+				});
 				const created = await client.createSchedule({
 					name,
 					cronPattern: opts.cron,
 					prompt: opts.prompt,
-					provider: opts.provider,
-					model: opts.model,
+					provider: modelSelection.provider,
+					model: modelSelection.model,
 					mode: parseMode(opts.mode) ?? "yolo",
 					workspaceRoot: opts.workspace,
 					cwd: opts.cwd,

apps/cli/src/commands/schedule/import-export.ts

@@ -1,6 +1,5 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
-import { CLINE_DEFAULT_MODEL_ID } from "@cline/shared";
 import type { Command } from "commander";
 import { ensureSchedulerHub } from "./client";
 import {
@@ -18,8 +17,13 @@ import {
 	resolveAddress,
 	toPositiveInt,
 } from "./common";
+import { resolveScheduleModelSelection } from "./model-selection";
 import type { CommandIo, ScheduleActionWrapper } from "./types";
 
+function stringValue(value: unknown): string | undefined {
+	return typeof value === "string" ? value : undefined;
+}
+
 function resolveImportedModelSelection(parsed: Record<string, unknown>): {
 	provider: string;
 	model: string;
@@ -30,19 +34,16 @@ function resolveImportedModelSelection(parsed: Record<string, unknown>): {
 		!Array.isArray(parsed.modelSelection)
 			? (parsed.modelSelection as Record<string, unknown>)
 			: undefined;
-	const provider = String(
-		modelSelection?.providerId ??
-			parsed.providerId ??
-			parsed.provider ??
-			"cline",
-	).trim();
-	const model = String(
-		modelSelection?.modelId ??
-			parsed.modelId ??
-			parsed.model ??
-			CLINE_DEFAULT_MODEL_ID,
-	).trim();
-	return { provider, model };
+	return resolveScheduleModelSelection({
+		provider:
+			stringValue(modelSelection?.providerId) ??
+			stringValue(parsed.providerId) ??
+			stringValue(parsed.provider),
+		model:
+			stringValue(modelSelection?.modelId) ??
+			stringValue(parsed.modelId) ??
+			stringValue(parsed.model),
+	});
 }
 
 export function registerScheduleExportCommand(

apps/cli/src/commands/schedule/model-selection.ts

@@ -0,0 +1,52 @@
+import { type ProviderSettings, ProviderSettingsManager } from "@cline/core";
+import { CLINE_DEFAULT_MODEL_ID } from "@cline/shared";
+
+export const DEFAULT_SCHEDULE_PROVIDER = "cline";
+
+interface ProviderSettingsReader {
+	getLastUsedProviderSettings(): ProviderSettings | undefined;
+	getProviderSettings(providerId: string): ProviderSettings | undefined;
+}
+
+function trimToUndefined(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : undefined;
+}
+
+export function resolveScheduleModelSelection(
+	options: {
+		provider?: string;
+		model?: string;
+	},
+	providerSettingsManager?: ProviderSettingsReader,
+): { provider: string; model: string } {
+	const explicitProvider = trimToUndefined(options.provider);
+	const explicitModel = trimToUndefined(options.model);
+	if (explicitProvider && explicitModel) {
+		return { provider: explicitProvider, model: explicitModel };
+	}
+
+	const manager = providerSettingsManager ?? new ProviderSettingsManager();
+	const lastUsedSettings = manager.getLastUsedProviderSettings();
+	const provider =
+		explicitProvider ??
+		trimToUndefined(lastUsedSettings?.provider) ??
+		DEFAULT_SCHEDULE_PROVIDER;
+	const selectedProviderSettings = explicitProvider
+		? manager.getProviderSettings(provider)
+		: lastUsedSettings;
+	const model =
+		explicitModel ??
+		trimToUndefined(selectedProviderSettings?.model) ??
+		(provider === DEFAULT_SCHEDULE_PROVIDER
+			? CLINE_DEFAULT_MODEL_ID
+			: undefined);
+
+	if (!model) {
+		throw new Error(
+			`No model is configured for provider "${provider}". Pass --model or save a model for that provider before creating the schedule.`,
+		);
+	}
+
+	return { provider, model };
+}

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

@@ -1,12 +1,10 @@
 import type { ChildProcess } from "node:child_process";
-import { EventEmitter } from "node:events";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
-const { mockEnsureCliHubServer, mockSpawn } = vi.hoisted(() => ({
-	mockEnsureCliHubServer: vi.fn(),
+const { mockSpawn } = vi.hoisted(() => ({
 	mockSpawn: vi.fn(),
 }));
 
@@ -18,14 +16,10 @@ vi.mock("node:child_process", async (importOriginal) => {
 	};
 });
 
-vi.mock("../utils/hub-runtime", () => ({
-	ensureCliHubServer: mockEnsureCliHubServer,
-}));
-
 import {
+	applyDeferredUpdate,
 	autoUpdateOnStartup,
 	checkForUpdates,
-	ensureCliHubServerAfterUpdate,
 	getInstallationInfo,
 	PackageManager,
 	resolveCliHubOwnerContext,
@@ -42,14 +36,6 @@ const originalIsDev = process.env.IS_DEV;
 const originalNoAutoUpdate = process.env.CLINE_NO_AUTO_UPDATE;
 const tempDirs: string[] = [];
 
-function createChildProcessThatCloses(exitCode: number): ChildProcess {
-	const child = new EventEmitter();
-	queueMicrotask(() => {
-		child.emit("close", exitCode);
-	});
-	return child as ChildProcess;
-}
-
 function createFile(path: string): string {
 	mkdirSync(dirname(path), { recursive: true });
 	writeFileSync(path, "");
@@ -265,68 +251,100 @@ describe("hub restart owner selection", () => {
 	});
 });
 
-describe("post-update hub launch", () => {
+describe("deferred auto update", () => {
 	afterEach(() => {
-		mockEnsureCliHubServer.mockReset();
 		mockSpawn.mockReset();
+		if (originalBuildEnv === undefined) {
+			delete process.env.CLINE_BUILD_ENV;
+		} else {
+			process.env.CLINE_BUILD_ENV = originalBuildEnv;
+		}
+		if (originalHubDiscoveryPath === undefined) {
+			delete process.env.CLINE_HUB_DISCOVERY_PATH;
+		} else {
+			process.env.CLINE_HUB_DISCOVERY_PATH = originalHubDiscoveryPath;
+		}
+		for (const dir of tempDirs.splice(0)) {
+			rmSync(dir, { recursive: true, force: true });
+		}
 	});
 
-	it("uses the freshly installed wrapper instead of the current executable", async () => {
-		mockSpawn.mockReturnValue(createChildProcessThatCloses(0));
-		const env = {
-			CLINE_WRAPPER_PATH: "/opt/cline/lib/node_modules/cline/bin/cline",
-			CLINE_NO_AUTO_UPDATE: "0",
-		};
-
-		await ensureCliHubServerAfterUpdate("/workspace/project", env, "linux");
-
-		expect(mockSpawn).toHaveBeenCalledWith(
-			"/opt/cline/lib/node_modules/cline/bin/cline",
-			["hub", "ensure"],
-			{
-				cwd: "/workspace/project",
-				env: {
-					...env,
-					CLINE_NO_AUTO_UPDATE: "1",
-				},
-				stdio: "ignore",
-				windowsHide: true,
-			},
-		);
-		expect(mockEnsureCliHubServer).not.toHaveBeenCalled();
-	});
-
-	it("uses the in-process ensure path when no executable cache can be deleted", async () => {
-		mockEnsureCliHubServer.mockResolvedValue({
-			url: "ws://127.0.0.1:25463/hub",
-			authToken: "token",
-		});
-
-		await ensureCliHubServerAfterUpdate(
-			"C:\\workspace\\project",
-			{ CLINE_WRAPPER_PATH: "C:\\npm\\node_modules\\cline\\bin\\cline" },
-			"win32",
-		);
-
-		expect(mockEnsureCliHubServer).toHaveBeenCalledWith(
-			"C:\\workspace\\project",
-		);
+	it("does nothing when no update was recorded", async () => {
+		expect(await applyDeferredUpdate(undefined)).toBe("none");
 		expect(mockSpawn).not.toHaveBeenCalled();
 	});
 
-	it("surfaces a failure from the freshly installed CLI", async () => {
-		mockSpawn.mockReturnValue(createChildProcessThatCloses(1));
+	it("starts the detached install when no hub is discoverable", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-update-test-"));
+		tempDirs.push(root);
+		process.env.CLINE_BUILD_ENV = "production";
+		process.env.CLINE_HUB_DISCOVERY_PATH = join(root, "production.json");
+		const unref = vi.fn();
+		mockSpawn.mockReturnValue({ unref } as unknown as ChildProcess);
 
-		await expect(
-			ensureCliHubServerAfterUpdate(
-				"/workspace/project",
-				{ CLINE_WRAPPER_PATH: "/opt/cline/bin/cline" },
-				"linux",
-			),
-		).rejects.toThrow(
-			"freshly installed Cline failed to start the hub (exit code 1)",
+		const outcome = await applyDeferredUpdate({
+			command: "npm update -g cline --tag latest --min-release-age=0",
+		});
+
+		expect(outcome).toBe("started");
+		expect(mockSpawn).toHaveBeenCalledWith(
+			"npm update -g cline --tag latest --min-release-age=0",
+			expect.objectContaining({
+				detached: true,
+				shell: true,
+				stdio: "ignore",
+			}),
 		);
+		expect(unref).toHaveBeenCalled();
 	});
+
+	it("defers while another cli client is attached to the hub", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-update-test-"));
+		tempDirs.push(root);
+		const discoveryPath = join(root, "production.json");
+		process.env.CLINE_BUILD_ENV = "production";
+		process.env.CLINE_HUB_DISCOVERY_PATH = discoveryPath;
+		const {
+			createLocalHubScheduleRuntimeHandlers,
+			NodeHubClient,
+			startHubWebSocketServer,
+		} = await import("@cline/core");
+		const server = await startHubWebSocketServer({
+			host: "127.0.0.1",
+			port: 0,
+			owner: { ownerId: "update-test", discoveryPath },
+			runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
+		});
+		const cliClient = new NodeHubClient({
+			url: server.url,
+			authToken: server.authToken,
+			clientType: "cli",
+			displayName: "fake attached cli",
+		});
+		try {
+			await cliClient.command("client.list", {});
+
+			expect(await applyDeferredUpdate({ command: "echo update" })).toBe(
+				"deferred",
+			);
+			expect(mockSpawn).not.toHaveBeenCalled();
+
+			await cliClient.dispose();
+			const unref = vi.fn();
+			mockSpawn.mockReturnValue({ unref } as unknown as ChildProcess);
+			// The hub unregisters the client when its socket closes; poll
+			// briefly rather than assuming the close is processed instantly.
+			let outcome = "deferred";
+			const deadline = Date.now() + 3_000;
+			while (outcome === "deferred" && Date.now() < deadline) {
+				outcome = await applyDeferredUpdate({ command: "echo update" });
+			}
+			expect(outcome).toBe("started");
+		} finally {
+			await cliClient.dispose().catch(() => undefined);
+			await server.close();
+		}
+	}, 15_000);
 });
 
 describe("withMinimumReleaseAgeBypass", () => {

apps/cli/src/commands/update.ts

@@ -1,17 +1,14 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import {
-	clearHubDiscovery,
 	isAutoUpdateEnabledGlobally,
-	probeHubServer,
+	NodeHubClient,
 	readHubDiscovery,
 	resolveProductionHubOwnerContext,
 	resolveSharedHubOwnerContext,
-	stopLocalHubServerGracefully,
 } from "@cline/core";
 import { resolveClineBuildEnv } from "@cline/shared";
 import { version } from "../../package.json";
-import { ensureCliHubServer } from "../utils/hub-runtime";
 import { c, writeErr, writeln } from "../utils/output";
 import {
 	getInstalledKanbanVersion,
@@ -237,50 +234,6 @@ async function runKanbanUpdate(
 	return waitForProcessExit(updateProcess);
 }
 
-/**
- * Start the hub through the freshly installed CLI after a self-update.
- *
- * On Unix, the npm wrapper normally starts the CLI from bin/.cline. npm 12 may
- * remove that cached executable while replacing the package and then block the
- * postinstall script that recreates it. The current process keeps running from
- * the unlinked executable, but process.execPath is no longer spawnable. Going
- * back through the wrapper makes it resolve the newly installed platform
- * binary instead.
- *
- * Windows does not create the bin/.cline cache, and development builds do not
- * have CLINE_WRAPPER_PATH, so those cases keep using the normal in-process
- * ensure path.
- */
-export async function ensureCliHubServerAfterUpdate(
-	workspaceRoot: string,
-	env: NodeJS.ProcessEnv = process.env,
-	platform: NodeJS.Platform = process.platform,
-): Promise<void> {
-	const wrapperPath = env.CLINE_WRAPPER_PATH?.trim();
-	if (!wrapperPath || platform === "win32") {
-		await ensureCliHubServer(workspaceRoot);
-		return;
-	}
-
-	const child = spawn(wrapperPath, ["hub", "ensure"], {
-		cwd: workspaceRoot,
-		env: {
-			...env,
-			// The fresh CLI only exists to start the hub. Do not let it launch
-			// another background update check while this update is finishing.
-			CLINE_NO_AUTO_UPDATE: "1",
-		},
-		stdio: "ignore",
-		windowsHide: true,
-	});
-	const exitCode = await waitForProcessExit(child);
-	if (exitCode !== 0) {
-		throw new Error(
-			`freshly installed Cline failed to start the hub (exit code ${exitCode})`,
-		);
-	}
-}
-
 function formatUpdateSummaryTargets(targets: string[]): string {
 	if (targets.length === 0) {
 		return "";
@@ -318,86 +271,40 @@ export function getPreferredKanbanInstaller(
 	);
 }
 
-const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
-
 export function resolveCliHubOwnerContext() {
 	return resolveClineBuildEnv() === "production"
 		? resolveProductionHubOwnerContext()
 		: resolveSharedHubOwnerContext();
 }
 
-async function waitForHubToStop(
-	url: string,
-	authToken: string | undefined,
-	timeoutMs: number,
-): Promise<boolean> {
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() < deadline) {
-		const check = await probeHubServer(url, { authToken }).catch(
-			() => undefined,
-		);
-		if (!check?.url) return true;
-		await sleep(100);
-	}
-	return false;
-}
+let pendingAutoUpdate: ManualUpdateCommand | undefined;
+let pendingAutoUpdateCheck: Promise<void> | undefined;
 
-/**
- * Restart the hub server if one is currently running.
- * Gracefully asks the running hub process to stop, falls back to process signals,
- * clears stale discovery, then re-ensures a fresh instance is spawned.
- */
-async function restartHubServerIfRunning(): Promise<void> {
-	const owner = resolveCliHubOwnerContext();
-	const discovery = await readHubDiscovery(owner.discoveryPath).catch(
-		() => undefined,
-	);
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
-	const health = discovery?.url
-		? await probeHubServer(discovery.url, {
-				authToken: discovery.authToken,
-			}).catch(() => undefined)
-		: undefined;
-	if (!discovery || !health?.url) return;
+// How long the exit sequence will wait for a still-in-flight startup version
+// check before giving up on it. Long enough for a typical registry response,
+// short enough that one-shot commands do not feel it.
+const UPDATE_CHECK_EXIT_GRACE_MS = 250;
 
-	const pid = discovery?.pid;
-	writeln(`${c.dim}[hub] restarting server…${c.reset}`);
-
-	let stopped = await stopLocalHubServerGracefully(owner).catch(() => false);
-	if (!stopped && pid) {
-		try {
-			process.kill(pid, "SIGTERM");
-		} catch {
-			// best-effort
-		}
-	}
-
-	stopped = await waitForHubToStop(health.url, discovery.authToken, 3_000);
-	if (!stopped && pid) {
-		try {
-			process.kill(pid, "SIGKILL");
-		} catch {
-			// best-effort
-		}
-		stopped = await waitForHubToStop(health.url, discovery.authToken, 2_000);
-	}
-
-	await clearHubDiscovery(owner.discoveryPath).catch(() => undefined);
-
-	// Re-ensure a fresh hub instance is spawned.
-	try {
-		await ensureCliHubServerAfterUpdate(process.cwd());
-		writeln(`${c.green}✓${c.reset} ${c.dim}[hub] server restarted${c.reset}`);
-	} catch (err) {
-		writeErr(
-			`[hub] failed to restart server: ${err instanceof Error ? err.message : String(err)}`,
-		);
-	}
-}
+// Hard cap on the exit-time hub query. The hub client's default connect and
+// command timeouts add up to tens of seconds against a wedged hub, and this
+// runs while the user is waiting for their shell prompt back.
+const CLIENT_COUNT_EXIT_TIMEOUT_MS = 3_000;
 
 /**
  * Non-blocking auto-update check for CLI startup.
- * Spawns a detached install process if a newer version is available.
+ *
+ * Deliberately does NOT install right away: replacing the npm package while
+ * cline processes are running swaps the binary under them — their respawn
+ * paths break on the new build fingerprint — and historically also restarted
+ * the hub daemon out from under live sessions. The check only records that an
+ * update is available; the CLI entrypoint calls applyDeferredUpdate() from
+ * its exit sequence (an explicit process.exit() follows, so a beforeExit hook
+ * would never fire), and the install runs only when no other CLI is attached
+ * to the hub — at that point nothing is running that the swap could hurt.
+ * The next launch picks up the new binary and a fresh hub.
+ *
  * Skipped for npx, dev, unknown installs. Disable with CLINE_NO_AUTO_UPDATE=1.
  */
 export function autoUpdateOnStartup(): void {
@@ -409,35 +316,129 @@ export function autoUpdateOnStartup(): void {
 		getInstallationInfo(version);
 	if (!updateCommand) return;
 
-	void (async () => {
+	pendingAutoUpdateCheck = (async () => {
 		try {
 			const latest = await getLatestVersion(packageName, version);
 			if (!latest || compareVersions(version, latest) >= 0) return;
-			const autoUpdateCommand = withMinimumReleaseAgeBypass(
+			pendingAutoUpdate = withMinimumReleaseAgeBypass(
 				updateCommand,
 				packageManager,
 			);
-			const child = spawn(autoUpdateCommand.command, {
-				shell: true,
-				detached: true,
-				stdio: "ignore",
-				env: autoUpdateCommand.env
-					? { ...process.env, ...autoUpdateCommand.env }
-					: process.env,
-				// Prevent a console window from flashing on Windows; detached
-				// processes otherwise allocate a new visible console.
-				windowsHide: true,
-			});
-			const exitCode = await waitForProcessExit(child);
-			if (exitCode === 0) {
-				await restartHubServerIfRunning();
-			}
 		} catch {
 			// Best-effort, silently ignore
 		}
 	})();
 }
 
+/**
+ * True when a hub is reachable and another cli* client is attached to it.
+ * Only cli* clients run the npm-installed binary — desktop sidecars and
+ * connectors ship their own — so only they make the swap unsafe. This runs
+ * after the entrypoint's disposeAll(), so this process's own registrations
+ * are closed and any cli client still listed belongs to another process. Errors count as attached:
+ * never install unless the hub positively confirms nothing would be hurt.
+ */
+async function otherCliClientsAttached(): Promise<boolean> {
+	const owner = resolveCliHubOwnerContext();
+	const discovery = await readHubDiscovery(owner.discoveryPath).catch(
+		() => undefined,
+	);
+	if (!discovery?.url) {
+		return false;
+	}
+	const client = new NodeHubClient({
+		url: discovery.url,
+		authToken: discovery.authToken,
+		clientType: "cli-update-check",
+		displayName: "cline update check",
+	});
+	try {
+		const reply = await client.command("client.list", {}, undefined, {
+			timeoutMs: CLIENT_COUNT_EXIT_TIMEOUT_MS,
+		});
+		const clients =
+			(reply.payload as { clients?: Array<{ clientType?: unknown }> })
+				.clients ?? [];
+		if (
+			clients.some(
+				(entry) =>
+					typeof entry?.clientType === "string" &&
+					entry.clientType.startsWith("cli") &&
+					entry.clientType !== "cli-update-check",
+			)
+		) {
+			return true;
+		}
+		// A TUI's registration can be lost in transport churn while its session
+		// connection survives (observed in review), so an empty client list is
+		// not proof of safety. Cross-check for sessions somebody is attached to.
+		// Participants, not session status: finished sessions can linger idle
+		// forever and must not pin updates, and participant-less scheduled runs
+		// live in the hub process, which a binary swap does not touch.
+		const sessions = await client.command(
+			"session.list",
+			{ limit: 500 },
+			undefined,
+			{ timeoutMs: CLIENT_COUNT_EXIT_TIMEOUT_MS },
+		);
+		const sessionRecords =
+			(sessions.payload as { sessions?: Array<{ participants?: unknown }> })
+				.sessions ?? [];
+		return sessionRecords.some(
+			(session) =>
+				Array.isArray(session?.participants) && session.participants.length > 0,
+		);
+	} finally {
+		await client.dispose().catch(() => undefined);
+	}
+}
+
+/**
+ * Spawns the recorded update install, detached, if no other CLI would be
+ * affected by the package swap. Fire-and-forget: the install outlives this
+ * process and its postinstall never blocks an exit.
+ */
+export async function applyDeferredUpdate(
+	pending?: ManualUpdateCommand,
+): Promise<"none" | "deferred" | "started"> {
+	if (!pending) {
+		// Short-lived commands can reach exit before the startup version check
+		// resolves; give it a brief grace so one-shot-only usage still updates.
+		if (pendingAutoUpdateCheck) {
+			await Promise.race([
+				pendingAutoUpdateCheck,
+				sleep(UPDATE_CHECK_EXIT_GRACE_MS),
+			]);
+		}
+		pending = pendingAutoUpdate;
+	}
+	if (!pending) {
+		return "none";
+	}
+	// The whole query is bounded: the user is waiting on their prompt, and a
+	// wedged hub must not turn a finished command into a hung one. A timeout
+	// counts as "attached" — never install unless the hub positively confirms.
+	const attached = await Promise.race([
+		otherCliClientsAttached(),
+		sleep(CLIENT_COUNT_EXIT_TIMEOUT_MS).then(() => true),
+	]).catch(() => true);
+	if (attached) {
+		return "deferred";
+	}
+	pendingAutoUpdate = undefined;
+	const child = spawn(pending.command, {
+		shell: true,
+		detached: true,
+		stdio: "ignore",
+		env: pending.env ? { ...process.env, ...pending.env } : process.env,
+		// Prevent a console window from flashing on Windows; detached
+		// processes otherwise allocate a new visible console.
+		windowsHide: true,
+	});
+	child.unref();
+	return "started";
+}
+
 export interface CheckForUpdatesOptions {
 	verbose?: boolean;
 	includeKanban?: boolean;
@@ -554,7 +555,9 @@ export async function checkForUpdates(
 					const exitCode = await runCliUpdate(manualUpdateCommand);
 					if (exitCode === 0) {
 						installedUpdates.push(`${packageName}@${latestVersion}`);
-						await restartHubServerIfRunning();
+						writeln(
+							`${c.dim}The update takes effect the next time cline starts.${c.reset}`,
+						);
 					} else {
 						writeErr(
 							`Cline update failed (exit code ${exitCode}). Try running: ${manualUpdateCommand.command}`,

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

@@ -7,6 +7,7 @@ import type {
 	UserInstructionConfigService,
 } from "@cline/core";
 import { isUnusableSessionError } from "@cline/core";
+import type { GeneratedMedia } from "@cline/shared";
 import type { SentMessage, Thread } from "chat";
 import type { CliLoggerAdapter } from "../logging/adapter";
 import { buildUserInputMessage, resolveSystemPrompt } from "../runtime/prompt";
@@ -125,6 +126,7 @@ async function postConnectorRuntimeReply<TState extends ConnectorThreadState>(
 	stream: AsyncIterable<string>,
 	postFinalReply?: (text: string) => Promise<void>,
 	resolveFallbackText?: () => Promise<string | undefined>,
+	hasNonTextReply?: () => boolean,
 ): Promise<void> {
 	if (transport !== "telegram" && !postFinalReply && !resolveFallbackText) {
 		await thread.post(stream);
@@ -135,6 +137,9 @@ async function postConnectorRuntimeReply<TState extends ConnectorThreadState>(
 	for await (const chunk of stream) {
 		text += chunk;
 	}
+	if (!text.trim() && hasNonTextReply?.()) {
+		return;
+	}
 	if (!text.trim()) {
 		text = (await resolveFallbackText?.())?.trim() || "";
 	}
@@ -151,6 +156,67 @@ async function postConnectorRuntimeReply<TState extends ConnectorThreadState>(
 	await postConnectorText(thread, transport, text);
 }
 
+const CONNECTOR_MEDIA_EXTENSIONS: Readonly<Record<string, string>> = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"audio/mpeg": "mp3",
+	"audio/wav": "wav",
+	"audio/ogg": "ogg",
+	"video/mp4": "mp4",
+	"video/webm": "webm",
+};
+
+async function postConnectorGeneratedMedia<TState extends ConnectorThreadState>(
+	thread: Thread<TState>,
+	mediaItems: readonly GeneratedMedia[],
+): Promise<void> {
+	if (mediaItems.length === 0) {
+		return;
+	}
+
+	const files: Array<{ data: Buffer; filename: string; mimeType: string }> = [];
+	const references: string[] = [];
+	for (const [index, media] of mediaItems.entries()) {
+		const label = media.name?.trim() || `Generated ${media.modality}`;
+		switch (media.source.type) {
+			case "base64": {
+				const data = Buffer.from(media.source.data, "base64");
+				if (data.byteLength === 0) {
+					references.push(
+						`${label} (${media.mediaType}) could not be attached.`,
+					);
+					break;
+				}
+				const extension =
+					CONNECTOR_MEDIA_EXTENSIONS[media.mediaType.toLowerCase()] ?? "bin";
+				const suppliedName = media.name ? basename(media.name) : "";
+				files.push({
+					data,
+					filename: suppliedName || `generated-${index + 1}.${extension}`,
+					mimeType: media.mediaType,
+				});
+				break;
+			}
+			case "url":
+				references.push(`[${label}](${media.source.url})`);
+				break;
+			case "artifact":
+				references.push(`${label}: artifact ${media.source.artifactId}`);
+				break;
+		}
+	}
+
+	if (files.length === 0 && references.length === 0) {
+		return;
+	}
+	await thread.post({
+		markdown: references.length > 0 ? references.join("\n") : "Generated media",
+		...(files.length > 0 ? { files } : {}),
+	});
+}
+
 /**
  * Clears a thread's stale session mapping after the hub reported the mapped
  * session no longer exists, so the next turn starts a fresh session instead of
@@ -1151,6 +1217,7 @@ async function runConnectorRuntimeTurn<
 		client: input.client,
 		sessionId,
 	});
+	const generatedMedia: GeneratedMedia[] = [];
 
 	const activeTurn: ActiveConnectorTurn = {
 		sessionId,
@@ -1200,6 +1267,9 @@ async function runConnectorRuntimeTurn<
 						formatConnectorApprovalPrompt(approval),
 					);
 				},
+				onMedia: (media) => {
+					generatedMedia.push(media);
+				},
 				onCompleted: async (result) => {
 					await input.onReplyCompleted?.({
 						sessionId,
@@ -1219,7 +1289,9 @@ async function runConnectorRuntimeTurn<
 			}),
 			postFinalReply,
 			resolveFallbackText,
+			() => generatedMedia.length > 0,
 		);
+		await postConnectorGeneratedMedia(input.thread, generatedMedia);
 	} finally {
 		input.pendingApprovals.delete(input.thread.id);
 		if (input.activeTurns?.get(turnKey) === activeTurn) {

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

@@ -11,6 +11,49 @@ type StreamHandlers = {
 };
 
 describe("createConnectorRuntimeTurnStream", () => {
+	it("forwards generated media without adding binary data to the text stream", async () => {
+		let handlers: StreamHandlers | undefined;
+		const media = {
+			id: "generated-1",
+			modality: "image" as const,
+			mediaType: "image/png",
+			source: { type: "base64" as const, data: "aGVsbG8=" },
+		};
+		const client = {
+			streamEvents: (_request: unknown, callbacks: StreamHandlers) => {
+				handlers = callbacks;
+				return () => {};
+			},
+			sendRuntimeSession: async () => {
+				handlers?.onEvent({
+					eventType: "runtime.chat.media",
+					payload: { media },
+				});
+				return { result: { text: "", finishReason: "stop", iterations: 1 } };
+			},
+		};
+		const receivedMedia: unknown[] = [];
+		const chunks: string[] = [];
+
+		for await (const chunk of createConnectorRuntimeTurnStream({
+			client: client as never,
+			sessionId: "session-1",
+			request: { config: {} as never, prompt: "make an image" },
+			clientId: "client-1",
+			logger: { core: {} } as unknown as CliLoggerAdapter,
+			transport: "slack",
+			conversationId: "thread-1",
+			onMedia: (item) => {
+				receivedMedia.push(item);
+			},
+		})) {
+			chunks.push(chunk);
+		}
+
+		expect(chunks).toEqual([]);
+		expect(receivedMedia).toEqual([media]);
+	});
+
 	it("delivers tool status via callbacks instead of appending it to streamed text", async () => {
 		let handlers: StreamHandlers | undefined;
 

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

@@ -1,4 +1,5 @@
 import type { ChatRunTurnRequest, HubSessionClient } from "@cline/core";
+import { type GeneratedMedia, isGeneratedMedia } from "@cline/shared";
 import type { CliLoggerAdapter } from "../logging/adapter";
 
 export type PendingConnectorApproval = {
@@ -141,6 +142,7 @@ export function createConnectorRuntimeTurnStream(input: {
 	conversationId: string;
 	onToolStatus?: (message: string) => Promise<void>;
 	onApprovalRequested?: (approval: PendingConnectorApproval) => Promise<void>;
+	onMedia?: (media: GeneratedMedia) => Promise<void> | void;
 	onCompleted?: (result: {
 		text: string;
 		finishReason?: string;
@@ -189,6 +191,13 @@ export function createConnectorRuntimeTurnStream(input: {
 				},
 				{
 					onEvent: (event) => {
+						if (event.eventType === "runtime.chat.media") {
+							const media = event.payload.media;
+							if (isGeneratedMedia(media)) {
+								void input.onMedia?.(media);
+							}
+							return;
+						}
 						if (event.eventType === "approval.requested") {
 							const approvalId =
 								typeof event.payload.approvalId === "string"

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

@@ -165,7 +165,6 @@ describe("buildConnectorStartRequest", () => {
 	});
 });
 
-
 describe("isReusableConnectorSession", () => {
 	it("rejects missing and terminal sessions", () => {
 		expect(isReusableConnectorSession(undefined)).toBe(false);

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

@@ -235,9 +235,7 @@ export async function getOrCreateSessionId<
 				transport: input.transport,
 				threadId: input.thread.id,
 				sessionId: existing,
-				...(existingSession?.status
-					? { status: existingSession.status }
-					: {}),
+				...(existingSession?.status ? { status: existingSession.status } : {}),
 			},
 		);
 	}

apps/cli/src/index.ts

@@ -97,6 +97,15 @@ if (!isMainThread) {
 		} finally {
 			await disposeAll();
 		}
+		// The explicit process.exit below means beforeExit never fires, so a
+		// startup-recorded auto-update must be applied here, after all runtime
+		// teardown. It spawns detached and only when no other CLI is attached.
+		try {
+			const { applyDeferredUpdate } = await import("./commands/update");
+			await applyDeferredUpdate();
+		} catch {
+			// Best-effort; never block exit on the updater.
+		}
 		process.exit(exitCode || (process.exitCode as number) || 0);
 	})();
 }

apps/cli/src/main.ts

@@ -505,6 +505,24 @@ export async function runCli(): Promise<void> {
 				io,
 			});
 		});
+	const mcpUninstallCmd = mcpCmd
+		.command("uninstall")
+		.alias("remove")
+		.alias("rm")
+		.description("Uninstall an MCP server by name")
+		.argument("<name>", "MCP server name")
+		.option("--json", "Output as JSON")
+		.action(async (name: string) => {
+			const opts = mcpUninstallCmd.opts<{
+				json?: boolean;
+			}>();
+			const { runMcpUninstallCommand } = await import("./commands/mcp");
+			ctx.exitCode = await runMcpUninstallCommand({
+				name,
+				json: opts.json === true || program.opts().json === true,
+				io,
+			});
+		});
 
 	const createDoctorRuntimeCommand = async () => {
 		const { createDoctorCommand } = await import("./commands/doctor");

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

@@ -1012,7 +1012,9 @@ Review with the bundled skill.`,
 		const linear = data.mcp.find((item) => item.name === "linear");
 		const docs = data.mcp.find((item) => item.name === "docs");
 
-		expect(linear?.description).toBe("streamableHttp, oauth error, timeout 60s");
+		expect(linear?.description).toBe(
+			"streamableHttp, oauth error, timeout 60s",
+		);
 		expect(linear?.loadError).toBe("OAuth authorization failed");
 		expect(docs?.description).toBe("sse, oauth authorized, timeout 60s");
 		expect(docs?.loadError).toBeUndefined();

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

@@ -15,7 +15,7 @@ import {
 	type ToolApprovalResult,
 	type UserInstructionConfigService,
 } from "@cline/core";
-import type { Message } from "@cline/shared";
+import type { MessageWithMetadata } from "@cline/shared";
 import { createCliCore } from "../../session/session";
 import { submitAndExitInTerminal } from "../../utils/approval";
 import type {
@@ -56,11 +56,11 @@ type AskQuestionRef = {
 	current: ((question: string, options: string[]) => Promise<string>) | null;
 };
 type CurrentMessagesRead =
-	| { messages: Message[]; status: "read" }
-	| { messages: Message[]; status: "recovered" }
-	| { messages: Message[]; status: "stale" };
+	| { messages: MessageWithMetadata[]; status: "read" }
+	| { messages: MessageWithMetadata[]; status: "recovered" }
+	| { messages: MessageWithMetadata[]; status: "stale" };
 type MissingSessionRecovery = {
-	messages: Message[];
+	messages: MessageWithMetadata[];
 };
 type ToolPolicyResolver = (
 	toolName: string,
@@ -210,7 +210,7 @@ export function createInteractiveSessionRuntime(input: {
 	};
 
 	const startFreshSession = async (
-		initial: Message[] = [],
+		initial: MessageWithMetadata[] = [],
 		sessionMetadata?: Record<string, unknown>,
 		initialCompactionState?: SessionCompactionState,
 		// Restarting an old session associate with this ID,
@@ -243,7 +243,7 @@ export function createInteractiveSessionRuntime(input: {
 
 	const startResumedSession = async (
 		resumeId: string,
-		initial: Message[] | undefined,
+		initial: MessageWithMetadata[] | undefined,
 	): Promise<void> => {
 		const generation = sessionStartGeneration;
 		const manager = await ensureSessionManager();
@@ -421,7 +421,7 @@ export function createInteractiveSessionRuntime(input: {
 	};
 
 	const restartWithMessages = async (
-		messages: Message[],
+		messages: MessageWithMetadata[],
 		sessionMetadata?: Record<string, unknown>,
 		initialCompactionState?: SessionCompactionState,
 		options?: { preserveSessionId?: boolean },
@@ -659,7 +659,9 @@ export function createInteractiveSessionRuntime(input: {
 		};
 	};
 
-	const resumeSession = async (sessionId: string): Promise<Message[]> => {
+	const resumeSession = async (
+		sessionId: string,
+	): Promise<MessageWithMetadata[]> => {
 		const manager = await ensureSessionManager();
 		const sessionRecord = await manager.get(sessionId);
 		if (!sessionRecord) {
@@ -754,7 +756,7 @@ export function createInteractiveSessionRuntime(input: {
 
 	const getCheckpointData = async (): Promise<
 		| {
-				messages: Message[];
+				messages: MessageWithMetadata[];
 				checkpointHistory: CheckpointEntry[];
 		  }
 		| undefined
@@ -777,7 +779,9 @@ export function createInteractiveSessionRuntime(input: {
 	const restoreCheckpoint = async (
 		runCount: number,
 		restoreWorkspace: boolean,
-	): Promise<{ newSessionId: string; messages: Message[] } | undefined> => {
+	): Promise<
+		{ newSessionId: string; messages: MessageWithMetadata[] } | undefined
+	> => {
 		const manager = sessionManager;
 		if (!manager || !activeSessionId) {
 			return undefined;

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

@@ -80,7 +80,9 @@ describe("applyInteractiveModelChange", () => {
 		}));
 		const saveProviderSettings = vi.fn(() => ({
 			version: 1 as const,
+			modes: {},
 			providers: {},
+			modes: {},
 		}));
 		const ensureReady = vi.fn(async () => {});
 		const restartWithCurrentMessages = vi.fn(async () => {});

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

@@ -490,6 +490,7 @@ export async function runInteractive(
 		tuiApp?.destroy();
 	});
 	let startupErrorReported = false;
+	let updateCliAfterExit = false;
 	const loadDeferredInitialMessages = resumeSessionId?.trim()
 		? async () => {
 				try {
@@ -749,6 +750,10 @@ export async function runInteractive(
 		onExit: () => {
 			tuiApp?.destroy();
 		},
+		onHubUpdateRestart: () => {
+			updateCliAfterExit = true;
+			tuiApp?.destroy();
+		},
 		onRunningChange: (running) => {
 			isRunning = running;
 			if (!running) {
@@ -877,4 +882,19 @@ export async function runInteractive(
 		prepareTerminalForPostTuiOutput();
 		writeln(formatInteractiveExitSummary(exitSummary));
 	}
+	if (updateCliAfterExit) {
+		if (!exitSummary) {
+			prepareTerminalForPostTuiOutput();
+		}
+		writeln(
+			"The shared Cline Hub was updated by another Cline installation. Updating this CLI…",
+		);
+		const { checkForUpdates } = await import("../commands/update");
+		const exitCode = await checkForUpdates({ includeKanban: false });
+		writeln(
+			exitCode === 0
+				? "Start cline again to reconnect to the updated Hub."
+				: "Update did not complete. Run 'cline update' manually, then start cline again.",
+		);
+	}
 }

apps/cli/src/runtime/tools.ts

@@ -2,6 +2,7 @@ import {
 	type BuiltinToolAvailabilityContext,
 	getCoreBuiltinToolCatalog,
 	resolveDisabledToolNames,
+	resolveModelToolSettings,
 	type ToolCatalogEntry,
 } from "@cline/core";
 
@@ -10,8 +11,14 @@ export type { ToolCatalogEntry } from "@cline/core";
 export function getToolCatalog(
 	availabilityContext?: BuiltinToolAvailabilityContext,
 ): ToolCatalogEntry[] {
+	const modelToolSettings = resolveModelToolSettings();
 	return getCoreBuiltinToolCatalog({
 		disabledToolIds: resolveDisabledToolNames(),
+		enabledModelToolIds: new Set(
+			Object.entries(modelToolSettings)
+				.filter(([, setting]) => setting?.enabled === true)
+				.map(([name]) => name),
+		),
 		...availabilityContext,
 	});
 }

apps/cli/src/session/export.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { generateConversationHTML } from "./export";
+
+describe("generateConversationHTML", () => {
+	it("renders provider model activity with the ordinary tool HTML", () => {
+		const html = generateConversationHTML(
+			{
+				version: 1,
+				updated_at: "2026-08-13T00:00:00.000Z",
+				messages: [
+					{
+						id: "assistant-search",
+						role: "assistant",
+						content: "Bun 1.3.14 is current.",
+						metadata: {
+							modelToolActivities: [
+								{
+									toolCallId: "search-1",
+									toolName: "web_search",
+									execution: "provider",
+									input: { query: "latest Bun release" },
+									output: "Bun 1.3.14",
+								},
+							],
+						},
+					},
+				],
+			},
+			"session",
+		);
+
+		expect(html).toContain("web_search");
+		expect(html).toContain("latest Bun release");
+		expect(html).toContain('<span class="success">Success</span>');
+		expect(html).toContain("Bun 1.3.14 is current.");
+	});
+});

apps/cli/src/session/export.ts

@@ -1,3 +1,4 @@
+import { projectSessionMessagesForDisplay } from "@cline/core";
 import {
 	type ContentBlock,
 	formatDisplayUserInput,
@@ -30,9 +31,12 @@ export function generateConversationHTML(
 	data: ConversationHistory,
 	fileName: string,
 ): string {
+	const displayMessages = projectSessionMessagesForDisplay(data.messages).map(
+		({ message }) => message,
+	);
 	// Build tool results map
 	const toolResultsMap = new Map<string, ToolResultContent>();
-	data.messages.forEach((msg) => {
+	displayMessages.forEach((msg) => {
 		if (!isStringContent(msg.content)) {
 			msg.content.forEach((block) => {
 				if (block.type === "tool_result") {
@@ -43,7 +47,7 @@ export function generateConversationHTML(
 	});
 
 	// Filter messages (same logic as viewer)
-	const filteredMessages = data.messages.filter((msg) => {
+	const filteredMessages = displayMessages.filter((msg) => {
 		if (msg.role === "assistant") return true;
 		if (isStringContent(msg.content)) {
 			return msg.content.trim().length > 0;
@@ -696,6 +700,14 @@ function renderContentHTML(
 					return renderToolUseHTML(block, toolResultsMap.get(block.id));
 				case "tool_result":
 					return ""; // Tool results are rendered with their corresponding tool_use
+				case "image":
+					return renderGeneratedMediaHTML({
+						modality: "image",
+						mediaType: block.mediaType,
+						source: { type: "base64", data: block.data },
+					});
+				case "media":
+					return renderGeneratedMediaHTML(block.media);
 				default:
 					return "";
 			}
@@ -703,6 +715,37 @@ function renderContentHTML(
 		.join("\n");
 }
 
+function renderGeneratedMediaHTML(media: {
+	modality: "image" | "audio" | "video" | "file";
+	mediaType: string;
+	source:
+		| { type: "base64"; data: string }
+		| { type: "url"; url: string }
+		| { type: "artifact"; artifactId: string };
+}): string {
+	const source =
+		media.source.type === "base64"
+			? `data:${media.mediaType};base64,${media.source.data}`
+			: media.source.type === "url"
+				? media.source.url
+				: undefined;
+	if (!source) {
+		return `<p class="generated-media">Generated ${escapeHtml(media.modality)} (${escapeHtml(media.mediaType)})</p>`;
+	}
+	const escapedSource = escapeHtml(source);
+	const escapedType = escapeHtml(media.mediaType);
+	switch (media.modality) {
+		case "image":
+			return `<img class="generated-media" src="${escapedSource}" alt="Generated image" />`;
+		case "audio":
+			return `<audio class="generated-media" controls src="${escapedSource}" type="${escapedType}"></audio>`;
+		case "video":
+			return `<video class="generated-media" controls src="${escapedSource}" type="${escapedType}"></video>`;
+		case "file":
+			return `<a class="generated-media" href="${escapedSource}" download>Generated file (${escapedType})</a>`;
+	}
+}
+
 function renderTextHTML(text: string): string {
 	// Simple markdown-like rendering
 	let html = escapeHtml(text);

apps/cli/src/tests/helpers/page-objects/settings.ts

@@ -1,89 +0,0 @@
-// ---------------------------------------------------------------------------
-// Page-object helpers for the /settings view.
-// ---------------------------------------------------------------------------
-
-import type { Terminal } from "@microsoft/tui-test/lib/terminal/term";
-import { expectVisible } from "../terminal.js";
-
-const TAB_ORDER = [
-	"API",
-	"Auto-approve",
-	"Features",
-	"Account",
-	"Other",
-] as const;
-
-export type SettingsTab = (typeof TAB_ORDER)[number];
-
-/**
- * Navigate to a specific settings tab by pressing Right from the API tab (index 0).
- * Waits for each tab's content to appear before pressing the next key, making
- * navigation deterministic regardless of machine speed.
- */
-export async function goToSettingsTab(
-	terminal: Terminal,
-	tab: SettingsTab,
-): Promise<void> {
-	const targetIndex = TAB_ORDER.indexOf(tab);
-	for (let i = 0; i < targetIndex; i++) {
-		terminal.keyRight();
-		// Wait for the next tab's content to appear before pressing again
-		await assertTabContent(terminal, TAB_ORDER[i + 1]);
-	}
-}
-
-/** Assert the API tab content is visible */
-export async function assertApiTab(terminal: Terminal): Promise<void> {
-	await expectVisible(terminal, ["Provider:", "Model ID:"]);
-}
-
-/** Assert the Auto-approve tab content is visible */
-export async function assertAutoApproveTab(terminal: Terminal): Promise<void> {
-	await expectVisible(terminal, [
-		"Read project files",
-		"Execute safe commands",
-		"Edit project files",
-	]);
-}
-
-/** Assert the Features tab content is visible */
-export async function assertFeaturesTab(terminal: Terminal): Promise<void> {
-	await expectVisible(terminal, [
-		"Subagents",
-		"Web tools",
-		"Double-check completion",
-	]);
-}
-
-/** Assert the Account tab content is visible */
-export async function assertAccountTab(terminal: Terminal): Promise<void> {
-	// The account tab shows sign-in options when not authenticated to Cline
-	await expectVisible(terminal, /sign in|sign out/i);
-}
-
-/** Assert the Other tab content is visible */
-export async function assertOtherTab(terminal: Terminal): Promise<void> {
-	await expectVisible(terminal, ["Preferred language:", "Cline v"]);
-}
-
-/**
- * Assert the content for a given tab is visible.
- * Used internally by goToSettingsTab to confirm navigation landed correctly.
- */
-export async function assertTabContent(
-	terminal: Terminal,
-	tab: SettingsTab,
-): Promise<void> {
-	switch (tab) {
-		case "API":
-			return assertApiTab(terminal);
-		case "Auto-approve":
-			return assertAutoApproveTab(terminal);
-		case "Features":
-			return assertFeaturesTab(terminal);
-		case "Account":
-			return assertAccountTab(terminal);
-		case "Other":
-			return assertOtherTab(terminal);
-	}
-}

apps/cli/src/tui/cline-account.ts

@@ -2,10 +2,9 @@ import {
 	type ClineAccountBalance,
 	type ClineAccountOrganization,
 	type ClineAccountOrganizationBalance,
-	type ClineSubscriptionPlan,
-	type UserCurrentPlan,
 	ClineAccountService,
 	type ClineAccountUser,
+	type ClineSubscriptionPlan,
 	formatProviderOAuthApiKey,
 	getPersistedProviderApiKey,
 	getProviderOAuthCredentialsFromSettings,
@@ -13,6 +12,7 @@ import {
 	type ProviderSettings,
 	ProviderSettingsManager,
 	saveLocalProviderOAuthCredentials,
+	type UserCurrentPlan,
 } from "@cline/core";
 import { getClineEnvironmentConfig } from "@cline/shared";
 import { formatCreditBalance, normalizeCreditBalance } from "../utils/output";

apps/cli/src/tui/components/chat-entry.tsx

@@ -45,6 +45,13 @@ function trimLeading(text: string): string {
 	return text.replace(/^\n+/, "");
 }
 
+function formatMediaSize(byteLength: number): string {
+	if (byteLength <= 0) return "unknown size";
+	if (byteLength < 1024) return `${byteLength} B`;
+	if (byteLength < 1024 * 1024) return `${(byteLength / 1024).toFixed(1)} KiB`;
+	return `${(byteLength / (1024 * 1024)).toFixed(1)} MiB`;
+}
+
 function ReasoningBlock(props: { text: string; streaming: boolean }) {
 	const [expanded, setExpanded] = useState(false);
 	const { width } = useTerminalDimensions();
@@ -640,10 +647,23 @@ export function ChatEntryView(props: {
 						)}
 					</box>
 					<box flexGrow={1}>
+						{/*
+						 * internalBlockMode="top-level" keeps each markdown block as its
+						 * own renderable. The default coalesced mode merges the whole
+						 * message into one block that is torn down and re-highlighted on
+						 * every streamed chunk, which flashes already-rendered headings
+						 * and links back to raw uncolored markdown while tree-sitter
+						 * re-highlights asynchronously. Top-level blocks are reused by
+						 * token identity, so settled content never re-renders.
+						 * tableOptions preserves the bordered table style that coalesced
+						 * mode used by default (top-level defaults to borderless columns).
+						 */}
 						<markdown
 							content={content}
 							syntaxStyle={getSyntaxStyle(theme, mode)}
 							streaming={entry.streaming}
+							internalBlockMode="top-level"
+							tableOptions={{ style: "grid" }}
 							fg={defaultFg}
 						/>
 					</box>
@@ -651,6 +671,20 @@ export function ChatEntryView(props: {
 			);
 		}
 
+		case "assistant_media":
+			return (
+				<box flexDirection="row">
+					<box width={2}>
+						<text fg={accent}>*</text>
+					</box>
+					<text fg={defaultFg} selectable>
+						{entry.location
+							? `Generated ${entry.modality} (${entry.mediaType}, ${formatMediaSize(entry.byteLength)}): ${entry.location}`
+							: `Generated ${entry.modality} (${entry.mediaType}) could not be saved`}
+					</text>
+				</box>
+			);
+
 		case "reasoning":
 			return <ReasoningBlock text={entry.text} streaming={entry.streaming} />;
 

apps/cli/src/tui/components/dialogs/hub-update-required-helpers.ts

@@ -0,0 +1,27 @@
+import type { Config } from "../../../utils/types";
+import type { DialogDismissKey } from "../../utils/dialog-keys";
+
+/**
+ * Enter starts the update-and-restart flow; Esc dismisses (the mismatch toast
+ * reminds the user to update manually). Other keys are ignored so the dialog
+ * is not lost to a stray keystroke mid-task.
+ */
+export function resolveHubUpdateRequiredKeyAction(
+	key: DialogDismissKey,
+): "update" | "dismiss" | "ignore" {
+	if (key.name === "return" || key.name === "enter") return "update";
+	if (key.name === "escape") return "dismiss";
+	return "ignore";
+}
+
+/**
+ * Yolo and sandbox sessions force the local backend and never attach to the
+ * shared managed Hub (see the forceLocalBackend condition in the interactive
+ * session runtime), so a build mismatch on that Hub is another installation's
+ * concern and must not interrupt these sessions with an update dialog.
+ */
+export function shouldWatchManagedHubBuild(
+	config: Pick<Config, "mode" | "sandbox">,
+): boolean {
+	return config.mode !== "yolo" && config.sandbox !== true;
+}

apps/cli/src/tui/components/dialogs/hub-update-required.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import {
+	resolveHubUpdateRequiredKeyAction,
+	shouldWatchManagedHubBuild,
+} from "./hub-update-required-helpers";
+
+describe("hub update required dialog", () => {
+	it("updates on Enter", () => {
+		expect(resolveHubUpdateRequiredKeyAction({ name: "return" })).toBe(
+			"update",
+		);
+		expect(resolveHubUpdateRequiredKeyAction({ name: "enter" })).toBe("update");
+	});
+
+	it("dismisses only on Esc", () => {
+		expect(resolveHubUpdateRequiredKeyAction({ name: "escape" })).toBe(
+			"dismiss",
+		);
+	});
+
+	it("ignores stray keystrokes so a mid-task keypress cannot lose the prompt", () => {
+		expect(resolveHubUpdateRequiredKeyAction({ name: "a" })).toBe("ignore");
+		expect(resolveHubUpdateRequiredKeyAction({ name: "space" })).toBe("ignore");
+		expect(resolveHubUpdateRequiredKeyAction({ name: "c", ctrl: true })).toBe(
+			"ignore",
+		);
+	});
+});
+
+describe("shouldWatchManagedHubBuild", () => {
+	it("watches for hub-attached modes", () => {
+		expect(shouldWatchManagedHubBuild({ mode: "act", sandbox: false })).toBe(
+			true,
+		);
+		expect(shouldWatchManagedHubBuild({ mode: "plan", sandbox: false })).toBe(
+			true,
+		);
+	});
+
+	it("skips yolo and sandbox sessions, which force the local backend and never attach to the managed Hub", () => {
+		expect(shouldWatchManagedHubBuild({ mode: "yolo", sandbox: false })).toBe(
+			false,
+		);
+		expect(shouldWatchManagedHubBuild({ mode: "act", sandbox: true })).toBe(
+			false,
+		);
+	});
+});

apps/cli/src/tui/components/dialogs/hub-update-required.tsx

@@ -0,0 +1,50 @@
+// @jsxImportSource @opentui/react
+import type { ChoiceContext } from "@opentui-ui/dialog";
+import { useDialogKeyboard } from "@opentui-ui/dialog/react";
+import { palette } from "../../palette";
+import { resolveHubUpdateRequiredKeyAction } from "./hub-update-required-helpers";
+
+export interface HubUpdateRequiredDetails {
+	hubCoreVersion?: string;
+}
+
+export function HubUpdateRequiredContent(
+	props: ChoiceContext<boolean> & HubUpdateRequiredDetails,
+) {
+	const { dialogId, dismiss, hubCoreVersion, resolve } = props;
+
+	useDialogKeyboard((key) => {
+		const action = resolveHubUpdateRequiredKeyAction(key);
+		if (action === "ignore") return;
+		if (action === "update") {
+			resolve(true);
+			return;
+		}
+		dismiss();
+	}, dialogId);
+
+	return (
+		<box flexDirection="column" paddingX={1} gap={1}>
+			<text fg="yellow">Cline Hub was updated</text>
+			<box flexDirection="column">
+				<text selectable>
+					Another Cline installation restarted the shared Cline Hub
+					{hubCoreVersion ? ` (core ${hubCoreVersion})` : ""}, and it no longer
+					matches this CLI.
+				</text>
+				<text selectable>
+					Update and restart Cline so this CLI and the Hub run the same version
+					again.
+				</text>
+			</box>
+			<box flexDirection="row">
+				<box paddingX={1} backgroundColor={palette.act}>
+					<text fg={palette.textOnSelection}>Update and restart</text>
+				</box>
+			</box>
+			<text fg={palette.muted}>
+				Press Enter to update and restart, Esc to dismiss
+			</text>
+		</box>
+	);
+}

apps/cli/src/tui/components/queued-prompts.tsx

@@ -117,7 +117,10 @@ function QueuedPromptRow(props: {
 					flexGrow={1}
 				/>
 			) : (
-				<text fg={selected ? theme.textOnSelection : undefined} flexGrow={1}>
+				<text
+					fg={selected ? theme.textOnSelection : theme.defaultForeground}
+					flexGrow={1}
+				>
 					{truncatePrompt(item.prompt)}
 				</text>
 			)}

apps/cli/src/tui/components/tool-output.tsx

@@ -55,6 +55,7 @@ function BashOutput(props: { fullText: string; theme: ResolvedTheme }) {
 
 	if (!expanded) {
 		return (
+			// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse expands optional output.
 			<box
 				flexDirection="column"
 				paddingLeft={2}
@@ -75,6 +76,7 @@ function BashOutput(props: { fullText: string; theme: ResolvedTheme }) {
 	}
 
 	return (
+		// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse collapses output.
 		<box
 			flexDirection="column"
 			paddingLeft={2}
@@ -160,6 +162,7 @@ function EditOutput(props: {
 	const diffPalette = props.theme.diff;
 
 	return (
+		// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse toggles the diff.
 		<box
 			flexDirection="column"
 			paddingLeft={2}
@@ -216,6 +219,7 @@ function ApplyPatchOutput(props: {
 	const diffPalette = props.theme.diff;
 
 	return (
+		// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse toggles the diff.
 		<box
 			flexDirection="column"
 			paddingLeft={2}
@@ -263,6 +267,7 @@ function GenericOutput(props: { outputSummary: string; fullText?: string }) {
 			: displayText;
 
 		return (
+			// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse expands long output.
 			<box
 				flexDirection="column"
 				paddingLeft={2}
@@ -278,6 +283,7 @@ function GenericOutput(props: { outputSummary: string; fullText?: string }) {
 	}
 
 	return (
+		// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse collapses output.
 		<box
 			flexDirection="column"
 			paddingLeft={2}
@@ -304,6 +310,7 @@ export function ToolOutput(props: ToolOutputProps) {
 		const showDetail =
 			errorExpanded && presentation.detail !== presentation.summary.trim();
 		return (
+			// biome-ignore lint/a11y/noStaticElementInteractions: OpenTUI box is a terminal renderable, not a DOM element; mouse toggles error details.
 			<box
 				flexDirection="column"
 				paddingLeft={2}

apps/cli/src/tui/hooks/use-agent-events.ts

@@ -7,6 +7,7 @@ import type {
 } from "../../runtime/session-events";
 import { formatCliErrorMessage } from "../../utils/cline-pass-errors";
 import { resolveNonCompactionStatusLabel } from "../../utils/events";
+import { materializeGeneratedMedia } from "../../utils/generated-media";
 import {
 	formatToolInput,
 	formatToolOutput,
@@ -205,6 +206,26 @@ export function useAgentEventHandlers(deps: AgentEventDeps) {
 							closeToolEntry(event);
 							break;
 						}
+						case "media": {
+							closeInlineStream();
+							const media = event.media;
+							if (!media) break;
+							const saved = materializeGeneratedMedia(media);
+							appendEntry({
+								kind: "assistant_media",
+								modality: media.modality,
+								mediaType: media.mediaType,
+								byteLength: saved?.byteLength ?? media.sizeBytes ?? 0,
+								location:
+									saved?.path ??
+									(media.source.type === "url"
+										? media.source.url
+										: media.source.type === "artifact"
+											? `artifact:${media.source.artifactId}`
+											: undefined),
+							});
+							break;
+						}
 					}
 					break;
 				}

apps/cli/src/tui/interactive-config.test.ts

@@ -2,13 +2,13 @@ import { describe, expect, it } from "vitest";
 import { getMcpDescription } from "./interactive-config";
 
 describe("getMcpDescription", () => {
-	it("discloses the fast initialize probe for unconfigured stdio servers", () => {
+	it("discloses the default initialize timeout for unconfigured stdio servers", () => {
 		expect(
 			getMcpDescription({
 				name: "local",
 				transport: { type: "stdio", command: "node" },
 			}),
-		).toBe("stdio, local, request timeout 60s, initialize probe 1.5s");
+		).toBe("stdio, local, request timeout 60s, initialize timeout 3s");
 	});
 
 	it("shows one configured timeout when it also applies to initialize", () => {
@@ -40,6 +40,6 @@ describe("getMcpDescription", () => {
 				transport: { type: "stdio", command: "node" },
 				timeoutSeconds: Number.NaN,
 			}),
-		).toBe("stdio, local, request timeout 60s, initialize probe 1.5s");
+		).toBe("stdio, local, request timeout 60s, initialize timeout 3s");
 	});
 });

apps/cli/src/tui/interactive-config.ts

@@ -9,6 +9,7 @@ import {
 } from "node:path";
 import {
 	type BuiltinToolAvailabilityContext,
+	DEFAULT_MCP_CONNECT_TIMEOUT_MS,
 	discoverPluginModulePaths,
 	getPluginDisplayName,
 	hasMcpSettingsFile,
@@ -183,7 +184,7 @@ export function getMcpDescription(registration: McpServerRegistration): string {
 	const timeoutDescription =
 		registration.transport.type === "stdio" &&
 		!isMcpTimeoutConfigured(registration.timeoutSeconds)
-			? `request timeout ${timeoutSeconds}s, initialize probe 1.5s`
+			? `request timeout ${timeoutSeconds}s, initialize timeout ${DEFAULT_MCP_CONNECT_TIMEOUT_MS / 1000}s`
 			: `timeout ${timeoutSeconds}s`;
 	return `${registration.transport.type}, ${getMcpAuthLabel(registration)}, ${timeoutDescription}`;
 }

apps/cli/src/tui/root.tsx

@@ -1,4 +1,9 @@
-import { getCurrentContextSize, summarizeUsageFromMessages } from "@cline/core";
+import {
+	getCurrentContextSize,
+	type ManagedHubBuildMismatchEvent,
+	summarizeUsageFromMessages,
+	watchManagedHubBuildMismatch,
+} from "@cline/core";
 import { formatDisplayUserInput } from "@cline/shared";
 import type { KeyEvent } from "@opentui/core";
 import { useRenderer, useTerminalDimensions } from "@opentui/react";
@@ -34,6 +39,8 @@ import {
 	buildCommandPaletteItems,
 	findCommandPaletteShortcut,
 } from "./components/dialogs/command-palette-items";
+import { HubUpdateRequiredContent } from "./components/dialogs/hub-update-required";
+import { shouldWatchManagedHubBuild } from "./components/dialogs/hub-update-required-helpers";
 import {
 	SKILLS_MARKETPLACE_ACTION,
 	SKILLS_MARKETPLACE_URL,
@@ -562,6 +569,55 @@ function App(props: TuiProps) {
 		return () => clearTimeout(timeout);
 	}, [appView, currentProviderId, dialog, notice, onInitialNoticeShown]);
 
+	const [hubBuildMismatch, setHubBuildMismatch] =
+		useState<ManagedHubBuildMismatchEvent | null>(null);
+	const hubBuildWatchEnabled = shouldWatchManagedHubBuild(props.config);
+	useEffect(() => {
+		if (!hubBuildWatchEnabled) return;
+		return watchManagedHubBuildMismatch({
+			onMismatch: (mismatch) => setHubBuildMismatch(mismatch),
+		});
+	}, [hubBuildWatchEnabled]);
+
+	const onHubUpdateRestart = props.onHubUpdateRestart;
+	useEffect(() => {
+		if (!hubBuildMismatch) return;
+		setHubBuildMismatch(null);
+		const hubCoreVersion = hubBuildMismatch.hubCoreVersion;
+		if (hubBuildMismatch.reason === "outdated_hub") {
+			// This CLI is already the newer build. The Hub is behind only because
+			// retiring it would kill the sessions it is serving, and it is
+			// replaced on its own at the next launch. Nothing is wrong, nothing is
+			// asked, and nothing the user can act on differs - so say nothing, the
+			// same conclusion the desktop surface reached.
+			//
+			// The classification still earns its keep here: it is what stops the
+			// update-and-restart prompt below from firing at someone who has
+			// nothing to update.
+			return;
+		}
+		void dialog
+			.choice<boolean>({
+				content: (ctx: ChoiceContext<boolean>) => (
+					<HubUpdateRequiredContent {...ctx} hubCoreVersion={hubCoreVersion} />
+				),
+			})
+			.then((update) => {
+				if (update) {
+					(onHubUpdateRestart ?? exitCline)();
+					return;
+				}
+				showToast(
+					"Hub still differs from this CLI. Run 'cline update' and restart when convenient.",
+					"info",
+				);
+				refocusTextareaRef.current();
+			})
+			.catch(() => {
+				refocusTextareaRef.current();
+			});
+	}, [dialog, exitCline, hubBuildMismatch, onHubUpdateRestart, showToast]);
+
 	const {
 		appendEntry: appendSessionEntry,
 		replaceEntries: replaceSessionEntries,

apps/cli/src/tui/types.ts

@@ -6,7 +6,7 @@ import type {
 	TeamEvent,
 } from "@cline/core";
 import type {
-	Message,
+	MessageWithMetadata,
 	ToolApprovalRequest,
 	ToolApprovalResult,
 } from "@cline/shared";
@@ -29,6 +29,13 @@ import type { InteractiveSlashCommand } from "./interactive-welcome";
 export type ChatEntry = (
 	| { kind: "user"; text: string }
 	| { kind: "assistant_text"; text: string; streaming: boolean }
+	| {
+			kind: "assistant_media";
+			modality: "image" | "audio" | "video" | "file";
+			mediaType: string;
+			byteLength: number;
+			location?: string;
+	  }
 	| { kind: "reasoning"; text: string; streaming: boolean }
 	| {
 			kind: "tool_call";
@@ -92,7 +99,7 @@ export interface InteractiveTurnResult {
 }
 
 export interface ResumedSessionResult {
-	messages: Message[];
+	messages: MessageWithMetadata[];
 	totalCost?: number;
 	currentContextSize?: number;
 }
@@ -145,7 +152,7 @@ export interface TuiProps {
 	initialPrompt?: string;
 	initialNotice?: CliMigrationNotice;
 	onInitialNoticeShown?: (notice: CliMigrationNotice) => void | Promise<void>;
-	initialMessages?: Message[];
+	initialMessages?: MessageWithMetadata[];
 	loadDeferredInitialMessages?: () => Promise<ResumedSessionResult>;
 	initialRepoStatus?: RepoStatus;
 	workflowSlashCommands?: InteractiveSlashCommand[];
@@ -185,6 +192,11 @@ export interface TuiProps {
 	}) => Promise<PendingPromptMutationResult>;
 	onAbort: () => boolean;
 	onExit: () => void;
+	/**
+	 * Exit the TUI and run the CLI self-update afterwards. Invoked when the
+	 * user accepts the "Hub was updated by another Cline installation" dialog.
+	 */
+	onHubUpdateRestart?: () => void;
 	onRunningChange: (isRunning: boolean) => void;
 	onTurnErrorReported: (reported: boolean) => void;
 	onAutoApproveChange: (enabled: boolean) => void;
@@ -213,12 +225,18 @@ export interface TuiProps {
 		| undefined
 	>;
 	getCheckpointData: () => Promise<
-		{ messages: Message[]; checkpointHistory: CheckpointEntry[] } | undefined
+		| {
+				messages: MessageWithMetadata[];
+				checkpointHistory: CheckpointEntry[];
+		  }
+		| undefined
 	>;
 	onRestoreCheckpoint: (
 		runCount: number,
 		restoreWorkspace: boolean,
-	) => Promise<{ newSessionId: string; messages: Message[] } | undefined>;
+	) => Promise<
+		{ newSessionId: string; messages: MessageWithMetadata[] } | undefined
+	>;
 	setToolApprover: (
 		approver:
 			| ((request: ToolApprovalRequest) => Promise<ToolApprovalResult>)

apps/cli/src/tui/utils/hydrate-messages.test.ts

@@ -1,4 +1,6 @@
-import type { Message } from "@cline/shared";
+import { readFileSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+import type { Message, MessageWithMetadata } from "@cline/shared";
 import { describe, expect, it } from "vitest";
 import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
 import { hydrateSessionMessages } from "./hydrate-messages";
@@ -106,6 +108,7 @@ describe("hydrateSessionMessages", () => {
 			},
 			{
 				kind: "tool_call",
+				toolCallId: "tool-1",
 				toolName: "switch_to_act_mode",
 				inputSummary: expect.any(String),
 				rawInput: {},
@@ -135,6 +138,36 @@ describe("hydrateSessionMessages", () => {
 		]);
 	});
 
+	// Regression test for https://github.com/cline/cline/issues/13036:
+	// persisted sessions with malformed tool inputs must stay resumable.
+	it("hydrates tool calls with malformed inputs without throwing", () => {
+		const messages = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "tool_use",
+						id: "tool-1",
+						name: "run_commands",
+						input: { command: null },
+					},
+				],
+			},
+		] as Message[];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{
+				kind: "tool_call",
+				toolCallId: "tool-1",
+				toolName: "run_commands",
+				inputSummary: "",
+				rawInput: { command: null },
+				streaming: false,
+				mode: undefined,
+			},
+		]);
+	});
+
 	it("leaves mode undefined for transcripts without user_input wrappers", () => {
 		const messages = [
 			{ role: "user", content: "plain old message" },
@@ -151,4 +184,119 @@ describe("hydrateSessionMessages", () => {
 			},
 		]);
 	});
+
+	it("materializes generated images from resumed assistant history", () => {
+		const messages = [
+			{
+				role: "assistant",
+				content: [
+					{
+						type: "image",
+						data: Buffer.from("history-image").toString("base64"),
+						mediaType: "image/webp",
+					},
+				],
+			},
+		] as Message[];
+
+		const [entry] = hydrateSessionMessages(messages);
+		expect(entry).toMatchObject({
+			kind: "assistant_media",
+			modality: "image",
+			mediaType: "image/webp",
+			byteLength: 13,
+			mode: undefined,
+		});
+		if (entry?.kind !== "assistant_media" || !entry.location) {
+			throw new Error("Expected a materialized assistant image");
+		}
+		try {
+			expect(readFileSync(entry.location, "utf8")).toBe("history-image");
+		} finally {
+			rmSync(dirname(entry.location), { recursive: true, force: true });
+		}
+	});
+
+	it("hydrates provider model tools through the ordinary tool card path", () => {
+		const messages: MessageWithMetadata[] = [
+			{
+				id: "assistant-search",
+				role: "assistant",
+				content: "Bun 1.3.14 is the latest stable release.",
+				metadata: {
+					modelToolActivities: [
+						{
+							toolCallId: "search-1",
+							toolName: "web_search",
+							execution: "provider",
+							input: { query: "latest Bun stable release" },
+							output: { sources: ["https://bun.sh/blog/bun-v1.3.14"] },
+						},
+					],
+				},
+			},
+		];
+
+		expect(hydrateSessionMessages(messages)).toEqual([
+			{
+				kind: "tool_call",
+				toolCallId: "search-1",
+				toolName: "web_search",
+				inputSummary: expect.any(String),
+				rawInput: { query: "latest Bun stable release" },
+				streaming: false,
+				mode: undefined,
+				result: {
+					outputSummary: '{"sources":["https://bun.sh/blog/bun-v1.3.14"]}',
+					rawOutput: '{"sources":["https://bun.sh/blog/bun-v1.3.14"]}',
+					error: undefined,
+				},
+			},
+			{
+				kind: "assistant_text",
+				text: "Bun 1.3.14 is the latest stable release.",
+				streaming: false,
+				mode: undefined,
+			},
+		]);
+	});
+
+	it("hydrates structured native search output and mirrors live error payloads", () => {
+		const nativeResult = {
+			type: "web_search_result",
+			url: "https://bun.sh/blog/bun-v1.3.14",
+			title: "Bun v1.3.14",
+			pageAge: "2026-08-12",
+			encryptedContent: "encrypted",
+		};
+		const messages: MessageWithMetadata[] = [
+			{
+				role: "assistant",
+				content: "Search failed.",
+				metadata: {
+					modelToolActivities: [
+						{
+							toolCallId: "search-native",
+							toolName: "web_search",
+							execution: "provider",
+							input: { query: "latest Bun" },
+							output: [nativeResult],
+							isError: true,
+						},
+					],
+				},
+			},
+		];
+
+		const [toolEntry] = hydrateSessionMessages(messages);
+		expect(toolEntry).toMatchObject({
+			kind: "tool_call",
+			toolCallId: "search-native",
+			result: {
+				outputSummary: "",
+				rawOutput: undefined,
+				error: JSON.stringify([nativeResult]),
+			},
+		});
+	});
 });

apps/cli/src/tui/utils/hydrate-messages.ts

@@ -1,18 +1,16 @@
-import type { AgentMode } from "@cline/core";
+import { type AgentMode, projectSessionMessagesForDisplay } from "@cline/core";
 import {
 	formatDisplayUserInput,
-	type Message,
+	type GeneratedMedia,
+	type MessageWithMetadata,
 	parseUserInputMode,
 } from "@cline/shared";
 import { ACT_MODE_CONTINUATION_PROMPT } from "../../runtime/interactive/mode";
+import { materializeGeneratedMedia } from "../../utils/generated-media";
 import { formatToolInput } from "../../utils/helpers";
 import type { ChatEntry } from "../types";
 
-type PersistedMessage = Message & {
-	metadata?: Record<string, unknown>;
-};
-
-function getDisplayRole(msg: PersistedMessage): string | undefined {
+function getDisplayRole(msg: MessageWithMetadata): string | undefined {
 	const role = msg.metadata?.displayRole;
 	return typeof role === "string" ? role.trim().toLowerCase() : undefined;
 }
@@ -33,13 +31,29 @@ function stringifyToolResult(
 				return block.text;
 			if (block.type === "file" && typeof block.path === "string")
 				return `Attached file: ${block.path}`;
-			return "";
+			if (block.type === "image") return "[image]";
+			try {
+				return JSON.stringify(block);
+			} catch {
+				return String(block);
+			}
 		})
 		.filter(Boolean)
 		.join("\n");
 }
 
-export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
+function stringifyToolError(content: unknown): string {
+	if (typeof content === "string") return content;
+	try {
+		return JSON.stringify(content) ?? String(content);
+	} catch {
+		return String(content);
+	}
+}
+
+export function hydrateSessionMessages(
+	messages: MessageWithMetadata[],
+): ChatEntry[] {
 	const entries: ChatEntry[] = [];
 	const toolUseMap = new Map<string, number>();
 	// Mode each entry was produced in, recovered from <user_input mode="...">
@@ -49,7 +63,7 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 	// wrappers on session restarts).
 	let mode: AgentMode | undefined;
 
-	for (const msg of messages as PersistedMessage[]) {
+	for (const { message: msg } of projectSessionMessagesForDisplay(messages)) {
 		const displayRole = getDisplayRole(msg);
 		if (displayRole === "system" || displayRole === "status") {
 			continue;
@@ -76,6 +90,39 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 		const userTextParts: string[] = [];
 
 		for (const block of msg.content) {
+			if (
+				msg.role === "assistant" &&
+				(block.type === "image" || block.type === "media")
+			) {
+				const media: GeneratedMedia =
+					block.type === "media"
+						? block.media
+						: {
+								id: `${msg.id ?? "history"}:media:${entries.length}`,
+								modality: "image",
+								mediaType: block.mediaType,
+								source: { type: "base64", data: block.data },
+							};
+				if (media.source.type !== "base64" || media.source.data.length > 0) {
+					const saved = materializeGeneratedMedia(media);
+					entries.push({
+						kind: "assistant_media",
+						modality: media.modality,
+						mediaType: media.mediaType,
+						byteLength: saved?.byteLength ?? media.sizeBytes ?? 0,
+						location:
+							saved?.path ??
+							(media.source.type === "url"
+								? media.source.url
+								: media.source.type === "artifact"
+									? `artifact:${media.source.artifactId}`
+									: undefined),
+						mode,
+					});
+				}
+				continue;
+			}
+
 			if (block.type === "text") {
 				if (msg.role === "user") {
 					userTextParts.push(block.text);
@@ -107,6 +154,7 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 			if (block.type === "tool_use") {
 				entries.push({
 					kind: "tool_call",
+					toolCallId: block.id,
 					toolName: block.name,
 					inputSummary: formatToolInput(block.name, block.input),
 					rawInput: block.input,
@@ -132,11 +180,16 @@ export function hydrateSessionMessages(messages: Message[]): ChatEntry[] {
 								| string
 								| Array<{ type: string; text?: string; path?: string }>,
 						);
-						entry.result = {
-							outputSummary: resultText.slice(0, 500),
-							rawOutput: block.content,
-							error: block.is_error ? resultText : undefined,
-						};
+						const error = block.is_error
+							? stringifyToolError(block.content)
+							: undefined;
+						entry.result = error
+							? { outputSummary: "", rawOutput: undefined, error }
+							: {
+									outputSummary: resultText.slice(0, 500),
+									rawOutput: block.content,
+									error: undefined,
+								};
 					}
 				}
 			}

apps/cli/src/tui/utils/tool-parsing.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { buildReadFilesKeys, parseReadFilesInput } from "./tool-parsing";
+import {
+	buildReadFilesKeys,
+	extractFullOutputText,
+	parseReadFilesInput,
+} from "./tool-parsing";
 
 describe("buildReadFilesKeys", () => {
 	it("produces unique keys when the same path is read twice", () => {
@@ -32,3 +36,64 @@ describe("buildReadFilesKeys", () => {
 		expect(buildReadFilesKeys([])).toEqual([]);
 	});
 });
+
+describe("extractFullOutputText", () => {
+	it("extracts text with real newlines from the MCP CallToolResult shape", () => {
+		const raw = {
+			content: [
+				{ type: "text", text: "# Memory\n\nline one" },
+				{ type: "text", text: "line two" },
+			],
+		};
+		expect(extractFullOutputText(raw)).toBe("# Memory\n\nline one\nline two");
+	});
+
+	it("keeps binary payloads behind placeholders in mixed MCP content", () => {
+		const raw = {
+			content: [
+				{ type: "text", text: "before" },
+				{ type: "image", data: "aGVsbG8=", mimeType: "image/png" },
+				{
+					type: "resource",
+					resource: { uri: "file:///a.md", blob: "d29ybGQ=" },
+				},
+				{ type: "resource_link", uri: "file:///b.md", name: "b.md" },
+				{ type: "text", text: "after" },
+			],
+		};
+		expect(extractFullOutputText(raw)).toBe(
+			"before\n[image: image/png]\naGVsbG8=\n[resource: file:///a.md]\nd29ybGQ=\n[resource_link: file:///b.md]\nafter",
+		);
+	});
+
+	it("chunks base64 payloads into 76-char lines so collapse stays compact", () => {
+		const raw = {
+			content: [
+				{ type: "image", data: "A".repeat(160), mimeType: "image/png" },
+			],
+		};
+		expect(extractFullOutputText(raw)?.split("\n")).toEqual([
+			"[image: image/png]",
+			"A".repeat(76),
+			"A".repeat(76),
+			"A".repeat(8),
+		]);
+	});
+
+	it("extracts embedded resource text from MCP content", () => {
+		const raw = {
+			content: [
+				{
+					type: "resource",
+					resource: { uri: "file:///memory.md", text: "resource body\nline 2" },
+				},
+			],
+		};
+		expect(extractFullOutputText(raw)).toBe("resource body\nline 2");
+	});
+
+	it("falls back to pretty JSON for objects without text content", () => {
+		const raw = { structuredContent: { ok: true } };
+		expect(extractFullOutputText(raw)).toBe(JSON.stringify(raw, null, 2));
+	});
+});

apps/cli/src/tui/utils/tool-parsing.ts

@@ -185,6 +185,12 @@ export function parseSpawnAgentInput(
 	return { task: input.task };
 }
 
+// Base64 payloads are one giant line; chunk to MIME width so GenericOutput's
+// line-based collapse stays compact and expand shows the full data.
+function chunkBase64(data: string): string {
+	return data.match(/.{1,76}/g)?.join("\n") ?? data;
+}
+
 export function extractFullOutputText(raw: unknown): string | undefined {
 	if (raw === null || raw === undefined) return undefined;
 	if (typeof raw === "string") return raw;
@@ -213,6 +219,51 @@ export function extractFullOutputText(raw: unknown): string | undefined {
 	}
 
 	if (typeof raw === "object") {
+		// MCP tools return {content: [{type: "text", text}, ...]}. Extract the
+		// text so multi-line results keep real newlines instead of being
+		// JSON-escaped into one giant line that floods the terminal (#13038).
+		// Non-text blocks keep their identifying metadata plus their base64
+		// payloads so mixed results are not silently truncated.
+		const content = (raw as { content?: unknown }).content;
+		if (Array.isArray(content)) {
+			const parts = content
+				.map((part) => {
+					if (!isRecord(part)) return "";
+					if (part.type === "text" && typeof part.text === "string") {
+						return part.text;
+					}
+					if (part.type === "resource" && isRecord(part.resource)) {
+						if (typeof part.resource.text === "string") {
+							return part.resource.text;
+						}
+						if (typeof part.resource.blob === "string" && part.resource.blob) {
+							const label =
+								typeof part.resource.uri === "string"
+									? `[resource: ${part.resource.uri}]`
+									: "[resource]";
+							return `${label}\n${chunkBase64(part.resource.blob)}`;
+						}
+						if (typeof part.resource.uri === "string") {
+							return `[resource: ${part.resource.uri}]`;
+						}
+					}
+					if (part.type === "resource_link" && typeof part.uri === "string") {
+						return `[resource_link: ${part.uri}]`;
+					}
+					if (
+						(part.type === "image" || part.type === "audio") &&
+						typeof part.mimeType === "string"
+					) {
+						if (typeof part.data === "string" && part.data) {
+							return `[${part.type}: ${part.mimeType}]\n${chunkBase64(part.data)}`;
+						}
+						return `[${part.type}: ${part.mimeType}]`;
+					}
+					return typeof part.type === "string" ? `[${part.type}]` : "";
+				})
+				.filter(Boolean);
+			if (parts.length > 0) return parts.join("\n");
+		}
 		try {
 			return JSON.stringify(raw, null, 2);
 		} catch {

apps/cli/src/utils/cline-pass-errors.test.ts

@@ -28,7 +28,7 @@ describe("cline-pass-errors", () => {
 		expect(isClinePassSubscriptionError(formatted)).toBe(true);
 		expect(formatCliErrorMessage(new Error(sdkFormatted))).toBe(formatted);
 		expect(formatCliErrorMessage(new Error(formatted))).toBe(formatted);
-	});	
+	});
 
 	it("recognizes and formats organization account individual subscription errors", () => {
 		const raw =

apps/cli/src/utils/cline-pass-errors.ts

@@ -21,11 +21,11 @@ export { getClineOrgIndividualInferenceSubscriptionMessage };
 export const CLI_PROMO_CODE = "";
 
 export function getCliSubscriptionUrl(): string {
-	if(!CLI_PROMO_CODE) {
+	if (!CLI_PROMO_CODE) {
 		return new URL(
 			`/dashboard/subscription?personal=true`,
 			getClineEnvironmentConfig().appBaseUrl,
-		).toString()
+		).toString();
 	}
 
 	return `${new URL(

apps/cli/src/utils/events.test.ts

@@ -1,3 +1,5 @@
+import { readFileSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
 import type { AgentEvent, TeamEvent } from "@cline/core";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
@@ -118,6 +120,41 @@ describe("handleEvent text formatting", () => {
 		expect(output).toMatch(/\[run_commands\].*\n.*\[read_files\]/s);
 	});
 
+	it("saves generated images and prints an openable path", () => {
+		handleEvent(
+			{
+				type: "content_end",
+				contentType: "media",
+				media: {
+					id: "generated-1",
+					modality: "image",
+					mediaType: "image/png",
+					source: {
+						type: "base64",
+						data: Buffer.from("one-shot-image").toString("base64"),
+					},
+				},
+			} as AgentEvent,
+			{} as Config,
+		);
+
+		expect(output).toContain("[generated image]");
+		const suffix = "/generated.png";
+		const pathEnd = output.indexOf(suffix);
+		const pathStart = output.lastIndexOf(" ", pathEnd);
+		const path =
+			pathEnd >= 0 && pathStart >= 0
+				? output.slice(pathStart + 1, pathEnd + suffix.length)
+				: undefined;
+		expect(path).toBeDefined();
+		if (!path) throw new Error("Expected generated image path in CLI output");
+		try {
+			expect(readFileSync(path, "utf8")).toBe("one-shot-image");
+		} finally {
+			rmSync(dirname(path), { recursive: true, force: true });
+		}
+	});
+
 	it("does not echo ask_question through the generic tool renderer", () => {
 		handleEvent(
 			{

apps/cli/src/utils/events.ts

@@ -4,6 +4,7 @@ import {
 	parseCompactionNoticeMetadata,
 } from "../tui/utils/compaction-status";
 import { formatCliErrorMessage } from "./cline-pass-errors";
+import { materializeGeneratedMedia } from "./generated-media";
 import { formatToolInput, formatToolOutput, truncate } from "./helpers";
 import {
 	c,
@@ -184,6 +185,30 @@ export function handleEvent(event: AgentEvent, config: Config): void {
 					}
 					shouldPrefixNextTextWithBlankLine = false;
 					break;
+				case "media": {
+					closeInlineStreamIfNeeded();
+					const media = event.media;
+					if (!media) break;
+					const saved = materializeGeneratedMedia(media);
+					if (saved) {
+						write(
+							`${c.dim}[generated ${media.modality}]${c.reset} ${saved.path}\n`,
+						);
+					} else if (media.source.type === "url") {
+						write(
+							`${c.dim}[generated ${media.modality}]${c.reset} ${media.source.url}\n`,
+						);
+					} else if (media.source.type === "artifact") {
+						write(
+							`${c.dim}[generated ${media.modality}]${c.reset} artifact:${media.source.artifactId}\n`,
+						);
+					} else {
+						write(
+							`${c.dim}[generated ${media.modality}]${c.reset} ${media.mediaType} could not be saved\n`,
+						);
+					}
+					break;
+				}
 			}
 			break;
 

apps/cli/src/utils/generated-media.test.ts

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+	cleanupMaterializedGeneratedMedia,
+	materializeGeneratedMedia,
+} from "./generated-media";
+
+describe("materializeGeneratedMedia", () => {
+	afterEach(cleanupMaterializedGeneratedMedia);
+
+	it("writes decoded media data to a private temporary file", () => {
+		const saved = materializeGeneratedMedia({
+			id: "generated-1",
+			modality: "image",
+			mediaType: "image/png",
+			source: {
+				type: "base64",
+				data: Buffer.from("generated-image").toString("base64"),
+			},
+		});
+
+		expect(saved).toBeDefined();
+		if (!saved) throw new Error("Expected generated media to be saved");
+		expect(saved).toMatchObject({ mediaType: "image/png", byteLength: 15 });
+		expect(saved.path).toMatch(/generated\.png$/);
+		expect(readFileSync(saved.path, "utf8")).toBe("generated-image");
+	});
+
+	it("cleans up materialized media directories", () => {
+		const saved = materializeGeneratedMedia({
+			id: "generated-cleanup",
+			modality: "audio",
+			mediaType: "audio/mpeg",
+			source: { type: "base64", data: "SUQz" },
+		});
+
+		expect(saved).toBeDefined();
+		if (!saved) throw new Error("Expected generated media to be saved");
+		const directory = dirname(saved.path);
+		expect(existsSync(directory)).toBe(true);
+
+		cleanupMaterializedGeneratedMedia();
+
+		expect(existsSync(directory)).toBe(false);
+	});
+
+	it("rejects non-materializable payloads", () => {
+		expect(
+			materializeGeneratedMedia({
+				id: "generated-remote",
+				modality: "audio",
+				mediaType: "audio/mpeg",
+				source: { type: "url", url: "https://example.com/audio.mp3" },
+			}),
+		).toBeUndefined();
+	});
+});

apps/cli/src/utils/generated-media.ts

@@ -0,0 +1,81 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { GeneratedMedia } from "@cline/shared";
+
+export interface MaterializedGeneratedMedia {
+	path: string;
+	mediaType: string;
+	modality: GeneratedMedia["modality"];
+	byteLength: number;
+}
+
+const materializedMediaDirectories = new Set<string>();
+let exitCleanupRegistered = false;
+
+/** Remove temporary files created for terminal display. */
+export function cleanupMaterializedGeneratedMedia(): void {
+	for (const directory of materializedMediaDirectories) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+	materializedMediaDirectories.clear();
+}
+
+function trackMaterializedMediaDirectory(directory: string): void {
+	materializedMediaDirectories.add(directory);
+	if (exitCleanupRegistered) return;
+	exitCleanupRegistered = true;
+	process.once("exit", cleanupMaterializedGeneratedMedia);
+}
+
+const MEDIA_EXTENSIONS: Readonly<Record<string, string>> = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp",
+	"image/avif": "avif",
+	"image/svg+xml": "svg",
+	"audio/mpeg": "mp3",
+	"audio/wav": "wav",
+	"audio/ogg": "ogg",
+	"video/mp4": "mp4",
+	"video/webm": "webm",
+};
+
+/**
+ * Persist generated media where terminal users can open it with their usual
+ * local tools. Each item gets a private temporary directory so concurrent
+ * sessions cannot overwrite one another.
+ */
+export function materializeGeneratedMedia(
+	media: GeneratedMedia,
+): MaterializedGeneratedMedia | undefined {
+	const mediaType = media.mediaType.trim().toLowerCase();
+	if (media.source.type !== "base64" || media.source.data.length === 0) {
+		return undefined;
+	}
+
+	let directory: string | undefined;
+	try {
+		const bytes = Buffer.from(media.source.data, "base64");
+		if (bytes.byteLength === 0) {
+			return undefined;
+		}
+		directory = mkdtempSync(join(tmpdir(), "cline-generated-media-"));
+		const extension = MEDIA_EXTENSIONS[mediaType] ?? "bin";
+		const path = join(directory, `generated.${extension}`);
+		writeFileSync(path, bytes, { mode: 0o600 });
+		trackMaterializedMediaDirectory(directory);
+		return {
+			path,
+			mediaType,
+			modality: media.modality,
+			byteLength: bytes.byteLength,
+		};
+	} catch {
+		if (directory !== undefined) {
+			rmSync(directory, { recursive: true, force: true });
+		}
+		return undefined;
+	}
+}

apps/cli/src/utils/helpers.test.ts

@@ -10,6 +10,7 @@ import {
 	isCliHookPayload,
 	normalizeAutoApproveArgs,
 	parseArgs,
+	truncate,
 } from "./helpers";
 
 type EnvSnapshot = {
@@ -374,6 +375,73 @@ describe("format helpers", () => {
 		).toBe("first (+2 more)");
 		expect(formatToolOutput(null)).toBe("");
 	});
+
+	// Regression tests for https://github.com/cline/cline/issues/13036:
+	// malformed tool inputs crossing the model/tool boundary must never
+	// throw from display-only formatters.
+	it("does not crash on run_commands with a null command", () => {
+		expect(formatToolInput("run_commands", { command: null })).toBe("");
+	});
+
+	it("does not crash on run_commands with a non-string command", () => {
+		expect(formatToolInput("run_commands", { command: { nested: true } })).toBe(
+			'{"nested":true}',
+		);
+		expect(formatToolInput("run_commands", { commands: { command: 42 } })).toBe(
+			"42",
+		);
+	});
+
+	it("keeps valid empty-string args in structured command summaries", () => {
+		expect(
+			formatToolInput("run_commands", {
+				commands: [{ command: "grep", args: ["", "pattern", "file.txt"] }],
+			}),
+		).toBe("grep  pattern file.txt");
+		expect(
+			formatToolInput("run_commands", {
+				commands: [{ command: "git", args: [null, "status", undefined] }],
+			}),
+		).toBe("git status");
+	});
+
+	it("skips null entries in run_commands command arrays", () => {
+		expect(
+			formatToolInput("run_commands", { commands: [null, "echo hi"] }),
+		).toBe("echo hi");
+		expect(formatToolInput("run_commands", [undefined, "echo hi"])).toBe(
+			"echo hi",
+		);
+	});
+
+	it("does not crash on fetch_web_content with malformed requests", () => {
+		expect(
+			formatToolInput("fetch_web_content", {
+				requests: [null, { url: "https://example.com" }, { url: 42 }, "raw"],
+			}),
+		).toBe("https://example.com, 42");
+	});
+
+	it("falls back to an empty summary for unserializable inputs", () => {
+		const circular: Record<string, unknown> = {};
+		circular.self = circular;
+		expect(formatToolInput("unknown_tool", circular)).toBe("");
+		expect(formatToolOutput(circular)).toBe("");
+		expect(
+			formatToolInput("unknown_tool", {
+				toJSON() {
+					throw new Error("boom");
+				},
+			}),
+		).toBe("");
+	});
+
+	it("truncates non-string values without throwing", () => {
+		expect(truncate(null, 10)).toBe("");
+		expect(truncate(undefined, 10)).toBe("");
+		expect(truncate(42, 10)).toBe("42");
+		expect(truncate({ nested: true }, 60)).toBe('{"nested":true}');
+	});
 });
 
 describe("hook payload validation and audit logging", () => {

apps/cli/src/utils/helpers.ts

@@ -53,8 +53,38 @@ export function resolveWorkspaceRoot(cwd: string): string {
 	return cwd;
 }
 
-export function truncate(str: string, maxLen: number): string {
-	const oneLine = str.replace(/\n/g, " ").trim();
+function safeJsonStringify(value: unknown): string {
+	try {
+		return JSON.stringify(value) ?? "";
+	} catch {
+		return "";
+	}
+}
+
+/**
+ * Normalizes an untrusted runtime value into a display string without ever
+ * throwing. Tool inputs/outputs cross the model/tool boundary, so they may
+ * not match their TypeScript annotations (e.g. `{ command: null }`).
+ */
+export function toDisplayString(value: unknown): string {
+	if (typeof value === "string") {
+		return value;
+	}
+	if (value === null || value === undefined) {
+		return "";
+	}
+	if (typeof value === "object") {
+		return safeJsonStringify(value);
+	}
+	try {
+		return String(value);
+	} catch {
+		return "";
+	}
+}
+
+export function truncate(value: unknown, maxLen: number): string {
+	const oneLine = toDisplayString(value).replace(/\n/g, " ").trim();
 	if (oneLine.length <= maxLen) {
 		return oneLine;
 	}
@@ -66,14 +96,21 @@ export function formatStructuredCommand(cmd: unknown): string {
 		return cmd;
 	}
 	if (cmd && typeof cmd === "object" && "command" in cmd) {
-		const structured = cmd as { command: string; args?: unknown };
-		const args = Array.isArray(structured.args) ? structured.args : [];
+		const structured = cmd as { command?: unknown; args?: unknown };
+		const command = toDisplayString(structured.command);
+		// Drop only nullish entries: they carry no display value, while an
+		// empty string is a valid argv entry that must stay in the summary.
+		const args = Array.isArray(structured.args)
+			? structured.args
+					.filter((arg) => arg !== null && arg !== undefined)
+					.map(toDisplayString)
+			: [];
 		if (args.length === 0) {
-			return structured.command;
+			return command;
 		}
-		return `${structured.command} ${args.join(" ")}`;
+		return `${command} ${args.join(" ")}`;
 	}
-	return String(cmd);
+	return toDisplayString(cmd);
 }
 
 function summarizeRunCommandsInput(input: unknown): string {
@@ -82,14 +119,17 @@ function summarizeRunCommandsInput(input: unknown): string {
 	}
 
 	if (Array.isArray(input)) {
-		return input.map(formatStructuredCommand).join("; ");
+		return input.map(formatStructuredCommand).filter(Boolean).join("; ");
 	}
 
 	if (input && typeof input === "object") {
 		const obj = input as Record<string, unknown>;
 		if (obj.commands !== undefined) {
 			if (Array.isArray(obj.commands)) {
-				return obj.commands.map(formatStructuredCommand).join("; ");
+				return obj.commands
+					.map(formatStructuredCommand)
+					.filter(Boolean)
+					.join("; ");
 			}
 			return formatStructuredCommand(obj.commands);
 		}
@@ -157,7 +197,11 @@ export function formatToolInput(toolName: string, input: unknown): string {
 			if (Array.isArray(obj.requests)) {
 				return truncate(
 					obj.requests
-						.map((r) => r.url)
+						.map((r) =>
+							r && typeof r === "object" && "url" in r
+								? toDisplayString((r as { url?: unknown }).url)
+								: "",
+						)
 						.filter(Boolean)
 						.join(", "),
 					120,
@@ -286,7 +330,7 @@ export function formatToolInput(toolName: string, input: unknown): string {
 			return "list";
 	}
 
-	return truncate(JSON.stringify(input), 60);
+	return truncate(input, 60);
 }
 
 export function formatToolOutput(output: unknown): string {
@@ -330,10 +374,10 @@ export function formatToolOutput(output: unknown): string {
 								)
 								.filter(Boolean)
 								.join(" ") || "Successfully read image"
-						: String(result ?? "");
+						: toDisplayString(result);
 					return truncate(resultStr, 80);
 				}
-				return truncate(JSON.stringify(item), 80);
+				return truncate(item, 80);
 			})
 			.filter((s) => s.length > 0);
 
@@ -346,7 +390,7 @@ export function formatToolOutput(output: unknown): string {
 		return `${results[0]} (+${results.length - 1} more)`;
 	}
 
-	return truncate(JSON.stringify(output), 100);
+	return truncate(output, 100);
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

apps/cli/src/utils/resume.ts

@@ -1,10 +1,10 @@
 import type { ClineCore } from "@cline/core";
-import type { Message } from "@cline/shared";
+import type { MessageWithMetadata } from "@cline/shared";
 
 export async function loadInteractiveResumeMessages(
 	sessionManager: ClineCore,
 	resumeSessionId?: string,
-): Promise<Message[] | undefined> {
+): Promise<MessageWithMetadata[] | undefined> {
 	const target = resumeSessionId?.trim();
 	if (!target) {
 		return undefined;

apps/cli/src/wizards/mcp/index.ts

@@ -8,6 +8,7 @@ import {
 	type McpServerEntry,
 	type McpTransport,
 	removeServer,
+	setServerOAuthClient,
 	toggleServer,
 	updateServer,
 } from "./settings";
@@ -49,6 +50,7 @@ type RemoteAuthMode = "none" | "headers" | "oauth";
 interface UrlServerConfig {
 	transport: McpTransport;
 	authMode: RemoteAuthMode;
+	oauthClient?: { clientId: string; clientSecret?: string };
 }
 
 export interface McpAddDefaults {
@@ -196,7 +198,29 @@ async function collectUrlTransport(
 	});
 	if (isCancel(authMode)) return null;
 
-	if (authMode === "oauth" || authMode === "none") {
+	if (authMode === "oauth") {
+		const clientId = await p.text({
+			message: "OAuth client ID (leave empty for dynamic registration)",
+		});
+		if (isCancel(clientId)) return null;
+		const normalizedClientId = (clientId as string).trim();
+		let clientSecret: string | undefined;
+		if (normalizedClientId) {
+			const secret = await p.password({
+				message: "OAuth client secret (leave empty for public clients)",
+			});
+			if (isCancel(secret)) return null;
+			clientSecret = (secret as string).trim() || undefined;
+		}
+		return {
+			transport: { type, url: (url as string).trim() },
+			authMode,
+			oauthClient: normalizedClientId
+				? { clientId: normalizedClientId, clientSecret }
+				: undefined,
+		};
+	}
+	if (authMode === "none") {
 		return {
 			transport: { type, url: (url as string).trim() },
 			authMode,
@@ -270,6 +294,7 @@ async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
 
 	let transport: McpTransport | null;
 	let authMode: RemoteAuthMode = "none";
+	let oauthClient: UrlServerConfig["oauthClient"];
 	if (type === "stdio") {
 		transport = await collectStdioTransport(defaults?.command);
 	} else {
@@ -279,6 +304,7 @@ async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
 		);
 		transport = config?.transport ?? null;
 		authMode = config?.authMode ?? "none";
+		oauthClient = config?.oauthClient;
 	}
 	if (!transport) return;
 
@@ -286,6 +312,8 @@ async function actionAdd(defaults?: McpAddDefaults): Promise<void> {
 	addServer(serverName, transport);
 	if (authMode !== "oauth") {
 		clearServerOAuth(serverName);
+	} else {
+		setServerOAuthClient(serverName, oauthClient);
 	}
 	p.log.success(`Added "${serverName}" to ${getSettingsPath()}`);
 	if (authMode === "oauth") {
@@ -374,18 +402,22 @@ async function actionEdit(): Promise<void> {
 
 	let transport: McpTransport | null;
 	let authMode: RemoteAuthMode = "none";
+	let oauthClient: UrlServerConfig["oauthClient"];
 	if (type === "stdio") {
 		transport = await collectStdioTransport();
 	} else {
 		const config = await collectUrlTransport(type as "sse" | "streamableHttp");
 		transport = config?.transport ?? null;
 		authMode = config?.authMode ?? "none";
+		oauthClient = config?.oauthClient;
 	}
 	if (!transport) return;
 
 	updateServer(name, transport);
 	if (type === "stdio" || authMode !== "oauth") {
 		clearServerOAuth(name);
+	} else {
+		setServerOAuthClient(name, oauthClient);
 	}
 	p.log.success(`Updated "${name}"`);
 	if (authMode === "oauth") {

apps/cli/src/wizards/mcp/settings.test.ts

@@ -8,6 +8,7 @@ import {
 	clearServerOAuth,
 	loadServers,
 	removeServer,
+	setServerOAuthClient,
 } from "./settings";
 
 describe("MCP wizard settings", () => {
@@ -139,4 +140,35 @@ describe("MCP wizard settings", () => {
 
 		await expect(readFile(settingsPath, "utf8")).resolves.toBe(before);
 	});
+
+	it("clears OAuth state when the configured client changes", async () => {
+		const settingsPath = await useTempSettingsPath();
+		await writeFile(
+			settingsPath,
+			JSON.stringify({
+				mcpServers: {
+					github: {
+						transport: {
+							type: "streamableHttp",
+							url: "https://api.githubcopilot.com/mcp/",
+						},
+						oauthClient: { clientId: "old-client", clientSecret: "old-secret" },
+						oauth: { tokens: { access_token: "old-token" } },
+					},
+				},
+			}),
+		);
+
+		setServerOAuthClient("github", {
+			clientId: "new-client",
+			clientSecret: "new-secret",
+		});
+
+		const [github] = loadServers();
+		expect(github?.oauth).toBeUndefined();
+		expect(github?.oauthClient).toEqual({
+			clientId: "new-client",
+			clientSecret: "new-secret",
+		});
+	});
 });

apps/cli/src/wizards/mcp/settings.ts

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import {
+	type McpServerOAuthClientConfig,
 	type McpServerOAuthState,
 	McpSettingsUpdateSkippedError,
 	resolveDefaultMcpSettingsPath,
@@ -10,6 +11,7 @@ export interface McpServerEntry {
 	name: string;
 	transport: McpTransport;
 	disabled?: boolean;
+	oauthClient?: McpServerOAuthClientConfig;
 	oauth?: McpServerOAuthState;
 }
 
@@ -49,6 +51,9 @@ export function loadServers(): McpServerEntry[] {
 				name,
 				transport,
 				disabled: entry.disabled === true,
+				oauthClient: entry.oauthClient as
+					| McpServerOAuthClientConfig
+					| undefined,
 				oauth,
 			};
 		});
@@ -138,6 +143,7 @@ export function clearServerOAuth(name: string): void {
 				);
 			}
 			delete existing.oauth;
+			delete existing.oauthClient;
 			servers[name] = existing;
 		});
 	} catch (error) {
@@ -148,6 +154,29 @@ export function clearServerOAuth(name: string): void {
 	}
 }
 
+export function setServerOAuthClient(
+	name: string,
+	client: McpServerOAuthClientConfig | undefined,
+): void {
+	mutateServers((servers) => {
+		const existing = getOwnServerRecord(servers, name);
+		if (!existing)
+			throw new McpSettingsUpdateSkippedError(`MCP server not found: ${name}`);
+		const previous = existing.oauthClient as
+			| McpServerOAuthClientConfig
+			| undefined;
+		if (
+			previous?.clientId !== client?.clientId ||
+			previous?.clientSecret !== client?.clientSecret
+		) {
+			delete existing.oauth;
+		}
+		if (client) existing.oauthClient = client;
+		else delete existing.oauthClient;
+		servers[name] = existing;
+	});
+}
+
 export function toggleServer(name: string, disabled: boolean): void {
 	mutateServers((servers) => {
 		const existing =

apps/cli/src/wizards/schedule/index.ts

@@ -1,10 +1,10 @@
 import * as p from "@clack/prompts";
-import { CLINE_DEFAULT_MODEL_ID } from "@cline/shared";
 import {
 	ensureSchedulerHub,
 	type HubScheduleClient,
 } from "../../commands/schedule/client";
 import { resolveAddress } from "../../commands/schedule/common";
+import { resolveScheduleModelSelection } from "../../commands/schedule/model-selection";
 import { CRON_PRESETS } from "./cron-presets";
 
 function isCancel(value: unknown): value is symbol {
@@ -211,12 +211,13 @@ async function actionCreate(client: HubScheduleClient): Promise<void> {
 		}
 	}
 
+	const modelSelection = resolveScheduleModelSelection({ provider, model });
 	const created = (await client.createSchedule({
 		name: (name as string).trim(),
 		cronPattern,
 		prompt: (prompt as string).trim(),
-		provider: provider ?? "cline",
-		model: model ?? CLINE_DEFAULT_MODEL_ID,
+		provider: modelSelection.provider,
+		model: modelSelection.model,
 		mode: mode as "act" | "plan" | "yolo",
 		workspaceRoot: (workspace as string).trim(),
 		systemPrompt,

apps/cli/vitest.config.ts

@@ -50,6 +50,7 @@ export default defineConfig({
 	},
 	test: {
 		environment: "node",
+		setupFiles: ["./vitest.setup.ts"],
 		include: ["src/**/*.test.ts"],
 		exclude: ["src/**/*.e2e.test.ts", "src/tests/**"],
 		// Default 5s is tight on CI: each test uses `resetModules()` + dynamic `import("./main")`

apps/cli/vitest.setup.ts

@@ -0,0 +1,15 @@
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Unit tests (and any subprocess they spawn, via env inheritance) must never
+// touch the developer's real ~/.cline: a test that reaches core startup can
+// otherwise spawn a real hub daemon against the real discovery record, or
+// trigger a real background auto-update. Point everything at a per-worker
+// temp dir before any test file is imported. Tests that need specific paths
+// still override these per-test.
+const isolatedRoot = mkdtempSync(join(tmpdir(), "cline-cli-vitest-"));
+process.env.CLINE_DIR = join(isolatedRoot, ".cline");
+process.env.CLINE_DATA_DIR = join(isolatedRoot, "data");
+process.env.CLINE_HUB_DISCOVERY_PATH = join(isolatedRoot, "hub-discovery.json");
+process.env.CLINE_NO_AUTO_UPDATE = "1";

apps/cline-hub/src/server/agent-events.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CoreSessionEvent } from "@cline/core";
+import type { HubContext } from "./state";
+
+// agent-events.ts only needs these siblings at runtime; mocking them keeps the
+// test from loading @cline/core (state-payloads imports it at module scope),
+// whose transitive provider deps do not survive vitest's module interop.
+vi.mock("./approvals", () => ({ rejectPendingApprovalsForSession: vi.fn() }));
+vi.mock("./state-payloads", () => ({ broadcastHubState: vi.fn() }));
+
+import { handleSessionEvent } from "./agent-events";
+
+function makeContextWithPeer(sessionId: string): {
+	ctx: HubContext;
+	sent: unknown[];
+} {
+	const sent: unknown[] = [];
+	const ctx = {
+		peers: new Set([{ selectedSessionId: sessionId }]),
+		sessions: new Map(),
+		send: (_peer: unknown, payload: unknown) => sent.push(payload),
+		sendToSelectedPeers(id: string, payload: unknown) {
+			if (id === sessionId) sent.push(payload);
+		},
+	} as unknown as HubContext;
+	return { ctx, sent };
+}
+
+function agentErrorEvent(
+	sessionId: string,
+	recoverable: boolean,
+): CoreSessionEvent {
+	return {
+		type: "agent_event",
+		payload: {
+			sessionId,
+			event: {
+				type: "error",
+				error: new Error(
+					"1 tool call(s) failed: [run_commands] Command not executed",
+				),
+				recoverable,
+				iteration: 1,
+			},
+		},
+	};
+}
+
+describe("handleSessionEvent — agent error events", () => {
+	it("forwards recoverable errors flagged as in-run notices, not turn outcomes", () => {
+		const { ctx, sent } = makeContextWithPeer("session-1");
+
+		handleSessionEvent(ctx, agentErrorEvent("session-1", true));
+
+		expect(sent).toEqual([
+			{
+				type: "error",
+				text: "1 tool call(s) failed: [run_commands] Command not executed",
+				recoverable: true,
+			},
+		]);
+	});
+
+	it("forwards non-recoverable errors unflagged", () => {
+		const { ctx, sent } = makeContextWithPeer("session-1");
+
+		handleSessionEvent(ctx, agentErrorEvent("session-1", false));
+
+		expect(sent).toEqual([
+			{
+				type: "error",
+				text: "1 tool call(s) failed: [run_commands] Command not executed",
+				recoverable: false,
+			},
+		]);
+	});
+});

apps/cline-hub/src/server/agent-events.ts

@@ -94,6 +94,13 @@ function forwardAgentEvent(
 					error: event.error,
 				},
 			});
+			return;
+		}
+		if (event.contentType === "media" && event.media) {
+			ctx.sendToSelectedPeers(sessionId, {
+				type: "assistant_media",
+				media: event.media,
+			});
 		}
 		return;
 	}
@@ -119,9 +126,16 @@ function forwardAgentEvent(
 		return;
 	}
 	if (event.type === "error") {
+		// Forwarded with the recoverable flag intact: recoverable errors are
+		// in-run notices (the MistakeTracker emits one per recorded mistake,
+		// e.g. a plan-mode guard-blocked run_commands call) and the run keeps
+		// going, so it is up to each peer to decide how to render them — the
+		// turn's outcome is decided by how it actually ends (turn_done /
+		// non-recoverable error).
 		ctx.sendToSelectedPeers(sessionId, {
 			type: "error",
 			text: event.error.message,
+			recoverable: event.recoverable,
 		});
 	}
 }

apps/cline-hub/src/server/deps.ts

@@ -1,6 +1,6 @@
 import { dirname, join, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
-import { ProviderSettingsManager } from "@cline/core";
+import { ClientSettingsManager, ProviderSettingsManager } from "@cline/core";
 import { buildInviteUrl, resolveClineHubServerOptions } from "../options";
 import type { BrowserConfig } from "./types";
 
@@ -19,6 +19,12 @@ export const cliIndexPath = normalize(
 );
 
 export const providerSettingsManager = new ProviderSettingsManager();
+export const desktopClientSettingsManager = new ClientSettingsManager({
+	clientId: "desktop",
+});
+desktopClientSettingsManager.initializeModesIfMissing(
+	providerSettingsManager.read().modes,
+);
 
 export const browserConfig: BrowserConfig = {
 	inviteRequired: Boolean(roomSecret),

apps/cline-hub/src/server/desktop-commands.ts

@@ -17,22 +17,25 @@ import {
 	type ProviderClient,
 	type ProviderProtocol,
 	type ProviderSettings,
+	parseProviderModeSettings,
 	readGlobalSettings,
 	saveLocalProviderOAuthCredentials,
 	saveLocalProviderSettings,
+	saveModeSettings,
 	setAutoUpdateEnabledGlobally,
-	setDisabledPlugin,
-	setDisabledTools,
 	setTelemetryOptOutGlobally,
-	toggleDisabledTool,
 } from "@cline/core";
-import { getClineEnvironmentConfig } from "@cline/shared";
+import { getClineEnvironmentConfig, ProviderModeSchema } from "@cline/shared";
 import {
 	connectorChannelsPayload,
 	startConnectorChannel,
 	stopConnectorChannel,
 } from "./connectors";
-import { providerSettingsManager, workspaceRoot } from "./deps";
+import {
+	desktopClientSettingsManager,
+	providerSettingsManager,
+	workspaceRoot,
+} from "./deps";
 import {
 	installMarketplaceEntryForDesktopCommand,
 	listMarketplaceInstalledEntries,
@@ -106,6 +109,7 @@ export async function handleDesktopCommand(
 		await ensureCustomProvidersLoaded(providerSettingsManager);
 		return await listLocalProviders(providerSettingsManager, {
 			isClinePassEnabled: true,
+			modeSettings: desktopClientSettingsManager.read().modes,
 		});
 	}
 	if (command === "list_provider_models") {
@@ -115,6 +119,18 @@ export async function handleDesktopCommand(
 			providerSettingsManager.getProviderConfig(provider),
 		);
 	}
+	if (command === "save_mode_settings") {
+		const mode = ProviderModeSchema.parse(args?.mode);
+		const settings =
+			args?.settings == null
+				? undefined
+				: parseProviderModeSettings(mode, args.settings);
+		return await saveModeSettings(
+			providerSettingsManager,
+			{ mode, settings },
+			desktopClientSettingsManager,
+		);
+	}
 	if (command === "save_provider_settings") {
 		return saveLocalProviderSettings(providerSettingsManager, {
 			...readProviderSettingsUpdate(args),
@@ -297,7 +313,13 @@ export async function handleDesktopCommand(
 	if (command === "toggle_disabled_plugin_tool") {
 		const toolName = String(args?.name ?? "").trim();
 		if (!toolName) throw new Error("tool name is required");
-		toggleDisabledTool(toolName);
+		if (!ctx.uiClient) throw new Error("Hub settings client is not connected");
+		await ctx.uiClient.toggleSetting({
+			type: "tools",
+			name: toolName,
+			workspaceRoot,
+			cwd: workspaceRoot,
+		});
 		return await listUserInstructionConfigs(workspaceRoot);
 	}
 	if (command === "set_tool_disabled") {
@@ -306,13 +328,30 @@ export async function handleDesktopCommand(
 			.map((name) => String(name ?? "").trim())
 			.filter(Boolean);
 		if (toolNames.length === 0) throw new Error("tool name is required");
-		setDisabledTools(toolNames, args?.disabled === true);
+		for (const name of toolNames) {
+			if (!ctx.uiClient)
+				throw new Error("Hub settings client is not connected");
+			await ctx.uiClient.toggleSetting({
+				type: "tools",
+				name,
+				enabled: args?.disabled !== true,
+				workspaceRoot,
+				cwd: workspaceRoot,
+			});
+		}
 		return await listUserInstructionConfigs(workspaceRoot);
 	}
 	if (command === "set_plugin_disabled") {
 		const pluginPath = String(args?.path ?? "").trim();
 		if (!pluginPath) throw new Error("plugin path is required");
-		setDisabledPlugin(pluginPath, args?.disabled === true);
+		if (!ctx.uiClient) throw new Error("Hub settings client is not connected");
+		await ctx.uiClient.toggleSetting({
+			type: "plugins",
+			path: pluginPath,
+			enabled: args?.disabled !== true,
+			workspaceRoot,
+			cwd: workspaceRoot,
+		});
 		return await listUserInstructionConfigs(workspaceRoot);
 	}
 	throw new Error(`unsupported desktop command: ${command}`);

apps/cline-hub/src/server/providers.ts

@@ -2,6 +2,7 @@ import process from "node:process";
 import {
 	ensureCustomProvidersLoaded,
 	getLocalProviderModels,
+	isChatProviderModel,
 	Llms,
 	listLocalProviders,
 	loginAndSaveLocalProviderOAuthCredentials,
@@ -86,12 +87,16 @@ export async function loadModels(
 		provider,
 		providerSettingsManager.getProviderConfig(provider),
 	);
-	const models: WebviewProviderModel[] = payload.models.map((model) => ({
-		id: model.id,
-		name: model.name,
-		supportsReasoning: model.supportsReasoning,
-		supportsThinking: model.supportsReasoning,
-	}));
+	const models: WebviewProviderModel[] = payload.models
+		.filter(isChatProviderModel)
+		.map((model) => ({
+			id: model.id,
+			name: model.name,
+			supportsReasoning: model.supportsReasoning,
+			supportsThinking: model.supportsReasoning,
+			inputModalities: model.inputModalities,
+			outputModalities: model.outputModalities,
+		}));
 	ctx.send(peer, { type: "models", providerId: provider, models });
 }
 

apps/cline-hub/src/server/session-mapping.test.ts

@@ -2,6 +2,10 @@ import { describe, expect, it } from "vitest";
 import { mapHistoryToWebviewMessages } from "./session-mapping";
 
 describe("mapHistoryToWebviewMessages", () => {
+	it("preserves tolerant handling of malformed history entries", () => {
+		expect(() => mapHistoryToWebviewMessages([null, 42])).not.toThrow();
+	});
+
 	it("hydrates assistant tool uses with following user tool results", () => {
 		const messages = mapHistoryToWebviewMessages([
 			{
@@ -228,4 +232,79 @@ describe("mapHistoryToWebviewMessages", () => {
 			},
 		});
 	});
+
+	it("hydrates provider model activities through ordinary tool events", () => {
+		const messages = mapHistoryToWebviewMessages([
+			{
+				id: "assistant-search",
+				role: "assistant",
+				content: "Bun 1.3.14 is current.",
+				metadata: {
+					modelToolActivities: [
+						{
+							toolCallId: "search-1",
+							toolName: "web_search",
+							execution: "provider",
+							input: { query: "latest Bun release" },
+							output: { answer: "1.3.14" },
+						},
+					],
+				},
+			},
+		]);
+
+		expect(messages).toHaveLength(2);
+		expect(messages[0]).toMatchObject({
+			role: "assistant",
+			toolEvents: [
+				{
+					toolCallId: "search-1",
+					name: "web_search",
+					state: "output-available",
+					input: { query: "latest Bun release" },
+					output: '{"answer":"1.3.14"}',
+				},
+			],
+		});
+		expect(messages[1]).toMatchObject({
+			id: "assistant-search",
+			role: "assistant",
+			text: "Bun 1.3.14 is current.",
+		});
+	});
+
+	it("keeps id-less history row ids stable as a provider result completes", () => {
+		const source = {
+			role: "assistant",
+			content: "Bun 1.3.14 is current.",
+			metadata: {
+				modelToolActivities: [
+					{
+						toolCallId: "search-1",
+						toolName: "web_search",
+						execution: "provider",
+						input: { query: "latest Bun release" },
+					},
+				],
+			},
+		};
+
+		const pending = mapHistoryToWebviewMessages([source]);
+		const completed = mapHistoryToWebviewMessages([
+			{
+				...source,
+				metadata: {
+					modelToolActivities: [
+						{
+							...source.metadata.modelToolActivities[0],
+							output: "1.3.14",
+						},
+					],
+				},
+			},
+		]);
+
+		expect(pending.at(-1)?.id).toBe("history-0");
+		expect(completed.at(-1)?.id).toBe("history-0");
+	});
 });

apps/cline-hub/src/server/session-mapping.ts

@@ -1,4 +1,10 @@
-import { formatDisplayUserInput } from "@cline/shared";
+import { projectSessionMessagesForDisplay } from "@cline/core";
+import {
+	formatDisplayUserInput,
+	isGeneratedMedia,
+	type MessageWithMetadata,
+	validateImageMedia,
+} from "@cline/shared";
 import type {
 	WebviewActionSessionSummary,
 	WebviewChatMessage,
@@ -193,13 +199,17 @@ export function mapHistoryToWebviewMessages(
 ): WebviewChatMessage[] {
 	const mapped: WebviewChatMessage[] = [];
 	const toolLocations = new Map<string, HistoryToolLocation>();
+	const displayHistory = projectSessionMessagesForDisplay(
+		history as MessageWithMetadata[],
+	);
 
-	for (const [index, entry] of history.entries()) {
+	for (const entry of displayHistory) {
+		const { message, sourceIndex } = entry;
 		const record =
-			entry && typeof entry === "object"
-				? (entry as Record<string, unknown>)
-				: { content: entry };
-		const messageKey = asString(record.id) ?? `history-${index}`;
+			message && typeof message === "object"
+				? (message as unknown as Record<string, unknown>)
+				: { content: message };
+		const messageKey = asString(record.id) ?? `history-${sourceIndex}`;
 		const rawRole = asString(record.role)?.toLowerCase();
 		let role: WebviewChatMessage["role"] =
 			rawRole === "user" || rawRole === "assistant" || rawRole === "error"
@@ -240,6 +250,35 @@ export function mapHistoryToWebviewMessages(
 				continue;
 			}
 
+			if (type === "image") {
+				const validation = validateImageMedia(
+					asString(part.mediaType),
+					asString(part.data) ?? "",
+				);
+				if (validation.ok) {
+					blocks.push({
+						id: `${messageKey}:media:${partIndex}`,
+						type: "media",
+						media: {
+							id: `${messageKey}:media:${partIndex}`,
+							modality: "image",
+							mediaType: validation.mediaType,
+							source: { type: "base64", data: validation.base64 },
+						},
+					});
+				}
+				continue;
+			}
+
+			if (type === "media" && isGeneratedMedia(part.media)) {
+				blocks.push({
+					id: `${messageKey}:media:${partIndex}`,
+					type: "media",
+					media: part.media,
+				});
+				continue;
+			}
+
 			if (type === "thinking" || type === "reasoning") {
 				reasoningRedacted =
 					pushReasoningBlock(
@@ -363,7 +402,7 @@ export function mapHistoryToWebviewMessages(
 
 		const text = textParts.join("\n");
 		const toolEventList = [...toolEvents.values()];
-		if (!text && reasoningParts.length === 0 && toolEventList.length === 0) {
+		if (blocks.length === 0) {
 			continue;
 		}
 		if (!text && role === "user" && toolEventList.length > 0) {

apps/cline-hub/src/server/sessions.ts

@@ -4,7 +4,7 @@ import {
 	type SessionRecord,
 	SessionSource,
 } from "@cline/core";
-import type { Message } from "@cline/llms";
+import type { MessageWithMetadata } from "@cline/llms";
 import type { WebviewConfig, WebviewReasonLevel } from "../webview-protocol";
 import { rejectPendingApprovalsForSession } from "./approvals";
 import { providerSettingsManager, workspaceRoot } from "./deps";
@@ -89,7 +89,7 @@ function buildSessionStartInput(
 		teamName?: string;
 		source?: SessionSource;
 		sessionMetadata?: Record<string, unknown>;
-		initialMessages?: Message[];
+		initialMessages?: MessageWithMetadata[];
 	},
 ): ClineCoreStartInput {
 	const mode = options?.mode === "plan" ? "plan" : "act";
@@ -137,7 +137,7 @@ function buildStartInputFromSession(
 	session: SessionRecord,
 	options?: {
 		sessionMetadata?: Record<string, unknown>;
-		initialMessages?: Message[];
+		initialMessages?: MessageWithMetadata[];
 	},
 ) {
 	const metadata =
@@ -348,7 +348,7 @@ export async function forkPeerSession(
 	try {
 		const rawMessages = (await ctx.cline.readMessages(
 			forkedFromSessionId,
-		)) as Message[];
+		)) as MessageWithMetadata[];
 		if (rawMessages.length === 0) {
 			ctx.send(peer, {
 				type: "fork_error",

apps/cline-hub/src/server/user-instructions.ts

@@ -1,14 +1,11 @@
 import { existsSync, readdirSync } from "node:fs";
 import { extname, join, basename as pathBasename } from "node:path";
 import {
+	createCoreSettingsService,
 	createUserInstructionConfigService,
-	discoverPluginModulePaths,
 	getCoreBuiltinToolCatalog,
-	getPluginDisplayName,
 	listHookConfigFiles,
-	listPluginTools,
 	readGlobalSettings,
-	resolvePluginConfigSearchPaths,
 	resolveAgentConfigSearchPaths as resolveSharedAgentConfigSearchPaths,
 } from "@cline/core";
 import { readFileSyncStrippingUtf8Bom } from "@cline/shared/node";
@@ -99,49 +96,21 @@ export async function listUserInstructionConfigs(
 		}
 	};
 
-	const loadPlugins = (): Array<{
-		name: string;
-		path: string;
-		enabled: boolean;
-	}> => {
-		const disabledPlugins = new Set(readGlobalSettings().disabledPlugins ?? []);
-		const pluginsByPath = new Map<
-			string,
-			{ name: string; path: string; enabled: boolean }
-		>();
-		const directories = resolvePluginConfigSearchPaths(
-			targetWorkspaceRoot,
-		).filter((d) => existsSync(d));
-		for (const directory of directories) {
-			try {
-				for (const filePath of discoverPluginModulePaths(directory)) {
-					if (pluginsByPath.has(filePath)) continue;
-					pluginsByPath.set(filePath, {
-						name: getPluginDisplayName(filePath, directory),
-						path: filePath,
-						enabled: !disabledPlugins.has(filePath),
-					});
-				}
-			} catch {
-				// best-effort
-			}
-		}
-		return [...pluginsByPath.values()].sort((a, b) =>
-			a.name.localeCompare(b.name),
-		);
-	};
-
-	const [rules, workflows, skills, pluginTools] = await Promise.all([
+	const [rules, workflows, skills, settingsSnapshot] = await Promise.all([
 		loadUserInstructionSnapshot("rule"),
 		loadUserInstructionSnapshot("workflow"),
 		loadUserInstructionSnapshot("skill"),
-		listPluginTools({
-			workspacePath: targetWorkspaceRoot,
+		createCoreSettingsService().list({
+			workspaceRoot: targetWorkspaceRoot,
 			cwd: targetWorkspaceRoot,
 		}),
 	]);
 	const disabledTools = new Set(readGlobalSettings().disabledTools ?? []);
+	// Pin spawn/teams availability so this listing matches the desktop
+	// sidecar's (sidecar/commands.ts) even if the preset defaults change.
 	const builtinToolCatalog = getCoreBuiltinToolCatalog({
+		enableSpawnAgent: true,
+		enableAgentTeams: true,
 		disabledToolIds: disabledTools,
 	});
 
@@ -151,7 +120,12 @@ export async function listUserInstructionConfigs(
 		workflows,
 		skills,
 		agents: loadAgents(),
-		plugins: loadPlugins(),
+		plugins: settingsSnapshot.plugins.map((plugin) => ({
+			name: plugin.name,
+			path: plugin.path,
+			enabled: plugin.enabled !== false,
+			contributions: plugin.contributions,
+		})),
 		tools: [
 			...builtinToolCatalog.map((tool) => ({
 				id: tool.id,
@@ -163,11 +137,11 @@ export async function listUserInstructionConfigs(
 				source: "builtin",
 				headlessToolNames: tool.headlessToolNames,
 			})),
-			...pluginTools.map((tool) => ({
-				id: `${tool.pluginName}:${tool.name}:${tool.path}`,
+			...settingsSnapshot.tools.map((tool) => ({
+				id: tool.id,
 				name: tool.name,
 				description: tool.description,
-				enabled: tool.enabled,
+				enabled: tool.enabled !== false,
 				source: tool.source,
 				path: tool.path,
 				pluginName: tool.pluginName,

apps/cline-hub/src/webview-protocol.ts

@@ -3,6 +3,7 @@ import type {
 	ProviderListItem,
 	ProviderModel,
 } from "@cline/core";
+import type { GeneratedMedia } from "@cline/shared";
 
 export type WebviewUsage = {
 	inputTokens?: number;
@@ -14,7 +15,7 @@ export type WebviewUsage = {
 
 export type WebviewProviderModel = Pick<
 	ProviderModel,
-	"id" | "name" | "supportsReasoning"
+	"id" | "name" | "supportsReasoning" | "inputModalities" | "outputModalities"
 > & {
 	supportsThinking?: boolean;
 };
@@ -35,6 +36,7 @@ export type WebviewToolEvent = {
 export type WebviewChatMessageBlock =
 	| { id: string; type: "text"; text: string }
 	| { id: string; type: "reasoning"; text: string; redacted?: boolean }
+	| { id: string; type: "media"; media: GeneratedMedia }
 	| {
 			id: string;
 			type: "tool";
@@ -272,7 +274,13 @@ export type WebviewInboundMessage =
 
 export type WebviewOutboundMessage =
 	| { type: "status"; text: string }
-	| { type: "error"; text: string }
+	/**
+	 * `recoverable: true` marks an in-run notice (e.g. a MistakeTracker
+	 * mistake such as a plan-mode guard-blocked command) — the run continues,
+	 * so peers should not treat it as the turn's outcome. Absent/false means
+	 * a genuine failure.
+	 */
+	| { type: "error"; text: string; recoverable?: boolean }
 	| {
 			type: "desktopCommandResult";
 			id: string;
@@ -296,6 +304,7 @@ export type WebviewOutboundMessage =
 	  }
 	| { type: "assistant_delta"; text: string }
 	| { type: "reasoning_delta"; text: string; redacted?: boolean }
+	| { type: "assistant_media"; media: GeneratedMedia }
 	| { type: "tool_event"; text: string; event?: WebviewToolEvent }
 	| ({ type: "approval_request" } & WebviewToolApprovalRequest)
 	| {

apps/cline-hub/src/webview/package.json

@@ -9,9 +9,11 @@
 		"preview": "vite preview"
 	},
 	"dependencies": {
+		"@cline/ui": "workspace:*",
 		"@base-ui/react": "^1.3.0",
 		"@cline/shared": "workspace:*",
-		"@fontsource-variable/schibsted-grotesk": "^5.2.8",
+		"@fontsource-variable/geist-mono": "^5.2.8",
+		"@fontsource-variable/inter": "^5.2.8",
 		"@radix-ui/react-use-controllable-state": "^1.2.2",
 		"@rive-app/react-webgl2": "^4.27.2",
 		"@shikijs/langs": "^4.2.0",
@@ -19,7 +21,7 @@
 		"@streamdown/cjk": "^1.0.3",
 		"@tailwindcss/vite": "^4.2.1",
 		"@xyflow/react": "^12.10.1",
-		"ai": "^7",
+		"ai": "^7.0.58",
 		"ansi-to-react": "^6.2.6",
 		"class-variance-authority": "^0.7.1",
 		"clsx": "^2.1.1",

apps/cline-hub/src/webview/src/Chat.tsx

@@ -1,5 +1,7 @@
 "use client";
 
+import type { GeneratedMedia } from "@cline/shared/browser";
+import { GeneratedMediaContent } from "@cline/ui";
 import {
 	CheckIcon,
 	GitBranchIcon,
@@ -324,6 +326,29 @@ function appendReasoningDelta(
 	return [...current, assistantMessage];
 }
 
+function appendAssistantMedia(
+	current: ChatMessage[],
+	media: GeneratedMedia,
+	activeAssistantIdRef: MutableRefObject<string | undefined>,
+): ChatMessage[] {
+	if (
+		current.some((message) =>
+			message.blocks?.some(
+				(block) => block.type === "media" && block.media.id === media.id,
+			),
+		)
+	) {
+		return current;
+	}
+	activeAssistantIdRef.current = undefined;
+	return [
+		...current,
+		createMessage("assistant", "", {
+			blocks: [{ id: `media:${media.id}`, type: "media", media }],
+		}),
+	];
+}
+
 type ToolResultEntry = {
 	query?: string;
 	result?: string;
@@ -637,6 +662,20 @@ function renderMessageBlocks(
 						<ReasoningContent>{block.text}</ReasoningContent>
 					</Reasoning>,
 				];
+			case "media": {
+				return [
+					<GeneratedMediaContent
+						classNames={{
+							image: "max-h-96 max-w-full rounded-md",
+							audio: "w-full",
+							video: "max-h-96 max-w-full",
+							unavailable: "rounded-md border p-3 text-sm",
+						}}
+						key={block.id}
+						media={block.media}
+					/>,
+				];
+			}
 			case "text":
 				if (options.isMeta) {
 					return [
@@ -807,6 +846,15 @@ export default function Chat({
 					setStatus(message.text);
 					return;
 				case "error":
+					// Recoverable errors are in-run notices (e.g. a plan-mode
+					// guard-blocked command recorded as a model mistake) — the
+					// run continues and any tool failure is already shown on
+					// its tool row, so keep the turn state and transcript
+					// intact. Only genuine failures end the turn.
+					if (message.recoverable) {
+						setStatus(`Recoverable error (run continues): ${message.text}`);
+						return;
+					}
 					setStatus(`Error: ${message.text}`);
 					setSending(false);
 					setHydratingSessionId(undefined);
@@ -966,6 +1014,11 @@ export default function Chat({
 						),
 					);
 					return;
+				case "assistant_media":
+					setMessages((current) =>
+						appendAssistantMedia(current, message.media, activeAssistantIdRef),
+					);
+					return;
 				case "tool_event":
 					setMessages((current) =>
 						appendToolEvent(

apps/cline-hub/src/webview/src/components/ui/combobox.tsx

@@ -105,7 +105,7 @@ function ComboboxContent({
 				align={align}
 				alignOffset={alignOffset}
 				anchor={anchor}
-				className="isolate z-50"
+				className="pointer-events-auto isolate z-[60]"
 			>
 				<ComboboxPrimitive.Popup
 					data-slot="combobox-content"

apps/cline-hub/src/webview/src/components/views/settings/extensions-view.tsx

@@ -3,9 +3,10 @@
 import {
 	Bot,
 	Code,
+	Copy,
 	FileText,
+	MoreVertical,
 	Play,
-	Puzzle,
 	RefreshCw,
 	Server,
 	Trash2,
@@ -16,6 +17,12 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
+import {
+	DropdownMenu,
+	DropdownMenuContent,
+	DropdownMenuItem,
+	DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
 import { Spinner } from "@/components/ui/spinner";
 import { Switch } from "@/components/ui/switch";
 import { desktopClient } from "@/lib/desktop-client";
@@ -97,6 +104,19 @@ type PluginItem = {
 	name: string;
 	path: string;
 	enabled: boolean;
+	contributions?: PluginContributions;
+};
+
+type PluginContributions = {
+	inspectionStatus?: "available" | "disabled" | "failed";
+	capabilities: string[];
+	tools: string[];
+	skills: string[];
+	rules: string[];
+	hooks: string[];
+	commands: string[];
+	mcpServers: string[];
+	providers: string[];
 };
 
 type ToolItem = {
@@ -856,6 +876,46 @@ export function CustomizationSectionView({
 		);
 	};
 
+	const renderPluginMenu = (target: LocalUninstallTarget) => {
+		const uninstalling = localUninstallingKeys.has(target.key);
+		return (
+			<DropdownMenu>
+				<DropdownMenuTrigger
+					render={
+						<Button
+							aria-label={`More actions for ${target.name ?? "plugin"}`}
+							className="m-0 size-auto shrink-0 p-0 text-muted-foreground"
+							onClick={(event) => event.stopPropagation()}
+							size="icon"
+							type="button"
+							variant="ghost"
+						/>
+					}
+				>
+					<MoreVertical className="size-4" />
+				</DropdownMenuTrigger>
+				<DropdownMenuContent align="end">
+					<DropdownMenuItem
+						onClick={() =>
+							void navigator.clipboard.writeText(target.path ?? "")
+						}
+					>
+						<Copy className="size-4" />
+						Copy path
+					</DropdownMenuItem>
+					<DropdownMenuItem
+						className="text-destructive focus:text-destructive"
+						disabled={uninstalling}
+						onClick={() => void uninstallLocalPrimitive(target)}
+					>
+						{uninstalling ? <Spinner /> : <Trash2 className="size-4" />}
+						{uninstalling ? "Uninstalling..." : "Uninstall"}
+					</DropdownMenuItem>
+				</DropdownMenuContent>
+			</DropdownMenu>
+		);
+	};
+
 	const renderSkillCard = (item: CommandItem) => {
 		const key = `${item.type}:${item.path}`;
 		return (
@@ -910,13 +970,32 @@ export function CustomizationSectionView({
 		scope: ItemScope;
 	}) => {
 		const key = plugin.path;
+		const contributionGroups = [
+			{
+				label: "Tools",
+				items:
+					plugin.contributions?.tools ??
+					(pluginToolsByPluginKey.get(plugin.path) ?? []).map(
+						(tool) => tool.name,
+					),
+			},
+			{ label: "Skills", items: plugin.contributions?.skills ?? [] },
+			{ label: "Rules", items: plugin.contributions?.rules ?? [] },
+			{ label: "Hooks", items: plugin.contributions?.hooks ?? [] },
+			{ label: "Commands", items: plugin.contributions?.commands ?? [] },
+			{ label: "MCP servers", items: plugin.contributions?.mcpServers ?? [] },
+			{ label: "Providers", items: plugin.contributions?.providers ?? [] },
+			{
+				label: "Capabilities",
+				items: plugin.contributions?.capabilities ?? [],
+			},
+		].filter((group) => group.items.length > 0);
 		return (
-			<div
+			<details
 				key={plugin.path}
 				className="rounded-lg border border-border px-5 py-4"
 			>
-				<div className="flex items-center gap-3">
-					<Puzzle className="h-4 w-4 shrink-0 text-primary" />
+				<summary className="flex cursor-pointer list-none items-center gap-3">
 					<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
 						{plugin.name}
 					</h3>
@@ -929,61 +1008,61 @@ export function CustomizationSectionView({
 						onCheckedChange={() => {
 							void setPluginEnabled(plugin);
 						}}
+						onClick={(event) => event.stopPropagation()}
 						disabled={togglingPluginPaths.has(plugin.path)}
 						aria-label={`Toggle ${plugin.name}`}
 					/>
-				</div>
-				<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
-					{plugin.path}
-				</p>
-				<div className="mt-3 ml-7 flex flex-col gap-2">
-					{(pluginToolsByPluginKey.get(plugin.path) ?? []).map((tool) => {
-						const isToggling = togglingToolIds.has(tool.id);
-						return (
-							<div
-								key={tool.id}
-								className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
-							>
-								<div className="min-w-0">
-									<p className="text-xs font-medium text-foreground">
-										{tool.name}
-									</p>
-									<p className="text-xs text-muted-foreground">
-										{tool.description?.trim() || "No description available."}
-									</p>
-								</div>
-								<div className="flex items-center gap-2">
-									<span className="text-xs text-muted-foreground">
-										{tool.enabled ? "Enabled" : "Disabled"}
-									</span>
-									<Switch
-										checked={tool.enabled}
-										onCheckedChange={() => {
-											void setToolEnabled(tool);
-										}}
-										disabled={isToggling || !plugin.enabled}
-										aria-label={`Toggle ${tool.name}`}
-									/>
-								</div>
-							</div>
-						);
-					})}
-					{(pluginToolsByPluginKey.get(plugin.path)?.length ?? 0) === 0 && (
-						<p className="text-xs text-muted-foreground">
-							No plugin tools found.
-						</p>
-					)}
-				</div>
-				<div className="mt-3">
-					{renderLocalActionRow({
+					{renderPluginMenu({
 						key,
 						type: "plugin",
 						id: plugin.name,
 						name: plugin.name,
 						path: plugin.path,
 					})}
+				</summary>
+				<div className="mt-3">
+					{plugin.contributions?.inspectionStatus === "disabled" ? (
+						<p className="mb-2 text-xs text-muted-foreground">
+							Enable this plugin to inspect its dynamic contributions.
+						</p>
+					) : null}
+					{contributionGroups.length > 0 ? (
+						<div>
+							<div className="flex flex-wrap items-center gap-2 py-2 text-xs font-medium text-foreground">
+								<span className="mr-1">Contributions</span>
+								{contributionGroups.map((group) => (
+									<Badge key={group.label} variant="outline">
+										{group.label} {group.items.length}
+									</Badge>
+								))}
+							</div>
+							<div className="grid max-h-56 gap-3 overflow-y-auto pt-2 sm:grid-cols-2">
+								{contributionGroups.map((group) => (
+									<div key={group.label} className="min-w-0">
+										<p className="mb-1 text-xs font-medium text-muted-foreground">
+											{group.label}
+										</p>
+										<div className="flex flex-wrap gap-1">
+											{group.items.map((item) => (
+												<Badge key={item} variant="secondary">
+													{item}
+												</Badge>
+											))}
+										</div>
+									</div>
+								))}
+							</div>
+						</div>
+					) : (
+						<p className="text-xs text-muted-foreground">
+							No plugin contributions found.
+						</p>
+					)}
 				</div>
-			</div>
+				{renderLocalActionMessage(key) ? (
+					<div className="mt-3">{renderLocalActionMessage(key)}</div>
+				) : null}
+			</details>
 		);
 	};
 
@@ -1000,53 +1079,56 @@ export function CustomizationSectionView({
 				disabled={togglingPluginPaths.has(plugin.path)}
 				aria-label={`Toggle ${plugin.name}`}
 			/>
+			{renderPluginMenu({
+				key: plugin.path,
+				type: "plugin",
+				id: plugin.name,
+				name: plugin.name,
+				path: plugin.path,
+			})}
 		</>
 	);
 
-	const renderPluginMatchedMeta = (plugin: PluginItem) => (
-		<p className="min-w-0 truncate text-xs font-mono text-muted-foreground">
-			{plugin.path}
-		</p>
-	);
-
 	const renderPluginMatchedDetails = (plugin: PluginItem) => {
-		const pluginTools = pluginToolsByPluginKey.get(plugin.path) ?? [];
-		if (pluginTools.length === 0) {
+		const contributionGroups = [
+			{
+				label: "Tools",
+				items:
+					plugin.contributions?.tools ??
+					(pluginToolsByPluginKey.get(plugin.path) ?? []).map(
+						(tool) => tool.name,
+					),
+			},
+			{ label: "Skills", items: plugin.contributions?.skills ?? [] },
+			{ label: "Rules", items: plugin.contributions?.rules ?? [] },
+			{ label: "Hooks", items: plugin.contributions?.hooks ?? [] },
+			{ label: "Commands", items: plugin.contributions?.commands ?? [] },
+			{ label: "MCP servers", items: plugin.contributions?.mcpServers ?? [] },
+			{ label: "Providers", items: plugin.contributions?.providers ?? [] },
+			{
+				label: "Capabilities",
+				items: plugin.contributions?.capabilities ?? [],
+			},
+		].filter((group) => group.items.length > 0);
+		if (contributionGroups.length === 0) {
 			return null;
 		}
 		return (
-			<div className="grid gap-2">
-				{pluginTools.map((tool) => {
-					const isToggling = togglingToolIds.has(tool.id);
-					return (
-						<div
-							key={tool.id}
-							className="flex items-center justify-between gap-4 rounded-md border border-border/70 px-3 py-2"
-						>
-							<div className="min-w-0">
-								<p className="text-xs font-medium text-foreground">
-									{tool.name}
-								</p>
-								<p className="text-xs text-muted-foreground">
-									{tool.description?.trim() || "No description available."}
-								</p>
-							</div>
-							<div className="flex items-center gap-2">
-								<span className="text-xs text-muted-foreground">
-									{tool.enabled ? "Enabled" : "Disabled"}
-								</span>
-								<Switch
-									checked={tool.enabled}
-									onCheckedChange={() => {
-										void setToolEnabled(tool);
-									}}
-									disabled={isToggling || !plugin.enabled}
-									aria-label={`Toggle ${tool.name}`}
-								/>
-							</div>
+			<div className="grid max-h-56 gap-3 overflow-y-auto sm:grid-cols-2">
+				{contributionGroups.map((group) => (
+					<div key={group.label} className="min-w-0">
+						<p className="mb-1 text-xs font-medium text-muted-foreground">
+							{group.label}
+						</p>
+						<div className="flex flex-wrap gap-1">
+							{group.items.map((item) => (
+								<Badge key={item} variant="secondary">
+									{item}
+								</Badge>
+							))}
 						</div>
-					);
-				})}
+					</div>
+				))}
 			</div>
 		);
 	};
@@ -1147,10 +1229,12 @@ export function CustomizationSectionView({
 							renderMatchedControls: () =>
 								renderPluginMatchedControls(item.plugin),
 							renderMatchedDetails:
+								Object.values(item.plugin.contributions ?? {}).some(
+									(values) => values.length > 0,
+								) ||
 								(pluginToolsByPluginKey.get(item.plugin.path) ?? []).length > 0
 									? () => renderPluginMatchedDetails(item.plugin)
 									: undefined,
-							renderMatchedMeta: () => renderPluginMatchedMeta(item.plugin),
 						}),
 					)
 				: catalogPrimitive === "mcp"
@@ -1476,7 +1560,6 @@ export function CustomizationSectionView({
 									className="rounded-lg border border-border px-5 py-4"
 								>
 									<div className="flex items-center gap-3">
-										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
 										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
 											{plugin.name}
 										</h3>
@@ -1492,13 +1575,9 @@ export function CustomizationSectionView({
 											aria-label={`Toggle ${plugin.name}`}
 										/>
 									</div>
-									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
-										{plugin.path}
-									</p>
-									<div className="mt-3 ml-7 flex flex-col gap-2">
+									<div className="mt-3 ml-7 flex max-h-56 flex-col gap-2 overflow-y-auto">
 										{(pluginToolsByPluginKey.get(plugin.path) ?? []).map(
 											(tool) => {
-												const isToggling = togglingToolIds.has(tool.id);
 												return (
 													<div
 														key={tool.id}
@@ -1513,19 +1592,6 @@ export function CustomizationSectionView({
 																	"No description available."}
 															</p>
 														</div>
-														<div className="flex items-center gap-2">
-															<span className="text-xs text-muted-foreground">
-																{tool.enabled ? "Enabled" : "Disabled"}
-															</span>
-															<Switch
-																checked={tool.enabled}
-																onCheckedChange={() => {
-																	void setToolEnabled(tool);
-																}}
-																disabled={isToggling || !plugin.enabled}
-																aria-label={`Toggle ${tool.name}`}
-															/>
-														</div>
 													</div>
 												);
 											},
@@ -1558,7 +1624,6 @@ export function CustomizationSectionView({
 									className="rounded-lg border border-border px-5 py-4"
 								>
 									<div className="flex items-center gap-3">
-										<Puzzle className="h-4 w-4 shrink-0 text-primary" />
 										<h3 className="min-w-0 flex-1 text-sm font-semibold text-foreground">
 											{plugin.name}
 										</h3>
@@ -1574,13 +1639,9 @@ export function CustomizationSectionView({
 											aria-label={`Toggle ${plugin.name}`}
 										/>
 									</div>
-									<p className="mt-1 ml-7 text-xs font-mono text-muted-foreground">
-										{plugin.path}
-									</p>
-									<div className="mt-3 ml-7 flex flex-col gap-2">
+									<div className="mt-3 ml-7 flex max-h-56 flex-col gap-2 overflow-y-auto">
 										{(pluginToolsByPluginKey.get(plugin.path) ?? []).map(
 											(tool) => {
-												const isToggling = togglingToolIds.has(tool.id);
 												return (
 													<div
 														key={tool.id}
@@ -1595,19 +1656,6 @@ export function CustomizationSectionView({
 																	"No description available."}
 															</p>
 														</div>
-														<div className="flex items-center gap-2">
-															<span className="text-xs text-muted-foreground">
-																{tool.enabled ? "Enabled" : "Disabled"}
-															</span>
-															<Switch
-																checked={tool.enabled}
-																onCheckedChange={() => {
-																	void setToolEnabled(tool);
-																}}
-																disabled={isToggling || !plugin.enabled}
-																aria-label={`Toggle ${tool.name}`}
-															/>
-														</div>
 													</div>
 												);
 											},

apps/cline-hub/src/webview/src/components/views/settings/routine-view.tsx

@@ -1154,9 +1154,7 @@ export function RoutineSchedulesContent() {
 			>
 				<DialogContent className="max-h-[90vh] overflow-y-auto sm:max-w-2xl">
 					<DialogHeader>
-						<DialogTitle>
-							{editingSchedule ? "Edit Routine" : "Create Routine"}
-						</DialogTitle>
+						<DialogTitle>Schedule</DialogTitle>
 						<DialogDescription>
 							{editingSchedule
 								? "Update this scheduler routine."

apps/cline-hub/src/webview/src/index.css

@@ -1,11 +1,16 @@
 @import "tailwindcss";
 @import "tw-animate-css";
 @import "shadcn/tailwind.css";
-@import "@fontsource-variable/schibsted-grotesk";
+@import "@fontsource-variable/inter";
+@import "@fontsource-variable/geist-mono";
 
 @custom-variant dark (&:is(.dark *));
 
 :root {
+	--font-weight-normal: 480;
+	--font-weight-medium: 560;
+	--font-weight-semibold: 640;
+	--font-weight-bold: 640;
 	--background: oklch(1 0 0);
 	--foreground: oklch(0.18 0.008 255);
 	--card: oklch(1 0 0);
@@ -42,10 +47,10 @@
 }
 
 @theme inline {
-	--font-sans: "Schibsted Grotesk Variable", sans-serif;
+	--font-sans: "Inter Variable", sans-serif;
 	--font-mono:
-		ui-monospace, "SFMono-Regular", Menlo, Consolas, "Liberation Mono",
-		monospace;
+		"Geist Mono Variable", ui-monospace, "SFMono-Regular", Menlo, Consolas,
+		"Liberation Mono", monospace;
 	--color-background: var(--background);
 	--color-foreground: var(--foreground);
 	--color-card: var(--card);
@@ -197,6 +202,10 @@
 }
 
 .dark {
+	--font-weight-normal: 400;
+	--font-weight-medium: 500;
+	--font-weight-semibold: 600;
+	--font-weight-bold: 600;
 	--background: oklch(0.145 0 0);
 	--foreground: oklch(0.985 0 0);
 	--card: oklch(0.205 0 0);

apps/cline-hub/src/webview/src/lib/provider-model-catalog.ts

@@ -16,12 +16,27 @@ export type ProviderModelCatalog = {
 };
 
 function toModelIds(models: ProviderModel[] | undefined): string[] {
-	return (models ?? []).map((model) => model.id);
+	return (models ?? [])
+		.filter(
+			(model) =>
+				(model.inputModalities === undefined ||
+					model.inputModalities.includes("text")) &&
+				(model.outputModalities === undefined ||
+					model.outputModalities.includes("text")),
+		)
+		.map((model) => model.id);
 }
 
 function toReasoningModelIds(models: ProviderModel[] | undefined): string[] {
 	return (models ?? [])
-		.filter((model) => model.supportsReasoning)
+		.filter(
+			(model) =>
+				(model.inputModalities === undefined ||
+					model.inputModalities.includes("text")) &&
+				(model.outputModalities === undefined ||
+					model.outputModalities.includes("text")) &&
+				model.supportsReasoning,
+		)
 		.map((model) => model.id);
 }
 
@@ -31,7 +46,10 @@ export function buildProviderModelCatalog(
 	return {
 		providers,
 		enabledProviderIds: providers
-			.filter((provider) => provider.enabled)
+			.filter(
+				(provider) =>
+					provider.enabled && toModelIds(provider.modelList).length > 0,
+			)
 			.map((provider) => provider.id),
 		providerModels: Object.fromEntries(
 			providers.map((provider) => [

apps/cline-hub/src/webview/src/lib/provider-schema.ts

@@ -1,11 +1,17 @@
+import type { ProviderModesSettings } from "@cline/shared/browser";
+
 export interface ProviderModel {
 	id: string;
 	name: string;
 	supportsAttachments?: boolean;
 	supportsVision?: boolean;
 	supportsReasoning?: boolean;
+	inputModalities?: ModelModality[];
+	outputModalities?: ModelModality[];
 }
 
+export type ModelModality = "text" | "image" | "audio" | "video" | "pdf";
+
 export type ProviderConfigFieldType =
 	| "text"
 	| "password"
@@ -63,6 +69,7 @@ export interface ProviderSettingsUpdate {
 export interface ProviderCatalogResponse {
 	providers: Provider[];
 	settingsPath: string;
+	modes: ProviderModesSettings;
 }
 
 export interface ProviderModelsResponse {

apps/examples/desktop-app/CHANGELOG.md

@@ -1,5 +1,102 @@
 # Cline Code Desktop Changelog
 
+## 0.0.14-beta.1
+
+- First beta release. Cline Code Beta installs side by side with the stable app so you can compare the two, and updates automatically from its own beta channel — stable installs are unaffected.
+- Cloud sessions (preview): run sessions in Cline's cloud straight from the desktop app. Connect GitHub during onboarding, pick a repository and branch, and hand sessions off between devices — transcripts, approvals, and queued prompts stay in sync, and you can rename cloud sessions and switch models mid-session. Turn it on with the Cloud sessions toggle in Settings.
+- Avatar overlay (preview): a floating desktop companion that reacts to what your sessions are doing.
+- Onboarding now includes a GitHub integration step.
+- Early proof of concept for running sessions in SSH remote environments.
+- Includes everything from the upcoming stable release: microphone voice input in the composer, model-driven image generation, redesigned question prompts, animated reasoning and tool disclosures, and session list polish.
+
+## 0.0.13
+
+- Added an app font size setting. A slider in Settings scales the interface, and your size is applied before the window paints, so launching no longer flashes at the old size first.
+- Models that support it can now search the web during a task. Turn it on with the Web Search toggle in Settings; the searches and their results appear in the transcript and are still there when you reopen the session.
+- Extended thinking budgets reach the provider again on Cline Pass — they had silently stopped applying when the gateway moved off the generic OpenAI-compatible path.
+- Two Cline installs on different builds no longer shut each other's Hub down in a loop, which was killing live sessions with an abnormal disconnect.
+- The app no longer replaces a Hub that is still serving sessions. It attaches to it instead, and the swap happens once that Hub goes idle.
+- The "update required" dialog no longer interrupts when the Hub is only finishing an update on its own. This app is already the newer build, nothing was being asked of you, and the Hub replaces itself once its sessions end.
+- Idle plugin sandbox processes are now reclaimed instead of lingering for the life of the session.
+- Refreshed the model catalog, which adds Crusoe as a provider and updates model lists and per-provider default models across the board.
+
+## 0.0.12
+
+- Every tool call now gets its own row in the transcript, with its own icon, status, and expandable detail — no more "Read 3 files · Ran 2 commands" grouping. Commands read like a terminal (`$ bun test`) with their captured output on expand, and edits show their diffs inline, one per hunk.
+- Running tool rows are highlighted in brand violet and settle to gray when they finish; errors stay red.
+- File diffs — both in chat rows and the diff panel — now render through a shared syntax-highlighted renderer that follows the app's theme instead of the browser's.
+- Refreshed session transcript layout, message surfaces, and composer, with new Inter and Geist Mono typography.
+- The thinking indicator now stays up during quiet stretches of a turn, such as while tool arguments are streaming, so the turn no longer looks frozen.
+- Message actions (copy, fork, timestamp) no longer crowd the message text, and expanded panels render at full opacity instead of faded.
+- On the welcome screen the chat input is centered and top-aligned, and prompt suggestions are temporarily hidden.
+- The first turn of a fresh session no longer wedges the composer on "Agent is working…" forever.
+- Scheduled runs no longer appear in the session sidebar and history list.
+- Reconnecting to a stale managed Cline Hub daemon is fixed. When another Cline install ships a newer Hub, the app now prompts to update and restart — and stages the app update first, so it no longer relaunches into the same version and immediately re-prompts.
+- The Hub daemon now shuts down cleanly instead of exiting with an error when a client is still connected.
+- The Claude Code provider is usable for agentic work again: sessions are anchored on the workspace folder, your `~/.claude` and project settings are loaded, and file edits under the workspace are allowed instead of every write being refused with no approval prompt.
+- Truncated tool-call JSON is now rejected instead of being silently "repaired" into wrong arguments.
+- Fixed strict providers (seen on Vercel with kimi-k3) rejecting a turn with "user message must have content" when a message held only empty text.
+- Fixed a mid-turn crash on streamed tool calls with non-zero indexes, hit through LiteLLM's Anthropic passthrough.
+- Compaction now respects your Max Output Tokens setting instead of a hardcoded 1024-token cap — reasoning models were spending the entire budget thinking, so no summary arrived and compaction was skipped every time.
+- Vertex AI: added Fable 5 and custom model IDs, and the global-region picker no longer hides models from the live catalog.
+
+## 0.0.11
+
+- Images can now be pasted straight from the clipboard into the composer.
+- Opening a folder that isn't a git repo no longer shows git jargon, and the welcome suggestions now adapt to what's actually in the folder instead of assuming a code project.
+- The folder picker now reports failures instead of doing nothing, and offers a manual path entry as a fallback.
+- Opening an existing session no longer overwrites the model you had selected.
+- The diff panel now resolves file paths against the session's working directory, so diffs open correctly for sessions rooted outside the app's own directory.
+- `/team` prompts now run through the core runtime.
+- Failed turns surface their error in the transcript instead of leaving the chat blank.
+- Plugins left behind as empty install directories are no longer listed as installed, and plugin settings and contributions are now managed centrally with atomic toggles.
+- Fixed a startup script-load error, and webview errors are now attributed to the source URL that caused them.
+- Signing out is handled as a normal state rather than surfacing as a command error.
+- Native-feel and performance polish: the browser context menu is suppressed on app chrome (kept for text fields and selections), UI chrome is no longer text-selectable while chat content still is, inner scrollers no longer rubber-band the window, Settings/Sessions/Onboarding/Diff load lazily, the composer no longer flickers the caret on every keystroke, slash commands are cached across menu opens, and Escape closes the provider/model picker.
+- Tool output no longer nests its own scrollbar.
+- Prompts queued during a turn now survive being interrupted — they're preserved across aborts, drained after a turn aborts itself, and the stop is surfaced instead of the queue being silently dropped. Queued turns that fail are reported as failures.
+- Session context stays durable across aborts and hub restarts.
+- A hung MCP server no longer takes down session creation, and stdio servers that were never configured get a 30-second initialize budget instead of blocking indefinitely.
+- Remote SSE MCP servers surface an OAuth authorization prompt on a 401 instead of failing outright.
+- LiteLLM requests route through Chat Completions instead of the Responses API.
+- Network interruptions mid-stream but before any model output are retried instead of failing the turn.
+- Checkpoints are picked up when git is initialized part-way through a session, and checkpoint diffs include files that were untracked when the snapshot was taken.
+- Scheduled run reports carry execution context — schedule metadata, durations, and lifecycle error details.
+
+## 0.0.10
+
+- Remote MCP servers can now authenticate with OAuth from Settings → MCP — authorize a server, see its auth status, and cancel or retry a pending authorization. Servers that require a pre-registered OAuth client (client ID/secret) instead of dynamic registration are now supported, and stored tokens are invalidated when a server's client configuration changes.
+- MCP errors are now shown on the individual server rather than as a page-level error, and a server with invalid configuration is surfaced with its error instead of silently disappearing from the list.
+- Failed turns no longer fail silently. Sending a message with no model credentials — or any queued turn that fails — now shows an error in the transcript, enriched with the underlying cause and a pointer to Settings → Models.
+- Fixed the first message of a chat (and some queued messages) rendering twice.
+- Fixed the composer getting stuck on "Agent is working…" after a turn already finished.
+- New "Connect a model" notice on the welcome screen when no provider has credentials, with one click to onboarding or model settings. It reacts live as you add credentials, and correctly recognizes Bedrock/Vertex and keyless local endpoints as already connected.
+- Added "Get an API key" links for popular providers in onboarding and Settings → Models, plus a link to the Cline dashboard from the Cline API key form.
+- The onboarding welcome step now explains what Cline is.
+- The stop button is now actually visible and clickable, Esc stops the current turn, and new shortcuts: Cmd/Ctrl+N for a new session, Cmd/Ctrl+, for settings.
+- Reasoning controls now resolve consistently across AI SDK providers, including Ollama, so effort levels and thinking on/off are honored wherever the provider supports them.
+- Vertex AI: credential refreshes now use the configured fetch, fixing ADC authentication behind proxies and custom networking.
+- Refreshed the bundled provider and model catalog.
+
+## 0.0.9
+
+- Cline Code now ships as a single universal macOS download that runs natively on both Apple Silicon and Intel — no more picking the right architecture. Existing per-architecture installs migrate to it automatically on their next update.
+- Session history can now be filtered by where a session came from — Desktop, CLI, extension, or scheduled — from a new filter control in the sidebar.
+- The composer now shows a token usage ring for the active model's context window, with cumulative cost, and it changes color as you approach the limit.
+- Skills now appear in the slash command menu alongside workflows, and commands that share a name are disambiguated instead of shadowing each other.
+- Installed plugins now show their real package names instead of all appearing as "index".
+- The agent header can be dragged to move the window again, including on read-only titles.
+- Chat message actions (copy, fork, edit, restore) no longer collide with the descenders of the message's last line.
+- Application errors are now reported in diagnostics, and the packaged app's telemetry configuration is baked into the sidecar at build time — previously the packaged build shipped with it empty, so no diagnostics were ever sent.
+- Plan mode now hard-blocks file-editing shell commands rather than relying on prompting alone; read-only investigation still works.
+- Running out of context is now recovered from automatically — the run compacts and retries once instead of failing with a raw provider error.
+- Empty model responses are now retried on every provider, not just Ollama, fixing hard "Model returned empty response" failures on OpenRouter, Cline, and OpenAI-compatible endpoints.
+- Claude 4.6+ and 5.x models are no longer rejected with "thinking.type.enabled is not supported".
+- Bedrock prompt caching works again — cache reads and writes were always 0 — and Bedrock foundation models now route through geo inference profiles.
+- Reasoning models on OpenAI-compatible endpoints now get the correct token parameter, and models without image support substitute image content instead of failing.
+- Refreshed the bundled provider and model catalog, adding Infomaniak and SCX.ai.
+- Upgraded the model layer to AI SDK 7 and switched Ollama to the native provider.
+
 ## 0.0.8
 
 - Edit any earlier message in a conversation — the app forks the session at that point, rewinds the workspace to that run's checkpoint, and re-runs from your edited prompt. Restores are transactional and workspace-atomic, so a failed restore won't leave you half-rewound.

apps/examples/desktop-app/EXPERIMENTAL.md

@@ -0,0 +1,136 @@
+# Desktop Experimental Branch & Beta Channel
+
+How experimental desktop features are developed on the `desktop-experimental`
+branch, shipped to users as **Cline Code Beta**, and graduated into `main`.
+The release mechanics (workflow internals, secrets) live in
+[`.github/workflows/desktop-publish.yml`](../../../.github/workflows/desktop-publish.yml)
+and the `publish-desktop` skill
+([`.cline/skills/publish-desktop/SKILL.md`](../../../.cline/skills/publish-desktop/SKILL.md));
+this doc is the process.
+
+## What the beta channel is
+
+The beta is a **separate app**, not a mode of the stable app:
+
+- Product name `Cline Code Beta`, bundle identifier `bot.cline.app.beta`
+  (stable is `Cline Code` / `bot.cline.app`) — set by
+  [`src-tauri/tauri.beta.conf.json`](./src-tauri/tauri.beta.conf.json), which
+  is layered over `tauri.release.conf.json` at build time.
+- Both apps install and run **side by side**, so people can compare beta
+  features against stable directly.
+- Each channel polls its own auto-update feed: stable installs poll the
+  rolling `desktop-latest` release, beta installs poll the rolling
+  `desktop-beta` release. The feed URL is compiled into the binary, so a beta
+  install only ever receives beta builds and vice versa. **Never delete either
+  rolling release.**
+- Yes, the names are asymmetric: `desktop-latest` *is* the stable feed. Do
+  not rename it to `desktop-stable` — the URL is baked into every stable
+  binary ever shipped and the updater has no fallback endpoint, so renaming
+  (or deleting) the release silently strands every existing install on a
+  dead feed forever. Renaming would mean maintaining both feeds for as long
+  as any pre-rename install exists, i.e. permanently. Same applies to
+  `desktop-beta` once the first beta ships.
+- Both apps share `~/.cline` (provider credentials, global settings, hub
+  daemon — the hub is multi-client by design, same as running the CLI and the
+  app together). A beta that requires a newer hub build can trigger the
+  hub-update-required flow in the stable app or vice versa; that's expected
+  version skew, not a bug in itself.
+
+Users join the beta by downloading the beta DMG from its GitHub release
+(announced on Slack). There is no auto-downgrade: leaving the beta means
+deleting the beta app (stable was never touched). Beta users get the stable
+version of a graduated feature through the normal stable release of the
+stable app they still have installed.
+
+## Branch model
+
+`desktop-experimental` is a long-lived branch where experimental features
+bake before graduating to `main`.
+
+- **Feature PRs target `desktop-experimental`** and are merged there to
+  iterate. Keep the feature's original PR against `main` open **as a draft**
+  — it accumulates the follow-up work done on the experimental branch and
+  documents intent to graduate.
+- **Graduation** = a fresh (or the updated draft) PR against `main`
+  containing the feature plus everything learned on the experimental branch.
+  Treat it as a normal `main` PR: full review, tests, no experimental
+  scaffolding.
+- **Sync direction is one-way**: merge `main` into `desktop-experimental`
+  regularly — at minimum after every stable desktop release — so the branch
+  never drifts far. Never merge `desktop-experimental` into `main` wholesale.
+- **Merge-conflict policy** when syncing `main` in:
+  - `package.json` / `src-tauri/tauri.conf.json` versions: keep the branch's
+    beta version (see versioning rule below for when to bump its base).
+  - `CHANGELOG.md`: keep both sides' sections, newest version first — stable
+    and beta sections interleave by recency.
+  - Feature code: main wins for anything that graduated; resolve toward
+    main's reviewed form.
+
+## Versioning & tags
+
+- Beta versions are prereleases of the **next** stable version: stable
+  `0.0.13` → betas `0.0.14-beta.1`, `0.0.14-beta.2`, …
+- Tag format: `desktop-vX.Y.Z-beta.N`, tagged on a `desktop-experimental`
+  commit. Stable tags (`desktop-vX.Y.Z`, no suffix) stay on `main`; the
+  workflow enforces both shapes and each channel's branch ancestry.
+- When a stable release ships with a version ≥ the current beta base, bump
+  the base for the next beta (stable `0.0.14` out → next beta is
+  `0.0.15-beta.1`). A beta must never share its `X.Y.Z` base with an
+  already-shipped stable.
+- Semver keeps the channels ordered: `0.0.14-beta.N` sorts above stable
+  `0.0.13` and below the eventual `0.0.14`.
+
+## Cutting a beta release
+
+Manual, like stable — no nightly automation. Short form (the
+`publish-desktop` skill walks through it):
+
+1. On `desktop-experimental`: merge `main` in, bump both version files to the
+   new beta version, prepend a `## X.Y.Z-beta.N` section to `CHANGELOG.md`,
+   commit, push.
+2. Tag `desktop-vX.Y.Z-beta.N` on that commit and push the tag.
+3. Dispatch **from `main`** with the beta channel:
+
+   ```sh
+   gh workflow run desktop-publish.yml --ref main \
+     -f git_tag=desktop-vX.Y.Z-beta.N \
+     -f channel=beta \
+     -f confirm_publish=publish
+   ```
+
+4. Approve the `PublishDesktop` environment gate; the workflow builds, signs,
+   and notarizes the beta bundle, creates a **prerelease** GitHub release,
+   refreshes `desktop-beta/latest.json`, and posts to Slack — same
+   announcement path as stable, marked as beta.
+
+**Why dispatch from `main` when the code is on `desktop-experimental`?**
+Security invariant: the workflow run executes `main`'s copy of
+`desktop-publish.yml` and only the *checkout* points at the beta tag (the
+`validate` job pins the tag to `desktop-experimental` ancestry). The
+signing-secret gates — the `github.ref == main` check and the
+`PublishDesktop` environment's main-only deployment-branch policy — stay
+exactly as they are for stable, and a workflow file edited on
+`desktop-experimental` can never reach the signing secrets. Do **not** add
+`desktop-experimental` to the PublishDesktop deployment-branch policy.
+
+One thing dispatch-from-main does *not* cover: the build job checks out the
+tag and runs its build scripts (dependency install hooks, `build:sdk`,
+Tauri's `beforeBuildCommand`, `build.rs`) with the signing secrets in scope
+— true for stable and beta alike. The control is the PublishDesktop
+required-reviewer approval: **approving a publish means vouching for the
+code the tag points at**, not just for the release happening. That is why
+`desktop-experimental` must keep main-grade merge controls (branch
+protection, maintainer-only pushes) — anyone who can land code there can get
+it executed alongside the signing keys once a publish of it is approved.
+
+## Guardrails worth knowing about
+
+- The updater comparator is a plain semver "newer than". Feed separation is
+  the entire safety story: a beta manifest on `desktop-latest` would
+  auto-update every stable install onto the beta. The workflow guards this
+  three ways: the stable channel rejects prerelease tags, the feed target is
+  derived fail-closed from the channel (and cross-checked in the release
+  job), and the build asserts the compiled binary embeds exactly its own
+  channel's feed URL before anything is signed into a release.
+- `tauri.beta.conf.json` must exist on the tagged commit (the build checks
+  out the tag), so keep it present on both `main` and `desktop-experimental`.

apps/examples/desktop-app/README.md

@@ -30,6 +30,59 @@ API keys, `JAVA_HOME`-style tool roots) are not pulled in. Set
 `CLINE_SIDECAR_SKIP_SHELL_PATH=1` to disable. Implementation and details:
 [`sidecar/shell-path.ts`](./sidecar/shell-path.ts).
 
+## SSH Remote Environments (v0)
+
+Open **Settings → Remote** to add and test an SSH host. Saving or testing a
+profile does not activate it. From the welcome chat, open the environment
+selector beside the workspace picker and choose the saved host; that selection
+starts the SSH connection at the remote user's home directory. Choose **Add
+project…** from the normal workspace selector to browse that machine and select
+a project, or choose **Local** in the environment selector to disconnect. Recent
+and last-used workspaces are remembered separately for each SSH host and for
+the local machine.
+
+SSH config aliases are supported. Leave **Port** blank to use the alias's SSH
+configuration (including its configured port), or enter a port to override it.
+The desktop keeps its webview and native integration local; only the
+authenticated Cline Hub protocol is forwarded through SSH. Agent tools,
+workspace discovery, Git metadata, and session persistence therefore run on the
+SSH host, while approvals and live session events return to the desktop.
+
+The desktop stores host metadata at
+`~/.cline/data/settings/remote-environments.json` with mode `0600`. It stores an
+identity-file path, never private-key contents. On first connect it uploads a
+content-addressed, branch-matched, self-contained Hub helper under
+`~/.cline/code/remote/`, binds the Hub to remote loopback, and forwards it to a
+random local loopback port. Linux x64 and arm64 helpers are bundled by
+`bun run build:sidecar:bin`; 32-bit Raspberry Pi operating systems are not
+supported in v0. The current helper is roughly 110 MB because it includes its
+own runtime. It is copied once per matching desktop build and cached, with no
+`apt`, `npm`, root access,
+global CLI install, or public Hub port. Disconnecting stops the desktop-owned
+remote Hub but leaves the helper cached for a faster reconnect. The helper
+imports the remote login-shell `PATH`, so user-installed Git, GitHub CLI, and
+MCP executables remain visible.
+
+The desktop uses its own discovery record, so an existing Cline CLI/Hub on the
+same account is neither replaced nor stopped. Both Hub processes can coexist
+while the desktop is connected; this isolation is intentional for the proof of
+concept so a branch-matched desktop helper cannot disrupt another Cline build.
+
+v0 intentionally leaves file attachments and opening a remote file in a local
+editor disabled. Text, images, file mentions/search, Git branch operations,
+session history, and remote agent tools are supported. The current desktop
+provider access/API token is sent through the authenticated tunnel for the
+session; reusable OAuth refresh credentials are not copied into remote provider
+settings.
+
+For a real SSH acceptance run, `scripts/verify-ssh-poc.ts` accepts
+`CLINE_SSH_TEST_HOST`, `CLINE_SSH_TEST_USER`, `CLINE_SSH_TEST_KEY`,
+`CLINE_SSH_TEST_WORKSPACE`, and `CLINE_SSH_TEST_HELPER`. It starts a remote
+connection at the SSH user's home, starts an agent session in the test
+workspace with the selected desktop provider, asks the agent to read
+`REMOTE_MARKER.txt`, then verifies the session appears in remote history and
+that its messages can be read back.
+
 ## Web Visual System
 
 The framework-neutral color, typography, radius, and navigation contract lives
@@ -55,6 +108,12 @@ lost: the `desktop-latest` release/tag (its feed URL is baked into shipped
 apps) and the updater private key (`TAURI_SIGNING_PRIVATE_KEY` — without it,
 shipped apps can't verify new updates).
 
+There is also a beta channel ("Cline Code Beta", a separate app that installs
+side by side with stable) cut from the `desktop-experimental` branch and
+served by the rolling `desktop-beta` release — the same never-delete rule
+applies to it. The experimental-branch process and beta release flow live in
+[`EXPERIMENTAL.md`](./EXPERIMENTAL.md).
+
 ## Shareable Desktop Packages (manual fallback)
 
 Tauri desktop bundles are OS-specific, so build each package on the target OS:
@@ -135,6 +194,16 @@ Desktop transport envelope:
 ## Data + Storage
 
 - Session artifacts are written under `~/.cline/data/sessions/<sessionId>/` (or `CLINE_SESSION_DATA_DIR`).
+- Desktop avatar packages live under `~/.cline/avatars/<avatar-name>/`. Each package
+  contains a v2 `spritesheet.webp` (or PNG) and either an `avatar.json` or
+  `pet.json` manifest with
+  `id`, `displayName`, `description`, `spriteVersionNumber: 2`, and
+  `spritesheetPath`. If both manifests exist, `avatar.json` takes precedence.
+  The bundled Cline Bot avatar is selected and enabled by default, with Mom also
+  available as a bundled option.
+  Visibility and the selected installed avatar are configured independently under
+  **Settings → General → Desktop avatar**; both values are stored in
+  `~/.cline/avatars/selected.json`.
 - Canonical replay/export artifact: `<sessionId>.messages.json`.
 - `<sessionId>.messages.json` is expected to contain ordered messages plus assistant `modelInfo` and `metrics` (including cache token fields when provided by the model runtime).
 - `<sessionId>.hooks.jsonl` is observability/debug telemetry and should not be required for normal history replay/export flows.
@@ -155,6 +224,14 @@ Logging can be configured with the same environment variables as the CLI:
 - `CLINE_LOG_PATH` overrides the log destination.
 - `CLINE_LOG_NAME` overrides the logger name.
 
+In a development webview, sidecar voice-input diagnostics are also streamed to
+the webview console as `[desktop:voice-input]` entries. Production builds can
+enable the same console stream with `NEXT_PUBLIC_CLINE_DEBUG_LOGS=1` at build
+time, or at runtime from DevTools with
+`localStorage.setItem("cline.debugLogs", "1")` followed by a reload. Diagnostic
+events include the selected provider/model and sanitized endpoint, but never
+credentials, request headers, recorded audio, or transcript contents.
+
 ## Troubleshooting
 
 - If live updates stall, verify the desktop backend websocket is connected and `chat_event` messages are arriving.
@@ -165,3 +242,17 @@ Logging can be configured with the same environment variables as the CLI:
   The next desktop or CLI Hub connection will reuse a compatible running Hub or
   replace an incompatible one through the shared discovery path.
 - Provider settings updates are patch-style: only fields you edit are changed. Unset fields are preserved instead of being cleared.
+- Speech input requires an enabled provider whose models.dev metadata identifies
+  a dedicated `audio`-to-`text` model, or the built-in ElevenLabs provider with
+  its Scribe v2 model. Choose the voice input provider and model explicitly under
+  **Settings → Models → Voice input**. That selection is stored separately from
+  the chat model as `modes.voiceInput` in
+  `~/.cline/data/settings/providers.json`; provider credentials remain in their
+  existing provider entry and never enter the webview. ElevenLabs uses its native
+  `/v1/speech-to-text` API. Text-to-speech models with `output: ["audio"]` are
+  not used for microphone transcription.
+- Streaming transcription models, such as Vercel AI Gateway's
+  `openai/gpt-realtime-whisper`, update the composer while the user speaks.
+  The sidecar mints a short-lived transcription token; the long-lived gateway
+  credential is never sent to the webview. Batch models such as
+  `openai/whisper-1` continue to transcribe after recording stops.

apps/examples/desktop-app/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cline/code",
-	"version": "0.0.8",
+	"version": "0.0.14-beta.1",
 	"private": true,
 	"scripts": {
 		"build:ui": "bun -F @cline/ui build",
@@ -22,17 +22,22 @@
 		"pretypecheck": "bun run build:ui",
 		"typecheck": "tsc -p tsconfig.dev.json --noEmit",
 		"pretest:chat-ui": "bun run build:ui",
-		"test:chat-ui": "vitest run webview/components/views/chat/chat-messages.test.tsx --config vitest.config.ts",
+		"test:chat-ui": "vitest run webview/components/views/chat/chat-messages.test.tsx webview/components/views/chat/messages --config vitest.config.ts",
 		"clean": "rm -rf webview/.next webview/out node_modules dist && (cd src-tauri && rm -rf target node_modules dist)"
 	},
 	"dependencies": {
+		"@ai-sdk/gateway": "4.0.31",
+		"@ai-sdk/google": "4.0.44",
+		"@ai-sdk/openai": "4.0.41",
+		"@ai-sdk/react": "4.0.44",
 		"@base-ui/react": "^1.2.0",
 		"@cline/core": "workspace:*",
 		"@cline/llms": "workspace:*",
 		"@cline/shared": "workspace:*",
 		"@cline/ui": "workspace:*",
-		"@fontsource-variable/schibsted-grotesk": "^5.2.8",
-		"@fontsource/azeret-mono": "^5.2.9",
+		"@pierre/diffs": "^1.3.0",
+		"@fontsource-variable/geist-mono": "^5.2.8",
+		"@fontsource-variable/inter": "^5.2.8",
 		"@hookform/resolvers": "^3.9.1",
 		"@radix-ui/react-accordion": "1.2.12",
 		"@radix-ui/react-alert-dialog": "1.1.15",
@@ -65,13 +70,12 @@
 		"@shikijs/themes": "^4.2.0",
 		"@streamdown/cjk": "^1.0.3",
 		"@tauri-apps/api": "^2.0.0",
-		"@vercel/analytics": "1.6.1",
+		"ai": "^7.0.58",
 		"autoprefixer": "^10.4.20",
 		"class-variance-authority": "^0.7.1",
 		"clsx": "^2.1.1",
 		"cmdk": "1.1.1",
 		"date-fns": "4.1.0",
-		"embla-carousel-react": "8.6.0",
 		"input-otp": "1.4.2",
 		"lucide-react": "^0.564.0",
 		"next": "16.2.11",
@@ -83,13 +87,12 @@
 		"react-dom": "19.2.4",
 		"react-hook-form": "^7.54.1",
 		"react-resizable-panels": "^2.1.7",
-		"recharts": "2.15.0",
 		"shiki": "^4.0.2",
 		"sonner": "^1.7.1",
 		"streamdown": "^2.5.0",
 		"tailwind-merge": "^3.3.1",
 		"vaul": "^1.1.2",
-		"zod": "^3.24.1"
+		"zod": "^3.25.76"
 	},
 	"devDependencies": {
 		"@tauri-apps/cli": "^2.0.0",

apps/examples/desktop-app/scripts/build-sidecar-bin.ts

@@ -38,22 +38,54 @@ const sidecarOutfile = (targetTriple: string): string => {
 	return `./src-tauri/bin/code-sidecar-${targetTriple}${extension}`;
 };
 
-const buildSidecar = async (targetTriple: string): Promise<string> => {
-	const outfile = sidecarOutfile(targetTriple);
+const buildSidecar = async (
+	targetTriple: string,
+	outfile = sidecarOutfile(targetTriple),
+	entrypoint = "./sidecar/index.ts",
+	minify = false,
+): Promise<string> => {
 	const bunTarget = resolveBunCompileTarget(targetTriple);
 	// Telemetry config must be inlined into the compiled binary: a packaged
 	// app launched from Finder/the Dock has no OTEL_* env at runtime, so
 	// without this the sidecar silently ships with telemetry disabled.
 	// Verify with `<binary> --telemetry-selfcheck` after building.
 	const defines = telemetryDefineArgs();
+	const optimizationArgs = minify ? ["--minify"] : [];
+	// A compiled Bun executable otherwise reads .env and bunfig.toml from its
+	// launch directory before our entrypoint runs. Remote helpers are launched
+	// from an SSH user's home directory, so that behavior can both make the
+	// helper fail on an unrelated dotenv file and leak workspace credentials
+	// into the Hub process. Packaged binaries must depend only on their explicit
+	// process environment and compiled configuration.
+	const runtimeIsolationArgs = [
+		"--no-compile-autoload-dotenv",
+		"--no-compile-autoload-bunfig",
+	];
 	if (bunTarget) {
-		await $`bun build ./sidecar/index.ts --compile --target=${bunTarget} ${defines} --outfile ${outfile}`;
+		await $`bun build ${entrypoint} --compile --target=${bunTarget} ${runtimeIsolationArgs} ${optimizationArgs} ${defines} --outfile ${outfile}`;
 	} else {
-		await $`bun build ./sidecar/index.ts --compile ${defines} --outfile ${outfile}`;
+		await $`bun build ${entrypoint} --compile ${runtimeIsolationArgs} ${optimizationArgs} ${defines} --outfile ${outfile}`;
 	}
 	return outfile;
 };
 
+// SSH environments run the same Hub build as the desktop in a dedicated
+// bootstrap/daemon binary. It intentionally excludes the desktop HTTP server,
+// command router, and UI backend. Linux x64 and arm64 cover common SSH hosts.
+const buildRemoteHelpers = async (): Promise<void> => {
+	for (const targetTriple of [
+		"x86_64-unknown-linux-gnu",
+		"aarch64-unknown-linux-gnu",
+	]) {
+		await buildSidecar(
+			targetTriple,
+			`./src-tauri/bin/remote-helpers/code-sidecar-${targetTriple}`,
+			"./sidecar/remote-helper.ts",
+			true,
+		);
+	}
+};
+
 // Tauri's universal-apple-darwin pseudo-target lipos the Rust binary itself
 // but expects sidecars (externalBin) to already be fat binaries named
 // `<name>-universal-apple-darwin`, so build both slices and merge them here.
@@ -68,12 +100,13 @@ const buildUniversalMacSidecar = async (): Promise<void> => {
 
 const main = async () => {
 	const targetTriple = await resolveTargetTriple();
-	await $`mkdir -p src-tauri/bin`;
+	await $`mkdir -p src-tauri/bin src-tauri/bin/remote-helpers`;
 	if (targetTriple === "universal-apple-darwin") {
 		await buildUniversalMacSidecar();
-		return;
+	} else {
+		await buildSidecar(targetTriple);
 	}
-	await buildSidecar(targetTriple);
+	await buildRemoteHelpers();
 };
 
 main().catch((error: unknown) => {

apps/examples/desktop-app/scripts/telemetry-define-args.test.ts

@@ -65,6 +65,18 @@ describe("telemetryDefineArgs", () => {
 		expect(withKeys["process.env.ERROR_SERVICE_API_KEY"]).toBe('"ek"');
 	});
 
+	it("inlines the cloud-agents toggle only when set at build time", () => {
+		const withoutToggle = defineMap(telemetryDefineArgs({}));
+		expect(withoutToggle).not.toHaveProperty(
+			"process.env.CLINE_CODE_CLOUD_AGENTS",
+		);
+
+		const withToggle = defineMap(
+			telemetryDefineArgs({ CLINE_CODE_CLOUD_AGENTS: "1" }),
+		);
+		expect(withToggle["process.env.CLINE_CODE_CLOUD_AGENTS"]).toBe('"1"');
+	});
+
 	it("JSON-escapes values so headers with quotes survive the define", () => {
 		const defines = defineMap(
 			telemetryDefineArgs({

apps/examples/desktop-app/scripts/telemetry-define-args.ts

@@ -15,6 +15,9 @@ const OPTIONAL_SECRET_ENV_VARS = [
 	"ERROR_SERVICE_API_KEY",
 ] as const;
 
+/** Optional build-time overrides for packaged dogfood builds. */
+const OPTIONAL_FEATURE_ENV_VARS = ["CLINE_CODE_CLOUD_AGENTS"] as const;
+
 /**
  * Every env var `getTelemetryBuildTimeConfig` reads
  * (sdk/packages/shared/src/services/telemetry-config.ts). Always inlined,
@@ -42,7 +45,10 @@ export function telemetryDefineArgs(
 	const define = (name: string, value: string) => {
 		args.push("--define", `process.env.${name}=${JSON.stringify(value)}`);
 	};
-	for (const name of OPTIONAL_SECRET_ENV_VARS) {
+	for (const name of [
+		...OPTIONAL_SECRET_ENV_VARS,
+		...OPTIONAL_FEATURE_ENV_VARS,
+	]) {
 		const value = env[name];
 		if (value) {
 			define(name, value);

apps/examples/desktop-app/scripts/verify-ssh-poc.ts

@@ -0,0 +1,176 @@
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	ClineCore,
+	ProviderSettingsManager,
+	RuntimeOAuthTokenManager,
+	resolveProviderApiKeyFromSettings,
+	SessionSource,
+	toProviderConfig,
+} from "@cline/core";
+import { RemoteEnvironmentService } from "../sidecar/remote-environments";
+
+const required = (name: string): string => {
+	const value = process.env[name]?.trim();
+	if (!value) throw new Error(`${name} is required`);
+	return value;
+};
+
+async function main(): Promise<void> {
+	const temporaryDirectory = await mkdtemp(join(tmpdir(), "cline-ssh-proof-"));
+	const service = new RemoteEnvironmentService({
+		profilesPath: join(temporaryDirectory, "remote-environments.json"),
+		helperBinaryPath: required("CLINE_SSH_TEST_HELPER"),
+		knownHostsPath: join(temporaryDirectory, "known_hosts"),
+		commandTimeoutMs: 60_000,
+		uploadTimeoutMs: 5 * 60_000,
+	});
+	let core: ClineCore | undefined;
+
+	try {
+		const helperPath = required("CLINE_SSH_TEST_HELPER");
+		const workspaceRoot = required("CLINE_SSH_TEST_WORKSPACE");
+		const profile = await service.upsert({
+			name: "SSH proof host",
+			host: required("CLINE_SSH_TEST_HOST"),
+			user: process.env.CLINE_SSH_TEST_USER?.trim() || undefined,
+			identityFile: required("CLINE_SSH_TEST_KEY"),
+		});
+		const connection = await service.connect(profile.id);
+		const marker = await service.run(profile.id, {
+			command: "sed",
+			args: ["-n", "1p", "REMOTE_MARKER.txt"],
+			cwd: workspaceRoot,
+		});
+
+		const providerSettings = new ProviderSettingsManager();
+		const stored = providerSettings.read();
+		const providerId = stored.lastUsedProvider;
+		if (!providerId)
+			throw new Error("No configured desktop provider is available");
+		const settings = providerSettings.getProviderSettings(providerId);
+		if (!settings)
+			throw new Error(`No settings found for provider ${providerId}`);
+		const modelId = settings.model || "meta/muse-spark-1.2";
+		const providerConfig = {
+			...toProviderConfig(
+				{ ...settings, model: modelId },
+				{ includeKnownModels: false },
+			),
+		};
+		delete providerConfig.refreshToken;
+		const oauth = await new RuntimeOAuthTokenManager({
+			providerSettingsManager: providerSettings,
+		}).resolveProviderApiKey({ providerId });
+		const apiKey =
+			oauth?.apiKey ||
+			resolveProviderApiKeyFromSettings(providerSettings, providerId);
+		if (!apiKey)
+			throw new Error(`No credential found for provider ${providerId}`);
+
+		core = await ClineCore.create({
+			clientName: "cline-code",
+			backendMode: "remote",
+			remote: {
+				endpoint: connection.endpoint,
+				authToken: connection.authToken,
+				workspaceRoot: connection.workspaceRoot,
+				cwd: connection.workspaceRoot,
+				clientType: "code-sidecar-ssh",
+			},
+		});
+		const eventNames: string[] = [];
+		const unsubscribe = core.subscribe((event) => {
+			eventNames.push(event.type);
+		});
+		const started = await core.start({
+			config: {
+				providerId,
+				modelId,
+				apiKey,
+				providerConfig,
+				workspaceRoot,
+				cwd: workspaceRoot,
+				systemPrompt: "",
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+			source: SessionSource.DESKTOP,
+			interactive: true,
+			toolPolicies: { "*": { autoApprove: true } },
+		});
+		const result = await core.send({
+			sessionId: started.sessionId,
+			prompt:
+				"Read REMOTE_MARKER.txt from this workspace with the file-reading tool, then reply with its exact contents. Do not change any files.",
+		});
+		const sessions = await core.list(20, { hydrate: false });
+		const messages = await core.readMessages(started.sessionId);
+		unsubscribe();
+		await core.dispose("desktop_ssh_proof_reconnect");
+		core = undefined;
+		await service.disconnect(profile.id);
+
+		const reconnected = await service.connect(profile.id);
+		core = await ClineCore.create({
+			clientName: "cline-code",
+			backendMode: "remote",
+			remote: {
+				endpoint: reconnected.endpoint,
+				authToken: reconnected.authToken,
+				workspaceRoot: reconnected.workspaceRoot,
+				cwd: reconnected.workspaceRoot,
+				clientType: "code-sidecar-ssh",
+			},
+		});
+		const sessionsAfterReconnect = await core.list(20, { hydrate: false });
+		const messagesAfterReconnect = await core.readMessages(started.sessionId);
+
+		const resultText = result?.text ?? "";
+		const report = {
+			connected: true,
+			remote: `${connection.platform}/${connection.arch}`,
+			connectionRoot: connection.workspaceRoot,
+			workspaceRoot: started.manifest.workspace_root,
+			sessionId: started.sessionId,
+			listContainsSession: sessions.some(
+				(session) => session.sessionId === started.sessionId,
+			),
+			messageCount: messages.length,
+			reconnected: true,
+			reconnectListContainsSession: sessionsAfterReconnect.some(
+				(session) => session.sessionId === started.sessionId,
+			),
+			reconnectMessageCount: messagesAfterReconnect.length,
+			helperBytes: (await stat(helperPath)).size,
+			sshMarker: marker.stdout.trim(),
+			agentText: resultText,
+			agentObservedMarker: resultText.includes("remote workspace proof"),
+			eventNames: [...new Set(eventNames)],
+		};
+		if (
+			report.sshMarker !== "remote workspace proof" ||
+			!report.agentObservedMarker ||
+			!report.listContainsSession ||
+			!report.reconnectListContainsSession ||
+			report.messageCount < 2 ||
+			report.reconnectMessageCount < 2 ||
+			!report.eventNames.includes("agent_event")
+		) {
+			throw new Error(`SSH proof failed: ${JSON.stringify(report)}`);
+		}
+		process.stdout.write(`${JSON.stringify(report)}\n`);
+	} finally {
+		await core?.dispose("desktop_ssh_proof_complete");
+		await service.dispose();
+		await rm(temporaryDirectory, { recursive: true, force: true });
+	}
+}
+
+void main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});

apps/examples/desktop-app/sidecar/ARCHITECTURE.md

@@ -17,7 +17,11 @@ sidecar/
 ├── server.ts             # Bun HTTP server + WebSocket handlers
 ├── context.ts            # SidecarContext type and factory
 ├── commands.ts           # Command router
-├── chat-session.ts       # Shared-Hub chat session adapter
+├── chat-session.ts       # Shared-Hub chat session adapter (local + cloud routing)
+├── cloud-sessions.ts     # Cloud session REST client + Hub-proxy manager
+├── cline-auth.ts         # Refresh-aware Cline auth token resolution
+├── desktop-settings.ts   # Desktop-owned settings (cloud sessions opt-in)
+├── feature-flags.ts      # Cloud sessions gate (env override + settings toggle)
 ├── session-data/         # Shared discovery, messages, artifacts, search helpers
 ├── paths.ts              # Path resolution
 ├── types.ts              # Shared types
@@ -89,7 +93,7 @@ online:
 
 ```typescript
 const pendingApprovals = new Map<string, {
-  resolve: (result: ToolApprovalResult) => void;
+  resolve: (result: ToolApprovalResult) => void | Promise<void>;
   request: ToolApprovalRequest;
 }>();
 
@@ -97,6 +101,10 @@ const pendingApprovals = new Map<string, {
 // When frontend responds → resolve promise
 ```
 
+Cloud sessions route approvals the same way, but the resolver forwards the
+response to the sandbox Hub (`approval.respond`), which is why `resolve` may
+be async.
+
 ### 3. Provider Management — Direct ProviderSettingsManager
 
 ```typescript
@@ -138,22 +146,39 @@ Supported commands:
 
 | Command | Implementation |
 |---------|---------------|
-| `chat_session_command` | shared Hub through `ClineCore` |
+| `chat_session_command` | shared Hub through `ClineCore`; cloud sessions route to `CloudSessionManager` |
 | `list_provider_catalog` | `ProviderSettingsManager` + `listLocalProviders` |
 | `list_provider_models` | `getLocalProviderModels` |
+| `save_voice_input_settings` | validates and persists the selected transcription provider/model |
+| `create_streaming_transcription_session` | mints a short-lived, transcription-bound browser token without exposing provider credentials |
+| `transcribe_audio` | configured voice input selection + provider credentials |
 | `save_provider_settings` | `saveLocalProviderSettings` |
 | `add_provider` | `addLocalProvider` |
 | `run_provider_oauth_login` | `loginLocalProvider` |
-| `list_chat_sessions` | `SqliteSessionStore` + file discovery |
-| `list_discovered_sessions` | Merged discovery |
-| `read_session_messages` | Session data readers |
+| `list_chat_sessions` | `SqliteSessionStore` + file discovery, merged with cloud sessions (2s budget) |
+| `list_discovered_sessions` | Merged discovery (local + cloud) |
+| `read_session_messages` | Session data readers; cloud sessions read through the sandbox Hub |
 | `read_session_hooks` | Session data readers |
-| `delete_chat_session` | `SqliteSessionStore.delete` + file cleanup |
-| `update_chat_session_title` | `resolveSessionBackend().updateSession` |
+| `delete_chat_session` | `SqliteSessionStore.delete` + file cleanup; cloud sessions also delete the sandbox |
+| `update_chat_session_title` | `resolveSessionBackend().updateSession`; cloud sessions PATCH the cloud API |
+| `get_feature_flags` | `isCloudAgentsEnabled()` (env override + settings toggle) |
+| `get_desktop_settings` | `readDesktopSettings()` |
+| `set_cloud_sessions_enabled` | `setCloudSessionsEnabled()` + `feature_flags_changed` broadcast |
+| `list_cloud_repositories` | `CloudSessionManager.listRepositories()` (GitHub integration) |
+| `list_cloud_branches` | `CloudSessionManager.listBranches()` (paginated) |
 | `list_mcp_servers` | Direct file I/O |
+| `authorize_mcp_server_oauth` | Explicit Connect action → cancellable `authorizeMcpServerOAuth` + system browser |
+| `cancel_mcp_server_oauth` | Cancel the pending MCP OAuth callback wait |
 | `upsert_mcp_server` | Direct file I/O |
 | `delete_mcp_server` | Direct file I/O |
 | `get_git_branch` | async `execFile("git", ...)` |
+
+Realtime mode sessions expose only one browser-callable tool, `run_cline`, when
+the selected realtime model supports tool calling. The webview implements that
+tool by sending the request through the active Cline chat session and returning
+its persisted result to the realtime provider for playback. Cline remains the
+owner of workspace context, agent tools, MCP, approvals, and session history;
+provider credentials remain in the sidecar.
 | `list_git_branches` | async `execFile("git", ...)` |
 | `checkout_git_branch` | async `execFile("git", ...)` |
 | `search_workspace_files` | `getFileIndex` |