Add test

Fix
Fix multiple worktrees open
2025-06-09 11:56:45 +05:30 · 2025-06-09 11:56:45 +05:30 · 2025-06-09 11:56:41 +05:30 · 2025-06-09 11:43:15 +05:30 · 2025-06-09 11:43:15 +05:30 · 2025-06-09 10:21:18 +05:30
212 changed files with 9560 additions and 2787 deletions
--- a/.github/actions/build_docs/action.yml
+++ b/.github/actions/build_docs/action.yml
@@ -19,6 +19,12 @@ runs:
      shell: bash -euxo pipefail {0}
      run: ./script/linux

+    - name: Check for broken links
+      uses: lycheeverse/lychee-action@82202e5e9c2f4ef1a55a3d02563e1cb6041e5332 # v2.4.1
+      with:
+        args: --no-progress './docs/src/**/*'
+        fail: true
+
    - name: Build book
      shell: bash -euxo pipefail {0}
      run: |
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -183,6 +183,9 @@ jobs:
      - name: Check for todo! and FIXME comments
        run: script/check-todos

+      - name: Check modifier use in keymaps
+        run: script/check-keymaps
+
      - name: Run style checks
        uses: ./.github/actions/check_style

@@ -736,6 +739,64 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+  freebsd:
+    timeout-minutes: 60
+    runs-on: github-8vcpu-ubuntu-2404
+    if: |
+      startsWith(github.ref, 'refs/tags/v')
+      || contains(github.event.pull_request.labels.*.name, 'run-bundling')
+    needs: [linux_tests]
+    name: Build Zed on FreeBSD
+    # env:
+    #   MYTOKEN : ${{ secrets.MYTOKEN }}
+    #   MYTOKEN2: "value2"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build FreeBSD remote-server
+        id: freebsd-build
+        uses: vmactions/freebsd-vm@c3ae29a132c8ef1924775414107a97cac042aad5 # v1.2.0
+        with:
+          # envs: "MYTOKEN MYTOKEN2"
+          usesh: true
+          release: 13.5
+          copyback: true
+          prepare: |
+            pkg install -y \
+              bash curl jq git \
+              rustup-init cmake-core llvm-devel-lite pkgconf protobuf # ibx11 alsa-lib rust-bindgen-cli
+          run: |
+            freebsd-version
+            sysctl hw.model
+            sysctl hw.ncpu
+            sysctl hw.physmem
+            sysctl hw.usermem
+            git config --global --add safe.directory /home/runner/work/zed/zed
+            rustup-init --profile minimal --default-toolchain none -y
+            . "$HOME/.cargo/env"
+            ./script/bundle-freebsd
+            mkdir -p out/
+            mv "target/zed-remote-server-freebsd-x86_64.gz" out/
+            rm -rf target/
+            cargo clean
+
+      - name: Upload Artifact to Workflow - zed-remote-server (run-bundling)
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
+        if: contains(github.event.pull_request.labels.*.name, 'run-bundling')
+        with:
+          name: zed-remote-server-${{ github.event.pull_request.head.sha || github.sha }}-x86_64-unknown-freebsd.gz
+          path: out/zed-remote-server-freebsd-x86_64.gz
+
+      - name: Upload Artifacts to release
+        uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v1
+        if: ${{ !(contains(github.event.pull_request.labels.*.name, 'run-bundling')) }}
+        with:
+          draft: true
+          prerelease: ${{ env.RELEASE_CHANNEL == 'preview' }}
+          files: |
+            out/zed-remote-server-freebsd-x86_64.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
  nix-build:
    name: Build with Nix
    uses: ./.github/workflows/nix.yml
@@ -750,12 +811,12 @@ jobs:
    if: |
      startsWith(github.ref, 'refs/tags/v')
      && endsWith(github.ref, '-pre') && !endsWith(github.ref, '.0-pre')
-    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64]
+    needs: [bundle-mac, bundle-linux-x86_x64, bundle-linux-aarch64, freebsd]
    runs-on:
      - self-hosted
      - bundle
    steps:
      - name: gh release
-        run: gh release edit $GITHUB_REF_NAME --draft=true
+        run: gh release edit $GITHUB_REF_NAME --draft=false
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -167,6 +167,50 @@ jobs:
      - name: Upload Zed Nightly
        run: script/upload-nightly linux-targz

+  freebsd:
+    timeout-minutes: 60
+    if: github.repository_owner == 'zed-industries'
+    runs-on: github-8vcpu-ubuntu-2404
+    needs: tests
+    env:
+      DIGITALOCEAN_SPACES_ACCESS_KEY: ${{ secrets.DIGITALOCEAN_SPACES_ACCESS_KEY }}
+      DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
+    name: Build Zed on FreeBSD
+    # env:
+    #   MYTOKEN : ${{ secrets.MYTOKEN }}
+    #   MYTOKEN2: "value2"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build FreeBSD remote-server
+        id: freebsd-build
+        uses: vmactions/freebsd-vm@c3ae29a132c8ef1924775414107a97cac042aad5 # v1.2.0
+        with:
+          # envs: "MYTOKEN MYTOKEN2"
+          usesh: true
+          release: 13.5
+          copyback: true
+          prepare: |
+            pkg install -y \
+              bash curl jq git \
+              rustup-init cmake-core llvm-devel-lite pkgconf protobuf # ibx11 alsa-lib rust-bindgen-cli
+          run: |
+            freebsd-version
+            sysctl hw.model
+            sysctl hw.ncpu
+            sysctl hw.physmem
+            sysctl hw.usermem
+            git config --global --add safe.directory /home/runner/work/zed/zed
+            rustup-init --profile minimal --default-toolchain none -y
+            . "$HOME/.cargo/env"
+            ./script/bundle-freebsd
+            mkdir -p out/
+            mv "target/zed-remote-server-freebsd-x86_64.gz" out/
+            rm -rf target/
+            cargo clean
+
+      - name: Upload Zed Nightly
+        run: script/upload-nightly freebsd
+
  bundle-nix:
    name: Build and cache Nix package
    needs: tests
--- a/.github/workflows/unit_evals.yml
+++ b/.github/workflows/unit_evals.yml
@@ -66,7 +66,7 @@ jobs:
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

-      - name: Send the pull request link into the Slack channel
+      - name: Send failure message to Slack channel if needed
        if: ${{ failure() }}
        uses: slackapi/slack-github-action@b0fa283ad8fea605de13dc3f449259339835fc52
        with:
--- a/.zed/settings.json
+++ b/.zed/settings.json
@@ -47,6 +47,7 @@
  "remove_trailing_whitespace_on_save": true,
  "ensure_final_newline_on_save": true,
  "file_scan_exclusions": [
+    "crates/assistant_tools/src/evals/fixtures",
    "crates/eval/worktrees/",
    "crates/eval/repos/",
    "**/.git",
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -59,7 +59,7 @@ dependencies = [
 "assistant_slash_command",
 "assistant_slash_commands",
 "assistant_tool",
- "async-watch",
+ "assistant_tools",
 "audio",
 "buffer_diff",
 "chrono",
@@ -130,6 +130,7 @@ dependencies = [
 "urlencoding",
 "util",
 "uuid",
+ "watch",
 "workspace",
 "workspace-hack",
 "zed_actions",
@@ -147,7 +148,6 @@ dependencies = [
 "deepseek",
 "fs",
 "gpui",
- "indexmap",
 "language_model",
 "lmstudio",
 "log",
@@ -631,7 +631,6 @@ name = "assistant_tool"
 version = "0.1.0"
 dependencies = [
 "anyhow",
- "async-watch",
 "buffer_diff",
 "clock",
 "collections",
@@ -653,6 +652,7 @@ dependencies = [
 "settings",
 "text",
 "util",
+ "watch",
 "workspace",
 "workspace-hack",
 "zlog",
@@ -665,7 +665,6 @@ dependencies = [
 "agent_settings",
 "anyhow",
 "assistant_tool",
- "async-watch",
 "buffer_diff",
 "chrono",
 "client",
@@ -716,6 +715,7 @@ dependencies = [
 "ui",
 "unindent",
 "util",
+ "watch",
 "web_search",
 "which 6.0.3",
 "workspace",
@@ -1074,15 +1074,6 @@ dependencies = [
 "tungstenite 0.26.2",
 ]

-[[package]]
-name = "async-watch"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a078faf4e27c0c6cc0efb20e5da59dcccc04968ebf2801d8e0b2195124cdcdb2"
-dependencies = [
- "event-listener 2.5.3",
-]
-
 [[package]]
 name = "async_zip"
 version = "0.0.17"
@@ -2987,7 +2978,6 @@ dependencies = [
 "anyhow",
 "assistant_context_editor",
 "assistant_slash_command",
- "assistant_tool",
 "async-stripe",
 "async-trait",
 "async-tungstenite",
@@ -4234,6 +4224,7 @@ dependencies = [
 "futures 0.3.31",
 "fuzzy",
 "gpui",
+ "itertools 0.14.0",
 "language",
 "log",
 "menu",
@@ -5013,7 +5004,6 @@ dependencies = [
 "assistant_tool",
 "assistant_tools",
 "async-trait",
- "async-watch",
 "buffer_diff",
 "chrono",
 "clap",
@@ -5055,6 +5045,7 @@ dependencies = [
 "unindent",
 "util",
 "uuid",
+ "watch",
 "workspace-hack",
 "zed_llm_client",
 ]
@@ -8739,7 +8730,6 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
- "async-watch",
 "clock",
 "collections",
 "ctor",
@@ -8789,6 +8779,7 @@ dependencies = [
 "unicase",
 "unindent",
 "util",
+ "watch",
 "workspace-hack",
 "zlog",
 ]
@@ -10147,7 +10138,6 @@ dependencies = [
 "async-std",
 "async-tar",
 "async-trait",
- "async-watch",
 "futures 0.3.31",
 "http_client",
 "log",
@@ -10157,6 +10147,7 @@ dependencies = [
 "serde_json",
 "smol",
 "util",
+ "watch",
 "which 6.0.3",
 "workspace-hack",
 ]
@@ -10205,6 +10196,7 @@ dependencies = [
 "util",
 "workspace",
 "workspace-hack",
+ "zed_actions",
 ]

 [[package]]
@@ -13006,7 +12998,6 @@ dependencies = [
 "askpass",
 "assistant_tool",
 "assistant_tools",
- "async-watch",
 "backtrace",
 "cargo_toml",
 "chrono",
@@ -13053,6 +13044,7 @@ dependencies = [
 "toml 0.8.20",
 "unindent",
 "util",
+ "watch",
 "worktree",
 "zlog",
 ]
@@ -15732,6 +15724,7 @@ dependencies = [
 "task",
 "theme",
 "thiserror 2.0.12",
+ "url",
 "util",
 "windows 0.61.1",
 "workspace-hack",
@@ -17913,6 +17906,19 @@ dependencies = [
 "leb128",
 ]

+[[package]]
+name = "watch"
+version = "0.1.0"
+dependencies = [
+ "ctor",
+ "futures 0.3.31",
+ "gpui",
+ "parking_lot",
+ "rand 0.8.5",
+ "workspace-hack",
+ "zlog",
+]
+
 [[package]]
 name = "wayland-backend"
 version = "0.3.8"
@@ -19724,7 +19730,6 @@ dependencies = [
 "assistant_context_editor",
 "assistant_tool",
 "assistant_tools",
- "async-watch",
 "audio",
 "auto_update",
 "auto_update_ui",
@@ -19841,6 +19846,7 @@ dependencies = [
 "uuid",
 "vim",
 "vim_mode_setting",
+ "watch",
 "web_search",
 "web_search_providers",
 "welcome",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -165,6 +165,7 @@ members = [
    "crates/util_macros",
    "crates/vim",
    "crates/vim_mode_setting",
+    "crates/watch",
    "crates/web_search",
    "crates/web_search_providers",
    "crates/welcome",
@@ -373,6 +374,7 @@ util = { path = "crates/util" }
 util_macros = { path = "crates/util_macros" }
 vim = { path = "crates/vim" }
 vim_mode_setting = { path = "crates/vim_mode_setting" }
+watch = { path = "crates/watch" }
 web_search = { path = "crates/web_search" }
 web_search_providers = { path = "crates/web_search_providers" }
 welcome = { path = "crates/welcome" }
@@ -403,7 +405,6 @@ async-recursion = "1.0.0"
 async-tar = "0.5.0"
 async-trait = "0.1"
 async-tungstenite = "0.29.1"
-async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 aws-config = { version = "1.6.1", features = ["behavior-version-latest"] }
 aws-credential-types = { version = "1.2.2", features = [
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -35,7 +35,7 @@
      "ctrl-shift-f5": "debugger::Restart",
      "f6": "debugger::Pause",
      "f7": "debugger::StepOver",
-      "cmd-f11": "debugger::StepInto",
+      "ctrl-f11": "debugger::StepInto",
      "shift-f11": "debugger::StepOut",
      "f11": "zed::ToggleFullScreen",
      "ctrl-alt-z": "edit_prediction::RateCompletions",
@@ -59,7 +59,6 @@
      "tab": "editor::Tab",
      "shift-tab": "editor::Backtab",
      "ctrl-k": "editor::CutToEndOfLine",
-      // "ctrl-t": "editor::Transpose",
      "ctrl-k ctrl-q": "editor::Rewrap",
      "ctrl-k q": "editor::Rewrap",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
@@ -100,21 +99,16 @@
      "shift-down": "editor::SelectDown",
      "shift-left": "editor::SelectLeft",
      "shift-right": "editor::SelectRight",
-      "ctrl-shift-left": "editor::SelectToPreviousWordStart", // cursorWordLeftSelect
-      "ctrl-shift-right": "editor::SelectToNextWordEnd", // cursorWordRightSelect
+      "ctrl-shift-left": "editor::SelectToPreviousWordStart",
+      "ctrl-shift-right": "editor::SelectToNextWordEnd",
      "ctrl-shift-home": "editor::SelectToBeginning",
      "ctrl-shift-end": "editor::SelectToEnd",
      "ctrl-a": "editor::SelectAll",
      "ctrl-l": "editor::SelectLine",
      "ctrl-shift-i": "editor::Format",
      "alt-shift-o": "editor::OrganizeImports",
-      // "cmd-shift-left": ["editor::SelectToBeginningOfLine", {"stop_at_soft_wraps": true, "stop_at_indent": true }],
-      // "ctrl-shift-a": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
      "shift-home": ["editor::SelectToBeginningOfLine", { "stop_at_soft_wraps": true, "stop_at_indent": true }],
-      // "cmd-shift-right": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
-      // "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
      "ctrl-alt-space": "editor::ShowCharacterPalette",
      "ctrl-;": "editor::ToggleLineNumbers",
      "ctrl-'": "editor::ToggleSelectedDiffHunks",
@@ -140,7 +134,6 @@
      "find": "buffer_search::Deploy",
      "ctrl-f": "buffer_search::Deploy",
      "ctrl-h": "buffer_search::DeployReplace",
-      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
      "ctrl-alt-e": "editor::SelectEnclosingSymbol",
@@ -153,8 +146,7 @@
    "context": "Editor && mode == full && edit_prediction",
    "bindings": {
      "alt-]": "editor::NextEditPrediction",
-      "alt-[": "editor::PreviousEditPrediction",
-      "alt-right": "editor::AcceptPartialEditPrediction"
+      "alt-[": "editor::PreviousEditPrediction"
    }
  },
  {
@@ -219,7 +211,6 @@
      "ctrl-enter": "assistant::Assist",
      "ctrl-s": "workspace::Save",
      "save": "workspace::Save",
-      "ctrl->": "assistant::QuoteSelection",
      "ctrl-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
@@ -245,6 +236,7 @@
      "ctrl-shift-j": "agent::ToggleNavigationMenu",
      "ctrl-shift-i": "agent::ToggleOptionsMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "ctrl->": "assistant::QuoteSelection",
      "ctrl-alt-e": "agent::RemoveAllContext",
      "ctrl-shift-e": "project_panel::ToggleFocus",
      "ctrl-shift-enter": "agent::ContinueThread",
@@ -268,8 +260,8 @@
  {
    "context": "AgentPanel && prompt_editor",
    "bindings": {
-      "cmd-n": "agent::NewTextThread",
-      "cmd-alt-t": "agent::NewThread"
+      "ctrl-n": "agent::NewTextThread",
+      "ctrl-alt-t": "agent::NewThread"
    }
  },
  {
@@ -662,14 +654,16 @@
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
      "alt-l": "editor::AcceptEditPrediction",
-      "tab": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptEditPrediction",
+      "alt-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
    "context": "Editor && edit_prediction_conflict",
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
-      "alt-l": "editor::AcceptEditPrediction"
+      "alt-l": "editor::AcceptEditPrediction",
+      "alt-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -181,8 +181,7 @@
    "use_key_equivalents": true,
    "bindings": {
      "alt-tab": "editor::NextEditPrediction",
-      "alt-shift-tab": "editor::PreviousEditPrediction",
-      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
+      "alt-shift-tab": "editor::PreviousEditPrediction"
    }
  },
  {
@@ -253,7 +252,6 @@
    "bindings": {
      "cmd-enter": "assistant::Assist",
      "cmd-s": "workspace::Save",
-      "cmd->": "assistant::QuoteSelection",
      "cmd-<": "assistant::InsertIntoEditor",
      "shift-enter": "assistant::Split",
      "ctrl-r": "assistant::CycleMessageRole",
@@ -280,6 +278,7 @@
      "cmd-shift-j": "agent::ToggleNavigationMenu",
      "cmd-shift-i": "agent::ToggleOptionsMenu",
      "shift-alt-escape": "agent::ExpandMessageEditor",
+      "cmd->": "assistant::QuoteSelection",
      "cmd-alt-e": "agent::RemoveAllContext",
      "cmd-shift-e": "project_panel::ToggleFocus",
      "cmd-shift-enter": "agent::ContinueThread",
@@ -719,14 +718,16 @@
    "context": "Editor && edit_prediction",
    "bindings": {
      "alt-tab": "editor::AcceptEditPrediction",
-      "tab": "editor::AcceptEditPrediction"
+      "tab": "editor::AcceptEditPrediction",
+      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
    "context": "Editor && edit_prediction_conflict",
    "use_key_equivalents": true,
    "bindings": {
-      "alt-tab": "editor::AcceptEditPrediction"
+      "alt-tab": "editor::AcceptEditPrediction",
+      "ctrl-cmd-right": "editor::AcceptPartialEditPrediction"
    }
  },
  {
--- a/assets/keymaps/initial.json
+++ b/assets/keymaps/initial.json
@@ -13,9 +13,9 @@
    }
  },
  {
-    "context": "Editor",
+    "context": "Editor && vim_mode == insert && !menu",
    "bindings": {
-      // "j k": ["workspace::SendKeystrokes", "escape"]
+      // "j k": "vim::SwitchToNormalMode"
    }
  }
 ]
--- a/assets/keymaps/linux/sublime_text.json
+++ b/assets/keymaps/linux/sublime_text.json
@@ -38,7 +38,7 @@
      "ctrl-shift-d": "editor::DuplicateSelection",
      "alt-f3": "editor::SelectAllMatches", // find_all_under
      // "ctrl-f3": "", // find_under (cancels any selections)
-      // "cmd-alt-shift-g": "" // find_under_prev (cancels any selections)
+      // "ctrl-alt-shift-g": "" // find_under_prev (cancels any selections)
      "f9": "editor::SortLinesCaseSensitive",
      "ctrl-f9": "editor::SortLinesCaseInsensitive",
      "f12": "editor::GoToDefinition",
--- a/assets/keymaps/macos/cursor.json
+++ b/assets/keymaps/macos/cursor.json
@@ -28,7 +28,8 @@
    "context": "InlineAssistEditor",
    "use_key_equivalents": true,
    "bindings": {
-      "cmd-shift-backspace": "editor::Cancel"
+      "cmd-shift-backspace": "editor::Cancel",
+      "cmd-enter": "menu::Confirm"
      // "alt-enter": // Quick Question
      // "cmd-shift-enter": // Full File Context
      // "cmd-shift-k": // Toggle input focus (editor <> inline assist)
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -711,7 +711,7 @@
    }
  },
  {
-    "context": "GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel",
+    "context": "AgentPanel || GitPanel || ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView || DebugPanel",
    "bindings": {
      // window related commands (ctrl-w X)
      "ctrl-w": null,
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -101,9 +101,12 @@
    // The second option is decimal.
    "unit": "binary"
  },
-  // The key to use for adding multiple cursors
-  // Currently "alt" or "cmd_or_ctrl"  (also aliased as
-  // "cmd" and "ctrl") are supported.
+  // Determines the modifier to be used to add multiple cursors with the mouse. The open hover link mouse gestures will adapt such that it do not conflict with the multicursor modifier.
+  //
+  // 1. Maps to `Alt` on Linux and Windows and to `Option` on MacOS:
+  //    "alt"
+  // 2. Maps `Control` on Linux and Windows and to `Command` on MacOS:
+  //    "cmd_or_ctrl" (alias: "cmd", "ctrl")
  "multi_cursor_modifier": "alt",
  // Whether to enable vim modes and key bindings.
  "vim_mode": false,
@@ -214,6 +217,8 @@
  "show_signature_help_after_edits": false,
  // Whether to show code action button at start of buffer line.
  "inline_code_actions": true,
+  // Whether to allow drag and drop text selection in buffer.
+  "drag_and_drop_selection": true,
  // What to do when go to definition yields no results.
  //
  // 1. Do nothing: `none`
@@ -599,7 +604,9 @@
      // 2. Never show indent guides:
      //    "never"
      "show": "always"
-    }
+    },
+    /// Hide main root dir
+    "hide_root": false
  },
  "outline_panel": {
    // Whether to show the outline panel button in the status bar
@@ -771,7 +778,6 @@
        "tools": {
          "copy_path": true,
          "create_directory": true,
-          "create_file": true,
          "delete_path": true,
          "diagnostics": true,
          "edit_file": true,
@@ -1034,6 +1040,14 @@
    "button": true,
    // Whether to show warnings or not by default.
    "include_warnings": true,
+    // Settings for using LSP pull diagnostics mechanism in Zed.
+    "lsp_pull_diagnostics": {
+      // Whether to pull for diagnostics or not.
+      "enabled": true,
+      // Minimum time to wait before pulling diagnostics from the language server(s).
+      // 0 turns the debounce off.
+      "debounce_ms": 50
+    },
    // Settings for inline diagnostics
    "inline": {
      // Whether to show diagnostics inline or not
@@ -1457,7 +1471,9 @@
      "language_servers": ["erlang-ls", "!elp", "..."]
    },
    "Git Commit": {
-      "allow_rewrap": "anywhere"
+      "allow_rewrap": "anywhere",
+      "soft_wrap": "editor_width",
+      "preferred_line_length": 72
    },
    "Go": {
      "code_actions_on_format": {
@@ -1535,12 +1551,6 @@
        "allowed": true
      }
    },
-    "SQL": {
-      "prettier": {
-        "allowed": true,
-        "plugins": ["prettier-plugin-sql"]
-      }
-    },
    "Starlark": {
      "language_servers": ["starpls", "!buck2-lsp", "..."]
    },
--- a/assets/themes/ayu/ayu.json
+++ b/assets/themes/ayu/ayu.json
@@ -261,6 +261,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#bfbdb6ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d2a6ffff",
            "font_style": null,
@@ -316,6 +321,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#d2a6ffff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#5ac1feff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#a9d94bff",
            "font_style": null,
@@ -442,9 +457,9 @@
        "terminal.foreground": "#5c6166ff",
        "terminal.bright_foreground": "#5c6166ff",
        "terminal.dim_foreground": "#fcfcfcff",
-        "terminal.ansi.black": "#fcfcfcff",
-        "terminal.ansi.bright_black": "#bcbec0ff",
-        "terminal.ansi.dim_black": "#5c6166ff",
+        "terminal.ansi.black": "#5c6166ff",
+        "terminal.ansi.bright_black": "#3b9ee5ff",
+        "terminal.ansi.dim_black": "#9c9fa2ff",
        "terminal.ansi.red": "#ef7271ff",
        "terminal.ansi.bright_red": "#febab6ff",
        "terminal.ansi.dim_red": "#833538ff",
@@ -463,9 +478,9 @@
        "terminal.ansi.cyan": "#4dbf99ff",
        "terminal.ansi.bright_cyan": "#ace0cbff",
        "terminal.ansi.dim_cyan": "#2a5f4aff",
-        "terminal.ansi.white": "#5c6166ff",
-        "terminal.ansi.bright_white": "#5c6166ff",
-        "terminal.ansi.dim_white": "#9c9fa2ff",
+        "terminal.ansi.white": "#fcfcfcff",
+        "terminal.ansi.bright_white": "#fcfcfcff",
+        "terminal.ansi.dim_white": "#bcbec0ff",
        "link_text.hover": "#3b9ee5ff",
        "conflict": "#f1ad49ff",
        "conflict.background": "#ffeedaff",
@@ -632,6 +647,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#5c6166ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#a37accff",
            "font_style": null,
@@ -687,6 +707,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#a37accff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#3b9ee5ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#86b300ff",
            "font_style": null,
@@ -1003,6 +1033,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#cccac2ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#dfbfffff",
            "font_style": null,
@@ -1058,6 +1093,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#dfbfffff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#72cffeff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#d4fe7fff",
            "font_style": null,
--- a/assets/themes/gruvbox/gruvbox.json
+++ b/assets/themes/gruvbox/gruvbox.json
@@ -270,6 +270,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -325,6 +330,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -655,6 +670,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -710,6 +730,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -1040,6 +1070,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#d3869bff",
            "font_style": null,
@@ -1095,6 +1130,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#fabd2eff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#83a598ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#b8bb25ff",
            "font_style": null,
@@ -1227,9 +1272,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#fbf1c7ff",
-        "terminal.ansi.black": "#fbf1c7ff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#0b6678ff",
+        "terminal.ansi.dim_black": "#5f5650ff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -1248,9 +1293,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#fbf1c7ff",
+        "terminal.ansi.bright_white": "#fbf1c7ff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -1425,6 +1470,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -1480,6 +1530,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
@@ -1612,9 +1672,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#f9f5d7ff",
-        "terminal.ansi.black": "#f9f5d7ff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#73675eff",
+        "terminal.ansi.dim_black": "#f9f5d7ff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -1633,9 +1693,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#f9f5d7ff",
+        "terminal.ansi.bright_white": "#f9f5d7ff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -1810,6 +1870,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -1865,6 +1930,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
@@ -1997,9 +2072,9 @@
        "terminal.foreground": "#282828ff",
        "terminal.bright_foreground": "#282828ff",
        "terminal.dim_foreground": "#f2e5bcff",
-        "terminal.ansi.black": "#f2e5bcff",
-        "terminal.ansi.bright_black": "#b0a189ff",
-        "terminal.ansi.dim_black": "#282828ff",
+        "terminal.ansi.black": "#282828ff",
+        "terminal.ansi.bright_black": "#73675eff",
+        "terminal.ansi.dim_black": "#f2e5bcff",
        "terminal.ansi.red": "#9d0308ff",
        "terminal.ansi.bright_red": "#db8b7aff",
        "terminal.ansi.dim_red": "#4e1207ff",
@@ -2018,9 +2093,9 @@
        "terminal.ansi.cyan": "#437b59ff",
        "terminal.ansi.bright_cyan": "#9fbca8ff",
        "terminal.ansi.dim_cyan": "#253e2eff",
-        "terminal.ansi.white": "#282828ff",
-        "terminal.ansi.bright_white": "#282828ff",
-        "terminal.ansi.dim_white": "#73675eff",
+        "terminal.ansi.white": "#f2e5bcff",
+        "terminal.ansi.bright_white": "#f2e5bcff",
+        "terminal.ansi.dim_white": "#b0a189ff",
        "link_text.hover": "#0b6678ff",
        "version_control.added": "#797410ff",
        "version_control.modified": "#b57615ff",
@@ -2195,6 +2270,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#066578ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#8f3e71ff",
            "font_style": null,
@@ -2250,6 +2330,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#b57613ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#0b6678ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#79740eff",
            "font_style": null,
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -264,6 +264,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#dce0e5ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#bf956aff",
            "font_style": null,
@@ -319,6 +324,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#dfc184ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#74ade8ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#a1c181ff",
            "font_style": null,
@@ -450,9 +465,9 @@
        "terminal.foreground": "#242529ff",
        "terminal.bright_foreground": "#242529ff",
        "terminal.dim_foreground": "#fafafaff",
-        "terminal.ansi.black": "#fafafaff",
-        "terminal.ansi.bright_black": "#aaaaaaff",
-        "terminal.ansi.dim_black": "#242529ff",
+        "terminal.ansi.black": "#242529ff",
+        "terminal.ansi.bright_black": "#242529ff",
+        "terminal.ansi.dim_black": "#97979aff",
        "terminal.ansi.red": "#d36151ff",
        "terminal.ansi.bright_red": "#f0b0a4ff",
        "terminal.ansi.dim_red": "#6f312aff",
@@ -471,9 +486,9 @@
        "terminal.ansi.cyan": "#3a82b7ff",
        "terminal.ansi.bright_cyan": "#a3bedaff",
        "terminal.ansi.dim_cyan": "#254058ff",
-        "terminal.ansi.white": "#242529ff",
-        "terminal.ansi.bright_white": "#242529ff",
-        "terminal.ansi.dim_white": "#97979aff",
+        "terminal.ansi.white": "#fafafaff",
+        "terminal.ansi.bright_white": "#fafafaff",
+        "terminal.ansi.dim_white": "#aaaaaaff",
        "link_text.hover": "#5c78e2ff",
        "version_control.added": "#27a657ff",
        "version_control.modified": "#d3b020ff",
@@ -643,6 +658,11 @@
            "font_style": null,
            "font_weight": null
          },
+          "namespace": {
+            "color": "#242529ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "number": {
            "color": "#ad6e25ff",
            "font_style": null,
@@ -698,6 +718,16 @@
            "font_style": null,
            "font_weight": null
          },
+          "selector": {
+            "color": "#669f59ff",
+            "font_style": null,
+            "font_weight": null
+          },
+          "selector.pseudo": {
+            "color": "#5c78e2ff",
+            "font_style": null,
+            "font_weight": null
+          },
          "string": {
            "color": "#649f57ff",
            "font_style": null,
--- a/crates/agent/Cargo.toml
+++ b/crates/agent/Cargo.toml
@@ -25,7 +25,6 @@ assistant_context_editor.workspace = true
 assistant_slash_command.workspace = true
 assistant_slash_commands.workspace = true
 assistant_tool.workspace = true
-async-watch.workspace = true
 audio.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
@@ -95,6 +94,7 @@ ui_input.workspace = true
 urlencoding.workspace = true
 util.workspace = true
 uuid.workspace = true
+watch.workspace = true
 workspace-hack.workspace = true
 workspace.workspace = true
 zed_actions.workspace = true
@@ -102,6 +102,7 @@ zed_llm_client.workspace = true
 zstd.workspace = true

 [dev-dependencies]
+assistant_tools.workspace = true
 buffer_diff = { workspace = true, features = ["test-support"] }
 editor = { workspace = true, features = ["test-support"] }
 gpui = { workspace = true, "features" = ["test-support"] }
--- a/crates/agent/src/active_thread.rs
+++ b/crates/agent/src/active_thread.rs
@@ -1144,6 +1144,10 @@ impl ActiveThread {
                    cx,
                );
            }
+            ThreadEvent::ProfileChanged => {
+                self.save_thread(cx);
+                cx.notify();
+            }
        }
    }

--- a/crates/agent/src/agent.rs
+++ b/crates/agent/src/agent.rs
@@ -3,6 +3,7 @@ mod agent_configuration;
 mod agent_diff;
 mod agent_model_selector;
 mod agent_panel;
+mod agent_profile;
 mod buffer_codegen;
 mod context;
 mod context_picker;
--- a/crates/agent/src/agent_configuration/manage_profiles_modal.rs
+++ b/crates/agent/src/agent_configuration/manage_profiles_modal.rs
@@ -2,25 +2,21 @@ mod profile_modal_header;

 use std::sync::Arc;

-use agent_settings::{AgentProfile, AgentProfileId, AgentSettings, builtin_profiles};
+use agent_settings::{AgentProfileId, AgentSettings, builtin_profiles};
 use assistant_tool::ToolWorkingSet;
-use convert_case::{Case, Casing as _};
 use editor::Editor;
 use fs::Fs;
-use gpui::{
-    DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, WeakEntity,
-    prelude::*,
-};
-use settings::{Settings as _, update_settings_file};
+use gpui::{DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, Subscription, prelude::*};
+use settings::Settings as _;
 use ui::{
    KeyBinding, ListItem, ListItemSpacing, ListSeparator, Navigable, NavigableEntry, prelude::*,
 };
-use util::ResultExt as _;
 use workspace::{ModalView, Workspace};

 use crate::agent_configuration::manage_profiles_modal::profile_modal_header::ProfileModalHeader;
 use crate::agent_configuration::tool_picker::{ToolPicker, ToolPickerDelegate};
-use crate::{AgentPanel, ManageProfiles, ThreadStore};
+use crate::agent_profile::AgentProfile;
+use crate::{AgentPanel, ManageProfiles};

 use super::tool_picker::ToolPickerMode;

@@ -103,7 +99,6 @@ pub struct NewProfileMode {
 pub struct ManageProfilesModal {
    fs: Arc<dyn Fs>,
    tools: Entity<ToolWorkingSet>,
-    thread_store: WeakEntity<ThreadStore>,
    focus_handle: FocusHandle,
    mode: Mode,
 }
@@ -119,9 +114,8 @@ impl ManageProfilesModal {
                let fs = workspace.app_state().fs.clone();
                let thread_store = panel.read(cx).thread_store();
                let tools = thread_store.read(cx).tools();
-                let thread_store = thread_store.downgrade();
                workspace.toggle_modal(window, cx, |window, cx| {
-                    let mut this = Self::new(fs, tools, thread_store, window, cx);
+                    let mut this = Self::new(fs, tools, window, cx);

                    if let Some(profile_id) = action.customize_tools.clone() {
                        this.configure_builtin_tools(profile_id, window, cx);
@@ -136,7 +130,6 @@ impl ManageProfilesModal {
    pub fn new(
        fs: Arc<dyn Fs>,
        tools: Entity<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -145,7 +138,6 @@ impl ManageProfilesModal {
        Self {
            fs,
            tools,
-            thread_store,
            focus_handle,
            mode: Mode::choose_profile(window, cx),
        }
@@ -206,7 +198,6 @@ impl ManageProfilesModal {
                ToolPickerMode::McpTools,
                self.fs.clone(),
                self.tools.clone(),
-                self.thread_store.clone(),
                profile_id.clone(),
                profile,
                cx,
@@ -244,7 +235,6 @@ impl ManageProfilesModal {
                ToolPickerMode::BuiltinTools,
                self.fs.clone(),
                self.tools.clone(),
-                self.thread_store.clone(),
                profile_id.clone(),
                profile,
                cx,
@@ -270,32 +260,10 @@ impl ManageProfilesModal {
        match &self.mode {
            Mode::ChooseProfile { .. } => {}
            Mode::NewProfile(mode) => {
-                let settings = AgentSettings::get_global(cx);
-
-                let base_profile = mode
-                    .base_profile_id
-                    .as_ref()
-                    .and_then(|profile_id| settings.profiles.get(profile_id).cloned());
-
                let name = mode.name_editor.read(cx).text(cx);
-                let profile_id = AgentProfileId(name.to_case(Case::Kebab).into());

-                let profile = AgentProfile {
-                    name: name.into(),
-                    tools: base_profile
-                        .as_ref()
-                        .map(|profile| profile.tools.clone())
-                        .unwrap_or_default(),
-                    enable_all_context_servers: base_profile
-                        .as_ref()
-                        .map(|profile| profile.enable_all_context_servers)
-                        .unwrap_or_default(),
-                    context_servers: base_profile
-                        .map(|profile| profile.context_servers)
-                        .unwrap_or_default(),
-                };
-
-                self.create_profile(profile_id.clone(), profile, cx);
+                let profile_id =
+                    AgentProfile::create(name, mode.base_profile_id.clone(), self.fs.clone(), cx);
                self.view_profile(profile_id, window, cx);
            }
            Mode::ViewProfile(_) => {}
@@ -325,19 +293,6 @@ impl ManageProfilesModal {
            }
        }
    }
-
-    fn create_profile(
-        &self,
-        profile_id: AgentProfileId,
-        profile: AgentProfile,
-        cx: &mut Context<Self>,
-    ) {
-        update_settings_file::<AgentSettings>(self.fs.clone(), cx, {
-            move |settings, _cx| {
-                settings.create_profile(profile_id, profile).log_err();
-            }
-        });
-    }
 }

 impl ModalView for ManageProfilesModal {}
@@ -520,14 +475,13 @@ impl ManageProfilesModal {
    ) -> impl IntoElement {
        let settings = AgentSettings::get_global(cx);

-        let profile_id = &settings.default_profile;
        let profile_name = settings
            .profiles
            .get(&mode.profile_id)
            .map(|profile| profile.name.clone())
            .unwrap_or_else(|| "Unknown".into());

-        let icon = match profile_id.as_str() {
+        let icon = match mode.profile_id.as_str() {
            "write" => IconName::Pencil,
            "ask" => IconName::MessageBubbles,
            _ => IconName::UserRoundPen,
--- a/crates/agent/src/agent_configuration/tool_picker.rs
+++ b/crates/agent/src/agent_configuration/tool_picker.rs
@@ -1,19 +1,17 @@
 use std::{collections::BTreeMap, sync::Arc};

 use agent_settings::{
-    AgentProfile, AgentProfileContent, AgentProfileId, AgentSettings, AgentSettingsContent,
+    AgentProfileContent, AgentProfileId, AgentProfileSettings, AgentSettings, AgentSettingsContent,
    ContextServerPresetContent,
 };
 use assistant_tool::{ToolSource, ToolWorkingSet};
 use fs::Fs;
 use gpui::{App, Context, DismissEvent, Entity, EventEmitter, Focusable, Task, WeakEntity, Window};
 use picker::{Picker, PickerDelegate};
-use settings::{Settings as _, update_settings_file};
+use settings::update_settings_file;
 use ui::{ListItem, ListItemSpacing, prelude::*};
 use util::ResultExt as _;

-use crate::ThreadStore;
-
 pub struct ToolPicker {
    picker: Entity<Picker<ToolPickerDelegate>>,
 }
@@ -71,11 +69,10 @@ pub enum PickerItem {

 pub struct ToolPickerDelegate {
    tool_picker: WeakEntity<ToolPicker>,
-    thread_store: WeakEntity<ThreadStore>,
    fs: Arc<dyn Fs>,
    items: Arc<Vec<PickerItem>>,
    profile_id: AgentProfileId,
-    profile: AgentProfile,
+    profile_settings: AgentProfileSettings,
    filtered_items: Vec<PickerItem>,
    selected_index: usize,
    mode: ToolPickerMode,
@@ -86,20 +83,18 @@ impl ToolPickerDelegate {
        mode: ToolPickerMode,
        fs: Arc<dyn Fs>,
        tool_set: Entity<ToolWorkingSet>,
-        thread_store: WeakEntity<ThreadStore>,
        profile_id: AgentProfileId,
-        profile: AgentProfile,
+        profile_settings: AgentProfileSettings,
        cx: &mut Context<ToolPicker>,
    ) -> Self {
        let items = Arc::new(Self::resolve_items(mode, &tool_set, cx));

        Self {
            tool_picker: cx.entity().downgrade(),
-            thread_store,
            fs,
            items,
            profile_id,
-            profile,
+            profile_settings,
            filtered_items: Vec::new(),
            selected_index: 0,
            mode,
@@ -249,28 +244,31 @@ impl PickerDelegate for ToolPickerDelegate {
        };

        let is_currently_enabled = if let Some(server_id) = server_id.clone() {
-            let preset = self.profile.context_servers.entry(server_id).or_default();
+            let preset = self
+                .profile_settings
+                .context_servers
+                .entry(server_id)
+                .or_default();
            let is_enabled = *preset.tools.entry(tool_name.clone()).or_default();
            *preset.tools.entry(tool_name.clone()).or_default() = !is_enabled;
            is_enabled
        } else {
-            let is_enabled = *self.profile.tools.entry(tool_name.clone()).or_default();
-            *self.profile.tools.entry(tool_name.clone()).or_default() = !is_enabled;
+            let is_enabled = *self
+                .profile_settings
+                .tools
+                .entry(tool_name.clone())
+                .or_default();
+            *self
+                .profile_settings
+                .tools
+                .entry(tool_name.clone())
+                .or_default() = !is_enabled;
            is_enabled
        };

-        let active_profile_id = &AgentSettings::get_global(cx).default_profile;
-        if active_profile_id == &self.profile_id {
-            self.thread_store
-                .update(cx, |this, cx| {
-                    this.load_profile(self.profile.clone(), cx);
-                })
-                .log_err();
-        }
-
        update_settings_file::<AgentSettings>(self.fs.clone(), cx, {
            let profile_id = self.profile_id.clone();
-            let default_profile = self.profile.clone();
+            let default_profile = self.profile_settings.clone();
            let server_id = server_id.clone();
            let tool_name = tool_name.clone();
            move |settings: &mut AgentSettingsContent, _cx| {
@@ -348,14 +346,18 @@ impl PickerDelegate for ToolPickerDelegate {
            ),
            PickerItem::Tool { name, server_id } => {
                let is_enabled = if let Some(server_id) = server_id {
-                    self.profile
+                    self.profile_settings
                        .context_servers
                        .get(server_id.as_ref())
                        .and_then(|preset| preset.tools.get(name))
                        .copied()
-                        .unwrap_or(self.profile.enable_all_context_servers)
+                        .unwrap_or(self.profile_settings.enable_all_context_servers)
                } else {
-                    self.profile.tools.get(name).copied().unwrap_or(false)
+                    self.profile_settings
+                        .tools
+                        .get(name)
+                        .copied()
+                        .unwrap_or(false)
                };

                Some(
--- a/crates/agent/src/agent_diff.rs
+++ b/crates/agent/src/agent_diff.rs
@@ -1378,7 +1378,8 @@ impl AgentDiff {
            | ThreadEvent::CheckpointChanged
            | ThreadEvent::ToolConfirmationNeeded
            | ThreadEvent::ToolUseLimitReached
-            | ThreadEvent::CancelEditing => {}
+            | ThreadEvent::CancelEditing
+            | ThreadEvent::ProfileChanged => {}
        }
    }

--- a/crates/agent/src/agent_panel.rs
+++ b/crates/agent/src/agent_panel.rs
@@ -57,7 +57,7 @@ use zed_llm_client::{CompletionIntent, UsageLimit};
 use crate::active_thread::{self, ActiveThread, ActiveThreadEvent};
 use crate::agent_configuration::{AgentConfiguration, AssistantConfigurationEvent};
 use crate::agent_diff::AgentDiff;
-use crate::history_store::{HistoryStore, RecentEntry};
+use crate::history_store::{HistoryEntryId, HistoryStore};
 use crate::message_editor::{MessageEditor, MessageEditorEvent};
 use crate::thread::{Thread, ThreadError, ThreadId, ThreadSummary, TokenUsageRatio};
 use crate::thread_history::{HistoryEntryElement, ThreadHistory};
@@ -257,6 +257,7 @@ impl ActiveView {

    pub fn prompt_editor(
        context_editor: Entity<ContextEditor>,
+        history_store: Entity<HistoryStore>,
        language_registry: Arc<LanguageRegistry>,
        window: &mut Window,
        cx: &mut App,
@@ -322,6 +323,19 @@ impl ActiveView {
                            editor.set_text(summary, window, cx);
                        })
                    }
+                    ContextEvent::PathChanged { old_path, new_path } => {
+                        history_store.update(cx, |history_store, cx| {
+                            if let Some(old_path) = old_path {
+                                history_store
+                                    .replace_recently_opened_text_thread(old_path, new_path, cx);
+                            } else {
+                                history_store.push_recently_opened_entry(
+                                    HistoryEntryId::Context(new_path.clone()),
+                                    cx,
+                                );
+                            }
+                        });
+                    }
                    _ => {}
                }
            }),
@@ -516,8 +530,7 @@ impl AgentPanel {
            HistoryStore::new(
                thread_store.clone(),
                context_store.clone(),
-                [RecentEntry::Thread(thread_id, thread.clone())],
-                window,
+                [HistoryEntryId::Thread(thread_id)],
                cx,
            )
        });
@@ -544,7 +557,13 @@ impl AgentPanel {
                    editor.insert_default_prompt(window, cx);
                    editor
                });
-                ActiveView::prompt_editor(context_editor, language_registry.clone(), window, cx)
+                ActiveView::prompt_editor(
+                    context_editor,
+                    history_store.clone(),
+                    language_registry.clone(),
+                    window,
+                    cx,
+                )
            }
        };

@@ -581,86 +600,9 @@ impl AgentPanel {
            let panel = weak_panel.clone();
            let assistant_navigation_menu =
                ContextMenu::build_persistent(window, cx, move |mut menu, _window, cx| {
-                    let recently_opened = panel
-                        .update(cx, |this, cx| {
-                            this.history_store.update(cx, |history_store, cx| {
-                                history_store.recently_opened_entries(cx)
-                            })
-                        })
-                        .unwrap_or_default();
-
-                    if !recently_opened.is_empty() {
-                        menu = menu.header("Recently Opened");
-
-                        for entry in recently_opened.iter() {
-                            if let RecentEntry::Context(context) = entry {
-                                if context.read(cx).path().is_none() {
-                                    log::error!(
-                                        "bug: text thread in recent history list was never saved"
-                                    );
-                                    continue;
-                                }
-                            }
-
-                            let summary = entry.summary(cx);
-
-                            menu = menu.entry_with_end_slot_on_hover(
-                                summary,
-                                None,
-                                {
-                                    let panel = panel.clone();
-                                    let entry = entry.clone();
-                                    move |window, cx| {
-                                        panel
-                                            .update(cx, {
-                                                let entry = entry.clone();
-                                                move |this, cx| match entry {
-                                                    RecentEntry::Thread(_, thread) => {
-                                                        this.open_thread(thread, window, cx)
-                                                    }
-                                                    RecentEntry::Context(context) => {
-                                                        let Some(path) = context.read(cx).path()
-                                                        else {
-                                                            return;
-                                                        };
-                                                        this.open_saved_prompt_editor(
-                                                            path.clone(),
-                                                            window,
-                                                            cx,
-                                                        )
-                                                        .detach_and_log_err(cx)
-                                                    }
-                                                }
-                                            })
-                                            .ok();
-                                    }
-                                },
-                                IconName::Close,
-                                "Close Entry".into(),
-                                {
-                                    let panel = panel.clone();
-                                    let entry = entry.clone();
-                                    move |_window, cx| {
-                                        panel
-                                            .update(cx, |this, cx| {
-                                                this.history_store.update(
-                                                    cx,
-                                                    |history_store, cx| {
-                                                        history_store.remove_recently_opened_entry(
-                                                            &entry, cx,
-                                                        );
-                                                    },
-                                                );
-                                            })
-                                            .ok();
-                                    }
-                                },
-                            );
-                        }
-
-                        menu = menu.separator();
+                    if let Some(panel) = panel.upgrade() {
+                        menu = Self::populate_recently_opened_menu_section(menu, panel, cx);
                    }
-
                    menu.action("View All", Box::new(OpenHistory))
                        .end_slot_action(DeleteRecentlyOpenThread.boxed_clone())
                        .fixed_width(px(320.).into())
@@ -898,6 +840,7 @@ impl AgentPanel {
        self.set_active_view(
            ActiveView::prompt_editor(
                context_editor.clone(),
+                self.history_store.clone(),
                self.language_registry.clone(),
                window,
                cx,
@@ -984,7 +927,13 @@ impl AgentPanel {
            )
        });
        self.set_active_view(
-            ActiveView::prompt_editor(editor.clone(), self.language_registry.clone(), window, cx),
+            ActiveView::prompt_editor(
+                editor.clone(),
+                self.history_store.clone(),
+                self.language_registry.clone(),
+                window,
+                cx,
+            ),
            window,
            cx,
        );
@@ -1383,16 +1332,6 @@ impl AgentPanel {
                    }
                }
            }
-            ActiveView::TextThread { context_editor, .. } => {
-                let context = context_editor.read(cx).context();
-                // When switching away from an unsaved text thread, delete its entry.
-                if context.read(cx).path().is_none() {
-                    let context = context.clone();
-                    self.history_store.update(cx, |store, cx| {
-                        store.remove_recently_opened_entry(&RecentEntry::Context(context), cx);
-                    });
-                }
-            }
            _ => {}
        }

@@ -1400,13 +1339,14 @@ impl AgentPanel {
            ActiveView::Thread { thread, .. } => self.history_store.update(cx, |store, cx| {
                if let Some(thread) = thread.upgrade() {
                    let id = thread.read(cx).id().clone();
-                    store.push_recently_opened_entry(RecentEntry::Thread(id, thread), cx);
+                    store.push_recently_opened_entry(HistoryEntryId::Thread(id), cx);
                }
            }),
            ActiveView::TextThread { context_editor, .. } => {
                self.history_store.update(cx, |store, cx| {
-                    let context = context_editor.read(cx).context().clone();
-                    store.push_recently_opened_entry(RecentEntry::Context(context), cx)
+                    if let Some(path) = context_editor.read(cx).context().read(cx).path() {
+                        store.push_recently_opened_entry(HistoryEntryId::Context(path.clone()), cx)
+                    }
                })
            }
            _ => {}
@@ -1425,6 +1365,70 @@ impl AgentPanel {

        self.focus_handle(cx).focus(window);
    }
+
+    fn populate_recently_opened_menu_section(
+        mut menu: ContextMenu,
+        panel: Entity<Self>,
+        cx: &mut Context<ContextMenu>,
+    ) -> ContextMenu {
+        let entries = panel
+            .read(cx)
+            .history_store
+            .read(cx)
+            .recently_opened_entries(cx);
+
+        if entries.is_empty() {
+            return menu;
+        }
+
+        menu = menu.header("Recently Opened");
+
+        for entry in entries {
+            let title = entry.title().clone();
+            let id = entry.id();
+
+            menu = menu.entry_with_end_slot_on_hover(
+                title,
+                None,
+                {
+                    let panel = panel.downgrade();
+                    let id = id.clone();
+                    move |window, cx| {
+                        let id = id.clone();
+                        panel
+                            .update(cx, move |this, cx| match id {
+                                HistoryEntryId::Thread(id) => this
+                                    .open_thread_by_id(&id, window, cx)
+                                    .detach_and_log_err(cx),
+                                HistoryEntryId::Context(path) => this
+                                    .open_saved_prompt_editor(path.clone(), window, cx)
+                                    .detach_and_log_err(cx),
+                            })
+                            .ok();
+                    }
+                },
+                IconName::Close,
+                "Close Entry".into(),
+                {
+                    let panel = panel.downgrade();
+                    let id = id.clone();
+                    move |_window, cx| {
+                        panel
+                            .update(cx, |this, cx| {
+                                this.history_store.update(cx, |history_store, cx| {
+                                    history_store.remove_recently_opened_entry(&id, cx);
+                                });
+                            })
+                            .ok();
+                    }
+                },
+            );
+        }
+
+        menu = menu.separator();
+
+        menu
+    }
 }

 impl Focusable for AgentPanel {
--- a/crates/agent/src/agent_profile.rs
+++ b/crates/agent/src/agent_profile.rs
@@ -0,0 +1,334 @@
+use std::sync::Arc;
+
+use agent_settings::{AgentProfileId, AgentProfileSettings, AgentSettings};
+use assistant_tool::{Tool, ToolSource, ToolWorkingSet};
+use collections::IndexMap;
+use convert_case::{Case, Casing};
+use fs::Fs;
+use gpui::{App, Entity};
+use settings::{Settings, update_settings_file};
+use ui::SharedString;
+use util::ResultExt;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct AgentProfile {
+    id: AgentProfileId,
+    tool_set: Entity<ToolWorkingSet>,
+}
+
+pub type AvailableProfiles = IndexMap<AgentProfileId, SharedString>;
+
+impl AgentProfile {
+    pub fn new(id: AgentProfileId, tool_set: Entity<ToolWorkingSet>) -> Self {
+        Self { id, tool_set }
+    }
+
+    /// Saves a new profile to the settings.
+    pub fn create(
+        name: String,
+        base_profile_id: Option<AgentProfileId>,
+        fs: Arc<dyn Fs>,
+        cx: &App,
+    ) -> AgentProfileId {
+        let id = AgentProfileId(name.to_case(Case::Kebab).into());
+
+        let base_profile =
+            base_profile_id.and_then(|id| AgentSettings::get_global(cx).profiles.get(&id).cloned());
+
+        let profile_settings = AgentProfileSettings {
+            name: name.into(),
+            tools: base_profile
+                .as_ref()
+                .map(|profile| profile.tools.clone())
+                .unwrap_or_default(),
+            enable_all_context_servers: base_profile
+                .as_ref()
+                .map(|profile| profile.enable_all_context_servers)
+                .unwrap_or_default(),
+            context_servers: base_profile
+                .map(|profile| profile.context_servers)
+                .unwrap_or_default(),
+        };
+
+        update_settings_file::<AgentSettings>(fs, cx, {
+            let id = id.clone();
+            move |settings, _cx| {
+                settings.create_profile(id, profile_settings).log_err();
+            }
+        });
+
+        id
+    }
+
+    /// Returns a map of AgentProfileIds to their names
+    pub fn available_profiles(cx: &App) -> AvailableProfiles {
+        let mut profiles = AvailableProfiles::default();
+        for (id, profile) in AgentSettings::get_global(cx).profiles.iter() {
+            profiles.insert(id.clone(), profile.name.clone());
+        }
+        profiles
+    }
+
+    pub fn id(&self) -> &AgentProfileId {
+        &self.id
+    }
+
+    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
+        let Some(settings) = AgentSettings::get_global(cx).profiles.get(&self.id) else {
+            return Vec::new();
+        };
+
+        self.tool_set
+            .read(cx)
+            .tools(cx)
+            .into_iter()
+            .filter(|tool| Self::is_enabled(settings, tool.source(), tool.name()))
+            .collect()
+    }
+
+    fn is_enabled(settings: &AgentProfileSettings, source: ToolSource, name: String) -> bool {
+        match source {
+            ToolSource::Native => *settings.tools.get(name.as_str()).unwrap_or(&false),
+            ToolSource::ContextServer { id } => {
+                if settings.enable_all_context_servers {
+                    return true;
+                }
+
+                let Some(preset) = settings.context_servers.get(id.as_ref()) else {
+                    return false;
+                };
+                *preset.tools.get(name.as_str()).unwrap_or(&false)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use agent_settings::ContextServerPreset;
+    use assistant_tool::ToolRegistry;
+    use collections::IndexMap;
+    use gpui::{AppContext, TestAppContext};
+    use http_client::FakeHttpClient;
+    use project::Project;
+    use settings::{Settings, SettingsStore};
+    use ui::SharedString;
+
+    use super::*;
+
+    #[gpui::test]
+    async fn test_enabled_built_in_tools_for_profile(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId::default();
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings
+            .tools
+            .into_iter()
+            .filter_map(|(tool, enabled)| enabled.then_some(tool.to_string()))
+            // Provider dependent
+            .filter(|tool| tool != "web_search")
+            .collect::<Vec<_>>();
+        // Plus all registered MCP tools
+        expected_tools.extend(["enabled_mcp_tool".into(), "disabled_mcp_tool".into()]);
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    #[gpui::test]
+    async fn test_custom_mcp_settings(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId("custom_mcp".into());
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings.context_servers["mcp"]
+            .tools
+            .iter()
+            .filter_map(|(key, enabled)| enabled.then(|| key.to_string()))
+            .collect::<Vec<_>>();
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    #[gpui::test]
+    async fn test_only_built_in(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let id = AgentProfileId("write_minus_mcp".into());
+        let profile_settings = cx.read(|cx| {
+            AgentSettings::get_global(cx)
+                .profiles
+                .get(&id)
+                .unwrap()
+                .clone()
+        });
+        let tool_set = default_tool_set(cx);
+
+        let profile = AgentProfile::new(id.clone(), tool_set);
+
+        let mut enabled_tools = cx
+            .read(|cx| profile.enabled_tools(cx))
+            .into_iter()
+            .map(|tool| tool.name())
+            .collect::<Vec<_>>();
+        enabled_tools.sort();
+
+        let mut expected_tools = profile_settings
+            .tools
+            .into_iter()
+            .filter_map(|(tool, enabled)| enabled.then_some(tool.to_string()))
+            // Provider dependent
+            .filter(|tool| tool != "web_search")
+            .collect::<Vec<_>>();
+        expected_tools.sort();
+
+        assert_eq!(enabled_tools, expected_tools);
+    }
+
+    fn init_test_settings(cx: &mut TestAppContext) {
+        cx.update(|cx| {
+            let settings_store = SettingsStore::test(cx);
+            cx.set_global(settings_store);
+            Project::init_settings(cx);
+            AgentSettings::register(cx);
+            language_model::init_settings(cx);
+            ToolRegistry::default_global(cx);
+            assistant_tools::init(FakeHttpClient::with_404_response(), cx);
+        });
+
+        cx.update(|cx| {
+            let mut agent_settings = AgentSettings::get_global(cx).clone();
+            agent_settings.profiles.insert(
+                AgentProfileId("write_minus_mcp".into()),
+                AgentProfileSettings {
+                    name: "write_minus_mcp".into(),
+                    enable_all_context_servers: false,
+                    ..agent_settings.profiles[&AgentProfileId::default()].clone()
+                },
+            );
+            agent_settings.profiles.insert(
+                AgentProfileId("custom_mcp".into()),
+                AgentProfileSettings {
+                    name: "mcp".into(),
+                    tools: IndexMap::default(),
+                    enable_all_context_servers: false,
+                    context_servers: IndexMap::from_iter([("mcp".into(), context_server_preset())]),
+                },
+            );
+            AgentSettings::override_global(agent_settings, cx);
+        })
+    }
+
+    fn context_server_preset() -> ContextServerPreset {
+        ContextServerPreset {
+            tools: IndexMap::from_iter([
+                ("enabled_mcp_tool".into(), true),
+                ("disabled_mcp_tool".into(), false),
+            ]),
+        }
+    }
+
+    fn default_tool_set(cx: &mut TestAppContext) -> Entity<ToolWorkingSet> {
+        cx.new(|_| {
+            let mut tool_set = ToolWorkingSet::default();
+            tool_set.insert(Arc::new(FakeTool::new("enabled_mcp_tool", "mcp")));
+            tool_set.insert(Arc::new(FakeTool::new("disabled_mcp_tool", "mcp")));
+            tool_set
+        })
+    }
+
+    struct FakeTool {
+        name: String,
+        source: SharedString,
+    }
+
+    impl FakeTool {
+        fn new(name: impl Into<String>, source: impl Into<SharedString>) -> Self {
+            Self {
+                name: name.into(),
+                source: source.into(),
+            }
+        }
+    }
+
+    impl Tool for FakeTool {
+        fn name(&self) -> String {
+            self.name.clone()
+        }
+
+        fn source(&self) -> ToolSource {
+            ToolSource::ContextServer {
+                id: self.source.clone(),
+            }
+        }
+
+        fn description(&self) -> String {
+            unimplemented!()
+        }
+
+        fn icon(&self) -> ui::IconName {
+            unimplemented!()
+        }
+
+        fn needs_confirmation(&self, _input: &serde_json::Value, _cx: &App) -> bool {
+            unimplemented!()
+        }
+
+        fn ui_text(&self, _input: &serde_json::Value) -> String {
+            unimplemented!()
+        }
+
+        fn run(
+            self: Arc<Self>,
+            _input: serde_json::Value,
+            _request: Arc<language_model::LanguageModelRequest>,
+            _project: Entity<Project>,
+            _action_log: Entity<assistant_tool::ActionLog>,
+            _model: Arc<dyn language_model::LanguageModel>,
+            _window: Option<gpui::AnyWindowHandle>,
+            _cx: &mut App,
+        ) -> assistant_tool::ToolResult {
+            unimplemented!()
+        }
+
+        fn may_perform_edits(&self) -> bool {
+            unimplemented!()
+        }
+    }
+}
--- a/crates/agent/src/context_picker/completion_provider.rs
+++ b/crates/agent/src/context_picker/completion_provider.rs
@@ -1,7 +1,5 @@
-use std::cell::RefCell;
 use std::ops::Range;
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::atomic::AtomicBool;

@@ -767,7 +765,7 @@ impl CompletionProvider for ContextPickerCompletionProvider {

        let snapshot = buffer.read(cx).snapshot();
        let source_range = snapshot.anchor_before(state.source_range.start)
-            ..snapshot.anchor_before(state.source_range.end);
+            ..snapshot.anchor_after(state.source_range.end);

        let thread_store = self.thread_store.clone();
        let text_thread_store = self.text_thread_store.clone();
@@ -912,16 +910,6 @@ impl CompletionProvider for ContextPickerCompletionProvider {
        })
    }

-    fn resolve_completions(
-        &self,
-        _buffer: Entity<Buffer>,
-        _completion_indices: Vec<usize>,
-        _completions: Rc<RefCell<Box<[Completion]>>>,
-        _cx: &mut Context<Editor>,
-    ) -> Task<Result<bool>> {
-        Task::ready(Ok(true))
-    }
-
    fn is_completion_trigger(
        &self,
        buffer: &Entity<language::Buffer>,
@@ -1077,7 +1065,7 @@ mod tests {
    use project::{Project, ProjectPath};
    use serde_json::json;
    use settings::SettingsStore;
-    use std::ops::Deref;
+    use std::{ops::Deref, rc::Rc};
    use util::{path, separator};
    use workspace::{AppState, Item};

--- a/crates/agent/src/context_picker/thread_context_picker.rs
+++ b/crates/agent/src/context_picker/thread_context_picker.rs
@@ -282,15 +282,18 @@ pub fn unordered_thread_entries(
    text_thread_store: Entity<TextThreadStore>,
    cx: &App,
 ) -> impl Iterator<Item = (DateTime<Utc>, ThreadContextEntry)> {
-    let threads = thread_store.read(cx).unordered_threads().map(|thread| {
-        (
-            thread.updated_at,
-            ThreadContextEntry::Thread {
-                id: thread.id.clone(),
-                title: thread.summary.clone(),
-            },
-        )
-    });
+    let threads = thread_store
+        .read(cx)
+        .reverse_chronological_threads()
+        .map(|thread| {
+            (
+                thread.updated_at,
+                ThreadContextEntry::Thread {
+                    id: thread.id.clone(),
+                    title: thread.summary.clone(),
+                },
+            )
+        });

    let text_threads = text_thread_store
        .read(cx)
@@ -300,7 +303,7 @@ pub fn unordered_thread_entries(
                context.mtime.to_utc(),
                ThreadContextEntry::Context {
                    path: context.path.clone(),
-                    title: context.title.clone().into(),
+                    title: context.title.clone(),
                },
            )
        });
--- a/crates/agent/src/context_server_tool.rs
+++ b/crates/agent/src/context_server_tool.rs
@@ -104,7 +104,15 @@ impl Tool for ContextServerTool {
                    tool_name,
                    arguments
                );
-                let response = protocol.run_tool(tool_name, arguments).await?;
+                let response = protocol
+                    .request::<context_server::types::request::CallTool>(
+                        context_server::types::CallToolParams {
+                            name: tool_name,
+                            arguments,
+                            meta: None,
+                        },
+                    )
+                    .await?;

                let mut result = String::new();
                for content in response.content {
--- a/crates/agent/src/history_store.rs
+++ b/crates/agent/src/history_store.rs
@@ -1,18 +1,17 @@
 use std::{collections::VecDeque, path::Path, sync::Arc};

-use anyhow::Context as _;
-use assistant_context_editor::{AssistantContext, SavedContextMetadata};
+use anyhow::{Context as _, Result};
+use assistant_context_editor::SavedContextMetadata;
 use chrono::{DateTime, Utc};
-use futures::future::{TryFutureExt as _, join_all};
-use gpui::{Entity, Task, prelude::*};
+use gpui::{AsyncApp, Entity, SharedString, Task, prelude::*};
+use itertools::Itertools;
+use paths::contexts_dir;
 use serde::{Deserialize, Serialize};
-use smol::future::FutureExt;
 use std::time::Duration;
-use ui::{App, SharedString, Window};
+use ui::App;
 use util::ResultExt as _;

 use crate::{
-    Thread,
    thread::ThreadId,
    thread_store::{SerializedThreadMetadata, ThreadStore},
 };
@@ -41,52 +40,34 @@ impl HistoryEntry {
            HistoryEntry::Context(context) => HistoryEntryId::Context(context.path.clone()),
        }
    }
+
+    pub fn title(&self) -> &SharedString {
+        match self {
+            HistoryEntry::Thread(thread) => &thread.summary,
+            HistoryEntry::Context(context) => &context.title,
+        }
+    }
 }

 /// Generic identifier for a history entry.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub enum HistoryEntryId {
    Thread(ThreadId),
    Context(Arc<Path>),
 }

-#[derive(Clone, Debug)]
-pub(crate) enum RecentEntry {
-    Thread(ThreadId, Entity<Thread>),
-    Context(Entity<AssistantContext>),
-}
-
-impl PartialEq for RecentEntry {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Thread(l0, _), Self::Thread(r0, _)) => l0 == r0,
-            (Self::Context(l0), Self::Context(r0)) => l0 == r0,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for RecentEntry {}
-
-impl RecentEntry {
-    pub(crate) fn summary(&self, cx: &App) -> SharedString {
-        match self {
-            RecentEntry::Thread(_, thread) => thread.read(cx).summary().or_default(),
-            RecentEntry::Context(context) => context.read(cx).summary().or_default(),
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize)]
-enum SerializedRecentEntry {
+enum SerializedRecentOpen {
    Thread(String),
+    ContextName(String),
+    /// Old format which stores the full path
    Context(String),
 }

 pub struct HistoryStore {
    thread_store: Entity<ThreadStore>,
    context_store: Entity<assistant_context_editor::ContextStore>,
-    recently_opened_entries: VecDeque<RecentEntry>,
+    recently_opened_entries: VecDeque<HistoryEntryId>,
    _subscriptions: Vec<gpui::Subscription>,
    _save_recently_opened_entries_task: Task<()>,
 }
@@ -95,8 +76,7 @@ impl HistoryStore {
    pub fn new(
        thread_store: Entity<ThreadStore>,
        context_store: Entity<assistant_context_editor::ContextStore>,
-        initial_recent_entries: impl IntoIterator<Item = RecentEntry>,
-        window: &mut Window,
+        initial_recent_entries: impl IntoIterator<Item = HistoryEntryId>,
        cx: &mut Context<Self>,
    ) -> Self {
        let subscriptions = vec![
@@ -104,68 +84,20 @@ impl HistoryStore {
            cx.observe(&context_store, |_, _, cx| cx.notify()),
        ];

-        window
-            .spawn(cx, {
-                let thread_store = thread_store.downgrade();
-                let context_store = context_store.downgrade();
-                let this = cx.weak_entity();
-                async move |cx| {
-                    let path = paths::data_dir().join(NAVIGATION_HISTORY_PATH);
-                    let contents = cx
-                        .background_spawn(async move { std::fs::read_to_string(path) })
-                        .await
-                        .ok()?;
-                    let entries = serde_json::from_str::<Vec<SerializedRecentEntry>>(&contents)
-                        .context("deserializing persisted agent panel navigation history")
-                        .log_err()?
-                        .into_iter()
-                        .take(MAX_RECENTLY_OPENED_ENTRIES)
-                        .map(|serialized| match serialized {
-                            SerializedRecentEntry::Thread(id) => thread_store
-                                .update_in(cx, |thread_store, window, cx| {
-                                    let thread_id = ThreadId::from(id.as_str());
-                                    thread_store
-                                        .open_thread(&thread_id, window, cx)
-                                        .map_ok(|thread| RecentEntry::Thread(thread_id, thread))
-                                        .boxed()
-                                })
-                                .unwrap_or_else(|_| {
-                                    async {
-                                        anyhow::bail!("no thread store");
-                                    }
-                                    .boxed()
-                                }),
-                            SerializedRecentEntry::Context(id) => context_store
-                                .update(cx, |context_store, cx| {
-                                    context_store
-                                        .open_local_context(Path::new(&id).into(), cx)
-                                        .map_ok(RecentEntry::Context)
-                                        .boxed()
-                                })
-                                .unwrap_or_else(|_| {
-                                    async {
-                                        anyhow::bail!("no context store");
-                                    }
-                                    .boxed()
-                                }),
-                        });
-                    let entries = join_all(entries)
-                        .await
-                        .into_iter()
-                        .filter_map(|result| result.log_with_level(log::Level::Debug))
-                        .collect::<VecDeque<_>>();
-
-                    this.update(cx, |this, _| {
-                        this.recently_opened_entries.extend(entries);
-                        this.recently_opened_entries
-                            .truncate(MAX_RECENTLY_OPENED_ENTRIES);
-                    })
-                    .ok();
-
-                    Some(())
-                }
+        cx.spawn(async move |this, cx| {
+            let entries = Self::load_recently_opened_entries(cx).await.log_err()?;
+            this.update(cx, |this, _| {
+                this.recently_opened_entries
+                    .extend(
+                        entries.into_iter().take(
+                            MAX_RECENTLY_OPENED_ENTRIES
+                                .saturating_sub(this.recently_opened_entries.len()),
+                        ),
+                    );
            })
-            .detach();
+            .ok()
+        })
+        .detach();

        Self {
            thread_store,
@@ -184,19 +116,20 @@ impl HistoryStore {
            return history_entries;
        }

-        for thread in self
-            .thread_store
-            .update(cx, |this, _cx| this.reverse_chronological_threads())
-        {
-            history_entries.push(HistoryEntry::Thread(thread));
-        }
-
-        for context in self
-            .context_store
-            .update(cx, |this, _cx| this.reverse_chronological_contexts())
-        {
-            history_entries.push(HistoryEntry::Context(context));
-        }
+        history_entries.extend(
+            self.thread_store
+                .read(cx)
+                .reverse_chronological_threads()
+                .cloned()
+                .map(HistoryEntry::Thread),
+        );
+        history_entries.extend(
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .cloned()
+                .map(HistoryEntry::Context),
+        );

        history_entries.sort_unstable_by_key(|entry| std::cmp::Reverse(entry.updated_at()));
        history_entries
@@ -206,15 +139,62 @@ impl HistoryStore {
        self.entries(cx).into_iter().take(limit).collect()
    }

+    pub fn recently_opened_entries(&self, cx: &App) -> Vec<HistoryEntry> {
+        #[cfg(debug_assertions)]
+        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
+            return Vec::new();
+        }
+
+        let thread_entries = self
+            .thread_store
+            .read(cx)
+            .reverse_chronological_threads()
+            .flat_map(|thread| {
+                self.recently_opened_entries
+                    .iter()
+                    .enumerate()
+                    .flat_map(|(index, entry)| match entry {
+                        HistoryEntryId::Thread(id) if &thread.id == id => {
+                            Some((index, HistoryEntry::Thread(thread.clone())))
+                        }
+                        _ => None,
+                    })
+            });
+
+        let context_entries =
+            self.context_store
+                .read(cx)
+                .unordered_contexts()
+                .flat_map(|context| {
+                    self.recently_opened_entries
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(index, entry)| match entry {
+                            HistoryEntryId::Context(path) if &context.path == path => {
+                                Some((index, HistoryEntry::Context(context.clone())))
+                            }
+                            _ => None,
+                        })
+                });
+
+        thread_entries
+            .chain(context_entries)
+            // optimization to halt iteration early
+            .take(self.recently_opened_entries.len())
+            .sorted_unstable_by_key(|(index, _)| *index)
+            .map(|(_, entry)| entry)
+            .collect()
+    }
+
    fn save_recently_opened_entries(&mut self, cx: &mut Context<Self>) {
        let serialized_entries = self
            .recently_opened_entries
            .iter()
            .filter_map(|entry| match entry {
-                RecentEntry::Context(context) => Some(SerializedRecentEntry::Context(
-                    context.read(cx).path()?.to_str()?.to_owned(),
-                )),
-                RecentEntry::Thread(id, _) => Some(SerializedRecentEntry::Thread(id.to_string())),
+                HistoryEntryId::Context(path) => path.file_name().map(|file| {
+                    SerializedRecentOpen::ContextName(file.to_string_lossy().to_string())
+                }),
+                HistoryEntryId::Thread(id) => Some(SerializedRecentOpen::Thread(id.to_string())),
            })
            .collect::<Vec<_>>();

@@ -233,7 +213,33 @@ impl HistoryStore {
        });
    }

-    pub fn push_recently_opened_entry(&mut self, entry: RecentEntry, cx: &mut Context<Self>) {
+    fn load_recently_opened_entries(cx: &AsyncApp) -> Task<Result<Vec<HistoryEntryId>>> {
+        cx.background_spawn(async move {
+            let path = paths::data_dir().join(NAVIGATION_HISTORY_PATH);
+            let contents = smol::fs::read_to_string(path).await?;
+            let entries = serde_json::from_str::<Vec<SerializedRecentOpen>>(&contents)
+                .context("deserializing persisted agent panel navigation history")?
+                .into_iter()
+                .take(MAX_RECENTLY_OPENED_ENTRIES)
+                .flat_map(|entry| match entry {
+                    SerializedRecentOpen::Thread(id) => {
+                        Some(HistoryEntryId::Thread(id.as_str().into()))
+                    }
+                    SerializedRecentOpen::ContextName(file_name) => Some(HistoryEntryId::Context(
+                        contexts_dir().join(file_name).into(),
+                    )),
+                    SerializedRecentOpen::Context(path) => {
+                        Path::new(&path).file_name().map(|file_name| {
+                            HistoryEntryId::Context(contexts_dir().join(file_name).into())
+                        })
+                    }
+                })
+                .collect::<Vec<_>>();
+            Ok(entries)
+        })
+    }
+
+    pub fn push_recently_opened_entry(&mut self, entry: HistoryEntryId, cx: &mut Context<Self>) {
        self.recently_opened_entries
            .retain(|old_entry| old_entry != &entry);
        self.recently_opened_entries.push_front(entry);
@@ -244,24 +250,33 @@ impl HistoryStore {

    pub fn remove_recently_opened_thread(&mut self, id: ThreadId, cx: &mut Context<Self>) {
        self.recently_opened_entries.retain(|entry| match entry {
-            RecentEntry::Thread(thread_id, _) if thread_id == &id => false,
+            HistoryEntryId::Thread(thread_id) if thread_id == &id => false,
            _ => true,
        });
        self.save_recently_opened_entries(cx);
    }

-    pub fn remove_recently_opened_entry(&mut self, entry: &RecentEntry, cx: &mut Context<Self>) {
+    pub fn replace_recently_opened_text_thread(
+        &mut self,
+        old_path: &Path,
+        new_path: &Arc<Path>,
+        cx: &mut Context<Self>,
+    ) {
+        for entry in &mut self.recently_opened_entries {
+            match entry {
+                HistoryEntryId::Context(path) if path.as_ref() == old_path => {
+                    *entry = HistoryEntryId::Context(new_path.clone());
+                    break;
+                }
+                _ => {}
+            }
+        }
+        self.save_recently_opened_entries(cx);
+    }
+
+    pub fn remove_recently_opened_entry(&mut self, entry: &HistoryEntryId, cx: &mut Context<Self>) {
        self.recently_opened_entries
            .retain(|old_entry| old_entry != entry);
        self.save_recently_opened_entries(cx);
    }
-
-    pub fn recently_opened_entries(&self, _cx: &mut Context<Self>) -> VecDeque<RecentEntry> {
-        #[cfg(debug_assertions)]
-        if std::env::var("ZED_SIMULATE_NO_THREAD_HISTORY").is_ok() {
-            return VecDeque::new();
-        }
-
-        self.recently_opened_entries.clone()
-    }
 }
--- a/crates/agent/src/inline_assistant.rs
+++ b/crates/agent/src/inline_assistant.rs
@@ -1011,7 +1011,7 @@ impl InlineAssistant {
                        self.update_editor_highlights(&editor, cx);
                    }
                } else {
-                    entry.get().highlight_updates.send(()).ok();
+                    entry.get_mut().highlight_updates.send(()).ok();
                }
            }

@@ -1519,7 +1519,7 @@ impl InlineAssistant {
 struct EditorInlineAssists {
    assist_ids: Vec<InlineAssistId>,
    scroll_lock: Option<InlineAssistScrollLock>,
-    highlight_updates: async_watch::Sender<()>,
+    highlight_updates: watch::Sender<()>,
    _update_highlights: Task<Result<()>>,
    _subscriptions: Vec<gpui::Subscription>,
 }
@@ -1531,7 +1531,7 @@ struct InlineAssistScrollLock {

 impl EditorInlineAssists {
    fn new(editor: &Entity<Editor>, window: &mut Window, cx: &mut App) -> Self {
-        let (highlight_updates_tx, mut highlight_updates_rx) = async_watch::channel(());
+        let (highlight_updates_tx, mut highlight_updates_rx) = watch::channel(());
        Self {
            assist_ids: Vec::new(),
            scroll_lock: None,
@@ -1689,7 +1689,7 @@ impl InlineAssist {
                        if let Some(editor) = editor.upgrade() {
                            InlineAssistant::update_global(cx, |this, cx| {
                                if let Some(editor_assists) =
-                                    this.assists_by_editor.get(&editor.downgrade())
+                                    this.assists_by_editor.get_mut(&editor.downgrade())
                                {
                                    editor_assists.highlight_updates.send(()).ok();
                                }
--- a/crates/agent/src/message_editor.rs
+++ b/crates/agent/src/message_editor.rs
@@ -175,8 +175,7 @@ impl MessageEditor {
            )
        });

-        let incompatible_tools =
-            cx.new(|cx| IncompatibleToolsState::new(thread.read(cx).tools().clone(), cx));
+        let incompatible_tools = cx.new(|cx| IncompatibleToolsState::new(thread.clone(), cx));

        let subscriptions = vec![
            cx.subscribe_in(&context_strip, window, Self::handle_context_strip_event),
@@ -204,15 +203,8 @@ impl MessageEditor {
            )
        });

-        let profile_selector = cx.new(|cx| {
-            ProfileSelector::new(
-                fs,
-                thread.clone(),
-                thread_store,
-                editor.focus_handle(cx),
-                cx,
-            )
-        });
+        let profile_selector =
+            cx.new(|cx| ProfileSelector::new(fs, thread.clone(), editor.focus_handle(cx), cx));

        Self {
            editor: editor.clone(),
--- a/crates/agent/src/profile_selector.rs
+++ b/crates/agent/src/profile_selector.rs
@@ -1,26 +1,24 @@
 use std::sync::Arc;

-use agent_settings::{
-    AgentDockPosition, AgentProfile, AgentProfileId, AgentSettings, GroupedAgentProfiles,
-    builtin_profiles,
-};
+use agent_settings::{AgentDockPosition, AgentProfileId, AgentSettings, builtin_profiles};
 use fs::Fs;
-use gpui::{Action, Empty, Entity, FocusHandle, Subscription, WeakEntity, prelude::*};
+use gpui::{Action, Empty, Entity, FocusHandle, Subscription, prelude::*};
 use language_model::LanguageModelRegistry;
 use settings::{Settings as _, SettingsStore, update_settings_file};
 use ui::{
    ContextMenu, ContextMenuEntry, DocumentationSide, PopoverMenu, PopoverMenuHandle, Tooltip,
    prelude::*,
 };
-use util::ResultExt as _;

-use crate::{ManageProfiles, Thread, ThreadStore, ToggleProfileSelector};
+use crate::{
+    ManageProfiles, Thread, ToggleProfileSelector,
+    agent_profile::{AgentProfile, AvailableProfiles},
+};

 pub struct ProfileSelector {
-    profiles: GroupedAgentProfiles,
+    profiles: AvailableProfiles,
    fs: Arc<dyn Fs>,
    thread: Entity<Thread>,
-    thread_store: WeakEntity<ThreadStore>,
    menu_handle: PopoverMenuHandle<ContextMenu>,
    focus_handle: FocusHandle,
    _subscriptions: Vec<Subscription>,
@@ -30,7 +28,6 @@ impl ProfileSelector {
    pub fn new(
        fs: Arc<dyn Fs>,
        thread: Entity<Thread>,
-        thread_store: WeakEntity<ThreadStore>,
        focus_handle: FocusHandle,
        cx: &mut Context<Self>,
    ) -> Self {
@@ -39,10 +36,9 @@ impl ProfileSelector {
        });

        Self {
-            profiles: GroupedAgentProfiles::from_settings(AgentSettings::get_global(cx)),
+            profiles: AgentProfile::available_profiles(cx),
            fs,
            thread,
-            thread_store,
            menu_handle: PopoverMenuHandle::default(),
            focus_handle,
            _subscriptions: vec![settings_subscription],
@@ -54,7 +50,7 @@ impl ProfileSelector {
    }

    fn refresh_profiles(&mut self, cx: &mut Context<Self>) {
-        self.profiles = GroupedAgentProfiles::from_settings(AgentSettings::get_global(cx));
+        self.profiles = AgentProfile::available_profiles(cx);
    }

    fn build_context_menu(
@@ -64,21 +60,30 @@ impl ProfileSelector {
    ) -> Entity<ContextMenu> {
        ContextMenu::build(window, cx, |mut menu, _window, cx| {
            let settings = AgentSettings::get_global(cx);
-            for (profile_id, profile) in self.profiles.builtin.iter() {
+
+            let mut found_non_builtin = false;
+            for (profile_id, profile_name) in self.profiles.iter() {
+                if !builtin_profiles::is_builtin(profile_id) {
+                    found_non_builtin = true;
+                    continue;
+                }
                menu = menu.item(self.menu_entry_for_profile(
                    profile_id.clone(),
-                    profile,
+                    profile_name,
                    settings,
                    cx,
                ));
            }

-            if !self.profiles.custom.is_empty() {
+            if found_non_builtin {
                menu = menu.separator().header("Custom Profiles");
-                for (profile_id, profile) in self.profiles.custom.iter() {
+                for (profile_id, profile_name) in self.profiles.iter() {
+                    if builtin_profiles::is_builtin(profile_id) {
+                        continue;
+                    }
                    menu = menu.item(self.menu_entry_for_profile(
                        profile_id.clone(),
-                        profile,
+                        profile_name,
                        settings,
                        cx,
                    ));
@@ -99,19 +104,20 @@ impl ProfileSelector {
    fn menu_entry_for_profile(
        &self,
        profile_id: AgentProfileId,
-        profile: &AgentProfile,
+        profile_name: &SharedString,
        settings: &AgentSettings,
-        _cx: &App,
+        cx: &App,
    ) -> ContextMenuEntry {
-        let documentation = match profile.name.to_lowercase().as_str() {
+        let documentation = match profile_name.to_lowercase().as_str() {
            builtin_profiles::WRITE => Some("Get help to write anything."),
            builtin_profiles::ASK => Some("Chat about your codebase."),
            builtin_profiles::MINIMAL => Some("Chat about anything with no tools."),
            _ => None,
        };
+        let thread_profile_id = self.thread.read(cx).profile().id();

-        let entry = ContextMenuEntry::new(profile.name.clone())
-            .toggleable(IconPosition::End, profile_id == settings.default_profile);
+        let entry = ContextMenuEntry::new(profile_name.clone())
+            .toggleable(IconPosition::End, &profile_id == thread_profile_id);

        let entry = if let Some(doc_text) = documentation {
            entry.documentation_aside(documentation_side(settings.dock), move |_| {
@@ -123,7 +129,7 @@ impl ProfileSelector {

        entry.handler({
            let fs = self.fs.clone();
-            let thread_store = self.thread_store.clone();
+            let thread = self.thread.clone();
            let profile_id = profile_id.clone();
            move |_window, cx| {
                update_settings_file::<AgentSettings>(fs.clone(), cx, {
@@ -133,11 +139,9 @@ impl ProfileSelector {
                    }
                });

-                thread_store
-                    .update(cx, |this, cx| {
-                        this.load_profile_by_id(profile_id.clone(), cx);
-                    })
-                    .log_err();
+                thread.update(cx, |this, cx| {
+                    this.set_profile(profile_id.clone(), cx);
+                });
            }
        })
    }
@@ -146,7 +150,7 @@ impl ProfileSelector {
 impl Render for ProfileSelector {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let settings = AgentSettings::get_global(cx);
-        let profile_id = &settings.default_profile;
+        let profile_id = self.thread.read(cx).profile().id();
        let profile = settings.profiles.get(profile_id);

        let selected_profile = profile
--- a/crates/agent/src/thread.rs
+++ b/crates/agent/src/thread.rs
@@ -4,7 +4,7 @@ use std::ops::Range;
 use std::sync::Arc;
 use std::time::Instant;

-use agent_settings::{AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, AgentSettings, CompletionMode};
 use anyhow::{Result, anyhow};
 use assistant_tool::{ActionLog, AnyToolCard, Tool, ToolWorkingSet};
 use chrono::{DateTime, Utc};
@@ -41,6 +41,7 @@ use uuid::Uuid;
 use zed_llm_client::{CompletionIntent, CompletionRequestStatus};

 use crate::ThreadStore;
+use crate::agent_profile::AgentProfile;
 use crate::context::{AgentContext, AgentContextHandle, ContextLoadResult, LoadedContext};
 use crate::thread_store::{
    SerializedCrease, SerializedLanguageModel, SerializedMessage, SerializedMessageSegment,
@@ -360,6 +361,7 @@ pub struct Thread {
    >,
    remaining_turns: u32,
    configured_model: Option<ConfiguredModel>,
+    profile: AgentProfile,
 }

 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -407,6 +409,7 @@ impl Thread {
    ) -> Self {
        let (detailed_summary_tx, detailed_summary_rx) = postage::watch::channel();
        let configured_model = LanguageModelRegistry::read_global(cx).default_model();
+        let profile_id = AgentSettings::get_global(cx).default_profile.clone();

        Self {
            id: ThreadId::new(),
@@ -449,6 +452,7 @@ impl Thread {
            request_callback: None,
            remaining_turns: u32::MAX,
            configured_model,
+            profile: AgentProfile::new(profile_id, tools),
        }
    }

@@ -495,6 +499,9 @@ impl Thread {
        let completion_mode = serialized
            .completion_mode
            .unwrap_or_else(|| AgentSettings::get_global(cx).preferred_completion_mode);
+        let profile_id = serialized
+            .profile
+            .unwrap_or_else(|| AgentSettings::get_global(cx).default_profile.clone());

        Self {
            id,
@@ -554,7 +561,7 @@ impl Thread {
            pending_checkpoint: None,
            project: project.clone(),
            prompt_builder,
-            tools,
+            tools: tools.clone(),
            tool_use,
            action_log: cx.new(|_| ActionLog::new(project)),
            initial_project_snapshot: Task::ready(serialized.initial_project_snapshot).shared(),
@@ -570,6 +577,7 @@ impl Thread {
            request_callback: None,
            remaining_turns: u32::MAX,
            configured_model,
+            profile: AgentProfile::new(profile_id, tools),
        }
    }

@@ -585,6 +593,17 @@ impl Thread {
        &self.id
    }

+    pub fn profile(&self) -> &AgentProfile {
+        &self.profile
+    }
+
+    pub fn set_profile(&mut self, id: AgentProfileId, cx: &mut Context<Self>) {
+        if &id != self.profile.id() {
+            self.profile = AgentProfile::new(id, self.tools.clone());
+            cx.emit(ThreadEvent::ProfileChanged);
+        }
+    }
+
    pub fn is_empty(&self) -> bool {
        self.messages.is_empty()
    }
@@ -919,8 +938,7 @@ impl Thread {
        model: Arc<dyn LanguageModel>,
    ) -> Vec<LanguageModelRequestTool> {
        if model.supports_tools() {
-            self.tools()
-                .read(cx)
+            self.profile
                .enabled_tools(cx)
                .into_iter()
                .filter_map(|tool| {
@@ -1180,6 +1198,7 @@ impl Thread {
                    }),
                completion_mode: Some(this.completion_mode),
                tool_use_limit_reached: this.tool_use_limit_reached,
+                profile: Some(this.profile.id().clone()),
            })
        })
    }
@@ -2121,7 +2140,7 @@ impl Thread {
        window: Option<AnyWindowHandle>,
        cx: &mut Context<Thread>,
    ) {
-        let available_tools = self.tools.read(cx).enabled_tools(cx);
+        let available_tools = self.profile.enabled_tools(cx);

        let tool_list = available_tools
            .iter()
@@ -2213,19 +2232,15 @@ impl Thread {
    ) -> Task<()> {
        let tool_name: Arc<str> = tool.name().into();

-        let tool_result = if self.tools.read(cx).is_disabled(&tool.source(), &tool_name) {
-            Task::ready(Err(anyhow!("tool is disabled: {tool_name}"))).into()
-        } else {
-            tool.run(
-                input,
-                request,
-                self.project.clone(),
-                self.action_log.clone(),
-                model,
-                window,
-                cx,
-            )
-        };
+        let tool_result = tool.run(
+            input,
+            request,
+            self.project.clone(),
+            self.action_log.clone(),
+            model,
+            window,
+            cx,
+        );

        // Store the card separately if it exists
        if let Some(card) = tool_result.card.clone() {
@@ -2344,8 +2359,7 @@ impl Thread {
        let client = self.project.read(cx).client();

        let enabled_tool_names: Vec<String> = self
-            .tools()
-            .read(cx)
+            .profile
            .enabled_tools(cx)
            .iter()
            .map(|tool| tool.name())
@@ -2858,6 +2872,7 @@ pub enum ThreadEvent {
    ToolUseLimitReached,
    CancelEditing,
    CompletionCanceled,
+    ProfileChanged,
 }

 impl EventEmitter<ThreadEvent> for Thread {}
@@ -2872,7 +2887,7 @@ struct PendingCompletion {
 mod tests {
    use super::*;
    use crate::{ThreadStore, context::load_context, context_store::ContextStore, thread_store};
-    use agent_settings::{AgentSettings, LanguageModelParameters};
+    use agent_settings::{AgentProfileId, AgentSettings, LanguageModelParameters};
    use assistant_tool::ToolRegistry;
    use editor::EditorSettings;
    use gpui::TestAppContext;
@@ -3285,6 +3300,71 @@ fn main() {{
        );
    }

+    #[gpui::test]
+    async fn test_storing_profile_setting_per_thread(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, thread_store, thread, _context_store, _model) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Check that we are starting with the default profile
+        let profile = cx.read(|cx| thread.read(cx).profile.clone());
+        let tool_set = cx.read(|cx| thread_store.read(cx).tools());
+        assert_eq!(
+            profile,
+            AgentProfile::new(AgentProfileId::default(), tool_set)
+        );
+    }
+
+    #[gpui::test]
+    async fn test_serializing_thread_profile(cx: &mut TestAppContext) {
+        init_test_settings(cx);
+
+        let project = create_test_project(
+            cx,
+            json!({"code.rs": "fn main() {\n    println!(\"Hello, world!\");\n}"}),
+        )
+        .await;
+
+        let (_workspace, thread_store, thread, _context_store, _model) =
+            setup_test_environment(cx, project.clone()).await;
+
+        // Profile gets serialized with default values
+        let serialized = thread
+            .update(cx, |thread, cx| thread.serialize(cx))
+            .await
+            .unwrap();
+
+        assert_eq!(serialized.profile, Some(AgentProfileId::default()));
+
+        let deserialized = cx.update(|cx| {
+            thread.update(cx, |thread, cx| {
+                Thread::deserialize(
+                    thread.id.clone(),
+                    serialized,
+                    thread.project.clone(),
+                    thread.tools.clone(),
+                    thread.prompt_builder.clone(),
+                    thread.project_context.clone(),
+                    None,
+                    cx,
+                )
+            })
+        });
+        let tool_set = cx.read(|cx| thread_store.read(cx).tools());
+
+        assert_eq!(
+            deserialized.profile,
+            AgentProfile::new(AgentProfileId::default(), tool_set)
+        );
+    }
+
    #[gpui::test]
    async fn test_temperature_setting(cx: &mut TestAppContext) {
        init_test_settings(cx);
--- a/crates/agent/src/thread_history.rs
+++ b/crates/agent/src/thread_history.rs
@@ -671,7 +671,7 @@ impl RenderOnce for HistoryEntryElement {
            ),
            HistoryEntry::Context(context) => (
                context.path.to_string_lossy().to_string(),
-                context.title.clone().into(),
+                context.title.clone(),
                context.mtime.timestamp(),
            ),
        };
--- a/crates/agent/src/thread_store.rs
+++ b/crates/agent/src/thread_store.rs
@@ -3,9 +3,9 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};

-use agent_settings::{AgentProfile, AgentProfileId, AgentSettings, CompletionMode};
+use agent_settings::{AgentProfileId, CompletionMode};
 use anyhow::{Context as _, Result, anyhow};
-use assistant_tool::{ToolId, ToolSource, ToolWorkingSet};
+use assistant_tool::{ToolId, ToolWorkingSet};
 use chrono::{DateTime, Utc};
 use collections::HashMap;
 use context_server::ContextServerId;
@@ -25,7 +25,6 @@ use prompt_store::{
    UserRulesContext, WorktreeContext,
 };
 use serde::{Deserialize, Serialize};
-use settings::{Settings as _, SettingsStore};
 use ui::Window;
 use util::ResultExt as _;

@@ -147,12 +146,7 @@ impl ThreadStore {
        prompt_store: Option<Entity<PromptStore>>,
        cx: &mut Context<Self>,
    ) -> (Self, oneshot::Receiver<()>) {
-        let mut subscriptions = vec![
-            cx.observe_global::<SettingsStore>(move |this: &mut Self, cx| {
-                this.load_default_profile(cx);
-            }),
-            cx.subscribe(&project, Self::handle_project_event),
-        ];
+        let mut subscriptions = vec![cx.subscribe(&project, Self::handle_project_event)];

        if let Some(prompt_store) = prompt_store.as_ref() {
            subscriptions.push(cx.subscribe(
@@ -200,7 +194,6 @@ impl ThreadStore {
            _reload_system_prompt_task: reload_system_prompt_task,
            _subscriptions: subscriptions,
        };
-        this.load_default_profile(cx);
        this.register_context_server_handlers(cx);
        this.reload(cx).detach_and_log_err(cx);
        (this, ready_rx)
@@ -400,16 +393,11 @@ impl ThreadStore {
        self.threads.len()
    }

-    pub fn unordered_threads(&self) -> impl Iterator<Item = &SerializedThreadMetadata> {
+    pub fn reverse_chronological_threads(&self) -> impl Iterator<Item = &SerializedThreadMetadata> {
+        // ordering is from "ORDER BY" in `list_threads`
        self.threads.iter()
    }

-    pub fn reverse_chronological_threads(&self) -> Vec<SerializedThreadMetadata> {
-        let mut threads = self.threads.iter().cloned().collect::<Vec<_>>();
-        threads.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.updated_at));
-        threads
-    }
-
    pub fn create_thread(&mut self, cx: &mut Context<Self>) -> Entity<Thread> {
        cx.new(|cx| {
            Thread::new(
@@ -520,92 +508,15 @@ impl ThreadStore {
        })
    }

-    fn load_default_profile(&self, cx: &mut Context<Self>) {
-        let assistant_settings = AgentSettings::get_global(cx);
-
-        self.load_profile_by_id(assistant_settings.default_profile.clone(), cx);
-    }
-
-    pub fn load_profile_by_id(&self, profile_id: AgentProfileId, cx: &mut Context<Self>) {
-        let assistant_settings = AgentSettings::get_global(cx);
-
-        if let Some(profile) = assistant_settings.profiles.get(&profile_id) {
-            self.load_profile(profile.clone(), cx);
-        }
-    }
-
-    pub fn load_profile(&self, profile: AgentProfile, cx: &mut Context<Self>) {
-        self.tools.update(cx, |tools, cx| {
-            tools.disable_all_tools(cx);
-            tools.enable(
-                ToolSource::Native,
-                &profile
-                    .tools
-                    .into_iter()
-                    .filter_map(|(tool, enabled)| enabled.then(|| tool))
-                    .collect::<Vec<_>>(),
-                cx,
-            );
-        });
-
-        if profile.enable_all_context_servers {
-            for context_server_id in self
-                .project
-                .read(cx)
-                .context_server_store()
-                .read(cx)
-                .all_server_ids()
-            {
-                self.tools.update(cx, |tools, cx| {
-                    tools.enable_source(
-                        ToolSource::ContextServer {
-                            id: context_server_id.0.into(),
-                        },
-                        cx,
-                    );
-                });
-            }
-            // Enable all the tools from all context servers, but disable the ones that are explicitly disabled
-            for (context_server_id, preset) in profile.context_servers {
-                self.tools.update(cx, |tools, cx| {
-                    tools.disable(
-                        ToolSource::ContextServer {
-                            id: context_server_id.into(),
-                        },
-                        &preset
-                            .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| (!enabled).then(|| tool))
-                            .collect::<Vec<_>>(),
-                        cx,
-                    )
-                })
-            }
-        } else {
-            for (context_server_id, preset) in profile.context_servers {
-                self.tools.update(cx, |tools, cx| {
-                    tools.enable(
-                        ToolSource::ContextServer {
-                            id: context_server_id.into(),
-                        },
-                        &preset
-                            .tools
-                            .into_iter()
-                            .filter_map(|(tool, enabled)| enabled.then(|| tool))
-                            .collect::<Vec<_>>(),
-                        cx,
-                    )
-                })
-            }
-        }
-    }
-
    fn register_context_server_handlers(&self, cx: &mut Context<Self>) {
-        cx.subscribe(
-            &self.project.read(cx).context_server_store(),
-            Self::handle_context_server_event,
-        )
-        .detach();
+        let context_server_store = self.project.read(cx).context_server_store();
+        cx.subscribe(&context_server_store, Self::handle_context_server_event)
+            .detach();
+
+        // Check for any servers that were already running before the handler was registered
+        for server in context_server_store.read(cx).running_servers() {
+            self.load_context_server_tools(server.id(), context_server_store.clone(), cx);
+        }
    }

    fn handle_context_server_event(
@@ -618,71 +529,71 @@ impl ThreadStore {
        match event {
            project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
                match status {
+                    ContextServerStatus::Starting => {}
                    ContextServerStatus::Running => {
-                        if let Some(server) =
-                            context_server_store.read(cx).get_running_server(server_id)
-                        {
-                            let context_server_manager = context_server_store.clone();
-                            cx.spawn({
-                                let server = server.clone();
-                                let server_id = server_id.clone();
-                                async move |this, cx| {
-                                    let Some(protocol) = server.client() else {
-                                        return;
-                                    };
-
-                                    if protocol.capable(context_server::protocol::ServerCapability::Tools) {
-                                        if let Some(tools) = protocol.list_tools().await.log_err() {
-                                            let tool_ids = tool_working_set
-                                                .update(cx, |tool_working_set, _| {
-                                                    tools
-                                                        .tools
-                                                        .into_iter()
-                                                        .map(|tool| {
-                                                            log::info!(
-                                                                "registering context server tool: {:?}",
-                                                                tool.name
-                                                            );
-                                                            tool_working_set.insert(Arc::new(
-                                                                ContextServerTool::new(
-                                                                    context_server_manager.clone(),
-                                                                    server.id(),
-                                                                    tool,
-                                                                ),
-                                                            ))
-                                                        })
-                                                        .collect::<Vec<_>>()
-                                                })
-                                                .log_err();
-
-                                            if let Some(tool_ids) = tool_ids {
-                                                this.update(cx, |this, cx| {
-                                                    this.context_server_tool_ids
-                                                        .insert(server_id, tool_ids);
-                                                    this.load_default_profile(cx);
-                                                })
-                                                .log_err();
-                                            }
-                                        }
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
+                        self.load_context_server_tools(server_id.clone(), context_server_store, cx);
                    }
                    ContextServerStatus::Stopped | ContextServerStatus::Error(_) => {
                        if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
                            tool_working_set.update(cx, |tool_working_set, _| {
                                tool_working_set.remove(&tool_ids);
                            });
-                            self.load_default_profile(cx);
                        }
                    }
-                    _ => {}
                }
            }
        }
    }
+
+    fn load_context_server_tools(
+        &self,
+        server_id: ContextServerId,
+        context_server_store: Entity<ContextServerStore>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(server) = context_server_store.read(cx).get_running_server(&server_id) else {
+            return;
+        };
+        let tool_working_set = self.tools.clone();
+        cx.spawn(async move |this, cx| {
+            let Some(protocol) = server.client() else {
+                return;
+            };
+
+            if protocol.capable(context_server::protocol::ServerCapability::Tools) {
+                if let Some(response) = protocol
+                    .request::<context_server::types::request::ListTools>(())
+                    .await
+                    .log_err()
+                {
+                    let tool_ids = tool_working_set
+                        .update(cx, |tool_working_set, _| {
+                            response
+                                .tools
+                                .into_iter()
+                                .map(|tool| {
+                                    log::info!("registering context server tool: {:?}", tool.name);
+                                    tool_working_set.insert(Arc::new(ContextServerTool::new(
+                                        context_server_store.clone(),
+                                        server.id(),
+                                        tool,
+                                    )))
+                                })
+                                .collect::<Vec<_>>()
+                        })
+                        .log_err();
+
+                    if let Some(tool_ids) = tool_ids {
+                        this.update(cx, |this, _| {
+                            this.context_server_tool_ids.insert(server_id, tool_ids);
+                        })
+                        .log_err();
+                    }
+                }
+            }
+        })
+        .detach();
+    }
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -714,6 +625,8 @@ pub struct SerializedThread {
    pub completion_mode: Option<CompletionMode>,
    #[serde(default)]
    pub tool_use_limit_reached: bool,
+    #[serde(default)]
+    pub profile: Option<AgentProfileId>,
 }

 #[derive(Serialize, Deserialize, Debug)]
@@ -856,6 +769,7 @@ impl LegacySerializedThread {
            model: None,
            completion_mode: None,
            tool_use_limit_reached: false,
+            profile: None,
        }
    }
 }
--- a/crates/agent/src/tool_compatibility.rs
+++ b/crates/agent/src/tool_compatibility.rs
@@ -1,30 +1,33 @@
 use std::sync::Arc;

-use assistant_tool::{Tool, ToolSource, ToolWorkingSet, ToolWorkingSetEvent};
+use assistant_tool::{Tool, ToolSource};
 use collections::HashMap;
 use gpui::{App, Context, Entity, IntoElement, Render, Subscription, Window};
 use language_model::{LanguageModel, LanguageModelToolSchemaFormat};
 use ui::prelude::*;

+use crate::{Thread, ThreadEvent};
+
 pub struct IncompatibleToolsState {
    cache: HashMap<LanguageModelToolSchemaFormat, Vec<Arc<dyn Tool>>>,
-    tool_working_set: Entity<ToolWorkingSet>,
-    _tool_working_set_subscription: Subscription,
+    thread: Entity<Thread>,
+    _thread_subscription: Subscription,
 }

 impl IncompatibleToolsState {
-    pub fn new(tool_working_set: Entity<ToolWorkingSet>, cx: &mut Context<Self>) -> Self {
+    pub fn new(thread: Entity<Thread>, cx: &mut Context<Self>) -> Self {
        let _tool_working_set_subscription =
-            cx.subscribe(&tool_working_set, |this, _, event, _| match event {
-                ToolWorkingSetEvent::EnabledToolsChanged => {
+            cx.subscribe(&thread, |this, _, event, _| match event {
+                ThreadEvent::ProfileChanged => {
                    this.cache.clear();
                }
+                _ => {}
            });

        Self {
            cache: HashMap::default(),
-            tool_working_set,
-            _tool_working_set_subscription,
+            thread,
+            _thread_subscription: _tool_working_set_subscription,
        }
    }

@@ -36,8 +39,9 @@ impl IncompatibleToolsState {
        self.cache
            .entry(model.tool_input_format())
            .or_insert_with(|| {
-                self.tool_working_set
+                self.thread
                    .read(cx)
+                    .profile()
                    .enabled_tools(cx)
                    .iter()
                    .filter(|tool| tool.input_schema(model.tool_input_format()).is_err())
--- a/crates/agent_settings/Cargo.toml
+++ b/crates/agent_settings/Cargo.toml
@@ -16,7 +16,6 @@ anthropic = { workspace = true, features = ["schemars"] }
 anyhow.workspace = true
 collections.workspace = true
 gpui.workspace = true
-indexmap.workspace = true
 language_model.workspace = true
 lmstudio = { workspace = true, features = ["schemars"] }
 log.workspace = true
--- a/crates/agent_settings/src/agent_profile.rs
+++ b/crates/agent_settings/src/agent_profile.rs
@@ -17,29 +17,6 @@ pub mod builtin_profiles {
    }
 }

-#[derive(Default)]
-pub struct GroupedAgentProfiles {
-    pub builtin: IndexMap<AgentProfileId, AgentProfile>,
-    pub custom: IndexMap<AgentProfileId, AgentProfile>,
-}
-
-impl GroupedAgentProfiles {
-    pub fn from_settings(settings: &crate::AgentSettings) -> Self {
-        let mut builtin = IndexMap::default();
-        let mut custom = IndexMap::default();
-
-        for (profile_id, profile) in settings.profiles.clone() {
-            if builtin_profiles::is_builtin(&profile_id) {
-                builtin.insert(profile_id, profile);
-            } else {
-                custom.insert(profile_id, profile);
-            }
-        }
-
-        Self { builtin, custom }
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize, JsonSchema)]
 pub struct AgentProfileId(pub Arc<str>);

@@ -63,7 +40,7 @@ impl Default for AgentProfileId {

 /// A profile for the Zed Agent that controls its behavior.
 #[derive(Debug, Clone)]
-pub struct AgentProfile {
+pub struct AgentProfileSettings {
    /// The name of the profile.
    pub name: SharedString,
    pub tools: IndexMap<Arc<str>, bool>,
--- a/crates/agent_settings/src/agent_settings.rs
+++ b/crates/agent_settings/src/agent_settings.rs
@@ -102,7 +102,7 @@ pub struct AgentSettings {
    pub using_outdated_settings_version: bool,
    pub default_profile: AgentProfileId,
    pub default_view: DefaultView,
-    pub profiles: IndexMap<AgentProfileId, AgentProfile>,
+    pub profiles: IndexMap<AgentProfileId, AgentProfileSettings>,
    pub always_allow_tool_actions: bool,
    pub notify_when_agent_waiting: NotifyWhenAgentWaiting,
    pub play_sound_when_agent_done: bool,
@@ -531,7 +531,7 @@ impl AgentSettingsContent {
    pub fn create_profile(
        &mut self,
        profile_id: AgentProfileId,
-        profile: AgentProfile,
+        profile_settings: AgentProfileSettings,
    ) -> Result<()> {
        self.v2_setting(|settings| {
            let profiles = settings.profiles.get_or_insert_default();
@@ -542,10 +542,10 @@ impl AgentSettingsContent {
            profiles.insert(
                profile_id,
                AgentProfileContent {
-                    name: profile.name.into(),
-                    tools: profile.tools,
-                    enable_all_context_servers: Some(profile.enable_all_context_servers),
-                    context_servers: profile
+                    name: profile_settings.name.into(),
+                    tools: profile_settings.tools,
+                    enable_all_context_servers: Some(profile_settings.enable_all_context_servers),
+                    context_servers: profile_settings
                        .context_servers
                        .into_iter()
                        .map(|(server_id, preset)| {
@@ -910,7 +910,7 @@ impl Settings for AgentSettings {
                    .extend(profiles.into_iter().map(|(id, profile)| {
                        (
                            id,
-                            AgentProfile {
+                            AgentProfileSettings {
                                name: profile.name.into(),
                                tools: profile.tools,
                                enable_all_context_servers: profile
--- a/crates/assistant_context_editor/src/context.rs
+++ b/crates/assistant_context_editor/src/context.rs
@@ -11,7 +11,7 @@ use assistant_slash_commands::FileCommandMetadata;
 use client::{self, proto, telemetry::Telemetry};
 use clock::ReplicaId;
 use collections::{HashMap, HashSet};
-use fs::{Fs, RemoveOptions};
+use fs::{Fs, RenameOptions};
 use futures::{FutureExt, StreamExt, future::Shared};
 use gpui::{
    App, AppContext as _, Context, Entity, EventEmitter, RenderImage, SharedString, Subscription,
@@ -452,6 +452,10 @@ pub enum ContextEvent {
    MessagesEdited,
    SummaryChanged,
    SummaryGenerated,
+    PathChanged {
+        old_path: Option<Arc<Path>>,
+        new_path: Arc<Path>,
+    },
    StreamedCompletion,
    StartedThoughtProcess(Range<language::Anchor>),
    EndedThoughtProcess(language::Anchor),
@@ -2894,22 +2898,34 @@ impl AssistantContext {
                }

                fs.create_dir(contexts_dir().as_ref()).await?;
-                fs.atomic_write(new_path.clone(), serde_json::to_string(&context).unwrap())
-                    .await?;
-                if let Some(old_path) = old_path {
+
+                // rename before write ensures that only one file exists
+                if let Some(old_path) = old_path.as_ref() {
                    if new_path.as_path() != old_path.as_ref() {
-                        fs.remove_file(
+                        fs.rename(
                            &old_path,
-                            RemoveOptions {
-                                recursive: false,
-                                ignore_if_not_exists: true,
+                            &new_path,
+                            RenameOptions {
+                                overwrite: true,
+                                ignore_if_exists: true,
                            },
                        )
                        .await?;
                    }
                }

-                this.update(cx, |this, _| this.path = Some(new_path.into()))?;
+                // update path before write in case it fails
+                this.update(cx, {
+                    let new_path: Arc<Path> = new_path.clone().into();
+                    move |this, cx| {
+                        this.path = Some(new_path.clone());
+                        cx.emit(ContextEvent::PathChanged { old_path, new_path });
+                    }
+                })
+                .ok();
+
+                fs.atomic_write(new_path, serde_json::to_string(&context).unwrap())
+                    .await?;
            }

            Ok(())
@@ -3277,7 +3293,7 @@ impl SavedContextV0_1_0 {

 #[derive(Debug, Clone)]
 pub struct SavedContextMetadata {
-    pub title: String,
+    pub title: SharedString,
    pub path: Arc<Path>,
    pub mtime: chrono::DateTime<chrono::Local>,
 }
--- a/crates/assistant_context_editor/src/context_editor.rs
+++ b/crates/assistant_context_editor/src/context_editor.rs
@@ -580,6 +580,7 @@ impl ContextEditor {
                });
            }
            ContextEvent::SummaryGenerated => {}
+            ContextEvent::PathChanged { .. } => {}
            ContextEvent::StartedThoughtProcess(range) => {
                let creases = self.insert_thought_process_output_sections(
                    [(
--- a/crates/assistant_context_editor/src/context_store.rs
+++ b/crates/assistant_context_editor/src/context_store.rs
@@ -347,12 +347,6 @@ impl ContextStore {
        self.contexts_metadata.iter()
    }

-    pub fn reverse_chronological_contexts(&self) -> Vec<SavedContextMetadata> {
-        let mut contexts = self.contexts_metadata.iter().cloned().collect::<Vec<_>>();
-        contexts.sort_unstable_by_key(|thread| std::cmp::Reverse(thread.mtime));
-        contexts
-    }
-
    pub fn create(&mut self, cx: &mut Context<Self>) -> Entity<AssistantContext> {
        let context = cx.new(|cx| {
            AssistantContext::local(
@@ -618,6 +612,16 @@ impl ContextStore {
            ContextEvent::SummaryChanged => {
                self.advertise_contexts(cx);
            }
+            ContextEvent::PathChanged { old_path, new_path } => {
+                if let Some(old_path) = old_path.as_ref() {
+                    for metadata in &mut self.contexts_metadata {
+                        if &metadata.path == old_path {
+                            metadata.path = new_path.clone();
+                            break;
+                        }
+                    }
+                }
+            }
            ContextEvent::Operation(operation) => {
                let context_id = context.read(cx).id().to_proto();
                let operation = operation.to_proto();
@@ -792,7 +796,7 @@ impl ContextStore {
                        .next()
                    {
                        contexts.push(SavedContextMetadata {
-                            title: title.to_string(),
+                            title: title.to_string().into(),
                            path: path.into(),
                            mtime: metadata.mtime.timestamp_for_user().into(),
                        });
@@ -809,74 +813,37 @@ impl ContextStore {
    }

    fn register_context_server_handlers(&self, cx: &mut Context<Self>) {
-        cx.subscribe(
-            &self.project.read(cx).context_server_store(),
-            Self::handle_context_server_event,
-        )
-        .detach();
+        let context_server_store = self.project.read(cx).context_server_store();
+        cx.subscribe(&context_server_store, Self::handle_context_server_event)
+            .detach();
+
+        // Check for any servers that were already running before the handler was registered
+        for server in context_server_store.read(cx).running_servers() {
+            self.load_context_server_slash_commands(server.id(), context_server_store.clone(), cx);
+        }
    }

    fn handle_context_server_event(
        &mut self,
-        context_server_manager: Entity<ContextServerStore>,
+        context_server_store: Entity<ContextServerStore>,
        event: &project::context_server_store::Event,
        cx: &mut Context<Self>,
    ) {
-        let slash_command_working_set = self.slash_commands.clone();
        match event {
            project::context_server_store::Event::ServerStatusChanged { server_id, status } => {
                match status {
                    ContextServerStatus::Running => {
-                        if let Some(server) = context_server_manager
-                            .read(cx)
-                            .get_running_server(server_id)
-                        {
-                            let context_server_manager = context_server_manager.clone();
-                            cx.spawn({
-                                let server = server.clone();
-                                let server_id = server_id.clone();
-                                async move |this, cx| {
-                                    let Some(protocol) = server.client() else {
-                                        return;
-                                    };
-
-                                    if protocol.capable(context_server::protocol::ServerCapability::Prompts) {
-                                        if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                            let slash_command_ids = prompts
-                                                .into_iter()
-                                                .filter(assistant_slash_commands::acceptable_prompt)
-                                                .map(|prompt| {
-                                                    log::info!(
-                                                        "registering context server command: {:?}",
-                                                        prompt.name
-                                                    );
-                                                    slash_command_working_set.insert(Arc::new(
-                                                        assistant_slash_commands::ContextServerSlashCommand::new(
-                                                            context_server_manager.clone(),
-                                                            server.id(),
-                                                            prompt,
-                                                        ),
-                                                    ))
-                                                })
-                                                .collect::<Vec<_>>();
-
-                                            this.update( cx, |this, _cx| {
-                                                this.context_server_slash_command_ids
-                                                    .insert(server_id.clone(), slash_command_ids);
-                                            })
-                                            .log_err();
-                                        }
-                                    }
-                                }
-                            })
-                            .detach();
-                        }
+                        self.load_context_server_slash_commands(
+                            server_id.clone(),
+                            context_server_store.clone(),
+                            cx,
+                        );
                    }
                    ContextServerStatus::Stopped | ContextServerStatus::Error(_) => {
                        if let Some(slash_command_ids) =
                            self.context_server_slash_command_ids.remove(server_id)
                        {
-                            slash_command_working_set.remove(&slash_command_ids);
+                            self.slash_commands.remove(&slash_command_ids);
                        }
                    }
                    _ => {}
@@ -884,4 +851,52 @@ impl ContextStore {
            }
        }
    }
+
+    fn load_context_server_slash_commands(
+        &self,
+        server_id: ContextServerId,
+        context_server_store: Entity<ContextServerStore>,
+        cx: &mut Context<Self>,
+    ) {
+        let Some(server) = context_server_store.read(cx).get_running_server(&server_id) else {
+            return;
+        };
+        let slash_command_working_set = self.slash_commands.clone();
+        cx.spawn(async move |this, cx| {
+            let Some(protocol) = server.client() else {
+                return;
+            };
+
+            if protocol.capable(context_server::protocol::ServerCapability::Prompts) {
+                if let Some(response) = protocol
+                    .request::<context_server::types::request::PromptsList>(())
+                    .await
+                    .log_err()
+                {
+                    let slash_command_ids = response
+                        .prompts
+                        .into_iter()
+                        .filter(assistant_slash_commands::acceptable_prompt)
+                        .map(|prompt| {
+                            log::info!("registering context server command: {:?}", prompt.name);
+                            slash_command_working_set.insert(Arc::new(
+                                assistant_slash_commands::ContextServerSlashCommand::new(
+                                    context_server_store.clone(),
+                                    server.id(),
+                                    prompt,
+                                ),
+                            ))
+                        })
+                        .collect::<Vec<_>>();
+
+                    this.update(cx, |this, _cx| {
+                        this.context_server_slash_command_ids
+                            .insert(server_id.clone(), slash_command_ids);
+                    })
+                    .log_err();
+                }
+            }
+        })
+        .detach();
+    }
 }
--- a/crates/assistant_context_editor/src/slash_command.rs
+++ b/crates/assistant_context_editor/src/slash_command.rs
@@ -10,9 +10,7 @@ use parking_lot::Mutex;
 use project::{CompletionIntent, CompletionSource, lsp_store::CompletionDocumentation};
 use rope::Point;
 use std::{
-    cell::RefCell,
    ops::Range,
-    rc::Rc,
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering::SeqCst},
@@ -240,13 +238,14 @@ impl SlashCommandCompletionProvider {

                Ok(vec![project::CompletionResponse {
                    completions,
-                    is_incomplete: false,
+                    // TODO: Could have slash commands indicate whether their completions are incomplete.
+                    is_incomplete: true,
                }])
            })
        } else {
            Task::ready(Ok(vec![project::CompletionResponse {
                completions: Vec::new(),
-                is_incomplete: false,
+                is_incomplete: true,
            }]))
        }
    }
@@ -275,17 +274,17 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                    position.row,
                    call.arguments.last().map_or(call.name.end, |arg| arg.end) as u32,
                );
-                let command_range = buffer.anchor_after(command_range_start)
+                let command_range = buffer.anchor_before(command_range_start)
                    ..buffer.anchor_after(command_range_end);

                let name = line[call.name.clone()].to_string();
                let (arguments, last_argument_range) = if let Some(argument) = call.arguments.last()
                {
                    let last_arg_start =
-                        buffer.anchor_after(Point::new(position.row, argument.start as u32));
+                        buffer.anchor_before(Point::new(position.row, argument.start as u32));
                    let first_arg_start = call.arguments.first().expect("we have the last element");
-                    let first_arg_start =
-                        buffer.anchor_after(Point::new(position.row, first_arg_start.start as u32));
+                    let first_arg_start = buffer
+                        .anchor_before(Point::new(position.row, first_arg_start.start as u32));
                    let arguments = call
                        .arguments
                        .into_iter()
@@ -298,7 +297,7 @@ impl CompletionProvider for SlashCommandCompletionProvider {
                    )
                } else {
                    let start =
-                        buffer.anchor_after(Point::new(position.row, call.name.start as u32));
+                        buffer.anchor_before(Point::new(position.row, call.name.start as u32));
                    (None, start..buffer_position)
                };

@@ -326,16 +325,6 @@ impl CompletionProvider for SlashCommandCompletionProvider {
        }
    }

-    fn resolve_completions(
-        &self,
-        _: Entity<Buffer>,
-        _: Vec<usize>,
-        _: Rc<RefCell<Box<[project::Completion]>>>,
-        _: &mut Context<Editor>,
-    ) -> Task<Result<bool>> {
-        Task::ready(Ok(true))
-    }
-
    fn is_completion_trigger(
        &self,
        buffer: &Entity<Buffer>,
--- a/crates/assistant_slash_commands/src/context_server_command.rs
+++ b/crates/assistant_slash_commands/src/context_server_command.rs
@@ -86,20 +86,26 @@ impl SlashCommand for ContextServerSlashCommand {
            cx.foreground_executor().spawn(async move {
                let protocol = server.client().context("Context server not initialized")?;

-                let completion_result = protocol
-                    .completion(
-                        context_server::types::CompletionReference::Prompt(
-                            context_server::types::PromptReference {
-                                r#type: context_server::types::PromptReferenceType::Prompt,
-                                name: prompt_name,
+                let response = protocol
+                    .request::<context_server::types::request::CompletionComplete>(
+                        context_server::types::CompletionCompleteParams {
+                            reference: context_server::types::CompletionReference::Prompt(
+                                context_server::types::PromptReference {
+                                    ty: context_server::types::PromptReferenceType::Prompt,
+                                    name: prompt_name,
+                                },
+                            ),
+                            argument: context_server::types::CompletionArgument {
+                                name: arg_name,
+                                value: arg_value,
                            },
-                        ),
-                        arg_name,
-                        arg_value,
+                            meta: None,
+                        },
                    )
                    .await?;

-                let completions = completion_result
+                let completions = response
+                    .completion
                    .values
                    .into_iter()
                    .map(|value| ArgumentCompletion {
@@ -138,10 +144,18 @@ impl SlashCommand for ContextServerSlashCommand {
        if let Some(server) = store.get_running_server(&server_id) {
            cx.foreground_executor().spawn(async move {
                let protocol = server.client().context("Context server not initialized")?;
-                let result = protocol.run_prompt(&prompt_name, prompt_args).await?;
+                let response = protocol
+                    .request::<context_server::types::request::PromptsGet>(
+                        context_server::types::PromptsGetParams {
+                            name: prompt_name.clone(),
+                            arguments: Some(prompt_args),
+                            meta: None,
+                        },
+                    )
+                    .await?;

                anyhow::ensure!(
-                    result
+                    response
                        .messages
                        .iter()
                        .all(|msg| matches!(msg.role, context_server::types::Role::User)),
@@ -149,7 +163,7 @@ impl SlashCommand for ContextServerSlashCommand {
                );

                // Extract text from user messages into a single prompt string
-                let mut prompt = result
+                let mut prompt = response
                    .messages
                    .into_iter()
                    .filter_map(|msg| match msg.content {
@@ -167,7 +181,7 @@ impl SlashCommand for ContextServerSlashCommand {
                        range: 0..(prompt.len()),
                        icon: IconName::ZedAssistant,
                        label: SharedString::from(
-                            result
+                            response
                                .description
                                .unwrap_or(format!("Result from {}", prompt_name)),
                        ),
--- a/crates/assistant_tool/Cargo.toml
+++ b/crates/assistant_tool/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/assistant_tool.rs"

 [dependencies]
 anyhow.workspace = true
-async-watch.workspace = true
 buffer_diff.workspace = true
 clock.workspace = true
 collections.workspace = true
@@ -30,6 +29,7 @@ serde.workspace = true
 serde_json.workspace = true
 text.workspace = true
 util.workspace = true
+watch.workspace = true
 workspace.workspace = true
 workspace-hack.workspace = true

--- a/crates/assistant_tool/src/action_log.rs
+++ b/crates/assistant_tool/src/action_log.rs
@@ -204,7 +204,7 @@ impl ActionLog {
            git_store.repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
        })?;

-        let (git_diff_updates_tx, mut git_diff_updates_rx) = async_watch::channel(());
+        let (mut git_diff_updates_tx, mut git_diff_updates_rx) = watch::channel(());
        let _repo_subscription =
            if let Some((git_diff, (buffer_repo, _))) = git_diff.as_ref().zip(buffer_repo) {
                cx.update(|cx| {
--- a/crates/assistant_tool/src/assistant_tool.rs
+++ b/crates/assistant_tool/src/assistant_tool.rs
@@ -214,7 +214,7 @@ pub trait Tool: 'static + Send + Sync {
        ToolSource::Native
    }

-    /// Returns true iff the tool needs the users's confirmation
+    /// Returns true if the tool needs the users's confirmation
    /// before having permission to run.
    fn needs_confirmation(&self, input: &serde_json::Value, cx: &App) -> bool;

--- a/crates/assistant_tool/src/tool_working_set.rs
+++ b/crates/assistant_tool/src/tool_working_set.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;

-use collections::{HashMap, HashSet, IndexMap};
-use gpui::{App, Context, EventEmitter};
+use collections::{HashMap, IndexMap};
+use gpui::App;

 use crate::{Tool, ToolRegistry, ToolSource};

@@ -13,17 +13,9 @@ pub struct ToolId(usize);
 pub struct ToolWorkingSet {
    context_server_tools_by_id: HashMap<ToolId, Arc<dyn Tool>>,
    context_server_tools_by_name: HashMap<String, Arc<dyn Tool>>,
-    enabled_sources: HashSet<ToolSource>,
-    enabled_tools_by_source: HashMap<ToolSource, HashSet<Arc<str>>>,
    next_tool_id: ToolId,
 }

-pub enum ToolWorkingSetEvent {
-    EnabledToolsChanged,
-}
-
-impl EventEmitter<ToolWorkingSetEvent> for ToolWorkingSet {}
-
 impl ToolWorkingSet {
    pub fn tool(&self, name: &str, cx: &App) -> Option<Arc<dyn Tool>> {
        self.context_server_tools_by_name
@@ -57,42 +49,6 @@ impl ToolWorkingSet {
        tools_by_source
    }

-    pub fn enabled_tools(&self, cx: &App) -> Vec<Arc<dyn Tool>> {
-        let all_tools = self.tools(cx);
-
-        all_tools
-            .into_iter()
-            .filter(|tool| self.is_enabled(&tool.source(), &tool.name().into()))
-            .collect()
-    }
-
-    pub fn disable_all_tools(&mut self, cx: &mut Context<Self>) {
-        self.enabled_tools_by_source.clear();
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn enable_source(&mut self, source: ToolSource, cx: &mut Context<Self>) {
-        self.enabled_sources.insert(source.clone());
-
-        let tools_by_source = self.tools_by_source(cx);
-        if let Some(tools) = tools_by_source.get(&source) {
-            self.enabled_tools_by_source.insert(
-                source,
-                tools
-                    .into_iter()
-                    .map(|tool| tool.name().into())
-                    .collect::<HashSet<_>>(),
-            );
-        }
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn disable_source(&mut self, source: &ToolSource, cx: &mut Context<Self>) {
-        self.enabled_sources.remove(source);
-        self.enabled_tools_by_source.remove(source);
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
    pub fn insert(&mut self, tool: Arc<dyn Tool>) -> ToolId {
        let tool_id = self.next_tool_id;
        self.next_tool_id.0 += 1;
@@ -102,42 +58,6 @@ impl ToolWorkingSet {
        tool_id
    }

-    pub fn is_enabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        self.enabled_tools_by_source
-            .get(source)
-            .map_or(false, |enabled_tools| enabled_tools.contains(name))
-    }
-
-    pub fn is_disabled(&self, source: &ToolSource, name: &Arc<str>) -> bool {
-        !self.is_enabled(source, name)
-    }
-
-    pub fn enable(
-        &mut self,
-        source: ToolSource,
-        tools_to_enable: &[Arc<str>],
-        cx: &mut Context<Self>,
-    ) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .extend(tools_to_enable.into_iter().cloned());
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
-    pub fn disable(
-        &mut self,
-        source: ToolSource,
-        tools_to_disable: &[Arc<str>],
-        cx: &mut Context<Self>,
-    ) {
-        self.enabled_tools_by_source
-            .entry(source)
-            .or_default()
-            .retain(|name| !tools_to_disable.contains(name));
-        cx.emit(ToolWorkingSetEvent::EnabledToolsChanged);
-    }
-
    pub fn remove(&mut self, tool_ids_to_remove: &[ToolId]) {
        self.context_server_tools_by_id
            .retain(|id, _| !tool_ids_to_remove.contains(id));
--- a/crates/assistant_tools/Cargo.toml
+++ b/crates/assistant_tools/Cargo.toml
@@ -18,7 +18,6 @@ eval = []
 agent_settings.workspace = true
 anyhow.workspace = true
 assistant_tool.workspace = true
-async-watch.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
 collections.workspace = true
@@ -58,6 +57,7 @@ terminal_view.workspace = true
 theme.workspace = true
 ui.workspace = true
 util.workspace = true
+watch.workspace = true
 web_search.workspace = true
 which.workspace = true
 workspace-hack.workspace = true
--- a/crates/assistant_tools/src/edit_agent.rs
+++ b/crates/assistant_tools/src/edit_agent.rs
@@ -420,12 +420,12 @@ impl EditAgent {
        cx: &mut AsyncApp,
    ) -> (
        Task<Result<(T, Vec<ResolvedOldText>)>>,
-        async_watch::Receiver<Option<Range<usize>>>,
+        watch::Receiver<Option<Range<usize>>>,
    )
    where
        T: 'static + Send + Unpin + Stream<Item = Result<EditParserEvent>>,
    {
-        let (old_range_tx, old_range_rx) = async_watch::channel(None);
+        let (mut old_range_tx, old_range_rx) = watch::channel(None);
        let task = cx.background_spawn(async move {
            let mut matcher = StreamingFuzzyMatcher::new(snapshot);
            while let Some(edit_event) = edit_events.next().await {
--- a/crates/assistant_tools/src/edit_agent/evals.rs
+++ b/crates/assistant_tools/src/edit_agent/evals.rs
@@ -39,7 +39,7 @@ fn eval_extract_handle_command_output() {
    // Model                       | Pass rate
    // ----------------------------|----------
    // claude-3.7-sonnet           |  0.98
-    // gemini-2.5-pro              |  0.86
+    // gemini-2.5-pro-06-05        |  0.77
    // gemini-2.5-flash            |  0.11
    // gpt-4.1                     |  1.00

@@ -58,6 +58,7 @@ fn eval_extract_handle_command_output() {
    eval(
        100,
        0.7, // Taking the lower bar for Gemini
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -116,6 +117,7 @@ fn eval_delete_run_git_blame() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -178,6 +180,7 @@ fn eval_translate_doc_comments() {
    eval(
        200,
        1.,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -241,6 +244,7 @@ fn eval_use_wasi_sdk_in_compile_parser_to_wasm() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -365,6 +369,7 @@ fn eval_disable_cursor_blinking() {
    eval(
        100,
        0.95,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text("Let's research how to cursor blinking works.")]),
@@ -448,6 +453,9 @@ fn eval_from_pixels_constructor() {
    eval(
        100,
        0.95,
+        // For whatever reason, this eval produces more mismatched tags.
+        // Increasing for now, let's see if we can bring this down.
+        0.2,
        EvalInput::from_conversation(
            vec![
                message(
@@ -648,6 +656,7 @@ fn eval_zode() {
    eval(
        50,
        1.,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text(include_str!("evals/fixtures/zode/prompt.md"))]),
@@ -754,6 +763,7 @@ fn eval_add_overwrite_test() {
    eval(
        200,
        0.5, // TODO: make this eval better
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(
@@ -993,6 +1003,7 @@ fn eval_create_empty_file() {
    eval(
        100,
        0.99,
+        0.05,
        EvalInput::from_conversation(
            vec![
                message(User, [text("Create a second empty todo file ")]),
@@ -1279,7 +1290,12 @@ impl EvalAssertion {
    }
 }

-fn eval(iterations: usize, expected_pass_ratio: f32, mut eval: EvalInput) {
+fn eval(
+    iterations: usize,
+    expected_pass_ratio: f32,
+    mismatched_tag_threshold: f32,
+    mut eval: EvalInput,
+) {
    let mut evaluated_count = 0;
    let mut failed_count = 0;
    report_progress(evaluated_count, failed_count, iterations);
@@ -1351,7 +1367,7 @@ fn eval(iterations: usize, expected_pass_ratio: f32, mut eval: EvalInput) {

    let mismatched_tag_ratio =
        cumulative_parser_metrics.mismatched_tags as f32 / cumulative_parser_metrics.tags as f32;
-    if mismatched_tag_ratio > 0.10 {
+    if mismatched_tag_ratio > mismatched_tag_threshold {
        for eval_output in eval_outputs {
            println!("{}", eval_output);
        }
--- a/crates/assistant_tools/src/edit_agent/evals/fixtures/zode/prompt.md
+++ b/crates/assistant_tools/src/edit_agent/evals/fixtures/zode/prompt.md
@@ -498,7 +498,7 @@ client.with_options(max_retries=5).messages.create(
 ### Timeouts

 By default requests time out after 10 minutes. You can configure this with a `timeout` option,
-which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:
+which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:

 ```python
 from anthropic import Anthropic
--- a/crates/collab/Cargo.toml
+++ b/crates/collab/Cargo.toml
@@ -80,7 +80,6 @@ zed_llm_client.workspace = true
 agent_settings.workspace = true
 assistant_context_editor.workspace = true
 assistant_slash_command.workspace = true
-assistant_tool.workspace = true
 async-trait.workspace = true
 audio.workspace = true
 buffer_diff.workspace = true
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -312,6 +312,7 @@ impl Server {
            .add_request_handler(
                forward_read_only_project_request::<proto::LanguageServerIdForName>,
            )
+            .add_request_handler(forward_read_only_project_request::<proto::GetDocumentDiagnostics>)
            .add_request_handler(
                forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
            )
@@ -354,6 +355,9 @@ impl Server {
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>)
            .add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)
            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBases>)
+            .add_message_handler(
+                broadcast_project_message_from_host::<proto::PullWorkspaceDiagnostics>,
+            )
            .add_request_handler(get_users)
            .add_request_handler(fuzzy_search_users)
            .add_request_handler(request_contact)
--- a/crates/collab/src/tests/editor_tests.rs
+++ b/crates/collab/src/tests/editor_tests.rs
@@ -7,7 +7,7 @@ use editor::{
    Editor, RowInfo,
    actions::{
        ConfirmCodeAction, ConfirmCompletion, ConfirmRename, ContextMenuFirst,
-        ExpandMacroRecursively, Redo, Rename, ToggleCodeActions, Undo,
+        ExpandMacroRecursively, Redo, Rename, SelectAll, ToggleCodeActions, Undo,
    },
    test::{
        editor_test_context::{AssertionContextManager, EditorTestContext},
@@ -2712,7 +2712,7 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
                params.text_document.uri,
                lsp::Url::from_file_path(path!("/a/main.rs")).unwrap(),
            );
-            assert_eq!(params.position, lsp::Position::new(0, 0),);
+            assert_eq!(params.position, lsp::Position::new(0, 0));
            Ok(Some(ExpandedMacro {
                name: "test_macro_name".to_string(),
                expansion: "test_macro_expansion on the host".to_string(),
@@ -2747,7 +2747,11 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
                params.text_document.uri,
                lsp::Url::from_file_path(path!("/a/main.rs")).unwrap(),
            );
-            assert_eq!(params.position, lsp::Position::new(0, 0),);
+            assert_eq!(
+                params.position,
+                lsp::Position::new(0, 12),
+                "editor_b has selected the entire text and should query for a different position"
+            );
            Ok(Some(ExpandedMacro {
                name: "test_macro_name".to_string(),
                expansion: "test_macro_expansion on the client".to_string(),
@@ -2756,6 +2760,7 @@ async fn test_client_can_query_lsp_ext(cx_a: &mut TestAppContext, cx_b: &mut Tes
    );

    editor_b.update_in(cx_b, |editor, window, cx| {
+        editor.select_all(&SelectAll, window, cx);
        expand_macro_recursively(editor, &ExpandMacroRecursively, window, cx)
    });
    expand_request_b.next().await.unwrap();
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -20,8 +20,8 @@ use gpui::{
    UpdateGlobal, px, size,
 };
 use language::{
-    Diagnostic, DiagnosticEntry, FakeLspAdapter, Language, LanguageConfig, LanguageMatcher,
-    LineEnding, OffsetRangeExt, Point, Rope,
+    Diagnostic, DiagnosticEntry, DiagnosticSourceKind, FakeLspAdapter, Language, LanguageConfig,
+    LanguageMatcher, LineEnding, OffsetRangeExt, Point, Rope,
    language_settings::{
        AllLanguageSettings, Formatter, FormatterList, PrettierSettings, SelectedFormatter,
    },
@@ -4237,7 +4237,8 @@ async fn test_collaborating_with_diagnostics(
                        message: "message 1".to_string(),
                        severity: lsp::DiagnosticSeverity::ERROR,
                        is_primary: true,
-                        ..Default::default()
+                        source_kind: DiagnosticSourceKind::Pushed,
+                        ..Diagnostic::default()
                    }
                },
                DiagnosticEntry {
@@ -4247,7 +4248,8 @@ async fn test_collaborating_with_diagnostics(
                        severity: lsp::DiagnosticSeverity::WARNING,
                        message: "message 2".to_string(),
                        is_primary: true,
-                        ..Default::default()
+                        source_kind: DiagnosticSourceKind::Pushed,
+                        ..Diagnostic::default()
                    }
                }
            ]
@@ -4259,7 +4261,7 @@ async fn test_collaborating_with_diagnostics(
        &lsp::PublishDiagnosticsParams {
            uri: lsp::Url::from_file_path(path!("/a/a.rs")).unwrap(),
            version: None,
-            diagnostics: vec![],
+            diagnostics: Vec::new(),
        },
    );
    executor.run_until_parked();
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -15,7 +15,6 @@ use language::{
 use project::{Completion, CompletionResponse, CompletionSource, search::SearchQuery};
 use settings::Settings;
 use std::{
-    cell::RefCell,
    ops::Range,
    rc::Rc,
    sync::{Arc, LazyLock},
@@ -73,16 +72,6 @@ impl CompletionProvider for MessageEditorCompletionProvider {
        })
    }

-    fn resolve_completions(
-        &self,
-        _buffer: Entity<Buffer>,
-        _completion_indices: Vec<usize>,
-        _completions: Rc<RefCell<Box<[Completion]>>>,
-        _cx: &mut Context<Editor>,
-    ) -> Task<anyhow::Result<bool>> {
-        Task::ready(Ok(false))
-    }
-
    fn is_completion_trigger(
        &self,
        _buffer: &Entity<Buffer>,
@@ -255,7 +244,7 @@ impl MessageEditor {
        {
            if !candidates.is_empty() {
                return cx.spawn(async move |_, cx| {
-                    let completion_response = Self::resolve_completions_for_candidates(
+                    let completion_response = Self::completions_for_candidates(
                        &cx,
                        query.as_str(),
                        &candidates,
@@ -273,7 +262,7 @@ impl MessageEditor {
        {
            if !candidates.is_empty() {
                return cx.spawn(async move |_, cx| {
-                    let completion_response = Self::resolve_completions_for_candidates(
+                    let completion_response = Self::completions_for_candidates(
                        &cx,
                        query.as_str(),
                        candidates,
@@ -292,7 +281,7 @@ impl MessageEditor {
        }]))
    }

-    async fn resolve_completions_for_candidates(
+    async fn completions_for_candidates(
        cx: &AsyncApp,
        query: &str,
        candidates: &[StringMatchCandidate],
--- a/crates/context_server/Cargo.toml
+++ b/crates/context_server/Cargo.toml
@@ -11,6 +11,9 @@ workspace = true
 [lib]
 path = "src/context_server.rs"

+[features]
+test-support = []
+
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
--- a/crates/context_server/src/context_server.rs
+++ b/crates/context_server/src/context_server.rs
@@ -1,5 +1,7 @@
 pub mod client;
 pub mod protocol;
+#[cfg(any(test, feature = "test-support"))]
+pub mod test;
 pub mod transport;
 pub mod types;

--- a/crates/context_server/src/protocol.rs
+++ b/crates/context_server/src/protocol.rs
@@ -6,10 +6,9 @@
 //! of messages.

 use anyhow::Result;
-use collections::HashMap;

 use crate::client::Client;
-use crate::types;
+use crate::types::{self, Request};

 pub struct ModelContextProtocol {
    inner: Client,
@@ -43,7 +42,7 @@ impl ModelContextProtocol {

        let response: types::InitializeResponse = self
            .inner
-            .request(types::RequestType::Initialize.as_str(), params)
+            .request(types::request::Initialize::METHOD, params)
            .await?;

        anyhow::ensure!(
@@ -94,137 +93,7 @@ impl InitializedContextServerProtocol {
        }
    }

-    fn check_capability(&self, capability: ServerCapability) -> Result<()> {
-        anyhow::ensure!(
-            self.capable(capability),
-            "Server does not support {capability:?} capability"
-        );
-        Ok(())
-    }
-
-    /// List the MCP prompts.
-    pub async fn list_prompts(&self) -> Result<Vec<types::Prompt>> {
-        self.check_capability(ServerCapability::Prompts)?;
-
-        let response: types::PromptsListResponse = self
-            .inner
-            .request(
-                types::RequestType::PromptsList.as_str(),
-                serde_json::json!({}),
-            )
-            .await?;
-
-        Ok(response.prompts)
-    }
-
-    /// List the MCP resources.
-    pub async fn list_resources(&self) -> Result<types::ResourcesListResponse> {
-        self.check_capability(ServerCapability::Resources)?;
-
-        let response: types::ResourcesListResponse = self
-            .inner
-            .request(
-                types::RequestType::ResourcesList.as_str(),
-                serde_json::json!({}),
-            )
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Executes a prompt with the given arguments and returns the result.
-    pub async fn run_prompt<P: AsRef<str>>(
-        &self,
-        prompt: P,
-        arguments: HashMap<String, String>,
-    ) -> Result<types::PromptsGetResponse> {
-        self.check_capability(ServerCapability::Prompts)?;
-
-        let params = types::PromptsGetParams {
-            name: prompt.as_ref().to_string(),
-            arguments: Some(arguments),
-            meta: None,
-        };
-
-        let response: types::PromptsGetResponse = self
-            .inner
-            .request(types::RequestType::PromptsGet.as_str(), params)
-            .await?;
-
-        Ok(response)
-    }
-
-    pub async fn completion<P: Into<String>>(
-        &self,
-        reference: types::CompletionReference,
-        argument: P,
-        value: P,
-    ) -> Result<types::Completion> {
-        let params = types::CompletionCompleteParams {
-            r#ref: reference,
-            argument: types::CompletionArgument {
-                name: argument.into(),
-                value: value.into(),
-            },
-            meta: None,
-        };
-        let result: types::CompletionCompleteResponse = self
-            .inner
-            .request(types::RequestType::CompletionComplete.as_str(), params)
-            .await?;
-
-        let completion = types::Completion {
-            values: result.completion.values,
-            total: types::CompletionTotal::from_options(
-                result.completion.has_more,
-                result.completion.total,
-            ),
-        };
-
-        Ok(completion)
-    }
-
-    /// List MCP tools.
-    pub async fn list_tools(&self) -> Result<types::ListToolsResponse> {
-        self.check_capability(ServerCapability::Tools)?;
-
-        let response = self
-            .inner
-            .request::<types::ListToolsResponse>(types::RequestType::ListTools.as_str(), ())
-            .await?;
-
-        Ok(response)
-    }
-
-    /// Executes a tool with the given arguments
-    pub async fn run_tool<P: AsRef<str>>(
-        &self,
-        tool: P,
-        arguments: Option<HashMap<String, serde_json::Value>>,
-    ) -> Result<types::CallToolResponse> {
-        self.check_capability(ServerCapability::Tools)?;
-
-        let params = types::CallToolParams {
-            name: tool.as_ref().to_string(),
-            arguments,
-            meta: None,
-        };
-
-        let response: types::CallToolResponse = self
-            .inner
-            .request(types::RequestType::CallTool.as_str(), params)
-            .await?;
-
-        Ok(response)
-    }
-}
-
-impl InitializedContextServerProtocol {
-    pub async fn request<R: serde::de::DeserializeOwned>(
-        &self,
-        method: &str,
-        params: impl serde::Serialize,
-    ) -> Result<R> {
-        self.inner.request(method, params).await
+    pub async fn request<T: Request>(&self, params: T::Params) -> Result<T::Response> {
+        self.inner.request(T::METHOD, params).await
    }
 }
--- a/crates/context_server/src/test.rs
+++ b/crates/context_server/src/test.rs
@@ -0,0 +1,118 @@
+use anyhow::Context as _;
+use collections::HashMap;
+use futures::{Stream, StreamExt as _, lock::Mutex};
+use gpui::BackgroundExecutor;
+use std::{pin::Pin, sync::Arc};
+
+use crate::{
+    transport::Transport,
+    types::{Implementation, InitializeResponse, ProtocolVersion, ServerCapabilities},
+};
+
+pub fn create_fake_transport(
+    name: impl Into<String>,
+    executor: BackgroundExecutor,
+) -> FakeTransport {
+    let name = name.into();
+    FakeTransport::new(executor).on_request::<crate::types::request::Initialize>(move |_params| {
+        create_initialize_response(name.clone())
+    })
+}
+
+fn create_initialize_response(server_name: String) -> InitializeResponse {
+    InitializeResponse {
+        protocol_version: ProtocolVersion(crate::types::LATEST_PROTOCOL_VERSION.to_string()),
+        server_info: Implementation {
+            name: server_name,
+            version: "1.0.0".to_string(),
+        },
+        capabilities: ServerCapabilities::default(),
+        meta: None,
+    }
+}
+
+pub struct FakeTransport {
+    request_handlers:
+        HashMap<&'static str, Arc<dyn Fn(serde_json::Value) -> serde_json::Value + Send + Sync>>,
+    tx: futures::channel::mpsc::UnboundedSender<String>,
+    rx: Arc<Mutex<futures::channel::mpsc::UnboundedReceiver<String>>>,
+    executor: BackgroundExecutor,
+}
+
+impl FakeTransport {
+    pub fn new(executor: BackgroundExecutor) -> Self {
+        let (tx, rx) = futures::channel::mpsc::unbounded();
+        Self {
+            request_handlers: Default::default(),
+            tx,
+            rx: Arc::new(Mutex::new(rx)),
+            executor,
+        }
+    }
+
+    pub fn on_request<T: crate::types::Request>(
+        mut self,
+        handler: impl Fn(T::Params) -> T::Response + Send + Sync + 'static,
+    ) -> Self {
+        self.request_handlers.insert(
+            T::METHOD,
+            Arc::new(move |value| {
+                let params = value.get("params").expect("Missing parameters").clone();
+                let params: T::Params =
+                    serde_json::from_value(params).expect("Invalid parameters received");
+                let response = handler(params);
+                serde_json::to_value(response).unwrap()
+            }),
+        );
+        self
+    }
+}
+
+#[async_trait::async_trait]
+impl Transport for FakeTransport {
+    async fn send(&self, message: String) -> anyhow::Result<()> {
+        if let Ok(msg) = serde_json::from_str::<serde_json::Value>(&message) {
+            let id = msg.get("id").and_then(|id| id.as_u64()).unwrap_or(0);
+
+            if let Some(method) = msg.get("method") {
+                let method = method.as_str().expect("Invalid method received");
+                if let Some(handler) = self.request_handlers.get(method) {
+                    let payload = handler(msg);
+                    let response = serde_json::json!({
+                        "jsonrpc": "2.0",
+                        "id": id,
+                        "result": payload
+                    });
+                    self.tx
+                        .unbounded_send(response.to_string())
+                        .context("sending a message")?;
+                } else {
+                    log::debug!("No handler registered for MCP request '{method}'");
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn receive(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
+        let rx = self.rx.clone();
+        let executor = self.executor.clone();
+        Box::pin(futures::stream::unfold(rx, move |rx| {
+            let executor = executor.clone();
+            async move {
+                let mut rx_guard = rx.lock().await;
+                executor.simulate_random_delay().await;
+                if let Some(message) = rx_guard.next().await {
+                    drop(rx_guard);
+                    Some((message, rx))
+                } else {
+                    None
+                }
+            }
+        }))
+    }
+
+    fn receive_err(&self) -> Pin<Box<dyn Stream<Item = String> + Send>> {
+        Box::pin(futures::stream::empty())
+    }
+}
--- a/crates/context_server/src/types.rs
+++ b/crates/context_server/src/types.rs
@@ -1,76 +1,92 @@
 use collections::HashMap;
+use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use url::Url;

 pub const LATEST_PROTOCOL_VERSION: &str = "2024-11-05";

-pub enum RequestType {
-    Initialize,
-    CallTool,
-    ResourcesUnsubscribe,
-    ResourcesSubscribe,
-    ResourcesRead,
-    ResourcesList,
-    LoggingSetLevel,
-    PromptsGet,
-    PromptsList,
-    CompletionComplete,
-    Ping,
-    ListTools,
-    ListResourceTemplates,
-    ListRoots,
+pub mod request {
+    use super::*;
+
+    macro_rules! request {
+        ($method:expr, $name:ident, $params:ty, $response:ty) => {
+            pub struct $name;
+
+            impl Request for $name {
+                type Params = $params;
+                type Response = $response;
+                const METHOD: &'static str = $method;
+            }
+        };
+    }
+
+    request!(
+        "initialize",
+        Initialize,
+        InitializeParams,
+        InitializeResponse
+    );
+    request!("tools/call", CallTool, CallToolParams, CallToolResponse);
+    request!(
+        "resources/unsubscribe",
+        ResourcesUnsubscribe,
+        ResourcesUnsubscribeParams,
+        ()
+    );
+    request!(
+        "resources/subscribe",
+        ResourcesSubscribe,
+        ResourcesSubscribeParams,
+        ()
+    );
+    request!(
+        "resources/read",
+        ResourcesRead,
+        ResourcesReadParams,
+        ResourcesReadResponse
+    );
+    request!("resources/list", ResourcesList, (), ResourcesListResponse);
+    request!(
+        "logging/setLevel",
+        LoggingSetLevel,
+        LoggingSetLevelParams,
+        ()
+    );
+    request!(
+        "prompts/get",
+        PromptsGet,
+        PromptsGetParams,
+        PromptsGetResponse
+    );
+    request!("prompts/list", PromptsList, (), PromptsListResponse);
+    request!(
+        "completion/complete",
+        CompletionComplete,
+        CompletionCompleteParams,
+        CompletionCompleteResponse
+    );
+    request!("ping", Ping, (), ());
+    request!("tools/list", ListTools, (), ListToolsResponse);
+    request!(
+        "resources/templates/list",
+        ListResourceTemplates,
+        (),
+        ListResourceTemplatesResponse
+    );
+    request!("roots/list", ListRoots, (), ListRootsResponse);
 }

-impl RequestType {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            RequestType::Initialize => "initialize",
-            RequestType::CallTool => "tools/call",
-            RequestType::ResourcesUnsubscribe => "resources/unsubscribe",
-            RequestType::ResourcesSubscribe => "resources/subscribe",
-            RequestType::ResourcesRead => "resources/read",
-            RequestType::ResourcesList => "resources/list",
-            RequestType::LoggingSetLevel => "logging/setLevel",
-            RequestType::PromptsGet => "prompts/get",
-            RequestType::PromptsList => "prompts/list",
-            RequestType::CompletionComplete => "completion/complete",
-            RequestType::Ping => "ping",
-            RequestType::ListTools => "tools/list",
-            RequestType::ListResourceTemplates => "resources/templates/list",
-            RequestType::ListRoots => "roots/list",
-        }
-    }
-}
-
-impl TryFrom<&str> for RequestType {
-    type Error = ();
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        match s {
-            "initialize" => Ok(RequestType::Initialize),
-            "tools/call" => Ok(RequestType::CallTool),
-            "resources/unsubscribe" => Ok(RequestType::ResourcesUnsubscribe),
-            "resources/subscribe" => Ok(RequestType::ResourcesSubscribe),
-            "resources/read" => Ok(RequestType::ResourcesRead),
-            "resources/list" => Ok(RequestType::ResourcesList),
-            "logging/setLevel" => Ok(RequestType::LoggingSetLevel),
-            "prompts/get" => Ok(RequestType::PromptsGet),
-            "prompts/list" => Ok(RequestType::PromptsList),
-            "completion/complete" => Ok(RequestType::CompletionComplete),
-            "ping" => Ok(RequestType::Ping),
-            "tools/list" => Ok(RequestType::ListTools),
-            "resources/templates/list" => Ok(RequestType::ListResourceTemplates),
-            "roots/list" => Ok(RequestType::ListRoots),
-            _ => Err(()),
-        }
-    }
+pub trait Request {
+    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
+    type Response: DeserializeOwned + Serialize + Send + Sync + 'static;
+    const METHOD: &'static str;
 }

 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct ProtocolVersion(pub String);

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct InitializeParams {
    pub protocol_version: ProtocolVersion,
@@ -80,7 +96,7 @@ pub struct InitializeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolParams {
    pub name: String,
@@ -90,7 +106,7 @@ pub struct CallToolParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesUnsubscribeParams {
    pub uri: Url,
@@ -98,7 +114,7 @@ pub struct ResourcesUnsubscribeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesSubscribeParams {
    pub uri: Url,
@@ -106,7 +122,7 @@ pub struct ResourcesSubscribeParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadParams {
    pub uri: Url,
@@ -114,7 +130,7 @@ pub struct ResourcesReadParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LoggingSetLevelParams {
    pub level: LoggingLevel,
@@ -122,7 +138,7 @@ pub struct LoggingSetLevelParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetParams {
    pub name: String,
@@ -132,37 +148,40 @@ pub struct PromptsGetParams {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteParams {
-    pub r#ref: CompletionReference,
+    #[serde(rename = "ref")]
+    pub reference: CompletionReference,
    pub argument: CompletionArgument,
    #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum CompletionReference {
    Prompt(PromptReference),
    Resource(ResourceReference),
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptReference {
-    pub r#type: PromptReferenceType,
+    #[serde(rename = "type")]
+    pub ty: PromptReferenceType,
    pub name: String,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourceReference {
-    pub r#type: PromptReferenceType,
+    #[serde(rename = "type")]
+    pub ty: PromptReferenceType,
    pub uri: Url,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PromptReferenceType {
    #[serde(rename = "ref/prompt")]
@@ -171,7 +190,7 @@ pub enum PromptReferenceType {
    Resource,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionArgument {
    pub name: String,
@@ -188,7 +207,7 @@ pub struct InitializeResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesReadResponse {
    pub contents: Vec<ResourceContentsType>,
@@ -196,14 +215,14 @@ pub struct ResourcesReadResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum ResourceContentsType {
    Text(TextResourceContents),
    Blob(BlobResourceContents),
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ResourcesListResponse {
    pub resources: Vec<Resource>,
@@ -220,7 +239,7 @@ pub struct SamplingMessage {
    pub content: MessageContent,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CreateMessageRequest {
    pub messages: Vec<SamplingMessage>,
@@ -296,7 +315,7 @@ pub struct MessageAnnotations {
    pub priority: Option<f64>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsGetResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -306,7 +325,7 @@ pub struct PromptsGetResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptsListResponse {
    pub prompts: Vec<Prompt>,
@@ -316,7 +335,7 @@ pub struct PromptsListResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionCompleteResponse {
    pub completion: CompletionResult,
@@ -324,7 +343,7 @@ pub struct CompletionCompleteResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CompletionResult {
    pub values: Vec<String>,
@@ -336,7 +355,7 @@ pub struct CompletionResult {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Prompt {
    pub name: String,
@@ -346,7 +365,7 @@ pub struct Prompt {
    pub arguments: Option<Vec<PromptArgument>>,
 }

-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PromptArgument {
    pub name: String,
@@ -509,7 +528,7 @@ pub struct ModelHint {
    pub name: Option<String>,
 }

-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum NotificationType {
    Initialized,
@@ -589,7 +608,7 @@ pub struct Completion {
    pub total: CompletionTotal,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CallToolResponse {
    pub content: Vec<ToolResponseContent>,
@@ -620,7 +639,7 @@ pub struct ListToolsResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListResourceTemplatesResponse {
    pub resource_templates: Vec<ResourceTemplate>,
@@ -630,7 +649,7 @@ pub struct ListResourceTemplatesResponse {
    pub meta: Option<HashMap<String, serde_json::Value>>,
 }

-#[derive(Debug, Deserialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListRootsResponse {
    pub roots: Vec<Root>,
--- a/crates/copilot/src/copilot.rs
+++ b/crates/copilot/src/copilot.rs
@@ -520,7 +520,7 @@ impl Copilot {

            let server = cx
                .update(|cx| {
-                    let mut params = server.default_initialize_params(cx);
+                    let mut params = server.default_initialize_params(false, cx);
                    params.initialization_options = Some(editor_info_json);
                    server.initialize(params, configuration.into(), cx)
                })?
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -8,6 +8,7 @@ use chrono::DateTime;
 use collections::HashSet;
 use fs::Fs;
 use futures::{AsyncBufReadExt, AsyncReadExt, StreamExt, io::BufReader, stream::BoxStream};
+use gpui::WeakEntity;
 use gpui::{App, AsyncApp, Global, prelude::*};
 use http_client::{AsyncBody, HttpClient, Method, Request as HttpRequest};
 use itertools::Itertools;
@@ -15,9 +16,12 @@ use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_dir;

-pub const COPILOT_CHAT_COMPLETION_URL: &str = "https://api.githubcopilot.com/chat/completions";
-pub const COPILOT_CHAT_AUTH_URL: &str = "https://api.github.com/copilot_internal/v2/token";
-pub const COPILOT_CHAT_MODELS_URL: &str = "https://api.githubcopilot.com/models";
+#[derive(Default, Clone, Debug, PartialEq)]
+pub struct CopilotChatSettings {
+    pub api_url: Arc<str>,
+    pub auth_url: Arc<str>,
+    pub models_url: Arc<str>,
+}

 // Copilot's base model; defined by Microsoft in premium requests table
 // This will be moved to the front of the Copilot model list, and will be used for
@@ -340,6 +344,7 @@ impl Global for GlobalCopilotChat {}
 pub struct CopilotChat {
    oauth_token: Option<String>,
    api_token: Option<ApiToken>,
+    settings: CopilotChatSettings,
    models: Option<Vec<Model>>,
    client: Arc<dyn HttpClient>,
 }
@@ -373,53 +378,30 @@ impl CopilotChat {
            .map(|model| model.0.clone())
    }

-    pub fn new(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &App) -> Self {
+    fn new(fs: Arc<dyn Fs>, client: Arc<dyn HttpClient>, cx: &mut Context<Self>) -> Self {
        let config_paths: HashSet<PathBuf> = copilot_chat_config_paths().into_iter().collect();
        let dir_path = copilot_chat_config_dir();
+        let settings = CopilotChatSettings::default();
+        cx.spawn(async move |this, cx| {
+            let mut parent_watch_rx = watch_config_dir(
+                cx.background_executor(),
+                fs.clone(),
+                dir_path.clone(),
+                config_paths,
+            );
+            while let Some(contents) = parent_watch_rx.next().await {
+                let oauth_token = extract_oauth_token(contents);

-        cx.spawn({
-            let client = client.clone();
-            async move |cx| {
-                let mut parent_watch_rx = watch_config_dir(
-                    cx.background_executor(),
-                    fs.clone(),
-                    dir_path.clone(),
-                    config_paths,
-                );
-                while let Some(contents) = parent_watch_rx.next().await {
-                    let oauth_token = extract_oauth_token(contents);
-                    cx.update(|cx| {
-                        if let Some(this) = Self::global(cx).as_ref() {
-                            this.update(cx, |this, cx| {
-                                this.oauth_token = oauth_token.clone();
-                                cx.notify();
-                            });
-                        }
-                    })?;
+                this.update(cx, |this, cx| {
+                    this.oauth_token = oauth_token.clone();
+                    cx.notify();
+                })?;

-                    if let Some(ref oauth_token) = oauth_token {
-                        let api_token = request_api_token(oauth_token, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.api_token = Some(api_token.clone());
-                                    cx.notify();
-                                });
-                            }
-                        })?;
-                        let models = get_models(api_token.api_key, client.clone()).await?;
-                        cx.update(|cx| {
-                            if let Some(this) = Self::global(cx).as_ref() {
-                                this.update(cx, |this, cx| {
-                                    this.models = Some(models);
-                                    cx.notify();
-                                });
-                            }
-                        })?;
-                    }
+                if oauth_token.is_some() {
+                    Self::update_models(&this, cx).await?;
                }
-                anyhow::Ok(())
            }
+            anyhow::Ok(())
        })
        .detach_and_log_err(cx);

@@ -427,10 +409,42 @@ impl CopilotChat {
            oauth_token: None,
            api_token: None,
            models: None,
+            settings,
            client,
        }
    }

+    async fn update_models(this: &WeakEntity<Self>, cx: &mut AsyncApp) -> Result<()> {
+        let (oauth_token, client, auth_url) = this.read_with(cx, |this, _| {
+            (
+                this.oauth_token.clone(),
+                this.client.clone(),
+                this.settings.auth_url.clone(),
+            )
+        })?;
+        let api_token = request_api_token(
+            &oauth_token.ok_or_else(|| {
+                anyhow!("OAuth token is missing while updating Copilot Chat models")
+            })?,
+            auth_url,
+            client.clone(),
+        )
+        .await?;
+
+        let models_url = this.update(cx, |this, cx| {
+            this.api_token = Some(api_token.clone());
+            cx.notify();
+            this.settings.models_url.clone()
+        })?;
+        let models = get_models(models_url, api_token.api_key, client.clone()).await?;
+
+        this.update(cx, |this, cx| {
+            this.models = Some(models);
+            cx.notify();
+        })?;
+        anyhow::Ok(())
+    }
+
    pub fn is_authenticated(&self) -> bool {
        self.oauth_token.is_some()
    }
@@ -449,20 +463,23 @@ impl CopilotChat {
            .flatten()
            .context("Copilot chat is not enabled")?;

-        let (oauth_token, api_token, client) = this.read_with(&cx, |this, _| {
-            (
-                this.oauth_token.clone(),
-                this.api_token.clone(),
-                this.client.clone(),
-            )
-        })?;
+        let (oauth_token, api_token, client, api_url, auth_url) =
+            this.read_with(&cx, |this, _| {
+                (
+                    this.oauth_token.clone(),
+                    this.api_token.clone(),
+                    this.client.clone(),
+                    this.settings.api_url.clone(),
+                    this.settings.auth_url.clone(),
+                )
+            })?;

        let oauth_token = oauth_token.context("No OAuth token available")?;

        let token = match api_token {
            Some(api_token) if api_token.remaining_seconds() > 5 * 60 => api_token.clone(),
            _ => {
-                let token = request_api_token(&oauth_token, client.clone()).await?;
+                let token = request_api_token(&oauth_token, auth_url, client.clone()).await?;
                this.update(&mut cx, |this, cx| {
                    this.api_token = Some(token.clone());
                    cx.notify();
@@ -471,12 +488,28 @@ impl CopilotChat {
            }
        };

-        stream_completion(client.clone(), token.api_key, request).await
+        stream_completion(client.clone(), token.api_key, api_url, request).await
+    }
+
+    pub fn set_settings(&mut self, settings: CopilotChatSettings, cx: &mut Context<Self>) {
+        let same_settings = self.settings == settings;
+        self.settings = settings;
+        if !same_settings {
+            cx.spawn(async move |this, cx| {
+                Self::update_models(&this, cx).await?;
+                Ok::<_, anyhow::Error>(())
+            })
+            .detach();
+        }
    }
 }

-async fn get_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
-    let all_models = request_models(api_token, client).await?;
+async fn get_models(
+    models_url: Arc<str>,
+    api_token: String,
+    client: Arc<dyn HttpClient>,
+) -> Result<Vec<Model>> {
+    let all_models = request_models(models_url, api_token, client).await?;

    let mut models: Vec<Model> = all_models
        .into_iter()
@@ -504,10 +537,14 @@ async fn get_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Ve
    Ok(models)
 }

-async fn request_models(api_token: String, client: Arc<dyn HttpClient>) -> Result<Vec<Model>> {
+async fn request_models(
+    models_url: Arc<str>,
+    api_token: String,
+    client: Arc<dyn HttpClient>,
+) -> Result<Vec<Model>> {
    let request_builder = HttpRequest::builder()
        .method(Method::GET)
-        .uri(COPILOT_CHAT_MODELS_URL)
+        .uri(models_url.as_ref())
        .header("Authorization", format!("Bearer {}", api_token))
        .header("Content-Type", "application/json")
        .header("Copilot-Integration-Id", "vscode-chat");
@@ -531,10 +568,14 @@ async fn request_models(api_token: String, client: Arc<dyn HttpClient>) -> Resul
    Ok(models)
 }

-async fn request_api_token(oauth_token: &str, client: Arc<dyn HttpClient>) -> Result<ApiToken> {
+async fn request_api_token(
+    oauth_token: &str,
+    auth_url: Arc<str>,
+    client: Arc<dyn HttpClient>,
+) -> Result<ApiToken> {
    let request_builder = HttpRequest::builder()
        .method(Method::GET)
-        .uri(COPILOT_CHAT_AUTH_URL)
+        .uri(auth_url.as_ref())
        .header("Authorization", format!("token {}", oauth_token))
        .header("Accept", "application/json");

@@ -579,6 +620,7 @@ fn extract_oauth_token(contents: String) -> Option<String> {
 async fn stream_completion(
    client: Arc<dyn HttpClient>,
    api_key: String,
+    completion_url: Arc<str>,
    request: Request,
 ) -> Result<BoxStream<'static, Result<ResponseEvent>>> {
    let is_vision_request = request.messages.last().map_or(false, |message| match message {
@@ -592,7 +634,7 @@ async fn stream_completion(

    let request_builder = HttpRequest::builder()
        .method(Method::POST)
-        .uri(COPILOT_CHAT_COMPLETION_URL)
+        .uri(completion_url.as_ref())
        .header(
            "Editor-Version",
            format!(
--- a/crates/debugger_ui/Cargo.toml
+++ b/crates/debugger_ui/Cargo.toml
@@ -39,6 +39,7 @@ file_icons.workspace = true
 futures.workspace = true
 fuzzy.workspace = true
 gpui.workspace = true
+itertools.workspace = true
 language.workspace = true
 log.workspace = true
 menu.workspace = true
--- a/crates/debugger_ui/src/debugger_panel.rs
+++ b/crates/debugger_ui/src/debugger_panel.rs
@@ -342,7 +342,7 @@ impl DebugPanel {
            window.defer(cx, move |window, cx| {
                workspace
                    .update(cx, |workspace, cx| {
-                        NewProcessModal::show(workspace, window, NewProcessMode::Launch, None, cx);
+                        NewProcessModal::show(workspace, window, NewProcessMode::Debug, None, cx);
                    })
                    .ok();
            });
--- a/crates/debugger_ui/src/new_process_modal.rs
+++ b/crates/debugger_ui/src/new_process_modal.rs
@@ -19,6 +19,7 @@ use gpui::{
    InteractiveText, KeyContext, PromptButton, PromptLevel, Render, StyledText, Subscription,
    TextStyle, UnderlineStyle, WeakEntity,
 };
+use itertools::Itertools as _;
 use picker::{Picker, PickerDelegate, highlighted_match_with_paths::HighlightedMatch};
 use project::{ProjectPath, TaskContexts, TaskSourceKind, task_store::TaskStore};
 use settings::{Settings, initial_local_debug_tasks_content};
@@ -49,7 +50,7 @@ pub(super) struct NewProcessModal {
    mode: NewProcessMode,
    debug_picker: Entity<Picker<DebugDelegate>>,
    attach_mode: Entity<AttachMode>,
-    launch_mode: Entity<LaunchMode>,
+    launch_mode: Entity<ConfigureMode>,
    task_mode: TaskMode,
    debugger: Option<DebugAdapterName>,
    // save_scenario_state: Option<SaveScenarioState>,
@@ -97,13 +98,13 @@ impl NewProcessModal {
                workspace.toggle_modal(window, cx, |window, cx| {
                    let attach_mode = AttachMode::new(None, workspace_handle.clone(), window, cx);

-                    let launch_picker = cx.new(|cx| {
+                    let debug_picker = cx.new(|cx| {
                        let delegate =
                            DebugDelegate::new(debug_panel.downgrade(), task_store.clone());
                        Picker::uniform_list(delegate, window, cx).modal(false)
                    });

-                    let configure_mode = LaunchMode::new(window, cx);
+                    let configure_mode = ConfigureMode::new(window, cx);

                    let task_overrides = Some(TaskOverrides { reveal_target });

@@ -122,7 +123,7 @@ impl NewProcessModal {
                    };

                    let _subscriptions = [
-                        cx.subscribe(&launch_picker, |_, _, _, cx| {
+                        cx.subscribe(&debug_picker, |_, _, _, cx| {
                            cx.emit(DismissEvent);
                        }),
                        cx.subscribe(
@@ -137,19 +138,76 @@ impl NewProcessModal {
                    ];

                    cx.spawn_in(window, {
-                        let launch_picker = launch_picker.downgrade();
+                        let debug_picker = debug_picker.downgrade();
                        let configure_mode = configure_mode.downgrade();
                        let task_modal = task_mode.task_modal.downgrade();
+                        let workspace = workspace_handle.clone();

                        async move |this, cx| {
                            let task_contexts = task_contexts.await;
                            let task_contexts = Arc::new(task_contexts);
-                            launch_picker
+                            let lsp_task_sources = task_contexts.lsp_task_sources.clone();
+                            let task_position = task_contexts.latest_selection;
+                            // Get LSP tasks and filter out based on language vs lsp preference
+                            let (lsp_tasks, prefer_lsp) =
+                                workspace.update(cx, |workspace, cx| {
+                                    let lsp_tasks = editor::lsp_tasks(
+                                        workspace.project().clone(),
+                                        &lsp_task_sources,
+                                        task_position,
+                                        cx,
+                                    );
+                                    let prefer_lsp = workspace
+                                        .active_item(cx)
+                                        .and_then(|item| item.downcast::<Editor>())
+                                        .map(|editor| {
+                                            editor
+                                                .read(cx)
+                                                .buffer()
+                                                .read(cx)
+                                                .language_settings(cx)
+                                                .tasks
+                                                .prefer_lsp
+                                        })
+                                        .unwrap_or(false);
+                                    (lsp_tasks, prefer_lsp)
+                                })?;
+
+                            let lsp_tasks = lsp_tasks.await;
+                            let add_current_language_tasks = !prefer_lsp || lsp_tasks.is_empty();
+
+                            let lsp_tasks = lsp_tasks
+                                .into_iter()
+                                .flat_map(|(kind, tasks_with_locations)| {
+                                    tasks_with_locations
+                                        .into_iter()
+                                        .sorted_by_key(|(location, task)| {
+                                            (location.is_none(), task.resolved_label.clone())
+                                        })
+                                        .map(move |(_, task)| (kind.clone(), task))
+                                })
+                                .collect::<Vec<_>>();
+
+                            let Some(task_inventory) = task_store
+                                .update(cx, |task_store, _| task_store.task_inventory().cloned())?
+                            else {
+                                return Ok(());
+                            };
+
+                            let (used_tasks, current_resolved_tasks) =
+                                task_inventory.update(cx, |task_inventory, cx| {
+                                    task_inventory
+                                        .used_and_current_resolved_tasks(&task_contexts, cx)
+                                })?;
+
+                            debug_picker
                                .update_in(cx, |picker, window, cx| {
-                                    picker.delegate.task_contexts_loaded(
+                                    picker.delegate.tasks_loaded(
                                        task_contexts.clone(),
                                        languages,
-                                        window,
+                                        lsp_tasks.clone(),
+                                        current_resolved_tasks.clone(),
+                                        add_current_language_tasks,
                                        cx,
                                    );
                                    picker.refresh(window, cx);
@@ -170,7 +228,15 @@ impl NewProcessModal {

                            task_modal
                                .update_in(cx, |task_modal, window, cx| {
-                                    task_modal.task_contexts_loaded(task_contexts, window, cx);
+                                    task_modal.tasks_loaded(
+                                        task_contexts,
+                                        lsp_tasks,
+                                        used_tasks,
+                                        current_resolved_tasks,
+                                        add_current_language_tasks,
+                                        window,
+                                        cx,
+                                    );
                                })
                                .ok();

@@ -178,12 +244,14 @@ impl NewProcessModal {
                                cx.notify();
                            })
                            .ok();
+
+                            anyhow::Ok(())
                        }
                    })
                    .detach();

                    Self {
-                        debug_picker: launch_picker,
+                        debug_picker,
                        attach_mode,
                        launch_mode: configure_mode,
                        task_mode,
@@ -820,18 +888,18 @@ impl RenderOnce for AttachMode {
 }

 #[derive(Clone)]
-pub(super) struct LaunchMode {
+pub(super) struct ConfigureMode {
    program: Entity<Editor>,
    cwd: Entity<Editor>,
    stop_on_entry: ToggleState,
    // save_to_debug_json: ToggleState,
 }

-impl LaunchMode {
+impl ConfigureMode {
    pub(super) fn new(window: &mut Window, cx: &mut App) -> Entity<Self> {
        let program = cx.new(|cx| Editor::single_line(window, cx));
        program.update(cx, |this, cx| {
-            this.set_placeholder_text("ENV=Zed ~/bin/debugger --launch", cx);
+            this.set_placeholder_text("ENV=Zed ~/bin/program --option", cx);
        });

        let cwd = cx.new(|cx| Editor::single_line(window, cx));
@@ -919,7 +987,7 @@ impl LaunchMode {
                    .child(adapter_menu),
            )
            .child(
-                Label::new("Debugger Program")
+                Label::new("Program")
                    .size(ui::LabelSize::Small)
                    .color(Color::Muted),
            )
@@ -1067,21 +1135,29 @@ impl DebugDelegate {
        (language, scenario)
    }

-    pub fn task_contexts_loaded(
+    pub fn tasks_loaded(
        &mut self,
        task_contexts: Arc<TaskContexts>,
        languages: Arc<LanguageRegistry>,
-        _window: &mut Window,
+        lsp_tasks: Vec<(TaskSourceKind, task::ResolvedTask)>,
+        current_resolved_tasks: Vec<(TaskSourceKind, task::ResolvedTask)>,
+        add_current_language_tasks: bool,
        cx: &mut Context<Picker<Self>>,
    ) {
-        self.task_contexts = Some(task_contexts);
+        self.task_contexts = Some(task_contexts.clone());

        let (recent, scenarios) = self
            .task_store
            .update(cx, |task_store, cx| {
                task_store.task_inventory().map(|inventory| {
                    inventory.update(cx, |inventory, cx| {
-                        inventory.list_debug_scenarios(self.task_contexts.as_ref().unwrap(), cx)
+                        inventory.list_debug_scenarios(
+                            &task_contexts,
+                            lsp_tasks,
+                            current_resolved_tasks,
+                            add_current_language_tasks,
+                            cx,
+                        )
                    })
                })
            })
@@ -1257,12 +1333,17 @@ impl PickerDelegate for DebugDelegate {
        .map(|icon| icon.color(Color::Muted).size(IconSize::Small));
        let indicator = if matches!(task_kind, Some(TaskSourceKind::Lsp { .. })) {
            Some(Indicator::icon(
-                Icon::new(IconName::BoltFilled).color(Color::Muted),
+                Icon::new(IconName::BoltFilled)
+                    .color(Color::Muted)
+                    .size(IconSize::Small),
            ))
        } else {
            None
        };
-        let icon = icon.map(|icon| IconWithIndicator::new(icon, indicator));
+        let icon = icon.map(|icon| {
+            IconWithIndicator::new(icon, indicator)
+                .indicator_border_color(Some(cx.theme().colors().border_transparent))
+        });

        Some(
            ListItem::new(SharedString::from(format!("debug-scenario-selection-{ix}")))
--- a/crates/debugger_ui/src/session/running/console.rs
+++ b/crates/debugger_ui/src/session/running/console.rs
@@ -282,16 +282,6 @@ impl CompletionProvider for ConsoleQueryBarCompletionProvider {
        }
    }

-    fn resolve_completions(
-        &self,
-        _buffer: Entity<Buffer>,
-        _completion_indices: Vec<usize>,
-        _completions: Rc<RefCell<Box<[Completion]>>>,
-        _cx: &mut Context<Editor>,
-    ) -> gpui::Task<anyhow::Result<bool>> {
-        Task::ready(Ok(false))
-    }
-
    fn apply_additional_edits_for_completion(
        &self,
        _buffer: Entity<Buffer>,
--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -11,7 +11,7 @@ use editor::{
 };
 use gpui::{TestAppContext, VisualTestContext};
 use indoc::indoc;
-use language::Rope;
+use language::{DiagnosticSourceKind, Rope};
 use lsp::LanguageServerId;
 use pretty_assertions::assert_eq;
 use project::FakeFs;
@@ -105,7 +105,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            }
            ],
            version: None
-        }, &[], cx).unwrap();
+        }, None, DiagnosticSourceKind::Pushed, &[], cx).unwrap();
    });

    // Open the project diagnostics view while there are already diagnostics.
@@ -176,6 +176,8 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -261,6 +263,8 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                    ],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -368,6 +372,8 @@ async fn test_diagnostics_with_folds(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -465,6 +471,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -507,6 +515,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -548,6 +558,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -560,6 +572,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
                    diagnostics: vec![],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -600,6 +614,8 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
                    }],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -732,6 +748,8 @@ async fn test_random_diagnostics_blocks(cx: &mut TestAppContext, mut rng: StdRng
                                diagnostics: diagnostics.clone(),
                                version: None,
                            },
+                            None,
+                            DiagnosticSourceKind::Pushed,
                            &[],
                            cx,
                        )
@@ -919,6 +937,8 @@ async fn test_random_diagnostics_with_inlays(cx: &mut TestAppContext, mut rng: S
                                diagnostics: diagnostics.clone(),
                                version: None,
                            },
+                            None,
+                            DiagnosticSourceKind::Pushed,
                            &[],
                            cx,
                        )
@@ -974,6 +994,8 @@ async fn active_diagnostics_dismiss_after_invalidation(cx: &mut TestAppContext)
                            ..Default::default()
                        }],
                    },
+                    None,
+                    DiagnosticSourceKind::Pushed,
                    &[],
                    cx,
                )
@@ -1007,6 +1029,8 @@ async fn active_diagnostics_dismiss_after_invalidation(cx: &mut TestAppContext)
                        version: None,
                        diagnostics: Vec::new(),
                    },
+                    None,
+                    DiagnosticSourceKind::Pushed,
                    &[],
                    cx,
                )
@@ -1088,6 +1112,8 @@ async fn cycle_through_same_place_diagnostics(cx: &mut TestAppContext) {
                            },
                        ],
                    },
+                    None,
+                    DiagnosticSourceKind::Pushed,
                    &[],
                    cx,
                )
@@ -1226,6 +1252,8 @@ async fn test_diagnostics_with_links(cx: &mut TestAppContext) {
                        ..Default::default()
                    }],
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -1277,6 +1305,8 @@ async fn test_hover_diagnostic_and_info_popovers(cx: &mut gpui::TestAppContext)
                        ..Default::default()
                    }],
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
@@ -1378,6 +1408,8 @@ async fn test_diagnostics_with_code(cx: &mut TestAppContext) {
                    ],
                    version: None,
                },
+                None,
+                DiagnosticSourceKind::Pushed,
                &[],
                cx,
            )
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -49,6 +49,7 @@ pub struct EditorSettings {
    #[serde(default)]
    pub diagnostics_max_severity: Option<DiagnosticSeverity>,
    pub inline_code_actions: bool,
+    pub drag_and_drop_selection: bool,
 }

 #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
@@ -422,7 +423,7 @@ pub struct EditorSettingsContent {
    /// Default: always
    pub seed_search_query_from_cursor: Option<SeedQuerySetting>,
    pub use_smartcase_search: Option<bool>,
-    /// The key to use for adding multiple cursors
+    /// Determines the modifier to be used to add multiple cursors with the mouse. The open hover link mouse gestures will adapt such that it do not conflict with the multicursor modifier.
    ///
    /// Default: alt
    pub multi_cursor_modifier: Option<MultiCursorModifier>,
@@ -495,6 +496,11 @@ pub struct EditorSettingsContent {
    ///
    /// Default: true
    pub inline_code_actions: Option<bool>,
+
+    /// Whether to allow drag and drop text selection in buffer.
+    ///
+    /// Default: true
+    pub drag_and_drop_selection: Option<bool>,
 }

 // Toolbar related settings
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -6300,6 +6300,296 @@ async fn test_add_selection_above_below(cx: &mut TestAppContext) {
    ));
 }

+#[gpui::test]
+async fn test_add_selection_above_below_multi_cursor(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+    let mut cx = EditorTestContext::new(cx).await;
+
+    cx.set_state(indoc!(
+        r#"line onˇe
+           liˇne two
+           line three
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // test multiple cursors expand in the same direction
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           liˇne three
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // test multiple cursors expand below overflow
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           liˇne thˇree
+           liˇne foˇur"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test multiple cursors retrieves back correctly
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           liˇne thˇree
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test multiple cursor groups maintain independent direction - first expands up, second shrinks above
+    cx.assert_editor_state(indoc!(
+        r#"liˇne onˇe
+           liˇne two
+           line three
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.undo_selection(&Default::default(), window, cx);
+    });
+
+    // test undo
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           line three
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.redo_selection(&Default::default(), window, cx);
+    });
+
+    // test redo
+    cx.assert_editor_state(indoc!(
+        r#"liˇne onˇe
+           liˇne two
+           line three
+           line four"#
+    ));
+
+    cx.set_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           ijkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test multiple selections expand in the same direction
+    cx.assert_editor_state(indoc!(
+        r#"ab«cdˇ»
+           ef«ghˇ»
+           «iˇ»jkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test multiple selection upward overflow
+    cx.assert_editor_state(indoc!(
+        r#"ab«cdˇ»
+           «eˇ»f«ghˇ»
+           «iˇ»jkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // test multiple selection retrieves back correctly
+    cx.assert_editor_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           «iˇ»jkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // test multiple cursor groups maintain independent direction - first shrinks down, second expands below
+    cx.assert_editor_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           ij«klˇ»
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.undo_selection(&Default::default(), window, cx);
+    });
+
+    // test undo
+    cx.assert_editor_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           «iˇ»jkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.redo_selection(&Default::default(), window, cx);
+    });
+
+    // test redo
+    cx.assert_editor_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           ij«klˇ»
+           «mˇ»nop"#
+    ));
+}
+
+#[gpui::test]
+async fn test_add_selection_above_below_multi_cursor_existing_state(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+    let mut cx = EditorTestContext::new(cx).await;
+
+    cx.set_state(indoc!(
+        r#"line onˇe
+           liˇne two
+           line three
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+        editor.add_selection_below(&Default::default(), window, cx);
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // initial state with two multi cursor groups
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           liˇne thˇree
+           liˇne foˇur"#
+    ));
+
+    // add single cursor in middle - simulate opt click
+    cx.update_editor(|editor, window, cx| {
+        let new_cursor_point = DisplayPoint::new(DisplayRow(2), 4);
+        editor.begin_selection(new_cursor_point, true, 1, window, cx);
+        editor.end_selection(window, cx);
+    });
+
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇne twˇo
+           liˇneˇ thˇree
+           liˇne foˇur"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test new added selection expands above and existing selection shrinks
+    cx.assert_editor_state(indoc!(
+        r#"line onˇe
+           liˇneˇ twˇo
+           liˇneˇ thˇree
+           line four"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    // test new added selection expands above and existing selection shrinks
+    cx.assert_editor_state(indoc!(
+        r#"lineˇ onˇe
+           liˇneˇ twˇo
+           lineˇ three
+           line four"#
+    ));
+
+    // intial state with two selection groups
+    cx.set_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           ijkl
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_above(&Default::default(), window, cx);
+        editor.add_selection_above(&Default::default(), window, cx);
+    });
+
+    cx.assert_editor_state(indoc!(
+        r#"ab«cdˇ»
+           «eˇ»f«ghˇ»
+           «iˇ»jkl
+           «mˇ»nop"#
+    ));
+
+    // add single selection in middle - simulate opt drag
+    cx.update_editor(|editor, window, cx| {
+        let new_cursor_point = DisplayPoint::new(DisplayRow(2), 3);
+        editor.begin_selection(new_cursor_point, true, 1, window, cx);
+        editor.update_selection(
+            DisplayPoint::new(DisplayRow(2), 4),
+            0,
+            gpui::Point::<f32>::default(),
+            window,
+            cx,
+        );
+        editor.end_selection(window, cx);
+    });
+
+    cx.assert_editor_state(indoc!(
+        r#"ab«cdˇ»
+           «eˇ»f«ghˇ»
+           «iˇ»jk«lˇ»
+           «mˇ»nop"#
+    ));
+
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // test new added selection expands below, others shrinks from above
+    cx.assert_editor_state(indoc!(
+        r#"abcd
+           ef«ghˇ»
+           «iˇ»jk«lˇ»
+           «mˇ»no«pˇ»"#
+    ));
+}
+
 #[gpui::test]
 async fn test_select_next(cx: &mut TestAppContext) {
    init_test(cx, |_| {});
@@ -13650,6 +13940,8 @@ async fn go_to_prev_overlapping_diagnostic(executor: BackgroundExecutor, cx: &mu
                            },
                        ],
                    },
+                    None,
+                    DiagnosticSourceKind::Pushed,
                    &[],
                    cx,
                )
@@ -21562,3 +21854,204 @@ fn assert_hunk_revert(
    cx.assert_editor_state(expected_reverted_text_with_selections);
    assert_eq!(actual_hunk_statuses_before, expected_hunk_statuses_before);
 }
+
+#[gpui::test(iterations = 10)]
+async fn test_pulling_diagnostics(cx: &mut TestAppContext) {
+    init_test(cx, |_| {});
+
+    let diagnostic_requests = Arc::new(AtomicUsize::new(0));
+    let counter = diagnostic_requests.clone();
+
+    let fs = FakeFs::new(cx.executor());
+    fs.insert_tree(
+        path!("/a"),
+        json!({
+            "first.rs": "fn main() { let a = 5; }",
+            "second.rs": "// Test file",
+        }),
+    )
+    .await;
+
+    let project = Project::test(fs, [path!("/a").as_ref()], cx).await;
+    let workspace = cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
+    let cx = &mut VisualTestContext::from_window(*workspace, cx);
+
+    let language_registry = project.read_with(cx, |project, _| project.languages().clone());
+    language_registry.add(rust_lang());
+    let mut fake_servers = language_registry.register_fake_lsp(
+        "Rust",
+        FakeLspAdapter {
+            capabilities: lsp::ServerCapabilities {
+                diagnostic_provider: Some(lsp::DiagnosticServerCapabilities::Options(
+                    lsp::DiagnosticOptions {
+                        identifier: None,
+                        inter_file_dependencies: true,
+                        workspace_diagnostics: true,
+                        work_done_progress_options: Default::default(),
+                    },
+                )),
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+    );
+
+    let editor = workspace
+        .update(cx, |workspace, window, cx| {
+            workspace.open_abs_path(
+                PathBuf::from(path!("/a/first.rs")),
+                OpenOptions::default(),
+                window,
+                cx,
+            )
+        })
+        .unwrap()
+        .await
+        .unwrap()
+        .downcast::<Editor>()
+        .unwrap();
+    let fake_server = fake_servers.next().await.unwrap();
+    let mut first_request = fake_server
+        .set_request_handler::<lsp::request::DocumentDiagnosticRequest, _, _>(move |params, _| {
+            let new_result_id = counter.fetch_add(1, atomic::Ordering::Release) + 1;
+            let result_id = Some(new_result_id.to_string());
+            assert_eq!(
+                params.text_document.uri,
+                lsp::Url::from_file_path(path!("/a/first.rs")).unwrap()
+            );
+            async move {
+                Ok(lsp::DocumentDiagnosticReportResult::Report(
+                    lsp::DocumentDiagnosticReport::Full(lsp::RelatedFullDocumentDiagnosticReport {
+                        related_documents: None,
+                        full_document_diagnostic_report: lsp::FullDocumentDiagnosticReport {
+                            items: Vec::new(),
+                            result_id,
+                        },
+                    }),
+                ))
+            }
+        });
+
+    let ensure_result_id = |expected: Option<String>, cx: &mut TestAppContext| {
+        project.update(cx, |project, cx| {
+            let buffer_id = editor
+                .read(cx)
+                .buffer()
+                .read(cx)
+                .as_singleton()
+                .expect("created a singleton buffer")
+                .read(cx)
+                .remote_id();
+            let buffer_result_id = project.lsp_store().read(cx).result_id(buffer_id);
+            assert_eq!(expected, buffer_result_id);
+        });
+    };
+
+    ensure_result_id(None, cx);
+    cx.executor().advance_clock(Duration::from_millis(60));
+    cx.executor().run_until_parked();
+    assert_eq!(
+        diagnostic_requests.load(atomic::Ordering::Acquire),
+        1,
+        "Opening file should trigger diagnostic request"
+    );
+    first_request
+        .next()
+        .await
+        .expect("should have sent the first diagnostics pull request");
+    ensure_result_id(Some("1".to_string()), cx);
+
+    // Editing should trigger diagnostics
+    editor.update_in(cx, |editor, window, cx| {
+        editor.handle_input("2", window, cx)
+    });
+    cx.executor().advance_clock(Duration::from_millis(60));
+    cx.executor().run_until_parked();
+    assert_eq!(
+        diagnostic_requests.load(atomic::Ordering::Acquire),
+        2,
+        "Editing should trigger diagnostic request"
+    );
+    ensure_result_id(Some("2".to_string()), cx);
+
+    // Moving cursor should not trigger diagnostic request
+    editor.update_in(cx, |editor, window, cx| {
+        editor.change_selections(None, window, cx, |s| {
+            s.select_ranges([Point::new(0, 0)..Point::new(0, 0)])
+        });
+    });
+    cx.executor().advance_clock(Duration::from_millis(60));
+    cx.executor().run_until_parked();
+    assert_eq!(
+        diagnostic_requests.load(atomic::Ordering::Acquire),
+        2,
+        "Cursor movement should not trigger diagnostic request"
+    );
+    ensure_result_id(Some("2".to_string()), cx);
+
+    // Multiple rapid edits should be debounced
+    for _ in 0..5 {
+        editor.update_in(cx, |editor, window, cx| {
+            editor.handle_input("x", window, cx)
+        });
+    }
+    cx.executor().advance_clock(Duration::from_millis(60));
+    cx.executor().run_until_parked();
+
+    let final_requests = diagnostic_requests.load(atomic::Ordering::Acquire);
+    assert!(
+        final_requests <= 4,
+        "Multiple rapid edits should be debounced (got {final_requests} requests)",
+    );
+    ensure_result_id(Some(final_requests.to_string()), cx);
+}
+
+#[gpui::test]
+async fn test_add_selection_after_moving_with_multiple_cursors(cx: &mut TestAppContext) {
+    // Regression test for issue #11671
+    // Previously, adding a cursor after moving multiple cursors would reset
+    // the cursor count instead of adding to the existing cursors.
+    init_test(cx, |_| {});
+    let mut cx = EditorTestContext::new(cx).await;
+
+    // Create a simple buffer with cursor at start
+    cx.set_state(indoc! {"
+        ˇaaaa
+        bbbb
+        cccc
+        dddd
+        eeee
+        ffff
+        gggg
+        hhhh"});
+
+    // Add 2 cursors below (so we have 3 total)
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // Verify we have 3 cursors
+    let initial_count = cx.update_editor(|editor, _, _| editor.selections.count());
+    assert_eq!(
+        initial_count, 3,
+        "Should have 3 cursors after adding 2 below"
+    );
+
+    // Move down one line
+    cx.update_editor(|editor, window, cx| {
+        editor.move_down(&MoveDown, window, cx);
+    });
+
+    // Add another cursor below
+    cx.update_editor(|editor, window, cx| {
+        editor.add_selection_below(&Default::default(), window, cx);
+    });
+
+    // Should now have 4 cursors (3 original + 1 new)
+    let final_count = cx.update_editor(|editor, _, _| editor.selections.count());
+    assert_eq!(
+        final_count, 4,
+        "Should have 4 cursors after moving and adding another"
+    );
+}
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -1,14 +1,14 @@
 use crate::{
-    ActiveDiagnostic, BlockId, COLUMNAR_SELECTION_MODIFIERS, CURSORS_VISIBLE_FOR,
-    ChunkRendererContext, ChunkReplacement, CodeActionSource, ConflictsOurs, ConflictsOursMarker,
-    ConflictsOuter, ConflictsTheirs, ConflictsTheirsMarker, ContextMenuPlacement, CursorShape,
-    CustomBlockId, DisplayDiffHunk, DisplayPoint, DisplayRow, DocumentHighlightRead,
-    DocumentHighlightWrite, EditDisplayMode, Editor, EditorMode, EditorSettings, EditorSnapshot,
-    EditorStyle, FILE_HEADER_HEIGHT, FocusedBlock, GutterDimensions, HalfPageDown, HalfPageUp,
-    HandleInput, HoveredCursor, InlayHintRefreshReason, InlineCompletion, JumpData, LineDown,
-    LineHighlight, LineUp, MAX_LINE_LEN, MIN_LINE_NUMBER_DIGITS, MINIMAP_FONT_SIZE,
-    MULTI_BUFFER_EXCERPT_HEADER_HEIGHT, OpenExcerpts, PageDown, PageUp, PhantomBreakpointIndicator,
-    Point, RowExt, RowRangeExt, SelectPhase, SelectedTextHighlight, Selection, SoftWrap,
+    ActiveDiagnostic, BlockId, CURSORS_VISIBLE_FOR, ChunkRendererContext, ChunkReplacement,
+    CodeActionSource, ConflictsOurs, ConflictsOursMarker, ConflictsOuter, ConflictsTheirs,
+    ConflictsTheirsMarker, ContextMenuPlacement, CursorShape, CustomBlockId, DisplayDiffHunk,
+    DisplayPoint, DisplayRow, DocumentHighlightRead, DocumentHighlightWrite, EditDisplayMode,
+    Editor, EditorMode, EditorSettings, EditorSnapshot, EditorStyle, FILE_HEADER_HEIGHT,
+    FocusedBlock, GutterDimensions, HalfPageDown, HalfPageUp, HandleInput, HoveredCursor,
+    InlayHintRefreshReason, InlineCompletion, JumpData, LineDown, LineHighlight, LineUp,
+    MAX_LINE_LEN, MIN_LINE_NUMBER_DIGITS, MINIMAP_FONT_SIZE, MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
+    OpenExcerpts, PageDown, PageUp, PhantomBreakpointIndicator, Point, RowExt, RowRangeExt,
+    SelectPhase, SelectedTextHighlight, Selection, SelectionDragState, SoftWrap,
    StickyHeaderExcerpt, ToPoint, ToggleFold,
    code_context_menus::{CodeActionsMenu, MENU_ASIDE_MAX_WIDTH, MENU_ASIDE_MIN_WIDTH, MENU_GAP},
    display_map::{
@@ -17,8 +17,7 @@ use crate::{
    },
    editor_settings::{
        CurrentLineHighlight, DoubleClickInMultibuffer, MinimapThumb, MinimapThumbBorder,
-        MultiCursorModifier, ScrollBeyondLastLine, ScrollbarAxes, ScrollbarDiagnostics,
-        ShowMinimap, ShowScrollbar,
+        ScrollBeyondLastLine, ScrollbarAxes, ScrollbarDiagnostics, ShowMinimap, ShowScrollbar,
    },
    git::blame::{BlameRenderer, GitBlame, GlobalBlameRenderer},
    hover_popover::{
@@ -79,10 +78,11 @@ use std::{
    time::Duration,
 };
 use sum_tree::Bias;
-use text::BufferId;
+use text::{BufferId, SelectionGoal};
 use theme::{ActiveTheme, Appearance, BufferLineHeight, PlayerColor};
 use ui::{ButtonLike, KeyBinding, POPOVER_Y_PADDING, Tooltip, h_flex, prelude::*};
 use unicode_segmentation::UnicodeSegmentation;
+use util::post_inc;
 use util::{RangeExt, ResultExt, debug_panic};
 use workspace::{CollaboratorId, Workspace, item::Item, notifications::NotifyTaskExt};

@@ -620,6 +620,7 @@ impl EditorElement {

        let text_hitbox = &position_map.text_hitbox;
        let gutter_hitbox = &position_map.gutter_hitbox;
+        let point_for_position = position_map.point_for_position(event.position);
        let mut click_count = event.click_count;
        let mut modifiers = event.modifiers;

@@ -633,6 +634,19 @@ impl EditorElement {
            return;
        }

+        if editor.drag_and_drop_selection_enabled && click_count == 1 {
+            let newest_anchor = editor.selections.newest_anchor();
+            let snapshot = editor.snapshot(window, cx);
+            let selection = newest_anchor.map(|anchor| anchor.to_display_point(&snapshot));
+            if point_for_position.intersects_selection(&selection) {
+                editor.selection_drag_state = SelectionDragState::ReadyToDrag {
+                    selection: newest_anchor.clone(),
+                };
+                cx.stop_propagation();
+                return;
+            }
+        }
+
        let is_singleton = editor.buffer().read(cx).is_singleton();

        if click_count == 2 && !is_singleton {
@@ -676,9 +690,9 @@ impl EditorElement {
            }
        }

-        let point_for_position = position_map.point_for_position(event.position);
        let position = point_for_position.previous_valid;
-        if modifiers == COLUMNAR_SELECTION_MODIFIERS {
+        let multi_cursor_modifier = Editor::multi_cursor_modifier(true, &modifiers, cx);
+        if Editor::columnar_selection_modifiers(multi_cursor_modifier, &modifiers) {
            editor.select(
                SelectPhase::BeginColumnar {
                    position,
@@ -699,11 +713,6 @@ impl EditorElement {
                cx,
            );
        } else {
-            let multi_cursor_setting = EditorSettings::get_global(cx).multi_cursor_modifier;
-            let multi_cursor_modifier = match multi_cursor_setting {
-                MultiCursorModifier::Alt => modifiers.alt,
-                MultiCursorModifier::CmdOrCtrl => modifiers.secondary(),
-            };
            editor.select(
                SelectPhase::Begin {
                    position,
@@ -821,6 +830,12 @@ impl EditorElement {
        let text_hitbox = &position_map.text_hitbox;
        let end_selection = editor.has_pending_selection();
        let pending_nonempty_selections = editor.has_pending_nonempty_selection();
+        let point_for_position = position_map.point_for_position(event.position);
+
+        let is_cut = !event.modifiers.control;
+        if editor.drop_selection(Some(point_for_position), is_cut, window, cx) {
+            return;
+        }

        if end_selection {
            editor.select(SelectPhase::End, window, cx);
@@ -867,13 +882,9 @@ impl EditorElement {
        let text_hitbox = &position_map.text_hitbox;
        let pending_nonempty_selections = editor.has_pending_nonempty_selection();

-        let multi_cursor_setting = EditorSettings::get_global(cx).multi_cursor_modifier;
-        let multi_cursor_modifier = match multi_cursor_setting {
-            MultiCursorModifier::Alt => event.modifiers().secondary(),
-            MultiCursorModifier::CmdOrCtrl => event.modifiers().alt,
-        };
+        let hovered_link_modifier = Editor::multi_cursor_modifier(false, &event.modifiers(), cx);

-        if !pending_nonempty_selections && multi_cursor_modifier && text_hitbox.is_hovered(window) {
+        if !pending_nonempty_selections && hovered_link_modifier && text_hitbox.is_hovered(window) {
            let point = position_map.point_for_position(event.up.position);
            editor.handle_click_hovered_link(point, event.modifiers(), window, cx);

@@ -888,12 +899,15 @@ impl EditorElement {
        window: &mut Window,
        cx: &mut Context<Editor>,
    ) {
-        if !editor.has_pending_selection() {
+        if !editor.has_pending_selection()
+            && matches!(editor.selection_drag_state, SelectionDragState::None)
+        {
            return;
        }

        let text_bounds = position_map.text_hitbox.bounds;
        let point_for_position = position_map.point_for_position(event.position);
+
        let mut scroll_delta = gpui::Point::<f32>::default();
        let vertical_margin = position_map.line_height.min(text_bounds.size.height / 3.0);
        let top = text_bounds.origin.y + vertical_margin;
@@ -925,15 +939,46 @@ impl EditorElement {
            scroll_delta.x = scale_horizontal_mouse_autoscroll_delta(event.position.x - right);
        }

-        editor.select(
-            SelectPhase::Update {
-                position: point_for_position.previous_valid,
-                goal_column: point_for_position.exact_unclipped.column(),
-                scroll_delta,
-            },
-            window,
-            cx,
-        );
+        if !editor.has_pending_selection() {
+            let drop_anchor = position_map
+                .snapshot
+                .display_point_to_anchor(point_for_position.previous_valid, Bias::Left);
+            match editor.selection_drag_state {
+                SelectionDragState::Dragging {
+                    ref mut drop_cursor,
+                    ..
+                } => {
+                    drop_cursor.start = drop_anchor;
+                    drop_cursor.end = drop_anchor;
+                }
+                SelectionDragState::ReadyToDrag { ref selection } => {
+                    let drop_cursor = Selection {
+                        id: post_inc(&mut editor.selections.next_selection_id),
+                        start: drop_anchor,
+                        end: drop_anchor,
+                        reversed: false,
+                        goal: SelectionGoal::None,
+                    };
+                    editor.selection_drag_state = SelectionDragState::Dragging {
+                        selection: selection.clone(),
+                        drop_cursor,
+                    };
+                }
+                _ => {}
+            }
+            editor.apply_scroll_delta(scroll_delta, window, cx);
+            cx.notify();
+        } else {
+            editor.select(
+                SelectPhase::Update {
+                    position: point_for_position.previous_valid,
+                    goal_column: point_for_position.exact_unclipped.column(),
+                    scroll_delta,
+                },
+                window,
+                cx,
+            );
+        }
    }

    fn mouse_moved(
@@ -1162,6 +1207,34 @@ impl EditorElement {

                let player = editor.current_user_player_color(cx);
                selections.push((player, layouts));
+
+                if let SelectionDragState::Dragging {
+                    ref selection,
+                    ref drop_cursor,
+                } = editor.selection_drag_state
+                {
+                    if drop_cursor
+                        .start
+                        .cmp(&selection.start, &snapshot.buffer_snapshot)
+                        .eq(&Ordering::Less)
+                        || drop_cursor
+                            .end
+                            .cmp(&selection.end, &snapshot.buffer_snapshot)
+                            .eq(&Ordering::Greater)
+                    {
+                        let drag_cursor_layout = SelectionLayout::new(
+                            drop_cursor.clone(),
+                            false,
+                            CursorShape::Bar,
+                            &snapshot.display_snapshot,
+                            false,
+                            false,
+                            None,
+                        );
+                        let absent_color = cx.theme().players().absent();
+                        selections.push((absent_color, vec![drag_cursor_layout]));
+                    }
+                }
            }

            if let Some(collaboration_hub) = &editor.collaboration_hub {
@@ -3881,7 +3954,8 @@ impl EditorElement {

                let edit_prediction = if edit_prediction_popover_visible {
                    self.editor.update(cx, move |editor, cx| {
-                        let accept_binding = editor.accept_edit_prediction_keybind(window, cx);
+                        let accept_binding =
+                            editor.accept_edit_prediction_keybind(false, window, cx);
                        let mut element = editor.render_edit_prediction_cursor_popover(
                            min_width,
                            max_width,
@@ -5130,7 +5204,7 @@ impl EditorElement {
        let is_singleton = self.editor.read(cx).is_singleton(cx);

        let line_height = layout.position_map.line_height;
-        window.set_cursor_style(CursorStyle::Arrow, Some(&layout.gutter_hitbox));
+        window.set_cursor_style(CursorStyle::Arrow, &layout.gutter_hitbox);

        for LineNumberLayout {
            shaped_line,
@@ -5157,9 +5231,9 @@ impl EditorElement {
            // In singleton buffers, we select corresponding lines on the line number click, so use | -like cursor.
            // In multi buffers, we open file at the line number clicked, so use a pointing hand cursor.
            if is_singleton {
-                window.set_cursor_style(CursorStyle::IBeam, Some(&hitbox));
+                window.set_cursor_style(CursorStyle::IBeam, &hitbox);
            } else {
-                window.set_cursor_style(CursorStyle::PointingHand, Some(&hitbox));
+                window.set_cursor_style(CursorStyle::PointingHand, &hitbox);
            }
        }
    }
@@ -5377,7 +5451,7 @@ impl EditorElement {
                    .read(cx)
                    .all_diff_hunks_expanded()
                {
-                    window.set_cursor_style(CursorStyle::PointingHand, Some(hunk_hitbox));
+                    window.set_cursor_style(CursorStyle::PointingHand, hunk_hitbox);
                }
            }
        }
@@ -5451,7 +5525,7 @@ impl EditorElement {
            |window| {
                let editor = self.editor.read(cx);
                if editor.mouse_cursor_hidden {
-                    window.set_cursor_style(CursorStyle::None, None);
+                    window.set_window_cursor_style(CursorStyle::None);
                } else if editor
                    .hovered_link_state
                    .as_ref()
@@ -5459,13 +5533,10 @@ impl EditorElement {
                {
                    window.set_cursor_style(
                        CursorStyle::PointingHand,
-                        Some(&layout.position_map.text_hitbox),
+                        &layout.position_map.text_hitbox,
                    );
                } else {
-                    window.set_cursor_style(
-                        CursorStyle::IBeam,
-                        Some(&layout.position_map.text_hitbox),
-                    );
+                    window.set_cursor_style(CursorStyle::IBeam, &layout.position_map.text_hitbox);
                };

                self.paint_lines_background(layout, window, cx);
@@ -5606,6 +5677,7 @@ impl EditorElement {
        let Some(scrollbars_layout) = layout.scrollbars_layout.take() else {
            return;
        };
+        let any_scrollbar_dragged = self.editor.read(cx).scroll_manager.any_scrollbar_dragged();

        for (scrollbar_layout, axis) in scrollbars_layout.iter_scrollbars() {
            let hitbox = &scrollbar_layout.hitbox;
@@ -5671,7 +5743,11 @@ impl EditorElement {
                            BorderStyle::Solid,
                        ));

-                        window.set_cursor_style(CursorStyle::Arrow, Some(&hitbox));
+                        if any_scrollbar_dragged {
+                            window.set_window_cursor_style(CursorStyle::Arrow);
+                        } else {
+                            window.set_cursor_style(CursorStyle::Arrow, &hitbox);
+                        }
                    }
                })
            }
@@ -5739,7 +5815,7 @@ impl EditorElement {
            }
        });

-        if self.editor.read(cx).scroll_manager.any_scrollbar_dragged() {
+        if any_scrollbar_dragged {
            window.on_mouse_event({
                let editor = self.editor.clone();
                move |_: &MouseUpEvent, phase, window, cx| {
@@ -6125,6 +6201,7 @@ impl EditorElement {
    fn paint_minimap(&self, layout: &mut EditorLayout, window: &mut Window, cx: &mut App) {
        if let Some(mut layout) = layout.minimap.take() {
            let minimap_hitbox = layout.thumb_layout.hitbox.clone();
+            let dragging_minimap = self.editor.read(cx).scroll_manager.is_dragging_minimap();

            window.paint_layer(layout.thumb_layout.hitbox.bounds, |window| {
                window.with_element_namespace("minimap", |window| {
@@ -6176,7 +6253,11 @@ impl EditorElement {
                });
            });

-            window.set_cursor_style(CursorStyle::Arrow, Some(&minimap_hitbox));
+            if dragging_minimap {
+                window.set_window_cursor_style(CursorStyle::Arrow);
+            } else {
+                window.set_cursor_style(CursorStyle::Arrow, &minimap_hitbox);
+            }

            let minimap_axis = ScrollbarAxis::Vertical;
            let pixels_per_line = (minimap_hitbox.size.height / layout.max_scroll_top)
@@ -6237,7 +6318,7 @@ impl EditorElement {
                }
            });

-            if self.editor.read(cx).scroll_manager.is_dragging_minimap() {
+            if dragging_minimap {
                window.on_mouse_event({
                    let editor = self.editor.clone();
                    move |event: &MouseUpEvent, phase, window, cx| {
@@ -6665,7 +6746,7 @@ impl AcceptEditPredictionBinding {
    pub fn keystroke(&self) -> Option<&Keystroke> {
        if let Some(binding) = self.0.as_ref() {
            match &binding.keystrokes() {
-                [keystroke] => Some(keystroke),
+                [keystroke, ..] => Some(keystroke),
                _ => None,
            }
        } else {
@@ -9234,6 +9315,35 @@ impl PointForPosition {
            None
        }
    }
+
+    pub fn intersects_selection(&self, selection: &Selection<DisplayPoint>) -> bool {
+        let Some(valid_point) = self.as_valid() else {
+            return false;
+        };
+        let range = selection.range();
+
+        let candidate_row = valid_point.row();
+        let candidate_col = valid_point.column();
+
+        let start_row = range.start.row();
+        let start_col = range.start.column();
+        let end_row = range.end.row();
+        let end_col = range.end.column();
+
+        if candidate_row < start_row || candidate_row > end_row {
+            false
+        } else if start_row == end_row {
+            candidate_col >= start_col && candidate_col < end_col
+        } else {
+            if candidate_row == start_row {
+                candidate_col >= start_col
+            } else if candidate_row == end_row {
+                candidate_col < end_col
+            } else {
+                true
+            }
+        }
+    }
 }

 impl PositionMap {
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -1,7 +1,7 @@
 use crate::{
    Anchor, Editor, EditorSettings, EditorSnapshot, FindAllReferences, GoToDefinition,
    GoToTypeDefinition, GotoDefinitionKind, InlayId, Navigated, PointForPosition, SelectPhase,
-    editor_settings::{GoToDefinitionFallback, MultiCursorModifier},
+    editor_settings::GoToDefinitionFallback,
    hover_popover::{self, InlayHover},
    scroll::ScrollAmount,
 };
@@ -120,11 +120,7 @@ impl Editor {
        window: &mut Window,
        cx: &mut Context<Self>,
    ) {
-        let multi_cursor_setting = EditorSettings::get_global(cx).multi_cursor_modifier;
-        let hovered_link_modifier = match multi_cursor_setting {
-            MultiCursorModifier::Alt => modifiers.secondary(),
-            MultiCursorModifier::CmdOrCtrl => modifiers.alt,
-        };
+        let hovered_link_modifier = Editor::multi_cursor_modifier(false, &modifiers, cx);
        if !hovered_link_modifier || self.has_pending_selection() {
            self.hide_hovered_link(cx);
            return;
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -869,6 +869,7 @@ impl InfoPopover {
        let keyboard_grace = Rc::clone(&self.keyboard_grace);
        div()
            .id("info_popover")
+            .occlude()
            .elevation_2(cx)
            // Prevent a mouse down/move on the popover from being propagated to the editor,
            // because that would dismiss the popover.
--- a/crates/editor/src/lsp_ext.rs
+++ b/crates/editor/src/lsp_ext.rs
@@ -42,8 +42,8 @@ where
        .selections
        .disjoint_anchors()
        .iter()
-        .filter(|selection| selection.start == selection.end)
-        .filter_map(|selection| Some((selection.start, selection.start.buffer_id?)))
+        .filter_map(|selection| Some((selection.head(), selection.head().buffer_id?)))
+        .unique_by(|(_, buffer_id)| *buffer_id)
        .filter_map(|(trigger_anchor, buffer_id)| {
            let buffer = editor.buffer().read(cx).buffer(buffer_id)?;
            let language = buffer.read(cx).language_at(trigger_anchor.text_anchor)?;
@@ -53,7 +53,6 @@ where
                None
            }
        })
-        .unique_by(|(_, buffer, _)| buffer.read(cx).remote_id())
        .collect::<Vec<_>>();

    let applicable_buffer_tasks = applicable_buffers
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -522,4 +522,12 @@ impl SemanticsProvider for BranchBufferSemanticsProvider {
    ) -> Option<Task<anyhow::Result<project::ProjectTransaction>>> {
        None
    }
+
+    fn pull_diagnostics_for_buffer(
+        &self,
+        _: Entity<Buffer>,
+        _: &mut App,
+    ) -> Task<anyhow::Result<()>> {
+        Task::ready(Ok(()))
+    }
 }
--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -132,9 +132,6 @@ pub fn expand_macro_recursively(
    window: &mut Window,
    cx: &mut Context<Editor>,
 ) {
-    if editor.selections.count() == 0 {
-        return;
-    }
    let Some(project) = &editor.project else {
        return;
    };
--- a/crates/eval/Cargo.toml
+++ b/crates/eval/Cargo.toml
@@ -24,7 +24,6 @@ anyhow.workspace = true
 assistant_tool.workspace = true
 assistant_tools.workspace = true
 async-trait.workspace = true
-async-watch.workspace = true
 buffer_diff.workspace = true
 chrono.workspace = true
 clap.workspace = true
@@ -66,5 +65,6 @@ toml.workspace = true
 unindent.workspace = true
 util.workspace = true
 uuid.workspace = true
+watch.workspace = true
 workspace-hack.workspace = true
 zed_llm_client.workspace = true
--- a/crates/eval/src/eval.rs
+++ b/crates/eval/src/eval.rs
@@ -385,7 +385,7 @@ pub fn init(cx: &mut App) -> Arc<AgentAppState> {

    extension::init(cx);

-    let (tx, rx) = async_watch::channel(None);
+    let (mut tx, rx) = watch::channel(None);
    cx.observe_global::<SettingsStore>(move |cx| {
        let settings = &ProjectSettings::get_global(cx).node;
        let options = NodeBinaryOptions {
--- a/crates/eval/src/example.rs
+++ b/crates/eval/src/example.rs
@@ -294,6 +294,7 @@ impl ExampleContext {
                | ThreadEvent::MessageDeleted(_)
                | ThreadEvent::SummaryChanged
                | ThreadEvent::SummaryGenerated
+                | ThreadEvent::ProfileChanged
                | ThreadEvent::ReceivedTextChunk
                | ThreadEvent::StreamedToolUse { .. }
                | ThreadEvent::CheckpointChanged
--- a/crates/eval/src/instance.rs
+++ b/crates/eval/src/instance.rs
@@ -306,17 +306,19 @@ impl ExampleInstance {

            let thread_store = thread_store.await?;

-            let profile_id = meta.profile_id.clone();
-            thread_store.update(cx, |thread_store, cx| thread_store.load_profile_by_id(profile_id, cx)).expect("Failed to load profile");

            let thread =
                thread_store.update(cx, |thread_store, cx| {
-                    if let Some(json) = &meta.existing_thread_json {
+                    let thread = if let Some(json) = &meta.existing_thread_json {
                        let serialized = SerializedThread::from_json(json.as_bytes()).expect("Can't read serialized thread");
                        thread_store.create_thread_from_serialized(serialized, cx)
                    } else {
                        thread_store.create_thread(cx)
-                    }
+                    };
+                    thread.update(cx, |thread, cx| {
+                        thread.set_profile(meta.profile_id.clone(), cx);
+                    });
+                    thread
                })?;


--- a/crates/extension_host/src/wasm_host.rs
+++ b/crates/extension_host/src/wasm_host.rs
@@ -87,7 +87,7 @@ impl extension::Extension for WasmExtension {
                        resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(command.into())
            }
@@ -113,7 +113,7 @@ impl extension::Extension for WasmExtension {
                        resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                anyhow::Ok(options)
            }
            .boxed()
@@ -136,7 +136,7 @@ impl extension::Extension for WasmExtension {
                        resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                anyhow::Ok(options)
            }
            .boxed()
@@ -161,7 +161,7 @@ impl extension::Extension for WasmExtension {
                        resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                anyhow::Ok(options)
            }
            .boxed()
@@ -186,7 +186,7 @@ impl extension::Extension for WasmExtension {
                        resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                anyhow::Ok(options)
            }
            .boxed()
@@ -208,7 +208,7 @@ impl extension::Extension for WasmExtension {
                        completions.into_iter().map(Into::into).collect(),
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(labels
                    .into_iter()
@@ -234,7 +234,7 @@ impl extension::Extension for WasmExtension {
                        symbols.into_iter().map(Into::into).collect(),
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(labels
                    .into_iter()
@@ -256,7 +256,7 @@ impl extension::Extension for WasmExtension {
                let completions = extension
                    .call_complete_slash_command_argument(store, &command.into(), &arguments)
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(completions.into_iter().map(Into::into).collect())
            }
@@ -282,7 +282,7 @@ impl extension::Extension for WasmExtension {
                let output = extension
                    .call_run_slash_command(store, &command.into(), &arguments, resource)
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(output.into())
            }
@@ -302,7 +302,7 @@ impl extension::Extension for WasmExtension {
                let command = extension
                    .call_context_server_command(store, context_server_id.clone(), project_resource)
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                anyhow::Ok(command.into())
            }
            .boxed()
@@ -325,7 +325,7 @@ impl extension::Extension for WasmExtension {
                        project_resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err}"))?
+                    .map_err(|err| store.data().extension_error(err))?
                else {
                    return Ok(None);
                };
@@ -343,7 +343,7 @@ impl extension::Extension for WasmExtension {
                let packages = extension
                    .call_suggest_docs_packages(store, provider.as_ref())
                    .await?
-                    .map_err(|err| anyhow!("{err:?}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                Ok(packages)
            }
@@ -369,7 +369,7 @@ impl extension::Extension for WasmExtension {
                        kv_store_resource,
                    )
                    .await?
-                    .map_err(|err| anyhow!("{err:?}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;

                anyhow::Ok(())
            }
@@ -390,7 +390,7 @@ impl extension::Extension for WasmExtension {
                let dap_binary = extension
                    .call_get_dap_binary(store, dap_name, config, user_installed_path, resource)
                    .await?
-                    .map_err(|err| anyhow!("{err:?}"))?;
+                    .map_err(|err| store.data().extension_error(err))?;
                let dap_binary = dap_binary.try_into()?;
                Ok(dap_binary)
            }
@@ -406,7 +406,7 @@ impl extension::Extension for WasmExtension {
                    .call_dap_schema(store)
                    .await
                    .and_then(|schema| serde_json::to_value(schema).map_err(|err| err.to_string()))
-                    .map_err(|err| anyhow!(err.to_string()))
+                    .map_err(|err| store.data().extension_error(err))
            }
            .boxed()
        })
@@ -680,6 +680,15 @@ impl WasmState {
    fn work_dir(&self) -> PathBuf {
        self.host.work_dir.join(self.manifest.id.as_ref())
    }
+
+    fn extension_error(&self, message: String) -> anyhow::Error {
+        anyhow!(
+            "from extension \"{}\" version {}: {}",
+            self.manifest.name,
+            self.manifest.version,
+            message
+        )
+    }
 }

 impl wasi::WasiView for WasmState {
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -459,7 +459,7 @@ enum Match {
 }

 impl Match {
-    fn path(&self) -> Option<&Arc<Path>> {
+    fn relative_path(&self) -> Option<&Arc<Path>> {
        match self {
            Match::History { path, .. } => Some(&path.project.path),
            Match::Search(panel_match) => Some(&panel_match.0.path),
@@ -467,6 +467,26 @@ impl Match {
        }
    }

+    fn abs_path(&self, project: &Entity<Project>, cx: &App) -> Option<PathBuf> {
+        match self {
+            Match::History { path, .. } => path.absolute.clone().or_else(|| {
+                project
+                    .read(cx)
+                    .worktree_for_id(path.project.worktree_id, cx)?
+                    .read(cx)
+                    .absolutize(&path.project.path)
+                    .ok()
+            }),
+            Match::Search(ProjectPanelOrdMatch(path_match)) => project
+                .read(cx)
+                .worktree_for_id(WorktreeId::from_usize(path_match.worktree_id), cx)?
+                .read(cx)
+                .absolutize(&path_match.path)
+                .ok(),
+            Match::CreateNew(_) => None,
+        }
+    }
+
    fn panel_match(&self) -> Option<&ProjectPanelOrdMatch> {
        match self {
            Match::History { panel_match, .. } => panel_match.as_ref(),
@@ -501,7 +521,7 @@ impl Matches {
            // reason for the matches set to change.
            self.matches
                .iter()
-                .position(|m| match m.path() {
+                .position(|m| match m.relative_path() {
                    Some(p) => path.project.path == *p,
                    None => false,
                })
@@ -1570,7 +1590,8 @@ impl PickerDelegate for FileFinderDelegate {
            if !settings.file_icons {
                return None;
            }
-            let file_name = path_match.path()?.file_name()?;
+            let abs_path = path_match.abs_path(&self.project, cx)?;
+            let file_name = abs_path.file_name()?;
            let icon = FileIcons::get_icon(file_name.as_ref(), cx)?;
            Some(Icon::from_path(icon).color(Color::Muted))
        });
--- a/crates/fs/src/fake_git_repo.rs
+++ b/crates/fs/src/fake_git_repo.rs
@@ -5,7 +5,7 @@ use futures::future::{self, BoxFuture};
 use git::{
    blame::Blame,
    repository::{
-        AskPassDelegate, Branch, CommitDetails, CommitOptions, GitRepository,
+        AskPassDelegate, Branch, CommitDetails, CommitOptions, FetchOptions, GitRepository,
        GitRepositoryCheckpoint, PushOptions, Remote, RepoPath, ResetMode,
    },
    status::{FileStatus, GitStatus, StatusCode, TrackedStatus, UnmergedStatus},
@@ -405,6 +405,7 @@ impl GitRepository for FakeGitRepository {

    fn fetch(
        &self,
+        _fetch_options: FetchOptions,
        _askpass: AskPassDelegate,
        _env: Arc<HashMap<String, String>>,
        _cx: AsyncApp,
--- a/crates/git/src/git.rs
+++ b/crates/git/src/git.rs
@@ -46,9 +46,11 @@ actions!(
        TrashUntrackedFiles,
        Uncommit,
        Push,
+        PushTo,
        ForcePush,
        Pull,
        Fetch,
+        FetchFrom,
        Commit,
        Amend,
        Cancel,
--- a/crates/git/src/repository.rs
+++ b/crates/git/src/repository.rs
@@ -193,6 +193,44 @@ pub enum ResetMode {
    Mixed,
 }

+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub enum FetchOptions {
+    All,
+    Remote(Remote),
+}
+
+impl FetchOptions {
+    pub fn to_proto(&self) -> Option<String> {
+        match self {
+            FetchOptions::All => None,
+            FetchOptions::Remote(remote) => Some(remote.clone().name.into()),
+        }
+    }
+
+    pub fn from_proto(remote_name: Option<String>) -> Self {
+        match remote_name {
+            Some(name) => FetchOptions::Remote(Remote { name: name.into() }),
+            None => FetchOptions::All,
+        }
+    }
+
+    pub fn name(&self) -> SharedString {
+        match self {
+            Self::All => "Fetch all remotes".into(),
+            Self::Remote(remote) => remote.name.clone(),
+        }
+    }
+}
+
+impl std::fmt::Display for FetchOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FetchOptions::All => write!(f, "--all"),
+            FetchOptions::Remote(remote) => write!(f, "{}", remote.name),
+        }
+    }
+}
+
 /// Modifies .git/info/exclude temporarily
 pub struct GitExcludeOverride {
    git_exclude_path: PathBuf,
@@ -381,6 +419,7 @@ pub trait GitRepository: Send + Sync {

    fn fetch(
        &self,
+        fetch_options: FetchOptions,
        askpass: AskPassDelegate,
        env: Arc<HashMap<String, String>>,
        // This method takes an AsyncApp to ensure it's invoked on the main thread,
@@ -1196,18 +1235,20 @@ impl GitRepository for RealGitRepository {

    fn fetch(
        &self,
+        fetch_options: FetchOptions,
        ask_pass: AskPassDelegate,
        env: Arc<HashMap<String, String>>,
        cx: AsyncApp,
    ) -> BoxFuture<Result<RemoteCommandOutput>> {
        let working_directory = self.working_directory();
+        let remote_name = format!("{}", fetch_options);
        let executor = cx.background_executor().clone();
        async move {
            let mut command = new_smol_command("git");
            command
                .envs(env.iter())
                .current_dir(&working_directory?)
-                .args(["fetch", "--all"])
+                .args(["fetch", &remote_name])
                .stdout(smol::process::Stdio::piped())
                .stderr(smol::process::Stdio::piped());

--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -20,8 +20,8 @@ use editor::{
 use futures::StreamExt as _;
 use git::blame::ParsedCommitMessage;
 use git::repository::{
-    Branch, CommitDetails, CommitOptions, CommitSummary, DiffType, PushOptions, Remote,
-    RemoteCommandOutput, ResetMode, Upstream, UpstreamTracking, UpstreamTrackingStatus,
+    Branch, CommitDetails, CommitOptions, CommitSummary, DiffType, FetchOptions, PushOptions,
+    Remote, RemoteCommandOutput, ResetMode, Upstream, UpstreamTracking, UpstreamTrackingStatus,
 };
 use git::status::StageStatus;
 use git::{Amend, ToggleStaged, repository::RepoPath, status::FileStatus};
@@ -383,7 +383,6 @@ pub(crate) fn commit_message_editor(
    commit_editor.set_show_gutter(false, cx);
    commit_editor.set_show_wrap_guides(false, cx);
    commit_editor.set_show_indent_guides(false, cx);
-    commit_editor.set_hard_wrap(Some(72), cx);
    let placeholder = placeholder.unwrap_or("Enter commit message".into());
    commit_editor.set_placeholder_text(placeholder, cx);
    commit_editor
@@ -1483,15 +1482,48 @@ impl GitPanel {
        }
    }

-    fn custom_or_suggested_commit_message(&self, cx: &mut Context<Self>) -> Option<String> {
+    fn custom_or_suggested_commit_message(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<String> {
+        let git_commit_language = self.commit_editor.read(cx).language_at(0, cx);
        let message = self.commit_editor.read(cx).text(cx);
-
-        if !message.trim().is_empty() {
-            return Some(message);
+        if message.is_empty() {
+            return self
+                .suggest_commit_message(cx)
+                .filter(|message| !message.trim().is_empty());
+        } else if message.trim().is_empty() {
+            return None;
        }
+        let buffer = cx.new(|cx| {
+            let mut buffer = Buffer::local(message, cx);
+            buffer.set_language(git_commit_language, cx);
+            buffer
+        });
+        let editor = cx.new(|cx| Editor::for_buffer(buffer, None, window, cx));
+        let wrapped_message = editor.update(cx, |editor, cx| {
+            editor.select_all(&Default::default(), window, cx);
+            editor.rewrap(&Default::default(), window, cx);
+            editor.text(cx)
+        });
+        if wrapped_message.trim().is_empty() {
+            return None;
+        }
+        Some(wrapped_message)
+    }

-        self.suggest_commit_message(cx)
-            .filter(|message| !message.trim().is_empty())
+    fn has_commit_message(&self, cx: &mut Context<Self>) -> bool {
+        let text = self.commit_editor.read(cx).text(cx);
+        if !text.trim().is_empty() {
+            return true;
+        } else if text.is_empty() {
+            return self
+                .suggest_commit_message(cx)
+                .is_some_and(|text| !text.trim().is_empty());
+        } else {
+            return false;
+        }
    }

    pub(crate) fn commit_changes(
@@ -1520,7 +1552,7 @@ impl GitPanel {
            return;
        }

-        let commit_message = self.custom_or_suggested_commit_message(cx);
+        let commit_message = self.custom_or_suggested_commit_message(window, cx);

        let Some(mut message) = commit_message else {
            self.commit_editor.read(cx).focus_handle(cx).focus(window);
@@ -1808,7 +1840,49 @@ impl GitPanel {
        }));
    }

-    pub(crate) fn fetch(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+    fn get_fetch_options(
+        &self,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Task<Option<FetchOptions>> {
+        let repo = self.active_repository.clone();
+        let workspace = self.workspace.clone();
+
+        cx.spawn_in(window, async move |_, cx| {
+            let repo = repo?;
+            let remotes = repo
+                .update(cx, |repo, _| repo.get_remotes(None))
+                .ok()?
+                .await
+                .ok()?
+                .log_err()?;
+
+            let mut remotes: Vec<_> = remotes.into_iter().map(FetchOptions::Remote).collect();
+            if remotes.len() > 1 {
+                remotes.push(FetchOptions::All);
+            }
+            let selection = cx
+                .update(|window, cx| {
+                    picker_prompt::prompt(
+                        "Pick which remote to fetch",
+                        remotes.iter().map(|r| r.name()).collect(),
+                        workspace,
+                        window,
+                        cx,
+                    )
+                })
+                .ok()?
+                .await?;
+            remotes.get(selection).cloned()
+        })
+    }
+
+    pub(crate) fn fetch(
+        &mut self,
+        is_fetch_all: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
        if !self.can_push_and_pull(cx) {
            return;
        }
@@ -1819,13 +1893,28 @@ impl GitPanel {
        telemetry::event!("Git Fetched");
        let askpass = self.askpass_delegate("git fetch", window, cx);
        let this = cx.weak_entity();
+
+        let fetch_options = if is_fetch_all {
+            Task::ready(Some(FetchOptions::All))
+        } else {
+            self.get_fetch_options(window, cx)
+        };
+
        window
            .spawn(cx, async move |cx| {
-                let fetch = repo.update(cx, |repo, cx| repo.fetch(askpass, cx))?;
+                let Some(fetch_options) = fetch_options.await else {
+                    return Ok(());
+                };
+                let fetch = repo.update(cx, |repo, cx| {
+                    repo.fetch(fetch_options.clone(), askpass, cx)
+                })?;

                let remote_message = fetch.await?;
                this.update(cx, |this, cx| {
-                    let action = RemoteAction::Fetch;
+                    let action = match fetch_options {
+                        FetchOptions::All => RemoteAction::Fetch(None),
+                        FetchOptions::Remote(remote) => RemoteAction::Fetch(Some(remote)),
+                    };
                    match remote_message {
                        Ok(remote_message) => this.show_remote_output(action, remote_message, cx),
                        Err(e) => {
@@ -1936,7 +2025,7 @@ impl GitPanel {
        };
        telemetry::event!("Git Pulled");
        let branch = branch.clone();
-        let remote = self.get_current_remote(window, cx);
+        let remote = self.get_remote(false, window, cx);
        cx.spawn_in(window, async move |this, cx| {
            let remote = match remote.await {
                Ok(Some(remote)) => remote,
@@ -1981,7 +2070,13 @@ impl GitPanel {
        .detach_and_log_err(cx);
    }

-    pub(crate) fn push(&mut self, force_push: bool, window: &mut Window, cx: &mut Context<Self>) {
+    pub(crate) fn push(
+        &mut self,
+        force_push: bool,
+        select_remote: bool,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) {
        if !self.can_push_and_pull(cx) {
            return;
        }
@@ -2006,7 +2101,7 @@ impl GitPanel {
                _ => None,
            }
        };
-        let remote = self.get_current_remote(window, cx);
+        let remote = self.get_remote(select_remote, window, cx);

        cx.spawn_in(window, async move |this, cx| {
            let remote = match remote.await {
@@ -2080,8 +2175,9 @@ impl GitPanel {
        !self.project.read(cx).is_via_collab()
    }

-    fn get_current_remote(
+    fn get_remote(
        &mut self,
+        always_select: bool,
        window: &mut Window,
        cx: &mut Context<Self>,
    ) -> impl Future<Output = anyhow::Result<Option<Remote>>> + use<> {
@@ -2091,38 +2187,37 @@ impl GitPanel {

        async move {
            let repo = repo.context("No active repository")?;
-            let mut current_remotes: Vec<Remote> = repo
+            let current_remotes: Vec<Remote> = repo
                .update(&mut cx, |repo, _| {
-                    let current_branch = repo.branch.as_ref().context("No active branch")?;
-                    anyhow::Ok(repo.get_remotes(Some(current_branch.name().to_string())))
+                    let current_branch = if always_select {
+                        None
+                    } else {
+                        let current_branch = repo.branch.as_ref().context("No active branch")?;
+                        Some(current_branch.name().to_string())
+                    };
+                    anyhow::Ok(repo.get_remotes(current_branch))
                })??
                .await??;

-            if current_remotes.len() == 0 {
-                anyhow::bail!("No active remote");
-            } else if current_remotes.len() == 1 {
-                return Ok(Some(current_remotes.pop().unwrap()));
-            } else {
-                let current_remotes: Vec<_> = current_remotes
-                    .into_iter()
-                    .map(|remotes| remotes.name)
-                    .collect();
-                let selection = cx
-                    .update(|window, cx| {
-                        picker_prompt::prompt(
-                            "Pick which remote to push to",
-                            current_remotes.clone(),
-                            workspace,
-                            window,
-                            cx,
-                        )
-                    })?
-                    .await;
+            let current_remotes: Vec<_> = current_remotes
+                .into_iter()
+                .map(|remotes| remotes.name)
+                .collect();
+            let selection = cx
+                .update(|window, cx| {
+                    picker_prompt::prompt(
+                        "Pick which remote to push to",
+                        current_remotes.clone(),
+                        workspace,
+                        window,
+                        cx,
+                    )
+                })?
+                .await;

-                Ok(selection.map(|selection| Remote {
-                    name: current_remotes[selection].clone(),
-                }))
-            }
+            Ok(selection.map(|selection| Remote {
+                name: current_remotes[selection].clone(),
+            }))
        }
    }

@@ -2832,7 +2927,7 @@ impl GitPanel {
            (false, "No changes to commit")
        } else if self.pending_commit.is_some() {
            (false, "Commit in progress")
-        } else if self.custom_or_suggested_commit_message(cx).is_none() {
+        } else if !self.has_commit_message(cx) {
            (false, "No commit message")
        } else if !self.has_write_access(cx) {
            (false, "You do not have write access to this project")
--- a/crates/git_ui/src/git_ui.rs
+++ b/crates/git_ui/src/git_ui.rs
@@ -59,7 +59,15 @@ pub fn init(cx: &mut App) {
                    return;
                };
                panel.update(cx, |panel, cx| {
-                    panel.fetch(window, cx);
+                    panel.fetch(true, window, cx);
+                });
+            });
+            workspace.register_action(|workspace, _: &git::FetchFrom, window, cx| {
+                let Some(panel) = workspace.panel::<git_panel::GitPanel>(cx) else {
+                    return;
+                };
+                panel.update(cx, |panel, cx| {
+                    panel.fetch(false, window, cx);
                });
            });
            workspace.register_action(|workspace, _: &git::Push, window, cx| {
@@ -67,7 +75,15 @@ pub fn init(cx: &mut App) {
                    return;
                };
                panel.update(cx, |panel, cx| {
-                    panel.push(false, window, cx);
+                    panel.push(false, false, window, cx);
+                });
+            });
+            workspace.register_action(|workspace, _: &git::PushTo, window, cx| {
+                let Some(panel) = workspace.panel::<git_panel::GitPanel>(cx) else {
+                    return;
+                };
+                panel.update(cx, |panel, cx| {
+                    panel.push(false, true, window, cx);
                });
            });
            workspace.register_action(|workspace, _: &git::ForcePush, window, cx| {
@@ -75,7 +91,7 @@ pub fn init(cx: &mut App) {
                    return;
                };
                panel.update(cx, |panel, cx| {
-                    panel.push(true, window, cx);
+                    panel.push(true, false, window, cx);
                });
            });
            workspace.register_action(|workspace, _: &git::Pull, window, cx| {
@@ -367,9 +383,11 @@ mod remote_button {
                            el.context(keybinding_target.clone())
                        })
                        .action("Fetch", git::Fetch.boxed_clone())
+                        .action("Fetch From", git::FetchFrom.boxed_clone())
                        .action("Pull", git::Pull.boxed_clone())
                        .separator()
                        .action("Push", git::Push.boxed_clone())
+                        .action("Push To", git::PushTo.boxed_clone())
                        .action("Force Push", git::ForcePush.boxed_clone())
                }))
            })
--- a/crates/git_ui/src/picker_prompt.rs
+++ b/crates/git_ui/src/picker_prompt.rs
@@ -28,6 +28,8 @@ pub fn prompt(
 ) -> Task<Option<usize>> {
    if options.is_empty() {
        return Task::ready(None);
+    } else if options.len() == 1 {
+        return Task::ready(Some(0));
    }
    let prompt = prompt.to_string().into();

--- a/crates/git_ui/src/remote_output.rs
+++ b/crates/git_ui/src/remote_output.rs
@@ -6,7 +6,7 @@ use util::ResultExt as _;

 #[derive(Clone)]
 pub enum RemoteAction {
-    Fetch,
+    Fetch(Option<Remote>),
    Pull(Remote),
    Push(SharedString, Remote),
 }
@@ -14,7 +14,7 @@ pub enum RemoteAction {
 impl RemoteAction {
    pub fn name(&self) -> &'static str {
        match self {
-            RemoteAction::Fetch => "fetch",
+            RemoteAction::Fetch(_) => "fetch",
            RemoteAction::Pull(_) => "pull",
            RemoteAction::Push(_, _) => "push",
        }
@@ -34,15 +34,19 @@ pub struct SuccessMessage {

 pub fn format_output(action: &RemoteAction, output: RemoteCommandOutput) -> SuccessMessage {
    match action {
-        RemoteAction::Fetch => {
+        RemoteAction::Fetch(remote) => {
            if output.stderr.is_empty() {
                SuccessMessage {
                    message: "Already up to date".into(),
                    style: SuccessStyle::Toast,
                }
            } else {
+                let message = match remote {
+                    Some(remote) => format!("Synchronized with {}", remote.name),
+                    None => "Synchronized with remotes".into(),
+                };
                SuccessMessage {
-                    message: "Synchronized with remotes".into(),
+                    message,
                    style: SuccessStyle::ToastWithLog { output },
                }
            }
--- a/crates/google_ai/src/google_ai.rs
+++ b/crates/google_ai/src/google_ai.rs
@@ -508,6 +508,16 @@ pub enum Model {
    Gemini25ProPreview0325,
    #[serde(rename = "gemini-2.5-flash-preview-04-17")]
    Gemini25FlashPreview0417,
+    #[serde(
+        rename = "gemini-2.5-flash-preview-latest",
+        alias = "gemini-2.5-flash-preview-05-20"
+    )]
+    Gemini25FlashPreview,
+    #[serde(
+        rename = "gemini-2.5-pro-preview-latest",
+        alias = "gemini-2.5-pro-preview-06-05"
+    )]
+    Gemini25ProPreview,
    #[serde(rename = "custom")]
    Custom {
        name: String,
@@ -535,6 +545,24 @@ impl Model {
            Model::Gemini25ProExp0325 => "gemini-2.5-pro-exp-03-25",
            Model::Gemini25ProPreview0325 => "gemini-2.5-pro-preview-03-25",
            Model::Gemini25FlashPreview0417 => "gemini-2.5-flash-preview-04-17",
+            Model::Gemini25FlashPreview => "gemini-2.5-flash-preview-latest",
+            Model::Gemini25ProPreview => "gemini-2.5-pro-preview-latest",
+            Model::Custom { name, .. } => name,
+        }
+    }
+    pub fn request_id(&self) -> &str {
+        match self {
+            Model::Gemini15Pro => "gemini-1.5-pro",
+            Model::Gemini15Flash => "gemini-1.5-flash",
+            Model::Gemini20Pro => "gemini-2.0-pro-exp",
+            Model::Gemini20Flash => "gemini-2.0-flash",
+            Model::Gemini20FlashThinking => "gemini-2.0-flash-thinking-exp",
+            Model::Gemini20FlashLite => "gemini-2.0-flash-lite-preview",
+            Model::Gemini25ProExp0325 => "gemini-2.5-pro-exp-03-25",
+            Model::Gemini25ProPreview0325 => "gemini-2.5-pro-preview-03-25",
+            Model::Gemini25FlashPreview0417 => "gemini-2.5-flash-preview-04-17",
+            Model::Gemini25FlashPreview => "gemini-2.5-flash-preview-05-20",
+            Model::Gemini25ProPreview => "gemini-2.5-pro-preview-06-05",
            Model::Custom { name, .. } => name,
        }
    }
@@ -548,8 +576,10 @@ impl Model {
            Model::Gemini20FlashThinking => "Gemini 2.0 Flash Thinking",
            Model::Gemini20FlashLite => "Gemini 2.0 Flash Lite",
            Model::Gemini25ProExp0325 => "Gemini 2.5 Pro Exp",
-            Model::Gemini25ProPreview0325 => "Gemini 2.5 Pro Preview",
-            Model::Gemini25FlashPreview0417 => "Gemini 2.5 Flash Preview",
+            Model::Gemini25ProPreview0325 => "Gemini 2.5 Pro Preview (0325)",
+            Model::Gemini25FlashPreview0417 => "Gemini 2.5 Flash Preview (0417)",
+            Model::Gemini25FlashPreview => "Gemini 2.5 Flash Preview",
+            Model::Gemini25ProPreview => "Gemini 2.5 Pro Preview",
            Self::Custom {
                name, display_name, ..
            } => display_name.as_ref().unwrap_or(name),
@@ -569,6 +599,8 @@ impl Model {
            Model::Gemini25ProExp0325 => ONE_MILLION,
            Model::Gemini25ProPreview0325 => ONE_MILLION,
            Model::Gemini25FlashPreview0417 => ONE_MILLION,
+            Model::Gemini25FlashPreview => ONE_MILLION,
+            Model::Gemini25ProPreview => ONE_MILLION,
            Model::Custom { max_tokens, .. } => *max_tokens,
        }
    }
@@ -582,6 +614,8 @@ impl Model {
            | Self::Gemini20FlashThinking
            | Self::Gemini20FlashLite
            | Self::Gemini25ProExp0325
+            | Self::Gemini25ProPreview
+            | Self::Gemini25FlashPreview
            | Self::Gemini25ProPreview0325
            | Self::Gemini25FlashPreview0417 => GoogleModelMode::Default,
            Self::Custom { mode, .. } => *mode,
--- a/crates/gpui/examples/painting.rs
+++ b/crates/gpui/examples/painting.rs
@@ -1,13 +1,14 @@
 use gpui::{
    Application, Background, Bounds, ColorSpace, Context, MouseDownEvent, Path, PathBuilder,
-    PathStyle, Pixels, Point, Render, StrokeOptions, Window, WindowOptions, canvas, div,
-    linear_color_stop, linear_gradient, point, prelude::*, px, rgb, size,
+    PathStyle, Pixels, Point, Render, SharedString, StrokeOptions, Window, WindowOptions, canvas,
+    div, linear_color_stop, linear_gradient, point, prelude::*, px, rgb, size,
 };

 struct PaintingViewer {
    default_lines: Vec<(Path<Pixels>, Background)>,
    lines: Vec<Vec<Point<Pixels>>>,
    start: Point<Pixels>,
+    dashed: bool,
    _painting: bool,
 }

@@ -140,7 +141,7 @@ impl PaintingViewer {
            .with_line_join(lyon::path::LineJoin::Bevel);
        let mut builder = PathBuilder::stroke(px(1.)).with_style(PathStyle::Stroke(options));
        builder.move_to(point(px(40.), px(320.)));
-        for i in 0..50 {
+        for i in 1..50 {
            builder.line_to(point(
                px(40.0 + i as f32 * 10.0),
                px(320.0 + (i as f32 * 10.0).sin() * 40.0),
@@ -153,6 +154,7 @@ impl PaintingViewer {
            default_lines: lines.clone(),
            lines: vec![],
            start: point(px(0.), px(0.)),
+            dashed: false,
            _painting: false,
        }
    }
@@ -162,10 +164,30 @@ impl PaintingViewer {
        cx.notify();
    }
 }
+
+fn button(
+    text: &str,
+    cx: &mut Context<PaintingViewer>,
+    on_click: impl Fn(&mut PaintingViewer, &mut Context<PaintingViewer>) + 'static,
+) -> impl IntoElement {
+    div()
+        .id(SharedString::from(text.to_string()))
+        .child(text.to_string())
+        .bg(gpui::black())
+        .text_color(gpui::white())
+        .active(|this| this.opacity(0.8))
+        .flex()
+        .px_3()
+        .py_1()
+        .on_click(cx.listener(move |this, _, _, cx| on_click(this, cx)))
+}
+
 impl Render for PaintingViewer {
    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        let default_lines = self.default_lines.clone();
        let lines = self.lines.clone();
+        let dashed = self.dashed;
+
        div()
            .font_family(".SystemUIFont")
            .bg(gpui::white())
@@ -182,17 +204,14 @@ impl Render for PaintingViewer {
                    .child("Mouse down any point and drag to draw lines (Hold on shift key to draw straight lines)")
                    .child(
                        div()
-                            .id("clear")
-                            .child("Clean up")
-                            .bg(gpui::black())
-                            .text_color(gpui::white())
-                            .active(|this| this.opacity(0.8))
                            .flex()
-                            .px_3()
-                            .py_1()
-                            .on_click(cx.listener(|this, _, _, cx| {
-                                this.clear(cx);
-                            })),
+                            .gap_x_2()
+                            .child(button(
+                                if dashed { "Solid" } else { "Dashed" },
+                                cx,
+                                move |this, _| this.dashed = !dashed,
+                            ))
+                            .child(button("Clear", cx, |this, cx| this.clear(cx))),
                    ),
            )
            .child(
@@ -202,7 +221,6 @@ impl Render for PaintingViewer {
                        canvas(
                            move |_, _, _| {},
                            move |_, _, window, _| {
-
                                for (path, color) in default_lines {
                                    window.paint_path(path, color);
                                }
@@ -213,6 +231,9 @@ impl Render for PaintingViewer {
                                    }

                                    let mut builder = PathBuilder::stroke(px(1.));
+                                    if dashed {
+                                        builder = builder.dash_array(&[px(4.), px(2.)]);
+                                    }
                                    for (i, p) in points.into_iter().enumerate() {
                                        if i == 0 {
                                            builder.move_to(p);
--- a/crates/gpui/examples/scrollable.rs
+++ b/crates/gpui/examples/scrollable.rs
@@ -0,0 +1,60 @@
+use gpui::{
+    App, Application, Bounds, Context, Window, WindowBounds, WindowOptions, div, prelude::*, px,
+    size,
+};
+
+struct Scrollable {}
+
+impl Render for Scrollable {
+    fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .size_full()
+            .id("vertical")
+            .p_4()
+            .overflow_scroll()
+            .bg(gpui::white())
+            .child("Example for test 2 way scroll in nested layout")
+            .child(
+                div()
+                    .h(px(5000.))
+                    .border_1()
+                    .border_color(gpui::blue())
+                    .bg(gpui::blue().opacity(0.05))
+                    .p_4()
+                    .child(
+                        div()
+                            .mb_5()
+                            .w_full()
+                            .id("horizontal")
+                            .overflow_scroll()
+                            .child(
+                                div()
+                                    .w(px(2000.))
+                                    .h(px(150.))
+                                    .bg(gpui::green().opacity(0.1))
+                                    .hover(|this| this.bg(gpui::green().opacity(0.2)))
+                                    .border_1()
+                                    .border_color(gpui::green())
+                                    .p_4()
+                                    .child("Scroll Horizontal"),
+                            ),
+                    )
+                    .child("Scroll Vertical"),
+            )
+    }
+}
+
+fn main() {
+    Application::new().run(|cx: &mut App| {
+        let bounds = Bounds::centered(None, size(px(500.), px(500.0)), cx);
+        cx.open_window(
+            WindowOptions {
+                window_bounds: Some(WindowBounds::Windowed(bounds)),
+                ..Default::default()
+            },
+            |_, cx| cx.new(|_| Scrollable {}),
+        )
+        .unwrap();
+        cx.activate(true);
+    });
+}
--- a/crates/gpui/examples/window_shadow.rs
+++ b/crates/gpui/examples/window_shadow.rs
@@ -61,7 +61,7 @@ impl Render for WindowShadow {
                                            CursorStyle::ResizeUpRightDownLeft
                                        }
                                    },
-                                    Some(&hitbox),
+                                    &hitbox,
                                );
                            },
                        )
--- a/crates/gpui/src/elements/div.rs
+++ b/crates/gpui/src/elements/div.rs
@@ -21,7 +21,8 @@ use crate::{
    HitboxId, InspectorElementId, IntoElement, IsZero, KeyContext, KeyDownEvent, KeyUpEvent,
    LayoutId, ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent,
    Overflow, ParentElement, Pixels, Point, Render, ScrollWheelEvent, SharedString, Size, Style,
-    StyleRefinement, Styled, Task, TooltipId, Visibility, Window, point, px, size,
+    StyleRefinement, Styled, Task, TooltipId, Visibility, Window, WindowControlArea, point, px,
+    size,
 };
 use collections::HashMap;
 use refineable::Refineable;
@@ -575,6 +576,12 @@ impl Interactivity {
        self.hitbox_behavior = HitboxBehavior::BlockMouse;
    }

+    /// Set the bounds of this element as a window control area for the platform window.
+    /// The imperative API equivalent to [`InteractiveElement::window_control_area`]
+    pub fn window_control_area(&mut self, area: WindowControlArea) {
+        self.window_control = Some(area);
+    }
+
    /// Block non-scroll mouse interactions with elements behind this element's hitbox. See
    /// [`Hitbox::is_hovered`] for details.
    ///
@@ -958,6 +965,13 @@ pub trait InteractiveElement: Sized {
        self
    }

+    /// Set the bounds of this element as a window control area for the platform window.
+    /// The fluent API equivalent to [`Interactivity::window_control_area`]
+    fn window_control_area(mut self, area: WindowControlArea) -> Self {
+        self.interactivity().window_control_area(area);
+        self
+    }
+
    /// Block non-scroll mouse interactions with elements behind this element's hitbox. See
    /// [`Hitbox::is_hovered`] for details.
    ///
@@ -1447,6 +1461,7 @@ pub struct Interactivity {
    pub(crate) drag_listener: Option<(Arc<dyn Any>, DragListener)>,
    pub(crate) hover_listener: Option<Box<dyn Fn(&bool, &mut Window, &mut App)>>,
    pub(crate) tooltip_builder: Option<TooltipBuilder>,
+    pub(crate) window_control: Option<WindowControlArea>,
    pub(crate) hitbox_behavior: HitboxBehavior,

    #[cfg(any(feature = "inspector", debug_assertions))]
@@ -1611,6 +1626,7 @@ impl Interactivity {

    fn should_insert_hitbox(&self, style: &Style, window: &Window, cx: &App) -> bool {
        self.hitbox_behavior != HitboxBehavior::Normal
+            || self.window_control.is_some()
            || style.mouse_cursor.is_some()
            || self.group.is_some()
            || self.scroll_offset.is_some()
@@ -1728,11 +1744,11 @@ impl Interactivity {

                                        if let Some(drag) = cx.active_drag.as_ref() {
                                            if let Some(mouse_cursor) = drag.cursor_style {
-                                                window.set_cursor_style(mouse_cursor, None);
+                                                window.set_window_cursor_style(mouse_cursor);
                                            }
                                        } else {
                                            if let Some(mouse_cursor) = style.mouse_cursor {
-                                                window.set_cursor_style(mouse_cursor, Some(hitbox));
+                                                window.set_cursor_style(mouse_cursor, hitbox);
                                            }
                                        }

@@ -1740,6 +1756,11 @@ impl Interactivity {
                                            GroupHitboxes::push(group, hitbox.id, cx);
                                        }

+                                        if let Some(area) = self.window_control {
+                                            window
+                                                .insert_window_control_hitbox(area, hitbox.clone());
+                                        }
+
                                        self.paint_mouse_listeners(
                                            hitbox,
                                            element_state.as_mut(),
@@ -2299,7 +2320,6 @@ impl Interactivity {
                    }
                    scroll_offset.y += delta_y;
                    scroll_offset.x += delta_x;
-                    cx.stop_propagation();
                    if *scroll_offset != old_scroll_offset {
                        cx.notify(current_view);
                    }
--- a/crates/gpui/src/elements/text.rs
+++ b/crates/gpui/src/elements/text.rs
@@ -769,7 +769,7 @@ impl Element for InteractiveText {
                            .iter()
                            .any(|range| range.contains(&ix))
                        {
-                            window.set_cursor_style(crate::CursorStyle::PointingHand, Some(hitbox))
+                            window.set_cursor_style(crate::CursorStyle::PointingHand, hitbox)
                        }
                    }

--- a/crates/gpui/src/key_dispatch.rs
+++ b/crates/gpui/src/key_dispatch.rs
@@ -50,8 +50,8 @@
 ///  KeyBinding::new("cmd-k left", pane::SplitLeft, Some("Pane"))
 ///
 use crate::{
-    Action, ActionRegistry, App, DispatchPhase, EntityId, FocusId, KeyBinding, KeyContext, Keymap,
-    Keystroke, ModifiersChangedEvent, Window,
+    Action, ActionRegistry, App, BindingIndex, DispatchPhase, EntityId, FocusId, KeyBinding,
+    KeyContext, Keymap, Keystroke, ModifiersChangedEvent, Window,
 };
 use collections::FxHashMap;
 use smallvec::SmallVec;
@@ -392,22 +392,67 @@ impl DispatchTree {

    /// Returns key bindings that invoke an action on the currently focused element. Bindings are
    /// returned in the order they were added. For display, the last binding should take precedence.
+    ///
+    /// Bindings are only included if they are the highest precedence match for their keystrokes, so
+    /// shadowed bindings are not included.
    pub fn bindings_for_action(
        &self,
        action: &dyn Action,
        context_stack: &[KeyContext],
    ) -> Vec<KeyBinding> {
+        // Ideally this would return a `DoubleEndedIterator` to avoid `highest_precedence_*`
+        // methods, but this can't be done very cleanly since keymap must be borrowed.
        let keymap = self.keymap.borrow();
        keymap
-            .bindings_for_action(action)
-            .filter(|binding| {
-                let (bindings, _) = keymap.bindings_for_input(&binding.keystrokes, context_stack);
-                bindings.iter().any(|b| b.action.partial_eq(action))
+            .bindings_for_action_with_indices(action)
+            .filter(|(binding_index, binding)| {
+                Self::binding_matches_predicate_and_not_shadowed(
+                    &keymap,
+                    *binding_index,
+                    &binding.keystrokes,
+                    context_stack,
+                )
            })
-            .cloned()
+            .map(|(_, binding)| binding.clone())
            .collect()
    }

+    /// Returns the highest precedence binding for the given action and context stack. This is the
+    /// same as the last result of `bindings_for_action`, but more efficient than getting all bindings.
+    pub fn highest_precedence_binding_for_action(
+        &self,
+        action: &dyn Action,
+        context_stack: &[KeyContext],
+    ) -> Option<KeyBinding> {
+        let keymap = self.keymap.borrow();
+        keymap
+            .bindings_for_action_with_indices(action)
+            .rev()
+            .find_map(|(binding_index, binding)| {
+                let found = Self::binding_matches_predicate_and_not_shadowed(
+                    &keymap,
+                    binding_index,
+                    &binding.keystrokes,
+                    context_stack,
+                );
+                if found { Some(binding.clone()) } else { None }
+            })
+    }
+
+    fn binding_matches_predicate_and_not_shadowed(
+        keymap: &Keymap,
+        binding_index: BindingIndex,
+        keystrokes: &[Keystroke],
+        context_stack: &[KeyContext],
+    ) -> bool {
+        let (bindings, _) = keymap.bindings_for_input_with_indices(&keystrokes, context_stack);
+        if let Some((highest_precedence_index, _)) = bindings.iter().next() {
+            binding_index == *highest_precedence_index
+        } else {
+            false
+        }
+    }
+
    fn bindings_for_input(
        &self,
        input: &[Keystroke],
--- a/crates/gpui/src/keymap.rs
+++ b/crates/gpui/src/keymap.rs
@@ -23,6 +23,10 @@ pub struct Keymap {
    version: KeymapVersion,
 }

+/// Index of a binding within a keymap.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct BindingIndex(usize);
+
 impl Keymap {
    /// Create a new keymap with the given bindings.
    pub fn new(bindings: Vec<KeyBinding>) -> Self {
@@ -63,7 +67,7 @@ impl Keymap {
    }

    /// Iterate over all bindings, in the order they were added.
-    pub fn bindings(&self) -> impl DoubleEndedIterator<Item = &KeyBinding> {
+    pub fn bindings(&self) -> impl DoubleEndedIterator<Item = &KeyBinding> + ExactSizeIterator {
        self.bindings.iter()
    }

@@ -73,6 +77,15 @@ impl Keymap {
        &'a self,
        action: &'a dyn Action,
    ) -> impl 'a + DoubleEndedIterator<Item = &'a KeyBinding> {
+        self.bindings_for_action_with_indices(action)
+            .map(|(_, binding)| binding)
+    }
+
+    /// Like `bindings_for_action_with_indices`, but also returns the binding indices.
+    pub fn bindings_for_action_with_indices<'a>(
+        &'a self,
+        action: &'a dyn Action,
+    ) -> impl 'a + DoubleEndedIterator<Item = (BindingIndex, &'a KeyBinding)> {
        let action_id = action.type_id();
        let binding_indices = self
            .binding_indices_by_action_id
@@ -105,7 +118,7 @@ impl Keymap {
                }
            }

-            Some(binding)
+            Some((BindingIndex(*ix), binding))
        })
    }

@@ -123,7 +136,7 @@ impl Keymap {

    /// Returns a list of bindings that match the given input, and a boolean indicating whether or
    /// not more bindings might match if the input was longer. Bindings are returned in precedence
-    /// order.
+    /// order (higher precedence first, reverse of the order they were added to the keymap).
    ///
    /// Precedence is defined by the depth in the tree (matches on the Editor take precedence over
    /// matches on the Pane, then the Workspace, etc.). Bindings with no context are treated as the
@@ -140,18 +153,36 @@ impl Keymap {
        input: &[Keystroke],
        context_stack: &[KeyContext],
    ) -> (SmallVec<[KeyBinding; 1]>, bool) {
-        let possibilities = self.bindings().rev().filter_map(|binding| {
-            binding
-                .match_keystrokes(input)
-                .map(|pending| (binding, pending))
-        });
+        let (bindings, pending) = self.bindings_for_input_with_indices(input, context_stack);
+        let bindings = bindings
+            .into_iter()
+            .map(|(_, binding)| binding)
+            .collect::<SmallVec<[KeyBinding; 1]>>();
+        (bindings, pending)
+    }

-        let mut bindings: SmallVec<[(KeyBinding, usize); 1]> = SmallVec::new();
+    /// Like `bindings_for_input`, but also returns the binding indices.
+    pub fn bindings_for_input_with_indices(
+        &self,
+        input: &[Keystroke],
+        context_stack: &[KeyContext],
+    ) -> (SmallVec<[(BindingIndex, KeyBinding); 1]>, bool) {
+        let possibilities = self
+            .bindings()
+            .enumerate()
+            .rev()
+            .filter_map(|(ix, binding)| {
+                binding
+                    .match_keystrokes(input)
+                    .map(|pending| (BindingIndex(ix), binding, pending))
+            });
+
+        let mut bindings: SmallVec<[(BindingIndex, KeyBinding, usize); 1]> = SmallVec::new();

        // (pending, is_no_action, depth, keystrokes)
        let mut pending_info_opt: Option<(bool, bool, usize, &[Keystroke])> = None;

-        'outer: for (binding, pending) in possibilities {
+        'outer: for (binding_index, binding, pending) in possibilities {
            for depth in (0..=context_stack.len()).rev() {
                if self.binding_enabled(binding, &context_stack[0..depth]) {
                    let is_no_action = is_no_action(&*binding.action);
@@ -191,20 +222,21 @@ impl Keymap {
                    }

                    if !pending {
-                        bindings.push((binding.clone(), depth));
+                        bindings.push((binding_index, binding.clone(), depth));
                        continue 'outer;
                    }
                }
            }
        }
-        bindings.sort_by(|a, b| a.1.cmp(&b.1).reverse());
+        // sort by descending depth
+        bindings.sort_by(|a, b| a.2.cmp(&b.2).reverse());
        let bindings = bindings
            .into_iter()
-            .map_while(|(binding, _)| {
+            .map_while(|(binding_index, binding, _)| {
                if is_no_action(&*binding.action) {
                    None
                } else {
-                    Some(binding)
+                    Some((binding_index, binding))
                }
            })
            .collect();
@@ -223,34 +255,6 @@ impl Keymap {

        true
    }
-
-    /// WARN: Assumes the bindings are in the order they were added to the keymap
-    /// returns the last binding for the given bindings, which
-    /// should be the user's binding in their keymap.json if they've set one,
-    /// otherwise, the last declared binding for this action in the base keymaps
-    /// (with Vim mode bindings being considered as declared later if Vim mode
-    /// is enabled)
-    ///
-    /// If you are considering changing the behavior of this function
-    /// (especially to fix a user reported issue) see issues #23621, #24931,
-    /// and possibly others as evidence that it has swapped back and forth a
-    /// couple times. The decision as of now is to pick a side and leave it
-    /// as is, until we have a better way to decide which binding to display
-    /// that is consistent and not confusing.
-    pub fn binding_to_display_from_bindings(mut bindings: Vec<KeyBinding>) -> Option<KeyBinding> {
-        bindings.pop()
-    }
-
-    /// Returns the first binding present in the iterator, which tends to be the
-    /// default binding without any key context. This is useful for cases where no
-    /// key context is available on binding display. Otherwise, bindings with a
-    /// more specific key context would take precedence and result in a
-    /// potentially invalid keybind being returned.
-    pub fn default_binding_from_bindings_iterator<'a>(
-        mut bindings: impl Iterator<Item = &'a KeyBinding>,
-    ) -> Option<&'a KeyBinding> {
-        bindings.next()
-    }
 }

 #[cfg(test)]
--- a/crates/gpui/src/path_builder.rs
+++ b/crates/gpui/src/path_builder.rs
@@ -27,6 +27,7 @@ pub struct PathBuilder {
    transform: Option<lyon::math::Transform>,
    /// PathStyle of the PathBuilder
    pub style: PathStyle,
+    dash_array: Option<Vec<Pixels>>,
 }

 impl From<lyon::path::Builder> for PathBuilder {
@@ -77,6 +78,7 @@ impl Default for PathBuilder {
            raw: lyon::path::Path::builder().with_svg(),
            style: PathStyle::Fill(FillOptions::default()),
            transform: None,
+            dash_array: None,
        }
    }
 }
@@ -100,6 +102,24 @@ impl PathBuilder {
        Self { style, ..self }
    }

+    /// Sets the dash array of the [`PathBuilder`].
+    ///
+    /// [MDN](https://developer.mozilla.org/en-US/docs/Web/SVG/Reference/Attribute/stroke-dasharray)
+    pub fn dash_array(mut self, dash_array: &[Pixels]) -> Self {
+        // If an odd number of values is provided, then the list of values is repeated to yield an even number of values.
+        // Thus, 5,3,2 is equivalent to 5,3,2,5,3,2.
+        let array = if dash_array.len() % 2 == 1 {
+            let mut new_dash_array = dash_array.to_vec();
+            new_dash_array.extend_from_slice(dash_array);
+            new_dash_array
+        } else {
+            dash_array.to_vec()
+        };
+
+        self.dash_array = Some(array);
+        self
+    }
+
    /// Move the current point to the given point.
    #[inline]
    pub fn move_to(&mut self, to: Point<Pixels>) {
@@ -229,7 +249,7 @@ impl PathBuilder {
        };

        match self.style {
-            PathStyle::Stroke(options) => Self::tessellate_stroke(&path, &options),
+            PathStyle::Stroke(options) => Self::tessellate_stroke(self.dash_array, &path, &options),
            PathStyle::Fill(options) => Self::tessellate_fill(&path, &options),
        }
    }
@@ -253,9 +273,37 @@ impl PathBuilder {
    }

    fn tessellate_stroke(
+        dash_array: Option<Vec<Pixels>>,
        path: &lyon::path::Path,
        options: &StrokeOptions,
    ) -> Result<Path<Pixels>, Error> {
+        let path = if let Some(dash_array) = dash_array {
+            let measurements = lyon::algorithms::measure::PathMeasurements::from_path(&path, 0.01);
+            let mut sampler = measurements
+                .create_sampler(path, lyon::algorithms::measure::SampleType::Normalized);
+            let mut builder = lyon::path::Path::builder();
+
+            let total_length = sampler.length();
+            let dash_array_len = dash_array.len();
+            let mut pos = 0.;
+            let mut dash_index = 0;
+            while pos < total_length {
+                let dash_length = dash_array[dash_index % dash_array_len].0;
+                let next_pos = (pos + dash_length).min(total_length);
+                if dash_index % 2 == 0 {
+                    let start = pos / total_length;
+                    let end = next_pos / total_length;
+                    sampler.split_range(start..end, &mut builder);
+                }
+                pos = next_pos;
+                dash_index += 1;
+            }
+
+            &builder.build()
+        } else {
+            path
+        };
+
        // Will contain the result of the tessellation.
        let mut buf: VertexBuffers<lyon::math::Point, u16> = VertexBuffers::new();
        let mut tessellator = StrokeTessellator::new();
--- a/Show More
+++ b/Show More