dap: Skip ConfigurationDone for GDB version < 17

.github/actionlint.yml

@@ -25,7 +25,6 @@ self-hosted-runner:
     - namespace-profile-32x64-ubuntu-2204
     # Namespace Ubuntu 24.04 (like ubuntu-latest)
     - namespace-profile-2x4-ubuntu-2404
-    - namespace-profile-8x32-ubuntu-2404
     # Namespace Limited Preview
     - namespace-profile-8x16-ubuntu-2004-arm-m4
     - namespace-profile-8x32-ubuntu-2004-arm-m4

.github/workflows/extension_bump.yml

@@ -66,7 +66,7 @@ jobs:
     if: |-
       (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions') &&
       (inputs.force-bump == 'true' || needs.check_bump_needed.outputs.needs_bump == 'true')
-    runs-on: namespace-profile-2x4-ubuntu-2404
+    runs-on: namespace-profile-8x16-ubuntu-2204
     steps:
     - id: generate-token
       name: extension_bump::generate_token
@@ -79,7 +79,7 @@ jobs:
       with:
         clean: false
     - name: extension_bump::install_bump_2_version
-      run: pip install bump2version --break-system-packages
+      run: pip install bump2version
       shell: bash -euxo pipefail {0}
     - id: bump-version
       name: extension_bump::bump_version
@@ -119,7 +119,7 @@ jobs:
     needs:
     - check_bump_needed
     if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions') && github.event_name == 'push' && github.ref == 'refs/heads/main' && needs.check_bump_needed.outputs.needs_bump == 'false'
-    runs-on: namespace-profile-2x4-ubuntu-2404
+    runs-on: namespace-profile-8x16-ubuntu-2204
     steps:
     - id: generate-token
       name: extension_bump::generate_token

.github/workflows/extension_release.yml

@@ -13,7 +13,7 @@ on:
 jobs:
   create_release:
     if: (github.repository_owner == 'zed-industries' || github.repository_owner == 'zed-extensions')
-    runs-on: namespace-profile-2x4-ubuntu-2404
+    runs-on: namespace-profile-8x16-ubuntu-2204
     steps:
     - id: generate-token
       name: extension_bump::generate_token

.github/workflows/extension_tests.yml

@@ -51,7 +51,7 @@ jobs:
     needs:
     - orchestrate
     if: needs.orchestrate.outputs.check_rust == 'true'
-    runs-on: namespace-profile-4x8-ubuntu-2204
+    runs-on: namespace-profile-16x32-ubuntu-2204
     steps:
     - name: steps::checkout_repo
       uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
@@ -79,7 +79,7 @@ jobs:
     needs:
     - orchestrate
     if: needs.orchestrate.outputs.check_extension == 'true'
-    runs-on: namespace-profile-8x32-ubuntu-2404
+    runs-on: namespace-profile-2x4-ubuntu-2404
     steps:
     - name: steps::checkout_repo
       uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683

.github/workflows/extension_workflow_rollout.yml

@@ -1,106 +0,0 @@
-# Generated from xtask::workflows::extension_workflow_rollout
-# Rebuild with `cargo xtask workflows`.
-name: extension_workflow_rollout
-env:
-  CARGO_TERM_COLOR: always
-on:
-  workflow_dispatch: {}
-jobs:
-  fetch_extension_repos:
-    runs-on: namespace-profile-2x4-ubuntu-2404
-    steps:
-    - id: list-repos
-      name: extension_workflow_rollout::fetch_extension_repos::get_repositories
-      uses: actions/github-script@v7
-      with:
-        script: |
-          const repos = await github.paginate(github.rest.repos.listForOrg, {
-              org: 'zed-extensions',
-              type: 'public',
-              per_page: 100,
-          });
-
-          const filteredRepos = repos
-              .filter(repo => !repo.archived)
-              .filter(repo => repo.name !== 'workflows' && repo.name !== 'material-icon-theme')
-              .map(repo => repo.name);
-
-          console.log(`Found ${filteredRepos.length} extension repos`);
-          return filteredRepos;
-        result-encoding: json
-    outputs:
-      repos: ${{ steps.list-repos.outputs.result }}
-    timeout-minutes: 5
-  rollout_workflows_to_extension:
-    needs:
-    - fetch_extension_repos
-    if: needs.fetch_extension_repos.outputs.repos != '[]'
-    runs-on: namespace-profile-2x4-ubuntu-2404
-    strategy:
-      matrix:
-        repo: ${{ fromJson(needs.fetch_extension_repos.outputs.repos) }}
-      fail-fast: false
-      max-parallel: 5
-    steps:
-    - id: generate-token
-      name: extension_bump::generate_token
-      uses: actions/create-github-app-token@v2
-      with:
-        app-id: ${{ secrets.ZED_ZIPPY_APP_ID }}
-        private-key: ${{ secrets.ZED_ZIPPY_APP_PRIVATE_KEY }}
-        owner: zed-extensions
-        repositories: ${{ matrix.repo }}
-        permission-pull-requests: write
-        permission-contents: write
-        permission-workflows: write
-    - name: checkout_zed_repo
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        clean: false
-        path: zed
-    - name: steps::checkout_repo_with_token
-      uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
-      with:
-        clean: false
-        token: ${{ steps.generate-token.outputs.token }}
-        repository: zed-extensions/${{ matrix.repo }}
-        path: extension
-    - name: extension_workflow_rollout::rollout_workflows_to_extension::copy_workflow_files
-      run: |
-        mkdir -p extension/.github/workflows
-        cp zed/extensions/workflows/shared/*.yml extension/.github/workflows/
-      shell: bash -euxo pipefail {0}
-    - id: short-sha
-      name: extension_workflow_rollout::rollout_workflows_to_extension::get_short_sha
-      run: |
-        echo "sha_short=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"
-      shell: bash -euxo pipefail {0}
-      working-directory: zed
-    - id: create-pr
-      name: extension_workflow_rollout::rollout_workflows_to_extension::create_pull_request
-      uses: peter-evans/create-pull-request@v7
-      with:
-        path: extension
-        title: Update CI workflows to `zed@${{ steps.short-sha.outputs.sha_short }}`
-        body: |
-          This PR updates the CI workflow files from the main Zed repository
-          based on the commit zed-industries/zed@${{ github.sha }}
-        commit-message: Update CI workflows to `zed@${{ steps.short-sha.outputs.sha_short }}`
-        branch: update-workflows
-        committer: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
-        author: zed-zippy[bot] <234243425+zed-zippy[bot]@users.noreply.github.com>
-        base: main
-        delete-branch: true
-        token: ${{ steps.generate-token.outputs.token }}
-        sign-commits: true
-    - name: extension_workflow_rollout::rollout_workflows_to_extension::enable_auto_merge
-      run: |
-        PR_NUMBER="${{ steps.create-pr.outputs.pull-request-number }}"
-        if [ -n "$PR_NUMBER" ]; then
-            cd extension
-            gh pr merge "$PR_NUMBER" --auto --squash
-        fi
-      shell: bash -euxo pipefail {0}
-      env:
-        GH_TOKEN: ${{ steps.generate-token.outputs.token }}
-    timeout-minutes: 10

.github/workflows/good_first_issue_notifier.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   handle-good-first-issue:
-    if: github.event.label.name == '.contrib/good first issue' && github.repository_owner == 'zed-industries'
+    if: github.event.label.name == 'good first issue' && github.repository_owner == 'zed-industries'
     runs-on: ubuntu-latest
 
     steps:

CONTRIBUTING.md

@@ -23,6 +23,7 @@ In particular we love PRs that are:
 
 If you're looking for concrete ideas:
 
+- [Curated board of issues](https://github.com/orgs/zed-industries/projects/69) suitable for everyone from first-time contributors to seasoned community champions.
 - [Triaged bugs with confirmed steps to reproduce](https://github.com/zed-industries/zed/issues?q=is%3Aissue%20state%3Aopen%20type%3ABug%20label%3Astate%3Areproducible).
 - [Area labels](https://github.com/zed-industries/zed/labels?q=area%3A*) to browse bugs in a specific part of the product you care about (after clicking on an area label, add type:Bug to the search).
 

Cargo.lock

@@ -268,7 +268,6 @@ dependencies = [
  "client",
  "collections",
  "env_logger 0.11.8",
- "feature_flags",
  "fs",
  "futures 0.3.31",
  "gpui",
@@ -2381,6 +2380,7 @@ dependencies = [
 name = "buffer_diff"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "clock",
  "ctor",
  "futures 0.3.31",
@@ -5212,7 +5212,6 @@ dependencies = [
  "anyhow",
  "arrayvec",
  "brotli",
- "buffer_diff",
  "client",
  "clock",
  "cloud_api_types",
@@ -5250,9 +5249,7 @@ dependencies = [
  "strum 0.27.2",
  "telemetry",
  "telemetry_events",
- "text",
  "thiserror 2.0.17",
- "time",
  "ui",
  "util",
  "uuid",
@@ -5357,10 +5354,8 @@ dependencies = [
  "anyhow",
  "buffer_diff",
  "client",
- "clock",
  "cloud_llm_client",
  "codestral",
- "collections",
  "command_palette_hooks",
  "copilot",
  "edit_prediction",
@@ -5369,20 +5364,18 @@ dependencies = [
  "feature_flags",
  "fs",
  "futures 0.3.31",
+ "git",
  "gpui",
  "indoc",
  "language",
- "language_model",
+ "log",
  "lsp",
  "markdown",
  "menu",
  "multi_buffer",
  "paths",
- "pretty_assertions",
  "project",
  "regex",
- "release_channel",
- "semver",
  "serde_json",
  "settings",
  "supermaven",
@@ -5395,7 +5388,6 @@ dependencies = [
  "workspace",
  "zed_actions",
  "zeta_prompt",
- "zlog",
 ]
 
 [[package]]
@@ -8653,7 +8645,6 @@ dependencies = [
  "extension",
  "gpui",
  "language",
- "lsp",
  "paths",
  "project",
  "schemars",
@@ -20964,7 +20955,7 @@ dependencies = [
 
 [[package]]
 name = "zed_glsl"
-version = "0.2.0"
+version = "0.1.0"
 dependencies = [
  "zed_extension_api 0.1.0",
 ]
@@ -20978,7 +20969,7 @@ dependencies = [
 
 [[package]]
 name = "zed_proto"
-version = "0.3.1"
+version = "0.3.0"
 dependencies = [
  "zed_extension_api 0.7.0",
 ]

assets/keymaps/default-linux.json

@@ -55,13 +55,6 @@
       "down": "menu::SelectNext",
     },
   },
-  {
-    "context": "menu",
-    "bindings": {
-      "right": "menu::SelectChild",
-      "left": "menu::SelectParent",
-    },
-  },
   {
     "context": "Editor",
     "bindings": {
@@ -248,7 +241,6 @@
       "ctrl-alt-l": "agent::OpenRulesLibrary",
       "ctrl-i": "agent::ToggleProfileSelector",
       "ctrl-alt-/": "agent::ToggleModelSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
       "ctrl-shift-j": "agent::ToggleNavigationMenu",
       "ctrl-alt-i": "agent::ToggleOptionsMenu",
       "ctrl-alt-shift-n": "agent::ToggleNewThreadMenu",
@@ -261,6 +253,7 @@
       "ctrl-y": "agent::AllowOnce",
       "ctrl-alt-y": "agent::AllowAlways",
       "ctrl-alt-z": "agent::RejectOnce",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -292,6 +285,38 @@
       "ctrl-alt-t": "agent::NewThread",
     },
   },
+  {
+    "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send",
+    "bindings": {
+      "enter": "agent::Chat",
+      "ctrl-enter": "agent::ChatWithFollow",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "ctrl-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "MessageEditor && !Picker > Editor && use_modifier_to_send",
+    "bindings": {
+      "ctrl-enter": "agent::Chat",
+      "enter": "editor::Newline",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "ctrl-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "EditMessageEditor > Editor",
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline",
+    },
+  },
   {
     "context": "AgentFeedbackMessageEditor > Editor",
     "bindings": {
@@ -306,25 +331,14 @@
       "ctrl-enter": "menu::Confirm",
     },
   },
-  {
-    "context": "AcpThread > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "ctrl-enter": "agent::ChatWithFollow",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "ctrl-shift-r": "agent::OpenAgentDiff",
-      "ctrl-shift-y": "agent::KeepAll",
-      "ctrl-shift-n": "agent::RejectAll",
-      "ctrl-shift-v": "agent::PasteRaw",
-      "shift-tab": "agent::CycleModeSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
-    },
-  },
   {
     "context": "AcpThread > Editor && !use_modifier_to_send",
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
     },
   },
   {
@@ -332,7 +346,11 @@
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-enter": "agent::Chat",
-      "enter": "editor::Newline",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -799,7 +817,7 @@
     },
   },
   {
-    "context": "InlineAssistant",
+    "context": "PromptEditor",
     "bindings": {
       "ctrl-[": "agent::CyclePreviousInlineAssist",
       "ctrl-]": "agent::CycleNextInlineAssist",

assets/keymaps/default-macos.json

@@ -54,13 +54,6 @@
       "ctrl-cmd-s": "workspace::ToggleWorktreeSecurity",
     },
   },
-  {
-    "context": "menu",
-    "bindings": {
-      "right": "menu::SelectChild",
-      "left": "menu::SelectParent",
-    },
-  },
   {
     "context": "Editor",
     "use_key_equivalents": true,
@@ -289,7 +282,6 @@
       "cmd-alt-p": "agent::ManageProfiles",
       "cmd-i": "agent::ToggleProfileSelector",
       "cmd-alt-/": "agent::ToggleModelSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
       "cmd-shift-j": "agent::ToggleNavigationMenu",
       "cmd-alt-m": "agent::ToggleOptionsMenu",
       "cmd-alt-shift-n": "agent::ToggleNewThreadMenu",
@@ -302,6 +294,7 @@
       "cmd-y": "agent::AllowOnce",
       "cmd-alt-y": "agent::AllowAlways",
       "cmd-alt-z": "agent::RejectOnce",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -333,6 +326,41 @@
       "cmd-alt-t": "agent::NewThread",
     },
   },
+  {
+    "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "enter": "agent::Chat",
+      "cmd-enter": "agent::ChatWithFollow",
+      "cmd-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll",
+      "cmd-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "MessageEditor && !Picker > Editor && use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "cmd-enter": "agent::Chat",
+      "enter": "editor::Newline",
+      "cmd-i": "agent::ToggleProfileSelector",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll",
+      "cmd-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "EditMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline",
+    },
+  },
   {
     "context": "AgentFeedbackMessageEditor > Editor",
     "use_key_equivalents": true,
@@ -354,25 +382,16 @@
       "cmd-enter": "menu::Confirm",
     },
   },
-  {
-    "context": "AcpThread > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "shift-ctrl-r": "agent::OpenAgentDiff",
-      "cmd-shift-y": "agent::KeepAll",
-      "cmd-shift-n": "agent::RejectAll",
-      "cmd-enter": "agent::ChatWithFollow",
-      "cmd-shift-v": "agent::PasteRaw",
-      "cmd-i": "agent::ToggleProfileSelector",
-      "shift-tab": "agent::CycleModeSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
-    },
-  },
   {
     "context": "AcpThread > Editor && !use_modifier_to_send",
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -380,7 +399,11 @@
     "use_key_equivalents": true,
     "bindings": {
       "cmd-enter": "agent::Chat",
-      "enter": "editor::Newline",
+      "shift-ctrl-r": "agent::OpenAgentDiff",
+      "cmd-shift-y": "agent::KeepAll",
+      "cmd-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -860,7 +883,7 @@
     },
   },
   {
-    "context": "InlineAssistant > Editor",
+    "context": "PromptEditor",
     "use_key_equivalents": true,
     "bindings": {
       "cmd-alt-/": "agent::ToggleModelSelector",

assets/keymaps/default-windows.json

@@ -54,13 +54,6 @@
       "down": "menu::SelectNext",
     },
   },
-  {
-    "context": "menu",
-    "bindings": {
-      "right": "menu::SelectChild",
-      "left": "menu::SelectParent",
-    },
-  },
   {
     "context": "Editor",
     "use_key_equivalents": true,
@@ -248,7 +241,6 @@
       "shift-alt-l": "agent::OpenRulesLibrary",
       "shift-alt-p": "agent::ManageProfiles",
       "ctrl-i": "agent::ToggleProfileSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
       "shift-alt-/": "agent::ToggleModelSelector",
       "shift-alt-j": "agent::ToggleNavigationMenu",
       "shift-alt-i": "agent::ToggleOptionsMenu",
@@ -262,6 +254,7 @@
       "shift-alt-a": "agent::AllowOnce",
       "ctrl-alt-y": "agent::AllowAlways",
       "shift-alt-z": "agent::RejectOnce",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -294,6 +287,41 @@
       "ctrl-alt-t": "agent::NewThread",
     },
   },
+  {
+    "context": "MessageEditor && !Picker > Editor && !use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "enter": "agent::Chat",
+      "ctrl-enter": "agent::ChatWithFollow",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "ctrl-shift-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "ctrl-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "MessageEditor && !Picker > Editor && use_modifier_to_send",
+    "use_key_equivalents": true,
+    "bindings": {
+      "ctrl-enter": "agent::Chat",
+      "enter": "editor::Newline",
+      "ctrl-i": "agent::ToggleProfileSelector",
+      "ctrl-shift-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "ctrl-shift-v": "agent::PasteRaw",
+    },
+  },
+  {
+    "context": "EditMessageEditor > Editor",
+    "use_key_equivalents": true,
+    "bindings": {
+      "escape": "menu::Cancel",
+      "enter": "menu::Confirm",
+      "alt-enter": "editor::Newline",
+    },
+  },
   {
     "context": "AgentFeedbackMessageEditor > Editor",
     "use_key_equivalents": true,
@@ -309,25 +337,16 @@
       "ctrl-enter": "menu::Confirm",
     },
   },
-  {
-    "context": "AcpThread > Editor",
-    "use_key_equivalents": true,
-    "bindings": {
-      "ctrl-enter": "agent::ChatWithFollow",
-      "ctrl-i": "agent::ToggleProfileSelector",
-      "ctrl-shift-r": "agent::OpenAgentDiff",
-      "ctrl-shift-y": "agent::KeepAll",
-      "ctrl-shift-n": "agent::RejectAll",
-      "ctrl-shift-v": "agent::PasteRaw",
-      "shift-tab": "agent::CycleModeSelector",
-      "alt-tab": "agent::CycleFavoriteModels",
-    },
-  },
   {
     "context": "AcpThread > Editor && !use_modifier_to_send",
     "use_key_equivalents": true,
     "bindings": {
       "enter": "agent::Chat",
+      "ctrl-shift-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -335,7 +354,11 @@
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-enter": "agent::Chat",
-      "enter": "editor::Newline",
+      "ctrl-shift-r": "agent::OpenAgentDiff",
+      "ctrl-shift-y": "agent::KeepAll",
+      "ctrl-shift-n": "agent::RejectAll",
+      "shift-tab": "agent::CycleModeSelector",
+      "alt-tab": "agent::CycleFavoriteModels",
     },
   },
   {
@@ -803,7 +826,7 @@
     },
   },
   {
-    "context": "InlineAssistant",
+    "context": "PromptEditor",
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-[": "agent::CyclePreviousInlineAssist",

assets/keymaps/linux/cursor.json

@@ -24,7 +24,7 @@
     },
   },
   {
-    "context": "InlineAssistant > Editor",
+    "context": "InlineAssistEditor",
     "use_key_equivalents": true,
     "bindings": {
       "ctrl-shift-backspace": "editor::Cancel",

assets/keymaps/macos/cursor.json

@@ -24,7 +24,7 @@
     },
   },
   {
-    "context": "InlineAssistant > Editor",
+    "context": "InlineAssistEditor",
     "use_key_equivalents": true,
     "bindings": {
       "cmd-shift-backspace": "editor::Cancel",

crates/acp_thread/src/acp_thread.rs

@@ -11,7 +11,6 @@ use language::language_settings::FormatOnSave;
 pub use mention::*;
 use project::lsp_store::{FormatTrigger, LspFormatTarget};
 use serde::{Deserialize, Serialize};
-use serde_json::to_string_pretty;
 use settings::Settings as _;
 use task::{Shell, ShellBuilder};
 pub use terminal::*;
@@ -884,7 +883,6 @@ pub enum AcpThreadEvent {
     Refusal,
     AvailableCommandsUpdated(Vec<acp::AvailableCommand>),
     ModeUpdated(acp::SessionModeId),
-    ConfigOptionsUpdated(Vec<acp::SessionConfigOption>),
 }
 
 impl EventEmitter<AcpThreadEvent> for AcpThread {}
@@ -1194,10 +1192,6 @@ impl AcpThread {
                 current_mode_id,
                 ..
             }) => cx.emit(AcpThreadEvent::ModeUpdated(current_mode_id)),
-            acp::SessionUpdate::ConfigOptionUpdate(acp::ConfigOptionUpdate {
-                config_options,
-                ..
-            }) => cx.emit(AcpThreadEvent::ConfigOptionsUpdated(config_options)),
             _ => {}
         }
         Ok(())
@@ -1998,42 +1992,37 @@ impl AcpThread {
     fn update_last_checkpoint(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
         let git_store = self.project.read(cx).git_store().clone();
 
-        let Some((_, message)) = self.last_user_message() else {
+        let old_checkpoint = if let Some((_, message)) = self.last_user_message() {
+            if let Some(checkpoint) = message.checkpoint.as_ref() {
+                checkpoint.git_checkpoint.clone()
+            } else {
+                return Task::ready(Ok(()));
+            }
+        } else {
             return Task::ready(Ok(()));
         };
-        let Some(user_message_id) = message.id.clone() else {
-            return Task::ready(Ok(()));
-        };
-        let Some(checkpoint) = message.checkpoint.as_ref() else {
-            return Task::ready(Ok(()));
-        };
-        let old_checkpoint = checkpoint.git_checkpoint.clone();
 
         let new_checkpoint = git_store.update(cx, |git, cx| git.checkpoint(cx));
         cx.spawn(async move |this, cx| {
-            let Some(new_checkpoint) = new_checkpoint
+            let new_checkpoint = new_checkpoint
                 .await
                 .context("failed to get new checkpoint")
-                .log_err()
-            else {
-                return Ok(());
-            };
-
-            let equal = git_store
-                .update(cx, |git, cx| {
-                    git.compare_checkpoints(old_checkpoint.clone(), new_checkpoint, cx)
-                })?
-                .await
-                .unwrap_or(true);
-
-            this.update(cx, |this, cx| {
-                if let Some((ix, message)) = this.user_message_mut(&user_message_id) {
-                    if let Some(checkpoint) = message.checkpoint.as_mut() {
-                        checkpoint.show = !equal;
-                        cx.emit(AcpThreadEvent::EntryUpdated(ix));
-                    }
-                }
-            })?;
+                .log_err();
+            if let Some(new_checkpoint) = new_checkpoint {
+                let equal = git_store
+                    .update(cx, |git, cx| {
+                        git.compare_checkpoints(old_checkpoint.clone(), new_checkpoint, cx)
+                    })?
+                    .await
+                    .unwrap_or(true);
+                this.update(cx, |this, cx| {
+                    let (ix, message) = this.last_user_message().context("no user message")?;
+                    let checkpoint = message.checkpoint.as_mut().context("no checkpoint")?;
+                    checkpoint.show = !equal;
+                    cx.emit(AcpThreadEvent::EntryUpdated(ix));
+                    anyhow::Ok(())
+                })??;
+            }
 
             Ok(())
         })
@@ -2433,10 +2422,8 @@ fn markdown_for_raw_output(
             )
         })),
         value => Some(cx.new(|cx| {
-            let pretty_json = to_string_pretty(value).unwrap_or_else(|_| value.to_string());
-
             Markdown::new(
-                format!("```json\n{}\n```", pretty_json).into(),
+                format!("```json\n{}\n```", value).into(),
                 Some(language_registry.clone()),
                 None,
                 cx,
@@ -4079,67 +4066,4 @@ mod tests {
             "Should have exactly 2 terminals (the completed ones from before checkpoint)"
         );
     }
-
-    /// Tests that update_last_checkpoint correctly updates the original message's checkpoint
-    /// even when a new user message is added while the async checkpoint comparison is in progress.
-    ///
-    /// This is a regression test for a bug where update_last_checkpoint would fail with
-    /// "no checkpoint" if a new user message (without a checkpoint) was added between when
-    /// update_last_checkpoint started and when its async closure ran.
-    #[gpui::test]
-    async fn test_update_last_checkpoint_with_new_message_added(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.executor());
-        fs.insert_tree(path!("/test"), json!({".git": {}, "file.txt": "content"}))
-            .await;
-        let project = Project::test(fs.clone(), [Path::new(path!("/test"))], cx).await;
-
-        let handler_done = Arc::new(AtomicBool::new(false));
-        let handler_done_clone = handler_done.clone();
-        let connection = Rc::new(FakeAgentConnection::new().on_user_message(
-            move |_, _thread, _cx| {
-                handler_done_clone.store(true, SeqCst);
-                async move { Ok(acp::PromptResponse::new(acp::StopReason::EndTurn)) }.boxed_local()
-            },
-        ));
-
-        let thread = cx
-            .update(|cx| connection.new_thread(project, Path::new(path!("/test")), cx))
-            .await
-            .unwrap();
-
-        let send_future = thread.update(cx, |thread, cx| thread.send_raw("First message", cx));
-        let send_task = cx.background_executor.spawn(send_future);
-
-        // Tick until handler completes, then a few more to let update_last_checkpoint start
-        while !handler_done.load(SeqCst) {
-            cx.executor().tick();
-        }
-        for _ in 0..5 {
-            cx.executor().tick();
-        }
-
-        thread.update(cx, |thread, cx| {
-            thread.push_entry(
-                AgentThreadEntry::UserMessage(UserMessage {
-                    id: Some(UserMessageId::new()),
-                    content: ContentBlock::Empty,
-                    chunks: vec!["Injected message (no checkpoint)".into()],
-                    checkpoint: None,
-                    indented: false,
-                }),
-                cx,
-            );
-        });
-
-        cx.run_until_parked();
-        let result = send_task.await;
-
-        assert!(
-            result.is_ok(),
-            "send should succeed even when new message added during update_last_checkpoint: {:?}",
-            result.err()
-        );
-    }
 }

crates/acp_thread/src/connection.rs

@@ -86,14 +86,6 @@ pub trait AgentConnection {
         None
     }
 
-    fn session_config_options(
-        &self,
-        _session_id: &acp::SessionId,
-        _cx: &App,
-    ) -> Option<Rc<dyn AgentSessionConfigOptions>> {
-        None
-    }
-
     fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
 
@@ -133,26 +125,6 @@ pub trait AgentSessionModes {
     fn set_mode(&self, mode: acp::SessionModeId, cx: &mut App) -> Task<Result<()>>;
 }
 
-pub trait AgentSessionConfigOptions {
-    /// Get all current config options with their state
-    fn config_options(&self) -> Vec<acp::SessionConfigOption>;
-
-    /// Set a config option value
-    /// Returns the full updated list of config options
-    fn set_config_option(
-        &self,
-        config_id: acp::SessionConfigId,
-        value: acp::SessionConfigValueId,
-        cx: &mut App,
-    ) -> Task<Result<Vec<acp::SessionConfigOption>>>;
-
-    /// Whenever the config options are updated the receiver will be notified.
-    /// Optional for agents that don't update their config options dynamically.
-    fn watch(&self, _cx: &mut App) -> Option<watch::Receiver<()>> {
-        None
-    }
-}
-
 #[derive(Debug)]
 pub struct AuthRequired {
     pub description: Option<String>,
@@ -230,6 +202,12 @@ pub trait AgentModelSelector: 'static {
     fn should_render_footer(&self) -> bool {
         false
     }
+
+    /// Whether this selector supports the favorites feature.
+    /// Only the native agent uses the model ID format that maps to settings.
+    fn supports_favorites(&self) -> bool {
+        false
+    }
 }
 
 /// Icon for a model in the model selector.

crates/acp_thread/src/diff.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
-use buffer_diff::BufferDiff;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use editor::{MultiBuffer, PathKey, multibuffer_context_lines};
 use gpui::{App, AppContext, AsyncApp, Context, Entity, Subscription, Task};
 use itertools::Itertools;
 use language::{
-    Anchor, Buffer, Capability, LanguageRegistry, OffsetRangeExt as _, Point, TextBuffer,
+    Anchor, Buffer, Capability, LanguageRegistry, OffsetRangeExt as _, Point, Rope, TextBuffer,
 };
 use std::{cmp::Reverse, ops::Range, path::Path, sync::Arc};
 use util::ResultExt;
@@ -49,15 +49,15 @@ impl Diff {
                     .update(cx, |multibuffer, cx| {
                         let hunk_ranges = {
                             let buffer = buffer.read(cx);
-                            diff.read(cx)
-                                .snapshot(cx)
-                                .hunks_intersecting_range(
-                                    Anchor::min_for_buffer(buffer.remote_id())
-                                        ..Anchor::max_for_buffer(buffer.remote_id()),
-                                    buffer,
-                                )
-                                .map(|diff_hunk| diff_hunk.buffer_range.to_point(buffer))
-                                .collect::<Vec<_>>()
+                            let diff = diff.read(cx);
+                            diff.hunks_intersecting_range(
+                                Anchor::min_for_buffer(buffer.remote_id())
+                                    ..Anchor::max_for_buffer(buffer.remote_id()),
+                                buffer,
+                                cx,
+                            )
+                            .map(|diff_hunk| diff_hunk.buffer_range.to_point(buffer))
+                            .collect::<Vec<_>>()
                         };
 
                         multibuffer.set_excerpts_for_path(
@@ -86,9 +86,17 @@ impl Diff {
 
     pub fn new(buffer: Entity<Buffer>, cx: &mut Context<Self>) -> Self {
         let buffer_text_snapshot = buffer.read(cx).text_snapshot();
+        let base_text_snapshot = buffer.read(cx).snapshot();
+        let base_text = base_text_snapshot.text();
+        debug_assert_eq!(buffer_text_snapshot.text(), base_text);
         let buffer_diff = cx.new(|cx| {
-            let mut diff = BufferDiff::new_unchanged(&buffer_text_snapshot, cx);
-            let secondary_diff = cx.new(|cx| BufferDiff::new_unchanged(&buffer_text_snapshot, cx));
+            let mut diff = BufferDiff::new_unchanged(&buffer_text_snapshot, base_text_snapshot);
+            let snapshot = diff.snapshot(cx);
+            let secondary_diff = cx.new(|cx| {
+                let mut diff = BufferDiff::new(&buffer_text_snapshot, cx);
+                diff.set_snapshot(snapshot, &buffer_text_snapshot, cx);
+                diff
+            });
             diff.set_secondary_diff(secondary_diff);
             diff
         });
@@ -101,7 +109,7 @@ impl Diff {
 
         Self::Pending(PendingDiff {
             multibuffer,
-            base_text: Arc::from(buffer_text_snapshot.text().as_str()),
+            base_text: Arc::new(base_text),
             _subscription: cx.observe(&buffer, |this, _, cx| {
                 if let Diff::Pending(diff) = this {
                     diff.update(cx);
@@ -168,7 +176,7 @@ impl Diff {
                 new_buffer,
                 ..
             }) => {
-                base_text.as_ref() != old_text
+                base_text.as_str() != old_text
                     || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
             }
             Diff::Finalized(FinalizedDiff {
@@ -176,7 +184,7 @@ impl Diff {
                 new_buffer,
                 ..
             }) => {
-                base_text.as_ref() != old_text
+                base_text.as_str() != old_text
                     || !new_buffer.read(cx).as_rope().chunks().equals_str(new_text)
             }
         }
@@ -185,7 +193,7 @@ impl Diff {
 
 pub struct PendingDiff {
     multibuffer: Entity<MultiBuffer>,
-    base_text: Arc<str>,
+    base_text: Arc<String>,
     new_buffer: Entity<Buffer>,
     diff: Entity<BufferDiff>,
     revealed_ranges: Vec<Range<Anchor>>,
@@ -200,22 +208,21 @@ impl PendingDiff {
         let base_text = self.base_text.clone();
         self.update_diff = cx.spawn(async move |diff, cx| {
             let text_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot())?;
-            let language = buffer.read_with(cx, |buffer, _| buffer.language().cloned())?;
-            let update = buffer_diff
-                .update(cx, |diff, cx| {
-                    diff.update_diff(
-                        text_snapshot.clone(),
-                        Some(base_text.clone()),
-                        false,
-                        language,
-                        cx,
-                    )
-                })?
-                .await;
+            let diff_snapshot = BufferDiff::update_diff(
+                buffer_diff.clone(),
+                text_snapshot.clone(),
+                Some(base_text),
+                false,
+                false,
+                None,
+                None,
+                cx,
+            )
+            .await?;
             buffer_diff.update(cx, |diff, cx| {
-                diff.set_snapshot(update.clone(), &text_snapshot, cx);
+                diff.set_snapshot(diff_snapshot.clone(), &text_snapshot, cx);
                 diff.secondary_diff().unwrap().update(cx, |diff, cx| {
-                    diff.set_snapshot(update, &text_snapshot, cx);
+                    diff.set_snapshot(diff_snapshot.clone(), &text_snapshot, cx);
                 });
             })?;
             diff.update(cx, |diff, cx| {
@@ -312,14 +319,13 @@ impl PendingDiff {
 
     fn excerpt_ranges(&self, cx: &App) -> Vec<Range<Point>> {
         let buffer = self.new_buffer.read(cx);
-        let mut ranges = self
-            .diff
-            .read(cx)
-            .snapshot(cx)
+        let diff = self.diff.read(cx);
+        let mut ranges = diff
             .hunks_intersecting_range(
                 Anchor::min_for_buffer(buffer.remote_id())
                     ..Anchor::max_for_buffer(buffer.remote_id()),
                 buffer,
+                cx,
             )
             .map(|diff_hunk| diff_hunk.buffer_range.to_point(buffer))
             .collect::<Vec<_>>();
@@ -351,47 +357,60 @@ impl PendingDiff {
 
 pub struct FinalizedDiff {
     path: String,
-    base_text: Arc<str>,
+    base_text: Arc<String>,
     new_buffer: Entity<Buffer>,
     multibuffer: Entity<MultiBuffer>,
     _update_diff: Task<Result<()>>,
 }
 
 async fn build_buffer_diff(
-    old_text: Arc<str>,
+    old_text: Arc<String>,
     buffer: &Entity<Buffer>,
     language_registry: Option<Arc<LanguageRegistry>>,
     cx: &mut AsyncApp,
 ) -> Result<Entity<BufferDiff>> {
-    let language = cx.update(|cx| buffer.read(cx).language().cloned())?;
     let buffer = cx.update(|cx| buffer.read(cx).snapshot())?;
 
-    let secondary_diff = cx.new(|cx| BufferDiff::new(&buffer, cx))?;
-
-    let update = secondary_diff
-        .update(cx, |secondary_diff, cx| {
-            secondary_diff.update_diff(
-                buffer.text.clone(),
-                Some(old_text),
-                true,
-                language.clone(),
+    let old_text_rope = cx
+        .background_spawn({
+            let old_text = old_text.clone();
+            async move { Rope::from(old_text.as_str()) }
+        })
+        .await;
+    let base_buffer = cx
+        .update(|cx| {
+            Buffer::build_snapshot(
+                old_text_rope,
+                buffer.language().cloned(),
+                language_registry,
                 cx,
             )
         })?
         .await;
 
-    secondary_diff.update(cx, |secondary_diff, cx| {
-        secondary_diff.language_changed(language.clone(), language_registry.clone(), cx);
-        secondary_diff.set_snapshot(update.clone(), &buffer, cx);
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
+                buffer.text.clone(),
+                Some(old_text),
+                base_buffer,
+                cx,
+            )
+        })?
+        .await;
+
+    let secondary_diff = cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer, cx);
+        diff.set_snapshot(diff_snapshot.clone(), &buffer, cx);
+        diff
     })?;
 
-    let diff = cx.new(|cx| BufferDiff::new(&buffer, cx))?;
-    diff.update(cx, |diff, cx| {
-        diff.language_changed(language, language_registry, cx);
-        diff.set_snapshot(update.clone(), &buffer, cx);
+    cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer.text, cx);
+        diff.set_snapshot(diff_snapshot, &buffer, cx);
         diff.set_secondary_diff(secondary_diff);
-    })?;
-    Ok(diff)
+        diff
+    })
 }
 
 #[cfg(test)]

crates/acp_tools/src/acp_tools.rs

@@ -4,20 +4,22 @@ use std::{
     fmt::Display,
     rc::{Rc, Weak},
     sync::Arc,
+    time::Duration,
 };
 
 use agent_client_protocol as acp;
 use collections::HashMap;
 use gpui::{
-    App, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment, ListState,
-    StyleRefinement, Subscription, Task, TextStyleRefinement, Window, actions, list, prelude::*,
+    App, ClipboardItem, Empty, Entity, EventEmitter, FocusHandle, Focusable, Global, ListAlignment,
+    ListState, StyleRefinement, Subscription, Task, TextStyleRefinement, Window, actions, list,
+    prelude::*,
 };
 use language::LanguageRegistry;
 use markdown::{CodeBlockRenderer, Markdown, MarkdownElement, MarkdownStyle};
 use project::Project;
 use settings::Settings;
 use theme::ThemeSettings;
-use ui::{CopyButton, Tooltip, WithScrollbar, prelude::*};
+use ui::{Tooltip, WithScrollbar, prelude::*};
 use util::ResultExt as _;
 use workspace::{
     Item, ItemHandle, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
@@ -542,11 +544,15 @@ impl Render for AcpTools {
 
 pub struct AcpToolsToolbarItemView {
     acp_tools: Option<Entity<AcpTools>>,
+    just_copied: bool,
 }
 
 impl AcpToolsToolbarItemView {
     pub fn new() -> Self {
-        Self { acp_tools: None }
+        Self {
+            acp_tools: None,
+            just_copied: false,
+        }
     }
 }
 
@@ -566,14 +572,37 @@ impl Render for AcpToolsToolbarItemView {
         h_flex()
             .gap_2()
             .child({
-                let message = acp_tools
-                    .read(cx)
-                    .serialize_observed_messages()
-                    .unwrap_or_default();
+                let acp_tools = acp_tools.clone();
+                IconButton::new(
+                    "copy_all_messages",
+                    if self.just_copied {
+                        IconName::Check
+                    } else {
+                        IconName::Copy
+                    },
+                )
+                .icon_size(IconSize::Small)
+                .tooltip(Tooltip::text(if self.just_copied {
+                    "Copied!"
+                } else {
+                    "Copy All Messages"
+                }))
+                .disabled(!has_messages)
+                .on_click(cx.listener(move |this, _, _window, cx| {
+                    if let Some(content) = acp_tools.read(cx).serialize_observed_messages() {
+                        cx.write_to_clipboard(ClipboardItem::new_string(content));
 
-                CopyButton::new(message)
-                    .tooltip_label("Copy All Messages")
-                    .disabled(!has_messages)
+                        this.just_copied = true;
+                        cx.spawn(async move |this, cx| {
+                            cx.background_executor().timer(Duration::from_secs(2)).await;
+                            this.update(cx, |this, cx| {
+                                this.just_copied = false;
+                                cx.notify();
+                            })
+                        })
+                        .detach();
+                    }
+                }))
             })
             .child(
                 IconButton::new("clear_messages", IconName::Trash)

crates/action_log/src/action_log.rs

@@ -262,7 +262,7 @@ impl ActionLog {
                         );
                     }
 
-                    (Arc::from(base_text.to_string().as_str()), base_text)
+                    (Arc::new(base_text.to_string()), base_text)
                 }
             });
 
@@ -302,7 +302,7 @@ impl ActionLog {
                     .context("buffer not tracked")?;
                 let old_unreviewed_edits = tracked_buffer.unreviewed_edits.clone();
                 let agent_diff_base = tracked_buffer.diff_base.clone();
-                let git_diff_base = git_diff.read(cx).base_text(cx).as_rope().clone();
+                let git_diff_base = git_diff.read(cx).base_text().as_rope().clone();
                 let buffer_text = tracked_buffer.snapshot.as_rope().clone();
                 anyhow::Ok(cx.background_spawn(async move {
                     let mut old_unreviewed_edits = old_unreviewed_edits.into_iter().peekable();
@@ -352,7 +352,7 @@ impl ActionLog {
                     }
 
                     (
-                        Arc::from(new_agent_diff_base.to_string().as_str()),
+                        Arc::new(new_agent_diff_base.to_string()),
                         new_agent_diff_base,
                     )
                 }))
@@ -374,11 +374,11 @@ impl ActionLog {
         this: &WeakEntity<ActionLog>,
         buffer: &Entity<Buffer>,
         buffer_snapshot: text::BufferSnapshot,
-        new_base_text: Arc<str>,
+        new_base_text: Arc<String>,
         new_diff_base: Rope,
         cx: &mut AsyncApp,
     ) -> Result<()> {
-        let (diff, language) = this.read_with(cx, |this, cx| {
+        let (diff, language, language_registry) = this.read_with(cx, |this, cx| {
             let tracked_buffer = this
                 .tracked_buffers
                 .get(buffer)
@@ -386,28 +386,25 @@ impl ActionLog {
             anyhow::Ok((
                 tracked_buffer.diff.clone(),
                 buffer.read(cx).language().cloned(),
+                buffer.read(cx).language_registry(),
             ))
         })??;
-        let update = diff.update(cx, |diff, cx| {
-            diff.update_diff(
-                buffer_snapshot.clone(),
-                Some(new_base_text),
-                true,
-                language,
-                cx,
-            )
-        });
+        let diff_snapshot = BufferDiff::update_diff(
+            diff.clone(),
+            buffer_snapshot.clone(),
+            Some(new_base_text),
+            true,
+            false,
+            language,
+            language_registry,
+            cx,
+        )
+        .await;
         let mut unreviewed_edits = Patch::default();
-        if let Ok(update) = update {
-            let update = update.await;
-
-            let diff_snapshot = diff.update(cx, |diff, cx| {
-                diff.set_snapshot(update.clone(), &buffer_snapshot, cx);
-                diff.snapshot(cx)
-            })?;
-
+        if let Ok(diff_snapshot) = diff_snapshot {
             unreviewed_edits = cx
                 .background_spawn({
+                    let diff_snapshot = diff_snapshot.clone();
                     let buffer_snapshot = buffer_snapshot.clone();
                     let new_diff_base = new_diff_base.clone();
                     async move {
@@ -434,6 +431,10 @@ impl ActionLog {
                     }
                 })
                 .await;
+
+            diff.update(cx, |diff, cx| {
+                diff.set_snapshot(diff_snapshot, &buffer_snapshot, cx);
+            })?;
         }
         this.update(cx, |this, cx| {
             let tracked_buffer = this
@@ -974,8 +975,7 @@ impl TrackedBuffer {
     fn has_edits(&self, cx: &App) -> bool {
         self.diff
             .read(cx)
-            .snapshot(cx)
-            .hunks(self.buffer.read(cx))
+            .hunks(self.buffer.read(cx), cx)
             .next()
             .is_some()
     }
@@ -2388,14 +2388,13 @@ mod tests {
                     (
                         buffer,
                         diff.read(cx)
-                            .snapshot(cx)
-                            .hunks(&snapshot)
+                            .hunks(&snapshot, cx)
                             .map(|hunk| HunkStatus {
                                 diff_status: hunk.status().kind,
                                 range: hunk.range,
                                 old_text: diff
                                     .read(cx)
-                                    .base_text(cx)
+                                    .base_text()
                                     .text_for_range(hunk.diff_base_byte_range)
                                     .collect(),
                             })

crates/agent/src/agent.rs

@@ -1167,6 +1167,10 @@ impl acp_thread::AgentModelSelector for NativeAgentModelSelector {
     fn should_render_footer(&self) -> bool {
         true
     }
+
+    fn supports_favorites(&self) -> bool {
+        true
+    }
 }
 
 impl acp_thread::AgentConnection for NativeAgentConnection {

crates/agent/src/native_agent_server.rs

@@ -1,14 +1,10 @@
 use std::{any::Any, path::Path, rc::Rc, sync::Arc};
 
-use agent_client_protocol as acp;
 use agent_servers::{AgentServer, AgentServerDelegate};
-use agent_settings::AgentSettings;
 use anyhow::Result;
-use collections::HashSet;
 use fs::Fs;
 use gpui::{App, Entity, SharedString, Task};
 use prompt_store::PromptStore;
-use settings::{LanguageModelSelection, Settings as _, update_settings_file};
 
 use crate::{HistoryStore, NativeAgent, NativeAgentConnection, templates::Templates};
 
@@ -75,38 +71,6 @@ impl AgentServer for NativeAgentServer {
     fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
         self
     }
-
-    fn favorite_model_ids(&self, cx: &mut App) -> HashSet<acp::ModelId> {
-        AgentSettings::get_global(cx).favorite_model_ids()
-    }
-
-    fn toggle_favorite_model(
-        &self,
-        model_id: acp::ModelId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        let selection = model_id_to_selection(&model_id);
-        update_settings_file(fs, cx, move |settings, _| {
-            let agent = settings.agent.get_or_insert_default();
-            if should_be_favorite {
-                agent.add_favorite_model(selection.clone());
-            } else {
-                agent.remove_favorite_model(&selection);
-            }
-        });
-    }
-}
-
-/// Convert a ModelId (e.g. "anthropic/claude-3-5-sonnet") to a LanguageModelSelection.
-fn model_id_to_selection(model_id: &acp::ModelId) -> LanguageModelSelection {
-    let id = model_id.0.as_ref();
-    let (provider, model) = id.split_once('/').unwrap_or(("", id));
-    LanguageModelSelection {
-        provider: provider.to_owned().into(),
-        model: model.to_owned(),
-    }
 }
 
 #[cfg(test)]

crates/agent/src/tools/grep_tool.rs

@@ -5,7 +5,7 @@ use futures::StreamExt;
 use gpui::{App, Entity, SharedString, Task};
 use language::{OffsetRangeExt, ParseStatus, Point};
 use project::{
-    Project, SearchResults, WorktreeSettings,
+    Project, WorktreeSettings,
     search::{SearchQuery, SearchResult},
 };
 use schemars::JsonSchema;
@@ -176,17 +176,14 @@ impl AgentTool for GrepTool {
 
         let project = self.project.downgrade();
         cx.spawn(async move |cx|  {
-            // Keep the search alive for the duration of result iteration. Dropping this task is the
-            // cancellation mechanism; we intentionally do not detach it.
-            let SearchResults {rx, _task_handle}  = results;
-            futures::pin_mut!(rx);
+            futures::pin_mut!(results);
 
             let mut output = String::new();
             let mut skips_remaining = input.offset;
             let mut matches_found = 0;
             let mut has_more_matches = false;
 
-            'outer: while let Some(SearchResult::Buffer { buffer, ranges }) = rx.next().await {
+            'outer: while let Some(SearchResult::Buffer { buffer, ranges }) = results.next().await {
                 if ranges.is_empty() {
                     continue;
                 }

crates/agent_servers/Cargo.toml

@@ -21,7 +21,6 @@ acp_tools.workspace = true
 acp_thread.workspace = true
 action_log.workspace = true
 agent-client-protocol.workspace = true
-feature_flags.workspace = true
 anyhow.workspace = true
 async-trait.workspace = true
 client.workspace = true

crates/agent_servers/src/acp.rs

@@ -4,7 +4,6 @@ use action_log::ActionLog;
 use agent_client_protocol::{self as acp, Agent as _, ErrorCode};
 use anyhow::anyhow;
 use collections::HashMap;
-use feature_flags::{AcpBetaFeatureFlag, FeatureFlagAppExt as _};
 use futures::AsyncBufReadExt as _;
 use futures::io::BufReader;
 use project::Project;
@@ -13,10 +12,8 @@ use serde::Deserialize;
 use settings::Settings as _;
 use task::ShellBuilder;
 use util::ResultExt as _;
-use util::process::Child;
 
 use std::path::PathBuf;
-use std::process::Stdio;
 use std::{any::Any, cell::RefCell};
 use std::{path::Path, rc::Rc};
 use thiserror::Error;
@@ -41,37 +38,20 @@ pub struct AcpConnection {
     agent_capabilities: acp::AgentCapabilities,
     default_mode: Option<acp::SessionModeId>,
     default_model: Option<acp::ModelId>,
-    default_config_options: HashMap<String, String>,
     root_dir: PathBuf,
-    child: Child,
+    // NB: Don't move this into the wait_task, since we need to ensure the process is
+    // killed on drop (setting kill_on_drop on the command seems to not always work).
+    child: smol::process::Child,
     _io_task: Task<Result<(), acp::Error>>,
     _wait_task: Task<Result<()>>,
     _stderr_task: Task<Result<()>>,
 }
 
-struct ConfigOptions {
-    config_options: Rc<RefCell<Vec<acp::SessionConfigOption>>>,
-    tx: Rc<RefCell<watch::Sender<()>>>,
-    rx: watch::Receiver<()>,
-}
-
-impl ConfigOptions {
-    fn new(config_options: Rc<RefCell<Vec<acp::SessionConfigOption>>>) -> Self {
-        let (tx, rx) = watch::channel(());
-        Self {
-            config_options,
-            tx: Rc::new(RefCell::new(tx)),
-            rx,
-        }
-    }
-}
-
 pub struct AcpSession {
     thread: WeakEntity<AcpThread>,
     suppress_abort_err: bool,
     models: Option<Rc<RefCell<acp::SessionModelState>>>,
     session_modes: Option<Rc<RefCell<acp::SessionModeState>>>,
-    config_options: Option<ConfigOptions>,
 }
 
 pub async fn connect(
@@ -80,7 +60,6 @@ pub async fn connect(
     root_dir: &Path,
     default_mode: Option<acp::SessionModeId>,
     default_model: Option<acp::ModelId>,
-    default_config_options: HashMap<String, String>,
     is_remote: bool,
     cx: &mut AsyncApp,
 ) -> Result<Rc<dyn AgentConnection>> {
@@ -90,7 +69,6 @@ pub async fn connect(
         root_dir,
         default_mode,
         default_model,
-        default_config_options,
         is_remote,
         cx,
     )
@@ -107,19 +85,22 @@ impl AcpConnection {
         root_dir: &Path,
         default_mode: Option<acp::SessionModeId>,
         default_model: Option<acp::ModelId>,
-        default_config_options: HashMap<String, String>,
         is_remote: bool,
         cx: &mut AsyncApp,
     ) -> Result<Self> {
         let shell = cx.update(|cx| TerminalSettings::get(None, cx).shell.clone())?;
         let builder = ShellBuilder::new(&shell, cfg!(windows)).non_interactive();
         let mut child =
-            builder.build_std_command(Some(command.path.display().to_string()), &command.args);
-        child.envs(command.env.iter().flatten());
+            builder.build_command(Some(command.path.display().to_string()), &command.args);
+        child
+            .envs(command.env.iter().flatten())
+            .stdin(std::process::Stdio::piped())
+            .stdout(std::process::Stdio::piped())
+            .stderr(std::process::Stdio::piped());
         if !is_remote {
             child.current_dir(root_dir);
         }
-        let mut child = Child::spawn(child, Stdio::piped(), Stdio::piped(), Stdio::piped())?;
+        let mut child = child.spawn()?;
 
         let stdout = child.stdout.take().context("Failed to take stdout")?;
         let stdin = child.stdin.take().context("Failed to take stdin")?;
@@ -236,7 +217,6 @@ impl AcpConnection {
             agent_capabilities: response.agent_capabilities,
             default_mode,
             default_model,
-            default_config_options,
             _io_task: io_task,
             _wait_task: wait_task,
             _stderr_task: stderr_task,
@@ -255,6 +235,7 @@ impl AcpConnection {
 
 impl Drop for AcpConnection {
     fn drop(&mut self) {
+        // See the comment on the child field.
         self.child.kill().log_err();
     }
 }
@@ -275,7 +256,6 @@ impl AgentConnection for AcpConnection {
         let sessions = self.sessions.clone();
         let default_mode = self.default_mode.clone();
         let default_model = self.default_model.clone();
-        let default_config_options = self.default_config_options.clone();
         let cwd = cwd.to_path_buf();
         let context_server_store = project.read(cx).context_server_store().read(cx);
         let mcp_servers = if project.read(cx).is_local() {
@@ -342,21 +322,8 @@ impl AgentConnection for AcpConnection {
                     }
                 })?;
 
-            let use_config_options = cx.update(|cx| cx.has_flag::<AcpBetaFeatureFlag>())?;
-
-            // Config options take precedence over legacy modes/models
-            let (modes, models, config_options) = if use_config_options && let Some(opts) = response.config_options {
-                (
-                    None,
-                    None,
-                    Some(Rc::new(RefCell::new(opts))),
-                )
-            } else {
-                // Fall back to legacy modes/models
-                let modes = response.modes.map(|modes| Rc::new(RefCell::new(modes)));
-                let models = response.models.map(|models| Rc::new(RefCell::new(models)));
-                (modes, models, None)
-            };
+            let modes = response.modes.map(|modes| Rc::new(RefCell::new(modes)));
+            let models = response.models.map(|models| Rc::new(RefCell::new(models)));
 
             if let Some(default_mode) = default_mode {
                 if let Some(modes) = modes.as_ref() {
@@ -444,92 +411,6 @@ impl AgentConnection for AcpConnection {
                 }
             }
 
-            if let Some(config_opts) = config_options.as_ref() {
-                let defaults_to_apply: Vec<_> = {
-                    let config_opts_ref = config_opts.borrow();
-                    config_opts_ref
-                        .iter()
-                        .filter_map(|config_option| {
-                            let default_value = default_config_options.get(&*config_option.id.0)?;
-
-                            let is_valid = match &config_option.kind {
-                                acp::SessionConfigKind::Select(select) => match &select.options {
-                                    acp::SessionConfigSelectOptions::Ungrouped(options) => {
-                                        options.iter().any(|opt| &*opt.value.0 == default_value.as_str())
-                                    }
-                                    acp::SessionConfigSelectOptions::Grouped(groups) => groups
-                                        .iter()
-                                        .any(|g| g.options.iter().any(|opt| &*opt.value.0 == default_value.as_str())),
-                                    _ => false,
-                                },
-                                _ => false,
-                            };
-
-                            if is_valid {
-                                let initial_value = match &config_option.kind {
-                                    acp::SessionConfigKind::Select(select) => {
-                                        Some(select.current_value.clone())
-                                    }
-                                    _ => None,
-                                };
-                                Some((config_option.id.clone(), default_value.clone(), initial_value))
-                            } else {
-                                log::warn!(
-                                    "`{}` is not a valid value for config option `{}` in {}",
-                                    default_value,
-                                    config_option.id.0,
-                                    name
-                                );
-                                None
-                            }
-                        })
-                        .collect()
-                };
-
-                for (config_id, default_value, initial_value) in defaults_to_apply {
-                    cx.spawn({
-                        let default_value_id = acp::SessionConfigValueId::new(default_value.clone());
-                        let session_id = response.session_id.clone();
-                        let config_id_clone = config_id.clone();
-                        let config_opts = config_opts.clone();
-                        let conn = conn.clone();
-                        async move |_| {
-                            let result = conn
-                                .set_session_config_option(
-                                    acp::SetSessionConfigOptionRequest::new(
-                                        session_id,
-                                        config_id_clone.clone(),
-                                        default_value_id,
-                                    ),
-                                )
-                                .await
-                                .log_err();
-
-                            if result.is_none() {
-                                if let Some(initial) = initial_value {
-                                    let mut opts = config_opts.borrow_mut();
-                                    if let Some(opt) = opts.iter_mut().find(|o| o.id == config_id_clone) {
-                                        if let acp::SessionConfigKind::Select(select) =
-                                            &mut opt.kind
-                                        {
-                                            select.current_value = initial;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    })
-                    .detach();
-
-                    let mut opts = config_opts.borrow_mut();
-                    if let Some(opt) = opts.iter_mut().find(|o| o.id == config_id) {
-                        if let acp::SessionConfigKind::Select(select) = &mut opt.kind {
-                            select.current_value = acp::SessionConfigValueId::new(default_value);
-                        }
-                    }
-                }
-            }
-
             let session_id = response.session_id;
             let action_log = cx.new(|_| ActionLog::new(project.clone()))?;
             let thread = cx.new(|cx| {
@@ -551,7 +432,6 @@ impl AgentConnection for AcpConnection {
                 suppress_abort_err: false,
                 session_modes: modes,
                 models,
-                config_options: config_options.map(|opts| ConfigOptions::new(opts))
             };
             sessions.borrow_mut().insert(session_id, session);
 
@@ -687,25 +567,6 @@ impl AgentConnection for AcpConnection {
         }
     }
 
-    fn session_config_options(
-        &self,
-        session_id: &acp::SessionId,
-        _cx: &App,
-    ) -> Option<Rc<dyn acp_thread::AgentSessionConfigOptions>> {
-        let sessions = self.sessions.borrow();
-        let session = sessions.get(session_id)?;
-
-        let config_opts = session.config_options.as_ref()?;
-
-        Some(Rc::new(AcpSessionConfigOptions {
-            session_id: session_id.clone(),
-            connection: self.connection.clone(),
-            state: config_opts.config_options.clone(),
-            watch_tx: config_opts.tx.clone(),
-            watch_rx: config_opts.rx.clone(),
-        }) as _)
-    }
-
     fn into_any(self: Rc<Self>) -> Rc<dyn Any> {
         self
     }
@@ -824,49 +685,6 @@ impl acp_thread::AgentModelSelector for AcpModelSelector {
     }
 }
 
-struct AcpSessionConfigOptions {
-    session_id: acp::SessionId,
-    connection: Rc<acp::ClientSideConnection>,
-    state: Rc<RefCell<Vec<acp::SessionConfigOption>>>,
-    watch_tx: Rc<RefCell<watch::Sender<()>>>,
-    watch_rx: watch::Receiver<()>,
-}
-
-impl acp_thread::AgentSessionConfigOptions for AcpSessionConfigOptions {
-    fn config_options(&self) -> Vec<acp::SessionConfigOption> {
-        self.state.borrow().clone()
-    }
-
-    fn set_config_option(
-        &self,
-        config_id: acp::SessionConfigId,
-        value: acp::SessionConfigValueId,
-        cx: &mut App,
-    ) -> Task<Result<Vec<acp::SessionConfigOption>>> {
-        let connection = self.connection.clone();
-        let session_id = self.session_id.clone();
-        let state = self.state.clone();
-
-        let watch_tx = self.watch_tx.clone();
-
-        cx.foreground_executor().spawn(async move {
-            let response = connection
-                .set_session_config_option(acp::SetSessionConfigOptionRequest::new(
-                    session_id, config_id, value,
-                ))
-                .await?;
-
-            *state.borrow_mut() = response.config_options.clone();
-            watch_tx.borrow_mut().send(()).ok();
-            Ok(response.config_options)
-        })
-    }
-
-    fn watch(&self, _cx: &mut App) -> Option<watch::Receiver<()>> {
-        Some(self.watch_rx.clone())
-    }
-}
-
 struct ClientDelegate {
     sessions: Rc<RefCell<HashMap<acp::SessionId, AcpSession>>>,
     cx: AsyncApp,
@@ -960,21 +778,6 @@ impl acp::Client for ClientDelegate {
             }
         }
 
-        if let acp::SessionUpdate::ConfigOptionUpdate(acp::ConfigOptionUpdate {
-            config_options,
-            ..
-        }) = &notification.update
-        {
-            if let Some(opts) = &session.config_options {
-                *opts.config_options.borrow_mut() = config_options.clone();
-                opts.tx.borrow_mut().send(()).ok();
-            } else {
-                log::error!(
-                    "Got a `ConfigOptionUpdate` notification, but the agent didn't specify `config_options` during session setup."
-                );
-            }
-        }
-
         // Clone so we can inspect meta both before and after handing off to the thread
         let update_clone = notification.update.clone();
 

crates/agent_servers/src/agent_servers.rs

@@ -10,7 +10,7 @@ pub mod e2e_tests;
 pub use claude::*;
 use client::ProxySettings;
 pub use codex::*;
-use collections::{HashMap, HashSet};
+use collections::HashMap;
 pub use custom::*;
 use fs::Fs;
 pub use gemini::*;
@@ -56,19 +56,9 @@ impl AgentServerDelegate {
 pub trait AgentServer: Send {
     fn logo(&self) -> ui::IconName;
     fn name(&self) -> SharedString;
-    fn connect(
-        &self,
-        root_dir: Option<&Path>,
-        delegate: AgentServerDelegate,
-        cx: &mut App,
-    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>>;
-
-    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
-
-    fn default_mode(&self, _cx: &App) -> Option<agent_client_protocol::SessionModeId> {
+    fn default_mode(&self, _cx: &mut App) -> Option<agent_client_protocol::SessionModeId> {
         None
     }
-
     fn set_default_mode(
         &self,
         _mode_id: Option<agent_client_protocol::SessionModeId>,
@@ -77,7 +67,7 @@ pub trait AgentServer: Send {
     ) {
     }
 
-    fn default_model(&self, _cx: &App) -> Option<agent_client_protocol::ModelId> {
+    fn default_model(&self, _cx: &mut App) -> Option<agent_client_protocol::ModelId> {
         None
     }
 
@@ -89,49 +79,14 @@ pub trait AgentServer: Send {
     ) {
     }
 
-    fn favorite_model_ids(&self, _cx: &mut App) -> HashSet<agent_client_protocol::ModelId> {
-        HashSet::default()
-    }
-
-    fn default_config_option(&self, _config_id: &str, _cx: &App) -> Option<String> {
-        None
-    }
-
-    fn set_default_config_option(
+    fn connect(
         &self,
-        _config_id: &str,
-        _value_id: Option<&str>,
-        _fs: Arc<dyn Fs>,
-        _cx: &mut App,
-    ) {
-    }
+        root_dir: Option<&Path>,
+        delegate: AgentServerDelegate,
+        cx: &mut App,
+    ) -> Task<Result<(Rc<dyn AgentConnection>, Option<task::SpawnInTerminal>)>>;
 
-    fn favorite_config_option_value_ids(
-        &self,
-        _config_id: &agent_client_protocol::SessionConfigId,
-        _cx: &mut App,
-    ) -> HashSet<agent_client_protocol::SessionConfigValueId> {
-        HashSet::default()
-    }
-
-    fn toggle_favorite_config_option_value(
-        &self,
-        _config_id: agent_client_protocol::SessionConfigId,
-        _value_id: agent_client_protocol::SessionConfigValueId,
-        _should_be_favorite: bool,
-        _fs: Arc<dyn Fs>,
-        _cx: &App,
-    ) {
-    }
-
-    fn toggle_favorite_model(
-        &self,
-        _model_id: agent_client_protocol::ModelId,
-        _should_be_favorite: bool,
-        _fs: Arc<dyn Fs>,
-        _cx: &App,
-    ) {
-    }
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
 
 impl dyn AgentServer {

crates/agent_servers/src/claude.rs

@@ -1,5 +1,4 @@
 use agent_client_protocol as acp;
-use collections::HashSet;
 use fs::Fs;
 use settings::{SettingsStore, update_settings_file};
 use std::path::Path;
@@ -31,7 +30,7 @@ impl AgentServer for ClaudeCode {
         ui::IconName::AiClaude
     }
 
-    fn default_mode(&self, cx: &App) -> Option<acp::SessionModeId> {
+    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings.get::<AllAgentServersSettings>(None).claude.clone()
         });
@@ -52,7 +51,7 @@ impl AgentServer for ClaudeCode {
         });
     }
 
-    fn default_model(&self, cx: &App) -> Option<acp::ModelId> {
+    fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings.get::<AllAgentServersSettings>(None).claude.clone()
         });
@@ -73,139 +72,6 @@ impl AgentServer for ClaudeCode {
         });
     }
 
-    fn favorite_model_ids(&self, cx: &mut App) -> HashSet<acp::ModelId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).claude.clone()
-        });
-
-        settings
-            .as_ref()
-            .map(|s| {
-                s.favorite_models
-                    .iter()
-                    .map(|id| acp::ModelId::new(id.clone()))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_model(
-        &self,
-        model_id: acp::ModelId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        update_settings_file(fs, cx, move |settings, _| {
-            let favorite_models = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .claude
-                .get_or_insert_default()
-                .favorite_models;
-
-            let model_id_str = model_id.to_string();
-            if should_be_favorite {
-                if !favorite_models.contains(&model_id_str) {
-                    favorite_models.push(model_id_str);
-                }
-            } else {
-                favorite_models.retain(|id| id != &model_id_str);
-            }
-        });
-    }
-
-    fn default_config_option(&self, config_id: &str, cx: &App) -> Option<String> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).claude.clone()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.default_config_options.get(config_id).cloned())
-    }
-
-    fn set_default_config_option(
-        &self,
-        config_id: &str,
-        value_id: Option<&str>,
-        fs: Arc<dyn Fs>,
-        cx: &mut App,
-    ) {
-        let config_id = config_id.to_string();
-        let value_id = value_id.map(|s| s.to_string());
-        update_settings_file(fs, cx, move |settings, _| {
-            let config_options = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .claude
-                .get_or_insert_default()
-                .default_config_options;
-
-            if let Some(value) = value_id.clone() {
-                config_options.insert(config_id.clone(), value);
-            } else {
-                config_options.remove(&config_id);
-            }
-        });
-    }
-
-    fn favorite_config_option_value_ids(
-        &self,
-        config_id: &acp::SessionConfigId,
-        cx: &mut App,
-    ) -> HashSet<acp::SessionConfigValueId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).claude.clone()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.favorite_config_option_values.get(config_id.0.as_ref()))
-            .map(|values| {
-                values
-                    .iter()
-                    .cloned()
-                    .map(acp::SessionConfigValueId::new)
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_config_option_value(
-        &self,
-        config_id: acp::SessionConfigId,
-        value_id: acp::SessionConfigValueId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        let config_id = config_id.to_string();
-        let value_id = value_id.to_string();
-
-        update_settings_file(fs, cx, move |settings, _| {
-            let favorites = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .claude
-                .get_or_insert_default()
-                .favorite_config_option_values;
-
-            let entry = favorites.entry(config_id.clone()).or_insert_with(Vec::new);
-
-            if should_be_favorite {
-                if !entry.iter().any(|v| v == &value_id) {
-                    entry.push(value_id.clone());
-                }
-            } else {
-                entry.retain(|v| v != &value_id);
-                if entry.is_empty() {
-                    favorites.remove(&config_id);
-                }
-            }
-        });
-    }
-
     fn connect(
         &self,
         root_dir: Option<&Path>,
@@ -219,14 +85,6 @@ impl AgentServer for ClaudeCode {
         let extra_env = load_proxy_env(cx);
         let default_mode = self.default_mode(cx);
         let default_model = self.default_model(cx);
-        let default_config_options = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .claude
-                .as_ref()
-                .map(|s| s.default_config_options.clone())
-                .unwrap_or_default()
-        });
 
         cx.spawn(async move |cx| {
             let (command, root_dir, login) = store
@@ -249,7 +107,6 @@ impl AgentServer for ClaudeCode {
                 root_dir.as_ref(),
                 default_mode,
                 default_model,
-                default_config_options,
                 is_remote,
                 cx,
             )

crates/agent_servers/src/codex.rs

@@ -5,7 +5,6 @@ use std::{any::Any, path::Path};
 use acp_thread::AgentConnection;
 use agent_client_protocol as acp;
 use anyhow::{Context as _, Result};
-use collections::HashSet;
 use fs::Fs;
 use gpui::{App, AppContext as _, SharedString, Task};
 use project::agent_server_store::{AllAgentServersSettings, CODEX_NAME};
@@ -32,7 +31,7 @@ impl AgentServer for Codex {
         ui::IconName::AiOpenAi
     }
 
-    fn default_mode(&self, cx: &App) -> Option<acp::SessionModeId> {
+    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings.get::<AllAgentServersSettings>(None).codex.clone()
         });
@@ -53,7 +52,7 @@ impl AgentServer for Codex {
         });
     }
 
-    fn default_model(&self, cx: &App) -> Option<acp::ModelId> {
+    fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings.get::<AllAgentServersSettings>(None).codex.clone()
         });
@@ -74,139 +73,6 @@ impl AgentServer for Codex {
         });
     }
 
-    fn favorite_model_ids(&self, cx: &mut App) -> HashSet<acp::ModelId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).codex.clone()
-        });
-
-        settings
-            .as_ref()
-            .map(|s| {
-                s.favorite_models
-                    .iter()
-                    .map(|id| acp::ModelId::new(id.clone()))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_model(
-        &self,
-        model_id: acp::ModelId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        update_settings_file(fs, cx, move |settings, _| {
-            let favorite_models = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .codex
-                .get_or_insert_default()
-                .favorite_models;
-
-            let model_id_str = model_id.to_string();
-            if should_be_favorite {
-                if !favorite_models.contains(&model_id_str) {
-                    favorite_models.push(model_id_str);
-                }
-            } else {
-                favorite_models.retain(|id| id != &model_id_str);
-            }
-        });
-    }
-
-    fn default_config_option(&self, config_id: &str, cx: &App) -> Option<String> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).codex.clone()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.default_config_options.get(config_id).cloned())
-    }
-
-    fn set_default_config_option(
-        &self,
-        config_id: &str,
-        value_id: Option<&str>,
-        fs: Arc<dyn Fs>,
-        cx: &mut App,
-    ) {
-        let config_id = config_id.to_string();
-        let value_id = value_id.map(|s| s.to_string());
-        update_settings_file(fs, cx, move |settings, _| {
-            let config_options = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .codex
-                .get_or_insert_default()
-                .default_config_options;
-
-            if let Some(value) = value_id.clone() {
-                config_options.insert(config_id.clone(), value);
-            } else {
-                config_options.remove(&config_id);
-            }
-        });
-    }
-
-    fn favorite_config_option_value_ids(
-        &self,
-        config_id: &acp::SessionConfigId,
-        cx: &mut App,
-    ) -> HashSet<acp::SessionConfigValueId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings.get::<AllAgentServersSettings>(None).codex.clone()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.favorite_config_option_values.get(config_id.0.as_ref()))
-            .map(|values| {
-                values
-                    .iter()
-                    .cloned()
-                    .map(acp::SessionConfigValueId::new)
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_config_option_value(
-        &self,
-        config_id: acp::SessionConfigId,
-        value_id: acp::SessionConfigValueId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        let config_id = config_id.to_string();
-        let value_id = value_id.to_string();
-
-        update_settings_file(fs, cx, move |settings, _| {
-            let favorites = &mut settings
-                .agent_servers
-                .get_or_insert_default()
-                .codex
-                .get_or_insert_default()
-                .favorite_config_option_values;
-
-            let entry = favorites.entry(config_id.clone()).or_insert_with(Vec::new);
-
-            if should_be_favorite {
-                if !entry.iter().any(|v| v == &value_id) {
-                    entry.push(value_id.clone());
-                }
-            } else {
-                entry.retain(|v| v != &value_id);
-                if entry.is_empty() {
-                    favorites.remove(&config_id);
-                }
-            }
-        });
-    }
-
     fn connect(
         &self,
         root_dir: Option<&Path>,
@@ -220,14 +86,6 @@ impl AgentServer for Codex {
         let extra_env = load_proxy_env(cx);
         let default_mode = self.default_mode(cx);
         let default_model = self.default_model(cx);
-        let default_config_options = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .codex
-                .as_ref()
-                .map(|s| s.default_config_options.clone())
-                .unwrap_or_default()
-        });
 
         cx.spawn(async move |cx| {
             let (command, root_dir, login) = store
@@ -251,7 +109,6 @@ impl AgentServer for Codex {
                 root_dir.as_ref(),
                 default_mode,
                 default_model,
-                default_config_options,
                 is_remote,
                 cx,
             )

crates/agent_servers/src/custom.rs

@@ -2,7 +2,6 @@ use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
 use acp_thread::AgentConnection;
 use agent_client_protocol as acp;
 use anyhow::{Context as _, Result};
-use collections::HashSet;
 use fs::Fs;
 use gpui::{App, AppContext as _, SharedString, Task};
 use project::agent_server_store::{AllAgentServersSettings, ExternalAgentServerName};
@@ -30,7 +29,7 @@ impl AgentServer for CustomAgentServer {
         IconName::Terminal
     }
 
-    fn default_mode(&self, cx: &App) -> Option<acp::SessionModeId> {
+    fn default_mode(&self, cx: &mut App) -> Option<acp::SessionModeId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings
                 .get::<AllAgentServersSettings>(None)
@@ -44,86 +43,6 @@ impl AgentServer for CustomAgentServer {
             .and_then(|s| s.default_mode().map(acp::SessionModeId::new))
     }
 
-    fn favorite_config_option_value_ids(
-        &self,
-        config_id: &acp::SessionConfigId,
-        cx: &mut App,
-    ) -> HashSet<acp::SessionConfigValueId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .custom
-                .get(&self.name())
-                .cloned()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.favorite_config_option_values(config_id.0.as_ref()))
-            .map(|values| {
-                values
-                    .iter()
-                    .cloned()
-                    .map(acp::SessionConfigValueId::new)
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_config_option_value(
-        &self,
-        config_id: acp::SessionConfigId,
-        value_id: acp::SessionConfigValueId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        let name = self.name();
-        let config_id = config_id.to_string();
-        let value_id = value_id.to_string();
-
-        update_settings_file(fs, cx, move |settings, _| {
-            let settings = settings
-                .agent_servers
-                .get_or_insert_default()
-                .custom
-                .entry(name.clone())
-                .or_insert_with(|| settings::CustomAgentServerSettings::Extension {
-                    default_model: None,
-                    default_mode: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: Default::default(),
-                    favorite_config_option_values: Default::default(),
-                });
-
-            match settings {
-                settings::CustomAgentServerSettings::Custom {
-                    favorite_config_option_values,
-                    ..
-                }
-                | settings::CustomAgentServerSettings::Extension {
-                    favorite_config_option_values,
-                    ..
-                } => {
-                    let entry = favorite_config_option_values
-                        .entry(config_id.clone())
-                        .or_insert_with(Vec::new);
-
-                    if should_be_favorite {
-                        if !entry.iter().any(|v| v == &value_id) {
-                            entry.push(value_id.clone());
-                        }
-                    } else {
-                        entry.retain(|v| v != &value_id);
-                        if entry.is_empty() {
-                            favorite_config_option_values.remove(&config_id);
-                        }
-                    }
-                }
-            }
-        });
-    }
-
     fn set_default_mode(&self, mode_id: Option<acp::SessionModeId>, fs: Arc<dyn Fs>, cx: &mut App) {
         let name = self.name();
         update_settings_file(fs, cx, move |settings, _| {
@@ -135,9 +54,6 @@ impl AgentServer for CustomAgentServer {
                 .or_insert_with(|| settings::CustomAgentServerSettings::Extension {
                     default_model: None,
                     default_mode: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: Default::default(),
-                    favorite_config_option_values: Default::default(),
                 });
 
             match settings {
@@ -149,7 +65,7 @@ impl AgentServer for CustomAgentServer {
         });
     }
 
-    fn default_model(&self, cx: &App) -> Option<acp::ModelId> {
+    fn default_model(&self, cx: &mut App) -> Option<acp::ModelId> {
         let settings = cx.read_global(|settings: &SettingsStore, _| {
             settings
                 .get::<AllAgentServersSettings>(None)
@@ -174,9 +90,6 @@ impl AgentServer for CustomAgentServer {
                 .or_insert_with(|| settings::CustomAgentServerSettings::Extension {
                     default_model: None,
                     default_mode: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: Default::default(),
-                    favorite_config_option_values: Default::default(),
                 });
 
             match settings {
@@ -188,125 +101,6 @@ impl AgentServer for CustomAgentServer {
         });
     }
 
-    fn favorite_model_ids(&self, cx: &mut App) -> HashSet<acp::ModelId> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .custom
-                .get(&self.name())
-                .cloned()
-        });
-
-        settings
-            .as_ref()
-            .map(|s| {
-                s.favorite_models()
-                    .iter()
-                    .map(|id| acp::ModelId::new(id.clone()))
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    fn toggle_favorite_model(
-        &self,
-        model_id: acp::ModelId,
-        should_be_favorite: bool,
-        fs: Arc<dyn Fs>,
-        cx: &App,
-    ) {
-        let name = self.name();
-        update_settings_file(fs, cx, move |settings, _| {
-            let settings = settings
-                .agent_servers
-                .get_or_insert_default()
-                .custom
-                .entry(name.clone())
-                .or_insert_with(|| settings::CustomAgentServerSettings::Extension {
-                    default_model: None,
-                    default_mode: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: Default::default(),
-                    favorite_config_option_values: Default::default(),
-                });
-
-            let favorite_models = match settings {
-                settings::CustomAgentServerSettings::Custom {
-                    favorite_models, ..
-                }
-                | settings::CustomAgentServerSettings::Extension {
-                    favorite_models, ..
-                } => favorite_models,
-            };
-
-            let model_id_str = model_id.to_string();
-            if should_be_favorite {
-                if !favorite_models.contains(&model_id_str) {
-                    favorite_models.push(model_id_str);
-                }
-            } else {
-                favorite_models.retain(|id| id != &model_id_str);
-            }
-        });
-    }
-
-    fn default_config_option(&self, config_id: &str, cx: &App) -> Option<String> {
-        let settings = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .custom
-                .get(&self.name())
-                .cloned()
-        });
-
-        settings
-            .as_ref()
-            .and_then(|s| s.default_config_option(config_id).map(|s| s.to_string()))
-    }
-
-    fn set_default_config_option(
-        &self,
-        config_id: &str,
-        value_id: Option<&str>,
-        fs: Arc<dyn Fs>,
-        cx: &mut App,
-    ) {
-        let name = self.name();
-        let config_id = config_id.to_string();
-        let value_id = value_id.map(|s| s.to_string());
-        update_settings_file(fs, cx, move |settings, _| {
-            let settings = settings
-                .agent_servers
-                .get_or_insert_default()
-                .custom
-                .entry(name.clone())
-                .or_insert_with(|| settings::CustomAgentServerSettings::Extension {
-                    default_model: None,
-                    default_mode: None,
-                    favorite_models: Vec::new(),
-                    default_config_options: Default::default(),
-                    favorite_config_option_values: Default::default(),
-                });
-
-            match settings {
-                settings::CustomAgentServerSettings::Custom {
-                    default_config_options,
-                    ..
-                }
-                | settings::CustomAgentServerSettings::Extension {
-                    default_config_options,
-                    ..
-                } => {
-                    if let Some(value) = value_id.clone() {
-                        default_config_options.insert(config_id.clone(), value);
-                    } else {
-                        default_config_options.remove(&config_id);
-                    }
-                }
-            }
-        });
-    }
-
     fn connect(
         &self,
         root_dir: Option<&Path>,
@@ -318,23 +112,6 @@ impl AgentServer for CustomAgentServer {
         let is_remote = delegate.project.read(cx).is_via_remote_server();
         let default_mode = self.default_mode(cx);
         let default_model = self.default_model(cx);
-        let default_config_options = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .custom
-                .get(&self.name())
-                .map(|s| match s {
-                    project::agent_server_store::CustomAgentServerSettings::Custom {
-                        default_config_options,
-                        ..
-                    }
-                    | project::agent_server_store::CustomAgentServerSettings::Extension {
-                        default_config_options,
-                        ..
-                    } => default_config_options.clone(),
-                })
-                .unwrap_or_default()
-        });
         let store = delegate.store.downgrade();
         let extra_env = load_proxy_env(cx);
         cx.spawn(async move |cx| {
@@ -360,7 +137,6 @@ impl AgentServer for CustomAgentServer {
                 root_dir.as_ref(),
                 default_mode,
                 default_model,
-                default_config_options,
                 is_remote,
                 cx,
             )

crates/agent_servers/src/e2e_tests.rs

@@ -455,12 +455,20 @@ pub async fn init_test(cx: &mut TestAppContext) -> Arc<FakeFs> {
             project::agent_server_store::AllAgentServersSettings {
                 claude: Some(BuiltinAgentServerSettings {
                     path: Some("claude-code-acp".into()),
-                    ..Default::default()
+                    args: None,
+                    env: None,
+                    ignore_system_version: None,
+                    default_mode: None,
+                    default_model: None,
                 }),
                 gemini: Some(crate::gemini::tests::local_command().into()),
                 codex: Some(BuiltinAgentServerSettings {
                     path: Some("codex-acp".into()),
-                    ..Default::default()
+                    args: None,
+                    env: None,
+                    ignore_system_version: None,
+                    default_mode: None,
+                    default_model: None,
                 }),
                 custom: collections::HashMap::default(),
             },

crates/agent_servers/src/gemini.rs

@@ -4,10 +4,9 @@ use std::{any::Any, path::Path};
 use crate::{AgentServer, AgentServerDelegate, load_proxy_env};
 use acp_thread::AgentConnection;
 use anyhow::{Context as _, Result};
-use gpui::{App, AppContext as _, SharedString, Task};
+use gpui::{App, SharedString, Task};
 use language_models::provider::google::GoogleLanguageModelProvider;
-use project::agent_server_store::{AllAgentServersSettings, GEMINI_NAME};
-use settings::SettingsStore;
+use project::agent_server_store::GEMINI_NAME;
 
 #[derive(Clone)]
 pub struct Gemini;
@@ -34,14 +33,6 @@ impl AgentServer for Gemini {
         let mut extra_env = load_proxy_env(cx);
         let default_mode = self.default_mode(cx);
         let default_model = self.default_model(cx);
-        let default_config_options = cx.read_global(|settings: &SettingsStore, _| {
-            settings
-                .get::<AllAgentServersSettings>(None)
-                .gemini
-                .as_ref()
-                .map(|s| s.default_config_options.clone())
-                .unwrap_or_default()
-        });
 
         cx.spawn(async move |cx| {
             extra_env.insert("SURFACE".to_owned(), "zed".to_owned());
@@ -74,7 +65,6 @@ impl AgentServer for Gemini {
                 root_dir.as_ref(),
                 default_mode,
                 default_model,
-                default_config_options,
                 is_remote,
                 cx,
             )

crates/agent_ui/src/acp.rs

@@ -1,4 +1,3 @@
-mod config_options;
 mod entry_view_state;
 mod message_editor;
 mod mode_selector;

crates/agent_ui/src/acp/config_options.rs

@@ -1,775 +0,0 @@
-use std::{cmp::Reverse, rc::Rc, sync::Arc};
-
-use acp_thread::AgentSessionConfigOptions;
-use agent_client_protocol as acp;
-use agent_servers::AgentServer;
-use collections::HashSet;
-use fs::Fs;
-use fuzzy::StringMatchCandidate;
-use gpui::{
-    BackgroundExecutor, Context, DismissEvent, Entity, Subscription, Task, Window, prelude::*,
-};
-use ordered_float::OrderedFloat;
-use picker::popover_menu::PickerPopoverMenu;
-use picker::{Picker, PickerDelegate};
-use settings::SettingsStore;
-use ui::{
-    ElevationIndex, IconButton, ListItem, ListItemSpacing, PopoverMenuHandle, Tooltip, prelude::*,
-};
-use util::ResultExt as _;
-
-use crate::ui::HoldForDefault;
-
-const PICKER_THRESHOLD: usize = 5;
-
-pub struct ConfigOptionsView {
-    config_options: Rc<dyn AgentSessionConfigOptions>,
-    selectors: Vec<Entity<ConfigOptionSelector>>,
-    agent_server: Rc<dyn AgentServer>,
-    fs: Arc<dyn Fs>,
-    config_option_ids: Vec<acp::SessionConfigId>,
-    _refresh_task: Task<()>,
-}
-
-impl ConfigOptionsView {
-    pub fn new(
-        config_options: Rc<dyn AgentSessionConfigOptions>,
-        agent_server: Rc<dyn AgentServer>,
-        fs: Arc<dyn Fs>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let selectors = Self::build_selectors(&config_options, &agent_server, &fs, window, cx);
-        let config_option_ids = Self::config_option_ids(&config_options);
-
-        let rx = config_options.watch(cx);
-        let refresh_task = cx.spawn_in(window, async move |this, cx| {
-            if let Some(mut rx) = rx {
-                while let Ok(()) = rx.recv().await {
-                    this.update_in(cx, |this, window, cx| {
-                        this.refresh_selectors_if_needed(window, cx);
-                        cx.notify();
-                    })
-                    .log_err();
-                }
-            }
-        });
-
-        Self {
-            config_options,
-            selectors,
-            agent_server,
-            fs,
-            config_option_ids,
-            _refresh_task: refresh_task,
-        }
-    }
-
-    fn config_option_ids(
-        config_options: &Rc<dyn AgentSessionConfigOptions>,
-    ) -> Vec<acp::SessionConfigId> {
-        config_options
-            .config_options()
-            .into_iter()
-            .map(|option| option.id)
-            .collect()
-    }
-
-    fn refresh_selectors_if_needed(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        let current_ids = Self::config_option_ids(&self.config_options);
-        if current_ids != self.config_option_ids {
-            self.config_option_ids = current_ids;
-            self.rebuild_selectors(window, cx);
-        }
-    }
-
-    fn rebuild_selectors(&mut self, window: &mut Window, cx: &mut Context<Self>) {
-        self.selectors = Self::build_selectors(
-            &self.config_options,
-            &self.agent_server,
-            &self.fs,
-            window,
-            cx,
-        );
-        cx.notify();
-    }
-
-    fn build_selectors(
-        config_options: &Rc<dyn AgentSessionConfigOptions>,
-        agent_server: &Rc<dyn AgentServer>,
-        fs: &Arc<dyn Fs>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Vec<Entity<ConfigOptionSelector>> {
-        config_options
-            .config_options()
-            .into_iter()
-            .map(|option| {
-                let config_options = config_options.clone();
-                let agent_server = agent_server.clone();
-                let fs = fs.clone();
-                cx.new(|cx| {
-                    ConfigOptionSelector::new(
-                        config_options,
-                        option.id.clone(),
-                        agent_server,
-                        fs,
-                        window,
-                        cx,
-                    )
-                })
-            })
-            .collect()
-    }
-}
-
-impl Render for ConfigOptionsView {
-    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        if self.selectors.is_empty() {
-            return div().into_any_element();
-        }
-
-        h_flex()
-            .gap_1()
-            .children(self.selectors.iter().cloned())
-            .into_any_element()
-    }
-}
-
-struct ConfigOptionSelector {
-    config_options: Rc<dyn AgentSessionConfigOptions>,
-    config_id: acp::SessionConfigId,
-    picker_handle: PopoverMenuHandle<Picker<ConfigOptionPickerDelegate>>,
-    picker: Entity<Picker<ConfigOptionPickerDelegate>>,
-    setting_value: bool,
-}
-
-impl ConfigOptionSelector {
-    pub fn new(
-        config_options: Rc<dyn AgentSessionConfigOptions>,
-        config_id: acp::SessionConfigId,
-        agent_server: Rc<dyn AgentServer>,
-        fs: Arc<dyn Fs>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let option_count = config_options
-            .config_options()
-            .iter()
-            .find(|opt| opt.id == config_id)
-            .map(count_config_options)
-            .unwrap_or(0);
-
-        let is_searchable = option_count >= PICKER_THRESHOLD;
-
-        let picker = {
-            let config_options = config_options.clone();
-            let config_id = config_id.clone();
-            let agent_server = agent_server.clone();
-            let fs = fs.clone();
-            cx.new(move |picker_cx| {
-                let delegate = ConfigOptionPickerDelegate::new(
-                    config_options,
-                    config_id,
-                    agent_server,
-                    fs,
-                    window,
-                    picker_cx,
-                );
-
-                if is_searchable {
-                    Picker::list(delegate, window, picker_cx)
-                } else {
-                    Picker::nonsearchable_list(delegate, window, picker_cx)
-                }
-                .show_scrollbar(true)
-                .width(rems(20.))
-                .max_height(Some(rems(20.).into()))
-            })
-        };
-
-        Self {
-            config_options,
-            config_id,
-            picker_handle: PopoverMenuHandle::default(),
-            picker,
-            setting_value: false,
-        }
-    }
-
-    fn current_option(&self) -> Option<acp::SessionConfigOption> {
-        self.config_options
-            .config_options()
-            .into_iter()
-            .find(|opt| opt.id == self.config_id)
-    }
-
-    fn current_value_name(&self) -> String {
-        let Some(option) = self.current_option() else {
-            return "Unknown".to_string();
-        };
-
-        match &option.kind {
-            acp::SessionConfigKind::Select(select) => {
-                find_option_name(&select.options, &select.current_value)
-                    .unwrap_or_else(|| "Unknown".to_string())
-            }
-            _ => "Unknown".to_string(),
-        }
-    }
-
-    fn render_trigger_button(&self, _window: &mut Window, _cx: &mut Context<Self>) -> Button {
-        let Some(option) = self.current_option() else {
-            return Button::new("config-option-trigger", "Unknown")
-                .label_size(LabelSize::Small)
-                .color(Color::Muted)
-                .disabled(true);
-        };
-
-        let icon = if self.picker_handle.is_deployed() {
-            IconName::ChevronUp
-        } else {
-            IconName::ChevronDown
-        };
-
-        Button::new(
-            ElementId::Name(format!("config-option-{}", option.id.0).into()),
-            self.current_value_name(),
-        )
-        .label_size(LabelSize::Small)
-        .color(Color::Muted)
-        .icon(icon)
-        .icon_size(IconSize::XSmall)
-        .icon_position(IconPosition::End)
-        .icon_color(Color::Muted)
-        .disabled(self.setting_value)
-    }
-}
-
-impl Render for ConfigOptionSelector {
-    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let Some(option) = self.current_option() else {
-            return div().into_any_element();
-        };
-
-        let trigger_button = self.render_trigger_button(window, cx);
-
-        let option_name = option.name.clone();
-        let option_description: Option<SharedString> = option.description.map(Into::into);
-
-        let tooltip = Tooltip::element(move |_window, _cx| {
-            let mut content = v_flex().gap_1().child(Label::new(option_name.clone()));
-            if let Some(desc) = option_description.as_ref() {
-                content = content.child(
-                    Label::new(desc.clone())
-                        .size(LabelSize::Small)
-                        .color(Color::Muted),
-                );
-            }
-            content.into_any()
-        });
-
-        PickerPopoverMenu::new(
-            self.picker.clone(),
-            trigger_button,
-            tooltip,
-            gpui::Corner::BottomRight,
-            cx,
-        )
-        .with_handle(self.picker_handle.clone())
-        .render(window, cx)
-        .into_any_element()
-    }
-}
-
-#[derive(Clone)]
-enum ConfigOptionPickerEntry {
-    Separator(SharedString),
-    Option(ConfigOptionValue),
-}
-
-#[derive(Clone)]
-struct ConfigOptionValue {
-    value: acp::SessionConfigValueId,
-    name: String,
-    description: Option<String>,
-    group: Option<String>,
-}
-
-struct ConfigOptionPickerDelegate {
-    config_options: Rc<dyn AgentSessionConfigOptions>,
-    config_id: acp::SessionConfigId,
-    agent_server: Rc<dyn AgentServer>,
-    fs: Arc<dyn Fs>,
-    filtered_entries: Vec<ConfigOptionPickerEntry>,
-    all_options: Vec<ConfigOptionValue>,
-    selected_index: usize,
-    selected_description: Option<(usize, SharedString, bool)>,
-    favorites: HashSet<acp::SessionConfigValueId>,
-    _settings_subscription: Subscription,
-}
-
-impl ConfigOptionPickerDelegate {
-    fn new(
-        config_options: Rc<dyn AgentSessionConfigOptions>,
-        config_id: acp::SessionConfigId,
-        agent_server: Rc<dyn AgentServer>,
-        fs: Arc<dyn Fs>,
-        window: &mut Window,
-        cx: &mut Context<Picker<Self>>,
-    ) -> Self {
-        let favorites = agent_server.favorite_config_option_value_ids(&config_id, cx);
-
-        let all_options = extract_options(&config_options, &config_id);
-        let filtered_entries = options_to_picker_entries(&all_options, &favorites);
-
-        let current_value = get_current_value(&config_options, &config_id);
-        let selected_index = current_value
-            .and_then(|current| {
-                filtered_entries.iter().position(|entry| {
-                    matches!(entry, ConfigOptionPickerEntry::Option(opt) if opt.value == current)
-                })
-            })
-            .unwrap_or(0);
-
-        let agent_server_for_subscription = agent_server.clone();
-        let config_id_for_subscription = config_id.clone();
-        let settings_subscription =
-            cx.observe_global_in::<SettingsStore>(window, move |picker, window, cx| {
-                let new_favorites = agent_server_for_subscription
-                    .favorite_config_option_value_ids(&config_id_for_subscription, cx);
-                if new_favorites != picker.delegate.favorites {
-                    picker.delegate.favorites = new_favorites;
-                    picker.refresh(window, cx);
-                }
-            });
-
-        cx.notify();
-
-        Self {
-            config_options,
-            config_id,
-            agent_server,
-            fs,
-            filtered_entries,
-            all_options,
-            selected_index,
-            selected_description: None,
-            favorites,
-            _settings_subscription: settings_subscription,
-        }
-    }
-
-    fn current_value(&self) -> Option<acp::SessionConfigValueId> {
-        get_current_value(&self.config_options, &self.config_id)
-    }
-}
-
-impl PickerDelegate for ConfigOptionPickerDelegate {
-    type ListItem = AnyElement;
-
-    fn match_count(&self) -> usize {
-        self.filtered_entries.len()
-    }
-
-    fn selected_index(&self) -> usize {
-        self.selected_index
-    }
-
-    fn set_selected_index(&mut self, ix: usize, _: &mut Window, cx: &mut Context<Picker<Self>>) {
-        self.selected_index = ix.min(self.filtered_entries.len().saturating_sub(1));
-        cx.notify();
-    }
-
-    fn can_select(
-        &mut self,
-        ix: usize,
-        _window: &mut Window,
-        _cx: &mut Context<Picker<Self>>,
-    ) -> bool {
-        match self.filtered_entries.get(ix) {
-            Some(ConfigOptionPickerEntry::Option(_)) => true,
-            Some(ConfigOptionPickerEntry::Separator(_)) | None => false,
-        }
-    }
-
-    fn placeholder_text(&self, _window: &mut Window, _cx: &mut App) -> Arc<str> {
-        "Select an option…".into()
-    }
-
-    fn update_matches(
-        &mut self,
-        query: String,
-        window: &mut Window,
-        cx: &mut Context<Picker<Self>>,
-    ) -> Task<()> {
-        let all_options = self.all_options.clone();
-
-        cx.spawn_in(window, async move |this, cx| {
-            let filtered_options = match this
-                .read_with(cx, |_, cx| {
-                    if query.is_empty() {
-                        None
-                    } else {
-                        Some((all_options.clone(), query.clone(), cx.background_executor().clone()))
-                    }
-                })
-                .ok()
-                .flatten()
-            {
-                Some((options, q, executor)) => fuzzy_search_options(options, &q, executor).await,
-                None => all_options,
-            };
-
-            this.update_in(cx, |this, window, cx| {
-                this.delegate.filtered_entries =
-                    options_to_picker_entries(&filtered_options, &this.delegate.favorites);
-
-                let current_value = this.delegate.current_value();
-                let new_index = current_value
-                    .and_then(|current| {
-                        this.delegate.filtered_entries.iter().position(|entry| {
-                            matches!(entry, ConfigOptionPickerEntry::Option(opt) if opt.value == current)
-                        })
-                    })
-                    .unwrap_or(0);
-
-                this.set_selected_index(new_index, Some(picker::Direction::Down), true, window, cx);
-                cx.notify();
-            })
-            .ok();
-        })
-    }
-
-    fn confirm(&mut self, _secondary: bool, window: &mut Window, cx: &mut Context<Picker<Self>>) {
-        if let Some(ConfigOptionPickerEntry::Option(option)) =
-            self.filtered_entries.get(self.selected_index)
-        {
-            if window.modifiers().secondary() {
-                let default_value = self
-                    .agent_server
-                    .default_config_option(self.config_id.0.as_ref(), cx);
-                let is_default = default_value.as_deref() == Some(&*option.value.0);
-
-                self.agent_server.set_default_config_option(
-                    self.config_id.0.as_ref(),
-                    if is_default {
-                        None
-                    } else {
-                        Some(option.value.0.as_ref())
-                    },
-                    self.fs.clone(),
-                    cx,
-                );
-            }
-
-            let task = self.config_options.set_config_option(
-                self.config_id.clone(),
-                option.value.clone(),
-                cx,
-            );
-
-            cx.spawn(async move |_, _| {
-                if let Err(err) = task.await {
-                    log::error!("Failed to set config option: {:?}", err);
-                }
-            })
-            .detach();
-
-            cx.emit(DismissEvent);
-        }
-    }
-
-    fn dismissed(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
-        cx.defer_in(window, |picker, window, cx| {
-            picker.set_query("", window, cx);
-        });
-    }
-
-    fn render_match(
-        &self,
-        ix: usize,
-        selected: bool,
-        _: &mut Window,
-        cx: &mut Context<Picker<Self>>,
-    ) -> Option<Self::ListItem> {
-        match self.filtered_entries.get(ix)? {
-            ConfigOptionPickerEntry::Separator(title) => Some(
-                div()
-                    .when(ix > 0, |this| this.mt_1())
-                    .child(
-                        div()
-                            .px_2()
-                            .py_1()
-                            .text_xs()
-                            .text_color(cx.theme().colors().text_muted)
-                            .child(title.clone()),
-                    )
-                    .into_any_element(),
-            ),
-            ConfigOptionPickerEntry::Option(option) => {
-                let current_value = self.current_value();
-                let is_selected = current_value.as_ref() == Some(&option.value);
-
-                let default_value = self
-                    .agent_server
-                    .default_config_option(self.config_id.0.as_ref(), cx);
-                let is_default = default_value.as_deref() == Some(&*option.value.0);
-
-                let is_favorite = self.favorites.contains(&option.value);
-
-                let option_name = option.name.clone();
-                let description = option.description.clone();
-
-                Some(
-                    div()
-                        .id(("config-option-picker-item", ix))
-                        .when_some(description, |this, desc| {
-                            let desc: SharedString = desc.into();
-                            this.on_hover(cx.listener(move |menu, hovered, _, cx| {
-                                if *hovered {
-                                    menu.delegate.selected_description =
-                                        Some((ix, desc.clone(), is_default));
-                                } else if matches!(menu.delegate.selected_description, Some((id, _, _)) if id == ix)
-                                {
-                                    menu.delegate.selected_description = None;
-                                }
-                                cx.notify();
-                            }))
-                        })
-                        .child(
-                            ListItem::new(ix)
-                                .inset(true)
-                                .spacing(ListItemSpacing::Sparse)
-                                .toggle_state(selected)
-                                .child(h_flex().w_full().child(Label::new(option_name).truncate()))
-                                .end_slot(div().pr_2().when(is_selected, |this| {
-                                    this.child(Icon::new(IconName::Check).color(Color::Accent))
-                                }))
-                                .end_hover_slot(div().pr_1p5().child({
-                                    let (icon, color, tooltip) = if is_favorite {
-                                        (IconName::StarFilled, Color::Accent, "Unfavorite")
-                                    } else {
-                                        (IconName::Star, Color::Default, "Favorite")
-                                    };
-
-                                    let config_id = self.config_id.clone();
-                                    let value_id = option.value.clone();
-                                    let agent_server = self.agent_server.clone();
-                                    let fs = self.fs.clone();
-
-                                    IconButton::new(("toggle-favorite-config-option", ix), icon)
-                                        .layer(ElevationIndex::ElevatedSurface)
-                                        .icon_color(color)
-                                        .icon_size(IconSize::Small)
-                                        .tooltip(Tooltip::text(tooltip))
-                                        .on_click(move |_, _, cx| {
-                                            agent_server.toggle_favorite_config_option_value(
-                                                config_id.clone(),
-                                                value_id.clone(),
-                                                !is_favorite,
-                                                fs.clone(),
-                                                cx,
-                                            );
-                                        })
-                                })),
-                        )
-                        .into_any_element(),
-                )
-            }
-        }
-    }
-
-    fn documentation_aside(
-        &self,
-        _window: &mut Window,
-        _cx: &mut Context<Picker<Self>>,
-    ) -> Option<ui::DocumentationAside> {
-        self.selected_description
-            .as_ref()
-            .map(|(_, description, is_default)| {
-                let description = description.clone();
-                let is_default = *is_default;
-
-                ui::DocumentationAside::new(
-                    ui::DocumentationSide::Left,
-                    Rc::new(move |_| {
-                        v_flex()
-                            .gap_1()
-                            .child(Label::new(description.clone()))
-                            .child(HoldForDefault::new(is_default))
-                            .into_any_element()
-                    }),
-                )
-            })
-    }
-
-    fn documentation_aside_index(&self) -> Option<usize> {
-        self.selected_description.as_ref().map(|(ix, _, _)| *ix)
-    }
-}
-
-fn extract_options(
-    config_options: &Rc<dyn AgentSessionConfigOptions>,
-    config_id: &acp::SessionConfigId,
-) -> Vec<ConfigOptionValue> {
-    let Some(option) = config_options
-        .config_options()
-        .into_iter()
-        .find(|opt| &opt.id == config_id)
-    else {
-        return Vec::new();
-    };
-
-    match &option.kind {
-        acp::SessionConfigKind::Select(select) => match &select.options {
-            acp::SessionConfigSelectOptions::Ungrouped(options) => options
-                .iter()
-                .map(|opt| ConfigOptionValue {
-                    value: opt.value.clone(),
-                    name: opt.name.clone(),
-                    description: opt.description.clone(),
-                    group: None,
-                })
-                .collect(),
-            acp::SessionConfigSelectOptions::Grouped(groups) => groups
-                .iter()
-                .flat_map(|group| {
-                    group.options.iter().map(|opt| ConfigOptionValue {
-                        value: opt.value.clone(),
-                        name: opt.name.clone(),
-                        description: opt.description.clone(),
-                        group: Some(group.name.clone()),
-                    })
-                })
-                .collect(),
-            _ => Vec::new(),
-        },
-        _ => Vec::new(),
-    }
-}
-
-fn get_current_value(
-    config_options: &Rc<dyn AgentSessionConfigOptions>,
-    config_id: &acp::SessionConfigId,
-) -> Option<acp::SessionConfigValueId> {
-    config_options
-        .config_options()
-        .into_iter()
-        .find(|opt| &opt.id == config_id)
-        .and_then(|opt| match &opt.kind {
-            acp::SessionConfigKind::Select(select) => Some(select.current_value.clone()),
-            _ => None,
-        })
-}
-
-fn options_to_picker_entries(
-    options: &[ConfigOptionValue],
-    favorites: &HashSet<acp::SessionConfigValueId>,
-) -> Vec<ConfigOptionPickerEntry> {
-    let mut entries = Vec::new();
-
-    let mut favorite_options = Vec::new();
-
-    for option in options {
-        if favorites.contains(&option.value) {
-            favorite_options.push(option.clone());
-        }
-    }
-
-    if !favorite_options.is_empty() {
-        entries.push(ConfigOptionPickerEntry::Separator("Favorites".into()));
-        for option in favorite_options {
-            entries.push(ConfigOptionPickerEntry::Option(option));
-        }
-
-        // If the remaining list would start ungrouped (group == None), insert a separator so
-        // Favorites doesn't visually run into the main list.
-        if let Some(option) = options.first()
-            && option.group.is_none()
-        {
-            entries.push(ConfigOptionPickerEntry::Separator("All Options".into()));
-        }
-    }
-
-    let mut current_group: Option<String> = None;
-    for option in options {
-        if option.group != current_group {
-            if let Some(group_name) = &option.group {
-                entries.push(ConfigOptionPickerEntry::Separator(
-                    group_name.clone().into(),
-                ));
-            }
-            current_group = option.group.clone();
-        }
-        entries.push(ConfigOptionPickerEntry::Option(option.clone()));
-    }
-
-    entries
-}
-
-async fn fuzzy_search_options(
-    options: Vec<ConfigOptionValue>,
-    query: &str,
-    executor: BackgroundExecutor,
-) -> Vec<ConfigOptionValue> {
-    let candidates = options
-        .iter()
-        .enumerate()
-        .map(|(ix, opt)| StringMatchCandidate::new(ix, &opt.name))
-        .collect::<Vec<_>>();
-
-    let mut matches = fuzzy::match_strings(
-        &candidates,
-        query,
-        false,
-        true,
-        100,
-        &Default::default(),
-        executor,
-    )
-    .await;
-
-    matches.sort_unstable_by_key(|mat| {
-        let candidate = &candidates[mat.candidate_id];
-        (Reverse(OrderedFloat(mat.score)), candidate.id)
-    });
-
-    matches
-        .into_iter()
-        .map(|mat| options[mat.candidate_id].clone())
-        .collect()
-}
-
-fn find_option_name(
-    options: &acp::SessionConfigSelectOptions,
-    value_id: &acp::SessionConfigValueId,
-) -> Option<String> {
-    match options {
-        acp::SessionConfigSelectOptions::Ungrouped(opts) => opts
-            .iter()
-            .find(|o| &o.value == value_id)
-            .map(|o| o.name.clone()),
-        acp::SessionConfigSelectOptions::Grouped(groups) => groups.iter().find_map(|group| {
-            group
-                .options
-                .iter()
-                .find(|o| &o.value == value_id)
-                .map(|o| o.name.clone())
-        }),
-        _ => None,
-    }
-}
-
-fn count_config_options(option: &acp::SessionConfigOption) -> usize {
-    match &option.kind {
-        acp::SessionConfigKind::Select(select) => match &select.options {
-            acp::SessionConfigSelectOptions::Ungrouped(options) => options.len(),
-            acp::SessionConfigSelectOptions::Grouped(groups) => {
-                groups.iter().map(|g| g.options.len()).sum()
-            }
-            _ => 0,
-        },
-        _ => 0,
-    }
-}

crates/agent_ui/src/acp/message_editor.rs

@@ -31,7 +31,7 @@ use rope::Point;
 use settings::Settings;
 use std::{cell::RefCell, fmt::Write, rc::Rc, sync::Arc};
 use theme::ThemeSettings;
-use ui::{ContextMenu, prelude::*};
+use ui::prelude::*;
 use util::{ResultExt, debug_panic};
 use workspace::{CollaboratorId, Workspace};
 use zed_actions::agent::{Chat, PasteRaw};
@@ -132,21 +132,6 @@ impl MessageEditor {
                 placement: Some(ContextMenuPlacement::Above),
             });
             editor.register_addon(MessageEditorAddon::new());
-
-            editor.set_custom_context_menu(|editor, _point, window, cx| {
-                let has_selection = editor.has_non_empty_selection(&editor.display_snapshot(cx));
-
-                Some(ContextMenu::build(window, cx, |menu, _, _| {
-                    menu.action("Cut", Box::new(editor::actions::Cut))
-                        .action_disabled_when(
-                            !has_selection,
-                            "Copy",
-                            Box::new(editor::actions::Copy),
-                        )
-                        .action("Paste", Box::new(editor::actions::Paste))
-                }))
-            });
-
             editor
         });
         let mention_set =

crates/agent_ui/src/acp/mode_selector.rs

@@ -7,8 +7,8 @@ use gpui::{Context, Entity, FocusHandle, WeakEntity, Window, prelude::*};
 use settings::Settings as _;
 use std::{rc::Rc, sync::Arc};
 use ui::{
-    Button, ContextMenu, ContextMenuEntry, DocumentationSide, KeyBinding, PopoverMenu,
-    PopoverMenuHandle, Tooltip, prelude::*,
+    Button, ContextMenu, ContextMenuEntry, DocumentationEdge, DocumentationSide, KeyBinding,
+    PopoverMenu, PopoverMenuHandle, Tooltip, prelude::*,
 };
 
 use crate::{CycleModeSelector, ToggleProfileSelector, ui::HoldForDefault};
@@ -105,7 +105,7 @@ impl ModeSelector {
                     .toggleable(IconPosition::End, is_selected);
 
                 let entry = if let Some(description) = &mode.description {
-                    entry.documentation_aside(side, {
+                    entry.documentation_aside(side, DocumentationEdge::Bottom, {
                         let description = description.clone();
 
                         move |_| {

crates/agent_ui/src/acp/model_selector.rs

@@ -3,20 +3,20 @@ use std::{cmp::Reverse, rc::Rc, sync::Arc};
 use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelList, AgentModelSelector};
 use agent_client_protocol::ModelId;
 use agent_servers::AgentServer;
+use agent_settings::AgentSettings;
 use anyhow::Result;
 use collections::{HashSet, IndexMap};
 use fs::Fs;
 use futures::FutureExt;
 use fuzzy::{StringMatchCandidate, match_strings};
 use gpui::{
-    Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, FocusHandle, Subscription, Task,
-    WeakEntity,
+    Action, AsyncWindowContext, BackgroundExecutor, DismissEvent, FocusHandle, Task, WeakEntity,
 };
 use itertools::Itertools;
 use ordered_float::OrderedFloat;
 use picker::{Picker, PickerDelegate};
-use settings::SettingsStore;
-use ui::{DocumentationAside, DocumentationSide, IntoElement, prelude::*};
+use settings::Settings;
+use ui::{DocumentationAside, DocumentationEdge, DocumentationSide, IntoElement, prelude::*};
 use util::ResultExt;
 use zed_actions::agent::OpenSettings;
 
@@ -54,9 +54,7 @@ pub struct AcpModelPickerDelegate {
     selected_index: usize,
     selected_description: Option<(usize, SharedString, bool)>,
     selected_model: Option<AgentModelInfo>,
-    favorites: HashSet<ModelId>,
     _refresh_models_task: Task<()>,
-    _settings_subscription: Subscription,
     focus_handle: FocusHandle,
 }
 
@@ -104,19 +102,6 @@ impl AcpModelPickerDelegate {
             })
         };
 
-        let agent_server_for_subscription = agent_server.clone();
-        let settings_subscription =
-            cx.observe_global_in::<SettingsStore>(window, move |picker, window, cx| {
-                // Only refresh if the favorites actually changed to avoid redundant work
-                // when other settings are modified (e.g., user editing settings.json)
-                let new_favorites = agent_server_for_subscription.favorite_model_ids(cx);
-                if new_favorites != picker.delegate.favorites {
-                    picker.delegate.favorites = new_favorites;
-                    picker.refresh(window, cx);
-                }
-            });
-        let favorites = agent_server.favorite_model_ids(cx);
-
         Self {
             selector,
             agent_server,
@@ -126,9 +111,7 @@ impl AcpModelPickerDelegate {
             selected_model: None,
             selected_index: 0,
             selected_description: None,
-            favorites,
             _refresh_models_task: refresh_models_task,
-            _settings_subscription: settings_subscription,
             focus_handle,
         }
     }
@@ -137,37 +120,40 @@ impl AcpModelPickerDelegate {
         self.selected_model.as_ref()
     }
 
-    pub fn favorites_count(&self) -> usize {
-        self.favorites.len()
-    }
-
     pub fn cycle_favorite_models(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
-        if self.favorites.is_empty() {
+        if !self.selector.supports_favorites() {
             return;
         }
 
-        let Some(models) = &self.models else {
+        let favorites = AgentSettings::get_global(cx).favorite_model_ids();
+
+        if favorites.is_empty() {
+            return;
+        }
+
+        let Some(models) = self.models.clone() else {
             return;
         };
 
-        let all_models: Vec<&AgentModelInfo> = match models {
-            AgentModelList::Flat(list) => list.iter().collect(),
-            AgentModelList::Grouped(index_map) => index_map.values().flatten().collect(),
+        let all_models: Vec<AgentModelInfo> = match models {
+            AgentModelList::Flat(list) => list,
+            AgentModelList::Grouped(index_map) => index_map
+                .into_values()
+                .flatten()
+                .collect::<Vec<AgentModelInfo>>(),
         };
 
-        let favorite_models: Vec<_> = all_models
-            .into_iter()
-            .filter(|model| self.favorites.contains(&model.id))
+        let favorite_models = all_models
+            .iter()
+            .filter(|model| favorites.contains(&model.id))
             .unique_by(|model| &model.id)
-            .collect();
+            .cloned()
+            .collect::<Vec<_>>();
 
-        if favorite_models.is_empty() {
-            return;
-        }
-
-        let current_id = self.selected_model.as_ref().map(|m| &m.id);
+        let current_id = self.selected_model.as_ref().map(|m| m.id.clone());
 
         let current_index_in_favorites = current_id
+            .as_ref()
             .and_then(|id| favorite_models.iter().position(|m| &m.id == id))
             .unwrap_or(usize::MAX);
 
@@ -234,7 +220,11 @@ impl PickerDelegate for AcpModelPickerDelegate {
         window: &mut Window,
         cx: &mut Context<Picker<Self>>,
     ) -> Task<()> {
-        let favorites = self.favorites.clone();
+        let favorites = if self.selector.supports_favorites() {
+            AgentSettings::get_global(cx).favorite_model_ids()
+        } else {
+            Default::default()
+        };
 
         cx.spawn_in(window, async move |this, cx| {
             let filtered_models = match this
@@ -327,20 +317,21 @@ impl PickerDelegate for AcpModelPickerDelegate {
                 let default_model = self.agent_server.default_model(cx);
                 let is_default = default_model.as_ref() == Some(&model_info.id);
 
+                let supports_favorites = self.selector.supports_favorites();
+
                 let is_favorite = *is_favorite;
                 let handle_action_click = {
                     let model_id = model_info.id.clone();
                     let fs = self.fs.clone();
-                    let agent_server = self.agent_server.clone();
 
-                    cx.listener(move |_, _, _, cx| {
-                        agent_server.toggle_favorite_model(
+                    move |cx: &App| {
+                        crate::favorite_models::toggle_model_id_in_settings(
                             model_id.clone(),
                             !is_favorite,
                             fs.clone(),
                             cx,
                         );
-                    })
+                    }
                 };
 
                 Some(
@@ -366,8 +357,10 @@ impl PickerDelegate for AcpModelPickerDelegate {
                                 })
                                 .is_selected(is_selected)
                                 .is_focused(selected)
-                                .is_favorite(is_favorite)
-                                .on_toggle_favorite(handle_action_click),
+                                .when(supports_favorites, |this| {
+                                    this.is_favorite(is_favorite)
+                                        .on_toggle_favorite(handle_action_click)
+                                }),
                         )
                         .into_any_element(),
                 )
@@ -388,6 +381,7 @@ impl PickerDelegate for AcpModelPickerDelegate {
 
                 DocumentationAside::new(
                     DocumentationSide::Left,
+                    DocumentationEdge::Top,
                     Rc::new(move |_| {
                         v_flex()
                             .gap_1()
@@ -399,10 +393,6 @@ impl PickerDelegate for AcpModelPickerDelegate {
             })
     }
 
-    fn documentation_aside_index(&self) -> Option<usize> {
-        self.selected_description.as_ref().map(|(ix, _, _)| *ix)
-    }
-
     fn render_footer(
         &self,
         _window: &mut Window,
@@ -613,46 +603,6 @@ mod tests {
             .collect()
     }
 
-    #[gpui::test]
-    async fn test_fuzzy_match(cx: &mut TestAppContext) {
-        let models = create_model_list(vec![
-            (
-                "zed",
-                vec![
-                    "Claude 3.7 Sonnet",
-                    "Claude 3.7 Sonnet Thinking",
-                    "gpt-4.1",
-                    "gpt-4.1-nano",
-                ],
-            ),
-            ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
-            ("ollama", vec!["mistral", "deepseek"]),
-        ]);
-
-        // Results should preserve models order whenever possible.
-        // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
-        // similarity scores, but `zed/gpt-4.1` was higher in the models list,
-        // so it should appear first in the results.
-        let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
-        assert_models_eq(
-            results,
-            vec![
-                ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
-                ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
-            ],
-        );
-
-        // Fuzzy search
-        let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
-        assert_models_eq(
-            results,
-            vec![
-                ("zed", vec!["gpt-4.1-nano"]),
-                ("openai", vec!["gpt-4.1-nano"]),
-            ],
-        );
-    }
-
     #[gpui::test]
     fn test_favorites_section_appears_when_favorites_exist(_cx: &mut TestAppContext) {
         let models = create_model_list(vec![
@@ -789,48 +739,42 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_favorites_count_returns_correct_count(_cx: &mut TestAppContext) {
-        let empty_favorites: HashSet<ModelId> = HashSet::default();
-        assert_eq!(empty_favorites.len(), 0);
-
-        let one_favorite = create_favorites(vec!["model-a"]);
-        assert_eq!(one_favorite.len(), 1);
-
-        let multiple_favorites = create_favorites(vec!["model-a", "model-b", "model-c"]);
-        assert_eq!(multiple_favorites.len(), 3);
-
-        let with_duplicates = create_favorites(vec!["model-a", "model-a", "model-b"]);
-        assert_eq!(with_duplicates.len(), 2);
-    }
-
-    #[gpui::test]
-    fn test_is_favorite_flag_set_correctly_in_entries(_cx: &mut TestAppContext) {
-        let models = AgentModelList::Flat(vec![
-            acp_thread::AgentModelInfo {
-                id: acp::ModelId::new("favorite-model".to_string()),
-                name: "Favorite".into(),
-                description: None,
-                icon: None,
-            },
-            acp_thread::AgentModelInfo {
-                id: acp::ModelId::new("regular-model".to_string()),
-                name: "Regular".into(),
-                description: None,
-                icon: None,
-            },
+    async fn test_fuzzy_match(cx: &mut TestAppContext) {
+        let models = create_model_list(vec![
+            (
+                "zed",
+                vec![
+                    "Claude 3.7 Sonnet",
+                    "Claude 3.7 Sonnet Thinking",
+                    "gpt-4.1",
+                    "gpt-4.1-nano",
+                ],
+            ),
+            ("openai", vec!["gpt-3.5-turbo", "gpt-4.1", "gpt-4.1-nano"]),
+            ("ollama", vec!["mistral", "deepseek"]),
         ]);
-        let favorites = create_favorites(vec!["favorite-model"]);
 
-        let entries = info_list_to_picker_entries(models, &favorites);
+        // Results should preserve models order whenever possible.
+        // In the case below, `zed/gpt-4.1` and `openai/gpt-4.1` have identical
+        // similarity scores, but `zed/gpt-4.1` was higher in the models list,
+        // so it should appear first in the results.
+        let results = fuzzy_search(models.clone(), "41".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1", "gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1", "gpt-4.1-nano"]),
+            ],
+        );
 
-        for entry in &entries {
-            if let AcpModelPickerEntry::Model(info, is_favorite) = entry {
-                if info.id.0.as_ref() == "favorite-model" {
-                    assert!(*is_favorite, "favorite-model should have is_favorite=true");
-                } else if info.id.0.as_ref() == "regular-model" {
-                    assert!(!*is_favorite, "regular-model should have is_favorite=false");
-                }
-            }
-        }
+        // Fuzzy search
+        let results = fuzzy_search(models.clone(), "4n".into(), cx.executor()).await;
+        assert_models_eq(
+            results,
+            vec![
+                ("zed", vec!["gpt-4.1-nano"]),
+                ("openai", vec!["gpt-4.1-nano"]),
+            ],
+        );
     }
 }

crates/agent_ui/src/acp/model_selector_popover.rs

@@ -2,13 +2,17 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 use acp_thread::{AgentModelIcon, AgentModelInfo, AgentModelSelector};
+use agent_servers::AgentServer;
+use agent_settings::AgentSettings;
 use fs::Fs;
 use gpui::{Entity, FocusHandle};
 use picker::popover_menu::PickerPopoverMenu;
-use ui::{ButtonLike, PopoverMenuHandle, TintColor, Tooltip, prelude::*};
+use settings::Settings as _;
+use ui::{ButtonLike, KeyBinding, PopoverMenuHandle, TintColor, Tooltip, prelude::*};
+use zed_actions::agent::ToggleModelSelector;
 
+use crate::CycleFavoriteModels;
 use crate::acp::{AcpModelSelector, model_selector::acp_model_selector};
-use crate::ui::ModelSelectorTooltip;
 
 pub struct AcpModelSelectorPopover {
     selector: Entity<AcpModelSelector>,
@@ -19,7 +23,7 @@ pub struct AcpModelSelectorPopover {
 impl AcpModelSelectorPopover {
     pub(crate) fn new(
         selector: Rc<dyn AgentModelSelector>,
-        agent_server: Rc<dyn agent_servers::AgentServer>,
+        agent_server: Rc<dyn AgentServer>,
         fs: Arc<dyn Fs>,
         menu_handle: PopoverMenuHandle<AcpModelSelector>,
         focus_handle: FocusHandle,
@@ -60,8 +64,7 @@ impl AcpModelSelectorPopover {
 
 impl Render for AcpModelSelectorPopover {
     fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        let selector = self.selector.read(cx);
-        let model = selector.delegate.active_model();
+        let model = self.selector.read(cx).delegate.active_model();
         let model_name = model
             .as_ref()
             .map(|model| model.name.clone())
@@ -77,13 +80,43 @@ impl Render for AcpModelSelectorPopover {
             (Color::Muted, IconName::ChevronDown)
         };
 
-        let show_cycle_row = selector.delegate.favorites_count() > 1;
-
         let tooltip = Tooltip::element({
-            move |_, _cx| {
-                ModelSelectorTooltip::new(focus_handle.clone())
-                    .show_cycle_row(show_cycle_row)
-                    .into_any_element()
+            move |_, cx| {
+                let focus_handle = focus_handle.clone();
+                let should_show_cycle_row = !AgentSettings::get_global(cx)
+                    .favorite_model_ids()
+                    .is_empty();
+
+                v_flex()
+                    .gap_1()
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .justify_between()
+                            .child(Label::new("Change Model"))
+                            .child(KeyBinding::for_action_in(
+                                &ToggleModelSelector,
+                                &focus_handle,
+                                cx,
+                            )),
+                    )
+                    .when(should_show_cycle_row, |this| {
+                        this.child(
+                            h_flex()
+                                .pt_1()
+                                .gap_2()
+                                .border_t_1()
+                                .border_color(cx.theme().colors().border_variant)
+                                .justify_between()
+                                .child(Label::new("Cycle Favorited Models"))
+                                .child(KeyBinding::for_action_in(
+                                    &CycleFavoriteModels,
+                                    &focus_handle,
+                                    cx,
+                                )),
+                        )
+                    })
+                    .into_any()
             }
         });
 

crates/agent_ui/src/acp/thread_view.rs

@@ -24,11 +24,11 @@ use file_icons::FileIcons;
 use fs::Fs;
 use futures::FutureExt as _;
 use gpui::{
-    Action, Animation, AnimationExt, AnyView, App, BorderStyle, ClickEvent, CursorStyle,
-    EdgesRefinement, ElementId, Empty, Entity, FocusHandle, Focusable, Hsla, Length, ListOffset,
-    ListState, PlatformDisplay, SharedString, StyleRefinement, Subscription, Task, TextStyle,
-    TextStyleRefinement, UnderlineStyle, WeakEntity, Window, WindowHandle, div, ease_in_out,
-    linear_color_stop, linear_gradient, list, point, pulsating_between,
+    Action, Animation, AnimationExt, AnyView, App, BorderStyle, ClickEvent, ClipboardItem,
+    CursorStyle, EdgesRefinement, ElementId, Empty, Entity, FocusHandle, Focusable, Hsla, Length,
+    ListOffset, ListState, PlatformDisplay, SharedString, StyleRefinement, Subscription, Task,
+    TextStyle, TextStyleRefinement, UnderlineStyle, WeakEntity, Window, WindowHandle, div,
+    ease_in_out, linear_color_stop, linear_gradient, list, point, pulsating_between,
 };
 use language::Buffer;
 
@@ -47,16 +47,14 @@ use terminal_view::terminal_panel::TerminalPanel;
 use text::Anchor;
 use theme::{AgentFontSize, ThemeSettings};
 use ui::{
-    Callout, CommonAnimationExt, ContextMenu, ContextMenuEntry, CopyButton, Disclosure, Divider,
-    DividerColor, ElevationIndex, KeyBinding, PopoverMenuHandle, SpinnerLabel, TintColor, Tooltip,
-    WithScrollbar, prelude::*, right_click_menu,
+    Callout, CommonAnimationExt, Disclosure, Divider, DividerColor, ElevationIndex, KeyBinding,
+    PopoverMenuHandle, SpinnerLabel, TintColor, Tooltip, WithScrollbar, prelude::*,
 };
 use util::{ResultExt, size::format_file_size, time::duration_alt_display};
 use workspace::{CollaboratorId, NewTerminal, Workspace};
 use zed_actions::agent::{Chat, ToggleModelSelector};
 use zed_actions::assistant::OpenRulesLibrary;
 
-use super::config_options::ConfigOptionsView;
 use super::entry_view_state::EntryViewState;
 use crate::acp::AcpModelSelectorPopover;
 use crate::acp::ModeSelector;
@@ -273,14 +271,12 @@ pub struct AcpThreadView {
     message_editor: Entity<MessageEditor>,
     focus_handle: FocusHandle,
     model_selector: Option<Entity<AcpModelSelectorPopover>>,
-    config_options_view: Option<Entity<ConfigOptionsView>>,
     profile_selector: Option<Entity<ProfileSelector>>,
     notifications: Vec<WindowHandle<AgentNotification>>,
     notification_subscriptions: HashMap<WindowHandle<AgentNotification>, Vec<Subscription>>,
     thread_retry_status: Option<RetryStatus>,
     thread_error: Option<ThreadError>,
     thread_error_markdown: Option<Entity<Markdown>>,
-    token_limit_callout_dismissed: bool,
     thread_feedback: ThreadFeedbackState,
     list_state: ListState,
     auth_task: Option<Task<()>>,
@@ -432,15 +428,14 @@ impl AcpThreadView {
             login: None,
             message_editor,
             model_selector: None,
-            config_options_view: None,
             profile_selector: None,
+
             notifications: Vec::new(),
             notification_subscriptions: HashMap::default(),
             list_state: list_state,
             thread_retry_status: None,
             thread_error: None,
             thread_error_markdown: None,
-            token_limit_callout_dismissed: false,
             thread_feedback: Default::default(),
             auth_task: None,
             expanded_tool_calls: HashSet::default(),
@@ -617,64 +612,42 @@ impl AcpThreadView {
 
                         AgentDiff::set_active_thread(&workspace, thread.clone(), window, cx);
 
-                        // Check for config options first
-                        // Config options take precedence over legacy mode/model selectors
-                        // (feature flag gating happens at the data layer)
-                        let config_options_provider = thread
+                        this.model_selector = thread
                             .read(cx)
                             .connection()
-                            .session_config_options(thread.read(cx).session_id(), cx);
+                            .model_selector(thread.read(cx).session_id())
+                            .map(|selector| {
+                                let agent_server = this.agent.clone();
+                                let fs = this.project.read(cx).fs().clone();
+                                cx.new(|cx| {
+                                    AcpModelSelectorPopover::new(
+                                        selector,
+                                        agent_server,
+                                        fs,
+                                        PopoverMenuHandle::default(),
+                                        this.focus_handle(cx),
+                                        window,
+                                        cx,
+                                    )
+                                })
+                            });
 
-                        let mode_selector;
-                        if let Some(config_options) = config_options_provider {
-                            // Use config options - don't create mode_selector or model_selector
-                            let agent_server = this.agent.clone();
-                            let fs = this.project.read(cx).fs().clone();
-                            this.config_options_view = Some(cx.new(|cx| {
-                                ConfigOptionsView::new(config_options, agent_server, fs, window, cx)
-                            }));
-                            this.model_selector = None;
-                            mode_selector = None;
-                        } else {
-                            // Fall back to legacy mode/model selectors
-                            this.config_options_view = None;
-                            this.model_selector = thread
-                                .read(cx)
-                                .connection()
-                                .model_selector(thread.read(cx).session_id())
-                                .map(|selector| {
-                                    let agent_server = this.agent.clone();
-                                    let fs = this.project.read(cx).fs().clone();
-                                    cx.new(|cx| {
-                                        AcpModelSelectorPopover::new(
-                                            selector,
-                                            agent_server,
-                                            fs,
-                                            PopoverMenuHandle::default(),
-                                            this.focus_handle(cx),
-                                            window,
-                                            cx,
-                                        )
-                                    })
-                                });
-
-                            mode_selector = thread
-                                .read(cx)
-                                .connection()
-                                .session_modes(thread.read(cx).session_id(), cx)
-                                .map(|session_modes| {
-                                    let fs = this.project.read(cx).fs().clone();
-                                    let focus_handle = this.focus_handle(cx);
-                                    cx.new(|_cx| {
-                                        ModeSelector::new(
-                                            session_modes,
-                                            this.agent.clone(),
-                                            fs,
-                                            focus_handle,
-                                        )
-                                    })
-                                });
-                        }
+                        let mode_selector = thread
+                            .read(cx)
+                            .connection()
+                            .session_modes(thread.read(cx).session_id(), cx)
+                            .map(|session_modes| {
+                                let fs = this.project.read(cx).fs().clone();
+                                let focus_handle = this.focus_handle(cx);
+                                cx.new(|_cx| {
+                                    ModeSelector::new(
+                                        session_modes,
+                                        this.agent.clone(),
+                                        fs,
+                                        focus_handle,
+                                    )
+                                })
+                            });
 
                         let mut subscriptions = vec![
                             cx.subscribe_in(&thread, window, Self::handle_thread_event),
@@ -1420,7 +1393,6 @@ impl AcpThreadView {
     fn clear_thread_error(&mut self, cx: &mut Context<Self>) {
         self.thread_error = None;
         self.thread_error_markdown = None;
-        self.token_limit_callout_dismissed = true;
         cx.notify();
     }
 
@@ -1547,10 +1519,6 @@ impl AcpThreadView {
                 // The connection keeps track of the mode
                 cx.notify();
             }
-            AcpThreadEvent::ConfigOptionsUpdated(_) => {
-                // The watch task in ConfigOptionsView handles rebuilding selectors
-                cx.notify();
-            }
         }
         cx.notify();
     }
@@ -2070,7 +2038,7 @@ impl AcpThreadView {
                                         }
                                     })
                                     .text_xs()
-                                    .child(editor.clone().into_any_element())
+                                    .child(editor.clone().into_any_element()),
                             )
                             .when(editor_focus, |this| {
                                 let base_container = h_flex()
@@ -2186,6 +2154,7 @@ impl AcpThreadView {
                                     if this_is_blank {
                                         return None;
                                     }
+
                                     Some(
                                         self.render_thinking_block(
                                             entry_ix,
@@ -2211,7 +2180,7 @@ impl AcpThreadView {
                         .when(is_last, |this| this.pb_4())
                         .w_full()
                         .text_ui(cx)
-                        .child(self.render_message_context_menu(entry_ix, message_body, cx))
+                        .child(message_body)
                         .into_any()
                 }
             }
@@ -2318,70 +2287,6 @@ impl AcpThreadView {
         }
     }
 
-    fn render_message_context_menu(
-        &self,
-        entry_ix: usize,
-        message_body: AnyElement,
-        cx: &Context<Self>,
-    ) -> AnyElement {
-        let entity = cx.entity();
-        let workspace = self.workspace.clone();
-
-        right_click_menu(format!("agent_context_menu-{}", entry_ix))
-            .trigger(move |_, _, _| message_body)
-            .menu(move |window, cx| {
-                let focus = window.focused(cx);
-                let entity = entity.clone();
-                let workspace = workspace.clone();
-
-                ContextMenu::build(window, cx, move |menu, _, cx| {
-                    let is_at_top = entity.read(cx).list_state.logical_scroll_top().item_ix == 0;
-
-                    let scroll_item = if is_at_top {
-                        ContextMenuEntry::new("Scroll to Bottom").handler({
-                            let entity = entity.clone();
-                            move |_, cx| {
-                                entity.update(cx, |this, cx| {
-                                    this.scroll_to_bottom(cx);
-                                });
-                            }
-                        })
-                    } else {
-                        ContextMenuEntry::new("Scroll to Top").handler({
-                            let entity = entity.clone();
-                            move |_, cx| {
-                                entity.update(cx, |this, cx| {
-                                    this.scroll_to_top(cx);
-                                });
-                            }
-                        })
-                    };
-
-                    let open_thread_as_markdown = ContextMenuEntry::new("Open Thread as Markdown")
-                        .handler({
-                            let entity = entity.clone();
-                            let workspace = workspace.clone();
-                            move |window, cx| {
-                                if let Some(workspace) = workspace.upgrade() {
-                                    entity
-                                        .update(cx, |this, cx| {
-                                            this.open_thread_as_markdown(workspace, window, cx)
-                                        })
-                                        .detach_and_log_err(cx);
-                                }
-                            }
-                        });
-
-                    menu.when_some(focus, |menu, focus| menu.context(focus))
-                        .action("Copy", Box::new(markdown::CopyAsMarkdown))
-                        .separator()
-                        .item(scroll_item)
-                        .item(open_thread_as_markdown)
-                })
-            })
-            .into_any_element()
-    }
-
     fn tool_card_header_bg(&self, cx: &Context<Self>) -> Hsla {
         cx.theme()
             .colors()
@@ -2584,11 +2489,9 @@ impl AcpThreadView {
                                     .border_color(self.tool_card_border_color(cx))
                                     .child(input_output_header("Raw Input:".into()))
                                     .children(tool_call.raw_input_markdown.clone().map(|input| {
-                                        div().id(("tool-call-raw-input-markdown", entry_ix)).child(
-                                            self.render_markdown(
-                                                input,
-                                                default_markdown_style(false, false, window, cx),
-                                            ),
+                                        self.render_markdown(
+                                            input,
+                                            default_markdown_style(false, false, window, cx),
                                         )
                                     }))
                                     .child(input_output_header("Output:".into())),
@@ -2596,17 +2499,15 @@ impl AcpThreadView {
                         })
                         .children(tool_call.content.iter().enumerate().map(
                             |(content_ix, content)| {
-                                div().id(("tool-call-output", entry_ix)).child(
-                                    self.render_tool_call_content(
-                                        entry_ix,
-                                        content,
-                                        content_ix,
-                                        tool_call,
-                                        use_card_layout,
-                                        window,
-                                        cx,
-                                    ),
-                                )
+                                div().child(self.render_tool_call_content(
+                                    entry_ix,
+                                    content,
+                                    content_ix,
+                                    tool_call,
+                                    use_card_layout,
+                                    window,
+                                    cx,
+                                ))
                             },
                         ))
                         .into_any(),
@@ -4383,6 +4284,37 @@ impl AcpThreadView {
 
         v_flex()
             .on_action(cx.listener(Self::expand_message_editor))
+            .on_action(cx.listener(|this, _: &ToggleProfileSelector, window, cx| {
+                if let Some(profile_selector) = this.profile_selector.as_ref() {
+                    profile_selector.read(cx).menu_handle().toggle(window, cx);
+                } else if let Some(mode_selector) = this.mode_selector() {
+                    mode_selector.read(cx).menu_handle().toggle(window, cx);
+                }
+            }))
+            .on_action(cx.listener(|this, _: &CycleModeSelector, window, cx| {
+                if let Some(profile_selector) = this.profile_selector.as_ref() {
+                    profile_selector.update(cx, |profile_selector, cx| {
+                        profile_selector.cycle_profile(cx);
+                    });
+                } else if let Some(mode_selector) = this.mode_selector() {
+                    mode_selector.update(cx, |mode_selector, cx| {
+                        mode_selector.cycle_mode(window, cx);
+                    });
+                }
+            }))
+            .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
+                if let Some(model_selector) = this.model_selector.as_ref() {
+                    model_selector
+                        .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
+                }
+            }))
+            .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| {
+                if let Some(model_selector) = this.model_selector.as_ref() {
+                    model_selector.update(cx, |model_selector, cx| {
+                        model_selector.cycle_favorite_models(window, cx);
+                    });
+                }
+            }))
             .p_2()
             .gap_2()
             .border_t_1()
@@ -4446,12 +4378,8 @@ impl AcpThreadView {
                             .gap_1()
                             .children(self.render_token_usage(cx))
                             .children(self.profile_selector.clone())
-                            // Either config_options_view OR (mode_selector + model_selector)
-                            .children(self.config_options_view.clone())
-                            .when(self.config_options_view.is_none(), |this| {
-                                this.children(self.mode_selector().cloned())
-                                    .children(self.model_selector.clone())
-                            })
+                            .children(self.mode_selector().cloned())
+                            .children(self.model_selector.clone())
                             .child(self.render_send_button(cx)),
                     ),
             )
@@ -5426,26 +5354,22 @@ impl AcpThreadView {
         cx.notify();
     }
 
-    fn render_token_limit_callout(&self, cx: &mut Context<Self>) -> Option<Callout> {
-        if self.token_limit_callout_dismissed {
-            return None;
-        }
-
+    fn render_token_limit_callout(
+        &self,
+        line_height: Pixels,
+        cx: &mut Context<Self>,
+    ) -> Option<Callout> {
         let token_usage = self.thread()?.read(cx).token_usage()?;
         let ratio = token_usage.ratio();
 
-        let (severity, icon, title) = match ratio {
+        let (severity, title) = match ratio {
             acp_thread::TokenUsageRatio::Normal => return None,
-            acp_thread::TokenUsageRatio::Warning => (
-                Severity::Warning,
-                IconName::Warning,
-                "Thread reaching the token limit soon",
-            ),
-            acp_thread::TokenUsageRatio::Exceeded => (
-                Severity::Error,
-                IconName::XCircle,
-                "Thread reached the token limit",
-            ),
+            acp_thread::TokenUsageRatio::Warning => {
+                (Severity::Warning, "Thread reaching the token limit soon")
+            }
+            acp_thread::TokenUsageRatio::Exceeded => {
+                (Severity::Error, "Thread reached the token limit")
+            }
         };
 
         let burn_mode_available = self.as_native_thread(cx).is_some_and(|thread| {
@@ -5465,7 +5389,7 @@ impl AcpThreadView {
         Some(
             Callout::new()
                 .severity(severity)
-                .icon(icon)
+                .line_height(line_height)
                 .title(title)
                 .description(description)
                 .actions_slot(
@@ -5497,8 +5421,7 @@ impl AcpThreadView {
                                     })),
                             )
                         }),
-                )
-                .dismiss_action(self.dismiss_error_button(cx)),
+                ),
         )
     }
 
@@ -5921,13 +5844,18 @@ impl AcpThreadView {
     fn create_copy_button(&self, message: impl Into<String>) -> impl IntoElement {
         let message = message.into();
 
-        CopyButton::new(message).tooltip_label("Copy Error Message")
+        IconButton::new("copy", IconName::Copy)
+            .icon_size(IconSize::Small)
+            .tooltip(Tooltip::text("Copy Error Message"))
+            .on_click(move |_, _, cx| {
+                cx.write_to_clipboard(ClipboardItem::new_string(message.clone()))
+            })
     }
 
     fn dismiss_error_button(&self, cx: &mut Context<Self>) -> impl IntoElement {
         IconButton::new("dismiss", IconName::Close)
             .icon_size(IconSize::Small)
-            .tooltip(Tooltip::text("Dismiss"))
+            .tooltip(Tooltip::text("Dismiss Error"))
             .on_click(cx.listener({
                 move |this, _, _, cx| {
                     this.clear_thread_error(cx);
@@ -6073,37 +6001,6 @@ impl Render for AcpThreadView {
             .on_action(cx.listener(Self::allow_always))
             .on_action(cx.listener(Self::allow_once))
             .on_action(cx.listener(Self::reject_once))
-            .on_action(cx.listener(|this, _: &ToggleProfileSelector, window, cx| {
-                if let Some(profile_selector) = this.profile_selector.as_ref() {
-                    profile_selector.read(cx).menu_handle().toggle(window, cx);
-                } else if let Some(mode_selector) = this.mode_selector() {
-                    mode_selector.read(cx).menu_handle().toggle(window, cx);
-                }
-            }))
-            .on_action(cx.listener(|this, _: &CycleModeSelector, window, cx| {
-                if let Some(profile_selector) = this.profile_selector.as_ref() {
-                    profile_selector.update(cx, |profile_selector, cx| {
-                        profile_selector.cycle_profile(cx);
-                    });
-                } else if let Some(mode_selector) = this.mode_selector() {
-                    mode_selector.update(cx, |mode_selector, cx| {
-                        mode_selector.cycle_mode(window, cx);
-                    });
-                }
-            }))
-            .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
-                if let Some(model_selector) = this.model_selector.as_ref() {
-                    model_selector
-                        .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
-                }
-            }))
-            .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| {
-                if let Some(model_selector) = this.model_selector.as_ref() {
-                    model_selector.update(cx, |model_selector, cx| {
-                        model_selector.cycle_favorite_models(window, cx);
-                    });
-                }
-            }))
             .track_focus(&self.focus_handle)
             .bg(cx.theme().colors().panel_background)
             .child(match &self.thread_state {
@@ -6187,7 +6084,7 @@ impl Render for AcpThreadView {
                 if let Some(usage_callout) = self.render_usage_callout(line_height, cx) {
                     Some(usage_callout.into_any_element())
                 } else {
-                    self.render_token_limit_callout(cx)
+                    self.render_token_limit_callout(line_height, cx)
                         .map(|token_limit_callout| token_limit_callout.into_any_element())
                 },
             )

crates/agent_ui/src/agent_configuration.rs

@@ -1370,9 +1370,6 @@ async fn open_new_agent_servers_entry_in_settings_editor(
                                 env: Some(HashMap::default()),
                                 default_mode: None,
                                 default_model: None,
-                                favorite_models: vec![],
-                                default_config_options: Default::default(),
-                                favorite_config_option_values: Default::default(),
                             },
                         );
                 }

crates/agent_ui/src/agent_diff.rs

@@ -146,13 +146,13 @@ impl AgentDiffPane {
             paths_to_delete.remove(&path_key);
 
             let snapshot = buffer.read(cx).snapshot();
+            let diff = diff_handle.read(cx);
 
-            let diff_hunk_ranges = diff_handle
-                .read(cx)
-                .snapshot(cx)
+            let diff_hunk_ranges = diff
                 .hunks_intersecting_range(
                     language::Anchor::min_max_range_for_buffer(snapshot.remote_id()),
                     &snapshot,
+                    cx,
                 )
                 .map(|diff_hunk| diff_hunk.buffer_range.to_point(&snapshot))
                 .collect::<Vec<_>>();
@@ -1363,8 +1363,7 @@ impl AgentDiff {
             | AcpThreadEvent::PromptCapabilitiesUpdated
             | AcpThreadEvent::AvailableCommandsUpdated(_)
             | AcpThreadEvent::Retry(_)
-            | AcpThreadEvent::ModeUpdated(_)
-            | AcpThreadEvent::ConfigOptionsUpdated(_) => {}
+            | AcpThreadEvent::ModeUpdated(_) => {}
         }
     }
 

crates/agent_ui/src/agent_model_selector.rs

@@ -1,7 +1,6 @@
 use crate::{
     ModelUsageContext,
     language_model_selector::{LanguageModelSelector, language_model_selector},
-    ui::ModelSelectorTooltip,
 };
 use fs::Fs;
 use gpui::{Entity, FocusHandle, SharedString};
@@ -10,6 +9,7 @@ use picker::popover_menu::PickerPopoverMenu;
 use settings::update_settings_file;
 use std::sync::Arc;
 use ui::{ButtonLike, PopoverMenuHandle, TintColor, Tooltip, prelude::*};
+use zed_actions::agent::ToggleModelSelector;
 
 pub struct AgentModelSelector {
     selector: Entity<LanguageModelSelector>,
@@ -81,12 +81,6 @@ impl AgentModelSelector {
     pub fn active_model(&self, cx: &App) -> Option<language_model::ConfiguredModel> {
         self.selector.read(cx).delegate.active_model(cx)
     }
-
-    pub fn cycle_favorite_models(&self, window: &mut Window, cx: &mut Context<Self>) {
-        self.selector.update(cx, |selector, cx| {
-            selector.delegate.cycle_favorite_models(window, cx);
-        });
-    }
 }
 
 impl Render for AgentModelSelector {
@@ -104,18 +98,8 @@ impl Render for AgentModelSelector {
             Color::Muted
         };
 
-        let show_cycle_row = self.selector.read(cx).delegate.favorites_count() > 1;
-
         let focus_handle = self.focus_handle.clone();
 
-        let tooltip = Tooltip::element({
-            move |_, _cx| {
-                ModelSelectorTooltip::new(focus_handle.clone())
-                    .show_cycle_row(show_cycle_row)
-                    .into_any_element()
-            }
-        });
-
         PickerPopoverMenu::new(
             self.selector.clone(),
             ButtonLike::new("active-model")
@@ -141,7 +125,9 @@ impl Render for AgentModelSelector {
                         .color(color)
                         .size(IconSize::XSmall),
                 ),
-            tooltip,
+            move |_window, cx| {
+                Tooltip::for_action_in("Change Model", &ToggleModelSelector, &focus_handle, cx)
+            },
             gpui::Corner::TopRight,
             cx,
         )

crates/agent_ui/src/favorite_models.rs

@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use agent_client_protocol::ModelId;
 use fs::Fs;
 use language_model::LanguageModel;
 use settings::{LanguageModelSelection, update_settings_file};
@@ -12,11 +13,20 @@ fn language_model_to_selection(model: &Arc<dyn LanguageModel>) -> LanguageModelS
     }
 }
 
+fn model_id_to_selection(model_id: &ModelId) -> LanguageModelSelection {
+    let id = model_id.0.as_ref();
+    let (provider, model) = id.split_once('/').unwrap_or(("", id));
+    LanguageModelSelection {
+        provider: provider.to_owned().into(),
+        model: model.to_owned(),
+    }
+}
+
 pub fn toggle_in_settings(
     model: Arc<dyn LanguageModel>,
     should_be_favorite: bool,
     fs: Arc<dyn Fs>,
-    cx: &mut App,
+    cx: &App,
 ) {
     let selection = language_model_to_selection(&model);
     update_settings_file(fs, cx, move |settings, _| {
@@ -28,3 +38,20 @@ pub fn toggle_in_settings(
         }
     });
 }
+
+pub fn toggle_model_id_in_settings(
+    model_id: ModelId,
+    should_be_favorite: bool,
+    fs: Arc<dyn Fs>,
+    cx: &App,
+) {
+    let selection = model_id_to_selection(&model_id);
+    update_settings_file(fs, cx, move |settings, _| {
+        let agent = settings.agent.get_or_insert_default();
+        if should_be_favorite {
+            agent.add_favorite_model(selection.clone());
+        } else {
+            agent.remove_favorite_model(&selection);
+        }
+    });
+}

crates/agent_ui/src/inline_prompt_editor.rs

@@ -40,9 +40,7 @@ use crate::completion_provider::{
 use crate::mention_set::paste_images_as_context;
 use crate::mention_set::{MentionSet, crease_for_mention};
 use crate::terminal_codegen::TerminalCodegen;
-use crate::{
-    CycleFavoriteModels, CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext,
-};
+use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist, ModelUsageContext};
 
 actions!(inline_assistant, [ThumbsUpResult, ThumbsDownResult]);
 
@@ -150,7 +148,7 @@ impl<T: 'static> Render for PromptEditor<T> {
             .into_any_element();
 
         v_flex()
-            .key_context("InlineAssistant")
+            .key_context("PromptEditor")
             .capture_action(cx.listener(Self::paste))
             .block_mouse_except_scroll()
             .size_full()
@@ -164,6 +162,10 @@ impl<T: 'static> Render for PromptEditor<T> {
             .bg(cx.theme().colors().editor_background)
             .child(
                 h_flex()
+                    .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
+                        this.model_selector
+                            .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
+                    }))
                     .on_action(cx.listener(Self::confirm))
                     .on_action(cx.listener(Self::cancel))
                     .on_action(cx.listener(Self::move_up))
@@ -172,15 +174,6 @@ impl<T: 'static> Render for PromptEditor<T> {
                     .on_action(cx.listener(Self::thumbs_down))
                     .capture_action(cx.listener(Self::cycle_prev))
                     .capture_action(cx.listener(Self::cycle_next))
-                    .on_action(cx.listener(|this, _: &ToggleModelSelector, window, cx| {
-                        this.model_selector
-                            .update(cx, |model_selector, cx| model_selector.toggle(window, cx));
-                    }))
-                    .on_action(cx.listener(|this, _: &CycleFavoriteModels, window, cx| {
-                        this.model_selector.update(cx, |model_selector, cx| {
-                            model_selector.cycle_favorite_models(window, cx);
-                        });
-                    }))
                     .child(
                         WithRemSize::new(ui_font_size)
                             .h_full()
@@ -862,7 +855,7 @@ impl<T: 'static> PromptEditor<T> {
                                         .map(|this| {
                                             if rated {
                                                 this.disabled(true)
-                                                    .icon_color(Color::Disabled)
+                                                    .icon_color(Color::Ignored)
                                                     .tooltip(move |_, cx| {
                                                         Tooltip::with_meta(
                                                             "Good Result",
@@ -872,15 +865,8 @@ impl<T: 'static> PromptEditor<T> {
                                                         )
                                                     })
                                             } else {
-                                                this.icon_color(Color::Muted).tooltip(
-                                                    move |_, cx| {
-                                                        Tooltip::for_action(
-                                                            "Good Result",
-                                                            &ThumbsUpResult,
-                                                            cx,
-                                                        )
-                                                    },
-                                                )
+                                                this.icon_color(Color::Muted)
+                                                    .tooltip(Tooltip::text("Good Result"))
                                             }
                                         })
                                         .on_click(cx.listener(|this, _, window, cx| {
@@ -893,7 +879,7 @@ impl<T: 'static> PromptEditor<T> {
                                         .map(|this| {
                                             if rated {
                                                 this.disabled(true)
-                                                    .icon_color(Color::Disabled)
+                                                    .icon_color(Color::Ignored)
                                                     .tooltip(move |_, cx| {
                                                         Tooltip::with_meta(
                                                             "Bad Result",
@@ -903,15 +889,8 @@ impl<T: 'static> PromptEditor<T> {
                                                         )
                                                     })
                                             } else {
-                                                this.icon_color(Color::Muted).tooltip(
-                                                    move |_, cx| {
-                                                        Tooltip::for_action(
-                                                            "Bad Result",
-                                                            &ThumbsDownResult,
-                                                            cx,
-                                                        )
-                                                    },
-                                                )
+                                                this.icon_color(Color::Muted)
+                                                    .tooltip(Tooltip::text("Bad Result"))
                                             }
                                         })
                                         .on_click(cx.listener(|this, _, window, cx| {
@@ -1109,6 +1088,7 @@ impl<T: 'static> PromptEditor<T> {
         let colors = cx.theme().colors();
 
         div()
+            .key_context("InlineAssistEditor")
             .size_full()
             .p_2()
             .pl_1()

crates/agent_ui/src/language_model_selector.rs

@@ -20,14 +20,14 @@ use crate::ui::{ModelSelectorFooter, ModelSelectorHeader, ModelSelectorListItem}
 
 type OnModelChanged = Arc<dyn Fn(Arc<dyn LanguageModel>, &mut App) + 'static>;
 type GetActiveModel = Arc<dyn Fn(&App) -> Option<ConfiguredModel> + 'static>;
-type OnToggleFavorite = Arc<dyn Fn(Arc<dyn LanguageModel>, bool, &mut App) + 'static>;
+type OnToggleFavorite = Arc<dyn Fn(Arc<dyn LanguageModel>, bool, &App) + 'static>;
 
 pub type LanguageModelSelector = Picker<LanguageModelPickerDelegate>;
 
 pub fn language_model_selector(
     get_active_model: impl Fn(&App) -> Option<ConfiguredModel> + 'static,
     on_model_changed: impl Fn(Arc<dyn LanguageModel>, &mut App) + 'static,
-    on_toggle_favorite: impl Fn(Arc<dyn LanguageModel>, bool, &mut App) + 'static,
+    on_toggle_favorite: impl Fn(Arc<dyn LanguageModel>, bool, &App) + 'static,
     popover_styles: bool,
     focus_handle: FocusHandle,
     window: &mut Window,
@@ -133,7 +133,7 @@ impl LanguageModelPickerDelegate {
     fn new(
         get_active_model: impl Fn(&App) -> Option<ConfiguredModel> + 'static,
         on_model_changed: impl Fn(Arc<dyn LanguageModel>, &mut App) + 'static,
-        on_toggle_favorite: impl Fn(Arc<dyn LanguageModel>, bool, &mut App) + 'static,
+        on_toggle_favorite: impl Fn(Arc<dyn LanguageModel>, bool, &App) + 'static,
         popover_styles: bool,
         focus_handle: FocusHandle,
         window: &mut Window,
@@ -250,10 +250,6 @@ impl LanguageModelPickerDelegate {
         (self.get_active_model)(cx)
     }
 
-    pub fn favorites_count(&self) -> usize {
-        self.all_models.favorites.len()
-    }
-
     pub fn cycle_favorite_models(&mut self, window: &mut Window, cx: &mut Context<Picker<Self>>) {
         if self.all_models.favorites.is_empty() {
             return;
@@ -565,10 +561,7 @@ impl PickerDelegate for LanguageModelPickerDelegate {
                 let handle_action_click = {
                     let model = model_info.model.clone();
                     let on_toggle_favorite = self.on_toggle_favorite.clone();
-                    cx.listener(move |picker, _, window, cx| {
-                        on_toggle_favorite(model.clone(), !is_favorite, cx);
-                        picker.refresh(window, cx);
-                    })
+                    move |cx: &App| on_toggle_favorite(model.clone(), !is_favorite, cx)
                 };
 
                 Some(

crates/agent_ui/src/mention_set.rs

@@ -12,8 +12,8 @@ use editor::{
 };
 use futures::{AsyncReadExt as _, FutureExt as _, future::Shared};
 use gpui::{
-    AppContext, ClipboardEntry, Context, Empty, Entity, EntityId, Image, ImageFormat, Img,
-    SharedString, Task, WeakEntity,
+    Animation, AnimationExt as _, AppContext, ClipboardEntry, Context, Empty, Entity, EntityId,
+    Image, ImageFormat, Img, SharedString, Task, WeakEntity, pulsating_between,
 };
 use http_client::{AsyncBody, HttpClientWithUrl};
 use itertools::Either;
@@ -32,14 +32,13 @@ use std::{
     path::{Path, PathBuf},
     rc::Rc,
     sync::Arc,
+    time::Duration,
 };
 use text::OffsetRangeExt;
-use ui::{Disclosure, Toggleable, prelude::*};
+use ui::{ButtonLike, Disclosure, TintColor, Toggleable, prelude::*};
 use util::{ResultExt, debug_panic, rel_path::RelPath};
 use workspace::{Workspace, notifications::NotifyResultExt as _};
 
-use crate::ui::MentionCrease;
-
 pub type MentionTask = Shared<Task<Result<Mention, String>>>;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -755,8 +754,25 @@ fn render_fold_icon_button(
                 .update(cx, |editor, cx| editor.is_range_selected(&fold_range, cx))
                 .unwrap_or_default();
 
-            MentionCrease::new(fold_id, icon_path.clone(), label.clone())
-                .is_toggled(is_in_text_selection)
+            ButtonLike::new(fold_id)
+                .style(ButtonStyle::Filled)
+                .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+                .toggle_state(is_in_text_selection)
+                .child(
+                    h_flex()
+                        .gap_1()
+                        .child(
+                            Icon::from_path(icon_path.clone())
+                                .size(IconSize::XSmall)
+                                .color(Color::Muted),
+                        )
+                        .child(
+                            Label::new(label.clone())
+                                .size(LabelSize::Small)
+                                .buffer_font(cx)
+                                .single_line(),
+                        ),
+                )
                 .into_any_element()
         }
     })
@@ -931,14 +947,12 @@ impl Render for LoadingContext {
             .editor
             .update(cx, |editor, cx| editor.is_range_selected(&self.range, cx))
             .unwrap_or_default();
-
-        let id = ElementId::from(("loading_context", self.id));
-
-        MentionCrease::new(id, self.icon.clone(), self.label.clone())
-            .is_toggled(is_in_text_selection)
-            .is_loading(self.loading.is_some())
-            .when_some(self.image.clone(), |this, image_task| {
-                this.image_preview(move |_, cx| {
+        ButtonLike::new(("loading-context", self.id))
+            .style(ButtonStyle::Filled)
+            .selected_style(ButtonStyle::Tinted(TintColor::Accent))
+            .toggle_state(is_in_text_selection)
+            .when_some(self.image.clone(), |el, image_task| {
+                el.hoverable_tooltip(move |_, cx| {
                     let image = image_task.peek().cloned().transpose().ok().flatten();
                     let image_task = image_task.clone();
                     cx.new::<ImageHover>(|cx| ImageHover {
@@ -957,6 +971,35 @@ impl Render for LoadingContext {
                     .into()
                 })
             })
+            .child(
+                h_flex()
+                    .gap_1()
+                    .child(
+                        Icon::from_path(self.icon.clone())
+                            .size(IconSize::XSmall)
+                            .color(Color::Muted),
+                    )
+                    .child(
+                        Label::new(self.label.clone())
+                            .size(LabelSize::Small)
+                            .buffer_font(cx)
+                            .single_line(),
+                    )
+                    .map(|el| {
+                        if self.loading.is_some() {
+                            el.with_animation(
+                                "loading-context-crease",
+                                Animation::new(Duration::from_secs(2))
+                                    .repeat()
+                                    .with_easing(pulsating_between(0.4, 0.8)),
+                                |label, delta| label.opacity(delta),
+                            )
+                            .into_any()
+                        } else {
+                            el.into_any()
+                        }
+                    }),
+            )
     }
 }
 

crates/agent_ui/src/profile_selector.rs

@@ -15,8 +15,8 @@ use std::{
     sync::{Arc, atomic::AtomicBool},
 };
 use ui::{
-    DocumentationAside, DocumentationSide, HighlightedLabel, KeyBinding, LabelSize, ListItem,
-    ListItemSpacing, PopoverMenuHandle, TintColor, Tooltip, prelude::*,
+    DocumentationAside, DocumentationEdge, DocumentationSide, HighlightedLabel, KeyBinding,
+    LabelSize, ListItem, ListItemSpacing, PopoverMenuHandle, TintColor, Tooltip, prelude::*,
 };
 
 /// Trait for types that can provide and manage agent profiles
@@ -244,7 +244,6 @@ pub(crate) struct ProfilePickerDelegate {
     string_candidates: Arc<Vec<StringMatchCandidate>>,
     filtered_entries: Vec<ProfilePickerEntry>,
     selected_index: usize,
-    hovered_index: Option<usize>,
     query: String,
     cancel: Option<Arc<AtomicBool>>,
     focus_handle: FocusHandle,
@@ -271,7 +270,6 @@ impl ProfilePickerDelegate {
             string_candidates,
             filtered_entries,
             selected_index: 0,
-            hovered_index: None,
             query: String::new(),
             cancel: None,
             focus_handle,
@@ -580,38 +578,23 @@ impl PickerDelegate for ProfilePickerDelegate {
                 let candidate = self.candidates.get(entry.candidate_index)?;
                 let active_id = self.provider.profile_id(cx);
                 let is_active = active_id == candidate.id;
-                let has_documentation = Self::documentation(candidate).is_some();
 
                 Some(
-                    div()
-                        .id(("profile-picker-item", ix))
-                        .when(has_documentation, |this| {
-                            this.on_hover(cx.listener(move |picker, hovered, _, cx| {
-                                if *hovered {
-                                    picker.delegate.hovered_index = Some(ix);
-                                } else if picker.delegate.hovered_index == Some(ix) {
-                                    picker.delegate.hovered_index = None;
-                                }
-                                cx.notify();
-                            }))
+                    ListItem::new(candidate.id.0.clone())
+                        .inset(true)
+                        .spacing(ListItemSpacing::Sparse)
+                        .toggle_state(selected)
+                        .child(HighlightedLabel::new(
+                            candidate.name.clone(),
+                            entry.positions.clone(),
+                        ))
+                        .when(is_active, |this| {
+                            this.end_slot(
+                                div()
+                                    .pr_2()
+                                    .child(Icon::new(IconName::Check).color(Color::Accent)),
+                            )
                         })
-                        .child(
-                            ListItem::new(candidate.id.0.clone())
-                                .inset(true)
-                                .spacing(ListItemSpacing::Sparse)
-                                .toggle_state(selected)
-                                .child(HighlightedLabel::new(
-                                    candidate.name.clone(),
-                                    entry.positions.clone(),
-                                ))
-                                .when(is_active, |this| {
-                                    this.end_slot(
-                                        div()
-                                            .pr_2()
-                                            .child(Icon::new(IconName::Check).color(Color::Accent)),
-                                    )
-                                }),
-                        )
                         .into_any_element(),
                 )
             }
@@ -625,8 +608,7 @@ impl PickerDelegate for ProfilePickerDelegate {
     ) -> Option<DocumentationAside> {
         use std::rc::Rc;
 
-        let hovered_index = self.hovered_index?;
-        let entry = match self.filtered_entries.get(hovered_index)? {
+        let entry = match self.filtered_entries.get(self.selected_index)? {
             ProfilePickerEntry::Profile(entry) => entry,
             ProfilePickerEntry::Header(_) => return None,
         };
@@ -644,14 +626,11 @@ impl PickerDelegate for ProfilePickerDelegate {
 
         Some(DocumentationAside {
             side,
+            edge: DocumentationEdge::Top,
             render: Rc::new(move |_| Label::new(docs_aside.clone()).into_any_element()),
         })
     }
 
-    fn documentation_aside_index(&self) -> Option<usize> {
-        self.hovered_index
-    }
-
     fn render_footer(
         &self,
         _: &mut Window,
@@ -739,7 +718,6 @@ mod tests {
                 string_candidates: Arc::new(Vec::new()),
                 filtered_entries: Vec::new(),
                 selected_index: 0,
-                hovered_index: None,
                 query: String::new(),
                 cancel: None,
                 focus_handle,
@@ -774,7 +752,6 @@ mod tests {
                 background: cx.background_executor().clone(),
                 candidates,
                 string_candidates: Arc::new(Vec::new()),
-                hovered_index: None,
                 filtered_entries: vec![
                     ProfilePickerEntry::Profile(ProfileMatchEntry {
                         candidate_index: 0,

crates/agent_ui/src/text_thread_editor.rs

@@ -1,8 +1,8 @@
 use crate::{
     language_model_selector::{LanguageModelSelector, language_model_selector},
-    ui::{BurnModeTooltip, ModelSelectorTooltip},
+    ui::BurnModeTooltip,
 };
-use agent_settings::CompletionMode;
+use agent_settings::{AgentSettings, CompletionMode};
 use anyhow::Result;
 use assistant_slash_command::{SlashCommand, SlashCommandOutputSection, SlashCommandWorkingSet};
 use assistant_slash_commands::{DefaultSlashCommand, FileSlashCommand, selections_creases};
@@ -2252,18 +2252,43 @@ impl TextThreadEditor {
         .color(color)
         .size(IconSize::XSmall);
 
-        let show_cycle_row = self
-            .language_model_selector
-            .read(cx)
-            .delegate
-            .favorites_count()
-            > 1;
-
         let tooltip = Tooltip::element({
-            move |_, _cx| {
-                ModelSelectorTooltip::new(focus_handle.clone())
-                    .show_cycle_row(show_cycle_row)
-                    .into_any_element()
+            move |_, cx| {
+                let focus_handle = focus_handle.clone();
+                let should_show_cycle_row = !AgentSettings::get_global(cx)
+                    .favorite_model_ids()
+                    .is_empty();
+
+                v_flex()
+                    .gap_1()
+                    .child(
+                        h_flex()
+                            .gap_2()
+                            .justify_between()
+                            .child(Label::new("Change Model"))
+                            .child(KeyBinding::for_action_in(
+                                &ToggleModelSelector,
+                                &focus_handle,
+                                cx,
+                            )),
+                    )
+                    .when(should_show_cycle_row, |this| {
+                        this.child(
+                            h_flex()
+                                .pt_1()
+                                .gap_2()
+                                .border_t_1()
+                                .border_color(cx.theme().colors().border_variant)
+                                .justify_between()
+                                .child(Label::new("Cycle Favorited Models"))
+                                .child(KeyBinding::for_action_in(
+                                    &CycleFavoriteModels,
+                                    &focus_handle,
+                                    cx,
+                                )),
+                        )
+                    })
+                    .into_any()
             }
         });
 

crates/agent_ui/src/ui.rs

@@ -4,7 +4,6 @@ mod burn_mode_tooltip;
 mod claude_code_onboarding_modal;
 mod end_trial_upsell;
 mod hold_for_default;
-mod mention_crease;
 mod model_selector_components;
 mod onboarding_modal;
 mod usage_callout;
@@ -15,7 +14,6 @@ pub use burn_mode_tooltip::*;
 pub use claude_code_onboarding_modal::*;
 pub use end_trial_upsell::*;
 pub use hold_for_default::*;
-pub use mention_crease::*;
 pub use model_selector_components::*;
 pub use onboarding_modal::*;
 pub use usage_callout::*;

crates/agent_ui/src/ui/hold_for_default.rs

@@ -27,7 +27,7 @@ impl RenderOnce for HoldForDefault {
                 PlatformStyle::platform(),
                 None,
                 Some(TextSize::Default.rems(cx).into()),
-                false,
+                true,
             )))
             .child(div().map(|this| {
                 if self.is_default {

crates/agent_ui/src/ui/mention_crease.rs

@@ -1,100 +0,0 @@
-use std::time::Duration;
-
-use gpui::{Animation, AnimationExt, AnyView, IntoElement, Window, pulsating_between};
-use settings::Settings;
-use theme::ThemeSettings;
-use ui::{ButtonLike, TintColor, prelude::*};
-
-#[derive(IntoElement)]
-pub struct MentionCrease {
-    id: ElementId,
-    icon: SharedString,
-    label: SharedString,
-    is_toggled: bool,
-    is_loading: bool,
-    image_preview: Option<Box<dyn Fn(&mut Window, &mut App) -> AnyView + 'static>>,
-}
-
-impl MentionCrease {
-    pub fn new(
-        id: impl Into<ElementId>,
-        icon: impl Into<SharedString>,
-        label: impl Into<SharedString>,
-    ) -> Self {
-        Self {
-            id: id.into(),
-            icon: icon.into(),
-            label: label.into(),
-            is_toggled: false,
-            is_loading: false,
-            image_preview: None,
-        }
-    }
-
-    pub fn is_toggled(mut self, is_toggled: bool) -> Self {
-        self.is_toggled = is_toggled;
-        self
-    }
-
-    pub fn is_loading(mut self, is_loading: bool) -> Self {
-        self.is_loading = is_loading;
-        self
-    }
-
-    pub fn image_preview(
-        mut self,
-        builder: impl Fn(&mut Window, &mut App) -> AnyView + 'static,
-    ) -> Self {
-        self.image_preview = Some(Box::new(builder));
-        self
-    }
-}
-
-impl RenderOnce for MentionCrease {
-    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let settings = ThemeSettings::get_global(cx);
-        let font_size = settings.agent_buffer_font_size(cx);
-        let buffer_font = settings.buffer_font.clone();
-
-        let button_height = DefiniteLength::Absolute(AbsoluteLength::Pixels(
-            px(window.line_height().into()) - px(1.),
-        ));
-
-        ButtonLike::new(self.id)
-            .style(ButtonStyle::Outlined)
-            .size(ButtonSize::Compact)
-            .height(button_height)
-            .selected_style(ButtonStyle::Tinted(TintColor::Accent))
-            .toggle_state(self.is_toggled)
-            .when_some(self.image_preview, |this, image_preview| {
-                this.hoverable_tooltip(image_preview)
-            })
-            .child(
-                h_flex()
-                    .pb_px()
-                    .gap_1()
-                    .font(buffer_font)
-                    .text_size(font_size)
-                    .child(
-                        Icon::from_path(self.icon.clone())
-                            .size(IconSize::XSmall)
-                            .color(Color::Muted),
-                    )
-                    .child(self.label.clone())
-                    .map(|this| {
-                        if self.is_loading {
-                            this.with_animation(
-                                "loading-context-crease",
-                                Animation::new(Duration::from_secs(2))
-                                    .repeat()
-                                    .with_easing(pulsating_between(0.4, 0.8)),
-                                |label, delta| label.opacity(delta),
-                            )
-                            .into_any()
-                        } else {
-                            this.into_any()
-                        }
-                    }),
-            )
-    }
-}

crates/agent_ui/src/ui/model_selector_components.rs

@@ -1,8 +1,5 @@
-use gpui::{Action, ClickEvent, FocusHandle, prelude::*};
+use gpui::{Action, FocusHandle, prelude::*};
 use ui::{ElevationIndex, KeyBinding, ListItem, ListItemSpacing, Tooltip, prelude::*};
-use zed_actions::agent::ToggleModelSelector;
-
-use crate::CycleFavoriteModels;
 
 enum ModelIcon {
     Name(IconName),
@@ -51,7 +48,7 @@ pub struct ModelSelectorListItem {
     is_selected: bool,
     is_focused: bool,
     is_favorite: bool,
-    on_toggle_favorite: Option<Box<dyn Fn(&ClickEvent, &mut Window, &mut App) + 'static>>,
+    on_toggle_favorite: Option<Box<dyn Fn(&App) + 'static>>,
 }
 
 impl ModelSelectorListItem {
@@ -92,10 +89,7 @@ impl ModelSelectorListItem {
         self
     }
 
-    pub fn on_toggle_favorite(
-        mut self,
-        handler: impl Fn(&ClickEvent, &mut Window, &mut App) + 'static,
-    ) -> Self {
+    pub fn on_toggle_favorite(mut self, handler: impl Fn(&App) + 'static) -> Self {
         self.on_toggle_favorite = Some(Box::new(handler));
         self
     }
@@ -147,7 +141,7 @@ impl RenderOnce for ModelSelectorListItem {
                             .icon_color(color)
                             .icon_size(IconSize::Small)
                             .tooltip(Tooltip::text(tooltip))
-                            .on_click(move |event, window, cx| (handle_click)(event, window, cx)),
+                            .on_click(move |_, _, cx| (handle_click)(cx)),
                     )
                 }
             }))
@@ -193,57 +187,3 @@ impl RenderOnce for ModelSelectorFooter {
             )
     }
 }
-
-#[derive(IntoElement)]
-pub struct ModelSelectorTooltip {
-    focus_handle: FocusHandle,
-    show_cycle_row: bool,
-}
-
-impl ModelSelectorTooltip {
-    pub fn new(focus_handle: FocusHandle) -> Self {
-        Self {
-            focus_handle,
-            show_cycle_row: true,
-        }
-    }
-
-    pub fn show_cycle_row(mut self, show: bool) -> Self {
-        self.show_cycle_row = show;
-        self
-    }
-}
-
-impl RenderOnce for ModelSelectorTooltip {
-    fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        v_flex()
-            .gap_1()
-            .child(
-                h_flex()
-                    .gap_2()
-                    .justify_between()
-                    .child(Label::new("Change Model"))
-                    .child(KeyBinding::for_action_in(
-                        &ToggleModelSelector,
-                        &self.focus_handle,
-                        cx,
-                    )),
-            )
-            .when(self.show_cycle_row, |this| {
-                this.child(
-                    h_flex()
-                        .pt_1()
-                        .gap_2()
-                        .border_t_1()
-                        .border_color(cx.theme().colors().border_variant)
-                        .justify_between()
-                        .child(Label::new("Cycle Favorited Models"))
-                        .child(KeyBinding::for_action_in(
-                            &CycleFavoriteModels,
-                            &self.focus_handle,
-                            cx,
-                        )),
-                )
-            })
-    }
-}

crates/buffer_diff/Cargo.toml

@@ -15,6 +15,7 @@ path = "src/buffer_diff.rs"
 test-support = ["settings"]
 
 [dependencies]
+anyhow.workspace = true
 clock.workspace = true
 futures.workspace = true
 git2.workspace = true

crates/collab/src/api/contributors.rs

@@ -113,7 +113,7 @@ impl CopilotSweAgentBot {
     const USER_ID: i32 = 198982749;
     /// The alias of the GitHub copilot user. Although https://api.github.com/users/copilot
     /// yields a 404, GitHub still refers to the copilot bot user as @Copilot in some cases.
-    const NAME_ALIAS: &'static str = "Copilot";
+    const NAME_ALIAS: &'static str = "copilot";
 
     /// Returns the `created_at` timestamp for the Dependabot bot user.
     fn created_at() -> &'static NaiveDateTime {

crates/collab/src/tests/integration_tests.rs

@@ -2647,13 +2647,13 @@ async fn test_git_diff_base_change(
     local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(1..2, "", "two\n", DiffHunkStatus::added_none())],
         );
     });
@@ -2677,13 +2677,13 @@ async fn test_git_diff_base_change(
     remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(1..2, "", "two\n", DiffHunkStatus::added_none())],
         );
     });
@@ -2699,13 +2699,13 @@ async fn test_git_diff_base_change(
     remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(committed_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(
                 1..2,
                 "TWO\n",
@@ -2731,13 +2731,13 @@ async fn test_git_diff_base_change(
     local_unstaged_diff_a.read_with(cx_a, |diff, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(new_staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(2..3, "", "three\n", DiffHunkStatus::added_none())],
         );
     });
@@ -2746,13 +2746,13 @@ async fn test_git_diff_base_change(
     remote_unstaged_diff_a.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(new_staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(2..3, "", "three\n", DiffHunkStatus::added_none())],
         );
     });
@@ -2760,13 +2760,13 @@ async fn test_git_diff_base_change(
     remote_uncommitted_diff_a.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_a.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(new_committed_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(
                 1..2,
                 "TWO_HUNDRED\n",
@@ -2813,13 +2813,13 @@ async fn test_git_diff_base_change(
     local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
-            &diff.base_text_string(cx).unwrap(),
+            &diff.base_text_string().unwrap(),
             &[(1..2, "", "two\n", DiffHunkStatus::added_none())],
         );
     });
@@ -2842,11 +2842,11 @@ async fn test_git_diff_base_change(
     remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_b.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
             &staged_text,
             &[(1..2, "", "two\n", DiffHunkStatus::added_none())],
@@ -2864,11 +2864,11 @@ async fn test_git_diff_base_change(
     local_unstaged_diff_b.read_with(cx_a, |diff, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(new_staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
             &new_staged_text,
             &[(2..3, "", "three\n", DiffHunkStatus::added_none())],
@@ -2878,11 +2878,11 @@ async fn test_git_diff_base_change(
     remote_unstaged_diff_b.read_with(cx_b, |diff, cx| {
         let buffer = remote_buffer_b.read(cx);
         assert_eq!(
-            diff.base_text_string(cx).as_deref(),
+            diff.base_text_string().as_deref(),
             Some(new_staged_text.as_str())
         );
         assert_hunks(
-            diff.snapshot(cx).hunks_in_row_range(0..4, buffer),
+            diff.hunks_in_row_range(0..4, buffer, cx),
             buffer,
             &new_staged_text,
             &[(2..3, "", "three\n", DiffHunkStatus::added_none())],
@@ -5195,7 +5195,7 @@ async fn test_project_search(
             cx,
         )
     });
-    while let Ok(result) = search_rx.rx.recv().await {
+    while let Ok(result) = search_rx.recv().await {
         match result {
             SearchResult::Buffer { buffer, ranges } => {
                 results.entry(buffer).or_insert(ranges);
@@ -6745,13 +6745,8 @@ async fn test_preview_tabs(cx: &mut TestAppContext) {
     });
 
     // Split pane to the right
-    pane.update_in(cx, |pane, window, cx| {
-        pane.split(
-            workspace::SplitDirection::Right,
-            workspace::SplitMode::default(),
-            window,
-            cx,
-        );
+    pane.update(cx, |pane, cx| {
+        pane.split(workspace::SplitDirection::Right, cx);
     });
     cx.run_until_parked();
     let right_pane = workspace.read_with(cx, |workspace, _| workspace.active_pane().clone());

crates/collab/src/tests/random_project_collaboration_tests.rs

@@ -905,7 +905,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                 drop(project);
                 let search = cx.executor().spawn(async move {
                     let mut results = HashMap::default();
-                    while let Ok(result) = search.rx.recv().await {
+                    while let Ok(result) = search.recv().await {
                         if let SearchResult::Buffer { buffer, ranges } = result {
                             results.entry(buffer).or_insert(ranges);
                         }
@@ -1377,7 +1377,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             .get_unstaged_diff(host_buffer.read(cx).remote_id(), cx)
                             .unwrap()
                             .read(cx)
-                            .base_text_string(cx)
+                            .base_text_string()
                     });
                     let guest_diff_base = guest_project.read_with(client_cx, |project, cx| {
                         project
@@ -1386,7 +1386,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                             .get_unstaged_diff(guest_buffer.read(cx).remote_id(), cx)
                             .unwrap()
                             .read(cx)
-                            .base_text_string(cx)
+                            .base_text_string()
                     });
                     assert_eq!(
                         guest_diff_base, host_diff_base,

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -855,6 +855,8 @@ async fn test_slow_adapter_startup_retries(
 
 #[gpui::test]
 async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &mut TestAppContext) {
+    use project::trusted_worktrees::RemoteHostLocation;
+
     cx_a.update(|cx| {
         release_channel::init(semver::Version::new(0, 0, 0), cx);
         project::trusted_worktrees::init(HashMap::default(), None, None, cx);
@@ -989,19 +991,23 @@ async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &m
     });
     assert_eq!(worktree_ids.len(), 2);
 
+    let remote_host = project_a.read_with(cx_a, |project, cx| {
+        project
+            .remote_connection_options(cx)
+            .map(RemoteHostLocation::from)
+    });
+
     let trusted_worktrees =
         cx_a.update(|cx| TrustedWorktrees::try_get_global(cx).expect("trust global should exist"));
-    let worktree_store = project_a.read_with(cx_a, |project, _| project.worktree_store());
 
-    let can_trust_a = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[0], cx)
-    });
-    let can_trust_b = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[1], cx)
-    });
+    let can_trust_a =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx));
+    let can_trust_b =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx));
     assert!(!can_trust_a, "project_a should be restricted initially");
     assert!(!can_trust_b, "project_b should be restricted initially");
 
+    let worktree_store = project_a.read_with(cx_a, |project, _| project.worktree_store());
     let has_restricted = trusted_worktrees.read_with(cx_a, |store, cx| {
         store.has_restricted_worktrees(&worktree_store, cx)
     });
@@ -1048,8 +1054,8 @@ async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &m
 
     trusted_worktrees.update(cx_a, |store, cx| {
         store.trust(
-            &worktree_store,
             HashSet::from_iter([PathTrust::Worktree(worktree_ids[0])]),
+            remote_host.clone(),
             cx,
         );
     });
@@ -1074,29 +1080,25 @@ async fn test_ssh_remote_worktree_trust(cx_a: &mut TestAppContext, server_cx: &m
         "inlay hints should be queried after trust approval"
     );
 
-    let can_trust_a = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[0], cx)
-    });
-    let can_trust_b = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[1], cx)
-    });
+    let can_trust_a =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx));
+    let can_trust_b =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx));
     assert!(can_trust_a, "project_a should be trusted after trust()");
     assert!(!can_trust_b, "project_b should still be restricted");
 
     trusted_worktrees.update(cx_a, |store, cx| {
         store.trust(
-            &worktree_store,
             HashSet::from_iter([PathTrust::Worktree(worktree_ids[1])]),
+            remote_host.clone(),
             cx,
         );
     });
 
-    let can_trust_a = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[0], cx)
-    });
-    let can_trust_b = trusted_worktrees.update(cx_a, |store, cx| {
-        store.can_trust(&worktree_store, worktree_ids[1], cx)
-    });
+    let can_trust_a =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[0], cx));
+    let can_trust_b =
+        trusted_worktrees.update(cx_a, |store, cx| store.can_trust(worktree_ids[1], cx));
     assert!(can_trust_a, "project_a should remain trusted");
     assert!(can_trust_b, "project_b should now be trusted");
 

crates/collab_ui/src/collab_panel.rs

@@ -31,9 +31,9 @@ use smallvec::SmallVec;
 use std::{mem, sync::Arc};
 use theme::{ActiveTheme, ThemeSettings};
 use ui::{
-    Avatar, AvatarAvailabilityIndicator, Button, Color, ContextMenu, CopyButton, Facepile,
-    HighlightedLabel, Icon, IconButton, IconName, IconSize, Indicator, Label, ListHeader, ListItem,
-    Tab, Tooltip, prelude::*, tooltip_container,
+    Avatar, AvatarAvailabilityIndicator, Button, Color, ContextMenu, Facepile, HighlightedLabel,
+    Icon, IconButton, IconName, IconSize, Indicator, Label, ListHeader, ListItem, Tab, Tooltip,
+    prelude::*, tooltip_container,
 };
 use util::{ResultExt, TryFutureExt, maybe};
 use workspace::{
@@ -2527,9 +2527,16 @@ impl CollabPanel {
 
         let button = match section {
             Section::ActiveCall => channel_link.map(|channel_link| {
-                CopyButton::new(channel_link)
+                let channel_link_copy = channel_link;
+                IconButton::new("channel-link", IconName::Copy)
+                    .icon_size(IconSize::Small)
+                    .size(ButtonSize::None)
                     .visible_on_hover("section-header")
-                    .tooltip_label("Copy Channel Link")
+                    .on_click(move |_, _, cx| {
+                        let item = ClipboardItem::new_string(channel_link_copy.clone());
+                        cx.write_to_clipboard(item)
+                    })
+                    .tooltip(Tooltip::text("Copy channel link"))
                     .into_any_element()
             }),
             Section::Contacts => Some(

crates/context_server/src/transport/stdio_transport.rs

@@ -34,7 +34,7 @@ impl StdioTransport {
         let shell = cx.update(|cx| TerminalSettings::get(None, cx).shell.clone())?;
         let builder = ShellBuilder::new(&shell, cfg!(windows)).non_interactive();
         let mut command =
-            builder.build_smol_command(Some(binary.executable.display().to_string()), &binary.args);
+            builder.build_command(Some(binary.executable.display().to_string()), &binary.args);
 
         command
             .envs(binary.env.unwrap_or_default())

crates/dap/src/transport.rs

@@ -24,7 +24,7 @@ use std::{
     time::Duration,
 };
 use task::TcpArgumentsTemplate;
-use util::{ConnectionResult, ResultExt, process::Child};
+use util::ConnectionResult;
 
 use crate::{
     adapters::{DebugAdapterBinary, TcpArguments},
@@ -528,7 +528,7 @@ impl TcpTransport {
             command.args(&binary.arguments);
             command.envs(&binary.envs);
 
-            let mut p = Child::spawn(command, Stdio::null(), Stdio::piped(), Stdio::piped())
+            let mut p = Child::spawn(command, Stdio::null())
                 .with_context(|| "failed to start debug adapter.")?;
 
             stdout_task = p.stdout.take().map(|stdout| {
@@ -582,7 +582,7 @@ impl Transport for TcpTransport {
 
     fn kill(&mut self) {
         if let Some(process) = &mut *self.process.lock() {
-            process.kill().log_err();
+            process.kill();
         }
     }
 
@@ -647,7 +647,7 @@ impl Transport for TcpTransport {
 impl Drop for TcpTransport {
     fn drop(&mut self) {
         if let Some(mut p) = self.process.lock().take() {
-            p.kill().log_err();
+            p.kill()
         }
     }
 }
@@ -678,7 +678,7 @@ impl StdioTransport {
         command.args(&binary.arguments);
         command.envs(&binary.envs);
 
-        let mut process = Child::spawn(command, Stdio::piped(), Stdio::piped(), Stdio::piped())?;
+        let mut process = Child::spawn(command, Stdio::piped())?;
 
         let _stderr_task = process.stderr.take().map(|stderr| {
             cx.background_spawn(TransportDelegate::handle_adapter_log(
@@ -703,7 +703,7 @@ impl Transport for StdioTransport {
     }
 
     fn kill(&mut self) {
-        self.process.lock().kill().log_err();
+        self.process.lock().kill();
     }
 
     fn connect(
@@ -731,7 +731,7 @@ impl Transport for StdioTransport {
 
 impl Drop for StdioTransport {
     fn drop(&mut self) {
-        self.process.lock().kill().log_err();
+        self.process.lock().kill();
     }
 }
 
@@ -1024,3 +1024,68 @@ impl Transport for FakeTransport {
         self
     }
 }
+
+struct Child {
+    process: smol::process::Child,
+}
+
+impl std::ops::Deref for Child {
+    type Target = smol::process::Child;
+
+    fn deref(&self) -> &Self::Target {
+        &self.process
+    }
+}
+
+impl std::ops::DerefMut for Child {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.process
+    }
+}
+
+impl Child {
+    fn into_inner(self) -> smol::process::Child {
+        self.process
+    }
+
+    #[cfg(not(windows))]
+    fn spawn(mut command: std::process::Command, stdin: Stdio) -> Result<Self> {
+        util::set_pre_exec_to_start_new_session(&mut command);
+        let mut command = smol::process::Command::from(command);
+        let process = command
+            .stdin(stdin)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .with_context(|| format!("failed to spawn command `{command:?}`",))?;
+        Ok(Self { process })
+    }
+
+    #[cfg(windows)]
+    fn spawn(command: std::process::Command, stdin: Stdio) -> Result<Self> {
+        // TODO(windows): create a job object and add the child process handle to it,
+        // see https://learn.microsoft.com/en-us/windows/win32/procthread/job-objects
+        let mut command = smol::process::Command::from(command);
+        let process = command
+            .stdin(stdin)
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .with_context(|| format!("failed to spawn command `{command:?}`",))?;
+        Ok(Self { process })
+    }
+
+    #[cfg(not(windows))]
+    fn kill(&mut self) {
+        let pid = self.process.id();
+        unsafe {
+            libc::killpg(pid as i32, libc::SIGKILL);
+        }
+    }
+
+    #[cfg(windows)]
+    fn kill(&mut self) {
+        // TODO(windows): terminate the job object in kill
+        let _ = self.process.kill();
+    }
+}

crates/debugger_ui/src/debugger_panel.rs

@@ -1579,10 +1579,8 @@ impl Panel for DebugPanel {
         Some(proto::PanelId::DebugPanel)
     }
 
-    fn icon(&self, _window: &Window, cx: &App) -> Option<IconName> {
-        DebuggerSettings::get_global(cx)
-            .button
-            .then_some(IconName::Debug)
+    fn icon(&self, _window: &Window, _cx: &App) -> Option<IconName> {
+        Some(IconName::Debug)
     }
 
     fn icon_tooltip(&self, _window: &Window, cx: &App) -> Option<&'static str> {

crates/edit_prediction/Cargo.toml

@@ -19,7 +19,6 @@ ai_onboarding.workspace = true
 anyhow.workspace = true
 arrayvec.workspace = true
 brotli.workspace = true
-buffer_diff.workspace = true
 client.workspace = true
 cloud_llm_client.workspace = true
 collections.workspace = true
@@ -53,9 +52,7 @@ settings.workspace = true
 strum.workspace = true
 telemetry.workspace = true
 telemetry_events.workspace = true
-text.workspace = true
 thiserror.workspace = true
-time.workspace = true
 ui.workspace = true
 util.workspace = true
 uuid.workspace = true

crates/edit_prediction/src/capture_example.rs

@@ -1,375 +0,0 @@
-use crate::{
-    EditPredictionStore, StoredEvent,
-    cursor_excerpt::editable_and_context_ranges_for_cursor_position, example_spec::ExampleSpec,
-};
-use anyhow::Result;
-use buffer_diff::BufferDiffSnapshot;
-use collections::HashMap;
-use gpui::{App, Entity, Task};
-use language::{Buffer, ToPoint as _};
-use project::Project;
-use std::{collections::hash_map, fmt::Write as _, path::Path, sync::Arc};
-use text::{BufferSnapshot as TextBufferSnapshot, ToOffset as _};
-
-pub fn capture_example(
-    project: Entity<Project>,
-    buffer: Entity<Buffer>,
-    cursor_anchor: language::Anchor,
-    last_event_is_expected_patch: bool,
-    cx: &mut App,
-) -> Option<Task<Result<ExampleSpec>>> {
-    let ep_store = EditPredictionStore::try_global(cx)?;
-    let snapshot = buffer.read(cx).snapshot();
-    let file = snapshot.file()?;
-    let worktree_id = file.worktree_id(cx);
-    let repository = project.read(cx).active_repository(cx)?;
-    let repository_snapshot = repository.read(cx).snapshot();
-    let worktree = project.read(cx).worktree_for_id(worktree_id, cx)?;
-    let cursor_path = worktree.read(cx).root_name().join(file.path());
-    if worktree.read(cx).abs_path() != repository_snapshot.work_directory_abs_path {
-        return None;
-    }
-
-    let repository_url = repository_snapshot
-        .remote_origin_url
-        .clone()
-        .or_else(|| repository_snapshot.remote_upstream_url.clone())?;
-    let revision = repository_snapshot.head_commit.as_ref()?.sha.to_string();
-
-    let mut events = ep_store.update(cx, |store, cx| {
-        store.edit_history_for_project_with_pause_split_last_event(&project, cx)
-    });
-
-    let git_store = project.read(cx).git_store().clone();
-
-    Some(cx.spawn(async move |mut cx| {
-        let snapshots_by_path = collect_snapshots(&project, &git_store, &events, &mut cx).await?;
-        let cursor_excerpt = cx
-            .background_executor()
-            .spawn(async move { compute_cursor_excerpt(&snapshot, cursor_anchor) })
-            .await;
-        let uncommitted_diff = cx
-            .background_executor()
-            .spawn(async move { compute_uncommitted_diff(snapshots_by_path) })
-            .await;
-
-        let mut edit_history = String::new();
-        let mut expected_patch = String::new();
-        if last_event_is_expected_patch {
-            if let Some(stored_event) = events.pop() {
-                zeta_prompt::write_event(&mut expected_patch, &stored_event.event);
-            }
-        }
-
-        for stored_event in &events {
-            zeta_prompt::write_event(&mut edit_history, &stored_event.event);
-            if !edit_history.ends_with('\n') {
-                edit_history.push('\n');
-            }
-        }
-
-        let name = generate_timestamp_name();
-
-        Ok(ExampleSpec {
-            name,
-            repository_url,
-            revision,
-            uncommitted_diff,
-            cursor_path: cursor_path.as_std_path().into(),
-            cursor_position: cursor_excerpt,
-            edit_history,
-            expected_patch,
-        })
-    }))
-}
-
-fn compute_cursor_excerpt(
-    snapshot: &language::BufferSnapshot,
-    cursor_anchor: language::Anchor,
-) -> String {
-    let cursor_point = cursor_anchor.to_point(snapshot);
-    let (_editable_range, context_range) =
-        editable_and_context_ranges_for_cursor_position(cursor_point, snapshot, 100, 50);
-
-    let context_start_offset = context_range.start.to_offset(snapshot);
-    let cursor_offset = cursor_anchor.to_offset(snapshot);
-    let cursor_offset_in_excerpt = cursor_offset.saturating_sub(context_start_offset);
-    let mut excerpt = snapshot.text_for_range(context_range).collect::<String>();
-    if cursor_offset_in_excerpt <= excerpt.len() {
-        excerpt.insert_str(cursor_offset_in_excerpt, zeta_prompt::CURSOR_MARKER);
-    }
-    excerpt
-}
-
-async fn collect_snapshots(
-    project: &Entity<Project>,
-    git_store: &Entity<project::git_store::GitStore>,
-    events: &[StoredEvent],
-    cx: &mut gpui::AsyncApp,
-) -> Result<HashMap<Arc<Path>, (TextBufferSnapshot, BufferDiffSnapshot)>> {
-    let mut snapshots_by_path = HashMap::default();
-    for stored_event in events {
-        let zeta_prompt::Event::BufferChange { path, .. } = stored_event.event.as_ref();
-        if let Some((project_path, full_path)) = project.read_with(cx, |project, cx| {
-            let project_path = project.find_project_path(path, cx)?;
-            let full_path = project
-                .worktree_for_id(project_path.worktree_id, cx)?
-                .read(cx)
-                .root_name()
-                .join(&project_path.path)
-                .as_std_path()
-                .into();
-            Some((project_path, full_path))
-        })? {
-            if let hash_map::Entry::Vacant(entry) = snapshots_by_path.entry(full_path) {
-                let buffer = project
-                    .update(cx, |project, cx| {
-                        project.open_buffer(project_path.clone(), cx)
-                    })?
-                    .await?;
-                let diff = git_store
-                    .update(cx, |git_store, cx| {
-                        git_store.open_uncommitted_diff(buffer.clone(), cx)
-                    })?
-                    .await?;
-                let diff_snapshot = diff.update(cx, |diff, cx| diff.snapshot(cx))?;
-                entry.insert((stored_event.old_snapshot.clone(), diff_snapshot));
-            }
-        }
-    }
-    Ok(snapshots_by_path)
-}
-
-fn compute_uncommitted_diff(
-    snapshots_by_path: HashMap<Arc<Path>, (TextBufferSnapshot, BufferDiffSnapshot)>,
-) -> String {
-    let mut uncommitted_diff = String::new();
-    for (full_path, (before_text, diff_snapshot)) in snapshots_by_path {
-        if let Some(head_text) = &diff_snapshot.base_text_string() {
-            let file_diff = language::unified_diff(head_text, &before_text.text());
-            if !file_diff.is_empty() {
-                let path_str = full_path.to_string_lossy();
-                writeln!(uncommitted_diff, "--- a/{path_str}").ok();
-                writeln!(uncommitted_diff, "+++ b/{path_str}").ok();
-                uncommitted_diff.push_str(&file_diff);
-                if !uncommitted_diff.ends_with('\n') {
-                    uncommitted_diff.push('\n');
-                }
-            }
-        }
-    }
-    uncommitted_diff
-}
-
-fn generate_timestamp_name() -> String {
-    let format = time::format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]");
-    match format {
-        Ok(format) => {
-            let now = time::OffsetDateTime::now_local()
-                .unwrap_or_else(|_| time::OffsetDateTime::now_utc());
-            now.format(&format)
-                .unwrap_or_else(|_| "unknown-time".to_string())
-        }
-        Err(_) => "unknown-time".to_string(),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use client::{Client, UserStore};
-    use clock::FakeSystemClock;
-    use gpui::{AppContext as _, TestAppContext, http_client::FakeHttpClient};
-    use indoc::indoc;
-    use language::{Anchor, Point};
-    use project::{FakeFs, Project};
-    use serde_json::json;
-    use settings::SettingsStore;
-    use std::path::Path;
-
-    #[gpui::test]
-    async fn test_capture_example(cx: &mut TestAppContext) {
-        init_test(cx);
-        let fs = FakeFs::new(cx.executor());
-
-        let committed_contents = indoc! {"
-            fn main() {
-                one();
-                two();
-                three();
-                four();
-                five();
-                six();
-                seven();
-                eight();
-                nine();
-            }
-        "};
-
-        let disk_contents = indoc! {"
-            fn main() {
-                // comment 1
-                one();
-                two();
-                three();
-                four();
-                five();
-                six();
-                seven();
-                eight();
-                // comment 2
-                nine();
-            }
-        "};
-
-        fs.insert_tree(
-            "/project",
-            json!({
-                ".git": {},
-                "src": {
-                    "main.rs": disk_contents,
-                }
-            }),
-        )
-        .await;
-
-        fs.set_head_for_repo(
-            Path::new("/project/.git"),
-            &[("src/main.rs", committed_contents.to_string())],
-            "abc123def456",
-        );
-        fs.set_remote_for_repo(
-            Path::new("/project/.git"),
-            "origin",
-            "https://github.com/test/repo.git",
-        );
-
-        let project = Project::test(fs.clone(), ["/project".as_ref()], cx).await;
-
-        let buffer = project
-            .update(cx, |project, cx| {
-                project.open_local_buffer("/project/src/main.rs", cx)
-            })
-            .await
-            .unwrap();
-
-        let ep_store = cx.read(|cx| EditPredictionStore::try_global(cx).unwrap());
-        ep_store.update(cx, |ep_store, cx| {
-            ep_store.register_buffer(&buffer, &project, cx)
-        });
-        cx.run_until_parked();
-
-        buffer.update(cx, |buffer, cx| {
-            let point = Point::new(6, 0);
-            buffer.edit([(point..point, "    // comment 3\n")], None, cx);
-            let point = Point::new(4, 0);
-            buffer.edit([(point..point, "    // comment 4\n")], None, cx);
-
-            pretty_assertions::assert_eq!(
-                buffer.text(),
-                indoc! {"
-                    fn main() {
-                        // comment 1
-                        one();
-                        two();
-                        // comment 4
-                        three();
-                        four();
-                        // comment 3
-                        five();
-                        six();
-                        seven();
-                        eight();
-                        // comment 2
-                        nine();
-                    }
-                "}
-            );
-        });
-        cx.run_until_parked();
-
-        let mut example = cx
-            .update(|cx| {
-                capture_example(project.clone(), buffer.clone(), Anchor::MIN, false, cx).unwrap()
-            })
-            .await
-            .unwrap();
-        example.name = "test".to_string();
-
-        pretty_assertions::assert_eq!(
-            example,
-            ExampleSpec {
-                name: "test".to_string(),
-                repository_url: "https://github.com/test/repo.git".to_string(),
-                revision: "abc123def456".to_string(),
-                uncommitted_diff: indoc! {"
-                    --- a/project/src/main.rs
-                    +++ b/project/src/main.rs
-                    @@ -1,4 +1,5 @@
-                     fn main() {
-                    +    // comment 1
-                         one();
-                         two();
-                         three();
-                    @@ -7,5 +8,6 @@
-                         six();
-                         seven();
-                         eight();
-                    +    // comment 2
-                         nine();
-                     }
-                "}
-                .to_string(),
-                cursor_path: Path::new("project/src/main.rs").into(),
-                cursor_position: indoc! {"
-                    <|user_cursor|>fn main() {
-                        // comment 1
-                        one();
-                        two();
-                        // comment 4
-                        three();
-                        four();
-                        // comment 3
-                        five();
-                        six();
-                        seven();
-                        eight();
-                        // comment 2
-                        nine();
-                    }
-                "}
-                .to_string(),
-                edit_history: indoc! {"
-                    --- a/project/src/main.rs
-                    +++ b/project/src/main.rs
-                    @@ -2,8 +2,10 @@
-                         // comment 1
-                         one();
-                         two();
-                    +    // comment 4
-                         three();
-                         four();
-                    +    // comment 3
-                         five();
-                         six();
-                         seven();
-                "}
-                .to_string(),
-                expected_patch: "".to_string(),
-            }
-        );
-    }
-
-    fn init_test(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            let settings_store = SettingsStore::test(cx);
-            cx.set_global(settings_store);
-            zlog::init_test();
-            let http_client = FakeHttpClient::with_404_response();
-            let client = Client::new(Arc::new(FakeSystemClock::new()), http_client, cx);
-            language_model::init(client.clone(), cx);
-            let user_store = cx.new(|cx| UserStore::new(client.clone(), cx));
-            EditPredictionStore::global(&client, &user_store, cx);
-        })
-    }
-}

crates/edit_prediction/src/edit_prediction.rs

@@ -35,7 +35,6 @@ use semver::Version;
 use serde::de::DeserializeOwned;
 use settings::{EditPredictionProvider, SettingsStore, update_settings_file};
 use std::collections::{VecDeque, hash_map};
-use text::Edit;
 use workspace::Workspace;
 
 use std::ops::Range;
@@ -58,9 +57,9 @@ pub mod open_ai_response;
 mod prediction;
 pub mod sweep_ai;
 
+#[cfg(any(test, feature = "test-support", feature = "cli-support"))]
 pub mod udiff;
 
-mod capture_example;
 mod zed_edit_prediction_delegate;
 pub mod zeta1;
 pub mod zeta2;
@@ -75,7 +74,6 @@ pub use crate::prediction::EditPrediction;
 pub use crate::prediction::EditPredictionId;
 use crate::prediction::EditPredictionResult;
 pub use crate::sweep_ai::SweepAi;
-pub use capture_example::capture_example;
 pub use language_model::ApiKeyState;
 pub use telemetry_events::EditPredictionRating;
 pub use zed_edit_prediction_delegate::ZedEditPredictionDelegate;
@@ -233,15 +231,8 @@ pub struct EditPredictionFinishedDebugEvent {
 
 pub type RequestDebugInfo = predict_edits_v3::DebugInfo;
 
-/// An event with associated metadata for reconstructing buffer state.
-#[derive(Clone)]
-pub struct StoredEvent {
-    pub event: Arc<zeta_prompt::Event>,
-    pub old_snapshot: TextBufferSnapshot,
-}
-
 struct ProjectState {
-    events: VecDeque<StoredEvent>,
+    events: VecDeque<Arc<zeta_prompt::Event>>,
     last_event: Option<LastEvent>,
     recent_paths: VecDeque<ProjectPath>,
     registered_buffers: HashMap<gpui::EntityId, RegisteredBuffer>,
@@ -257,7 +248,7 @@ struct ProjectState {
 }
 
 impl ProjectState {
-    pub fn events(&self, cx: &App) -> Vec<StoredEvent> {
+    pub fn events(&self, cx: &App) -> Vec<Arc<zeta_prompt::Event>> {
         self.events
             .iter()
             .cloned()
@@ -269,7 +260,7 @@ impl ProjectState {
             .collect()
     }
 
-    pub fn events_split_by_pause(&self, cx: &App) -> Vec<StoredEvent> {
+    pub fn events_split_by_pause(&self, cx: &App) -> Vec<Arc<zeta_prompt::Event>> {
         self.events
             .iter()
             .cloned()
@@ -424,7 +415,7 @@ impl LastEvent {
         &self,
         license_detection_watchers: &HashMap<WorktreeId, Rc<LicenseDetectionWatcher>>,
         cx: &App,
-    ) -> Option<StoredEvent> {
+    ) -> Option<Arc<zeta_prompt::Event>> {
         let path = buffer_path_with_id_fallback(self.new_file.as_ref(), &self.new_snapshot, cx);
         let old_path = buffer_path_with_id_fallback(self.old_file.as_ref(), &self.old_snapshot, cx);
 
@@ -439,22 +430,19 @@ impl LastEvent {
                     })
                 });
 
-        let diff = compute_diff_between_snapshots(&self.old_snapshot, &self.new_snapshot)?;
+        let diff = language::unified_diff(&self.old_snapshot.text(), &self.new_snapshot.text());
 
         if path == old_path && diff.is_empty() {
             None
         } else {
-            Some(StoredEvent {
-                event: Arc::new(zeta_prompt::Event::BufferChange {
-                    old_path,
-                    path,
-                    diff,
-                    in_open_source_repo,
-                    // TODO: Actually detect if this edit was predicted or not
-                    predicted: false,
-                }),
-                old_snapshot: self.old_snapshot.clone(),
-            })
+            Some(Arc::new(zeta_prompt::Event::BufferChange {
+                old_path,
+                path,
+                diff,
+                in_open_source_repo,
+                // TODO: Actually detect if this edit was predicted or not
+                predicted: false,
+            }))
         }
     }
 
@@ -487,52 +475,6 @@ impl LastEvent {
     }
 }
 
-pub(crate) fn compute_diff_between_snapshots(
-    old_snapshot: &TextBufferSnapshot,
-    new_snapshot: &TextBufferSnapshot,
-) -> Option<String> {
-    let edits: Vec<Edit<usize>> = new_snapshot
-        .edits_since::<usize>(&old_snapshot.version)
-        .collect();
-
-    let (first_edit, last_edit) = edits.first().zip(edits.last())?;
-
-    let old_start_point = old_snapshot.offset_to_point(first_edit.old.start);
-    let old_end_point = old_snapshot.offset_to_point(last_edit.old.end);
-    let new_start_point = new_snapshot.offset_to_point(first_edit.new.start);
-    let new_end_point = new_snapshot.offset_to_point(last_edit.new.end);
-
-    const CONTEXT_LINES: u32 = 3;
-
-    let old_context_start_row = old_start_point.row.saturating_sub(CONTEXT_LINES);
-    let new_context_start_row = new_start_point.row.saturating_sub(CONTEXT_LINES);
-    let old_context_end_row =
-        (old_end_point.row + 1 + CONTEXT_LINES).min(old_snapshot.max_point().row);
-    let new_context_end_row =
-        (new_end_point.row + 1 + CONTEXT_LINES).min(new_snapshot.max_point().row);
-
-    let old_start_line_offset = old_snapshot.point_to_offset(Point::new(old_context_start_row, 0));
-    let new_start_line_offset = new_snapshot.point_to_offset(Point::new(new_context_start_row, 0));
-    let old_end_line_offset = old_snapshot
-        .point_to_offset(Point::new(old_context_end_row + 1, 0).min(old_snapshot.max_point()));
-    let new_end_line_offset = new_snapshot
-        .point_to_offset(Point::new(new_context_end_row + 1, 0).min(new_snapshot.max_point()));
-    let old_edit_range = old_start_line_offset..old_end_line_offset;
-    let new_edit_range = new_start_line_offset..new_end_line_offset;
-
-    let old_region_text: String = old_snapshot.text_for_range(old_edit_range).collect();
-    let new_region_text: String = new_snapshot.text_for_range(new_edit_range).collect();
-
-    let diff = language::unified_diff_with_offsets(
-        &old_region_text,
-        &new_region_text,
-        old_context_start_row,
-        new_context_start_row,
-    );
-
-    Some(diff)
-}
-
 fn buffer_path_with_id_fallback(
     file: Option<&Arc<dyn File>>,
     snapshot: &TextBufferSnapshot,
@@ -701,7 +643,7 @@ impl EditPredictionStore {
         &self,
         project: &Entity<Project>,
         cx: &App,
-    ) -> Vec<StoredEvent> {
+    ) -> Vec<Arc<zeta_prompt::Event>> {
         self.projects
             .get(&project.entity_id())
             .map(|project_state| project_state.events(cx))
@@ -712,7 +654,7 @@ impl EditPredictionStore {
         &self,
         project: &Entity<Project>,
         cx: &App,
-    ) -> Vec<StoredEvent> {
+    ) -> Vec<Arc<zeta_prompt::Event>> {
         self.projects
             .get(&project.entity_id())
             .map(|project_state| project_state.events_split_by_pause(cx))
@@ -1594,10 +1536,8 @@ impl EditPredictionStore {
 
         self.get_or_init_project(&project, cx);
         let project_state = self.projects.get(&project.entity_id()).unwrap();
-        let stored_events = project_state.events(cx);
-        let has_events = !stored_events.is_empty();
-        let events: Vec<Arc<zeta_prompt::Event>> =
-            stored_events.into_iter().map(|e| e.event).collect();
+        let events = project_state.events(cx);
+        let has_events = !events.is_empty();
         let debug_tx = project_state.debug_tx.clone();
 
         let snapshot = active_buffer.read(cx).snapshot();

crates/edit_prediction/src/edit_prediction_tests.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::{compute_diff_between_snapshots, udiff::apply_diff_to_string, zeta1::MAX_EVENT_TOKENS};
+use crate::{udiff::apply_diff_to_string, zeta1::MAX_EVENT_TOKENS};
 use client::{UserStore, test::FakeServer};
 use clock::{FakeSystemClock, ReplicaId};
 use cloud_api_types::{CreateLlmTokenResponse, LlmToken};
@@ -360,7 +360,7 @@ async fn test_edit_history_getter_pause_splits_last_event(cx: &mut TestAppContex
         ep_store.edit_history_for_project(&project, cx)
     });
     assert_eq!(events.len(), 1);
-    let zeta_prompt::Event::BufferChange { diff, .. } = events[0].event.as_ref();
+    let zeta_prompt::Event::BufferChange { diff, .. } = events[0].as_ref();
     assert_eq!(
         diff.as_str(),
         indoc! {"
@@ -377,7 +377,7 @@ async fn test_edit_history_getter_pause_splits_last_event(cx: &mut TestAppContex
         ep_store.edit_history_for_project_with_pause_split_last_event(&project, cx)
     });
     assert_eq!(events.len(), 2);
-    let zeta_prompt::Event::BufferChange { diff, .. } = events[0].event.as_ref();
+    let zeta_prompt::Event::BufferChange { diff, .. } = events[0].as_ref();
     assert_eq!(
         diff.as_str(),
         indoc! {"
@@ -389,7 +389,7 @@ async fn test_edit_history_getter_pause_splits_last_event(cx: &mut TestAppContex
         "}
     );
 
-    let zeta_prompt::Event::BufferChange { diff, .. } = events[1].event.as_ref();
+    let zeta_prompt::Event::BufferChange { diff, .. } = events[1].as_ref();
     assert_eq!(
         diff.as_str(),
         indoc! {"
@@ -2082,74 +2082,6 @@ async fn test_unauthenticated_with_custom_url_allows_prediction_impl(cx: &mut Te
     );
 }
 
-#[gpui::test]
-fn test_compute_diff_between_snapshots(cx: &mut TestAppContext) {
-    let buffer = cx.new(|cx| {
-        Buffer::local(
-            indoc! {"
-                zero
-                one
-                two
-                three
-                four
-                five
-                six
-                seven
-                eight
-                nine
-                ten
-                eleven
-                twelve
-                thirteen
-                fourteen
-                fifteen
-                sixteen
-                seventeen
-                eighteen
-                nineteen
-                twenty
-                twenty-one
-                twenty-two
-                twenty-three
-                twenty-four
-            "},
-            cx,
-        )
-    });
-
-    let old_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
-
-    buffer.update(cx, |buffer, cx| {
-        let point = Point::new(12, 0);
-        buffer.edit([(point..point, "SECOND INSERTION\n")], None, cx);
-        let point = Point::new(8, 0);
-        buffer.edit([(point..point, "FIRST INSERTION\n")], None, cx);
-    });
-
-    let new_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
-
-    let diff = compute_diff_between_snapshots(&old_snapshot, &new_snapshot).unwrap();
-
-    assert_eq!(
-        diff,
-        indoc! {"
-            @@ -6,10 +6,12 @@
-             five
-             six
-             seven
-            +FIRST INSERTION
-             eight
-             nine
-             ten
-             eleven
-            +SECOND INSERTION
-             twelve
-             thirteen
-             fourteen
-            "}
-    );
-}
-
 #[ctor::ctor]
 fn init_logger() {
     zlog::init_test();

crates/edit_prediction/src/example_spec.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use std::{fmt::Write as _, mem, path::Path, sync::Arc};
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ExampleSpec {
     #[serde(default)]
     pub name: String,

crates/edit_prediction_cli/src/format_prompt.rs

@@ -45,11 +45,6 @@ pub async fn run_format_prompt(
             let snapshot = state.buffer.read_with(&cx, |buffer, _| buffer.snapshot())?;
             let project = state.project.clone();
             let (_, input) = ep_store.update(&mut cx, |ep_store, cx| {
-                let events = ep_store
-                    .edit_history_for_project(&project, cx)
-                    .into_iter()
-                    .map(|e| e.event)
-                    .collect();
                 anyhow::Ok(zeta2_prompt_input(
                     &snapshot,
                     example
@@ -58,7 +53,7 @@ pub async fn run_format_prompt(
                         .context("context must be set")?
                         .files
                         .clone(),
-                    events,
+                    ep_store.edit_history_for_project(&project, cx),
                     example.spec.cursor_path.clone(),
                     example
                         .buffer

crates/edit_prediction_ui/Cargo.toml

@@ -15,7 +15,8 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 buffer_diff.workspace = true
-collections.workspace = true
+git.workspace = true
+log.workspace = true
 time.workspace = true
 client.workspace = true
 cloud_llm_client.workspace = true
@@ -49,18 +50,11 @@ zed_actions.workspace = true
 zeta_prompt.workspace = true
 
 [dev-dependencies]
-clock.workspace = true
 copilot = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 futures.workspace = true
 indoc.workspace = true
-language_model.workspace = true
 lsp = { workspace = true, features = ["test-support"] }
-pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
-release_channel.workspace = true
-semver.workspace = true
 serde_json.workspace = true
 theme = { workspace = true, features = ["test-support"] }
-workspace = { workspace = true, features = ["test-support"] }
-zlog.workspace = true

crates/edit_prediction_ui/src/edit_prediction_button.rs

@@ -36,8 +36,8 @@ use std::{
 };
 use supermaven::{AccountStatus, Supermaven};
 use ui::{
-    Clickable, ContextMenu, ContextMenuEntry, DocumentationSide, IconButton, IconButtonShape,
-    Indicator, PopoverMenu, PopoverMenuHandle, ProgressBar, Tooltip, prelude::*,
+    Clickable, ContextMenu, ContextMenuEntry, DocumentationEdge, DocumentationSide, IconButton,
+    IconButtonShape, Indicator, PopoverMenu, PopoverMenuHandle, ProgressBar, Tooltip, prelude::*,
 };
 use util::ResultExt as _;
 use workspace::{
@@ -680,7 +680,7 @@ impl EditPredictionButton {
                     menu = menu.item(
                         entry
                             .disabled(true)
-                            .documentation_aside(DocumentationSide::Left, move |_cx| {
+                            .documentation_aside(DocumentationSide::Left, DocumentationEdge::Top, move |_cx| {
                                 Label::new(format!("Edit predictions cannot be toggled for this buffer because they are disabled for {}", language.name()))
                                     .into_any_element()
                             })
@@ -726,7 +726,7 @@ impl EditPredictionButton {
                 .item(
                     ContextMenuEntry::new("Eager")
                         .toggleable(IconPosition::Start, eager_mode)
-                        .documentation_aside(DocumentationSide::Left, move |_| {
+                        .documentation_aside(DocumentationSide::Left, DocumentationEdge::Top, move |_| {
                             Label::new("Display predictions inline when there are no language server completions available.").into_any_element()
                         })
                         .handler({
@@ -739,7 +739,7 @@ impl EditPredictionButton {
                 .item(
                     ContextMenuEntry::new("Subtle")
                         .toggleable(IconPosition::Start, subtle_mode)
-                        .documentation_aside(DocumentationSide::Left, move |_| {
+                        .documentation_aside(DocumentationSide::Left, DocumentationEdge::Top, move |_| {
                             Label::new("Display predictions inline only when holding a modifier key (alt by default).").into_any_element()
                         })
                         .handler({
@@ -778,7 +778,7 @@ impl EditPredictionButton {
                             .toggleable(IconPosition::Start, data_collection.is_enabled())
                             .icon(icon_name)
                             .icon_color(icon_color)
-                            .documentation_aside(DocumentationSide::Left, move |cx| {
+                            .documentation_aside(DocumentationSide::Left, DocumentationEdge::Top, move |cx| {
                                 let (msg, label_color, icon_name, icon_color) = match (is_open_source, is_collecting) {
                                     (true, true) => (
                                         "Project identified as open source, and you're sharing data.",
@@ -862,7 +862,7 @@ impl EditPredictionButton {
             ContextMenuEntry::new("Configure Excluded Files")
                 .icon(IconName::LockOutlined)
                 .icon_color(Color::Muted)
-                .documentation_aside(DocumentationSide::Left, |_| {
+                .documentation_aside(DocumentationSide::Left, DocumentationEdge::Top, |_| {
                     Label::new(indoc!{"
                         Open your settings to add sensitive paths for which Zed will never predict edits."}).into_any_element()
                 })
@@ -915,8 +915,11 @@ impl EditPredictionButton {
                 .when(
                     cx.has_flag::<PredictEditsRatePredictionsFeatureFlag>(),
                     |this| {
-                        this.action("Capture Prediction Example", CaptureExample.boxed_clone())
-                            .action("Rate Predictions", RatePredictions.boxed_clone())
+                        this.action(
+                            "Capture Edit Prediction Example",
+                            CaptureExample.boxed_clone(),
+                        )
+                        .action("Rate Predictions", RatePredictions.boxed_clone())
                     },
                 );
         }

crates/edit_prediction_ui/src/edit_prediction_ui.rs

@@ -2,17 +2,25 @@ mod edit_prediction_button;
 mod edit_prediction_context_view;
 mod rate_prediction_modal;
 
+use std::any::{Any as _, TypeId};
+use std::path::Path;
+use std::sync::Arc;
+
 use command_palette_hooks::CommandPaletteFilter;
-use edit_prediction::{ResetOnboarding, Zeta2FeatureFlag, capture_example};
+use edit_prediction::{
+    EditPredictionStore, ResetOnboarding, Zeta2FeatureFlag, example_spec::ExampleSpec,
+};
 use edit_prediction_context_view::EditPredictionContextView;
 use editor::Editor;
 use feature_flags::FeatureFlagAppExt as _;
-use gpui::actions;
-use language::language_settings::AllLanguageSettings;
+use git::repository::DiffType;
+use gpui::{Window, actions};
+use language::ToPoint as _;
+use log;
 use project::DisableAiSettings;
 use rate_prediction_modal::RatePredictionsModal;
 use settings::{Settings as _, SettingsStore};
-use std::any::{Any as _, TypeId};
+use text::ToOffset as _;
 use ui::{App, prelude::*};
 use workspace::{SplitDirection, Workspace};
 
@@ -48,9 +56,7 @@ pub fn init(cx: &mut App) {
             }
         });
 
-        workspace.register_action(|workspace, _: &CaptureExample, window, cx| {
-            capture_example_as_markdown(workspace, window, cx);
-        });
+        workspace.register_action(capture_edit_prediction_example);
         workspace.register_action_renderer(|div, _, _, cx| {
             let has_flag = cx.has_flag::<Zeta2FeatureFlag>();
             div.when(has_flag, |div| {
@@ -132,48 +138,182 @@ fn feature_gate_predict_edits_actions(cx: &mut App) {
     .detach();
 }
 
-fn capture_example_as_markdown(
+fn capture_edit_prediction_example(
     workspace: &mut Workspace,
+    _: &CaptureExample,
     window: &mut Window,
     cx: &mut Context<Workspace>,
-) -> Option<()> {
+) {
+    let Some(ep_store) = EditPredictionStore::try_global(cx) else {
+        return;
+    };
+
+    let project = workspace.project().clone();
+
+    let (worktree_root, repository) = {
+        let project_ref = project.read(cx);
+        let worktree_root = project_ref
+            .visible_worktrees(cx)
+            .next()
+            .map(|worktree| worktree.read(cx).abs_path());
+        let repository = project_ref.active_repository(cx);
+        (worktree_root, repository)
+    };
+
+    let (Some(worktree_root), Some(repository)) = (worktree_root, repository) else {
+        log::error!("CaptureExampleSpec: missing worktree or active repository");
+        return;
+    };
+
+    let repository_snapshot = repository.read(cx).snapshot();
+    if worktree_root.as_ref() != repository_snapshot.work_directory_abs_path.as_ref() {
+        log::error!(
+            "repository is not at worktree root (repo={:?}, worktree={:?})",
+            repository_snapshot.work_directory_abs_path,
+            worktree_root
+        );
+        return;
+    }
+
+    let Some(repository_url) = repository_snapshot
+        .remote_origin_url
+        .clone()
+        .or_else(|| repository_snapshot.remote_upstream_url.clone())
+    else {
+        log::error!("active repository has no origin/upstream remote url");
+        return;
+    };
+
+    let Some(revision) = repository_snapshot
+        .head_commit
+        .as_ref()
+        .map(|commit| commit.sha.to_string())
+    else {
+        log::error!("active repository has no head commit");
+        return;
+    };
+
+    let mut events = ep_store.update(cx, |store, cx| {
+        store.edit_history_for_project_with_pause_split_last_event(&project, cx)
+    });
+
+    let Some(editor) = workspace.active_item_as::<Editor>(cx) else {
+        log::error!("no active editor");
+        return;
+    };
+
+    let Some(project_path) = editor.read(cx).project_path(cx) else {
+        log::error!("active editor has no project path");
+        return;
+    };
+
+    let Some((buffer, cursor_anchor)) = editor
+        .read(cx)
+        .buffer()
+        .read(cx)
+        .text_anchor_for_position(editor.read(cx).selections.newest_anchor().head(), cx)
+    else {
+        log::error!("failed to resolve cursor buffer/anchor");
+        return;
+    };
+
+    let snapshot = buffer.read(cx).snapshot();
+    let cursor_point = cursor_anchor.to_point(&snapshot);
+    let (_editable_range, context_range) =
+        edit_prediction::cursor_excerpt::editable_and_context_ranges_for_cursor_position(
+            cursor_point,
+            &snapshot,
+            100,
+            50,
+        );
+
+    let cursor_path: Arc<Path> = repository
+        .read(cx)
+        .project_path_to_repo_path(&project_path, cx)
+        .map(|repo_path| Path::new(repo_path.as_unix_str()).into())
+        .unwrap_or_else(|| Path::new(project_path.path.as_unix_str()).into());
+
+    let cursor_position = {
+        let context_start_offset = context_range.start.to_offset(&snapshot);
+        let cursor_offset = cursor_anchor.to_offset(&snapshot);
+        let cursor_offset_in_excerpt = cursor_offset.saturating_sub(context_start_offset);
+        let mut excerpt = snapshot.text_for_range(context_range).collect::<String>();
+        if cursor_offset_in_excerpt <= excerpt.len() {
+            excerpt.insert_str(cursor_offset_in_excerpt, zeta_prompt::CURSOR_MARKER);
+        }
+        excerpt
+    };
+
     let markdown_language = workspace
         .app_state()
         .languages
         .language_for_name("Markdown");
 
-    let fs = workspace.app_state().fs.clone();
-    let project = workspace.project().clone();
-    let editor = workspace.active_item_as::<Editor>(cx)?;
-    let editor = editor.read(cx);
-    let (buffer, cursor_anchor) = editor
-        .buffer()
-        .read(cx)
-        .text_anchor_for_position(editor.selections.newest_anchor().head(), cx)?;
-    let example = capture_example(project.clone(), buffer, cursor_anchor, true, cx)?;
-
-    let examples_dir = AllLanguageSettings::get_global(cx)
-        .edit_predictions
-        .examples_dir
-        .clone();
-
     cx.spawn_in(window, async move |workspace_entity, cx| {
         let markdown_language = markdown_language.await?;
-        let example_spec = example.await?;
-        let buffer = if let Some(dir) = examples_dir {
-            fs.create_dir(&dir).await.ok();
-            let mut path = dir.join(&example_spec.name.replace(' ', "--").replace(':', "-"));
-            path.set_extension("md");
-            project.update(cx, |project, cx| project.open_local_buffer(&path, cx))
-        } else {
-            project.update(cx, |project, cx| project.create_buffer(false, cx))
-        }?
-        .await?;
 
+        let uncommitted_diff_rx = repository.update(cx, |repository, cx| {
+            repository.diff(DiffType::HeadToWorktree, cx)
+        })?;
+
+        let uncommitted_diff = match uncommitted_diff_rx.await {
+            Ok(Ok(diff)) => diff,
+            Ok(Err(error)) => {
+                log::error!("failed to compute uncommitted diff: {error:#}");
+                return Ok(());
+            }
+            Err(error) => {
+                log::error!("uncommitted diff channel dropped: {error:#}");
+                return Ok(());
+            }
+        };
+
+        let mut edit_history = String::new();
+        let mut expected_patch = String::new();
+        if let Some(last_event) = events.pop() {
+            for event in &events {
+                zeta_prompt::write_event(&mut edit_history, event);
+                if !edit_history.ends_with('\n') {
+                    edit_history.push('\n');
+                }
+                edit_history.push('\n');
+            }
+
+            zeta_prompt::write_event(&mut expected_patch, &last_event);
+        }
+
+        let format =
+            time::format_description::parse("[year]-[month]-[day] [hour]:[minute]:[second]");
+        let name = match format {
+            Ok(format) => {
+                let now = time::OffsetDateTime::now_local()
+                    .unwrap_or_else(|_| time::OffsetDateTime::now_utc());
+                now.format(&format)
+                    .unwrap_or_else(|_| "unknown-time".to_string())
+            }
+            Err(_) => "unknown-time".to_string(),
+        };
+
+        let markdown = ExampleSpec {
+            name,
+            repository_url,
+            revision,
+            uncommitted_diff,
+            cursor_path,
+            cursor_position,
+            edit_history,
+            expected_patch,
+        }
+        .to_markdown();
+
+        let buffer = project
+            .update(cx, |project, cx| project.create_buffer(false, cx))?
+            .await?;
         buffer.update(cx, |buffer, cx| {
-            buffer.set_text(example_spec.to_markdown(), cx);
+            buffer.set_text(markdown, cx);
             buffer.set_language(Some(markdown_language), cx);
         })?;
+
         workspace_entity.update_in(cx, |workspace, window, cx| {
             workspace.add_item_to_active_pane(
                 Box::new(
@@ -187,5 +327,4 @@ fn capture_example_as_markdown(
         })
     })
     .detach_and_log_err(cx);
-    None
 }

crates/edit_prediction_ui/src/rate_prediction_modal.rs

@@ -1,4 +1,4 @@
-use buffer_diff::BufferDiff;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use edit_prediction::{EditPrediction, EditPredictionRating, EditPredictionStore};
 use editor::{Editor, ExcerptRange, MultiBuffer};
 use feature_flags::FeatureFlag;
@@ -323,23 +323,22 @@ impl RatePredictionsModal {
                 let start = Point::new(range.start.row.saturating_sub(5), 0);
                 let end = Point::new(range.end.row + 5, 0).min(new_buffer_snapshot.max_point());
 
-                let language = new_buffer_snapshot.language().cloned();
-                let diff = cx.new(|cx| BufferDiff::new(&new_buffer_snapshot.text, cx));
-                diff.update(cx, |diff, cx| {
-                    let update = diff.update_diff(
+                let diff = cx.new::<BufferDiff>(|cx| {
+                    let diff_snapshot = BufferDiffSnapshot::new_with_base_buffer(
                         new_buffer_snapshot.text.clone(),
                         Some(old_buffer_snapshot.text().into()),
-                        true,
-                        language,
+                        old_buffer_snapshot.clone(),
                         cx,
                     );
+                    let diff = BufferDiff::new(&new_buffer_snapshot, cx);
                     cx.spawn(async move |diff, cx| {
-                        let update = update.await;
+                        let diff_snapshot = diff_snapshot.await;
                         diff.update(cx, |diff, cx| {
-                            diff.set_snapshot(update, &new_buffer_snapshot.text, cx);
+                            diff.set_snapshot(diff_snapshot, &new_buffer_snapshot.text, cx);
                         })
                     })
                     .detach();
+                    diff
                 });
 
                 editor.disable_header_for_buffer(new_buffer_id, cx);

crates/editor/src/display_map.rs

@@ -232,6 +232,8 @@ impl DisplayMap {
             .update(cx, |map, cx| map.sync(tab_snapshot, edits, cx));
         let block_snapshot = self.block_map.read(wrap_snapshot, edits).snapshot;
 
+        // todo word diff here?
+
         DisplaySnapshot {
             block_snapshot,
             diagnostics_max_severity: self.diagnostics_max_severity,

crates/editor/src/display_map/wrap_map.rs

@@ -1119,6 +1119,7 @@ impl Iterator for WrapRows<'_> {
             RowInfo {
                 buffer_id: None,
                 buffer_row: None,
+                base_text_row: None,
                 multibuffer_row: None,
                 diff_status,
                 expand_info: None,

crates/editor/src/editor.rs

@@ -1072,7 +1072,6 @@ pub struct Editor {
     minimap_visibility: MinimapVisibility,
     offset_content: bool,
     disable_expand_excerpt_buttons: bool,
-    delegate_expand_excerpts: bool,
     show_line_numbers: Option<bool>,
     use_relative_line_numbers: Option<bool>,
     show_git_diff_gutter: Option<bool>,
@@ -1204,7 +1203,6 @@ pub struct Editor {
     hide_mouse_mode: HideMouseMode,
     pub change_list: ChangeList,
     inline_value_cache: InlineValueCache,
-    number_deleted_lines: bool,
 
     selection_drag_state: SelectionDragState,
     colors: Option<LspColorData>,
@@ -1217,6 +1215,7 @@ pub struct Editor {
     applicable_language_settings: HashMap<Option<LanguageName>, LanguageSettings>,
     accent_data: Option<AccentData>,
     fetched_tree_sitter_chunks: HashMap<ExcerptId, HashSet<Range<BufferRow>>>,
+    use_base_text_line_numbers: bool,
 }
 
 #[derive(Debug, PartialEq)]
@@ -1257,7 +1256,6 @@ pub struct EditorSnapshot {
     show_gutter: bool,
     offset_content: bool,
     show_line_numbers: Option<bool>,
-    number_deleted_lines: bool,
     show_git_diff_gutter: Option<bool>,
     show_code_actions: Option<bool>,
     show_runnables: Option<bool>,
@@ -2239,7 +2237,6 @@ impl Editor {
             show_line_numbers: (!full_mode).then_some(false),
             use_relative_line_numbers: None,
             disable_expand_excerpt_buttons: !full_mode,
-            delegate_expand_excerpts: false,
             show_git_diff_gutter: None,
             show_code_actions: None,
             show_runnables: None,
@@ -2408,7 +2405,7 @@ impl Editor {
             applicable_language_settings: HashMap::default(),
             accent_data: None,
             fetched_tree_sitter_chunks: HashMap::default(),
-            number_deleted_lines: false,
+            use_base_text_line_numbers: false,
         };
 
         if is_minimap {
@@ -2943,7 +2940,6 @@ impl Editor {
             show_gutter: self.show_gutter,
             offset_content: self.offset_content,
             show_line_numbers: self.show_line_numbers,
-            number_deleted_lines: self.number_deleted_lines,
             show_git_diff_gutter: self.show_git_diff_gutter,
             show_code_actions: self.show_code_actions,
             show_runnables: self.show_runnables,
@@ -11500,7 +11496,7 @@ impl Editor {
         let buffer = buffer.read(cx);
         let original_text = diff
             .read(cx)
-            .base_text(cx)
+            .base_text()
             .as_rope()
             .slice(hunk.diff_base_byte_range.start.0..hunk.diff_base_byte_range.end.0);
         let buffer_snapshot = buffer.snapshot();
@@ -16594,6 +16590,7 @@ impl Editor {
         &mut self,
         lines: u32,
         direction: ExpandExcerptDirection,
+
         cx: &mut Context<Self>,
     ) {
         let selections = self.selections.disjoint_anchors_arc();
@@ -16604,24 +16601,14 @@ impl Editor {
             lines
         };
 
-        let snapshot = self.buffer.read(cx).snapshot(cx);
-        let mut excerpt_ids = selections
-            .iter()
-            .flat_map(|selection| snapshot.excerpt_ids_for_range(selection.range()))
-            .collect::<Vec<_>>();
-        excerpt_ids.sort();
-        excerpt_ids.dedup();
-
-        if self.delegate_expand_excerpts {
-            cx.emit(EditorEvent::ExpandExcerptsRequested {
-                excerpt_ids,
-                lines,
-                direction,
-            });
-            return;
-        }
-
         self.buffer.update(cx, |buffer, cx| {
+            let snapshot = buffer.snapshot(cx);
+            let mut excerpt_ids = selections
+                .iter()
+                .flat_map(|selection| snapshot.excerpt_ids_for_range(selection.range()))
+                .collect::<Vec<_>>();
+            excerpt_ids.sort();
+            excerpt_ids.dedup();
             buffer.expand_excerpts(excerpt_ids, lines, direction, cx)
         })
     }
@@ -16633,18 +16620,8 @@ impl Editor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) {
-        let lines_to_expand = EditorSettings::get_global(cx).expand_excerpt_lines;
-
-        if self.delegate_expand_excerpts {
-            cx.emit(EditorEvent::ExpandExcerptsRequested {
-                excerpt_ids: vec![excerpt],
-                lines: lines_to_expand,
-                direction,
-            });
-            return;
-        }
-
         let current_scroll_position = self.scroll_position(cx);
+        let lines_to_expand = EditorSettings::get_global(cx).expand_excerpt_lines;
         let mut scroll = None;
 
         if direction == ExpandExcerptDirection::Down {
@@ -19721,6 +19698,10 @@ impl Editor {
         self.display_map.read(cx).fold_placeholder.clone()
     }
 
+    pub fn set_use_base_text_line_numbers(&mut self, show: bool, _cx: &mut Context<Self>) {
+        self.use_base_text_line_numbers = show;
+    }
+
     pub fn set_expand_all_diff_hunks(&mut self, cx: &mut App) {
         self.buffer.update(cx, |buffer, cx| {
             buffer.set_all_diff_hunks_expanded(cx);
@@ -19962,7 +19943,7 @@ impl Editor {
                         buffer_word_diffs: Vec::default(),
                         diff_base_byte_range: hunk.diff_base_byte_range.start.0
                             ..hunk.diff_base_byte_range.end.0,
-                        secondary_status: hunk.status.secondary,
+                        secondary_status: hunk.secondary_status,
                         range: Point::zero()..Point::zero(), // unused
                     })
                     .collect::<Vec<_>>(),
@@ -20591,10 +20572,6 @@ impl Editor {
         cx.notify();
     }
 
-    pub fn set_delegate_expand_excerpts(&mut self, delegate: bool) {
-        self.delegate_expand_excerpts = delegate;
-    }
-
     pub fn set_show_git_diff_gutter(&mut self, show_git_diff_gutter: bool, cx: &mut Context<Self>) {
         self.show_git_diff_gutter = Some(show_git_diff_gutter);
         cx.notify();
@@ -21006,12 +20983,8 @@ impl Editor {
 
             Some((
                 multi_buffer.buffer(buffer.remote_id()).unwrap(),
-                buffer_diff_snapshot.row_to_base_text_row(start_row_in_buffer, Bias::Left, buffer)
-                    ..buffer_diff_snapshot.row_to_base_text_row(
-                        end_row_in_buffer,
-                        Bias::Left,
-                        buffer,
-                    ),
+                buffer_diff_snapshot.row_to_base_text_row(start_row_in_buffer, buffer)
+                    ..buffer_diff_snapshot.row_to_base_text_row(end_row_in_buffer, buffer),
             ))
         });
 
@@ -25325,34 +25298,36 @@ impl EditorSnapshot {
     /// Returns the line delta from `base` to `line` in the multibuffer, ignoring wrapped lines.
     ///
     /// This is positive if `base` is before `line`.
-    fn relative_line_delta(
-        &self,
-        base: DisplayRow,
-        line: DisplayRow,
-        consider_wrapped_lines: bool,
-    ) -> i64 {
+    fn relative_line_delta(&self, base: DisplayRow, line: DisplayRow) -> i64 {
         let point = DisplayPoint::new(line, 0).to_point(self);
-        self.relative_line_delta_to_point(base, point, consider_wrapped_lines)
+        self.relative_line_delta_to_point(base, point)
     }
 
-    /// Returns the line delta from `base` to `point` in the multibuffer.
+    /// Returns the line delta from `base` to `point` in the multibuffer, ignoring wrapped lines.
     ///
     /// This is positive if `base` is before `point`.
-    pub fn relative_line_delta_to_point(
-        &self,
-        base: DisplayRow,
-        point: Point,
-        consider_wrapped_lines: bool,
-    ) -> i64 {
+    pub fn relative_line_delta_to_point(&self, base: DisplayRow, point: Point) -> i64 {
         let base_point = DisplayPoint::new(base, 0).to_point(self);
-        if consider_wrapped_lines {
-            let wrap_snapshot = self.wrap_snapshot();
-            let base_wrap_row = wrap_snapshot.make_wrap_point(base_point, Bias::Left).row();
-            let wrap_row = wrap_snapshot.make_wrap_point(point, Bias::Left).row();
-            wrap_row.0 as i64 - base_wrap_row.0 as i64
-        } else {
-            point.row as i64 - base_point.row as i64
-        }
+        point.row as i64 - base_point.row as i64
+    }
+
+    /// Returns the line delta from `base` to `line` in the multibuffer, counting wrapped lines.
+    ///
+    /// This is positive if `base` is before `line`.
+    fn relative_wrapped_line_delta(&self, base: DisplayRow, line: DisplayRow) -> i64 {
+        let point = DisplayPoint::new(line, 0).to_point(self);
+        self.relative_wrapped_line_delta_to_point(base, point)
+    }
+
+    /// Returns the line delta from `base` to `point` in the multibuffer, counting wrapped lines.
+    ///
+    /// This is positive if `base` is before `point`.
+    pub fn relative_wrapped_line_delta_to_point(&self, base: DisplayRow, point: Point) -> i64 {
+        let base_point = DisplayPoint::new(base, 0).to_point(self);
+        let wrap_snapshot = self.wrap_snapshot();
+        let base_wrap_row = wrap_snapshot.make_wrap_point(base_point, Bias::Left).row();
+        let wrap_row = wrap_snapshot.make_wrap_point(point, Bias::Left).row();
+        wrap_row.0 as i64 - base_wrap_row.0 as i64
     }
 
     /// Returns the unsigned relative line number to display for each row in `rows`.
@@ -25364,21 +25339,23 @@ impl EditorSnapshot {
         relative_to: DisplayRow,
         count_wrapped_lines: bool,
     ) -> HashMap<DisplayRow, u32> {
-        let initial_offset = self.relative_line_delta(relative_to, rows.start, count_wrapped_lines);
-
-        self.row_infos(rows.start)
+        let initial_offset = if count_wrapped_lines {
+            self.relative_wrapped_line_delta(relative_to, rows.start)
+        } else {
+            self.relative_line_delta(relative_to, rows.start)
+        };
+        let display_row_infos = self
+            .row_infos(rows.start)
             .take(rows.len())
             .enumerate()
-            .map(|(i, row_info)| (DisplayRow(rows.start.0 + i as u32), row_info))
+            .map(|(i, row_info)| (DisplayRow(rows.start.0 + i as u32), row_info));
+        display_row_infos
             .filter(|(_row, row_info)| {
                 row_info.buffer_row.is_some()
                     || (count_wrapped_lines && row_info.wrapped_buffer_row.is_some())
             })
             .enumerate()
-            .flat_map(|(i, (row, _row_info))| {
-                (row != relative_to)
-                    .then_some((row, (initial_offset + i as i64).unsigned_abs() as u32))
-            })
+            .map(|(i, (row, _row_info))| (row, (initial_offset + i as i64).unsigned_abs() as u32))
             .collect()
     }
 }
@@ -25436,11 +25413,6 @@ pub enum EditorEvent {
     ExcerptsExpanded {
         ids: Vec<ExcerptId>,
     },
-    ExpandExcerptsRequested {
-        excerpt_ids: Vec<ExcerptId>,
-        lines: u32,
-        direction: ExpandExcerptDirection,
-    },
     BufferEdited,
     Edited {
         transaction_id: clock::Lamport,

crates/editor/src/editor_tests.rs

@@ -36,7 +36,8 @@ use languages::markdown_lang;
 use languages::rust_lang;
 use lsp::CompletionParams;
 use multi_buffer::{
-    ExcerptRange, IndentGuide, MultiBuffer, MultiBufferOffset, MultiBufferOffsetUtf16, PathKey,
+    ExcerptRange, IndentGuide, MultiBuffer, MultiBufferFilterMode, MultiBufferOffset,
+    MultiBufferOffsetUtf16, PathKey,
 };
 use parking_lot::Mutex;
 use pretty_assertions::{assert_eq, assert_ne};
@@ -13220,28 +13221,30 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut TestAppContext) {
     // Handle formatting requests to the language server.
     cx.lsp
         .set_request_handler::<lsp::request::Formatting, _, _>({
+            let buffer_changes = buffer_changes.clone();
             move |_, _| {
+                let buffer_changes = buffer_changes.clone();
                 // Insert blank lines between each line of the buffer.
                 async move {
-                    // TODO: this assertion is not reliably true. Currently nothing guarantees that we deliver
-                    // DidChangedTextDocument to the LSP before sending the formatting request.
-                    // assert_eq!(
-                    //     &buffer_changes.lock()[1..],
-                    //     &[
-                    //         (
-                    //             lsp::Range::new(lsp::Position::new(0, 3), lsp::Position::new(0, 4)),
-                    //             "".into()
-                    //         ),
-                    //         (
-                    //             lsp::Range::new(lsp::Position::new(2, 5), lsp::Position::new(2, 6)),
-                    //             "".into()
-                    //         ),
-                    //         (
-                    //             lsp::Range::new(lsp::Position::new(3, 4), lsp::Position::new(3, 4)),
-                    //             "\n".into()
-                    //         ),
-                    //     ]
-                    // );
+                    // When formatting is requested, trailing whitespace has already been stripped,
+                    // and the trailing newline has already been added.
+                    assert_eq!(
+                        &buffer_changes.lock()[1..],
+                        &[
+                            (
+                                lsp::Range::new(lsp::Position::new(0, 3), lsp::Position::new(0, 4)),
+                                "".into()
+                            ),
+                            (
+                                lsp::Range::new(lsp::Position::new(2, 5), lsp::Position::new(2, 6)),
+                                "".into()
+                            ),
+                            (
+                                lsp::Range::new(lsp::Position::new(3, 4), lsp::Position::new(3, 4)),
+                                "\n".into()
+                            ),
+                        ]
+                    );
 
                     Ok(Some(vec![
                         lsp::TextEdit {
@@ -13273,6 +13276,7 @@ async fn test_strip_whitespace_and_format_via_lsp(cx: &mut TestAppContext) {
         ]
         .join("\n"),
     );
+    cx.run_until_parked();
 
     // Submit a format request.
     let format = cx
@@ -18342,7 +18346,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut TestAppCon
     );
 
     update_test_project_settings(cx, |project_settings| {
-        project_settings.lsp.0.insert(
+        project_settings.lsp.insert(
             "Some other server name".into(),
             LspSettings {
                 binary: None,
@@ -18363,7 +18367,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut TestAppCon
     );
 
     update_test_project_settings(cx, |project_settings| {
-        project_settings.lsp.0.insert(
+        project_settings.lsp.insert(
             language_server_name.into(),
             LspSettings {
                 binary: None,
@@ -18384,7 +18388,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut TestAppCon
     );
 
     update_test_project_settings(cx, |project_settings| {
-        project_settings.lsp.0.insert(
+        project_settings.lsp.insert(
             language_server_name.into(),
             LspSettings {
                 binary: None,
@@ -18405,7 +18409,7 @@ async fn test_language_server_restart_due_to_settings_change(cx: &mut TestAppCon
     );
 
     update_test_project_settings(cx, |project_settings| {
-        project_settings.lsp.0.insert(
+        project_settings.lsp.insert(
             language_server_name.into(),
             LspSettings {
                 binary: None,
@@ -19880,9 +19884,7 @@ async fn test_multibuffer_reverts(cx: &mut TestAppContext) {
             (buffer_2.clone(), base_text_2),
             (buffer_3.clone(), base_text_3),
         ] {
-            let diff = cx.new(|cx| {
-                BufferDiff::new_with_base_text(diff_base, &buffer.read(cx).text_snapshot(), cx)
-            });
+            let diff = cx.new(|cx| BufferDiff::new_with_base_text(diff_base, &buffer, cx));
             editor
                 .buffer
                 .update(cx, |buffer, cx| buffer.add_diff(diff, cx));
@@ -20507,9 +20509,7 @@ async fn test_toggle_diff_expand_in_multi_buffer(cx: &mut TestAppContext) {
                 (buffer_2.clone(), file_2_old),
                 (buffer_3.clone(), file_3_old),
             ] {
-                let diff = cx.new(|cx| {
-                    BufferDiff::new_with_base_text(diff_base, &buffer.read(cx).text_snapshot(), cx)
-                });
+                let diff = cx.new(|cx| BufferDiff::new_with_base_text(diff_base, &buffer, cx));
                 editor
                     .buffer
                     .update(cx, |buffer, cx| buffer.add_diff(diff, cx));
@@ -20615,9 +20615,7 @@ async fn test_expand_diff_hunk_at_excerpt_boundary(cx: &mut TestAppContext) {
         cx.add_window(|window, cx| Editor::new(EditorMode::full(), multi_buffer, None, window, cx));
     editor
         .update(cx, |editor, _window, cx| {
-            let diff = cx.new(|cx| {
-                BufferDiff::new_with_base_text(base, &buffer.read(cx).text_snapshot(), cx)
-            });
+            let diff = cx.new(|cx| BufferDiff::new_with_base_text(base, &buffer, cx));
             editor
                 .buffer
                 .update(cx, |buffer, cx| buffer.add_diff(diff, cx))
@@ -22051,9 +22049,7 @@ async fn test_indent_guide_with_expanded_diff_hunks(cx: &mut TestAppContext) {
 
         editor.buffer().update(cx, |multibuffer, cx| {
             let buffer = multibuffer.as_singleton().unwrap();
-            let diff = cx.new(|cx| {
-                BufferDiff::new_with_base_text(base_text, &buffer.read(cx).text_snapshot(), cx)
-            });
+            let diff = cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer, cx));
 
             multibuffer.set_all_diff_hunks_expanded(cx);
             multibuffer.add_diff(diff, cx);
@@ -28729,7 +28725,7 @@ fn test_relative_line_numbers(cx: &mut TestAppContext) {
             assert_eq!(
                 relative_number,
                 snapshot
-                    .relative_line_delta(display_row, base_display_row, false)
+                    .relative_line_delta(display_row, base_display_row)
                     .unsigned_abs() as u32,
             );
         }
@@ -28739,7 +28735,6 @@ fn test_relative_line_numbers(cx: &mut TestAppContext) {
             .into_iter()
             .enumerate()
             .map(|(i, row)| (DisplayRow(row), i.abs_diff(wrapped_base_row) as u32))
-            .filter(|(row, _)| *row != base_display_row)
             .collect_vec();
         let actual_relative_numbers = snapshot
             .calculate_relative_line_numbers(
@@ -28756,7 +28751,7 @@ fn test_relative_line_numbers(cx: &mut TestAppContext) {
             assert_eq!(
                 relative_number,
                 snapshot
-                    .relative_line_delta(display_row, base_display_row, true)
+                    .relative_wrapped_line_delta(display_row, base_display_row)
                     .unsigned_abs() as u32,
             );
         }
@@ -29227,6 +29222,208 @@ async fn test_multibuffer_selections_with_folding(cx: &mut TestAppContext) {
         "});
 }
 
+#[gpui::test]
+async fn test_filtered_editor_pair(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
+    let mut leader_cx = EditorTestContext::new(cx).await;
+
+    let diff_base = indoc!(
+        r#"
+        one
+        two
+        three
+        four
+        five
+        six
+        "#
+    );
+
+    let initial_state = indoc!(
+        r#"
+        ˇone
+        two
+        THREE
+        four
+        five
+        six
+        "#
+    );
+
+    leader_cx.set_state(initial_state);
+
+    leader_cx.set_head_text(&diff_base);
+    leader_cx.run_until_parked();
+
+    let follower = leader_cx.update_multibuffer(|leader, cx| {
+        leader.set_filter_mode(Some(MultiBufferFilterMode::KeepInsertions));
+        leader.set_all_diff_hunks_expanded(cx);
+        leader.get_or_create_follower(cx)
+    });
+    follower.update(cx, |follower, cx| {
+        follower.set_filter_mode(Some(MultiBufferFilterMode::KeepDeletions));
+        follower.set_all_diff_hunks_expanded(cx);
+    });
+
+    let follower_editor =
+        leader_cx.new_window_entity(|window, cx| build_editor(follower, window, cx));
+    // leader_cx.window.focus(&follower_editor.focus_handle(cx));
+
+    let mut follower_cx = EditorTestContext::for_editor_in(follower_editor, &mut leader_cx).await;
+    cx.run_until_parked();
+
+    leader_cx.assert_editor_state(initial_state);
+    follower_cx.assert_editor_state(indoc! {
+        r#"
+        ˇone
+        two
+        three
+        four
+        five
+        six
+        "#
+    });
+
+    follower_cx.editor(|editor, _window, cx| {
+        assert!(editor.read_only(cx));
+    });
+
+    leader_cx.update_editor(|editor, _window, cx| {
+        editor.edit([(Point::new(4, 0)..Point::new(5, 0), "FIVE\n")], cx);
+    });
+    cx.run_until_parked();
+
+    leader_cx.assert_editor_state(indoc! {
+        r#"
+        ˇone
+        two
+        THREE
+        four
+        FIVE
+        six
+        "#
+    });
+
+    follower_cx.assert_editor_state(indoc! {
+        r#"
+        ˇone
+        two
+        three
+        four
+        five
+        six
+        "#
+    });
+
+    leader_cx.update_editor(|editor, _window, cx| {
+        editor.edit([(Point::new(6, 0)..Point::new(6, 0), "SEVEN")], cx);
+    });
+    cx.run_until_parked();
+
+    leader_cx.assert_editor_state(indoc! {
+        r#"
+        ˇone
+        two
+        THREE
+        four
+        FIVE
+        six
+        SEVEN"#
+    });
+
+    follower_cx.assert_editor_state(indoc! {
+        r#"
+        ˇone
+        two
+        three
+        four
+        five
+        six
+        "#
+    });
+
+    leader_cx.update_editor(|editor, window, cx| {
+        editor.move_down(&MoveDown, window, cx);
+        editor.refresh_selected_text_highlights(true, window, cx);
+    });
+    leader_cx.run_until_parked();
+}
+
+#[gpui::test]
+async fn test_filtered_editor_pair_complex(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
+    let base_text = "base\n";
+    let buffer_text = "buffer\n";
+
+    let buffer1 = cx.new(|cx| Buffer::local(buffer_text, cx));
+    let diff1 = cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer1, cx));
+
+    let extra_buffer_1 = cx.new(|cx| Buffer::local("dummy text 1\n", cx));
+    let extra_diff_1 = cx.new(|cx| BufferDiff::new_with_base_text("", &extra_buffer_1, cx));
+    let extra_buffer_2 = cx.new(|cx| Buffer::local("dummy text 2\n", cx));
+    let extra_diff_2 = cx.new(|cx| BufferDiff::new_with_base_text("", &extra_buffer_2, cx));
+
+    let leader = cx.new(|cx| {
+        let mut leader = MultiBuffer::new(Capability::ReadWrite);
+        leader.set_all_diff_hunks_expanded(cx);
+        leader.set_filter_mode(Some(MultiBufferFilterMode::KeepInsertions));
+        leader
+    });
+    let follower = leader.update(cx, |leader, cx| leader.get_or_create_follower(cx));
+    follower.update(cx, |follower, _| {
+        follower.set_filter_mode(Some(MultiBufferFilterMode::KeepDeletions));
+    });
+
+    leader.update(cx, |leader, cx| {
+        leader.insert_excerpts_after(
+            ExcerptId::min(),
+            extra_buffer_2.clone(),
+            vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
+            cx,
+        );
+        leader.add_diff(extra_diff_2.clone(), cx);
+
+        leader.insert_excerpts_after(
+            ExcerptId::min(),
+            extra_buffer_1.clone(),
+            vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
+            cx,
+        );
+        leader.add_diff(extra_diff_1.clone(), cx);
+
+        leader.insert_excerpts_after(
+            ExcerptId::min(),
+            buffer1.clone(),
+            vec![ExcerptRange::new(text::Anchor::MIN..text::Anchor::MAX)],
+            cx,
+        );
+        leader.add_diff(diff1.clone(), cx);
+    });
+
+    cx.run_until_parked();
+    let mut cx = cx.add_empty_window();
+
+    let leader_editor = cx
+        .new_window_entity(|window, cx| Editor::for_multibuffer(leader.clone(), None, window, cx));
+    let follower_editor = cx.new_window_entity(|window, cx| {
+        Editor::for_multibuffer(follower.clone(), None, window, cx)
+    });
+
+    let mut leader_cx = EditorTestContext::for_editor_in(leader_editor.clone(), &mut cx).await;
+    leader_cx.assert_editor_state(indoc! {"
+       ˇbuffer
+
+       dummy text 1
+
+       dummy text 2
+    "});
+    let mut follower_cx = EditorTestContext::for_editor_in(follower_editor.clone(), &mut cx).await;
+    follower_cx.assert_editor_state(indoc! {"
+        ˇbase
+
+
+    "});
+}
+
 #[gpui::test]
 async fn test_multibuffer_scroll_cursor_top_margin(cx: &mut TestAppContext) {
     init_test(cx, |_| {});
@@ -29405,17 +29602,6 @@ async fn test_newline_task_list_continuation(cx: &mut TestAppContext) {
         - [ ] ˇ
     "});
 
-    // Case 2.1: Works with uppercase checked marker too
-    cx.set_state(indoc! {"
-        - [X] completed taskˇ
-    "});
-    cx.update_editor(|e, window, cx| e.newline(&Newline, window, cx));
-    cx.wait_for_autoindent_applied().await;
-    cx.assert_editor_state(indoc! {"
-        - [X] completed task
-        - [ ] ˇ
-    "});
-
     // Case 3: Cursor position doesn't matter - content after marker is what counts
     cx.set_state(indoc! {"
         - [ ] taˇsk
@@ -29983,14 +30169,11 @@ async fn test_local_worktree_trust(cx: &mut TestAppContext) {
             .map(|wt| wt.read(cx).id())
             .expect("should have a worktree")
     });
-    let worktree_store = project.read_with(cx, |project, _| project.worktree_store());
 
     let trusted_worktrees =
         cx.update(|cx| TrustedWorktrees::try_get_global(cx).expect("trust global should exist"));
 
-    let can_trust = trusted_worktrees.update(cx, |store, cx| {
-        store.can_trust(&worktree_store, worktree_id, cx)
-    });
+    let can_trust = trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx));
     assert!(!can_trust, "worktree should be restricted initially");
 
     let buffer_before_approval = project
@@ -30036,8 +30219,8 @@ async fn test_local_worktree_trust(cx: &mut TestAppContext) {
 
     trusted_worktrees.update(cx, |store, cx| {
         store.trust(
-            &worktree_store,
             std::collections::HashSet::from_iter([PathTrust::Worktree(worktree_id)]),
+            None,
             cx,
         );
     });
@@ -30064,9 +30247,8 @@ async fn test_local_worktree_trust(cx: &mut TestAppContext) {
         "inlay hints should be queried after trust approval"
     );
 
-    let can_trust_after = trusted_worktrees.update(cx, |store, cx| {
-        store.can_trust(&worktree_store, worktree_id, cx)
-    });
+    let can_trust_after =
+        trusted_worktrees.update(cx, |store, cx| store.can_trust(worktree_id, cx));
     assert!(can_trust_after, "worktree should be trusted after trust()");
 }
 

crates/editor/src/element.rs

@@ -3264,15 +3264,17 @@ impl EditorElement {
             line_number.clear();
             let non_relative_number = if relative.wrapped() {
                 row_info.buffer_row.or(row_info.wrapped_buffer_row)? + 1
+            } else if self.editor.read(cx).use_base_text_line_numbers {
+                row_info.base_text_row?.0 + 1
             } else {
                 row_info.buffer_row? + 1
             };
             let relative_number = relative_rows.get(&display_row);
             if !(relative_line_numbers_enabled && relative_number.is_some())
-                && !snapshot.number_deleted_lines
                 && row_info
                     .diff_status
                     .is_some_and(|status| status.is_deleted())
+                && !self.editor.read(cx).use_base_text_line_numbers
             {
                 return None;
             }
@@ -4609,15 +4611,15 @@ impl EditorElement {
             );
 
             let line_number = show_line_numbers.then(|| {
-                let relative_number = relative_to
-                    .filter(|_| relative_line_numbers != RelativeLineNumbers::Disabled)
-                    .map(|base| {
-                        snapshot.relative_line_delta_to_point(
-                            base,
-                            start_point,
-                            relative_line_numbers == RelativeLineNumbers::Wrapped,
-                        )
-                    });
+                let relative_number = relative_to.and_then(|base| match relative_line_numbers {
+                    RelativeLineNumbers::Disabled => None,
+                    RelativeLineNumbers::Enabled => {
+                        Some(snapshot.relative_line_delta_to_point(base, start_point))
+                    }
+                    RelativeLineNumbers::Wrapped => {
+                        Some(snapshot.relative_wrapped_line_delta_to_point(base, start_point))
+                    }
+                });
                 let number = relative_number
                     .filter(|&delta| delta != 0)
                     .map(|delta| delta.unsigned_abs() as u32)
@@ -9053,8 +9055,14 @@ impl Element for EditorElement {
                     let em_advance = window.text_system().em_advance(font_id, font_size).unwrap();
                     let glyph_grid_cell = size(em_advance, line_height);
 
-                    let gutter_dimensions =
-                        snapshot.gutter_dimensions(font_id, font_size, style, window, cx);
+                    let gutter_dimensions = snapshot
+                        .gutter_dimensions(
+                            font_id,
+                            font_size,
+                            style,
+                            window,
+                            cx,
+                        );
                     let text_width = bounds.size.width - gutter_dimensions.width;
 
                     let settings = EditorSettings::get_global(cx);
@@ -9268,10 +9276,10 @@ impl Element for EditorElement {
                         };
 
                         let background_color = match diff_status.kind {
-                            DiffHunkStatusKind::Added => cx.theme().colors().version_control_added,
-                            DiffHunkStatusKind::Deleted => {
-                                cx.theme().colors().version_control_deleted
-                            }
+                            DiffHunkStatusKind::Added =>
+                                cx.theme().colors().version_control_added,
+                            DiffHunkStatusKind::Deleted =>
+                                cx.theme().colors().version_control_deleted,
                             DiffHunkStatusKind::Modified => {
                                 debug_panic!("modified diff status for row info");
                                 continue;
@@ -9415,26 +9423,25 @@ impl Element for EditorElement {
                         );
 
                     // relative rows are based on newest selection, even outside the visible area
-                    let relative_row_base = self.editor.update(cx, |editor, cx| {
-                        (editor.selections.count() != 0).then(|| {
+                    let relative_row_base =  self.editor.update(cx, |editor, cx| {
+                        if editor.selections.count()==0 {
+                            return None;
+                        }
                             let newest = editor
                                 .selections
                                 .newest::<Point>(&editor.display_snapshot(cx));
-
-                            SelectionLayout::new(
+                            Some(SelectionLayout::new(
                                 newest,
                                 editor.selections.line_mode(),
                                 editor.cursor_offset_on_selection,
                                 editor.cursor_shape,
-                                &snapshot,
+                                &snapshot.display_snapshot,
                                 true,
                                 true,
                                 None,
                             )
-                            .head
-                            .row()
-                        })
-                    });
+                            .head.row())
+                        });
 
                     let mut breakpoint_rows = self.editor.update(cx, |editor, cx| {
                         editor.active_breakpoints(start_row..end_row, window, cx)
@@ -9594,10 +9601,9 @@ impl Element for EditorElement {
                                 cx,
                             );
                         } else {
-                            debug_panic!(concat!(
-                                "skipping recursive prepaint at max depth. ",
-                                "renderer widths may be stale."
-                            ));
+                            debug_panic!(
+                                "skipping recursive prepaint at max depth. renderer widths may be stale."
+                            );
                         }
                     }
 
@@ -9709,10 +9715,9 @@ impl Element for EditorElement {
                                 cx,
                             );
                         } else {
-                            debug_panic!(concat!(
-                                "skipping recursive prepaint at max depth. ",
-                                "block layout may be stale."
-                            ));
+                            debug_panic!(
+                                "skipping recursive prepaint at max depth. block layout may be stale."
+                            );
                         }
                     }
 
@@ -11718,7 +11723,6 @@ mod tests {
         assert_eq!(relative_rows[&DisplayRow(1)], 2);
         assert_eq!(relative_rows[&DisplayRow(2)], 1);
         // current line has no relative number
-        assert!(!relative_rows.contains_key(&DisplayRow(3)));
         assert_eq!(relative_rows[&DisplayRow(4)], 1);
         assert_eq!(relative_rows[&DisplayRow(5)], 2);
 
@@ -11865,7 +11869,6 @@ mod tests {
         assert_eq!(relative_rows[&DisplayRow(1)], 2);
         assert_eq!(relative_rows[&DisplayRow(2)], 1);
         // current line has no relative number
-        assert!(!relative_rows.contains_key(&DisplayRow(3)));
         assert_eq!(relative_rows[&DisplayRow(4)], 1);
         assert_eq!(relative_rows[&DisplayRow(5)], 2);
 
@@ -11921,7 +11924,6 @@ mod tests {
         assert_eq!(relative_rows[&DisplayRow(1)], 2);
         assert_eq!(relative_rows[&DisplayRow(2)], 1);
         // current line, even if deleted, has no relative number
-        assert!(!relative_rows.contains_key(&DisplayRow(3)));
         assert_eq!(relative_rows[&DisplayRow(4)], 1);
         assert_eq!(relative_rows[&DisplayRow(5)], 2);
     }

crates/editor/src/hover_popover.rs

@@ -24,7 +24,7 @@ use std::{borrow::Cow, cell::RefCell};
 use std::{ops::Range, sync::Arc, time::Duration};
 use std::{path::PathBuf, rc::Rc};
 use theme::ThemeSettings;
-use ui::{CopyButton, Scrollbars, WithScrollbar, prelude::*, theme_is_transparent};
+use ui::{Scrollbars, WithScrollbar, prelude::*, theme_is_transparent};
 use url::Url;
 use util::TryFutureExt;
 use workspace::{OpenOptions, OpenVisible, Workspace};
@@ -994,13 +994,11 @@ impl DiagnosticPopover {
                     .border_color(self.border_color)
                     .rounded_lg()
                     .child(
-                        h_flex()
+                        div()
                             .id("diagnostic-content-container")
-                            .gap_1()
-                            .items_start()
+                            .overflow_y_scroll()
                             .max_w(max_size.width)
                             .max_h(max_size.height)
-                            .overflow_y_scroll()
                             .track_scroll(&self.scroll_handle)
                             .child(
                                 MarkdownElement::new(
@@ -1023,11 +1021,7 @@ impl DiagnosticPopover {
                                         }
                                     },
                                 ),
-                            )
-                            .child({
-                                let message = self.local_diagnostic.diagnostic.message.clone();
-                                CopyButton::new(message).tooltip_label("Copy Diagnostic")
-                            }),
+                            ),
                     )
                     .custom_scrollbars(
                         Scrollbars::for_settings::<EditorSettings>()

crates/editor/src/mouse_context_menu.rs

@@ -164,6 +164,11 @@ pub fn deploy_context_menu(
         window.focus(&editor.focus_handle(cx), cx);
     }
 
+    // Don't show context menu for inline editors
+    if !editor.mode().is_full() {
+        return;
+    }
+
     let display_map = editor.display_snapshot(cx);
     let source_anchor = display_map.display_point_to_anchor(point, text::Bias::Right);
     let context_menu = if let Some(custom) = editor.custom_context_menu.take() {
@@ -174,11 +179,6 @@ pub fn deploy_context_menu(
         };
         menu
     } else {
-        // Don't show context menu for inline editors (only applies to default menu)
-        if !editor.mode().is_full() {
-            return;
-        }
-
         // Don't show the context menu if there isn't a project associated with this editor
         let Some(project) = editor.project.clone() else {
             return;

crates/editor/src/split.rs

@@ -1,16 +1,9 @@
-use std::ops::Range;
-
-use buffer_diff::BufferDiff;
-use collections::HashMap;
 use feature_flags::{FeatureFlag, FeatureFlagAppExt as _};
 use gpui::{
     Action, AppContext as _, Entity, EventEmitter, Focusable, NoAction, Subscription, WeakEntity,
 };
-use language::{Buffer, Capability};
-use multi_buffer::{Anchor, ExcerptId, ExcerptRange, ExpandExcerptDirection, MultiBuffer, PathKey};
+use multi_buffer::{MultiBuffer, MultiBufferFilterMode};
 use project::Project;
-use rope::Point;
-use text::{Bias, OffsetRangeExt as _};
 use ui::{
     App, Context, InteractiveElement as _, IntoElement as _, ParentElement as _, Render,
     Styled as _, Window, div,
@@ -40,7 +33,6 @@ struct SplitDiff;
 struct UnsplitDiff;
 
 pub struct SplittableEditor {
-    primary_multibuffer: Entity<MultiBuffer>,
     primary_editor: Entity<Editor>,
     secondary: Option<SecondaryEditor>,
     panes: PaneGroup,
@@ -49,12 +41,9 @@ pub struct SplittableEditor {
 }
 
 struct SecondaryEditor {
-    multibuffer: Entity<MultiBuffer>,
     editor: Entity<Editor>,
     pane: Entity<Pane>,
     has_latest_selection: bool,
-    primary_to_secondary: HashMap<ExcerptId, ExcerptId>,
-    secondary_to_primary: HashMap<ExcerptId, ExcerptId>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -74,22 +63,14 @@ impl SplittableEditor {
     }
 
     pub fn new_unsplit(
-        primary_multibuffer: Entity<MultiBuffer>,
+        buffer: Entity<MultiBuffer>,
         project: Entity<Project>,
         workspace: Entity<Workspace>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let primary_editor = cx.new(|cx| {
-            let mut editor = Editor::for_multibuffer(
-                primary_multibuffer.clone(),
-                Some(project.clone()),
-                window,
-                cx,
-            );
-            editor.set_expand_all_diff_hunks(cx);
-            editor
-        });
+        let primary_editor =
+            cx.new(|cx| Editor::for_multibuffer(buffer, Some(project.clone()), window, cx));
         let pane = cx.new(|cx| {
             let mut pane = Pane::new(
                 workspace.downgrade(),
@@ -107,25 +88,17 @@ impl SplittableEditor {
         });
         let panes = PaneGroup::new(pane);
         // TODO(split-diff) we might want to tag editor events with whether they came from primary/secondary
-        let subscriptions = vec![cx.subscribe(
-            &primary_editor,
-            |this, _, event: &EditorEvent, cx| match event {
-                EditorEvent::ExpandExcerptsRequested {
-                    excerpt_ids,
-                    lines,
-                    direction,
-                } => {
-                    this.expand_excerpts(excerpt_ids.iter().copied(), *lines, *direction, cx);
-                }
-                EditorEvent::SelectionsChanged { .. } => {
-                    if let Some(secondary) = &mut this.secondary {
+        let subscriptions =
+            vec![
+                cx.subscribe(&primary_editor, |this, _, event: &EditorEvent, cx| {
+                    if let EditorEvent::SelectionsChanged { .. } = event
+                        && let Some(secondary) = &mut this.secondary
+                    {
                         secondary.has_latest_selection = false;
                     }
-                    cx.emit(event.clone());
-                }
-                _ => cx.emit(event.clone()),
-            },
-        )];
+                    cx.emit(event.clone())
+                }),
+            ];
 
         window.defer(cx, {
             let workspace = workspace.downgrade();
@@ -142,7 +115,6 @@ impl SplittableEditor {
         });
         Self {
             primary_editor,
-            primary_multibuffer,
             secondary: None,
             panes,
             workspace: workspace.downgrade(),
@@ -161,22 +133,24 @@ impl SplittableEditor {
             return;
         };
         let project = workspace.read(cx).project().clone();
-
-        let secondary_multibuffer = cx.new(|cx| {
-            let mut multibuffer = MultiBuffer::new(Capability::ReadOnly);
-            multibuffer.set_all_diff_hunks_expanded(cx);
-            multibuffer
+        let follower = self.primary_editor.update(cx, |primary, cx| {
+            primary.buffer().update(cx, |buffer, cx| {
+                let follower = buffer.get_or_create_follower(cx);
+                buffer.set_filter_mode(Some(MultiBufferFilterMode::KeepInsertions));
+                follower
+            })
         });
-        let secondary_editor = cx.new(|cx| {
-            let mut editor = Editor::for_multibuffer(
-                secondary_multibuffer.clone(),
-                Some(project.clone()),
-                window,
-                cx,
-            );
-            editor.number_deleted_lines = true;
-            editor.set_delegate_expand_excerpts(true);
-            editor
+        follower.update(cx, |follower, _| {
+            follower.set_filter_mode(Some(MultiBufferFilterMode::KeepDeletions));
+        });
+        let secondary_editor = workspace.update(cx, |workspace, cx| {
+            cx.new(|cx| {
+                let mut editor = Editor::for_multibuffer(follower, Some(project), window, cx);
+                // TODO(split-diff) this should be at the multibuffer level
+                editor.set_use_base_text_line_numbers(true, cx);
+                editor.added_to_workspace(workspace, window, cx);
+                editor
+            })
         });
         let secondary_pane = cx.new(|cx| {
             let mut pane = Pane::new(
@@ -201,59 +175,23 @@ impl SplittableEditor {
             pane
         });
 
-        let subscriptions = vec![cx.subscribe(
-            &secondary_editor,
-            |this, _, event: &EditorEvent, cx| match event {
-                EditorEvent::ExpandExcerptsRequested {
-                    excerpt_ids,
-                    lines,
-                    direction,
-                } => {
-                    if let Some(secondary) = &this.secondary {
-                        let primary_ids: Vec<_> = excerpt_ids
-                            .iter()
-                            .filter_map(|id| secondary.secondary_to_primary.get(id).copied())
-                            .collect();
-                        this.expand_excerpts(primary_ids.into_iter(), *lines, *direction, cx);
-                    }
-                }
-                EditorEvent::SelectionsChanged { .. } => {
-                    if let Some(secondary) = &mut this.secondary {
+        let subscriptions =
+            vec![
+                cx.subscribe(&secondary_editor, |this, _, event: &EditorEvent, cx| {
+                    if let EditorEvent::SelectionsChanged { .. } = event
+                        && let Some(secondary) = &mut this.secondary
+                    {
                         secondary.has_latest_selection = true;
                     }
-                    cx.emit(event.clone());
-                }
-                _ => cx.emit(event.clone()),
-            },
-        )];
-        let mut secondary = SecondaryEditor {
+                    cx.emit(event.clone())
+                }),
+            ];
+        self.secondary = Some(SecondaryEditor {
             editor: secondary_editor,
-            multibuffer: secondary_multibuffer,
             pane: secondary_pane.clone(),
             has_latest_selection: false,
-            primary_to_secondary: HashMap::default(),
-            secondary_to_primary: HashMap::default(),
             _subscriptions: subscriptions,
-        };
-        self.primary_editor.update(cx, |editor, cx| {
-            editor.set_delegate_expand_excerpts(true);
-            editor.buffer().update(cx, |primary_multibuffer, cx| {
-                primary_multibuffer.set_show_deleted_hunks(false, cx);
-                let paths = primary_multibuffer.paths().cloned().collect::<Vec<_>>();
-                for path in paths {
-                    let Some(excerpt_id) = primary_multibuffer.excerpts_for_path(&path).next()
-                    else {
-                        continue;
-                    };
-                    let snapshot = primary_multibuffer.snapshot(cx);
-                    let buffer = snapshot.buffer_for_excerpt(excerpt_id).unwrap();
-                    let diff = primary_multibuffer.diff_for(buffer.remote_id()).unwrap();
-                    secondary.sync_path_excerpts(path.clone(), primary_multibuffer, diff, cx);
-                }
-            })
         });
-        self.secondary = Some(secondary);
-
         let primary_pane = self.panes.first_pane();
         self.panes
             .split(&primary_pane, &secondary_pane, SplitDirection::Left, cx)
@@ -267,9 +205,8 @@ impl SplittableEditor {
         };
         self.panes.remove(&secondary.pane, cx).unwrap();
         self.primary_editor.update(cx, |primary, cx| {
-            primary.set_delegate_expand_excerpts(false);
-            primary.buffer().update(cx, |buffer, cx| {
-                buffer.set_show_deleted_hunks(true, cx);
+            primary.buffer().update(cx, |buffer, _| {
+                buffer.set_filter_mode(None);
             });
         });
         cx.notify();
@@ -291,299 +228,6 @@ impl SplittableEditor {
             });
         }
     }
-
-    pub fn set_excerpts_for_path(
-        &mut self,
-        path: PathKey,
-        buffer: Entity<Buffer>,
-        ranges: impl IntoIterator<Item = Range<Point>> + Clone,
-        context_line_count: u32,
-        diff: Entity<BufferDiff>,
-        cx: &mut Context<Self>,
-    ) -> (Vec<Range<Anchor>>, bool) {
-        self.primary_multibuffer
-            .update(cx, |primary_multibuffer, cx| {
-                let (anchors, added_a_new_excerpt) = primary_multibuffer.set_excerpts_for_path(
-                    path.clone(),
-                    buffer,
-                    ranges,
-                    context_line_count,
-                    cx,
-                );
-                primary_multibuffer.add_diff(diff.clone(), cx);
-                if let Some(secondary) = &mut self.secondary {
-                    secondary.sync_path_excerpts(path, primary_multibuffer, diff, cx);
-                }
-                (anchors, added_a_new_excerpt)
-            })
-    }
-
-    fn expand_excerpts(
-        &mut self,
-        excerpt_ids: impl Iterator<Item = ExcerptId> + Clone,
-        lines: u32,
-        direction: ExpandExcerptDirection,
-        cx: &mut Context<Self>,
-    ) {
-        let mut corresponding_paths = HashMap::default();
-        self.primary_multibuffer.update(cx, |multibuffer, cx| {
-            let snapshot = multibuffer.snapshot(cx);
-            if self.secondary.is_some() {
-                corresponding_paths = excerpt_ids
-                    .clone()
-                    .map(|excerpt_id| {
-                        let path = multibuffer.path_for_excerpt(excerpt_id).unwrap();
-                        let buffer = snapshot.buffer_for_excerpt(excerpt_id).unwrap();
-                        let diff = multibuffer.diff_for(buffer.remote_id()).unwrap();
-                        (path, diff)
-                    })
-                    .collect::<HashMap<_, _>>();
-            }
-            multibuffer.expand_excerpts(excerpt_ids.clone(), lines, direction, cx);
-        });
-
-        if let Some(secondary) = &mut self.secondary {
-            self.primary_multibuffer.update(cx, |multibuffer, cx| {
-                for (path, diff) in corresponding_paths {
-                    secondary.sync_path_excerpts(path, multibuffer, diff, cx);
-                }
-            })
-        }
-    }
-
-    pub fn remove_excerpts_for_path(&mut self, path: PathKey, cx: &mut Context<Self>) {
-        self.primary_multibuffer.update(cx, |buffer, cx| {
-            buffer.remove_excerpts_for_path(path.clone(), cx)
-        });
-        if let Some(secondary) = &mut self.secondary {
-            secondary.remove_mappings_for_path(&path, cx);
-            secondary
-                .multibuffer
-                .update(cx, |buffer, cx| buffer.remove_excerpts_for_path(path, cx))
-        }
-    }
-}
-
-#[cfg(test)]
-impl SplittableEditor {
-    fn check_invariants(&self, quiesced: bool, cx: &App) {
-        use buffer_diff::DiffHunkStatusKind;
-        use collections::HashSet;
-        use multi_buffer::MultiBufferOffset;
-        use multi_buffer::MultiBufferRow;
-        use multi_buffer::MultiBufferSnapshot;
-
-        fn format_diff(snapshot: &MultiBufferSnapshot) -> String {
-            let text = snapshot.text();
-            let row_infos = snapshot.row_infos(MultiBufferRow(0)).collect::<Vec<_>>();
-            let boundary_rows = snapshot
-                .excerpt_boundaries_in_range(MultiBufferOffset(0)..)
-                .map(|b| b.row)
-                .collect::<HashSet<_>>();
-
-            text.split('\n')
-                .enumerate()
-                .zip(row_infos)
-                .map(|((ix, line), info)| {
-                    let marker = match info.diff_status.map(|status| status.kind) {
-                        Some(DiffHunkStatusKind::Added) => "+ ",
-                        Some(DiffHunkStatusKind::Deleted) => "- ",
-                        Some(DiffHunkStatusKind::Modified) => unreachable!(),
-                        None => {
-                            if !line.is_empty() {
-                                "  "
-                            } else {
-                                ""
-                            }
-                        }
-                    };
-                    let boundary_row = if boundary_rows.contains(&MultiBufferRow(ix as u32)) {
-                        "  ----------\n"
-                    } else {
-                        ""
-                    };
-                    let expand = info
-                        .expand_info
-                        .map(|expand_info| match expand_info.direction {
-                            ExpandExcerptDirection::Up => " [↑]",
-                            ExpandExcerptDirection::Down => " [↓]",
-                            ExpandExcerptDirection::UpAndDown => " [↕]",
-                        })
-                        .unwrap_or_default();
-
-                    format!("{boundary_row}{marker}{line}{expand}")
-                })
-                .collect::<Vec<_>>()
-                .join("\n")
-        }
-
-        let Some(secondary) = &self.secondary else {
-            return;
-        };
-
-        log::info!(
-            "primary:\n\n{}",
-            format_diff(&self.primary_multibuffer.read(cx).snapshot(cx))
-        );
-
-        log::info!(
-            "secondary:\n\n{}",
-            format_diff(&secondary.multibuffer.read(cx).snapshot(cx))
-        );
-
-        let primary_excerpts = self.primary_multibuffer.read(cx).excerpt_ids();
-        let secondary_excerpts = secondary.multibuffer.read(cx).excerpt_ids();
-        assert_eq!(primary_excerpts.len(), secondary_excerpts.len());
-
-        assert_eq!(
-            secondary.primary_to_secondary.len(),
-            primary_excerpts.len(),
-            "primary_to_secondary mapping count should match excerpt count"
-        );
-        assert_eq!(
-            secondary.secondary_to_primary.len(),
-            secondary_excerpts.len(),
-            "secondary_to_primary mapping count should match excerpt count"
-        );
-
-        for primary_id in &primary_excerpts {
-            assert!(
-                secondary.primary_to_secondary.contains_key(primary_id),
-                "primary excerpt {:?} should have a mapping to secondary",
-                primary_id
-            );
-        }
-        for secondary_id in &secondary_excerpts {
-            assert!(
-                secondary.secondary_to_primary.contains_key(secondary_id),
-                "secondary excerpt {:?} should have a mapping to primary",
-                secondary_id
-            );
-        }
-
-        for (primary_id, secondary_id) in &secondary.primary_to_secondary {
-            assert_eq!(
-                secondary.secondary_to_primary.get(secondary_id),
-                Some(primary_id),
-                "mappings should be bijective"
-            );
-        }
-
-        if quiesced {
-            let primary_snapshot = self.primary_multibuffer.read(cx).snapshot(cx);
-            let secondary_snapshot = secondary.multibuffer.read(cx).snapshot(cx);
-            let primary_diff_hunks = primary_snapshot
-                .diff_hunks()
-                .map(|hunk| hunk.diff_base_byte_range)
-                .collect::<Vec<_>>();
-            let secondary_diff_hunks = secondary_snapshot
-                .diff_hunks()
-                .map(|hunk| hunk.diff_base_byte_range)
-                .collect::<Vec<_>>();
-            pretty_assertions::assert_eq!(primary_diff_hunks, secondary_diff_hunks);
-
-            // Filtering out empty lines is a bit of a hack, to work around a case where
-            // the base text has a trailing newline but the current text doesn't, or vice versa.
-            // In this case, we get the additional newline on one side, but that line is not
-            // marked as added/deleted by rowinfos.
-            let primary_unmodified_rows = primary_snapshot
-                .text()
-                .split("\n")
-                .zip(primary_snapshot.row_infos(MultiBufferRow(0)))
-                .filter(|(line, row_info)| !line.is_empty() && row_info.diff_status.is_none())
-                .map(|(line, _)| line.to_owned())
-                .collect::<Vec<_>>();
-            let secondary_unmodified_rows = secondary_snapshot
-                .text()
-                .split("\n")
-                .zip(secondary_snapshot.row_infos(MultiBufferRow(0)))
-                .filter(|(line, row_info)| !line.is_empty() && row_info.diff_status.is_none())
-                .map(|(line, _)| line.to_owned())
-                .collect::<Vec<_>>();
-            pretty_assertions::assert_eq!(primary_unmodified_rows, secondary_unmodified_rows);
-        }
-    }
-
-    fn randomly_edit_excerpts(
-        &mut self,
-        rng: &mut impl rand::Rng,
-        mutation_count: usize,
-        cx: &mut Context<Self>,
-    ) {
-        use collections::HashSet;
-        use rand::prelude::*;
-        use std::env;
-        use util::RandomCharIter;
-
-        let max_excerpts = env::var("MAX_EXCERPTS")
-            .map(|i| i.parse().expect("invalid `MAX_EXCERPTS` variable"))
-            .unwrap_or(5);
-
-        for _ in 0..mutation_count {
-            let paths = self
-                .primary_multibuffer
-                .read(cx)
-                .paths()
-                .cloned()
-                .collect::<Vec<_>>();
-            let excerpt_ids = self.primary_multibuffer.read(cx).excerpt_ids();
-
-            if rng.random_bool(0.1) && !excerpt_ids.is_empty() {
-                let mut excerpts = HashSet::default();
-                for _ in 0..rng.random_range(0..excerpt_ids.len()) {
-                    excerpts.extend(excerpt_ids.choose(rng).copied());
-                }
-
-                let line_count = rng.random_range(0..5);
-
-                log::info!("Expanding excerpts {excerpts:?} by {line_count} lines");
-
-                self.expand_excerpts(
-                    excerpts.iter().cloned(),
-                    line_count,
-                    ExpandExcerptDirection::UpAndDown,
-                    cx,
-                );
-                continue;
-            }
-
-            if excerpt_ids.is_empty() || (rng.random() && excerpt_ids.len() < max_excerpts) {
-                let len = rng.random_range(100..500);
-                let text = RandomCharIter::new(&mut *rng).take(len).collect::<String>();
-                let buffer = cx.new(|cx| Buffer::local(text, cx));
-                log::info!(
-                    "Creating new buffer {} with text: {:?}",
-                    buffer.read(cx).remote_id(),
-                    buffer.read(cx).text()
-                );
-                let buffer_snapshot = buffer.read(cx).snapshot();
-                let diff = cx.new(|cx| BufferDiff::new_unchanged(&buffer_snapshot, cx));
-                // Create some initial diff hunks.
-                buffer.update(cx, |buffer, cx| {
-                    buffer.randomly_edit(rng, 1, cx);
-                });
-                let buffer_snapshot = buffer.read(cx).text_snapshot();
-                let ranges = diff.update(cx, |diff, cx| {
-                    diff.recalculate_diff_sync(&buffer_snapshot, cx);
-                    diff.snapshot(cx)
-                        .hunks(&buffer_snapshot)
-                        .map(|hunk| hunk.buffer_range.to_point(&buffer_snapshot))
-                        .collect::<Vec<_>>()
-                });
-                let path = PathKey::for_buffer(&buffer, cx);
-                self.set_excerpts_for_path(path, buffer, ranges, 2, diff, cx);
-            } else {
-                let remove_count = rng.random_range(1..=paths.len());
-                let paths_to_remove = paths
-                    .choose_multiple(rng, remove_count)
-                    .cloned()
-                    .collect::<Vec<_>>();
-                for path in paths_to_remove {
-                    self.remove_excerpts_for_path(path.clone(), cx);
-                }
-            }
-        }
-    }
 }
 
 impl EventEmitter<EditorEvent> for SplittableEditor {}
@@ -621,223 +265,3 @@ impl Render for SplittableEditor {
             .child(inner)
     }
 }
-
-impl SecondaryEditor {
-    fn sync_path_excerpts(
-        &mut self,
-        path_key: PathKey,
-        primary_multibuffer: &mut MultiBuffer,
-        diff: Entity<BufferDiff>,
-        cx: &mut App,
-    ) {
-        let Some(excerpt_id) = primary_multibuffer.excerpts_for_path(&path_key).next() else {
-            self.remove_mappings_for_path(&path_key, cx);
-            self.multibuffer.update(cx, |multibuffer, cx| {
-                multibuffer.remove_excerpts_for_path(path_key, cx);
-            });
-            return;
-        };
-
-        let primary_excerpt_ids: Vec<ExcerptId> =
-            primary_multibuffer.excerpts_for_path(&path_key).collect();
-
-        let primary_multibuffer_snapshot = primary_multibuffer.snapshot(cx);
-        let main_buffer = primary_multibuffer_snapshot
-            .buffer_for_excerpt(excerpt_id)
-            .unwrap();
-        let base_text_buffer = diff.read(cx).base_text_buffer();
-        let diff_snapshot = diff.read(cx).snapshot(cx);
-        let base_text_buffer_snapshot = base_text_buffer.read(cx).snapshot();
-        let new = primary_multibuffer
-            .excerpts_for_buffer(main_buffer.remote_id(), cx)
-            .into_iter()
-            .map(|(_, excerpt_range)| {
-                let point_range_to_base_text_point_range = |range: Range<Point>| {
-                    let start_row = diff_snapshot.row_to_base_text_row(
-                        range.start.row,
-                        Bias::Left,
-                        main_buffer,
-                    );
-                    let end_row =
-                        diff_snapshot.row_to_base_text_row(range.end.row, Bias::Right, main_buffer);
-                    let end_column = diff_snapshot.base_text().line_len(end_row);
-                    Point::new(start_row, 0)..Point::new(end_row, end_column)
-                };
-                let primary = excerpt_range.primary.to_point(main_buffer);
-                let context = excerpt_range.context.to_point(main_buffer);
-                ExcerptRange {
-                    primary: point_range_to_base_text_point_range(primary),
-                    context: point_range_to_base_text_point_range(context),
-                }
-            })
-            .collect();
-
-        let main_buffer = primary_multibuffer.buffer(main_buffer.remote_id()).unwrap();
-
-        self.remove_mappings_for_path(&path_key, cx);
-
-        self.editor.update(cx, |editor, cx| {
-            editor.buffer().update(cx, |buffer, cx| {
-                buffer.update_path_excerpts(
-                    path_key.clone(),
-                    base_text_buffer,
-                    &base_text_buffer_snapshot,
-                    new,
-                    cx,
-                );
-                buffer.add_inverted_diff(diff, main_buffer, cx);
-            })
-        });
-
-        let secondary_excerpt_ids: Vec<ExcerptId> = self
-            .multibuffer
-            .read(cx)
-            .excerpts_for_path(&path_key)
-            .collect();
-
-        for (primary_id, secondary_id) in primary_excerpt_ids.into_iter().zip(secondary_excerpt_ids)
-        {
-            self.primary_to_secondary.insert(primary_id, secondary_id);
-            self.secondary_to_primary.insert(secondary_id, primary_id);
-        }
-    }
-
-    fn remove_mappings_for_path(&mut self, path_key: &PathKey, cx: &App) {
-        let secondary_excerpt_ids: Vec<ExcerptId> = self
-            .multibuffer
-            .read(cx)
-            .excerpts_for_path(path_key)
-            .collect();
-
-        for secondary_id in secondary_excerpt_ids {
-            if let Some(primary_id) = self.secondary_to_primary.remove(&secondary_id) {
-                self.primary_to_secondary.remove(&primary_id);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use fs::FakeFs;
-    use gpui::AppContext as _;
-    use language::Capability;
-    use multi_buffer::{MultiBuffer, PathKey};
-    use project::Project;
-    use rand::rngs::StdRng;
-    use settings::SettingsStore;
-    use ui::VisualContext as _;
-    use workspace::Workspace;
-
-    use crate::SplittableEditor;
-
-    fn init_test(cx: &mut gpui::TestAppContext) {
-        cx.update(|cx| {
-            let store = SettingsStore::test(cx);
-            cx.set_global(store);
-            theme::init(theme::LoadThemes::JustBase, cx);
-            crate::init(cx);
-        });
-    }
-
-    #[gpui::test(iterations = 100)]
-    async fn test_random_split_editor(mut rng: StdRng, cx: &mut gpui::TestAppContext) {
-        use rand::prelude::*;
-
-        init_test(cx);
-        let project = Project::test(FakeFs::new(cx.executor()), [], cx).await;
-        let (workspace, cx) =
-            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        let primary_multibuffer = cx.new(|cx| {
-            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
-            multibuffer.set_all_diff_hunks_expanded(cx);
-            multibuffer
-        });
-        let editor = cx.new_window_entity(|window, cx| {
-            let mut editor =
-                SplittableEditor::new_unsplit(primary_multibuffer, project, workspace, window, cx);
-            editor.split(&Default::default(), window, cx);
-            editor
-        });
-
-        let operations = std::env::var("OPERATIONS")
-            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
-            .unwrap_or(20);
-        let rng = &mut rng;
-        for _ in 0..operations {
-            editor.update(cx, |editor, cx| {
-                let buffers = editor
-                    .primary_editor
-                    .read(cx)
-                    .buffer()
-                    .read(cx)
-                    .all_buffers();
-
-                if buffers.is_empty() {
-                    editor.randomly_edit_excerpts(rng, 2, cx);
-                    editor.check_invariants(true, cx);
-                    return;
-                }
-
-                let quiesced = match rng.random_range(0..100) {
-                    0..=69 if !buffers.is_empty() => {
-                        let buffer = buffers.iter().choose(rng).unwrap();
-                        buffer.update(cx, |buffer, cx| {
-                            if rng.random() {
-                                log::info!("randomly editing single buffer");
-                                buffer.randomly_edit(rng, 5, cx);
-                            } else {
-                                log::info!("randomly undoing/redoing in single buffer");
-                                buffer.randomly_undo_redo(rng, cx);
-                            }
-                        });
-                        false
-                    }
-                    70..=79 => {
-                        log::info!("mutating excerpts");
-                        editor.randomly_edit_excerpts(rng, 2, cx);
-                        false
-                    }
-                    80..=89 if !buffers.is_empty() => {
-                        log::info!("recalculating buffer diff");
-                        let buffer = buffers.iter().choose(rng).unwrap();
-                        let diff = editor
-                            .primary_multibuffer
-                            .read(cx)
-                            .diff_for(buffer.read(cx).remote_id())
-                            .unwrap();
-                        let buffer_snapshot = buffer.read(cx).text_snapshot();
-                        diff.update(cx, |diff, cx| {
-                            diff.recalculate_diff_sync(&buffer_snapshot, cx);
-                        });
-                        false
-                    }
-                    _ => {
-                        log::info!("quiescing");
-                        for buffer in buffers {
-                            let buffer_snapshot = buffer.read(cx).text_snapshot();
-                            let diff = editor
-                                .primary_multibuffer
-                                .read(cx)
-                                .diff_for(buffer.read(cx).remote_id())
-                                .unwrap();
-                            diff.update(cx, |diff, cx| {
-                                diff.recalculate_diff_sync(&buffer_snapshot, cx);
-                            });
-                            let diff_snapshot = diff.read(cx).snapshot(cx);
-                            let ranges = diff_snapshot
-                                .hunks(&buffer_snapshot)
-                                .map(|hunk| hunk.range)
-                                .collect::<Vec<_>>();
-                            let path = PathKey::for_buffer(&buffer, cx);
-                            editor.set_excerpts_for_path(path, buffer, ranges, 2, diff, cx);
-                        }
-                        true
-                    }
-                };
-
-                editor.check_invariants(quiesced, cx);
-            });
-        }
-    }
-}

crates/eval/src/example.rs

@@ -365,12 +365,11 @@ impl ExampleContext {
                         let snapshot = buffer.read(cx).snapshot();
 
                         let file = snapshot.file().unwrap();
-                        let base_text = diff.read(cx).base_text(cx).text();
+                        let diff = diff.read(cx);
+                        let base_text = diff.base_text().text();
 
                         let hunks = diff
-                            .read(cx)
-                            .snapshot(cx)
-                            .hunks(&snapshot)
+                            .hunks(&snapshot, cx)
                             .map(|hunk| FileEditHunk {
                                 base_text: base_text[hunk.diff_base_byte_range.clone()].to_string(),
                                 text: snapshot

crates/feature_flags/src/flags.rs

@@ -23,9 +23,3 @@ pub struct AgentV2FeatureFlag;
 impl FeatureFlag for AgentV2FeatureFlag {
     const NAME: &'static str = "agent-v2";
 }
-
-pub struct AcpBetaFeatureFlag;
-
-impl FeatureFlag for AcpBetaFeatureFlag {
-    const NAME: &'static str = "acp-beta";
-}

crates/file_finder/src/file_finder.rs

@@ -1760,19 +1760,16 @@ impl PickerDelegate for FileFinderDelegate {
                                                 menu.context(focus_handle)
                                                     .action(
                                                         "Split Left",
-                                                        pane::SplitLeft::default().boxed_clone(),
+                                                        pane::SplitLeft.boxed_clone(),
                                                     )
                                                     .action(
                                                         "Split Right",
-                                                        pane::SplitRight::default().boxed_clone(),
-                                                    )
-                                                    .action(
-                                                        "Split Up",
-                                                        pane::SplitUp::default().boxed_clone(),
+                                                        pane::SplitRight.boxed_clone(),
                                                     )
+                                                    .action("Split Up", pane::SplitUp.boxed_clone())
                                                     .action(
                                                         "Split Down",
-                                                        pane::SplitDown::default().boxed_clone(),
+                                                        pane::SplitDown.boxed_clone(),
                                                     )
                                             }
                                         }))

crates/fs/src/fake_git_repo.rs

@@ -156,16 +156,8 @@ impl GitRepository for FakeGitRepository {
         })
     }
 
-    fn remote_url(&self, name: &str) -> BoxFuture<'_, Option<String>> {
-        let name = name.to_string();
-        let fut = self.with_state_async(false, move |state| {
-            state
-                .remotes
-                .get(&name)
-                .context("remote not found")
-                .cloned()
-        });
-        async move { fut.await.ok() }.boxed()
+    fn remote_url(&self, _name: &str) -> BoxFuture<'_, Option<String>> {
+        async move { None }.boxed()
     }
 
     fn diff_tree(&self, _request: DiffTreeType) -> BoxFuture<'_, Result<TreeDiff>> {

crates/fs/src/fs.rs

@@ -335,11 +335,12 @@ impl FileHandle for std::fs::File {
         let mut path_buf = MaybeUninit::<[u8; libc::PATH_MAX as usize]>::uninit();
 
         let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_GETPATH, path_buf.as_mut_ptr()) };
-        anyhow::ensure!(result != -1, "fcntl returned -1");
+        if result == -1 {
+            anyhow::bail!("fcntl returned -1".to_string());
+        }
 
         // SAFETY: `fcntl` will initialize the path buffer.
         let c_str = unsafe { CStr::from_ptr(path_buf.as_ptr().cast()) };
-        anyhow::ensure!(!c_str.is_empty(), "Could find a path for the file handle");
         let path = PathBuf::from(OsStr::from_bytes(c_str.to_bytes()));
         Ok(path)
     }
@@ -371,11 +372,12 @@ impl FileHandle for std::fs::File {
         kif.kf_structsize = libc::KINFO_FILE_SIZE;
 
         let result = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_KINFO, kif.as_mut_ptr()) };
-        anyhow::ensure!(result != -1, "fcntl returned -1");
+        if result == -1 {
+            anyhow::bail!("fcntl returned -1".to_string());
+        }
 
         // SAFETY: `fcntl` will initialize the kif.
         let c_str = unsafe { CStr::from_ptr(kif.assume_init().kf_path.as_ptr()) };
-        anyhow::ensure!(!c_str.is_empty(), "Could find a path for the file handle");
         let path = PathBuf::from(OsStr::from_bytes(c_str.to_bytes()));
         Ok(path)
     }
@@ -396,21 +398,18 @@ impl FileHandle for std::fs::File {
         // Query required buffer size (in wide chars)
         let required_len =
             unsafe { GetFinalPathNameByHandleW(handle, &mut [], FILE_NAME_NORMALIZED) };
-        anyhow::ensure!(
-            required_len != 0,
-            "GetFinalPathNameByHandleW returned 0 length"
-        );
+        if required_len == 0 {
+            anyhow::bail!("GetFinalPathNameByHandleW returned 0 length");
+        }
 
         // Allocate buffer and retrieve the path
         let mut buf: Vec<u16> = vec![0u16; required_len as usize + 1];
         let written = unsafe { GetFinalPathNameByHandleW(handle, &mut buf, FILE_NAME_NORMALIZED) };
-        anyhow::ensure!(
-            written != 0,
-            "GetFinalPathNameByHandleW failed to write path"
-        );
+        if written == 0 {
+            anyhow::bail!("GetFinalPathNameByHandleW failed to write path");
+        }
 
         let os_str: OsString = OsString::from_wide(&buf[..written as usize]);
-        anyhow::ensure!(!os_str.is_empty(), "Could find a path for the file handle");
         Ok(PathBuf::from(os_str))
     }
 }
@@ -1858,18 +1857,6 @@ impl FakeFs {
         .unwrap();
     }
 
-    pub fn set_remote_for_repo(
-        &self,
-        dot_git: &Path,
-        name: impl Into<String>,
-        url: impl Into<String>,
-    ) {
-        self.with_git_state(dot_git, true, |state| {
-            state.remotes.insert(name.into(), url.into());
-        })
-        .unwrap();
-    }
-
     pub fn insert_branches(&self, dot_git: &Path, branches: &[&str]) {
         self.with_git_state(dot_git, true, |state| {
             if let Some(first) = branches.first()

crates/fsevent/src/fsevent.rs

@@ -76,7 +76,7 @@ impl EventStream {
                     cf::CFRelease(cf_path);
                     cf::CFRelease(cf_url);
                 } else {
-                    log::error!("Failed to create CFURL for path: {path:?}");
+                    log::error!("Failed to create CFURL for path: {}", path.display());
                 }
             }
 

crates/git_ui/src/blame_ui.rs

@@ -13,7 +13,7 @@ use project::{git_store::Repository, project_settings::ProjectSettings};
 use settings::Settings as _;
 use theme::ThemeSettings;
 use time::OffsetDateTime;
-use ui::{ContextMenu, CopyButton, Divider, prelude::*, tooltip_container};
+use ui::{ContextMenu, Divider, prelude::*, tooltip_container};
 use workspace::Workspace;
 
 const GIT_BLAME_MAX_AUTHOR_CHARS_DISPLAYED: usize = 20;
@@ -335,10 +335,18 @@ impl BlameRenderer for GitBlameRenderer {
                                                     cx.stop_propagation();
                                                 }),
                                             )
-                                            .child(Divider::vertical())
                                             .child(
-                                                CopyButton::new(sha.to_string())
-                                                    .tooltip_label("Copy SHA"),
+                                                IconButton::new("copy-sha-button", IconName::Copy)
+                                                    .icon_size(IconSize::Small)
+                                                    .icon_color(Color::Muted)
+                                                    .on_click(move |_, _, cx| {
+                                                        cx.stop_propagation();
+                                                        cx.write_to_clipboard(
+                                                            ClipboardItem::new_string(
+                                                                sha.to_string(),
+                                                            ),
+                                                        )
+                                                    }),
                                             ),
                                     ),
                             ),

crates/git_ui/src/commit_tooltip.rs

@@ -5,7 +5,7 @@ use git::blame::BlameEntry;
 use git::repository::CommitSummary;
 use git::{GitRemote, commit::ParsedCommitMessage};
 use gpui::{
-    App, Asset, Element, Entity, MouseButton, ParentElement, Render, ScrollHandle,
+    App, Asset, ClipboardItem, Element, Entity, MouseButton, ParentElement, Render, ScrollHandle,
     StatefulInteractiveElement, WeakEntity, prelude::*,
 };
 use markdown::{Markdown, MarkdownElement};
@@ -14,7 +14,7 @@ use settings::Settings;
 use std::hash::Hash;
 use theme::ThemeSettings;
 use time::{OffsetDateTime, UtcOffset};
-use ui::{Avatar, CopyButton, Divider, prelude::*, tooltip_container};
+use ui::{Avatar, Divider, IconButtonShape, prelude::*, tooltip_container};
 use workspace::Workspace;
 
 #[derive(Clone, Debug)]
@@ -315,8 +315,8 @@ impl Render for CommitTooltip {
                                                     cx.open_url(pr.url.as_str())
                                                 }),
                                             )
-                                            .child(Divider::vertical())
                                         })
+                                        .child(Divider::vertical())
                                         .child(
                                             Button::new(
                                                 "commit-sha-button",
@@ -342,8 +342,18 @@ impl Render for CommitTooltip {
                                                 },
                                             ),
                                         )
-                                        .child(Divider::vertical())
-                                        .child(CopyButton::new(full_sha).tooltip_label("Copy SHA")),
+                                        .child(
+                                            IconButton::new("copy-sha-button", IconName::Copy)
+                                                .shape(IconButtonShape::Square)
+                                                .icon_size(IconSize::Small)
+                                                .icon_color(Color::Muted)
+                                                .on_click(move |_, _, cx| {
+                                                    cx.stop_propagation();
+                                                    cx.write_to_clipboard(
+                                                        ClipboardItem::new_string(full_sha.clone()),
+                                                    )
+                                                }),
+                                        ),
                                 ),
                         ),
                 )

crates/git_ui/src/commit_view.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context as _, Result};
-use buffer_diff::BufferDiff;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use editor::display_map::{BlockPlacement, BlockProperties, BlockStyle};
 use editor::{Editor, EditorEvent, ExcerptRange, MultiBuffer, multibuffer_context_lines};
 use git::repository::{CommitDetails, CommitDiff, RepoPath};
@@ -8,9 +8,9 @@ use git::{
     parse_git_remote_url,
 };
 use gpui::{
-    AnyElement, App, AppContext as _, AsyncApp, AsyncWindowContext, ClipboardItem, Context,
-    Element, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement,
-    ParentElement, PromptLevel, Render, Styled, Task, WeakEntity, Window, actions,
+    AnyElement, App, AppContext as _, AsyncApp, AsyncWindowContext, Context, Element, Entity,
+    EventEmitter, FocusHandle, Focusable, InteractiveElement, IntoElement, ParentElement,
+    PromptLevel, Render, Styled, Task, WeakEntity, Window, actions,
 };
 use language::{
     Anchor, Buffer, Capability, DiskState, File, LanguageRegistry, LineEnding, OffsetRangeExt as _,
@@ -24,7 +24,7 @@ use std::{
     sync::Arc,
 };
 use theme::ActiveTheme;
-use ui::{ButtonLike, DiffStat, Tooltip, prelude::*};
+use ui::{DiffStat, Tooltip, prelude::*};
 use util::{ResultExt, paths::PathStyle, rel_path::RelPath, truncate_and_trailoff};
 use workspace::item::TabTooltipContent;
 use workspace::{
@@ -262,8 +262,7 @@ impl CommitView {
                         let snapshot = buffer.read(cx).snapshot();
                         let path = snapshot.file().unwrap().path().clone();
                         let excerpt_ranges = {
-                            let diff_snapshot = buffer_diff.read(cx).snapshot(cx);
-                            let mut hunks = diff_snapshot.hunks(&snapshot).peekable();
+                            let mut hunks = buffer_diff.read(cx).hunks(&snapshot, cx).peekable();
                             if hunks.peek().is_none() {
                                 vec![language::Point::zero()..snapshot.max_point()]
                             } else {
@@ -384,7 +383,6 @@ impl CommitView {
     fn render_header(&self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
         let commit = &self.commit;
         let author_name = commit.author_name.clone();
-        let commit_sha = commit.sha.clone();
         let commit_date = time::OffsetDateTime::from_unix_timestamp(commit.commit_timestamp)
             .unwrap_or_else(|_| time::OffsetDateTime::now_utc());
         let local_offset = time::UtcOffset::current_local_offset().unwrap_or(time::UtcOffset::UTC);
@@ -431,19 +429,6 @@ impl CommitView {
                 .full_width()
         });
 
-        let clipboard_has_link = cx
-            .read_from_clipboard()
-            .and_then(|entry| entry.text())
-            .map_or(false, |clipboard_text| {
-                clipboard_text.trim() == commit_sha.as_ref()
-            });
-
-        let (copy_icon, copy_icon_color) = if clipboard_has_link {
-            (IconName::Check, Color::Success)
-        } else {
-            (IconName::Copy, Color::Muted)
-        };
-
         h_flex()
             .border_b_1()
             .border_color(cx.theme().colors().border_variant)
@@ -469,47 +454,13 @@ impl CommitView {
                                 h_flex()
                                     .gap_1()
                                     .child(Label::new(author_name).color(Color::Default))
-                                    .child({
-                                        ButtonLike::new("sha")
-                                            .child(
-                                                h_flex()
-                                                    .group("sha_btn")
-                                                    .size_full()
-                                                    .max_w_32()
-                                                    .gap_0p5()
-                                                    .child(
-                                                        Label::new(commit_sha.clone())
-                                                            .color(Color::Muted)
-                                                            .size(LabelSize::Small)
-                                                            .truncate()
-                                                            .buffer_font(cx),
-                                                    )
-                                                    .child(
-                                                        div().visible_on_hover("sha_btn").child(
-                                                            Icon::new(copy_icon)
-                                                                .color(copy_icon_color)
-                                                                .size(IconSize::Small),
-                                                        ),
-                                                    ),
-                                            )
-                                            .tooltip({
-                                                let commit_sha = commit_sha.clone();
-                                                move |_, cx| {
-                                                    Tooltip::with_meta(
-                                                        "Copy Commit SHA",
-                                                        None,
-                                                        commit_sha.clone(),
-                                                        cx,
-                                                    )
-                                                }
-                                            })
-                                            .on_click(move |_, _, cx| {
-                                                cx.stop_propagation();
-                                                cx.write_to_clipboard(ClipboardItem::new_string(
-                                                    commit_sha.to_string(),
-                                                ));
-                                            })
-                                    }),
+                                    .child(
+                                        Label::new(format!("Commit:{}", commit.sha))
+                                            .color(Color::Muted)
+                                            .size(LabelSize::Small)
+                                            .truncate()
+                                            .buffer_font(cx),
+                                    ),
                             )
                             .child(
                                 h_flex()
@@ -786,30 +737,35 @@ async fn build_buffer_diff(
         LineEnding::normalize(old_text);
     }
 
-    let language = cx.update(|cx| buffer.read(cx).language().cloned())?;
     let buffer = cx.update(|cx| buffer.read(cx).snapshot())?;
 
-    let diff = cx.new(|cx| BufferDiff::new(&buffer.text, cx))?;
-
-    let update = diff
-        .update(cx, |diff, cx| {
-            diff.update_diff(
-                buffer.text.clone(),
-                old_text.map(|old_text| Arc::from(old_text.as_str())),
-                true,
-                language.clone(),
+    let base_buffer = cx
+        .update(|cx| {
+            Buffer::build_snapshot(
+                old_text.as_deref().unwrap_or("").into(),
+                buffer.language().cloned(),
+                Some(language_registry.clone()),
                 cx,
             )
         })?
         .await;
 
-    diff.update(cx, |diff, cx| {
-        diff.language_changed(language, Some(language_registry.clone()), cx);
-        diff.set_snapshot(update, &buffer.text, cx)
-    })
-    .ok();
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
+                buffer.text.clone(),
+                old_text.map(Arc::new),
+                base_buffer,
+                cx,
+            )
+        })?
+        .await;
 
-    Ok(diff)
+    cx.new(|cx| {
+        let mut diff = BufferDiff::new(&buffer.text, cx);
+        diff.set_snapshot(diff_snapshot, &buffer.text, cx);
+        diff
+    })
 }
 
 impl EventEmitter<EditorEvent> for CommitView {}

crates/git_ui/src/file_diff_view.rs

@@ -1,14 +1,14 @@
 //! FileDiffView provides a UI for displaying differences between two buffers.
 
 use anyhow::Result;
-use buffer_diff::BufferDiff;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use editor::{Editor, EditorEvent, MultiBuffer};
 use futures::{FutureExt, select_biased};
 use gpui::{
     AnyElement, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle,
     Focusable, IntoElement, Render, Task, Window,
 };
-use language::{Buffer, LanguageRegistry};
+use language::Buffer;
 use project::Project;
 use std::{
     any::{Any, TypeId},
@@ -52,9 +52,8 @@ impl FileDiffView {
             let new_buffer = project
                 .update(cx, |project, cx| project.open_local_buffer(&new_path, cx))?
                 .await?;
-            let languages = project.update(cx, |project, _| project.languages().clone())?;
 
-            let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, languages, cx).await?;
+            let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, cx).await?;
 
             workspace.update_in(cx, |workspace, window, cx| {
                 let diff_view = cx.new(|cx| {
@@ -144,16 +143,19 @@ impl FileDiffView {
                             this.new_buffer.read(cx).snapshot(),
                         )
                     })?;
+                    let diff_snapshot = cx
+                        .update(|cx| {
+                            BufferDiffSnapshot::new_with_base_buffer(
+                                new_snapshot.text.clone(),
+                                Some(old_snapshot.text().into()),
+                                old_snapshot,
+                                cx,
+                            )
+                        })?
+                        .await;
                     diff.update(cx, |diff, cx| {
-                        diff.set_base_text(
-                            Some(old_snapshot.text().as_str().into()),
-                            old_snapshot.language().cloned(),
-                            new_snapshot.text.clone(),
-                            cx,
-                        )
-                    })?
-                    .await
-                    .ok();
+                        diff.set_snapshot(diff_snapshot, &new_snapshot, cx)
+                    })?;
                     log::trace!("finish recalculating");
                 }
                 Ok(())
@@ -165,36 +167,27 @@ impl FileDiffView {
 async fn build_buffer_diff(
     old_buffer: &Entity<Buffer>,
     new_buffer: &Entity<Buffer>,
-    language_registry: Arc<LanguageRegistry>,
     cx: &mut AsyncApp,
 ) -> Result<Entity<BufferDiff>> {
     let old_buffer_snapshot = old_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
     let new_buffer_snapshot = new_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
 
-    let diff = cx.new(|cx| BufferDiff::new(&new_buffer_snapshot.text, cx))?;
-
-    let update = diff
-        .update(cx, |diff, cx| {
-            diff.update_diff(
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
                 new_buffer_snapshot.text.clone(),
                 Some(old_buffer_snapshot.text().into()),
-                true,
-                new_buffer_snapshot.language().cloned(),
+                old_buffer_snapshot,
                 cx,
             )
         })?
         .await;
 
-    diff.update(cx, |diff, cx| {
-        diff.language_changed(
-            new_buffer_snapshot.language().cloned(),
-            Some(language_registry),
-            cx,
-        );
-        diff.set_snapshot(update, &new_buffer_snapshot.text, cx);
-    })?;
-
-    Ok(diff)
+    cx.new(|cx| {
+        let mut diff = BufferDiff::new(&new_buffer_snapshot.text, cx);
+        diff.set_snapshot(diff_snapshot, &new_buffer_snapshot.text, cx);
+        diff
+    })
 }
 
 impl EventEmitter<EditorEvent> for FileDiffView {}

crates/git_ui/src/git_panel.rs

@@ -3638,7 +3638,7 @@ impl GitPanel {
             self.entry_count += 1;
             let is_staging_or_staged = GitPanel::stage_status_for_entry(status_entry, repo)
                 .as_bool()
-                .unwrap_or(true);
+                .unwrap_or(false);
 
             if repo.had_conflict_on_last_merge_head_change(&status_entry.repo_path) {
                 self.conflicted_count += 1;

crates/git_ui/src/project_diff.rs

@@ -423,7 +423,7 @@ impl ProjectDiff {
         let mut has_staged_hunks = false;
         let mut has_unstaged_hunks = false;
         for hunk in editor.diff_hunks_in_ranges(&ranges, &snapshot) {
-            match hunk.status.secondary {
+            match hunk.secondary_status {
                 DiffHunkSecondaryStatus::HasSecondaryHunk
                 | DiffHunkSecondaryStatus::SecondaryHunkAdditionPending => {
                     has_unstaged_hunks = true;
@@ -525,13 +525,14 @@ impl ProjectDiff {
             .expect("project diff editor should have a conflict addon");
 
         let snapshot = buffer.read(cx).snapshot();
-        let diff_snapshot = diff.read(cx).snapshot(cx);
+        let diff_read = diff.read(cx);
 
         let excerpt_ranges = {
-            let diff_hunk_ranges = diff_snapshot
+            let diff_hunk_ranges = diff_read
                 .hunks_intersecting_range(
-                    Anchor::min_max_range_for_buffer(snapshot.remote_id()),
+                    Anchor::min_max_range_for_buffer(diff_read.buffer_id),
                     &snapshot,
+                    cx,
                 )
                 .map(|diff_hunk| diff_hunk.buffer_range.to_point(&snapshot));
             let conflicts = conflict_addon
@@ -550,21 +551,18 @@ impl ProjectDiff {
             }
         };
 
-        let (was_empty, is_excerpt_newly_added) = self.editor.update(cx, |editor, cx| {
-            let was_empty = editor
-                .primary_editor()
-                .read(cx)
-                .buffer()
-                .read(cx)
-                .is_empty();
-            let (_, is_newly_added) = editor.set_excerpts_for_path(
+        let (was_empty, is_excerpt_newly_added) = self.multibuffer.update(cx, |multibuffer, cx| {
+            let was_empty = multibuffer.is_empty();
+            let (_, is_newly_added) = multibuffer.set_excerpts_for_path(
                 path_key.clone(),
                 buffer,
                 excerpt_ranges,
                 multibuffer_context_lines(cx),
-                diff,
                 cx,
             );
+            if self.branch_diff.read(cx).diff_base().is_merge_base() {
+                multibuffer.add_diff(diff.clone(), cx);
+            }
             (was_empty, is_newly_added)
         });
 
@@ -641,9 +639,9 @@ impl ProjectDiff {
                 }
             }
 
-            this.editor.update(cx, |editor, cx| {
+            this.multibuffer.update(cx, |multibuffer, cx| {
                 for path in previous_paths {
-                    if let Some(buffer) = this.multibuffer.read(cx).buffer_for_path(&path, cx) {
+                    if let Some(buffer) = multibuffer.buffer_for_path(&path, cx) {
                         let skip = match reason {
                             RefreshReason::DiffChanged | RefreshReason::EditorSaved => {
                                 buffer.read(cx).is_dirty()
@@ -656,7 +654,7 @@ impl ProjectDiff {
                     }
 
                     this.buffer_diff_subscriptions.remove(&path.path);
-                    editor.remove_excerpts_for_path(path, cx);
+                    multibuffer.remove_excerpts_for_path(path.clone(), cx);
                 }
             });
             buffers_to_load
@@ -1691,6 +1689,12 @@ mod tests {
         )
         .await;
         let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
+        let (workspace, cx) =
+            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
+        let diff = cx.new_window_entity(|window, cx| {
+            ProjectDiff::new(project.clone(), workspace, window, cx)
+        });
+        cx.run_until_parked();
 
         fs.set_head_for_repo(
             path!("/project/.git").as_ref(),
@@ -1701,12 +1705,6 @@ mod tests {
             path!("/project/.git").as_ref(),
             &[("foo.txt", "foo\n".into())],
         );
-
-        let (workspace, cx) =
-            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        let diff = cx.new_window_entity(|window, cx| {
-            ProjectDiff::new(project.clone(), workspace, window, cx)
-        });
         cx.run_until_parked();
 
         let editor = diff.read_with(cx, |diff, cx| diff.editor.read(cx).primary_editor().clone());
@@ -1714,8 +1712,8 @@ mod tests {
             &editor,
             cx,
             &"
-                - ˇfoo
-                + FOO
+                - foo
+                + ˇFOO
             "
             .unindent(),
         );
@@ -1822,12 +1820,6 @@ mod tests {
         let project = Project::test(fs.clone(), [path!("/project").as_ref()], cx).await;
         let (workspace, cx) =
             cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        fs.set_head_for_repo(
-            path!("/project/.git").as_ref(),
-            &[("foo", "original\n".into())],
-            "deadbeef",
-        );
-
         let buffer = project
             .update(cx, |project, cx| {
                 project.open_local_buffer(path!("/project/foo"), cx)
@@ -1842,6 +1834,13 @@ mod tests {
         });
         cx.run_until_parked();
 
+        fs.set_head_for_repo(
+            path!("/project/.git").as_ref(),
+            &[("foo", "original\n".into())],
+            "deadbeef",
+        );
+        cx.run_until_parked();
+
         let diff_editor =
             diff.read_with(cx, |diff, cx| diff.editor.read(cx).primary_editor().clone());
 
@@ -1849,8 +1848,8 @@ mod tests {
             &diff_editor,
             cx,
             &"
-                - ˇoriginal
-                + modified
+                - original
+                + ˇmodified
             "
             .unindent(),
         );
@@ -1913,9 +1912,9 @@ mod tests {
             &diff_editor,
             cx,
             &"
-                - ˇoriginal
+                - original
                 + different
-            "
+                  ˇ"
             .unindent(),
         );
     }

crates/git_ui/src/text_diff_view.rs

@@ -1,7 +1,7 @@
 //! TextDiffView currently provides a UI for displaying differences between the clipboard and selected text.
 
 use anyhow::Result;
-use buffer_diff::BufferDiff;
+use buffer_diff::{BufferDiff, BufferDiffSnapshot};
 use editor::{Editor, EditorEvent, MultiBuffer, ToPoint, actions::DiffClipboardWithSelectionData};
 use futures::{FutureExt, select_biased};
 use gpui::{
@@ -257,25 +257,23 @@ async fn update_diff_buffer(
     cx: &mut AsyncApp,
 ) -> Result<()> {
     let source_buffer_snapshot = source_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
-    let language = source_buffer_snapshot.language().cloned();
 
     let base_buffer_snapshot = clipboard_buffer.read_with(cx, |buffer, _| buffer.snapshot())?;
     let base_text = base_buffer_snapshot.text();
 
-    let update = diff
-        .update(cx, |diff, cx| {
-            diff.update_diff(
+    let diff_snapshot = cx
+        .update(|cx| {
+            BufferDiffSnapshot::new_with_base_buffer(
                 source_buffer_snapshot.text.clone(),
-                Some(Arc::from(base_text.as_str())),
-                true,
-                language,
+                Some(Arc::new(base_text)),
+                base_buffer_snapshot,
                 cx,
             )
         })?
         .await;
 
     diff.update(cx, |diff, cx| {
-        diff.set_snapshot(update, &source_buffer_snapshot.text, cx);
+        diff.set_snapshot(diff_snapshot, &source_buffer_snapshot.text, cx);
     })?;
     Ok(())
 }

crates/git_ui/src/worktree_picker.rs

@@ -13,7 +13,7 @@ use picker::{Picker, PickerDelegate, PickerEditorPosition};
 use project::{
     DirectoryLister,
     git_store::Repository,
-    trusted_worktrees::{PathTrust, TrustedWorktrees},
+    trusted_worktrees::{PathTrust, RemoteHostLocation, TrustedWorktrees},
 };
 use recent_projects::{RemoteConnectionModal, connect};
 use remote::{RemoteConnectionOptions, remote_client::ConnectionIdentifier};
@@ -271,18 +271,16 @@ impl WorktreeListDelegate {
                     if let Some((parent_worktree, _)) =
                         project.read(cx).find_worktree(repo_path, cx)
                     {
-                        let worktree_store = project.read(cx).worktree_store();
                         trusted_worktrees.update(cx, |trusted_worktrees, cx| {
-                            if trusted_worktrees.can_trust(
-                                &worktree_store,
-                                parent_worktree.read(cx).id(),
-                                cx,
-                            ) {
+                            if trusted_worktrees.can_trust(parent_worktree.read(cx).id(), cx) {
                                 trusted_worktrees.trust(
-                                    &worktree_store,
                                     HashSet::from_iter([PathTrust::AbsPath(
                                         new_worktree_path.clone(),
                                     )]),
+                                    project
+                                        .read(cx)
+                                        .remote_connection_options(cx)
+                                        .map(RemoteHostLocation::from),
                                     cx,
                                 );
                             }

crates/gpui/src/elements/div.rs

@@ -2154,6 +2154,7 @@ impl Interactivity {
             || cx.active_drag.is_some() && !self.drag_over_styles.is_empty()
         {
             let hitbox = hitbox.clone();
+            let was_hovered = hitbox.is_hovered(window);
             let hover_state = self.hover_style.as_ref().and_then(|_| {
                 element_state
                     .as_ref()
@@ -2161,12 +2162,8 @@ impl Interactivity {
                     .cloned()
             });
             let current_view = window.current_view();
-
             window.on_mouse_event(move |_: &MouseMoveEvent, phase, window, cx| {
                 let hovered = hitbox.is_hovered(window);
-                let was_hovered = hover_state
-                    .as_ref()
-                    .is_some_and(|state| state.borrow().element);
                 if phase == DispatchPhase::Capture && hovered != was_hovered {
                     if let Some(hover_state) = &hover_state {
                         hover_state.borrow_mut().element = hovered;
@@ -2182,13 +2179,12 @@ impl Interactivity {
                     .as_ref()
                     .and_then(|element| element.hover_state.as_ref())
                     .cloned();
+
+                let was_group_hovered = group_hitbox_id.is_hovered(window);
                 let current_view = window.current_view();
 
                 window.on_mouse_event(move |_: &MouseMoveEvent, phase, window, cx| {
                     let group_hovered = group_hitbox_id.is_hovered(window);
-                    let was_group_hovered = hover_state
-                        .as_ref()
-                        .is_some_and(|state| state.borrow().group);
                     if phase == DispatchPhase::Capture && group_hovered != was_group_hovered {
                         if let Some(hover_state) = &hover_state {
                             hover_state.borrow_mut().group = group_hovered;

crates/gpui/src/platform/mac/metal_renderer.rs

@@ -46,9 +46,9 @@ pub unsafe fn new_renderer(
     _native_window: *mut c_void,
     _native_view: *mut c_void,
     _bounds: crate::Size<f32>,
-    transparent: bool,
+    _transparent: bool,
 ) -> Renderer {
-    MetalRenderer::new(context, transparent)
+    MetalRenderer::new(context)
 }
 
 pub(crate) struct InstanceBufferPool {
@@ -128,7 +128,7 @@ pub struct PathRasterizationVertex {
 }
 
 impl MetalRenderer {
-    pub fn new(instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>, transparent: bool) -> Self {
+    pub fn new(instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>) -> Self {
         // Prefer low‐power integrated GPUs on Intel Mac. On Apple
         // Silicon, there is only ever one GPU, so this is equivalent to
         // `metal::Device::system_default()`.
@@ -152,9 +152,7 @@ impl MetalRenderer {
         let layer = metal::MetalLayer::new();
         layer.set_device(&device);
         layer.set_pixel_format(MTLPixelFormat::BGRA8Unorm);
-        // Support direct-to-display rendering if the window is not transparent
-        // https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos
-        layer.set_opaque(!transparent);
+        layer.set_opaque(false);
         layer.set_maximum_drawable_count(3);
         unsafe {
             let _: () = msg_send![&*layer, setAllowsNextDrawableTimeout: NO];
@@ -354,8 +352,8 @@ impl MetalRenderer {
         }
     }
 
-    pub fn update_transparency(&self, transparent: bool) {
-        self.layer.set_opaque(!transparent);
+    pub fn update_transparency(&self, _transparent: bool) {
+        // todo(mac)?
     }
 
     pub fn destroy(&self) {

crates/gpui/src/platform/windows/events.rs

@@ -42,7 +42,7 @@ impl WindowsWindowInner {
         let handled = match msg {
             // eagerly activate the window, so calls to `active_window` will work correctly
             WM_MOUSEACTIVATE => {
-                unsafe { SetActiveWindow(handle).ok() };
+                unsafe { SetActiveWindow(handle).log_err() };
                 None
             }
             WM_ACTIVATE => self.handle_activate_msg(wparam),

crates/gpui/src/platform/windows/window.rs

@@ -740,8 +740,8 @@ impl PlatformWindow for WindowsWindow {
                         ShowWindowAsync(hwnd, SW_RESTORE).ok().log_err();
                     }
 
-                    SetActiveWindow(hwnd).ok();
-                    SetFocus(Some(hwnd)).ok();
+                    SetActiveWindow(hwnd).log_err();
+                    SetFocus(Some(hwnd)).log_err();
                 }
 
                 // premium ragebait by windows, this is needed because the window

crates/json_schema_store/Cargo.toml

@@ -20,7 +20,6 @@ dap.workspace = true
 extension.workspace = true
 gpui.workspace = true
 language.workspace = true
-lsp.workspace = true
 paths.workspace = true
 project.workspace = true
 schemars.workspace = true

crates/json_schema_store/src/json_schema_store.rs

@@ -2,11 +2,9 @@
 use std::{str::FromStr, sync::Arc};
 
 use anyhow::{Context as _, Result};
-use gpui::{App, AsyncApp, BorrowAppContext as _, Entity, Task, WeakEntity};
+use gpui::{App, AsyncApp, BorrowAppContext as _, Entity, WeakEntity};
 use language::{LanguageRegistry, language_settings::all_language_settings};
-use lsp::LanguageServerBinaryOptions;
-use project::{LspStore, lsp_store::LocalLspAdapterDelegate};
-use settings::LSP_SETTINGS_SCHEMA_URL_PREFIX;
+use project::LspStore;
 use util::schemars::{AllowTrailingCommas, DefaultDenyUnknownFields};
 
 // Origin: https://github.com/SchemaStore/schemastore
@@ -77,28 +75,23 @@ fn handle_schema_request(
     lsp_store: Entity<LspStore>,
     uri: String,
     cx: &mut AsyncApp,
-) -> Task<Result<String>> {
-    let languages = lsp_store.read_with(cx, |lsp_store, _| lsp_store.languages.clone());
-    cx.spawn(async move |cx| {
-        let languages = languages?;
-        let schema = resolve_schema_request(&languages, lsp_store, uri, cx).await?;
-        serde_json::to_string(&schema).context("Failed to serialize schema")
-    })
+) -> Result<String> {
+    let languages = lsp_store.read_with(cx, |lsp_store, _| lsp_store.languages.clone())?;
+    let schema = resolve_schema_request(&languages, uri, cx)?;
+    serde_json::to_string(&schema).context("Failed to serialize schema")
 }
 
-pub async fn resolve_schema_request(
+pub fn resolve_schema_request(
     languages: &Arc<LanguageRegistry>,
-    lsp_store: Entity<LspStore>,
     uri: String,
     cx: &mut AsyncApp,
 ) -> Result<serde_json::Value> {
     let path = uri.strip_prefix("zed://schemas/").context("Invalid URI")?;
-    resolve_schema_request_inner(languages, lsp_store, path, cx).await
+    resolve_schema_request_inner(languages, path, cx)
 }
 
-pub async fn resolve_schema_request_inner(
+pub fn resolve_schema_request_inner(
     languages: &Arc<LanguageRegistry>,
-    lsp_store: Entity<LspStore>,
     path: &str,
     cx: &mut AsyncApp,
 ) -> Result<serde_json::Value> {
@@ -106,121 +99,37 @@ pub async fn resolve_schema_request_inner(
     let schema_name = schema_name.unwrap_or(path);
 
     let schema = match schema_name {
-        "settings" if rest.is_some_and(|r| r.starts_with("lsp/")) => {
-            let lsp_name = rest
-                .and_then(|r| {
-                    r.strip_prefix(
-                        LSP_SETTINGS_SCHEMA_URL_PREFIX
-                            .strip_prefix("zed://schemas/settings/")
-                            .unwrap(),
-                    )
-                })
-                .context("Invalid LSP schema path")?;
-
-            let adapter = languages
-                .all_lsp_adapters()
+        "settings" => cx.update(|cx| {
+            let font_names = &cx.text_system().all_font_names();
+            let language_names = &languages
+                .language_names()
                 .into_iter()
-                .find(|adapter| adapter.name().as_ref() as &str == lsp_name)
-                .with_context(|| format!("LSP adapter not found: {}", lsp_name))?;
-
-            let delegate = cx
-                .update(|inner_cx| {
-                    lsp_store.update(inner_cx, |lsp_store, inner_cx| {
-                        let Some(local) = lsp_store.as_local() else {
-                            return None;
-                        };
-                        let Some(worktree) = local.worktree_store.read(inner_cx).worktrees().next()
-                        else {
-                            return None;
-                        };
-                        Some(LocalLspAdapterDelegate::from_local_lsp(
-                            local, &worktree, inner_cx,
-                        ))
-                    })
-                })?
-                .context(concat!(
-                    "Failed to create adapter delegate - ",
-                    "either LSP store is not in local mode or no worktree is available"
-                ))?;
-
-            let adapter_for_schema = adapter.clone();
-
-            let binary = adapter
-                .get_language_server_command(
-                    delegate,
-                    None,
-                    LanguageServerBinaryOptions {
-                        allow_path_lookup: true,
-                        allow_binary_download: false,
-                        pre_release: false,
-                    },
-                    cx,
-                )
-                .await
-                .await
-                .0
-                .with_context(|| {
-                    format!(
-                        concat!(
-                            "Failed to find language server {} ",
-                            "to generate initialization params schema"
-                        ),
-                        lsp_name
-                    )
-                })?;
-
-            adapter_for_schema
-                .adapter
-                .clone()
-                .initialization_options_schema(&binary)
-                .await
-                .unwrap_or_else(|| {
-                    serde_json::json!({
-                        "type": "object",
-                        "additionalProperties": true
-                    })
-                })
-        }
-        "settings" => {
-            let lsp_adapter_names = languages
-                .all_lsp_adapters()
-                .into_iter()
-                .map(|adapter| adapter.name().to_string())
+                .map(|name| name.to_string())
                 .collect::<Vec<_>>();
 
-            cx.update(|cx| {
-                let font_names = &cx.text_system().all_font_names();
-                let language_names = &languages
-                    .language_names()
-                    .into_iter()
-                    .map(|name| name.to_string())
-                    .collect::<Vec<_>>();
+            let mut icon_theme_names = vec![];
+            let mut theme_names = vec![];
+            if let Some(registry) = theme::ThemeRegistry::try_global(cx) {
+                icon_theme_names.extend(
+                    registry
+                        .list_icon_themes()
+                        .into_iter()
+                        .map(|icon_theme| icon_theme.name),
+                );
+                theme_names.extend(registry.list_names());
+            }
+            let icon_theme_names = icon_theme_names.as_slice();
+            let theme_names = theme_names.as_slice();
 
-                let mut icon_theme_names = vec![];
-                let mut theme_names = vec![];
-                if let Some(registry) = theme::ThemeRegistry::try_global(cx) {
-                    icon_theme_names.extend(
-                        registry
-                            .list_icon_themes()
-                            .into_iter()
-                            .map(|icon_theme| icon_theme.name),
-                    );
-                    theme_names.extend(registry.list_names());
-                }
-                let icon_theme_names = icon_theme_names.as_slice();
-                let theme_names = theme_names.as_slice();
-
-                cx.global::<settings::SettingsStore>().json_schema(
-                    &settings::SettingsJsonSchemaParams {
-                        language_names,
-                        font_names,
-                        theme_names,
-                        icon_theme_names,
-                        lsp_adapter_names: &lsp_adapter_names,
-                    },
-                )
-            })?
-        }
+            cx.global::<settings::SettingsStore>().json_schema(
+                &settings::SettingsJsonSchemaParams {
+                    language_names,
+                    font_names,
+                    theme_names,
+                    icon_theme_names,
+                },
+            )
+        })?,
         "keymap" => cx.update(settings::KeymapFile::generate_json_schema_for_registered_actions)?,
         "action" => {
             let normalized_action_name = rest.context("No Action name provided")?;

crates/language/src/language.rs

@@ -67,7 +67,7 @@ use task::RunnableTag;
 pub use task_context::{ContextLocation, ContextProvider, RunnableRange};
 pub use text_diff::{
     DiffOptions, apply_diff_patch, line_diff, text_diff, text_diff_with_options, unified_diff,
-    unified_diff_with_offsets, word_diff_ranges,
+    word_diff_ranges,
 };
 use theme::SyntaxTheme;
 pub use toolchain::{
@@ -461,14 +461,6 @@ pub trait LspAdapter: 'static + Send + Sync + DynLspInstaller {
         Ok(None)
     }
 
-    /// Returns the JSON schema of the initialization_options for the language server.
-    async fn initialization_options_schema(
-        self: Arc<Self>,
-        _language_server_binary: &LanguageServerBinary,
-    ) -> Option<serde_json::Value> {
-        None
-    }
-
     async fn workspace_configuration(
         self: Arc<Self>,
         _: &Arc<dyn LspAdapterDelegate>,

crates/language/src/language_settings.rs

@@ -392,7 +392,6 @@ pub struct EditPredictionSettings {
     /// Whether edit predictions are enabled in the assistant panel.
     /// This setting has no effect if globally disabled.
     pub enabled_in_text_threads: bool,
-    pub examples_dir: Option<Arc<Path>>,
 }
 
 impl EditPredictionSettings {
@@ -700,7 +699,6 @@ impl settings::Settings for AllLanguageSettings {
                 copilot: copilot_settings,
                 codestral: codestral_settings,
                 enabled_in_text_threads,
-                examples_dir: edit_predictions.examples_dir,
             },
             defaults: default_language_settings,
             languages,

crates/language/src/text_diff.rs

@@ -1,139 +1,25 @@
 use crate::{CharClassifier, CharKind, CharScopeContext, LanguageScope};
 use anyhow::{Context, anyhow};
 use imara_diff::{
-    Algorithm, Sink, diff,
-    intern::{InternedInput, Interner, Token},
+    Algorithm, UnifiedDiffBuilder, diff,
+    intern::{InternedInput, Token},
     sources::lines_with_terminator,
 };
-use std::{fmt::Write, iter, ops::Range, sync::Arc};
+use std::{iter, ops::Range, sync::Arc};
 
 const MAX_WORD_DIFF_LEN: usize = 512;
 const MAX_WORD_DIFF_LINE_COUNT: usize = 8;
 
 /// Computes a diff between two strings, returning a unified diff string.
 pub fn unified_diff(old_text: &str, new_text: &str) -> String {
-    unified_diff_with_offsets(old_text, new_text, 0, 0)
-}
-
-/// Computes a diff between two strings, returning a unified diff string with
-/// hunk headers adjusted to reflect the given starting line numbers (1-indexed).
-pub fn unified_diff_with_offsets(
-    old_text: &str,
-    new_text: &str,
-    old_start_line: u32,
-    new_start_line: u32,
-) -> String {
     let input = InternedInput::new(old_text, new_text);
     diff(
         Algorithm::Histogram,
         &input,
-        OffsetUnifiedDiffBuilder::new(&input, old_start_line, new_start_line),
+        UnifiedDiffBuilder::new(&input),
     )
 }
 
-/// A unified diff builder that applies line number offsets to hunk headers.
-struct OffsetUnifiedDiffBuilder<'a> {
-    before: &'a [Token],
-    after: &'a [Token],
-    interner: &'a Interner<&'a str>,
-
-    pos: u32,
-    before_hunk_start: u32,
-    after_hunk_start: u32,
-    before_hunk_len: u32,
-    after_hunk_len: u32,
-
-    old_line_offset: u32,
-    new_line_offset: u32,
-
-    buffer: String,
-    dst: String,
-}
-
-impl<'a> OffsetUnifiedDiffBuilder<'a> {
-    fn new(input: &'a InternedInput<&'a str>, old_line_offset: u32, new_line_offset: u32) -> Self {
-        Self {
-            before_hunk_start: 0,
-            after_hunk_start: 0,
-            before_hunk_len: 0,
-            after_hunk_len: 0,
-            old_line_offset,
-            new_line_offset,
-            buffer: String::with_capacity(8),
-            dst: String::new(),
-            interner: &input.interner,
-            before: &input.before,
-            after: &input.after,
-            pos: 0,
-        }
-    }
-
-    fn print_tokens(&mut self, tokens: &[Token], prefix: char) {
-        for &token in tokens {
-            writeln!(&mut self.buffer, "{prefix}{}", self.interner[token]).unwrap();
-        }
-    }
-
-    fn flush(&mut self) {
-        if self.before_hunk_len == 0 && self.after_hunk_len == 0 {
-            return;
-        }
-
-        let end = (self.pos + 3).min(self.before.len() as u32);
-        self.update_pos(end, end);
-
-        writeln!(
-            &mut self.dst,
-            "@@ -{},{} +{},{} @@",
-            self.before_hunk_start + 1 + self.old_line_offset,
-            self.before_hunk_len,
-            self.after_hunk_start + 1 + self.new_line_offset,
-            self.after_hunk_len,
-        )
-        .unwrap();
-        write!(&mut self.dst, "{}", &self.buffer).unwrap();
-        self.buffer.clear();
-        self.before_hunk_len = 0;
-        self.after_hunk_len = 0;
-    }
-
-    fn update_pos(&mut self, print_to: u32, move_to: u32) {
-        self.print_tokens(&self.before[self.pos as usize..print_to as usize], ' ');
-        let len = print_to - self.pos;
-        self.pos = move_to;
-        self.before_hunk_len += len;
-        self.after_hunk_len += len;
-    }
-}
-
-impl Sink for OffsetUnifiedDiffBuilder<'_> {
-    type Out = String;
-
-    fn process_change(&mut self, before: Range<u32>, after: Range<u32>) {
-        if before.start - self.pos > 6 {
-            self.flush();
-        }
-        if self.before_hunk_len == 0 && self.after_hunk_len == 0 {
-            self.pos = before.start.saturating_sub(3);
-            self.before_hunk_start = self.pos;
-            self.after_hunk_start = after.start.saturating_sub(3);
-        }
-        self.update_pos(before.start, before.end);
-        self.before_hunk_len += before.end - before.start;
-        self.after_hunk_len += after.end - after.start;
-        self.print_tokens(
-            &self.before[before.start as usize..before.end as usize],
-            '-',
-        );
-        self.print_tokens(&self.after[after.start as usize..after.end as usize], '+');
-    }
-
-    fn finish(mut self) -> Self::Out {
-        self.flush();
-        self.dst
-    }
-}
-
 /// Computes a diff between two strings, returning a vector of old and new row
 /// ranges.
 pub fn line_diff(old_text: &str, new_text: &str) -> Vec<(Range<u32>, Range<u32>)> {
@@ -441,30 +327,4 @@ mod tests {
         let patch = unified_diff(old_text, new_text);
         assert_eq!(apply_diff_patch(old_text, &patch).unwrap(), new_text);
     }
-
-    #[test]
-    fn test_unified_diff_with_offsets() {
-        let old_text = "foo\nbar\nbaz\n";
-        let new_text = "foo\nBAR\nbaz\n";
-
-        let expected_diff_body = " foo\n-bar\n+BAR\n baz\n";
-
-        let diff_no_offset = unified_diff(old_text, new_text);
-        assert_eq!(
-            diff_no_offset,
-            format!("@@ -1,3 +1,3 @@\n{}", expected_diff_body)
-        );
-
-        let diff_with_offset = unified_diff_with_offsets(old_text, new_text, 9, 11);
-        assert_eq!(
-            diff_with_offset,
-            format!("@@ -10,3 +12,3 @@\n{}", expected_diff_body)
-        );
-
-        let diff_with_offset = unified_diff_with_offsets(old_text, new_text, 99, 104);
-        assert_eq!(
-            diff_with_offset,
-            format!("@@ -100,3 +105,3 @@\n{}", expected_diff_body)
-        );
-    }
 }