WIP

WIP: start using replace blocks for patches
2024-10-31 15:53:24 +01:00 · 2024-10-31 15:02:21 +01:00 · 2024-10-31 15:02:06 +01:00 · 2024-10-31 15:01:43 +01:00
336 changed files with 6733 additions and 15677 deletions
--- a/.github/ISSUE_TEMPLATE/0_feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/0_feature_request.yml
@@ -15,13 +15,6 @@ body:
      description: A clear and concise description of what you want to happen.
    validations:
      required: true
-  - type: textarea
-    id: environment
-    attributes:
-      label: Environment
-      description: Run the `copy system specs into clipboard` command palette action and paste the output in the field below.
-    validations:
-      required: true
  - type: textarea
    attributes:
      label: |
--- a/.github/ISSUE_TEMPLATE/1_bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/1_bug_report.yml
@@ -2,7 +2,7 @@ name: Bug Report
 description: |
  Use this template for **non-crash-related** bug reports.
  Tip: open this issue template from within Zed with the `file bug report` command palette action.
-labels: ["admin read", "triage", "bug"]
+labels: ["admin read", "triage", "defect"]
 body:
  - type: checkboxes
    attributes:
@@ -38,12 +38,9 @@ body:
        Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
        If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
      value: |
-        <details><summary>Zed.log</summary>
-
+        <details><summary>Zed.log</summary><pre>
        <!-- Click below this line and paste or drag-and-drop your log-->
-        ```

-        ```
-        <!-- Click above this line and paste or drag-and-drop your log--></details>
+        <!-- Click above this line and paste or drag-and-drop your log--></pre></details>
    validations:
      required: false
--- a/.github/ISSUE_TEMPLATE/2_crash_report.yml
+++ b/.github/ISSUE_TEMPLATE/2_crash_report.yml
@@ -1,7 +1,7 @@
 name: Crash Report
 description: |
  Use this template for crash reports.
-labels: ["admin read", "triage", "bug", "panic / crash"]
+labels: ["admin read", "triage", "defect", "panic / crash"]
 body:
  - type: checkboxes
    attributes:
@@ -31,12 +31,9 @@ body:
        Linux: `~/.local/share/zed/logs/Zed.log` or $XDG_DATA_HOME
        If you only need the most recent lines, you can run the `zed: open log` command palette action to see the last 1000.
      value: |
-        <details><summary>Zed.log</summary>
-
+        <details><summary>Zed.log</summary><pre>
        <!-- Click below this line and paste or drag-and-drop your log-->
-        ```

-        ```
-        <!-- Click above this line and paste or drag-and-drop your log--></details>
+        <!-- Click above this line and paste or drag-and-drop your log--></pre></details>
    validations:
      required: false
--- a/.github/actions/run_tests/action.yml
+++ b/.github/actions/run_tests/action.yml
@@ -10,7 +10,7 @@ runs:
        cargo install cargo-nextest

    - name: Install Node
-      uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+      uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
      with:
        node-version: "18"

--- a/.github/workflows/bump_patch_version.yml
+++ b/.github/workflows/bump_patch_version.yml
@@ -43,8 +43,6 @@ jobs:
          esac
          which cargo-set-version > /dev/null || cargo install cargo-edit
          output=$(cargo set-version -p zed --bump patch 2>&1 | sed 's/.* //')
-          export GIT_COMMITTER_NAME="Zed Bot"
-          export GIT_COMMITTER_EMAIL="hi@zed.dev"
          git commit -am "Bump to $output for @$GITHUB_ACTOR" --author "Zed Bot <hi@zed.dev>"
          git tag v${output}${tag_suffix}
          git push origin HEAD v${output}${tag_suffix}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ on:
    branches:
      - "**"
    paths-ignore:
-      - "docs/**/*"
+      - "docs/**"
      - ".github/workflows/community_*"

 concurrency:
@@ -232,7 +232,7 @@ jobs:
      DIGITALOCEAN_SPACES_SECRET_KEY: ${{ secrets.DIGITALOCEAN_SPACES_SECRET_KEY }}
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

@@ -260,7 +260,7 @@ jobs:
        run: |
          mkdir -p target/
          # Ignore any errors that occur while drafting release notes to not fail the build.
-          script/draft-release-notes "$RELEASE_VERSION" "$RELEASE_CHANNEL" > target/release-notes.md || true
+          script/draft-release-notes "$version" "$channel" > target/release-notes.md || true

      - name: Generate license file
        run: script/generate-licenses
--- a/.github/workflows/community_close_stale_issues.yml
+++ b/.github/workflows/community_close_stale_issues.yml
@@ -6,7 +6,6 @@ on:

 jobs:
  stale:
-    if: github.repository_owner == 'zed-industries'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/stale@28ca1036281a5e5922ead5184a1bbf96e5fc984e # v9
@@ -25,7 +24,7 @@ jobs:
          # issues, preventing 365 days from working until then.
          days-before-stale: 180
          days-before-close: 7
-          any-of-issue-labels: "bug,panic / crash"
+          any-of-issue-labels: "defect,panic / crash"
          operations-per-run: 1000
          ascending: true
          enable-statistics: true
--- a/.github/workflows/community_update_all_top_ranking_issues.yml
+++ b/.github/workflows/community_update_all_top_ranking_issues.yml
@@ -12,7 +12,7 @@ jobs:
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      - name: Set up uv
-        uses: astral-sh/setup-uv@2e657c127d5b1635d5a8e3fa40e0ac50a5bf6992 # v3
+        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
        with:
          version: "latest"
          enable-cache: true
--- a/.github/workflows/community_update_weekly_top_ranking_issues.yml
+++ b/.github/workflows/community_update_weekly_top_ranking_issues.yml
@@ -12,7 +12,7 @@ jobs:
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
      - name: Set up uv
-        uses: astral-sh/setup-uv@2e657c127d5b1635d5a8e3fa40e0ac50a5bf6992 # v3
+        uses: astral-sh/setup-uv@f3bcaebff5eace81a1c062af9f9011aae482ca9d # v3
        with:
          version: "latest"
          enable-cache: true
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -21,7 +21,7 @@ jobs:
          version: 9

      - name: Setup Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "20"
          cache: "pnpm"
--- a/.github/workflows/deploy_cloudflare.yml
+++ b/.github/workflows/deploy_cloudflare.yml
@@ -37,28 +37,28 @@ jobs:
          mdbook build ./docs --dest-dir=../target/deploy/docs/

      - name: Deploy Docs
-        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: pages deploy target/deploy --project-name=docs

      - name: Deploy Install
-        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: r2 object put -f script/install.sh zed-open-source-website-assets/install.sh

      - name: Deploy Docs Workers
-        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: deploy .cloudflare/docs-proxy/src/worker.js

      - name: Deploy Install Workers
-        uses: cloudflare/wrangler-action@05f17c4a695b4d94b57b59997562c6a4624c64e4 # v3
+        uses: cloudflare/wrangler-action@9681c2997648301493e78cacbfb790a9f19c833f # v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
--- a/.github/workflows/randomized_tests.yml
+++ b/.github/workflows/randomized_tests.yml
@@ -22,7 +22,7 @@ jobs:
      - buildjet-16vcpu-ubuntu-2204
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

--- a/.github/workflows/release_nightly.yml
+++ b/.github/workflows/release_nightly.yml
@@ -70,7 +70,7 @@ jobs:
      ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON: ${{ secrets.ZED_CLOUD_PROVIDER_ADDITIONAL_MODELS_JSON }}
    steps:
      - name: Install Node
-        uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af # v4
+        uses: actions/setup-node@0a44ba7841725637a19e28fa30b79a866c81b0a6 # v4
        with:
          node-version: "18"

--- a/.mailmap
+++ b/.mailmap
@@ -60,8 +60,6 @@ Max Brunsfeld <maxbrunsfeld@gmail.com>
 Max Brunsfeld <maxbrunsfeld@gmail.com> <max@zed.dev>
 Max Linke <maxlinke88@gmail.com>
 Max Linke <maxlinke88@gmail.com> <kain88-de@users.noreply.github.com>
-Michael Sloan <michael@zed.dev>
-Michael Sloan <michael@zed.dev> <mgsloan@google.com>
 Mikayla Maki <mikayla@zed.dev>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@gmail.com>
 Mikayla Maki <mikayla@zed.dev> <mikayla.c.maki@icloud.com>
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,6 @@ members = [
    "crates/extension",
    "crates/extension_api",
    "crates/extension_cli",
-    "crates/extension_host",
    "crates/extensions_ui",
    "crates/feature_flags",
    "crates/feedback",
@@ -203,7 +202,6 @@ db = { path = "crates/db" }
 diagnostics = { path = "crates/diagnostics" }
 editor = { path = "crates/editor" }
 extension = { path = "crates/extension" }
-extension_host = { path = "crates/extension_host" }
 extensions_ui = { path = "crates/extensions_ui" }
 feature_flags = { path = "crates/feature_flags" }
 feedback = { path = "crates/feedback" }
@@ -339,7 +337,6 @@ chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4.4", features = ["derive"] }
 clickhouse = "0.11.6"
 cocoa = "0.26"
-cocoa-foundation = "0.2.0"
 convert_case = "0.6.0"
 core-foundation = "0.9.3"
 core-foundation-sys = "0.8.6"
@@ -351,7 +348,6 @@ ec4rs = "1.1"
 emojis = "0.6.1"
 env_logger = "0.11"
 exec = "0.3.1"
-fancy-regex = "0.14.0"
 fork = "0.2.0"
 futures = "0.3"
 futures-batch = "0.6.1"
@@ -371,11 +367,10 @@ itertools = "0.13.0"
 jsonwebtoken = "9.3"
 libc = "0.2"
 linkify = "0.10.0"
-linkme = "0.3"
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
-nbformat = "0.3.2"
+nbformat = "0.3.1"
 nix = "0.29"
 num-format = "0.4.4"
 once_cell = "1.19.0"
@@ -384,7 +379,6 @@ palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
 pathdiff = "0.2"
 pet = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c" }
-pet-fs = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c" }
 pet-conda = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 pet-core = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
 pet-poetry = { git = "https://github.com/microsoft/python-environment-tools.git", rev = "ffcbf3f28c46633abd5448a52b1f396c322e0d6c"  }
@@ -409,7 +403,7 @@ reqwest = { git = "https://github.com/zed-industries/reqwest.git", rev = "fd110f
    "stream",
 ] }
 rsa = "0.9.6"
-runtimelib = { version = "0.16.1", default-features = false, features = [
+runtimelib = { version = "0.16.0", default-features = false, features = [
    "async-dispatcher-runtime",
 ] }
 rustc-demangle = "0.1.23"
@@ -479,7 +473,6 @@ tree-sitter-yaml = { git = "https://github.com/zed-industries/tree-sitter-yaml",
 unicase = "2.6"
 unindent = "0.1.7"
 unicode-segmentation = "1.10"
-unicode-script = "0.5.7"
 url = "2.2"
 uuid = { version = "1.1.2", features = ["v4", "v5", "serde"] }
 wasmparser = "0.215"
--- a/assets/icons/file_search.svg
+++ b/assets/icons/file_search.svg
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-file-search"><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"/><path d="m9 18-1.5-1.5"/><circle cx="5" cy="14" r="3"/></svg>
--- a/assets/icons/refresh_title.svg
+++ b/assets/icons/refresh_title.svg
@@ -1,5 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7 21V12M7 12H3M7 12H11" stroke="black" stroke-width="2" stroke-linecap="round"/>
-<path d="M21 19L16 19L16 14" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-<path d="M7.99987 5.07027L7.49915 4.20467L7.99987 5.07027ZM6.04652 5.25026C5.63245 5.61573 5.59305 6.24766 5.95851 6.66173C6.32398 7.0758 6.95592 7.1152 7.36999 6.74974L6.04652 5.25026ZM11.9999 5C15.8659 5 18.9999 8.13401 18.9999 12H20.9999C20.9999 7.02944 16.9705 3 11.9999 3V5ZM18.9999 12C18.9999 14.2101 17.9768 16.1806 16.3744 17.4651L17.6254 19.0256C19.6809 17.3779 20.9999 14.8426 20.9999 12H18.9999ZM8.5006 5.93588C9.5292 5.34086 10.7232 5 11.9999 5V3C10.3623 3 8.82395 3.4383 7.49915 4.20467L8.5006 5.93588ZM7.36999 6.74974C7.71803 6.44255 8.09667 6.16954 8.5006 5.93588L7.49915 4.20467C6.9797 4.50515 6.49329 4.85593 6.04652 5.25026L7.36999 6.74974Z" fill="black"/>
-</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -56,8 +56,7 @@
      "shift-tab": "editor::TabPrev",
      "ctrl-k": "editor::CutToEndOfLine",
      // "ctrl-t": "editor::Transpose",
-      "ctrl-k ctrl-q": "editor::Rewrap",
-      "ctrl-k q": "editor::Rewrap",
+      "alt-q": "editor::Rewrap",
      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-delete": "editor::DeleteToNextWordEnd",
      "shift-delete": "editor::Cut",
@@ -127,8 +126,7 @@
      "shift-enter": "editor::Newline",
      "ctrl-enter": "editor::NewlineAbove",
      "ctrl-shift-enter": "editor::NewlineBelow",
-      "ctrl-k ctrl-z": "editor::ToggleSoftWrap",
-      "ctrl-k z": "editor::ToggleSoftWrap",
+      "alt-z": "editor::ToggleSoftWrap",
      "ctrl-f": "buffer_search::Deploy",
      "ctrl-h": ["buffer_search::Deploy", { "replace_enabled": true }],
      // "cmd-e": ["buffer_search::Deploy", { "focus": false }],
@@ -142,7 +140,7 @@
    "bindings": {
      "alt-]": "editor::NextInlineCompletion",
      "alt-[": "editor::PreviousInlineCompletion",
-      "alt-right": "editor::AcceptPartialInlineCompletion"
+      "ctrl-right": "editor::AcceptPartialInlineCompletion"
    }
  },
  {
@@ -171,7 +169,7 @@
      "ctrl-k c": "assistant::CopyCode",
      "ctrl-g": "search::SelectNextMatch",
      "ctrl-shift-g": "search::SelectPrevMatch",
-      "ctrl-shift-m": "assistant::ToggleModelSelector",
+      "alt-m": "assistant::ToggleModelSelector",
      "ctrl-k h": "assistant::DeployHistory",
      "ctrl-k l": "assistant::DeployPromptLibrary",
      "ctrl-n": "assistant::NewContext"
@@ -253,10 +251,10 @@
      "ctrl-shift-pagedown": "pane::SwapItemRight",
      "ctrl-w": "pane::CloseActiveItem",
      "ctrl-f4": "pane::CloseActiveItem",
-      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
+      "alt-ctrl-t": "pane::CloseInactiveItems",
      "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
-      "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
-      "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
+      "ctrl-k u": "pane::CloseCleanItems",
+      "ctrl-k w": "pane::CloseAllItems",
      "ctrl-shift-f": "project_search::ToggleFocus",
      "ctrl-alt-g": "search::SelectNextMatch",
      "ctrl-alt-shift-g": "search::SelectPrevMatch",
@@ -328,6 +326,7 @@
      "ctrl-k ctrl-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
      "ctrl-.": "editor::ToggleCodeActions",
+      "alt-ctrl-r": "editor::RevealInFileManager",
      "ctrl-k r": "editor::RevealInFileManager",
      "ctrl-k p": "editor::CopyPath",
      "ctrl-\\": "pane::SplitRight",
@@ -418,8 +417,6 @@
      "ctrl-k shift-up": ["workspace::SwapPaneInDirection", "Up"],
      "ctrl-k shift-down": ["workspace::SwapPaneInDirection", "Down"],
      "ctrl-shift-x": "zed::Extensions",
-      "ctrl-shift-r": "task::Rerun",
-      "ctrl-alt-r": "task::Rerun",
      "alt-t": "task::Rerun",
      "alt-shift-t": "task::Spawn"
    }
@@ -567,11 +564,9 @@
      "ctrl-alt-c": "outline_panel::CopyPath",
      "alt-ctrl-shift-c": "outline_panel::CopyRelativePath",
      "alt-ctrl-r": "outline_panel::RevealInFileManager",
-      "space": "outline_panel::Open",
+      "space": ["outline_panel::Open", { "change_selection": false }],
      "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrev",
-      "alt-enter": "editor::OpenExcerpts",
-      "ctrl-k enter": "editor::OpenExcerptsSplit"
+      "shift-up": "menu::SelectPrev"
    }
  },
  {
@@ -592,7 +587,7 @@
      "ctrl-delete": ["project_panel::Delete", { "skip_prompt": false }],
      "alt-ctrl-r": "project_panel::RevealInFileManager",
      "ctrl-shift-enter": "project_panel::OpenWithSystem",
-      "ctrl-shift-f": "project_panel::NewSearchInDirectory",
+      "alt-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev",
      "escape": "menu::Cancel"
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -51,13 +51,14 @@
      "shift-tab": "editor::TabPrev",
      "ctrl-k": "editor::CutToEndOfLine",
      "ctrl-t": "editor::Transpose",
-      "cmd-k q": "editor::Rewrap",
-      "cmd-k cmd-q": "editor::Rewrap",
+      "alt-q": "editor::Rewrap",
      "cmd-backspace": "editor::DeleteToBeginningOfLine",
      "cmd-delete": "editor::DeleteToEndOfLine",
      "alt-backspace": "editor::DeleteToPreviousWordStart",
      "ctrl-w": "editor::DeleteToPreviousWordStart",
      "alt-delete": "editor::DeleteToNextWordEnd",
+      "alt-h": "editor::DeleteToPreviousWordStart",
+      "alt-d": "editor::DeleteToNextWordEnd",
      "cmd-x": "editor::Cut",
      "cmd-c": "editor::Copy",
      "cmd-v": "editor::Paste",
@@ -85,7 +86,9 @@
      "ctrl-f": "editor::MoveRight",
      "ctrl-l": "editor::ScrollCursorCenter",
      "alt-left": "editor::MoveToPreviousWordStart",
+      "alt-b": "editor::MoveToPreviousWordStart",
      "alt-right": "editor::MoveToNextWordEnd",
+      "alt-f": "editor::MoveToNextWordEnd",
      "cmd-left": "editor::MoveToBeginningOfLine",
      "ctrl-a": "editor::MoveToBeginningOfLine",
      "cmd-right": "editor::MoveToEndOfLine",
@@ -101,7 +104,9 @@
      "shift-right": "editor::SelectRight",
      "ctrl-shift-f": "editor::SelectRight",
      "alt-shift-left": "editor::SelectToPreviousWordStart", // cursorWordLeftSelect
+      "alt-shift-b": "editor::SelectToPreviousWordStart",
      "alt-shift-right": "editor::SelectToNextWordEnd", // cursorWordRightSelect
+      "alt-shift-f": "editor::SelectToNextWordEnd",
      "ctrl-shift-up": "editor::SelectToStartOfParagraph",
      "ctrl-shift-down": "editor::SelectToEndOfParagraph",
      "cmd-shift-up": "editor::SelectToBeginning",
@@ -116,7 +121,7 @@
      "shift-end": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
      "ctrl-shift-e": ["editor::SelectToEndOfLine", { "stop_at_soft_wraps": true }],
      "ctrl-v": ["editor::MovePageDown", { "center_cursor": true }],
-      "ctrl-shift-v": ["editor::MovePageUp", { "center_cursor": true }],
+      "alt-v": ["editor::MovePageUp", { "center_cursor": true }],
      "ctrl-cmd-space": "editor::ShowCharacterPalette",
      "cmd-;": "editor::ToggleLineNumbers",
      "cmd-alt-z": "editor::RevertSelectedHunks",
@@ -135,7 +140,7 @@
      "shift-enter": "editor::Newline",
      "cmd-enter": "editor::NewlineBelow",
      "cmd-shift-enter": "editor::NewlineAbove",
-      "cmd-k z": "editor::ToggleSoftWrap",
+      "alt-z": "editor::ToggleSoftWrap",
      "cmd-f": "buffer_search::Deploy",
      "cmd-alt-f": ["buffer_search::Deploy", { "replace_enabled": true }],
      "cmd-alt-l": ["buffer_search::Deploy", { "selection_search_enabled": true }],
@@ -150,7 +155,7 @@
    "bindings": {
      "alt-]": "editor::NextInlineCompletion",
      "alt-[": "editor::PreviousInlineCompletion",
-      "ctrl-right": "editor::AcceptPartialInlineCompletion"
+      "cmd-right": "editor::AcceptPartialInlineCompletion"
    }
  },
  {
@@ -186,7 +191,7 @@
      "cmd-k c": "assistant::CopyCode",
      "cmd-g": "search::SelectNextMatch",
      "cmd-shift-g": "search::SelectPrevMatch",
-      "cmd-shift-m": "assistant::ToggleModelSelector",
+      "alt-m": "assistant::ToggleModelSelector",
      "cmd-k h": "assistant::DeployHistory",
      "cmd-k l": "assistant::DeployPromptLibrary",
      "cmd-n": "assistant::NewContext"
@@ -286,10 +291,10 @@
      "ctrl-shift-pageup": "pane::SwapItemLeft",
      "ctrl-shift-pagedown": "pane::SwapItemRight",
      "cmd-w": "pane::CloseActiveItem",
-      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
+      "alt-cmd-t": "pane::CloseInactiveItems",
      "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
-      "cmd-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
-      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
+      "cmd-k u": "pane::CloseCleanItems",
+      "cmd-k cmd-w": "pane::CloseAllItems",
      "cmd-f": "project_search::ToggleFocus",
      "cmd-g": "search::SelectNextMatch",
      "cmd-shift-g": "search::SelectPrevMatch",
@@ -359,6 +364,7 @@
      "cmd-k cmd-j": "editor::UnfoldAll",
      "ctrl-space": "editor::ShowCompletions",
      "cmd-.": "editor::ToggleCodeActions",
+      "alt-cmd-r": "editor::RevealInFileManager",
      "cmd-k r": "editor::RevealInFileManager",
      "cmd-k p": "editor::CopyPath",
      "cmd-\\": "pane::SplitRight",
@@ -451,9 +457,7 @@
  {
    "context": "Workspace && !Terminal",
    "bindings": {
-      "cmd-shift-r": "task::Spawn",
-      "cmd-alt-r": "task::Rerun",
-      "alt-t": "task::Spawn",
+      "alt-t": "task::Rerun",
      "alt-shift-t": "task::Spawn"
    }
  },
@@ -573,11 +577,9 @@
      "cmd-alt-c": "outline_panel::CopyPath",
      "alt-cmd-shift-c": "outline_panel::CopyRelativePath",
      "alt-cmd-r": "outline_panel::RevealInFileManager",
-      "space": "outline_panel::Open",
+      "space": ["outline_panel::Open", { "change_selection": false }],
      "shift-down": "menu::SelectNext",
-      "shift-up": "menu::SelectPrev",
-      "alt-enter": "editor::OpenExcerpts",
-      "cmd-k enter": "editor::OpenExcerptsSplit"
+      "shift-up": "menu::SelectPrev"
    }
  },
  {
@@ -602,7 +604,7 @@
      "alt-cmd-r": "project_panel::RevealInFileManager",
      "ctrl-shift-enter": "project_panel::OpenWithSystem",
      "cmd-alt-backspace": ["project_panel::Delete", { "skip_prompt": false }],
-      "cmd-shift-f": "project_panel::NewSearchInDirectory",
+      "alt-shift-f": "project_panel::NewSearchInDirectory",
      "shift-down": "menu::SelectNext",
      "shift-up": "menu::SelectPrev",
      "escape": "menu::Cancel"
--- a/assets/keymaps/linux/emacs.json
+++ b/assets/keymaps/linux/emacs.json
@@ -1,63 +0,0 @@
-// documentation: https://zed.dev/docs/key-bindings
-//
-// To see the default key bindings run `zed: open default keymap`
-// from the command palette.
-[
-  {
-    "context": "Editor",
-    "bindings": {
-      "ctrl-g": "editor::Cancel",
-      "ctrl-shift-g": "go_to_line::Toggle",
-      //"ctrl-space": "editor::SetMark",
-      "ctrl-x u": "editor::Undo",
-      "ctrl-x ctrl-u": "editor::Redo",
-      "ctrl-f": "editor::MoveRight",
-      "ctrl-b": "editor::MoveLeft",
-      "ctrl-n": "editor::MoveDown",
-      "ctrl-p": "editor::MoveUp",
-      "ctrl-a": "editor::MoveToBeginningOfLine",
-      "ctrl-e": "editor::MoveToEndOfLine",
-      "alt-f": "editor::MoveToNextSubwordEnd",
-      "alt-b": "editor::MoveToPreviousSubwordStart",
-      "ctrl-d": "editor::Delete",
-      "alt-d": "editor::DeleteToNextWordEnd",
-      "ctrl-k": "editor::CutToEndOfLine",
-      "ctrl-w": "editor::Cut",
-      "alt-w": "editor::Copy",
-      "ctrl-y": "editor::Paste",
-      "ctrl-_": "editor::Undo",
-      "ctrl-v": "editor::MovePageDown",
-      "alt-v": "editor::MovePageUp",
-      "ctrl-x ]": "editor::MoveToEnd",
-      "ctrl-x [": "editor::MoveToBeginning",
-      "ctrl-l": "editor::ScrollCursorCenterTopBottom",
-      "ctrl-s": "buffer_search::Deploy",
-      "ctrl-x ctrl-f": "file_finder::Toggle",
-      "ctrl-shift-r": "editor::Rename"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "ctrl-x k": "pane::CloseActiveItem",
-      "ctrl-x ctrl-c": "workspace::CloseWindow",
-      "ctrl-x o": "workspace::ActivateNextPane",
-      "ctrl-x b": "tab_switcher::Toggle",
-      "ctrl-x 0": "pane::CloseActiveItem",
-      "ctrl-x 1": "pane::CloseInactiveItems",
-      "ctrl-x 2": "pane::SplitVertical",
-      "ctrl-x ctrl-f": "file_finder::Toggle",
-      "ctrl-x ctrl-s": "workspace::Save",
-      "ctrl-x ctrl-w": "workspace::SaveAs",
-      "ctrl-x s": "workspace::SaveAll",
-      "shift shift": "file_finder::Toggle"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "ctrl-alt-left": "pane::GoBack",
-      "ctrl-alt-right": "pane::GoForward"
-    }
-  }
-]
--- a/assets/keymaps/linux/jetbrains.json
+++ b/assets/keymaps/linux/jetbrains.json
@@ -1,7 +1,6 @@
 [
  {
    "bindings": {
-      "ctrl-alt-s": "zed::OpenSettings",
      "ctrl-shift-[": "pane::ActivatePrevItem",
      "ctrl-shift-]": "pane::ActivateNextItem"
    }
@@ -26,8 +25,8 @@
      "alt-j": ["editor::SelectNext", { "replace_newest": false }],
      "alt-shift-j": ["editor::SelectPrevious", { "replace_newest": false }],
      "ctrl-/": ["editor::ToggleComments", { "advance_downwards": true }],
-      "ctrl-w": "editor::SelectLargerSyntaxNode",
-      "ctrl-shift-w": "editor::SelectSmallerSyntaxNode",
+      "alt-up": "editor::SelectLargerSyntaxNode",
+      "alt-down": "editor::SelectSmallerSyntaxNode",
      "shift-alt-up": "editor::MoveLineUp",
      "shift-alt-down": "editor::MoveLineDown",
      "ctrl-alt-l": "editor::Format",
@@ -44,7 +43,6 @@
      "shift-f2": "editor::GoToPrevDiagnostic",
      "ctrl-alt-shift-down": "editor::GoToHunk",
      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
-      "ctrl-alt-z": "editor::RevertSelectedHunks",
      "ctrl-home": "editor::MoveToBeginning",
      "ctrl-end": "editor::MoveToEnd",
      "ctrl-shift-home": "editor::SelectToBeginning",
--- a/assets/keymaps/macos/emacs.json
+++ b/assets/keymaps/macos/emacs.json
@@ -1,63 +0,0 @@
-// documentation: https://zed.dev/docs/key-bindings
-//
-// To see the default key bindings run `zed: open default keymap`
-// from the command palette.
-[
-  {
-    "context": "Editor",
-    "bindings": {
-      "ctrl-g": "editor::Cancel",
-      "ctrl-shift-g": "go_to_line::Toggle",
-      //"ctrl-space": "editor::SetMark",
-      "ctrl-x u": "editor::Undo",
-      "ctrl-x ctrl-u": "editor::Redo",
-      "ctrl-f": "editor::MoveRight",
-      "ctrl-b": "editor::MoveLeft",
-      "ctrl-n": "editor::MoveDown",
-      "ctrl-p": "editor::MoveUp",
-      "ctrl-a": "editor::MoveToBeginningOfLine",
-      "ctrl-e": "editor::MoveToEndOfLine",
-      "alt-f": "editor::MoveToNextSubwordEnd",
-      "alt-b": "editor::MoveToPreviousSubwordStart",
-      "ctrl-d": "editor::Delete",
-      "alt-d": "editor::DeleteToNextWordEnd",
-      "ctrl-k": "editor::CutToEndOfLine",
-      "ctrl-w": "editor::Cut",
-      "alt-w": "editor::Copy",
-      "ctrl-y": "editor::Paste",
-      "ctrl-_": "editor::Undo",
-      "ctrl-v": "editor::MovePageDown",
-      "alt-v": "editor::MovePageUp",
-      "ctrl-x ]": "editor::MoveToEnd",
-      "ctrl-x [": "editor::MoveToBeginning",
-      "ctrl-l": "editor::ScrollCursorCenterTopBottom",
-      "ctrl-s": "buffer_search::Deploy",
-      "ctrl-x ctrl-f": "file_finder::Toggle",
-      "ctrl-shift-r": "editor::Rename"
-    }
-  },
-  {
-    "context": "Workspace",
-    "bindings": {
-      "ctrl-x k": "pane::CloseActiveItem",
-      "ctrl-x ctrl-c": "workspace::CloseWindow",
-      "ctrl-x o": "workspace::ActivateNextPane",
-      "ctrl-x b": "tab_switcher::Toggle",
-      "ctrl-x 0": "pane::CloseActiveItem",
-      "ctrl-x 1": "pane::CloseInactiveItems",
-      "ctrl-x 2": "pane::SplitVertical",
-      "ctrl-x ctrl-f": "file_finder::Toggle",
-      "ctrl-x ctrl-s": "workspace::Save",
-      "ctrl-x ctrl-w": "workspace::SaveAs",
-      "ctrl-x s": "workspace::SaveAll",
-      "shift shift": "file_finder::Toggle"
-    }
-  },
-  {
-    "context": "Pane",
-    "bindings": {
-      "ctrl-alt-left": "pane::GoBack",
-      "ctrl-alt-right": "pane::GoForward"
-    }
-  }
-]
--- a/assets/keymaps/macos/jetbrains.json
+++ b/assets/keymaps/macos/jetbrains.json
@@ -24,8 +24,8 @@
      "ctrl-g": ["editor::SelectNext", { "replace_newest": false }],
      "ctrl-cmd-g": ["editor::SelectPrevious", { "replace_newest": false }],
      "cmd-/": ["editor::ToggleComments", { "advance_downwards": true }],
-      "cmd-up": "editor::SelectLargerSyntaxNode",
-      "cmd-down": "editor::SelectSmallerSyntaxNode",
+      "alt-up": "editor::SelectLargerSyntaxNode",
+      "alt-down": "editor::SelectSmallerSyntaxNode",
      "shift-alt-up": "editor::MoveLineUp",
      "shift-alt-down": "editor::MoveLineDown",
      "cmd-alt-l": "editor::Format",
@@ -58,12 +58,6 @@
      "alt-enter": "editor::ToggleCodeActions"
    }
  },
-  {
-    "context": "BufferSearchBar > Editor",
-    "bindings": {
-      "shift-enter": "search::SelectPrevMatch"
-    }
-  },
  {
    "context": "Workspace",
    "bindings": {
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -1,7 +1,6 @@
 [
  {
    "context": "VimControl && !menu",
-    "use_layout_keys": true,
    "bindings": {
      "i": ["vim::PushOperator", { "Object": { "around": false } }],
      "a": ["vim::PushOperator", { "Object": { "around": true } }],
@@ -128,9 +127,6 @@
      "shift-h": "vim::WindowTop",
      "shift-m": "vim::WindowMiddle",
      "shift-l": "vim::WindowBottom",
-      "q": "vim::ToggleRecord",
-      "shift-q": "vim::ReplayLastRecording",
-      "@": ["vim::PushOperator", "ReplayRegister"],
      // z commands
      "z enter": ["workspace::SendKeystrokes", "z t ^"],
      "z -": ["workspace::SendKeystrokes", "z b ^"],
@@ -141,14 +137,14 @@
      "z .": ["workspace::SendKeystrokes", "z z ^"],
      "z b": "editor::ScrollCursorBottom",
      "z a": "editor::ToggleFold",
-      "z shift-a": "editor::ToggleFoldRecursive",
+      "z A": "editor::ToggleFoldRecursive",
      "z c": "editor::Fold",
-      "z shift-c": "editor::FoldRecursive",
+      "z C": "editor::FoldRecursive",
      "z o": "editor::UnfoldLines",
-      "z shift-o": "editor::UnfoldRecursive",
+      "z O": "editor::UnfoldRecursive",
      "z f": "editor::FoldSelectedRanges",
-      "z shift-m": "editor::FoldAll",
-      "z shift-r": "editor::UnfoldAll",
+      "z M": "editor::FoldAll",
+      "z R": "editor::UnfoldAll",
      "shift-z shift-q": ["pane::CloseActiveItem", { "saveIntent": "skip" }],
      "shift-z shift-z": ["pane::CloseActiveItem", { "saveIntent": "saveAll" }],
      // Count support
@@ -161,374 +157,6 @@
      "7": ["vim::Number", 7],
      "8": ["vim::Number", 8],
      "9": ["vim::Number", 9],
-      "ctrl-w d": "editor::GoToDefinitionSplit",
-      "ctrl-w g d": "editor::GoToDefinitionSplit",
-      "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
-      "ctrl-w g shift-d": "editor::GoToTypeDefinitionSplit",
-      "ctrl-w space": "editor::OpenExcerptsSplit",
-      "ctrl-w g space": "editor::OpenExcerptsSplit",
-      "ctrl-6": "pane::AlternateFile"
-    }
-  },
-  {
-    "context": "vim_mode == normal",
-    "use_layout_keys": true,
-    "bindings": {
-      "escape": "editor::Cancel",
-      "ctrl-[": "editor::Cancel",
-      ":": "command_palette::Toggle",
-      ".": "vim::Repeat",
-      "c": ["vim::PushOperator", "Change"],
-      "shift-c": "vim::ChangeToEndOfLine",
-      "d": ["vim::PushOperator", "Delete"],
-      "shift-d": "vim::DeleteToEndOfLine",
-      "shift-j": "vim::JoinLines",
-      "y": ["vim::PushOperator", "Yank"],
-      "shift-y": "vim::YankLine",
-      "i": "vim::InsertBefore",
-      "shift-i": "vim::InsertFirstNonWhitespace",
-      "a": "vim::InsertAfter",
-      "shift-a": "vim::InsertEndOfLine",
-      "x": "vim::DeleteRight",
-      "shift-x": "vim::DeleteLeft",
-      "o": "vim::InsertLineBelow",
-      "shift-o": "vim::InsertLineAbove",
-      "~": "vim::ChangeCase",
-      "ctrl-a": "vim::Increment",
-      "ctrl-x": "vim::Decrement",
-      "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "before": true }],
-      "u": "vim::Undo",
-      "ctrl-r": "vim::Redo",
-      "r": ["vim::PushOperator", "Replace"],
-      "s": "vim::Substitute",
-      "shift-s": "vim::SubstituteLine",
-      ">": ["vim::PushOperator", "Indent"],
-      "<": ["vim::PushOperator", "Outdent"],
-      "g u": ["vim::PushOperator", "Lowercase"],
-      "g shift-u": ["vim::PushOperator", "Uppercase"],
-      "g ~": ["vim::PushOperator", "OppositeCase"],
-      "\"": ["vim::PushOperator", "Register"],
-      "g q": ["vim::PushOperator", "Rewrap"],
-      "g w": ["vim::PushOperator", "Rewrap"],
-      "ctrl-pagedown": "pane::ActivateNextItem",
-      "ctrl-pageup": "pane::ActivatePrevItem",
-      "insert": "vim::InsertBefore",
-      // tree-sitter related commands
-      "[ x": "editor::SelectLargerSyntaxNode",
-      "] x": "editor::SelectSmallerSyntaxNode",
-      "] d": "editor::GoToDiagnostic",
-      "[ d": "editor::GoToPrevDiagnostic",
-      "] c": "editor::GoToHunk",
-      "[ c": "editor::GoToPrevHunk",
-      "g c": ["vim::PushOperator", "ToggleComments"]
-    }
-  },
-  {
-    "context": "VimControl && VimCount",
-    "use_layout_keys": true,
-    "bindings": {
-      "0": ["vim::Number", 0],
-      ":": "vim::CountCommand"
-    }
-  },
-  {
-    "context": "vim_mode == visual",
-    "use_layout_keys": true,
-    "bindings": {
-      ":": "vim::VisualCommand",
-      "u": "vim::ConvertToLowerCase",
-      "shift-u": "vim::ConvertToUpperCase",
-      "o": "vim::OtherEnd",
-      "shift-o": "vim::OtherEnd",
-      "d": "vim::VisualDelete",
-      "x": "vim::VisualDelete",
-      "shift-d": "vim::VisualDeleteLine",
-      "shift-x": "vim::VisualDeleteLine",
-      "y": "vim::VisualYank",
-      "shift-y": "vim::VisualYank",
-      "p": "vim::Paste",
-      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
-      "s": "vim::Substitute",
-      "shift-s": "vim::SubstituteLine",
-      "shift-r": "vim::SubstituteLine",
-      "c": "vim::Substitute",
-      "~": "vim::ChangeCase",
-      "*": ["vim::MoveToNext", { "partialWord": true }],
-      "#": ["vim::MoveToPrev", { "partialWord": true }],
-      "ctrl-a": "vim::Increment",
-      "ctrl-x": "vim::Decrement",
-      "g ctrl-a": ["vim::Increment", { "step": true }],
-      "g ctrl-x": ["vim::Decrement", { "step": true }],
-      "shift-i": "vim::InsertBefore",
-      "shift-a": "vim::InsertAfter",
-      "g shift-i": "vim::VisualInsertFirstNonWhiteSpace",
-      "g shift-a": "vim::VisualInsertEndOfLine",
-      "shift-j": "vim::JoinLines",
-      "r": ["vim::PushOperator", "Replace"],
-      "ctrl-c": ["vim::SwitchMode", "Normal"],
-      "escape": ["vim::SwitchMode", "Normal"],
-      "ctrl-[": ["vim::SwitchMode", "Normal"],
-      ">": "vim::Indent",
-      "<": "vim::Outdent",
-      "i": ["vim::PushOperator", { "Object": { "around": false } }],
-      "a": ["vim::PushOperator", { "Object": { "around": true } }],
-      "g c": "vim::ToggleComments",
-      "g q": "vim::Rewrap",
-      "\"": ["vim::PushOperator", "Register"],
-      // tree-sitter related commands
-      "[ x": "editor::SelectLargerSyntaxNode",
-      "] x": "editor::SelectSmallerSyntaxNode"
-    }
-  },
-  {
-    "context": "vim_mode == insert",
-    "use_layout_keys": true,
-    "bindings": {
-      "escape": "vim::NormalBefore",
-      "ctrl-c": "vim::NormalBefore",
-      "ctrl-[": "vim::NormalBefore",
-      "ctrl-x": null,
-      "ctrl-x ctrl-o": "editor::ShowCompletions",
-      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
-      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
-      "ctrl-x ctrl-l": "editor::ToggleCodeActions", // zed specific
-      "ctrl-x ctrl-z": "editor::Cancel",
-      "ctrl-w": "editor::DeleteToPreviousWordStart",
-      "ctrl-u": "editor::DeleteToBeginningOfLine",
-      "ctrl-t": "vim::Indent",
-      "ctrl-d": "vim::Outdent",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-r": ["vim::PushOperator", "Register"],
-      "insert": "vim::ToggleReplace"
-    }
-  },
-  {
-    "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
-    "use_layout_keys": true,
-    "bindings": {
-      "ctrl-p": "editor::ShowCompletions",
-      "ctrl-n": "editor::ShowCompletions"
-    }
-  },
-  {
-    "context": "vim_mode == replace",
-    "use_layout_keys": true,
-    "bindings": {
-      "escape": "vim::NormalBefore",
-      "ctrl-c": "vim::NormalBefore",
-      "ctrl-[": "vim::NormalBefore",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-v": "editor::Paste", // note: this is *very* similar to ctrl-v in vim, but ctrl-shift-v on linux is the typical shortcut for paste when ctrl-v is already in use.
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-shift-q": ["vim::PushOperator", { "Literal": {} }],
-      "backspace": "vim::UndoReplace",
-      "tab": "vim::Tab",
-      "enter": "vim::Enter",
-      "insert": "vim::InsertBefore"
-    }
-  },
-  {
-    "context": "vim_mode == waiting",
-    "use_layout_keys": true,
-    "bindings": {
-      "tab": "vim::Tab",
-      "enter": "vim::Enter",
-      "escape": "vim::ClearOperators",
-      "ctrl-c": "vim::ClearOperators",
-      "ctrl-[": "vim::ClearOperators",
-      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
-      "ctrl-v": ["vim::PushOperator", { "Literal": {} }],
-      "ctrl-q": ["vim::PushOperator", { "Literal": {} }]
-    }
-  },
-  {
-    "context": "vim_mode == operator",
-    "use_layout_keys": true,
-    "bindings": {
-      "escape": "vim::ClearOperators",
-      "ctrl-c": "vim::ClearOperators",
-      "ctrl-[": "vim::ClearOperators"
-    }
-  },
-  {
-    "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
-    "use_layout_keys": true,
-    "bindings": {
-      "w": "vim::Word",
-      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
-      "t": "vim::Tag",
-      "s": "vim::Sentence",
-      "p": "vim::Paragraph",
-      "'": "vim::Quotes",
-      "`": "vim::BackQuotes",
-      "\"": "vim::DoubleQuotes",
-      "|": "vim::VerticalBars",
-      "(": "vim::Parentheses",
-      ")": "vim::Parentheses",
-      "b": "vim::Parentheses",
-      "[": "vim::SquareBrackets",
-      "]": "vim::SquareBrackets",
-      "r": "vim::SquareBrackets",
-      "{": "vim::CurlyBrackets",
-      "}": "vim::CurlyBrackets",
-      "shift-b": "vim::CurlyBrackets",
-      "<": "vim::AngleBrackets",
-      ">": "vim::AngleBrackets",
-      "a": "vim::AngleBrackets",
-      "g": "vim::Argument"
-    }
-  },
-  {
-    "context": "vim_operator == c",
-    "use_layout_keys": true,
-    "bindings": {
-      "c": "vim::CurrentLine",
-      "d": "editor::Rename", // zed specific
-      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
-    }
-  },
-  {
-    "context": "vim_operator == d",
-    "use_layout_keys": true,
-    "bindings": {
-      "d": "vim::CurrentLine",
-      "s": ["vim::PushOperator", "DeleteSurrounds"],
-      "o": "editor::ToggleHunkDiff", // "d o"
-      "p": "editor::RevertSelectedHunks" // "d p"
-    }
-  },
-  {
-    "context": "vim_operator == gu",
-    "use_layout_keys": true,
-    "bindings": {
-      "g u": "vim::CurrentLine",
-      "u": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == gU",
-    "use_layout_keys": true,
-    "bindings": {
-      "g shift-u": "vim::CurrentLine",
-      "shift-u": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == g~",
-    "use_layout_keys": true,
-    "bindings": {
-      "g ~": "vim::CurrentLine",
-      "~": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == gq",
-    "use_layout_keys": true,
-    "bindings": {
-      "g q": "vim::CurrentLine",
-      "q": "vim::CurrentLine",
-      "g w": "vim::CurrentLine",
-      "w": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == y",
-    "use_layout_keys": true,
-    "bindings": {
-      "y": "vim::CurrentLine",
-      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
-    }
-  },
-  {
-    "context": "vim_operator == ys",
-    "use_layout_keys": true,
-    "bindings": {
-      "s": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == >",
-    "use_layout_keys": true,
-    "bindings": {
-      ">": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == <",
-    "use_layout_keys": true,
-    "bindings": {
-      "<": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_operator == gc",
-    "use_layout_keys": true,
-    "bindings": {
-      "c": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "vim_mode == literal",
-    "use_layout_keys": true,
-    "bindings": {
-      "ctrl-@": ["vim::Literal", ["ctrl-@", "\u0000"]],
-      "ctrl-a": ["vim::Literal", ["ctrl-a", "\u0001"]],
-      "ctrl-b": ["vim::Literal", ["ctrl-b", "\u0002"]],
-      "ctrl-c": ["vim::Literal", ["ctrl-c", "\u0003"]],
-      "ctrl-d": ["vim::Literal", ["ctrl-d", "\u0004"]],
-      "ctrl-e": ["vim::Literal", ["ctrl-e", "\u0005"]],
-      "ctrl-f": ["vim::Literal", ["ctrl-f", "\u0006"]],
-      "ctrl-g": ["vim::Literal", ["ctrl-g", "\u0007"]],
-      "ctrl-h": ["vim::Literal", ["ctrl-h", "\u0008"]],
-      "ctrl-i": ["vim::Literal", ["ctrl-i", "\u0009"]],
-      "ctrl-j": ["vim::Literal", ["ctrl-j", "\u000A"]],
-      "ctrl-k": ["vim::Literal", ["ctrl-k", "\u000B"]],
-      "ctrl-l": ["vim::Literal", ["ctrl-l", "\u000C"]],
-      "ctrl-m": ["vim::Literal", ["ctrl-m", "\u000D"]],
-      "ctrl-n": ["vim::Literal", ["ctrl-n", "\u000E"]],
-      "ctrl-o": ["vim::Literal", ["ctrl-o", "\u000F"]],
-      "ctrl-p": ["vim::Literal", ["ctrl-p", "\u0010"]],
-      "ctrl-q": ["vim::Literal", ["ctrl-q", "\u0011"]],
-      "ctrl-r": ["vim::Literal", ["ctrl-r", "\u0012"]],
-      "ctrl-s": ["vim::Literal", ["ctrl-s", "\u0013"]],
-      "ctrl-t": ["vim::Literal", ["ctrl-t", "\u0014"]],
-      "ctrl-u": ["vim::Literal", ["ctrl-u", "\u0015"]],
-      "ctrl-v": ["vim::Literal", ["ctrl-v", "\u0016"]],
-      "ctrl-w": ["vim::Literal", ["ctrl-w", "\u0017"]],
-      "ctrl-x": ["vim::Literal", ["ctrl-x", "\u0018"]],
-      "ctrl-y": ["vim::Literal", ["ctrl-y", "\u0019"]],
-      "ctrl-z": ["vim::Literal", ["ctrl-z", "\u001A"]],
-      "ctrl-[": ["vim::Literal", ["ctrl-[", "\u001B"]],
-      "ctrl-\\": ["vim::Literal", ["ctrl-\\", "\u001C"]],
-      "ctrl-]": ["vim::Literal", ["ctrl-]", "\u001D"]],
-      "ctrl-^": ["vim::Literal", ["ctrl-^", "\u001E"]],
-      "ctrl-_": ["vim::Literal", ["ctrl-_", "\u001F"]],
-      "escape": ["vim::Literal", ["escape", "\u001B"]],
-      "enter": ["vim::Literal", ["enter", "\u000D"]],
-      "tab": ["vim::Literal", ["tab", "\u0009"]],
-      // zed extensions:
-      "backspace": ["vim::Literal", ["backspace", "\u0008"]],
-      "delete": ["vim::Literal", ["delete", "\u007F"]]
-    }
-  },
-  {
-    "context": "BufferSearchBar && !in_replace",
-    "use_layout_keys": true,
-    "bindings": {
-      "enter": "vim::SearchSubmit",
-      "escape": "buffer_search::Dismiss"
-    }
-  },
-  {
-    "context": "ProjectPanel || CollabPanel || OutlinePanel || ChatPanel || VimControl || EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
-    "use_layout_keys": true,
-    "bindings": {
      // window related commands (ctrl-w X)
      "ctrl-w": null,
      "ctrl-w left": ["workspace::ActivatePaneInDirection", "Left"],
@@ -573,12 +201,299 @@
      "ctrl-w o": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-w ctrl-o": "workspace::CloseInactiveTabsAndPanes",
      "ctrl-w n": "workspace::NewFileSplitHorizontal",
-      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal"
+      "ctrl-w ctrl-n": "workspace::NewFileSplitHorizontal",
+      "ctrl-w d": "editor::GoToDefinitionSplit",
+      "ctrl-w g d": "editor::GoToDefinitionSplit",
+      "ctrl-w shift-d": "editor::GoToTypeDefinitionSplit",
+      "ctrl-w g shift-d": "editor::GoToTypeDefinitionSplit",
+      "ctrl-w space": "editor::OpenExcerptsSplit",
+      "ctrl-w g space": "editor::OpenExcerptsSplit",
+      "ctrl-6": "pane::AlternateFile"
    }
  },
  {
-    "context": "EmptyPane || SharedScreen || MarkdownPreview || KeyContextView",
-    "use_layout_keys": true,
+    "context": "vim_mode == normal",
+    "bindings": {
+      "escape": "editor::Cancel",
+      "ctrl-[": "editor::Cancel",
+      ":": "command_palette::Toggle",
+      ".": "vim::Repeat",
+      "c": ["vim::PushOperator", "Change"],
+      "shift-c": "vim::ChangeToEndOfLine",
+      "d": ["vim::PushOperator", "Delete"],
+      "shift-d": "vim::DeleteToEndOfLine",
+      "shift-j": "vim::JoinLines",
+      "y": ["vim::PushOperator", "Yank"],
+      "shift-y": "vim::YankLine",
+      "i": "vim::InsertBefore",
+      "shift-i": "vim::InsertFirstNonWhitespace",
+      "a": "vim::InsertAfter",
+      "shift-a": "vim::InsertEndOfLine",
+      "x": "vim::DeleteRight",
+      "shift-x": "vim::DeleteLeft",
+      "o": "vim::InsertLineBelow",
+      "shift-o": "vim::InsertLineAbove",
+      "~": "vim::ChangeCase",
+      "ctrl-a": "vim::Increment",
+      "ctrl-x": "vim::Decrement",
+      "p": "vim::Paste",
+      "shift-p": ["vim::Paste", { "before": true }],
+      "u": "vim::Undo",
+      "ctrl-r": "vim::Redo",
+      "r": ["vim::PushOperator", "Replace"],
+      "s": "vim::Substitute",
+      "shift-s": "vim::SubstituteLine",
+      ">": ["vim::PushOperator", "Indent"],
+      "<": ["vim::PushOperator", "Outdent"],
+      "g u": ["vim::PushOperator", "Lowercase"],
+      "g shift-u": ["vim::PushOperator", "Uppercase"],
+      "g ~": ["vim::PushOperator", "OppositeCase"],
+      "\"": ["vim::PushOperator", "Register"],
+      "g q": ["vim::PushOperator", "Rewrap"],
+      "g w": ["vim::PushOperator", "Rewrap"],
+      "q": "vim::ToggleRecord",
+      "shift-q": "vim::ReplayLastRecording",
+      "@": ["vim::PushOperator", "ReplayRegister"],
+      "ctrl-pagedown": "pane::ActivateNextItem",
+      "ctrl-pageup": "pane::ActivatePrevItem",
+      "insert": "vim::InsertBefore",
+      // tree-sitter related commands
+      "[ x": "editor::SelectLargerSyntaxNode",
+      "] x": "editor::SelectSmallerSyntaxNode",
+      "] d": "editor::GoToDiagnostic",
+      "[ d": "editor::GoToPrevDiagnostic",
+      "] c": "editor::GoToHunk",
+      "[ c": "editor::GoToPrevHunk",
+      "g c": ["vim::PushOperator", "ToggleComments"]
+    }
+  },
+  {
+    "context": "VimControl && VimCount",
+    "bindings": {
+      "0": ["vim::Number", 0],
+      ":": "vim::CountCommand"
+    }
+  },
+  {
+    "context": "vim_mode == visual",
+    "bindings": {
+      ":": "vim::VisualCommand",
+      "u": "vim::ConvertToLowerCase",
+      "U": "vim::ConvertToUpperCase",
+      "o": "vim::OtherEnd",
+      "shift-o": "vim::OtherEnd",
+      "d": "vim::VisualDelete",
+      "x": "vim::VisualDelete",
+      "shift-d": "vim::VisualDeleteLine",
+      "shift-x": "vim::VisualDeleteLine",
+      "y": "vim::VisualYank",
+      "shift-y": "vim::VisualYank",
+      "p": "vim::Paste",
+      "shift-p": ["vim::Paste", { "preserveClipboard": true }],
+      "s": "vim::Substitute",
+      "shift-s": "vim::SubstituteLine",
+      "shift-r": "vim::SubstituteLine",
+      "c": "vim::Substitute",
+      "~": "vim::ChangeCase",
+      "*": ["vim::MoveToNext", { "partialWord": true }],
+      "#": ["vim::MoveToPrev", { "partialWord": true }],
+      "ctrl-a": "vim::Increment",
+      "ctrl-x": "vim::Decrement",
+      "g ctrl-a": ["vim::Increment", { "step": true }],
+      "g ctrl-x": ["vim::Decrement", { "step": true }],
+      "shift-i": "vim::InsertBefore",
+      "shift-a": "vim::InsertAfter",
+      "g I": "vim::VisualInsertFirstNonWhiteSpace",
+      "g A": "vim::VisualInsertEndOfLine",
+      "shift-j": "vim::JoinLines",
+      "r": ["vim::PushOperator", "Replace"],
+      "ctrl-c": ["vim::SwitchMode", "Normal"],
+      "escape": ["vim::SwitchMode", "Normal"],
+      "ctrl-[": ["vim::SwitchMode", "Normal"],
+      ">": "vim::Indent",
+      "<": "vim::Outdent",
+      "i": ["vim::PushOperator", { "Object": { "around": false } }],
+      "a": ["vim::PushOperator", { "Object": { "around": true } }],
+      "g c": "vim::ToggleComments",
+      "g q": "vim::Rewrap",
+      "\"": ["vim::PushOperator", "Register"],
+      // tree-sitter related commands
+      "[ x": "editor::SelectLargerSyntaxNode",
+      "] x": "editor::SelectSmallerSyntaxNode"
+    }
+  },
+  {
+    "context": "vim_mode == insert",
+    "bindings": {
+      "escape": "vim::NormalBefore",
+      "ctrl-c": "vim::NormalBefore",
+      "ctrl-[": "vim::NormalBefore",
+      "ctrl-x": null,
+      "ctrl-x ctrl-o": "editor::ShowCompletions",
+      "ctrl-x ctrl-a": "assistant::InlineAssist", // zed specific
+      "ctrl-x ctrl-c": "editor::ShowInlineCompletion", // zed specific
+      "ctrl-x ctrl-l": "editor::ToggleCodeActions", // zed specific
+      "ctrl-x ctrl-z": "editor::Cancel",
+      "ctrl-w": "editor::DeleteToPreviousWordStart",
+      "ctrl-u": "editor::DeleteToBeginningOfLine",
+      "ctrl-t": "vim::Indent",
+      "ctrl-d": "vim::Outdent",
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "ctrl-r": ["vim::PushOperator", "Register"],
+      "insert": "vim::ToggleReplace"
+    }
+  },
+  {
+    "context": "vim_mode == insert && !(showing_code_actions || showing_completions)",
+    "bindings": {
+      "ctrl-p": "editor::ShowCompletions",
+      "ctrl-n": "editor::ShowCompletions"
+    }
+  },
+  {
+    "context": "vim_mode == replace",
+    "bindings": {
+      "escape": "vim::NormalBefore",
+      "ctrl-c": "vim::NormalBefore",
+      "ctrl-[": "vim::NormalBefore",
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }],
+      "backspace": "vim::UndoReplace",
+      "tab": "vim::Tab",
+      "enter": "vim::Enter",
+      "insert": "vim::InsertBefore"
+    }
+  },
+  {
+    "context": "vim_mode == waiting",
+    "bindings": {
+      "tab": "vim::Tab",
+      "enter": "vim::Enter",
+      "escape": "vim::ClearOperators",
+      "ctrl-c": "vim::ClearOperators",
+      "ctrl-[": "vim::ClearOperators",
+      "ctrl-k": ["vim::PushOperator", { "Digraph": {} }]
+    }
+  },
+  {
+    "context": "vim_mode == operator",
+    "bindings": {
+      "escape": "vim::ClearOperators",
+      "ctrl-c": "vim::ClearOperators",
+      "ctrl-[": "vim::ClearOperators"
+    }
+  },
+  {
+    "context": "vim_operator == a || vim_operator == i || vim_operator == cs",
+    "bindings": {
+      "w": "vim::Word",
+      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
+      "t": "vim::Tag",
+      "s": "vim::Sentence",
+      "p": "vim::Paragraph",
+      "'": "vim::Quotes",
+      "`": "vim::BackQuotes",
+      "\"": "vim::DoubleQuotes",
+      "|": "vim::VerticalBars",
+      "(": "vim::Parentheses",
+      ")": "vim::Parentheses",
+      "b": "vim::Parentheses",
+      "[": "vim::SquareBrackets",
+      "]": "vim::SquareBrackets",
+      "{": "vim::CurlyBrackets",
+      "}": "vim::CurlyBrackets",
+      "shift-b": "vim::CurlyBrackets",
+      "<": "vim::AngleBrackets",
+      ">": "vim::AngleBrackets",
+      "a": "vim::Argument"
+    }
+  },
+  {
+    "context": "vim_operator == c",
+    "bindings": {
+      "c": "vim::CurrentLine",
+      "d": "editor::Rename", // zed specific
+      "s": ["vim::PushOperator", { "ChangeSurrounds": {} }]
+    }
+  },
+  {
+    "context": "vim_operator == d",
+    "bindings": {
+      "d": "vim::CurrentLine",
+      "s": ["vim::PushOperator", "DeleteSurrounds"],
+      "o": "editor::ToggleHunkDiff", // "d o"
+      "p": "editor::RevertSelectedHunks" // "d p"
+    }
+  },
+  {
+    "context": "vim_operator == gu",
+    "bindings": {
+      "g u": "vim::CurrentLine",
+      "u": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == gU",
+    "bindings": {
+      "g shift-u": "vim::CurrentLine",
+      "shift-u": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == g~",
+    "bindings": {
+      "g ~": "vim::CurrentLine",
+      "~": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == gq",
+    "bindings": {
+      "g q": "vim::CurrentLine",
+      "q": "vim::CurrentLine",
+      "g w": "vim::CurrentLine",
+      "w": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == y",
+    "bindings": {
+      "y": "vim::CurrentLine",
+      "s": ["vim::PushOperator", { "AddSurrounds": {} }]
+    }
+  },
+  {
+    "context": "vim_operator == ys",
+    "bindings": {
+      "s": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == >",
+    "bindings": {
+      ">": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == <",
+    "bindings": {
+      "<": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "vim_operator == gc",
+    "bindings": {
+      "c": "vim::CurrentLine"
+    }
+  },
+  {
+    "context": "BufferSearchBar && !in_replace",
+    "bindings": {
+      "enter": "vim::SearchSubmit",
+      "escape": "buffer_search::Dismiss"
+    }
+  },
+  {
+    "context": "EmptyPane || SharedScreen",
    "bindings": {
      ":": "command_palette::Toggle",
      "g /": "pane::DeploySearch"
@@ -587,7 +502,6 @@
  {
    // netrw compatibility
    "context": "ProjectPanel && not_editing",
-    "use_layout_keys": true,
    "bindings": {
      ":": "command_palette::Toggle",
      "%": "project_panel::NewFile",
@@ -615,7 +529,6 @@
  },
  {
    "context": "OutlinePanel && not_editing",
-    "use_layout_keys": true,
    "bindings": {
      "j": "menu::SelectNext",
      "k": "menu::SelectPrev",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -68,17 +68,9 @@
  "ui_font_size": 16,
  // How much to fade out unused code.
  "unnecessary_code_fade": 0.3,
-  // Active pane styling settings.
-  "active_pane_modifiers": {
-    // The factor to grow the active pane by. Defaults to 1.0
-    // which gives the same size as all other panes.
-    "magnification": 1.0,
-    // Inset border size of the active pane, in pixels.
-    "border_size": 0.0,
-    // Opacity of the inactive panes. 0 means transparent, 1 means opaque.
-    // Values are clamped to the [0.0, 1.0] range.
-    "inactive_opacity": 1.0
-  },
+  // The factor to grow the active pane by. Defaults to 1.0
+  // which gives the same size as all other panes.
+  "active_pane_magnification": 1.0,
  // The direction that you want to split panes horizontally. Defaults to "up"
  "pane_split_direction_horizontal": "up",
  // The direction that you want to split panes horizontally. Defaults to "left"
@@ -160,7 +152,7 @@
  "show_signature_help_after_edits": true,
  // Whether to show wrap guides (vertical rulers) in the editor.
  // Setting this to true will show a guide at the 'preferred_line_length' value
-  // if 'soft_wrap' is set to 'preferred_line_length', and will show any
+  // if softwrap is set to 'preferred_line_length', and will show any
  // additional guides as specified by the 'wrap_guides' setting.
  "show_wrap_guides": true,
  // Character counts at which to show wrap guides in the editor.
@@ -182,8 +174,6 @@
  // bracket, brace, single or double quote characters.
  // For example, when you select text and type (, Zed will surround the text with ().
  "use_auto_surround": true,
-  // Whether indentation of pasted content should be adjusted based on the context.
-  "auto_indent_on_paste": true,
  // Controls how the editor handles the autoclosed characters.
  // When set to `false`(default), skipping over and auto-removing of the closing characters
  // happen only for auto-inserted characters.
@@ -485,7 +475,7 @@
    "default_width": 640,
    // Default height when the assistant is docked to the bottom.
    "default_height": 320,
-    // The default model to use when creating new chats.
+    // The default model to use when creating new contexts.
    "default_model": {
      // The provider to use.
      "provider": "zed.dev",
@@ -830,6 +820,7 @@
  "tasks": {
    "variables": {}
  },
+  "toolchain": { "name": "default", "path": "default" },
  // An object whose keys are language names, and whose values
  // are arrays of filenames or extensions of files that should
  // use those languages.
--- a/assets/themes/one/one.json
+++ b/assets/themes/one/one.json
@@ -27,15 +27,15 @@
        "ghost_element.active": "#454a56ff",
        "ghost_element.selected": "#454a56ff",
        "ghost_element.disabled": "#2e343eff",
-        "text": "#dce0e5ff",
-        "text.muted": "#a9afbcff",
-        "text.placeholder": "#878a98ff",
-        "text.disabled": "#878a98ff",
+        "text": "#c8ccd4ff",
+        "text.muted": "#838994ff",
+        "text.placeholder": "#696B77ff",
+        "text.disabled": "#696B77ff",
        "text.accent": "#74ade8ff",
-        "icon": "#dce0e5ff",
-        "icon.muted": "#a9afbcff",
-        "icon.disabled": "#878a98ff",
-        "icon.placeholder": "#a9afbcff",
+        "icon": "#c8ccd4ff",
+        "icon.muted": "#838994ff",
+        "icon.disabled": "#696B77ff",
+        "icon.placeholder": "#838994ff",
        "icon.accent": "#74ade8ff",
        "status_bar.background": "#3b414dff",
        "title_bar.background": "#3b414dff",
@@ -60,19 +60,19 @@
        "editor.active_line.background": "#2f343ebf",
        "editor.highlighted_line.background": "#2f343eff",
        "editor.line_number": "#c8ccd459",
-        "editor.active_line_number": "#dce0e5ff",
-        "editor.invisible": "#878a98ff",
+        "editor.active_line_number": "#c8ccd4ff",
+        "editor.invisible": "#696B77ff",
        "editor.wrap_guide": "#c8ccd40d",
        "editor.active_wrap_guide": "#c8ccd41a",
        "editor.document_highlight.read_background": "#74ade81a",
        "editor.document_highlight.write_background": "#555a6366",
        "terminal.background": "#282c33ff",
-        "terminal.foreground": "#dce0e5ff",
-        "terminal.bright_foreground": "#dce0e5ff",
+        "terminal.foreground": "#c8ccd4ff",
+        "terminal.bright_foreground": "#c8ccd4ff",
        "terminal.dim_foreground": "#282c33ff",
        "terminal.ansi.black": "#282c33ff",
        "terminal.ansi.bright_black": "#525561ff",
-        "terminal.ansi.dim_black": "#dce0e5ff",
+        "terminal.ansi.dim_black": "#c8ccd4ff",
        "terminal.ansi.red": "#d07277ff",
        "terminal.ansi.bright_red": "#673a3cff",
        "terminal.ansi.dim_red": "#eab7b9ff",
@@ -91,8 +91,8 @@
        "terminal.ansi.cyan": "#6eb4bfff",
        "terminal.ansi.bright_cyan": "#3a565bff",
        "terminal.ansi.dim_cyan": "#b9d9dfff",
-        "terminal.ansi.white": "#dce0e5ff",
-        "terminal.ansi.bright_white": "#dce0e5ff",
+        "terminal.ansi.white": "#c8ccd4ff",
+        "terminal.ansi.bright_white": "#c8ccd4ff",
        "terminal.ansi.dim_white": "#575d65ff",
        "link_text.hover": "#74ade8ff",
        "conflict": "#dec184ff",
@@ -107,14 +107,14 @@
        "error": "#d07277ff",
        "error.background": "#d072771a",
        "error.border": "#4c2b2cff",
-        "hidden": "#878a98ff",
-        "hidden.background": "#696b771a",
+        "hidden": "#696B77ff",
+        "hidden.background": "#696B771a",
        "hidden.border": "#414754ff",
-        "hint": "#788ca6ff",
+        "hint": "#5a6f89ff",
        "hint.background": "#5a6f891a",
        "hint.border": "#293b5bff",
-        "ignored": "#878a98ff",
-        "ignored.background": "#696b771a",
+        "ignored": "#696B77ff",
+        "ignored.background": "#696B771a",
        "ignored.border": "#464b57ff",
        "info": "#74ade8ff",
        "info.background": "#74ade81a",
@@ -131,7 +131,7 @@
        "success": "#a1c181ff",
        "success.background": "#a1c1811a",
        "success.border": "#38482fff",
-        "unreachable": "#a9afbcff",
+        "unreachable": "#838994ff",
        "unreachable.background": "#8389941a",
        "unreachable.border": "#464b57ff",
        "warning": "#dec184ff",
@@ -211,7 +211,7 @@
            "font_weight": null
          },
          "embedded": {
-            "color": "#dce0e5ff",
+            "color": "#c8ccd4ff",
            "font_style": null,
            "font_weight": null
          },
@@ -236,7 +236,7 @@
            "font_weight": null
          },
          "hint": {
-            "color": "#788ca6ff",
+            "color": "#5a6f89ff",
            "font_style": null,
            "font_weight": 700
          },
@@ -276,7 +276,7 @@
            "font_weight": null
          },
          "preproc": {
-            "color": "#dce0e5ff",
+            "color": "#c8ccd4ff",
            "font_style": null,
            "font_weight": null
          },
@@ -361,7 +361,7 @@
            "font_weight": null
          },
          "variable": {
-            "color": "#dce0e5ff",
+            "color": "#c8ccd4ff",
            "font_style": null,
            "font_weight": null
          },
@@ -402,15 +402,15 @@
        "ghost_element.active": "#cacacaff",
        "ghost_element.selected": "#cacacaff",
        "ghost_element.disabled": "#ebebecff",
-        "text": "#242529ff",
-        "text.muted": "#58585aff",
-        "text.placeholder": "#7e8086ff",
-        "text.disabled": "#7e8086ff",
+        "text": "#383a41ff",
+        "text.muted": "#7e8087ff",
+        "text.placeholder": "#a1a1a3ff",
+        "text.disabled": "#a1a1a3ff",
        "text.accent": "#5c78e2ff",
-        "icon": "#242529ff",
-        "icon.muted": "#58585aff",
-        "icon.disabled": "#7e8086ff",
-        "icon.placeholder": "#58585aff",
+        "icon": "#383a41ff",
+        "icon.muted": "#7e8087ff",
+        "icon.disabled": "#a1a1a3ff",
+        "icon.placeholder": "#7e8087ff",
        "icon.accent": "#5c78e2ff",
        "status_bar.background": "#dcdcddff",
        "title_bar.background": "#dcdcddff",
@@ -428,26 +428,26 @@
        "scrollbar.thumb.border": "#dfdfe0ff",
        "scrollbar.track.background": "#00000000",
        "scrollbar.track.border": "#eeeeeeff",
-        "editor.foreground": "#242529ff",
+        "editor.foreground": "#383a41ff",
        "editor.background": "#fafafaff",
        "editor.gutter.background": "#fafafaff",
        "editor.subheader.background": "#ebebecff",
        "editor.active_line.background": "#ebebecbf",
        "editor.highlighted_line.background": "#ebebecff",
        "editor.line_number": "#383a4159",
-        "editor.active_line_number": "#242529ff",
+        "editor.active_line_number": "#383a41ff",
        "editor.invisible": "#a3a3a4ff",
        "editor.wrap_guide": "#383a410d",
        "editor.active_wrap_guide": "#383a411a",
        "editor.document_highlight.read_background": "#5c78e21a",
        "editor.document_highlight.write_background": "#a3a3a466",
        "terminal.background": "#fafafaff",
-        "terminal.foreground": "#242529ff",
-        "terminal.bright_foreground": "#242529ff",
+        "terminal.foreground": "#383a41ff",
+        "terminal.bright_foreground": "#383a41ff",
        "terminal.dim_foreground": "#fafafaff",
        "terminal.ansi.black": "#fafafaff",
        "terminal.ansi.bright_black": "#aaaaaaff",
-        "terminal.ansi.dim_black": "#242529ff",
+        "terminal.ansi.dim_black": "#383a41ff",
        "terminal.ansi.red": "#d36151ff",
        "terminal.ansi.bright_red": "#f0b0a4ff",
        "terminal.ansi.dim_red": "#6f312aff",
@@ -466,11 +466,11 @@
        "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.white": "#383a41ff",
+        "terminal.ansi.bright_white": "#383a41ff",
        "terminal.ansi.dim_white": "#97979aff",
        "link_text.hover": "#5c78e2ff",
-        "conflict": "#a48819ff",
+        "conflict": "#dec184ff",
        "conflict.background": "#faf2e6ff",
        "conflict.border": "#f4e7d1ff",
        "created": "#669f59ff",
@@ -482,19 +482,19 @@
        "error": "#d36151ff",
        "error.background": "#fbdfd9ff",
        "error.border": "#f6c6bdff",
-        "hidden": "#7e8086ff",
+        "hidden": "#a1a1a3ff",
        "hidden.background": "#dcdcddff",
        "hidden.border": "#d3d3d4ff",
-        "hint": "#7274a7ff",
+        "hint": "#9294beff",
        "hint.background": "#e2e2faff",
        "hint.border": "#cbcdf6ff",
-        "ignored": "#7e8086ff",
+        "ignored": "#a1a1a3ff",
        "ignored.background": "#dcdcddff",
        "ignored.border": "#c9c9caff",
        "info": "#5c78e2ff",
        "info.background": "#e2e2faff",
        "info.border": "#cbcdf6ff",
-        "modified": "#a48819ff",
+        "modified": "#a47a23ff",
        "modified.background": "#faf2e6ff",
        "modified.border": "#f4e7d1ff",
        "predictive": "#9b9ec6ff",
@@ -506,10 +506,10 @@
        "success": "#669f59ff",
        "success.background": "#dfeadbff",
        "success.border": "#c8dcc1ff",
-        "unreachable": "#58585aff",
+        "unreachable": "#7e8087ff",
        "unreachable.background": "#dcdcddff",
        "unreachable.border": "#c9c9caff",
-        "warning": "#a48819ff",
+        "warning": "#dec184ff",
        "warning.background": "#faf2e6ff",
        "warning.border": "#f4e7d1ff",
        "players": [
@@ -544,7 +544,7 @@
            "selection": "#d361513d"
          },
          {
-            "cursor": "#a48819ff",
+            "cursor": "#dec184ff",
            "background": "#dec184ff",
            "selection": "#dec1843d"
          },
@@ -586,7 +586,7 @@
            "font_weight": null
          },
          "embedded": {
-            "color": "#242529ff",
+            "color": "#383a41ff",
            "font_style": null,
            "font_weight": null
          },
@@ -611,7 +611,7 @@
            "font_weight": null
          },
          "hint": {
-            "color": "#7274a7ff",
+            "color": "#9294beff",
            "font_style": null,
            "font_weight": 700
          },
@@ -651,12 +651,12 @@
            "font_weight": null
          },
          "preproc": {
-            "color": "#242529ff",
+            "color": "#383a41ff",
            "font_style": null,
            "font_weight": null
          },
          "primary": {
-            "color": "#242529ff",
+            "color": "#383a41ff",
            "font_style": null,
            "font_weight": null
          },
@@ -666,7 +666,7 @@
            "font_weight": null
          },
          "punctuation": {
-            "color": "#242529ff",
+            "color": "#383a41ff",
            "font_style": null,
            "font_weight": null
          },
@@ -736,7 +736,7 @@
            "font_weight": null
          },
          "variable": {
-            "color": "#242529ff",
+            "color": "#383a41ff",
            "font_style": null,
            "font_weight": null
          },
--- a/assets/themes/solarized/solarized.json
+++ b/assets/themes/solarized/solarized.json
@@ -519,8 +519,8 @@
            "selection": "#d337813d"
          },
          {
-            "cursor": "#cb4b16ff",
-            "background": "#cb4b16ff",
+            "cursor": "#cb4b17ff",
+            "background": "#cb4b17ff",
            "selection": "#cb4b173d"
          },
          {
@@ -596,7 +596,7 @@
            "font_weight": 700
          },
          "enum": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
@@ -621,7 +621,7 @@
            "font_weight": null
          },
          "link_text": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": "italic",
            "font_weight": null
          },
@@ -636,7 +636,7 @@
            "font_weight": null
          },
          "operator": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
@@ -686,7 +686,7 @@
            "font_weight": null
          },
          "string": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
@@ -696,17 +696,17 @@
            "font_weight": null
          },
          "string.regex": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
          "string.special": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
          "string.special.symbol": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
@@ -716,7 +716,7 @@
            "font_weight": null
          },
          "text.literal": {
-            "color": "#cb4b16ff",
+            "color": "#cb4b17ff",
            "font_style": null,
            "font_weight": null
          },
--- a/crates/activity_indicator/Cargo.toml
+++ b/crates/activity_indicator/Cargo.toml
@@ -16,7 +16,7 @@ doctest = false
 anyhow.workspace = true
 auto_update.workspace = true
 editor.workspace = true
-extension_host.workspace = true
+extension.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -1,6 +1,6 @@
 use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
 use editor::Editor;
-use extension_host::ExtensionStore;
+use extension::ExtensionStore;
 use futures::StreamExt;
 use gpui::{
    actions, percentage, Animation, AnimationExt as _, AppContext, CursorStyle, EventEmitter,
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -12,14 +12,10 @@ mod prompts;
 mod slash_command;
 pub(crate) mod slash_command_picker;
 pub mod slash_command_settings;
-mod slash_command_working_set;
 mod streaming_diff;
 mod terminal_inline_assistant;
-mod tool_working_set;
 mod tools;

-pub use crate::slash_command_working_set::{SlashCommandId, SlashCommandWorkingSet};
-pub use crate::tool_working_set::{ToolId, ToolWorkingSet};
 pub use assistant_panel::{AssistantPanel, AssistantPanelEvent};
 use assistant_settings::AssistantSettings;
 use assistant_slash_command::SlashCommandRegistry;
@@ -27,11 +23,12 @@ use assistant_tool::ToolRegistry;
 use client::{proto, Client};
 use command_palette_hooks::CommandPaletteFilter;
 pub use context::*;
+use context_servers::ContextServerRegistry;
 pub use context_store::*;
 use feature_flags::FeatureFlagAppExt;
 use fs::Fs;
-use gpui::impl_actions;
 use gpui::{actions, AppContext, Global, SharedString, UpdateGlobal};
+use gpui::{impl_actions, Context as _};
 use indexed_docs::IndexedDocsRegistry;
 pub(crate) use inline_assistant::*;
 use language_model::{
@@ -44,18 +41,16 @@ use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsStore};
-use slash_command::search_command::SearchSlashCommandFeatureFlag;
 use slash_command::{
-    auto_command, cargo_workspace_command, default_command, delta_command, diagnostics_command,
-    docs_command, fetch_command, file_command, now_command, project_command, prompt_command,
-    search_command, selection_command, symbols_command, tab_command, terminal_command,
+    auto_command, cargo_workspace_command, context_server_command, default_command, delta_command,
+    diagnostics_command, docs_command, fetch_command, file_command, now_command, project_command,
+    prompt_command, search_command, symbols_command, tab_command, terminal_command,
 };
 use std::path::PathBuf;
 use std::sync::Arc;
 pub(crate) use streaming_diff::*;
 use util::ResultExt;

-use crate::slash_command::streaming_example_command;
 use crate::slash_command_settings::SlashCommandSettings;

 actions!(
@@ -215,23 +210,21 @@ pub fn init(
        });
    }

-    if cx.has_flag::<SearchSlashCommandFeatureFlag>() {
-        cx.spawn(|mut cx| {
-            let client = client.clone();
-            async move {
-                let embedding_provider = CloudEmbeddingProvider::new(client.clone());
-                let semantic_index = SemanticDb::new(
-                    paths::embeddings_dir().join("semantic-index-db.0.mdb"),
-                    Arc::new(embedding_provider),
-                    &mut cx,
-                )
-                .await?;
+    cx.spawn(|mut cx| {
+        let client = client.clone();
+        async move {
+            let embedding_provider = CloudEmbeddingProvider::new(client.clone());
+            let semantic_index = SemanticDb::new(
+                paths::embeddings_dir().join("semantic-index-db.0.mdb"),
+                Arc::new(embedding_provider),
+                &mut cx,
+            )
+            .await?;

-                cx.update(|cx| cx.set_global(semantic_index))
-            }
-        })
-        .detach();
-    }
+            cx.update(|cx| cx.set_global(semantic_index))
+        }
+    })
+    .detach();

    context_store::init(&client.clone().into());
    prompt_library::init(cx);
@@ -283,9 +276,116 @@ pub fn init(
    })
    .detach();

+    register_context_server_handlers(cx);
+
    prompt_builder
 }

+fn register_context_server_handlers(cx: &mut AppContext) {
+    cx.subscribe(
+        &context_servers::manager::ContextServerManager::global(cx),
+        |manager, event, cx| match event {
+            context_servers::manager::Event::ServerStarted { server_id } => {
+                cx.update_model(
+                    &manager,
+                    |manager: &mut context_servers::manager::ContextServerManager, cx| {
+                        let slash_command_registry = SlashCommandRegistry::global(cx);
+                        let context_server_registry = ContextServerRegistry::global(cx);
+                        if let Some(server) = manager.get_server(server_id) {
+                            cx.spawn(|_, _| async move {
+                                let Some(protocol) = server.client.read().clone() else {
+                                    return;
+                                };
+
+                                if protocol.capable(context_servers::protocol::ServerCapability::Prompts) {
+                                    if let Some(prompts) = protocol.list_prompts().await.log_err() {
+                                        for prompt in prompts
+                                            .into_iter()
+                                            .filter(context_server_command::acceptable_prompt)
+                                        {
+                                            log::info!(
+                                                "registering context server command: {:?}",
+                                                prompt.name
+                                            );
+                                            context_server_registry.register_command(
+                                                server.id.clone(),
+                                                prompt.name.as_str(),
+                                            );
+                                            slash_command_registry.register_command(
+                                                context_server_command::ContextServerSlashCommand::new(
+                                                    &server, prompt,
+                                                ),
+                                                true,
+                                            );
+                                        }
+                                    }
+                                }
+                            })
+                            .detach();
+                        }
+                    },
+                );
+
+                cx.update_model(
+                    &manager,
+                    |manager: &mut context_servers::manager::ContextServerManager, cx| {
+                        let tool_registry = ToolRegistry::global(cx);
+                        let context_server_registry = ContextServerRegistry::global(cx);
+                        if let Some(server) = manager.get_server(server_id) {
+                            cx.spawn(|_, _| async move {
+                                let Some(protocol) = server.client.read().clone() else {
+                                    return;
+                                };
+
+                                if protocol.capable(context_servers::protocol::ServerCapability::Tools) {
+                                    if let Some(tools) = protocol.list_tools().await.log_err() {
+                                        for tool in tools.tools {
+                                            log::info!(
+                                                "registering context server tool: {:?}",
+                                                tool.name
+                                            );
+                                            context_server_registry.register_tool(
+                                                server.id.clone(),
+                                                tool.name.as_str(),
+                                            );
+                                            tool_registry.register_tool(
+                                                tools::context_server_tool::ContextServerTool::new(
+                                                    server.id.clone(),
+                                                    tool
+                                                ),
+                                            );
+                                        }
+                                    }
+                                }
+                            })
+                            .detach();
+                        }
+                    },
+                );
+            }
+            context_servers::manager::Event::ServerStopped { server_id } => {
+                let slash_command_registry = SlashCommandRegistry::global(cx);
+                let context_server_registry = ContextServerRegistry::global(cx);
+                if let Some(commands) = context_server_registry.get_commands(server_id) {
+                    for command_name in commands {
+                        slash_command_registry.unregister_command_by_name(&command_name);
+                        context_server_registry.unregister_command(&server_id, &command_name);
+                    }
+                }
+
+                if let Some(tools) = context_server_registry.get_tools(server_id) {
+                    let tool_registry = ToolRegistry::global(cx);
+                    for tool_name in tools {
+                        tool_registry.unregister_tool_by_name(&tool_name);
+                        context_server_registry.unregister_tool(&server_id, &tool_name);
+                    }
+                }
+            }
+        },
+    )
+    .detach();
+}
+
 fn init_language_model_settings(cx: &mut AppContext) {
    update_active_language_model_from_settings(cx);

@@ -335,7 +435,6 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
    slash_command_registry
        .register_command(cargo_workspace_command::CargoWorkspaceSlashCommand, true);
    slash_command_registry.register_command(prompt_command::PromptSlashCommand, true);
-    slash_command_registry.register_command(selection_command::SelectionCommand, true);
    slash_command_registry.register_command(default_command::DefaultSlashCommand, false);
    slash_command_registry.register_command(terminal_command::TerminalSlashCommand, true);
    slash_command_registry.register_command(now_command::NowSlashCommand, false);
@@ -369,19 +468,6 @@ fn register_slash_commands(prompt_builder: Option<Arc<PromptBuilder>>, cx: &mut
    })
    .detach();

-    cx.observe_flag::<streaming_example_command::StreamingExampleSlashCommandFeatureFlag, _>({
-        let slash_command_registry = slash_command_registry.clone();
-        move |is_enabled, _cx| {
-            if is_enabled {
-                slash_command_registry.register_command(
-                    streaming_example_command::StreamingExampleSlashCommand,
-                    false,
-                );
-            }
-        }
-    })
-    .detach();
-
    update_slash_commands_from_settings(cx);
    cx.observe_global::<SettingsStore>(update_slash_commands_from_settings)
        .detach();
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -410,7 +410,7 @@ pub struct AssistantSettingsContentV2 {
    ///
    /// Default: 320
    default_height: Option<f32>,
-    /// The default model to use when creating new chats.
+    /// The default model to use when creating new contexts.
    default_model: Option<LanguageModelSelection>,
    /// Additional models with which to generate alternatives when performing inline assists.
    inline_alternatives: Option<Vec<LanguageModelSelection>>,
@@ -498,11 +498,11 @@ pub struct LegacyAssistantSettingsContent {
    ///
    /// Default: 320
    pub default_height: Option<f32>,
-    /// The default OpenAI model to use when creating new chats.
+    /// The default OpenAI model to use when creating new contexts.
    ///
    /// Default: gpt-4-1106-preview
    pub default_open_ai_model: Option<OpenAiModel>,
-    /// OpenAI API base URL to use when creating new chats.
+    /// OpenAI API base URL to use when creating new contexts.
    ///
    /// Default: https://api.openai.com/v1
    pub openai_api_url: Option<String>,
--- a/crates/assistant/src/context.rs
+++ b/crates/assistant/src/context.rs
--- a/crates/assistant/src/context/context_tests.rs
+++ b/crates/assistant/src/context/context_tests.rs
@@ -1,22 +1,15 @@
 use super::{AssistantEdit, MessageCacheMetadata};
-use crate::slash_command_working_set::SlashCommandWorkingSet;
-use crate::ToolWorkingSet;
 use crate::{
    assistant_panel, prompt_library, slash_command::file_command, AssistantEditKind, CacheStatus,
-    Context, ContextEvent, ContextId, ContextOperation, InvokedSlashCommandId, MessageId,
-    MessageStatus, PromptBuilder,
+    Context, ContextEvent, ContextId, ContextOperation, MessageId, MessageStatus, PromptBuilder,
 };
 use anyhow::Result;
 use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent, SlashCommandOutput,
-    SlashCommandOutputSection, SlashCommandRegistry, SlashCommandResult,
+    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
+    SlashCommandRegistry, SlashCommandResult,
 };
-use collections::{HashMap, HashSet};
+use collections::HashSet;
 use fs::FakeFs;
-use futures::{
-    channel::mpsc,
-    stream::{self, StreamExt},
-};
 use gpui::{AppContext, Model, SharedString, Task, TestAppContext, WeakView};
 use language::{Buffer, BufferSnapshot, LanguageRegistry, LspAdapterDelegate};
 use language_model::{LanguageModelCacheConfiguration, LanguageModelRegistry, Role};
@@ -34,8 +27,8 @@ use std::{
    rc::Rc,
    sync::{atomic::AtomicBool, Arc},
 };
-use text::{network::Network, OffsetRangeExt as _, ReplicaId, ToOffset};
-use ui::{Context as _, IconName, WindowContext};
+use text::{network::Network, OffsetRangeExt as _, ReplicaId};
+use ui::{Context as _, WindowContext};
 use unindent::Unindent;
 use util::{
    test::{generate_marked_text, marked_text_ranges},
@@ -51,17 +44,8 @@ fn test_inserting_and_removing_messages(cx: &mut AppContext) {
    assistant_panel::init(cx);
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry,
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry, None, None, prompt_builder.clone(), cx));
    let buffer = context.read(cx).buffer.clone();

    let message_1 = context.read(cx).message_anchors[0].clone();
@@ -193,17 +177,8 @@ fn test_message_splitting(cx: &mut AppContext) {
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));

    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry.clone(),
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry, None, None, prompt_builder.clone(), cx));
    let buffer = context.read(cx).buffer.clone();

    let message_1 = context.read(cx).message_anchors[0].clone();
@@ -297,17 +272,8 @@ fn test_messages_for_offsets(cx: &mut AppContext) {
    assistant_panel::init(cx);
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry,
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry, None, None, prompt_builder.clone(), cx));
    let buffer = context.read(cx).buffer.clone();

    let message_1 = context.read(cx).message_anchors[0].clone();
@@ -412,53 +378,23 @@ async fn test_slash_commands(cx: &mut TestAppContext) {

    let registry = Arc::new(LanguageRegistry::test(cx.executor()));
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry.clone(),
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry.clone(), None, None, prompt_builder.clone(), cx));

-    #[derive(Default)]
-    struct ContextRanges {
-        parsed_commands: HashSet<Range<language::Anchor>>,
-        command_outputs: HashMap<InvokedSlashCommandId, Range<language::Anchor>>,
-        output_sections: HashSet<Range<language::Anchor>>,
-    }
-
-    let context_ranges = Rc::new(RefCell::new(ContextRanges::default()));
+    let output_ranges = Rc::new(RefCell::new(HashSet::default()));
    context.update(cx, |_, cx| {
        cx.subscribe(&context, {
-            let context_ranges = context_ranges.clone();
-            move |context, _, event, _| {
-                let mut context_ranges = context_ranges.borrow_mut();
-                match event {
-                    ContextEvent::InvokedSlashCommandChanged { command_id } => {
-                        let command = context.invoked_slash_command(command_id).unwrap();
-                        context_ranges
-                            .command_outputs
-                            .insert(*command_id, command.range.clone());
+            let ranges = output_ranges.clone();
+            move |_, _, event, _| match event {
+                ContextEvent::PendingSlashCommandsUpdated { removed, updated } => {
+                    for range in removed {
+                        ranges.borrow_mut().remove(range);
                    }
-                    ContextEvent::ParsedSlashCommandsUpdated { removed, updated } => {
-                        for range in removed {
-                            context_ranges.parsed_commands.remove(range);
-                        }
-                        for command in updated {
-                            context_ranges
-                                .parsed_commands
-                                .insert(command.source_range.clone());
-                        }
+                    for command in updated {
+                        ranges.borrow_mut().insert(command.source_range.clone());
                    }
-                    ContextEvent::SlashCommandOutputSectionAdded { section } => {
-                        context_ranges.output_sections.insert(section.range.clone());
-                    }
-                    _ => {}
                }
+                _ => {}
            }
        })
        .detach();
@@ -470,12 +406,14 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
    buffer.update(cx, |buffer, cx| {
        buffer.edit([(0..0, "/file src/lib.rs")], None, cx);
    });
-    assert_text_and_context_ranges(
+    assert_text_and_output_ranges(
        &buffer,
-        &context_ranges,
-        &"
-        «/file src/lib.rs»"
-            .unindent(),
+        &output_ranges.borrow(),
+        "
+        «/file src/lib.rs»
+        "
+        .unindent()
+        .trim_end(),
        cx,
    );

@@ -484,12 +422,14 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
        let edit_offset = buffer.text().find("lib.rs").unwrap();
        buffer.edit([(edit_offset..edit_offset + "lib".len(), "main")], None, cx);
    });
-    assert_text_and_context_ranges(
+    assert_text_and_output_ranges(
        &buffer,
-        &context_ranges,
-        &"
-        «/file src/main.rs»"
-            .unindent(),
+        &output_ranges.borrow(),
+        "
+        «/file src/main.rs»
+        "
+        .unindent()
+        .trim_end(),
        cx,
    );

@@ -502,180 +442,36 @@ async fn test_slash_commands(cx: &mut TestAppContext) {
            cx,
        );
    });
-    assert_text_and_context_ranges(
+    assert_text_and_output_ranges(
        &buffer,
-        &context_ranges,
-        &"
-        /unknown src/main.rs"
-            .unindent(),
-        cx,
-    );
-
-    // Undoing the insertion of an non-existent slash command resorts the previous one.
-    buffer.update(cx, |buffer, cx| buffer.undo(cx));
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        «/file src/main.rs»"
-            .unindent(),
-        cx,
-    );
-
-    let (command_output_tx, command_output_rx) = mpsc::unbounded();
-    context.update(cx, |context, cx| {
-        let command_source_range = context.parsed_slash_commands[0].source_range.clone();
-        context.insert_command_output(
-            command_source_range,
-            "file",
-            Task::ready(Ok(command_output_rx.boxed())),
-            true,
-            cx,
-        );
-    });
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        ⟦«/file src/main.rs»
-        …⟧
+        &output_ranges.borrow(),
        "
-        .unindent(),
-        cx,
-    );
-
-    command_output_tx
-        .unbounded_send(Ok(SlashCommandEvent::StartSection {
-            icon: IconName::Ai,
-            label: "src/main.rs".into(),
-            metadata: None,
-        }))
-        .unwrap();
-    command_output_tx
-        .unbounded_send(Ok(SlashCommandEvent::Content("src/main.rs".into())))
-        .unwrap();
-    cx.run_until_parked();
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        ⟦«/file src/main.rs»
-        src/main.rs…⟧
+        /unknown src/main.rs
        "
-        .unindent(),
-        cx,
-    );
-
-    command_output_tx
-        .unbounded_send(Ok(SlashCommandEvent::Content("\nfn main() {}".into())))
-        .unwrap();
-    cx.run_until_parked();
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        ⟦«/file src/main.rs»
-        src/main.rs
-        fn main() {}…⟧
-        "
-        .unindent(),
-        cx,
-    );
-
-    command_output_tx
-        .unbounded_send(Ok(SlashCommandEvent::EndSection))
-        .unwrap();
-    cx.run_until_parked();
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        ⟦«/file src/main.rs»
-        ⟪src/main.rs
-        fn main() {}⟫…⟧
-        "
-        .unindent(),
-        cx,
-    );
-
-    drop(command_output_tx);
-    cx.run_until_parked();
-    assert_text_and_context_ranges(
-        &buffer,
-        &context_ranges,
-        &"
-        ⟦⟪src/main.rs
-        fn main() {}⟫⟧
-        "
-        .unindent(),
+        .unindent()
+        .trim_end(),
        cx,
    );

    #[track_caller]
-    fn assert_text_and_context_ranges(
+    fn assert_text_and_output_ranges(
        buffer: &Model<Buffer>,
-        ranges: &RefCell<ContextRanges>,
+        ranges: &HashSet<Range<language::Anchor>>,
        expected_marked_text: &str,
        cx: &mut TestAppContext,
    ) {
-        let mut actual_marked_text = String::new();
-        buffer.update(cx, |buffer, _| {
-            struct Endpoint {
-                offset: usize,
-                marker: char,
-            }
-
-            let ranges = ranges.borrow();
-            let mut endpoints = Vec::new();
-            for range in ranges.command_outputs.values() {
-                endpoints.push(Endpoint {
-                    offset: range.start.to_offset(buffer),
-                    marker: '⟦',
-                });
-            }
-            for range in ranges.parsed_commands.iter() {
-                endpoints.push(Endpoint {
-                    offset: range.start.to_offset(buffer),
-                    marker: '«',
-                });
-            }
-            for range in ranges.output_sections.iter() {
-                endpoints.push(Endpoint {
-                    offset: range.start.to_offset(buffer),
-                    marker: '⟪',
-                });
-            }
-
-            for range in ranges.output_sections.iter() {
-                endpoints.push(Endpoint {
-                    offset: range.end.to_offset(buffer),
-                    marker: '⟫',
-                });
-            }
-            for range in ranges.parsed_commands.iter() {
-                endpoints.push(Endpoint {
-                    offset: range.end.to_offset(buffer),
-                    marker: '»',
-                });
-            }
-            for range in ranges.command_outputs.values() {
-                endpoints.push(Endpoint {
-                    offset: range.end.to_offset(buffer),
-                    marker: '⟧',
-                });
-            }
-
-            endpoints.sort_by_key(|endpoint| endpoint.offset);
-            let mut offset = 0;
-            for endpoint in endpoints {
-                actual_marked_text.extend(buffer.text_for_range(offset..endpoint.offset));
-                actual_marked_text.push(endpoint.marker);
-                offset = endpoint.offset;
-            }
-            actual_marked_text.extend(buffer.text_for_range(offset..buffer.len()));
+        let (expected_text, expected_ranges) = marked_text_ranges(expected_marked_text, false);
+        let (actual_text, actual_ranges) = buffer.update(cx, |buffer, _| {
+            let mut ranges = ranges
+                .iter()
+                .map(|range| range.to_offset(buffer))
+                .collect::<Vec<_>>();
+            ranges.sort_by_key(|a| a.start);
+            (buffer.text(), ranges)
        });

-        assert_eq!(actual_marked_text, expected_marked_text);
+        assert_eq!(actual_text, expected_text);
+        assert_eq!(actual_ranges, expected_ranges);
    }
 }

@@ -709,8 +505,6 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            Some(project),
            None,
            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
            cx,
        )
    });
@@ -974,8 +768,6 @@ async fn test_workflow_step_parsing(cx: &mut TestAppContext) {
            Default::default(),
            registry.clone(),
            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
            None,
            None,
            cx,
@@ -1084,17 +876,8 @@ async fn test_serialization(cx: &mut TestAppContext) {
    cx.update(assistant_panel::init);
    let registry = Arc::new(LanguageRegistry::test(cx.executor()));
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry.clone(),
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry.clone(), None, None, prompt_builder.clone(), cx));
    let buffer = context.read_with(cx, |context, _| context.buffer.clone());
    let message_0 = context.read_with(cx, |context, _| context.message_anchors[0].id);
    let message_1 = context.update(cx, |context, cx| {
@@ -1134,8 +917,6 @@ async fn test_serialization(cx: &mut TestAppContext) {
            Default::default(),
            registry.clone(),
            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
            None,
            None,
            cx,
@@ -1194,8 +975,6 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                language::Capability::ReadWrite,
                registry.clone(),
                prompt_builder.clone(),
-                Arc::new(SlashCommandWorkingSet::default()),
-                Arc::new(ToolWorkingSet::default()),
                None,
                None,
                cx,
@@ -1284,57 +1063,44 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
                        offset + 1..offset + 1 + command_text.len()
                    });

+                    let output_len = rng.gen_range(1..=10);
                    let output_text = RandomCharIter::new(&mut rng)
                        .filter(|c| *c != '\r')
-                        .take(10)
+                        .take(output_len)
                        .collect::<String>();

-                    let mut events = vec![Ok(SlashCommandEvent::StartMessage {
-                        role: Role::User,
-                        merge_same_roles: true,
-                    })];
-
                    let num_sections = rng.gen_range(0..=3);
-                    let mut section_start = 0;
+                    let mut sections = Vec::with_capacity(num_sections);
                    for _ in 0..num_sections {
-                        let mut section_end = rng.gen_range(section_start..=output_text.len());
-                        while !output_text.is_char_boundary(section_end) {
-                            section_end += 1;
-                        }
-                        events.push(Ok(SlashCommandEvent::StartSection {
-                            icon: IconName::Ai,
+                        let section_start = rng.gen_range(0..output_len);
+                        let section_end = rng.gen_range(section_start..=output_len);
+                        sections.push(SlashCommandOutputSection {
+                            range: section_start..section_end,
+                            icon: ui::IconName::Ai,
                            label: "section".into(),
                            metadata: None,
-                        }));
-                        events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                            text: output_text[section_start..section_end].to_string(),
-                            run_commands_in_text: false,
-                        })));
-                        events.push(Ok(SlashCommandEvent::EndSection));
-                        section_start = section_end;
-                    }
-
-                    if section_start < output_text.len() {
-                        events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                            text: output_text[section_start..].to_string(),
-                            run_commands_in_text: false,
-                        })));
+                        });
                    }

                    log::info!(
-                        "Context {}: insert slash command output at {:?} with {:?} events",
+                        "Context {}: insert slash command output at {:?} with {:?}",
                        context_index,
                        command_range,
-                        events.len()
+                        sections
                    );

                    let command_range = context.buffer.read(cx).anchor_after(command_range.start)
                        ..context.buffer.read(cx).anchor_after(command_range.end);
                    context.insert_command_output(
                        command_range,
-                        "/command",
-                        Task::ready(Ok(stream::iter(events).boxed())),
+                        Task::ready(Ok(SlashCommandOutput {
+                            text: output_text,
+                            sections,
+                            run_commands_in_text: false,
+                        }
+                        .to_event_stream())),
                        true,
+                        false,
                        cx,
                    );
                });
@@ -1412,7 +1178,7 @@ async fn test_random_context_collaboration(cx: &mut TestAppContext, mut rng: Std
        let first_context = contexts[0].read(cx);
        for context in &contexts[1..] {
            let context = context.read(cx);
-            assert!(context.pending_ops.is_empty(), "pending ops: {:?}", context.pending_ops);
+            assert!(context.pending_ops.is_empty());
            assert_eq!(
                context.buffer.read(cx).text(),
                first_context.buffer.read(cx).text(),
@@ -1449,17 +1215,8 @@ fn test_mark_cache_anchors(cx: &mut AppContext) {
    assistant_panel::init(cx);
    let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
-    let context = cx.new_model(|cx| {
-        Context::local(
-            registry,
-            None,
-            None,
-            prompt_builder.clone(),
-            Arc::new(SlashCommandWorkingSet::default()),
-            Arc::new(ToolWorkingSet::default()),
-            cx,
-        )
-    });
+    let context =
+        cx.new_model(|cx| Context::local(registry, None, None, prompt_builder.clone(), cx));
    let buffer = context.read(cx).buffer.clone();

    // Create a test cache configuration
--- a/crates/assistant/src/context_store.rs
+++ b/crates/assistant/src/context_store.rs
@@ -1,16 +1,10 @@
-use crate::slash_command::context_server_command;
 use crate::{
-    prompts::PromptBuilder, slash_command_working_set::SlashCommandWorkingSet, Context,
-    ContextEvent, ContextId, ContextOperation, ContextVersion, SavedContext, SavedContextMetadata,
+    prompts::PromptBuilder, Context, ContextEvent, ContextId, ContextOperation, ContextVersion,
+    SavedContext, SavedContextMetadata,
 };
-use crate::{tools, SlashCommandId, ToolId, ToolWorkingSet};
 use anyhow::{anyhow, Context as _, Result};
 use client::{proto, telemetry::Telemetry, Client, TypedEnvelope};
 use clock::ReplicaId;
-use collections::HashMap;
-use command_palette_hooks::CommandPaletteFilter;
-use context_servers::manager::{ContextServerManager, ContextServerSettings};
-use context_servers::{ContextServerFactoryRegistry, CONTEXT_SERVERS_NAMESPACE};
 use fs::Fs;
 use futures::StreamExt;
 use fuzzy::StringMatchCandidate;
@@ -22,7 +16,6 @@ use paths::contexts_dir;
 use project::Project;
 use regex::Regex;
 use rpc::AnyProtoClient;
-use settings::{Settings as _, SettingsStore};
 use std::{
    cmp::Reverse,
    ffi::OsStr,
@@ -50,14 +43,9 @@ pub struct RemoteContextMetadata {
 pub struct ContextStore {
    contexts: Vec<ContextHandle>,
    contexts_metadata: Vec<SavedContextMetadata>,
-    context_server_manager: Model<ContextServerManager>,
-    context_server_slash_command_ids: HashMap<Arc<str>, Vec<SlashCommandId>>,
-    context_server_tool_ids: HashMap<Arc<str>, Vec<ToolId>>,
    host_contexts: Vec<RemoteContextMetadata>,
    fs: Arc<dyn Fs>,
    languages: Arc<LanguageRegistry>,
-    slash_commands: Arc<SlashCommandWorkingSet>,
-    tools: Arc<ToolWorkingSet>,
    telemetry: Arc<Telemetry>,
    _watch_updates: Task<Option<()>>,
    client: Arc<Client>,
@@ -99,8 +87,6 @@ impl ContextStore {
    pub fn new(
        project: Model<Project>,
        prompt_builder: Arc<PromptBuilder>,
-        slash_commands: Arc<SlashCommandWorkingSet>,
-        tools: Arc<ToolWorkingSet>,
        cx: &mut AppContext,
    ) -> Task<Result<Model<Self>>> {
        let fs = project.read(cx).fs().clone();
@@ -111,18 +97,12 @@ impl ContextStore {
            let (mut events, _) = fs.watch(contexts_dir(), CONTEXT_WATCH_DURATION).await;

            let this = cx.new_model(|cx: &mut ModelContext<Self>| {
-                let context_server_manager = cx.new_model(|_cx| ContextServerManager::new());
                let mut this = Self {
                    contexts: Vec::new(),
                    contexts_metadata: Vec::new(),
-                    context_server_manager,
-                    context_server_slash_command_ids: HashMap::default(),
-                    context_server_tool_ids: HashMap::default(),
                    host_contexts: Vec::new(),
                    fs,
                    languages,
-                    slash_commands,
-                    tools,
                    telemetry,
                    _watch_updates: cx.spawn(|this, mut cx| {
                        async move {
@@ -147,89 +127,15 @@ impl ContextStore {
                };
                this.handle_project_changed(project, cx);
                this.synchronize_contexts(cx);
-                this.register_context_server_handlers(cx);
-
-                // TODO: At the time when we construct the `ContextStore` we may not have yet initialized the extensions.
-                // In order to register the context servers when the extension is loaded, we're periodically looping to
-                // see if there are context servers to register.
-                //
-                // I tried doing this in a subscription on the `ExtensionStore`, but it never seemed to fire.
-                //
-                // We should find a more elegant way to do this.
-                let context_server_factory_registry =
-                    ContextServerFactoryRegistry::default_global(cx);
-                cx.spawn(|context_store, mut cx| async move {
-                    loop {
-                        let mut servers_to_register = Vec::new();
-                        for (_id, factory) in
-                            context_server_factory_registry.context_server_factories()
-                        {
-                            if let Some(server) = factory(&cx).await.log_err() {
-                                servers_to_register.push(server);
-                            }
-                        }
-
-                        let Some(_) = context_store
-                            .update(&mut cx, |this, cx| {
-                                this.context_server_manager.update(cx, |this, cx| {
-                                    for server in servers_to_register {
-                                        this.add_server(server, cx).detach_and_log_err(cx);
-                                    }
-                                })
-                            })
-                            .log_err()
-                        else {
-                            break;
-                        };
-
-                        smol::Timer::after(Duration::from_millis(100)).await;
-                    }
-
-                    anyhow::Ok(())
-                })
-                .detach_and_log_err(cx);
-
                this
            })?;
            this.update(&mut cx, |this, cx| this.reload(cx))?
                .await
                .log_err();
-
-            this.update(&mut cx, |this, cx| {
-                this.watch_context_server_settings(cx);
-            })
-            .log_err();
-
            Ok(this)
        })
    }

-    fn watch_context_server_settings(&self, cx: &mut ModelContext<Self>) {
-        cx.observe_global::<SettingsStore>(move |this, cx| {
-            this.context_server_manager.update(cx, |manager, cx| {
-                let location = this.project.read(cx).worktrees(cx).next().map(|worktree| {
-                    settings::SettingsLocation {
-                        worktree_id: worktree.read(cx).id(),
-                        path: Path::new(""),
-                    }
-                });
-                let settings = ContextServerSettings::get(location, cx);
-
-                manager.maintain_servers(settings, cx);
-
-                let has_any_context_servers = !manager.servers().is_empty();
-                CommandPaletteFilter::update_global(cx, |filter, _cx| {
-                    if has_any_context_servers {
-                        filter.show_namespace(CONTEXT_SERVERS_NAMESPACE);
-                    } else {
-                        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
-                    }
-                });
-            })
-        })
-        .detach();
-    }
-
    async fn handle_advertise_contexts(
        this: Model<Self>,
        envelope: TypedEnvelope<proto::AdvertiseContexts>,
@@ -436,8 +342,6 @@ impl ContextStore {
                Some(self.project.clone()),
                Some(self.telemetry.clone()),
                self.prompt_builder.clone(),
-                self.slash_commands.clone(),
-                self.tools.clone(),
                cx,
            )
        });
@@ -460,8 +364,6 @@ impl ContextStore {
        let project = self.project.clone();
        let telemetry = self.telemetry.clone();
        let prompt_builder = self.prompt_builder.clone();
-        let slash_commands = self.slash_commands.clone();
-        let tools = self.tools.clone();
        let request = self.client.request(proto::CreateContext { project_id });
        cx.spawn(|this, mut cx| async move {
            let response = request.await?;
@@ -474,8 +376,6 @@ impl ContextStore {
                    capability,
                    language_registry,
                    prompt_builder,
-                    slash_commands,
-                    tools,
                    Some(project),
                    Some(telemetry),
                    cx,
@@ -525,8 +425,6 @@ impl ContextStore {
            }
        });
        let prompt_builder = self.prompt_builder.clone();
-        let slash_commands = self.slash_commands.clone();
-        let tools = self.tools.clone();

        cx.spawn(|this, mut cx| async move {
            let saved_context = load.await?;
@@ -536,8 +434,6 @@ impl ContextStore {
                    path.clone(),
                    languages,
                    prompt_builder,
-                    slash_commands,
-                    tools,
                    Some(project),
                    Some(telemetry),
                    cx,
@@ -604,8 +500,6 @@ impl ContextStore {
            context_id: context_id.to_proto(),
        });
        let prompt_builder = self.prompt_builder.clone();
-        let slash_commands = self.slash_commands.clone();
-        let tools = self.tools.clone();
        cx.spawn(|this, mut cx| async move {
            let response = request.await?;
            let context_proto = response.context.context("invalid context")?;
@@ -616,8 +510,6 @@ impl ContextStore {
                    capability,
                    language_registry,
                    prompt_builder,
-                    slash_commands,
-                    tools,
                    Some(project),
                    Some(telemetry),
                    cx,
@@ -853,114 +745,4 @@ impl ContextStore {
            })
        })
    }
-
-    pub fn restart_context_servers(&mut self, cx: &mut ModelContext<Self>) {
-        cx.update_model(
-            &self.context_server_manager,
-            |context_server_manager, cx| {
-                for server in context_server_manager.servers() {
-                    context_server_manager
-                        .restart_server(&server.id(), cx)
-                        .detach_and_log_err(cx);
-                }
-            },
-        );
-    }
-
-    fn register_context_server_handlers(&self, cx: &mut ModelContext<Self>) {
-        cx.subscribe(
-            &self.context_server_manager.clone(),
-            Self::handle_context_server_event,
-        )
-        .detach();
-    }
-
-    fn handle_context_server_event(
-        &mut self,
-        context_server_manager: Model<ContextServerManager>,
-        event: &context_servers::manager::Event,
-        cx: &mut ModelContext<Self>,
-    ) {
-        let slash_command_working_set = self.slash_commands.clone();
-        let tool_working_set = self.tools.clone();
-        match event {
-            context_servers::manager::Event::ServerStarted { server_id } => {
-                if let Some(server) = context_server_manager.read(cx).get_server(server_id) {
-                    let context_server_manager = context_server_manager.clone();
-                    cx.spawn({
-                        let server = server.clone();
-                        let server_id = server_id.clone();
-                        |this, mut cx| async move {
-                            let Some(protocol) = server.client() else {
-                                return;
-                            };
-
-                            if protocol.capable(context_servers::protocol::ServerCapability::Prompts) {
-                                if let Some(prompts) = protocol.list_prompts().await.log_err() {
-                                    let slash_command_ids = prompts
-                                        .into_iter()
-                                        .filter(context_server_command::acceptable_prompt)
-                                        .map(|prompt| {
-                                            log::info!(
-                                                "registering context server command: {:?}",
-                                                prompt.name
-                                            );
-                                            slash_command_working_set.insert(Arc::new(
-                                                context_server_command::ContextServerSlashCommand::new(
-                                                    context_server_manager.clone(),
-                                                    &server,
-                                                    prompt,
-                                                ),
-                                            ))
-                                        })
-                                        .collect::<Vec<_>>();
-
-                                    this.update(&mut cx, |this, _cx| {
-                                        this.context_server_slash_command_ids
-                                            .insert(server_id.clone(), slash_command_ids);
-                                    })
-                                    .log_err();
-                                }
-                            }
-
-                            if protocol.capable(context_servers::protocol::ServerCapability::Tools) {
-                                if let Some(tools) = protocol.list_tools().await.log_err() {
-                                    let tool_ids = tools.tools.into_iter().map(|tool| {
-                                        log::info!("registering context server tool: {:?}", tool.name);
-                                        tool_working_set.insert(
-                                            Arc::new(tools::context_server_tool::ContextServerTool::new(
-                                                context_server_manager.clone(),
-                                                server.id(),
-                                                tool,
-                                            )),
-                                        )
-
-                                    }).collect::<Vec<_>>();
-
-
-                                    this.update(&mut cx, |this, _cx| {
-                                        this.context_server_tool_ids
-                                            .insert(server_id, tool_ids);
-                                    })
-                                    .log_err();
-                                }
-                            }
-                        }
-                    })
-                    .detach();
-                }
-            }
-            context_servers::manager::Event::ServerStopped { server_id } => {
-                if let Some(slash_command_ids) =
-                    self.context_server_slash_command_ids.remove(server_id)
-                {
-                    slash_command_working_set.remove(&slash_command_ids);
-                }
-
-                if let Some(tool_ids) = self.context_server_tool_ids.remove(server_id) {
-                    tool_working_set.remove(&tool_ids);
-                }
-            }
-        }
-    }
 }
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -21,7 +21,9 @@ use fs::Fs;
 use futures::{
    channel::mpsc,
    future::{BoxFuture, LocalBoxFuture},
-    join, SinkExt, Stream, StreamExt,
+    join,
+    stream::{self, BoxStream},
+    SinkExt, Stream, StreamExt,
 };
 use gpui::{
    anchored, deferred, point, AnyElement, AppContext, ClickEvent, EventEmitter, FocusHandle,
@@ -30,8 +32,7 @@ use gpui::{
 };
 use language::{Buffer, IndentKind, Point, Selection, TransactionId};
 use language_model::{
-    logging::report_assistant_event, LanguageModel, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, LanguageModelTextStream, Role,
+    LanguageModel, LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use multi_buffer::MultiBufferRow;
 use parking_lot::Mutex;
@@ -53,9 +54,7 @@ use telemetry_events::{AssistantEvent, AssistantKind, AssistantPhase};
 use terminal_view::terminal_panel::TerminalPanel;
 use text::{OffsetRangeExt, ToPoint as _};
 use theme::ThemeSettings;
-use ui::{
-    prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, KeyBinding, Popover, Tooltip,
-};
+use ui::{prelude::*, text_for_action, CheckboxWithLabel, IconButtonShape, Popover, Tooltip};
 use util::{RangeExt, ResultExt};
 use workspace::{notifications::NotificationId, ItemHandle, Toast, Workspace};

@@ -86,7 +85,7 @@ pub struct InlineAssistant {
    confirmed_assists: HashMap<InlineAssistId, Model<CodegenAlternative>>,
    prompt_history: VecDeque<String>,
    prompt_builder: Arc<PromptBuilder>,
-    telemetry: Arc<Telemetry>,
+    telemetry: Option<Arc<Telemetry>>,
    fs: Arc<dyn Fs>,
 }

@@ -107,7 +106,7 @@ impl InlineAssistant {
            confirmed_assists: HashMap::default(),
            prompt_history: VecDeque::default(),
            prompt_builder,
-            telemetry,
+            telemetry: Some(telemetry),
            fs,
        }
    }
@@ -242,18 +241,19 @@ impl InlineAssistant {
            };
            codegen_ranges.push(start..end);

-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                self.telemetry.report_assistant_event(AssistantEvent {
-                    conversation_id: None,
-                    kind: AssistantKind::Inline,
-                    phase: AssistantPhase::Invoked,
-                    message_id: None,
-                    model: model.telemetry_id(),
-                    model_provider: model.provider_id().to_string(),
-                    response_latency: None,
-                    error_message: None,
-                    language_name: buffer.language().map(|language| language.name().to_proto()),
-                });
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                    telemetry.report_assistant_event(AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        phase: AssistantPhase::Invoked,
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: buffer.language().map(|language| language.name().to_proto()),
+                    });
+                }
            }
        }

@@ -754,6 +754,33 @@ impl InlineAssistant {

    pub fn finish_assist(&mut self, assist_id: InlineAssistId, undo: bool, cx: &mut WindowContext) {
        if let Some(assist) = self.assists.get(&assist_id) {
+            if let Some(telemetry) = self.telemetry.as_ref() {
+                if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
+                    let language_name = assist.editor.upgrade().and_then(|editor| {
+                        let multibuffer = editor.read(cx).buffer().read(cx);
+                        let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
+                        ranges
+                            .first()
+                            .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                            .map(|language| language.name())
+                    });
+                    telemetry.report_assistant_event(AssistantEvent {
+                        conversation_id: None,
+                        kind: AssistantKind::Inline,
+                        phase: if undo {
+                            AssistantPhase::Rejected
+                        } else {
+                            AssistantPhase::Accepted
+                        },
+                        model: model.telemetry_id(),
+                        model_provider: model.provider_id().to_string(),
+                        response_latency: None,
+                        error_message: None,
+                        language_name: language_name.map(|name| name.to_proto()),
+                    });
+                }
+            }
+
            let assist_group_id = assist.group_id;
            if self.assist_groups[&assist_group_id].linked {
                for assist_id in self.unlink_assist_group(assist_group_id, cx) {
@@ -788,45 +815,12 @@ impl InlineAssistant {
                }
            }

-            let active_alternative = assist.codegen.read(cx).active_alternative().clone();
-            let message_id = active_alternative.read(cx).message_id.clone();
-
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                let language_name = assist.editor.upgrade().and_then(|editor| {
-                    let multibuffer = editor.read(cx).buffer().read(cx);
-                    let ranges = multibuffer.range_to_buffer_ranges(assist.range.clone(), cx);
-                    ranges
-                        .first()
-                        .and_then(|(buffer, _, _)| buffer.read(cx).language())
-                        .map(|language| language.name())
-                });
-                report_assistant_event(
-                    AssistantEvent {
-                        conversation_id: None,
-                        kind: AssistantKind::Inline,
-                        message_id,
-                        phase: if undo {
-                            AssistantPhase::Rejected
-                        } else {
-                            AssistantPhase::Accepted
-                        },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
-                        response_latency: None,
-                        error_message: None,
-                        language_name: language_name.map(|name| name.to_proto()),
-                    },
-                    Some(self.telemetry.clone()),
-                    cx.http_client(),
-                    model.api_key(cx),
-                    cx.background_executor(),
-                );
-            }
-
            if undo {
                assist.codegen.update(cx, |codegen, cx| codegen.undo(cx));
            } else {
-                self.confirmed_assists.insert(assist_id, active_alternative);
+                let confirmed_alternative = assist.codegen.read(cx).active_alternative().clone();
+                self.confirmed_assists
+                    .insert(assist_id, confirmed_alternative);
            }
        }
    }
@@ -1757,20 +1751,6 @@ impl PromptEditor {
    ) {
        match event {
            EditorEvent::Edited { .. } => {
-                if let Some(workspace) = cx.window_handle().downcast::<Workspace>() {
-                    workspace
-                        .update(cx, |workspace, cx| {
-                            let is_via_ssh = workspace
-                                .project()
-                                .update(cx, |project, _| project.is_via_ssh());
-
-                            workspace
-                                .client()
-                                .telemetry()
-                                .log_edit_event("inline assist", is_via_ssh);
-                        })
-                        .log_err();
-                }
                let prompt = self.editor.read(cx).text(cx);
                if self
                    .prompt_history_ix
@@ -1913,58 +1893,21 @@ impl PromptEditor {
        let codegen = self.codegen.read(cx);
        let disabled = matches!(codegen.status(cx), CodegenStatus::Idle);

-        let model_registry = LanguageModelRegistry::read_global(cx);
-        let default_model = model_registry.active_model();
-        let alternative_models = model_registry.inline_alternative_models();
-
-        let get_model_name = |index: usize| -> String {
-            let name = |model: &Arc<dyn LanguageModel>| model.name().0.to_string();
-
-            match index {
-                0 => default_model.as_ref().map_or_else(String::new, name),
-                index if index <= alternative_models.len() => alternative_models
-                    .get(index - 1)
-                    .map_or_else(String::new, name),
-                _ => String::new(),
-            }
-        };
-
-        let total_models = alternative_models.len() + 1;
-
-        if total_models <= 1 {
-            return div().into_any_element();
-        }
-
-        let current_index = codegen.active_alternative;
-        let prev_index = (current_index + total_models - 1) % total_models;
-        let next_index = (current_index + 1) % total_models;
-
-        let prev_model_name = get_model_name(prev_index);
-        let next_model_name = get_model_name(next_index);
-
        h_flex()
            .child(
                IconButton::new("previous", IconName::ChevronLeft)
                    .icon_color(Color::Muted)
-                    .disabled(disabled || current_index == 0)
+                    .disabled(disabled)
                    .shape(IconButtonShape::Square)
                    .tooltip({
                        let focus_handle = self.editor.focus_handle(cx);
                        move |cx| {
-                            cx.new_view(|cx| {
-                                let mut tooltip = Tooltip::new("Previous Alternative").key_binding(
-                                    KeyBinding::for_action_in(
-                                        &CyclePreviousInlineAssist,
-                                        &focus_handle,
-                                        cx,
-                                    ),
-                                );
-                                if !disabled && current_index != 0 {
-                                    tooltip = tooltip.meta(prev_model_name.clone());
-                                }
-                                tooltip
-                            })
-                            .into()
+                            Tooltip::for_action_in(
+                                "Previous Alternative",
+                                &CyclePreviousInlineAssist,
+                                &focus_handle,
+                                cx,
+                            )
                        }
                    })
                    .on_click(cx.listener(|this, _, cx| {
@@ -1988,25 +1931,17 @@ impl PromptEditor {
            .child(
                IconButton::new("next", IconName::ChevronRight)
                    .icon_color(Color::Muted)
-                    .disabled(disabled || current_index == total_models - 1)
+                    .disabled(disabled)
                    .shape(IconButtonShape::Square)
                    .tooltip({
                        let focus_handle = self.editor.focus_handle(cx);
                        move |cx| {
-                            cx.new_view(|cx| {
-                                let mut tooltip = Tooltip::new("Next Alternative").key_binding(
-                                    KeyBinding::for_action_in(
-                                        &CycleNextInlineAssist,
-                                        &focus_handle,
-                                        cx,
-                                    ),
-                                );
-                                if !disabled && current_index != total_models - 1 {
-                                    tooltip = tooltip.meta(next_model_name.clone());
-                                }
-                                tooltip
-                            })
-                            .into()
+                            Tooltip::for_action_in(
+                                "Next Alternative",
+                                &CycleNextInlineAssist,
+                                &focus_handle,
+                                cx,
+                            )
                        }
                    })
                    .on_click(cx.listener(|this, _, cx| {
@@ -2349,7 +2284,7 @@ pub struct Codegen {
    buffer: Model<MultiBuffer>,
    range: Range<Anchor>,
    initial_transaction_id: Option<TransactionId>,
-    telemetry: Arc<Telemetry>,
+    telemetry: Option<Arc<Telemetry>>,
    builder: Arc<PromptBuilder>,
    is_insertion: bool,
 }
@@ -2359,7 +2294,7 @@ impl Codegen {
        buffer: Model<MultiBuffer>,
        range: Range<Anchor>,
        initial_transaction_id: Option<TransactionId>,
-        telemetry: Arc<Telemetry>,
+        telemetry: Option<Arc<Telemetry>>,
        builder: Arc<PromptBuilder>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
@@ -2368,7 +2303,7 @@ impl Codegen {
                buffer.clone(),
                range.clone(),
                false,
-                Some(telemetry.clone()),
+                telemetry.clone(),
                builder.clone(),
                cx,
            )
@@ -2459,7 +2394,7 @@ impl Codegen {
                    self.buffer.clone(),
                    self.range.clone(),
                    false,
-                    Some(self.telemetry.clone()),
+                    self.telemetry.clone(),
                    self.builder.clone(),
                    cx,
                )
@@ -2562,7 +2497,6 @@ pub struct CodegenAlternative {
    line_operations: Vec<LineOperation>,
    request: Option<LanguageModelRequest>,
    elapsed_time: Option<f64>,
-    message_id: Option<String>,
 }

 enum CodegenStatus {
@@ -2621,7 +2555,6 @@ impl CodegenAlternative {
            buffer: buffer.clone(),
            old_buffer,
            edit_position: None,
-            message_id: None,
            snapshot,
            last_equal_ranges: Default::default(),
            transformation_transaction_id: None,
@@ -2726,20 +2659,20 @@ impl CodegenAlternative {

        self.edit_position = Some(self.range.start.bias_right(&self.snapshot));

-        let api_key = model.api_key(cx);
        let telemetry_id = model.telemetry_id();
        let provider_id = model.provider_id();
-        let stream: LocalBoxFuture<Result<LanguageModelTextStream>> =
+        let chunks: LocalBoxFuture<Result<BoxStream<Result<String>>>> =
            if user_prompt.trim().to_lowercase() == "delete" {
-                async { Ok(LanguageModelTextStream::default()) }.boxed_local()
+                async { Ok(stream::empty().boxed()) }.boxed_local()
            } else {
                let request = self.build_request(user_prompt, assistant_panel_context, cx)?;
                self.request = Some(request.clone());

-                cx.spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await })
-                    .boxed_local()
+                let chunks = cx
+                    .spawn(|_, cx| async move { model.stream_completion_text(request, &cx).await });
+                async move { Ok(chunks.await?.boxed()) }.boxed_local()
            };
-        self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
+        self.handle_stream(telemetry_id, provider_id.to_string(), chunks, cx);
        Ok(())
    }

@@ -2804,8 +2737,7 @@ impl CodegenAlternative {
        &mut self,
        model_telemetry_id: String,
        model_provider_id: String,
-        model_api_key: Option<String>,
-        stream: impl 'static + Future<Output = Result<LanguageModelTextStream>>,
+        stream: impl 'static + Future<Output = Result<BoxStream<'static, Result<String>>>>,
        cx: &mut ModelContext<Self>,
    ) {
        let start_time = Instant::now();
@@ -2835,7 +2767,6 @@ impl CodegenAlternative {
            }
        }

-        let http_client = cx.http_client().clone();
        let telemetry = self.telemetry.clone();
        let language_name = {
            let multibuffer = self.buffer.read(cx);
@@ -2851,21 +2782,15 @@ impl CodegenAlternative {
        let mut edit_start = self.range.start.to_offset(&snapshot);
        self.generation = cx.spawn(|codegen, mut cx| {
            async move {
-                let stream = stream.await;
-                let message_id = stream
-                    .as_ref()
-                    .ok()
-                    .and_then(|stream| stream.message_id.clone());
+                let chunks = stream.await;
                let generate = async {
                    let (mut diff_tx, mut diff_rx) = mpsc::channel(1);
-                    let executor = cx.background_executor().clone();
-                    let message_id = message_id.clone();
                    let line_based_stream_diff: Task<anyhow::Result<()>> =
                        cx.background_executor().spawn(async move {
                            let mut response_latency = None;
                            let request_start = Instant::now();
                            let diff = async {
-                                let chunks = StripInvalidSpans::new(stream?.stream);
+                                let chunks = StripInvalidSpans::new(chunks?);
                                futures::pin_mut!(chunks);
                                let mut diff = StreamingDiff::new(selected_text.to_string());
                                let mut line_diff = LineDiff::default();
@@ -2961,10 +2886,9 @@ impl CodegenAlternative {

                            let error_message =
                                result.as_ref().err().map(|error| error.to_string());
-                            report_assistant_event(
-                                AssistantEvent {
+                            if let Some(telemetry) = telemetry {
+                                telemetry.report_assistant_event(AssistantEvent {
                                    conversation_id: None,
-                                    message_id,
                                    kind: AssistantKind::Inline,
                                    phase: AssistantPhase::Response,
                                    model: model_telemetry_id,
@@ -2972,12 +2896,8 @@ impl CodegenAlternative {
                                    response_latency,
                                    error_message,
                                    language_name: language_name.map(|name| name.to_proto()),
-                                },
-                                telemetry,
-                                http_client,
-                                model_api_key,
-                                &executor,
-                            );
+                                });
+                            }

                            result?;
                            Ok(())
@@ -3041,7 +2961,6 @@ impl CodegenAlternative {

                codegen
                    .update(&mut cx, |this, cx| {
-                        this.message_id = message_id;
                        this.last_equal_ranges.clear();
                        if let Err(error) = result {
                            this.status = CodegenStatus::Error(error);
@@ -3593,7 +3512,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        let mut new_text = concat!(
            "       let mut x = 0;\n",
@@ -3657,7 +3584,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        cx.background_executor.run_until_parked();

@@ -3724,7 +3659,15 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });

        cx.background_executor.run_until_parked();

@@ -3790,7 +3733,16 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });
+
        let new_text = concat!(
            "func main() {\n",
            "\tx := 0\n",
@@ -3845,7 +3797,16 @@ mod tests {
            )
        });

-        let chunks_tx = simulate_response_stream(codegen.clone(), cx);
+        let (chunks_tx, chunks_rx) = mpsc::unbounded();
+        codegen.update(cx, |codegen, cx| {
+            codegen.handle_stream(
+                String::new(),
+                String::new(),
+                future::ready(Ok(chunks_rx.map(Ok).boxed())),
+                cx,
+            )
+        });
+
        chunks_tx
            .unbounded_send("let mut x = 0;\nx += 1;".to_string())
            .unwrap();
@@ -3919,26 +3880,6 @@ mod tests {
        }
    }

-    fn simulate_response_stream(
-        codegen: Model<CodegenAlternative>,
-        cx: &mut TestAppContext,
-    ) -> mpsc::UnboundedSender<String> {
-        let (chunks_tx, chunks_rx) = mpsc::unbounded();
-        codegen.update(cx, |codegen, cx| {
-            codegen.handle_stream(
-                String::new(),
-                String::new(),
-                None,
-                future::ready(Ok(LanguageModelTextStream {
-                    message_id: None,
-                    stream: chunks_rx.map(Ok).boxed(),
-                })),
-                cx,
-            );
-        });
-        chunks_tx
-    }
-
    fn rust_lang() -> Language {
        Language::new(
            LanguageConfig {
--- a/crates/assistant/src/model_selector.rs
+++ b/crates/assistant/src/model_selector.rs
@@ -1,17 +1,21 @@
 use feature_flags::ZedPro;
+use gpui::Action;
+use gpui::DismissEvent;

 use language_model::{LanguageModel, LanguageModelAvailability, LanguageModelRegistry};
 use proto::Plan;
 use workspace::ShowConfiguration;

 use std::sync::Arc;
+use ui::ListItemSpacing;

 use crate::assistant_settings::AssistantSettings;
 use fs::Fs;
-use gpui::{Action, AnyElement, DismissEvent, SharedString, Task};
+use gpui::SharedString;
+use gpui::Task;
 use picker::{Picker, PickerDelegate};
 use settings::update_settings_file;
-use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverMenuHandle, PopoverTrigger};
+use ui::{prelude::*, ListItem, PopoverMenu, PopoverMenuHandle, PopoverTrigger};

 const TRY_ZED_PRO_URL: &str = "https://zed.dev/pro";

@@ -81,36 +85,14 @@ impl PickerDelegate for ModelPickerDelegate {

    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
        let all_models = self.all_models.clone();
-
-        let llm_registry = LanguageModelRegistry::global(cx);
-
-        let configured_models: Vec<_> = llm_registry
-            .read(cx)
-            .providers()
-            .iter()
-            .filter(|provider| provider.is_authenticated(cx))
-            .map(|provider| provider.id())
-            .collect();
-
        cx.spawn(|this, mut cx| async move {
            let filtered_models = cx
                .background_executor()
                .spawn(async move {
-                    let displayed_models = if configured_models.is_empty() {
-                        all_models
-                    } else {
-                        all_models
-                            .into_iter()
-                            .filter(|model_info| {
-                                configured_models.contains(&model_info.model.provider_id())
-                            })
-                            .collect::<Vec<_>>()
-                    };
-
                    if query.is_empty() {
-                        displayed_models
+                        all_models
                    } else {
-                        displayed_models
+                        all_models
                            .into_iter()
                            .filter(|model_info| {
                                model_info
@@ -159,29 +141,6 @@ impl PickerDelegate for ModelPickerDelegate {

    fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}

-    fn render_header(&self, cx: &mut ViewContext<Picker<Self>>) -> Option<AnyElement> {
-        let configured_models_count = LanguageModelRegistry::global(cx)
-            .read(cx)
-            .providers()
-            .iter()
-            .filter(|provider| provider.is_authenticated(cx))
-            .count();
-
-        if configured_models_count > 0 {
-            Some(
-                Label::new("Configured Models")
-                    .size(LabelSize::Small)
-                    .color(Color::Muted)
-                    .mt_1()
-                    .mb_0p5()
-                    .ml_3()
-                    .into_any_element(),
-            )
-        } else {
-            None
-        }
-    }
-
    fn render_match(
        &self,
        ix: usize,
@@ -189,10 +148,9 @@ impl PickerDelegate for ModelPickerDelegate {
        cx: &mut ViewContext<Picker<Self>>,
    ) -> Option<Self::ListItem> {
        use feature_flags::FeatureFlagAppExt;
-        let show_badges = cx.has_flag::<ZedPro>();
-
        let model_info = self.filtered_models.get(ix)?;
-        let provider_name: String = model_info.model.provider_name().0.clone().into();
+        let show_badges = cx.has_flag::<ZedPro>();
+        let provider_name: String = model_info.model.provider_name().0.into();

        Some(
            ListItem::new(ix)
@@ -207,32 +165,27 @@ impl PickerDelegate for ModelPickerDelegate {
                    ),
                )
                .child(
-                    h_flex()
-                        .w_full()
-                        .items_center()
-                        .gap_1p5()
-                        .min_w(px(200.))
-                        .child(Label::new(model_info.model.name().0.clone()))
-                        .child(
-                            h_flex()
-                                .gap_0p5()
-                                .child(
-                                    Label::new(provider_name)
-                                        .size(LabelSize::XSmall)
-                                        .color(Color::Muted),
-                                )
-                                .children(match model_info.availability {
-                                    LanguageModelAvailability::Public => None,
-                                    LanguageModelAvailability::RequiresPlan(Plan::Free) => None,
-                                    LanguageModelAvailability::RequiresPlan(Plan::ZedPro) => {
-                                        show_badges.then(|| {
-                                            Label::new("Pro")
-                                                .size(LabelSize::XSmall)
-                                                .color(Color::Muted)
-                                        })
-                                    }
-                                }),
-                        ),
+                    h_flex().w_full().justify_between().min_w(px(200.)).child(
+                        h_flex()
+                            .gap_1p5()
+                            .child(Label::new(model_info.model.name().0.clone()))
+                            .child(
+                                Label::new(provider_name)
+                                    .size(LabelSize::XSmall)
+                                    .color(Color::Muted),
+                            )
+                            .children(match model_info.availability {
+                                LanguageModelAvailability::Public => None,
+                                LanguageModelAvailability::RequiresPlan(Plan::Free) => None,
+                                LanguageModelAvailability::RequiresPlan(Plan::ZedPro) => {
+                                    show_badges.then(|| {
+                                        Label::new("Pro")
+                                            .size(LabelSize::XSmall)
+                                            .color(Color::Muted)
+                                    })
+                                }
+                            }),
+                    ),
                )
                .end_slot(div().when(model_info.is_selected, |this| {
                    this.child(
@@ -260,7 +213,7 @@ impl PickerDelegate for ModelPickerDelegate {
                .justify_between()
                .when(cx.has_flag::<ZedPro>(), |this| {
                    this.child(match plan {
-                        // Already a Zed Pro subscriber
+                        // Already a zed pro subscriber
                        Plan::ZedPro => Button::new("zed-pro", "Zed Pro")
                            .icon(IconName::ZedAssistant)
                            .icon_size(IconSize::Small)
@@ -301,7 +254,6 @@ impl<T: PopoverTrigger> RenderOnce for ModelSelector<T> {
        let selected_provider = LanguageModelRegistry::read_global(cx)
            .active_provider()
            .map(|m| m.id());
-
        let selected_model = LanguageModelRegistry::read_global(cx)
            .active_model()
            .map(|m| m.id());
--- a/crates/assistant/src/prompt_library.rs
+++ b/crates/assistant/src/prompt_library.rs
@@ -1,4 +1,3 @@
-use crate::SlashCommandWorkingSet;
 use crate::{slash_command::SlashCommandCompletionProvider, AssistantPanel, InlineAssistant};
 use anyhow::{anyhow, Result};
 use chrono::{DateTime, Utc};
@@ -523,11 +522,7 @@ impl PromptLibrary {
                            editor.set_use_modal_editing(false);
                            editor.set_current_line_highlight(Some(CurrentLineHighlight::None));
                            editor.set_completion_provider(Some(Box::new(
-                                SlashCommandCompletionProvider::new(
-                                    Arc::new(SlashCommandWorkingSet::default()),
-                                    None,
-                                    None,
-                                ),
+                                SlashCommandCompletionProvider::new(None, None),
                            )));
                            if focus {
                                editor.focus(cx);
--- a/crates/assistant/src/prompts.rs
+++ b/crates/assistant/src/prompts.rs
@@ -310,7 +310,7 @@ impl PromptBuilder {
            .render("terminal_assistant_prompt", &context)
    }

-    pub fn generate_suggest_edits_prompt(&self) -> Result<String, RenderError> {
+    pub fn generate_workflow_prompt(&self) -> Result<String, RenderError> {
        self.handlebars.lock().render("suggest_edits", &())
    }

--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -1,5 +1,4 @@
 use crate::assistant_panel::ContextEditor;
-use crate::SlashCommandWorkingSet;
 use anyhow::Result;
 use assistant_slash_command::AfterCompletion;
 pub use assistant_slash_command::{SlashCommand, SlashCommandOutput, SlashCommandRegistry};
@@ -32,15 +31,12 @@ pub mod now_command;
 pub mod project_command;
 pub mod prompt_command;
 pub mod search_command;
-pub mod selection_command;
-pub mod streaming_example_command;
 pub mod symbols_command;
 pub mod tab_command;
 pub mod terminal_command;

 pub(crate) struct SlashCommandCompletionProvider {
    cancel_flag: Mutex<Arc<AtomicBool>>,
-    slash_commands: Arc<SlashCommandWorkingSet>,
    editor: Option<WeakView<ContextEditor>>,
    workspace: Option<WeakView<Workspace>>,
 }
@@ -54,13 +50,11 @@ pub(crate) struct SlashCommandLine {

 impl SlashCommandCompletionProvider {
    pub fn new(
-        slash_commands: Arc<SlashCommandWorkingSet>,
        editor: Option<WeakView<ContextEditor>>,
        workspace: Option<WeakView<Workspace>>,
    ) -> Self {
        Self {
            cancel_flag: Mutex::new(Arc::new(AtomicBool::new(false))),
-            slash_commands,
            editor,
            workspace,
        }
@@ -73,9 +67,9 @@ impl SlashCommandCompletionProvider {
        name_range: Range<Anchor>,
        cx: &mut WindowContext,
    ) -> Task<Result<Vec<project::Completion>>> {
-        let slash_commands = self.slash_commands.clone();
-        let candidates = slash_commands
-            .command_names(cx)
+        let commands = SlashCommandRegistry::global(cx);
+        let candidates = commands
+            .command_names()
            .into_iter()
            .enumerate()
            .map(|(ix, def)| StringMatchCandidate {
@@ -102,7 +96,7 @@ impl SlashCommandCompletionProvider {
                matches
                    .into_iter()
                    .filter_map(|mat| {
-                        let command = slash_commands.command(&mat.string, cx)?;
+                        let command = commands.command(&mat.string)?;
                        let mut new_text = mat.string.clone();
                        let requires_argument = command.requires_argument();
                        let accepts_arguments = command.accepts_arguments();
@@ -131,6 +125,7 @@ impl SlashCommandCompletionProvider {
                                                            &command_name,
                                                            &[],
                                                            true,
+                                                            false,
                                                            workspace.clone(),
                                                            cx,
                                                        );
@@ -215,6 +210,7 @@ impl SlashCommandCompletionProvider {
                                                            &command_name,
                                                            &completed_arguments,
                                                            true,
+                                                            false,
                                                            workspace.clone(),
                                                            cx,
                                                        );
--- a/crates/assistant/src/slash_command/context_server_command.rs
+++ b/crates/assistant/src/slash_command/context_server_command.rs
@@ -8,7 +8,7 @@ use context_servers::{
    manager::{ContextServer, ContextServerManager},
    types::Prompt,
 };
-use gpui::{AppContext, Model, Task, WeakView, WindowContext};
+use gpui::{AppContext, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
@@ -19,21 +19,15 @@ use workspace::Workspace;
 use crate::slash_command::create_label_for_command;

 pub struct ContextServerSlashCommand {
-    server_manager: Model<ContextServerManager>,
-    server_id: Arc<str>,
+    server_id: String,
    prompt: Prompt,
 }

 impl ContextServerSlashCommand {
-    pub fn new(
-        server_manager: Model<ContextServerManager>,
-        server: &Arc<dyn ContextServer>,
-        prompt: Prompt,
-    ) -> Self {
+    pub fn new(server: &Arc<ContextServer>, prompt: Prompt) -> Self {
        Self {
-            server_id: server.id(),
+            server_id: server.id.clone(),
            prompt,
-            server_manager,
        }
    }
 }
@@ -80,16 +74,20 @@ impl SlashCommand for ContextServerSlashCommand {
        _workspace: Option<WeakView<Workspace>>,
        cx: &mut WindowContext,
    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        let Ok((arg_name, arg_value)) = completion_argument(&self.prompt, arguments) else {
-            return Task::ready(Err(anyhow!("Failed to complete argument")));
-        };
-
        let server_id = self.server_id.clone();
        let prompt_name = self.prompt.name.clone();
+        let manager = ContextServerManager::global(cx);
+        let manager = manager.read(cx);

-        if let Some(server) = self.server_manager.read(cx).get_server(&server_id) {
+        let (arg_name, arg_val) = match completion_argument(&self.prompt, arguments) {
+            Ok(tp) => tp,
+            Err(e) => {
+                return Task::ready(Err(e));
+            }
+        };
+        if let Some(server) = manager.get_server(&server_id) {
            cx.foreground_executor().spawn(async move {
-                let Some(protocol) = server.client() else {
+                let Some(protocol) = server.client.read().clone() else {
                    return Err(anyhow!("Context server not initialized"));
                };

@@ -102,7 +100,7 @@ impl SlashCommand for ContextServerSlashCommand {
                            },
                        ),
                        arg_name,
-                        arg_value,
+                        arg_val,
                    )
                    .await?;

@@ -140,10 +138,11 @@ impl SlashCommand for ContextServerSlashCommand {
            Err(e) => return Task::ready(Err(e)),
        };

-        let manager = self.server_manager.read(cx);
+        let manager = ContextServerManager::global(cx);
+        let manager = manager.read(cx);
        if let Some(server) = manager.get_server(&server_id) {
            cx.foreground_executor().spawn(async move {
-                let Some(protocol) = server.client() else {
+                let Some(protocol) = server.client.read().clone() else {
                    return Err(anyhow!("Context server not initialized"));
                };
                let result = protocol.run_prompt(&prompt_name, prompt_args).await?;
--- a/crates/assistant/src/slash_command/delta_command.rs
+++ b/crates/assistant/src/slash_command/delta_command.rs
@@ -58,7 +58,6 @@ impl SlashCommand for DeltaSlashCommand {
        let mut paths = HashSet::default();
        let mut file_command_old_outputs = Vec::new();
        let mut file_command_new_outputs = Vec::new();
-
        for section in context_slash_command_output_sections.iter().rev() {
            if let Some(metadata) = section
                .metadata
@@ -85,7 +84,6 @@ impl SlashCommand for DeltaSlashCommand {

        cx.background_executor().spawn(async move {
            let mut output = SlashCommandOutput::default();
-            let mut changes_detected = false;

            let file_command_new_outputs = future::join_all(file_command_new_outputs).await;
            for (old_text, new_output) in file_command_old_outputs
@@ -98,7 +96,6 @@ impl SlashCommand for DeltaSlashCommand {
                        if let Some(file_command_range) = new_output.sections.first() {
                            let new_text = &new_output.text[file_command_range.range.clone()];
                            if old_text.chars().ne(new_text.chars()) {
-                                changes_detected = true;
                                output.sections.extend(new_output.sections.into_iter().map(
                                    |section| SlashCommandOutputSection {
                                        range: output.text.len() + section.range.start
@@ -115,10 +112,6 @@ impl SlashCommand for DeltaSlashCommand {
                }
            }

-            if !changes_detected {
-                return Err(anyhow!("no new changes detected"));
-            }
-
            Ok(output.to_event_stream())
        })
    }
--- a/crates/assistant/src/slash_command/file_command.rs
+++ b/crates/assistant/src/slash_command/file_command.rs
@@ -21,6 +21,8 @@ use ui::prelude::*;
 use util::ResultExt;
 use workspace::Workspace;

+use crate::slash_command::diagnostics_command::collect_buffer_diagnostics;
+
 pub(crate) struct FileSlashCommand;

 impl FileSlashCommand {
@@ -256,7 +258,8 @@ fn collect_files(
                        break;
                    }
                    directory_stack.pop().unwrap();
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
+                    events_tx
+                        .unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
                        SlashCommandContent::Text {
                            text: "\n".into(),
@@ -361,7 +364,7 @@ fn collect_files(
            }

            while let Some(_) = directory_stack.pop() {
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
+                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection { metadata: None }))?;
            }
        }

@@ -540,6 +543,8 @@ pub fn append_buffer_to_output(
    output.text.push('\n');

    let section_ix = output.sections.len();
+    collect_buffer_diagnostics(output, buffer, false);
+
    output.sections.insert(
        section_ix,
        build_entry_output_section(prev_len..output.text.len(), path, false, None),
--- a/crates/assistant/src/slash_command/search_command.rs
+++ b/crates/assistant/src/slash_command/search_command.rs
@@ -21,10 +21,6 @@ pub(crate) struct SearchSlashCommandFeatureFlag;

 impl FeatureFlag for SearchSlashCommandFeatureFlag {
    const NAME: &'static str = "search-slash-command";
-
-    fn enabled_for_staff() -> bool {
-        false
-    }
 }

 pub(crate) struct SearchSlashCommand;
--- a/crates/assistant/src/slash_command/selection_command.rs
+++ b/crates/assistant/src/slash_command/selection_command.rs
@@ -1,98 +0,0 @@
-use crate::assistant_panel::selections_creases;
-use anyhow::{anyhow, Result};
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
-    SlashCommandOutputSection, SlashCommandResult,
-};
-use futures::StreamExt;
-use gpui::{AppContext, Task, WeakView};
-use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate};
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use ui::{IconName, SharedString, WindowContext};
-use workspace::Workspace;
-
-pub(crate) struct SelectionCommand;
-
-impl SlashCommand for SelectionCommand {
-    fn name(&self) -> String {
-        "selection".into()
-    }
-
-    fn label(&self, _cx: &AppContext) -> CodeLabel {
-        CodeLabel::plain(self.name(), None)
-    }
-
-    fn description(&self) -> String {
-        "Insert editor selection".into()
-    }
-
-    fn icon(&self) -> IconName {
-        IconName::Quote
-    }
-
-    fn menu_text(&self) -> String {
-        self.description()
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn accepts_arguments(&self) -> bool {
-        true
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Err(anyhow!("this command does not require argument")))
-    }
-
-    fn run(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
-        let mut events = vec![];
-
-        let Some(creases) = workspace
-            .update(cx, selections_creases)
-            .unwrap_or_else(|e| {
-                events.push(Err(e));
-                None
-            })
-        else {
-            return Task::ready(Err(anyhow!("no active selection")));
-        };
-
-        for (text, title) in creases {
-            events.push(Ok(SlashCommandEvent::StartSection {
-                icon: IconName::TextSnippet,
-                label: SharedString::from(title),
-                metadata: None,
-            }));
-            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                text,
-                run_commands_in_text: false,
-            })));
-            events.push(Ok(SlashCommandEvent::EndSection));
-            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                text: "\n".to_string(),
-                run_commands_in_text: false,
-            })));
-        }
-
-        let result = futures::stream::iter(events).boxed();
-
-        Task::ready(Ok(result))
-    }
-}
--- a/crates/assistant/src/slash_command/streaming_example_command.rs
+++ b/crates/assistant/src/slash_command/streaming_example_command.rs
@@ -1,117 +0,0 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use std::time::Duration;
-
-use anyhow::Result;
-use assistant_slash_command::{
-    ArgumentCompletion, SlashCommand, SlashCommandContent, SlashCommandEvent,
-    SlashCommandOutputSection, SlashCommandResult,
-};
-use feature_flags::FeatureFlag;
-use futures::channel::mpsc;
-use gpui::{Task, WeakView};
-use language::{BufferSnapshot, LspAdapterDelegate};
-use smol::stream::StreamExt;
-use smol::Timer;
-use ui::prelude::*;
-use workspace::Workspace;
-
-pub struct StreamingExampleSlashCommandFeatureFlag;
-
-impl FeatureFlag for StreamingExampleSlashCommandFeatureFlag {
-    const NAME: &'static str = "streaming-example-slash-command";
-}
-
-pub(crate) struct StreamingExampleSlashCommand;
-
-impl SlashCommand for StreamingExampleSlashCommand {
-    fn name(&self) -> String {
-        "streaming-example".into()
-    }
-
-    fn description(&self) -> String {
-        "An example slash command that showcases streaming.".into()
-    }
-
-    fn menu_text(&self) -> String {
-        self.description()
-    }
-
-    fn requires_argument(&self) -> bool {
-        false
-    }
-
-    fn complete_argument(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _cancel: Arc<AtomicBool>,
-        _workspace: Option<WeakView<Workspace>>,
-        _cx: &mut WindowContext,
-    ) -> Task<Result<Vec<ArgumentCompletion>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn run(
-        self: Arc<Self>,
-        _arguments: &[String],
-        _context_slash_command_output_sections: &[SlashCommandOutputSection<language::Anchor>],
-        _context_buffer: BufferSnapshot,
-        _workspace: WeakView<Workspace>,
-        _delegate: Option<Arc<dyn LspAdapterDelegate>>,
-        cx: &mut WindowContext,
-    ) -> Task<SlashCommandResult> {
-        let (events_tx, events_rx) = mpsc::unbounded();
-        cx.background_executor()
-            .spawn(async move {
-                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                    icon: IconName::FileRust,
-                    label: "Section 1".into(),
-                    metadata: None,
-                }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "Hello".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
-
-                Timer::after(Duration::from_secs(1)).await;
-
-                events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                    icon: IconName::FileRust,
-                    label: "Section 2".into(),
-                    metadata: None,
-                }))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                    SlashCommandContent::Text {
-                        text: "World".into(),
-                        run_commands_in_text: false,
-                    },
-                )))?;
-                events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
-
-                for n in 1..=10 {
-                    Timer::after(Duration::from_secs(1)).await;
-
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::StartSection {
-                        icon: IconName::StarFilled,
-                        label: format!("Section {n}").into(),
-                        metadata: None,
-                    }))?;
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::Content(
-                        SlashCommandContent::Text {
-                            text: "lorem ipsum ".repeat(n).trim().into(),
-                            run_commands_in_text: false,
-                        },
-                    )))?;
-                    events_tx.unbounded_send(Ok(SlashCommandEvent::EndSection))?;
-                }
-
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx);
-
-        Task::ready(Ok(events_rx.boxed()))
-    }
-}
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -1,15 +1,17 @@
 use std::sync::Arc;

+use assistant_slash_command::SlashCommandRegistry;
+
 use gpui::{AnyElement, DismissEvent, SharedString, Task, WeakView};
 use picker::{Picker, PickerDelegate, PickerEditorPosition};
-use ui::{prelude::*, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger};
+use ui::{prelude::*, KeyBinding, ListItem, ListItemSpacing, PopoverMenu, PopoverTrigger};

 use crate::assistant_panel::ContextEditor;
-use crate::SlashCommandWorkingSet;
+use crate::QuoteSelection;

 #[derive(IntoElement)]
 pub(super) struct SlashCommandSelector<T: PopoverTrigger> {
-    working_set: Arc<SlashCommandWorkingSet>,
+    registry: Arc<SlashCommandRegistry>,
    active_context_editor: WeakView<ContextEditor>,
    trigger: T,
 }
@@ -30,6 +32,7 @@ enum SlashCommandEntry {
        renderer: fn(&mut WindowContext<'_>) -> AnyElement,
        on_confirm: fn(&mut WindowContext<'_>),
    },
+    QuoteButton,
 }

 impl AsRef<str> for SlashCommandEntry {
@@ -37,6 +40,7 @@ impl AsRef<str> for SlashCommandEntry {
        match self {
            SlashCommandEntry::Info(SlashCommandInfo { name, .. })
            | SlashCommandEntry::Advert { name, .. } => name,
+            SlashCommandEntry::QuoteButton => "Quote Selection",
        }
    }
 }
@@ -50,12 +54,12 @@ pub(crate) struct SlashCommandDelegate {

 impl<T: PopoverTrigger> SlashCommandSelector<T> {
    pub(crate) fn new(
-        working_set: Arc<SlashCommandWorkingSet>,
+        registry: Arc<SlashCommandRegistry>,
        active_context_editor: WeakView<ContextEditor>,
        trigger: T,
    ) -> Self {
        SlashCommandSelector {
-            working_set,
+            registry,
            active_context_editor,
            trigger,
        }
@@ -149,6 +153,9 @@ impl PickerDelegate for SlashCommandDelegate {
                        })
                        .ok();
                }
+                SlashCommandEntry::QuoteButton => {
+                    cx.dispatch_action(Box::new(QuoteSelection));
+                }
                SlashCommandEntry::Advert { on_confirm, .. } => {
                    on_confirm(cx);
                }
@@ -216,6 +223,40 @@ impl PickerDelegate for SlashCommandDelegate {
                            ),
                    ),
            ),
+            SlashCommandEntry::QuoteButton => {
+                let focus = cx.focus_handle();
+                let key_binding = KeyBinding::for_action_in(&QuoteSelection, &focus, cx);
+
+                Some(
+                    ListItem::new(ix)
+                        .inset(true)
+                        .spacing(ListItemSpacing::Dense)
+                        .selected(selected)
+                        .child(
+                            v_flex()
+                                .child(
+                                    h_flex()
+                                        .gap_1p5()
+                                        .child(Icon::new(IconName::Quote).size(IconSize::XSmall))
+                                        .child(
+                                            div().font_buffer(cx).child(
+                                                Label::new("selection").size(LabelSize::Small),
+                                            ),
+                                        ),
+                                )
+                                .child(
+                                    h_flex()
+                                        .gap_1p5()
+                                        .child(
+                                            Label::new("Insert editor selection")
+                                                .color(Color::Muted)
+                                                .size(LabelSize::Small),
+                                        )
+                                        .children(key_binding.map(|kb| kb.render(cx))),
+                                ),
+                        ),
+                )
+            }
            SlashCommandEntry::Advert { renderer, .. } => Some(
                ListItem::new(ix)
                    .inset(true)
@@ -230,11 +271,11 @@ impl PickerDelegate for SlashCommandDelegate {
 impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
        let all_models = self
-            .working_set
-            .featured_command_names(cx)
+            .registry
+            .featured_command_names()
            .into_iter()
            .filter_map(|command_name| {
-                let command = self.working_set.command(&command_name, cx)?;
+                let command = self.registry.command(&command_name)?;
                let menu_text = SharedString::from(Arc::from(command.menu_text()));
                let label = command.label(cx);
                let args = label.filter_range.end.ne(&label.text.len()).then(|| {
@@ -249,44 +290,47 @@ impl<T: PopoverTrigger> RenderOnce for SlashCommandSelector<T> {
                    icon: command.icon(),
                }))
            })
-            .chain([SlashCommandEntry::Advert {
-                name: "create-your-command".into(),
-                renderer: |cx| {
-                    v_flex()
-                        .w_full()
-                        .child(
-                            h_flex()
-                                .w_full()
-                                .font_buffer(cx)
-                                .items_center()
-                                .justify_between()
-                                .child(
-                                    h_flex()
-                                        .items_center()
-                                        .gap_1p5()
-                                        .child(Icon::new(IconName::Plus).size(IconSize::XSmall))
-                                        .child(
-                                            div().font_buffer(cx).child(
-                                                Label::new("create-your-command")
-                                                    .size(LabelSize::Small),
+            .chain([
+                SlashCommandEntry::Advert {
+                    name: "create-your-command".into(),
+                    renderer: |cx| {
+                        v_flex()
+                            .w_full()
+                            .child(
+                                h_flex()
+                                    .w_full()
+                                    .font_buffer(cx)
+                                    .items_center()
+                                    .justify_between()
+                                    .child(
+                                        h_flex()
+                                            .items_center()
+                                            .gap_1p5()
+                                            .child(Icon::new(IconName::Plus).size(IconSize::XSmall))
+                                            .child(
+                                                div().font_buffer(cx).child(
+                                                    Label::new("create-your-command")
+                                                        .size(LabelSize::Small),
+                                                ),
                                            ),
-                                        ),
-                                )
-                                .child(
-                                    Icon::new(IconName::ArrowUpRight)
-                                        .size(IconSize::XSmall)
-                                        .color(Color::Muted),
-                                ),
-                        )
-                        .child(
-                            Label::new("Create your custom command")
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                        )
-                        .into_any_element()
+                                    )
+                                    .child(
+                                        Icon::new(IconName::ArrowUpRight)
+                                            .size(IconSize::XSmall)
+                                            .color(Color::Muted),
+                                    ),
+                            )
+                            .child(
+                                Label::new("Create your custom command")
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                            )
+                            .into_any_element()
+                    },
+                    on_confirm: |cx| cx.open_url("https://zed.dev/docs/extensions/slash-commands"),
                },
-                on_confirm: |cx| cx.open_url("https://zed.dev/docs/extensions/slash-commands"),
-            }])
+                SlashCommandEntry::QuoteButton,
+            ])
            .collect::<Vec<_>>();

        let delegate = SlashCommandDelegate {
--- a/crates/assistant/src/slash_command_working_set.rs
+++ b/crates/assistant/src/slash_command_working_set.rs
@@ -1,79 +0,0 @@
-use assistant_slash_command::{SlashCommand, SlashCommandRegistry};
-use collections::HashMap;
-use gpui::AppContext;
-use parking_lot::Mutex;
-use std::sync::Arc;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
-pub struct SlashCommandId(usize);
-
-/// A working set of slash commands for use in one instance of the Assistant Panel.
-#[derive(Default)]
-pub struct SlashCommandWorkingSet {
-    state: Mutex<WorkingSetState>,
-}
-
-#[derive(Default)]
-struct WorkingSetState {
-    context_server_commands_by_id: HashMap<SlashCommandId, Arc<dyn SlashCommand>>,
-    context_server_commands_by_name: HashMap<Arc<str>, Arc<dyn SlashCommand>>,
-    next_command_id: SlashCommandId,
-}
-
-impl SlashCommandWorkingSet {
-    pub fn command(&self, name: &str, cx: &AppContext) -> Option<Arc<dyn SlashCommand>> {
-        self.state
-            .lock()
-            .context_server_commands_by_name
-            .get(name)
-            .cloned()
-            .or_else(|| SlashCommandRegistry::global(cx).command(name))
-    }
-
-    pub fn command_names(&self, cx: &AppContext) -> Vec<Arc<str>> {
-        let mut command_names = SlashCommandRegistry::global(cx).command_names();
-        command_names.extend(
-            self.state
-                .lock()
-                .context_server_commands_by_name
-                .keys()
-                .cloned(),
-        );
-
-        command_names
-    }
-
-    pub fn featured_command_names(&self, cx: &AppContext) -> Vec<Arc<str>> {
-        SlashCommandRegistry::global(cx).featured_command_names()
-    }
-
-    pub fn insert(&self, command: Arc<dyn SlashCommand>) -> SlashCommandId {
-        let mut state = self.state.lock();
-        let command_id = state.next_command_id;
-        state.next_command_id.0 += 1;
-        state
-            .context_server_commands_by_id
-            .insert(command_id, command.clone());
-        state.slash_commands_changed();
-        command_id
-    }
-
-    pub fn remove(&self, command_ids_to_remove: &[SlashCommandId]) {
-        let mut state = self.state.lock();
-        state
-            .context_server_commands_by_id
-            .retain(|id, _| !command_ids_to_remove.contains(id));
-        state.slash_commands_changed();
-    }
-}
-
-impl WorkingSetState {
-    fn slash_commands_changed(&mut self) {
-        self.context_server_commands_by_name.clear();
-        self.context_server_commands_by_name.extend(
-            self.context_server_commands_by_id
-                .values()
-                .map(|command| (command.name().into(), command.clone())),
-        );
-    }
-}
--- a/crates/assistant/src/streaming_diff.rs
+++ b/crates/assistant/src/streaming_diff.rs
@@ -28,36 +28,13 @@ impl Matrix {
        self.cols = cols;
    }

-    fn swap_columns(&mut self, col1: usize, col2: usize) {
-        if col1 == col2 {
-            return;
-        }
-
-        if col1 >= self.cols {
-            panic!("column out of bounds");
-        }
-
-        if col2 >= self.cols {
-            panic!("column out of bounds");
-        }
-
-        unsafe {
-            let ptr = self.cells.as_mut_ptr();
-            std::ptr::swap_nonoverlapping(
-                ptr.add(col1 * self.rows),
-                ptr.add(col2 * self.rows),
-                self.rows,
-            );
-        }
-    }
-
    fn get(&self, row: usize, col: usize) -> f64 {
        if row >= self.rows {
            panic!("row out of bounds")
        }

        if col >= self.cols {
-            panic!("column out of bounds")
+            panic!("col out of bounds")
        }
        self.cells[col * self.rows + row]
    }
@@ -68,7 +45,7 @@ impl Matrix {
        }

        if col >= self.cols {
-            panic!("column out of bounds")
+            panic!("col out of bounds")
        }

        self.cells[col * self.rows + row] = value;
@@ -129,32 +106,26 @@ impl StreamingDiff {

    pub fn push_new(&mut self, text: &str) -> Vec<CharOperation> {
        self.new.extend(text.chars());
-        self.scores.swap_columns(0, self.scores.cols - 1);
-        self.scores
-            .resize(self.old.len() + 1, self.new.len() - self.new_text_ix + 1);
-        self.equal_runs.retain(|(_i, j), _| *j == self.new_text_ix);
+        self.scores.resize(self.old.len() + 1, self.new.len() + 1);

        for j in self.new_text_ix + 1..=self.new.len() {
-            let relative_j = j - self.new_text_ix;
-
-            self.scores
-                .set(0, relative_j, j as f64 * Self::INSERTION_SCORE);
+            self.scores.set(0, j, j as f64 * Self::INSERTION_SCORE);
            for i in 1..=self.old.len() {
-                let insertion_score = self.scores.get(i, relative_j - 1) + Self::INSERTION_SCORE;
-                let deletion_score = self.scores.get(i - 1, relative_j) + Self::DELETION_SCORE;
+                let insertion_score = self.scores.get(i, j - 1) + Self::INSERTION_SCORE;
+                let deletion_score = self.scores.get(i - 1, j) + Self::DELETION_SCORE;
                let equality_score = if self.old[i - 1] == self.new[j - 1] {
                    let mut equal_run = self.equal_runs.get(&(i - 1, j - 1)).copied().unwrap_or(0);
                    equal_run += 1;
                    self.equal_runs.insert((i, j), equal_run);

                    let exponent = cmp::min(equal_run as i32 / 4, Self::MAX_EQUALITY_EXPONENT);
-                    self.scores.get(i - 1, relative_j - 1) + Self::EQUALITY_BASE.powi(exponent)
+                    self.scores.get(i - 1, j - 1) + Self::EQUALITY_BASE.powi(exponent)
                } else {
                    f64::NEG_INFINITY
                };

                let score = insertion_score.max(deletion_score).max(equality_score);
-                self.scores.set(i, relative_j, score);
+                self.scores.set(i, j, score);
            }
        }

@@ -162,7 +133,7 @@ impl StreamingDiff {
        let mut next_old_text_ix = self.old_text_ix;
        let next_new_text_ix = self.new.len();
        for i in self.old_text_ix..=self.old.len() {
-            let score = self.scores.get(i, next_new_text_ix - self.new_text_ix);
+            let score = self.scores.get(i, next_new_text_ix);
            if score > max_score {
                max_score = score;
                next_old_text_ix = i;
@@ -203,9 +174,7 @@ impl StreamingDiff {

            let (prev_i, prev_j) = [insertion_score, deletion_score, equality_score]
                .iter()
-                .max_by_key(|cell| {
-                    cell.map(|(i, j)| OrderedFloat(self.scores.get(i, j - self.new_text_ix)))
-                })
+                .max_by_key(|cell| cell.map(|(i, j)| OrderedFloat(self.scores.get(i, j))))
                .unwrap()
                .unwrap();

--- a/crates/assistant/src/terminal_inline_assistant.rs
+++ b/crates/assistant/src/terminal_inline_assistant.rs
@@ -17,8 +17,7 @@ use gpui::{
 };
 use language::Buffer;
 use language_model::{
-    logging::report_assistant_event, LanguageModelRegistry, LanguageModelRequest,
-    LanguageModelRequestMessage, Role,
+    LanguageModelRegistry, LanguageModelRequest, LanguageModelRequestMessage, Role,
 };
 use settings::Settings;
 use std::{
@@ -307,33 +306,6 @@ impl TerminalInlineAssistant {
                    this.focus_handle(cx).focus(cx);
                })
                .log_err();
-
-            if let Some(model) = LanguageModelRegistry::read_global(cx).active_model() {
-                let codegen = assist.codegen.read(cx);
-                let executor = cx.background_executor().clone();
-                report_assistant_event(
-                    AssistantEvent {
-                        conversation_id: None,
-                        kind: AssistantKind::InlineTerminal,
-                        message_id: codegen.message_id.clone(),
-                        phase: if undo {
-                            AssistantPhase::Rejected
-                        } else {
-                            AssistantPhase::Accepted
-                        },
-                        model: model.telemetry_id(),
-                        model_provider: model.provider_id().to_string(),
-                        response_latency: None,
-                        error_message: None,
-                        language_name: None,
-                    },
-                    codegen.telemetry.clone(),
-                    cx.http_client(),
-                    model.api_key(cx),
-                    &executor,
-                );
-            }
-
            assist.codegen.update(cx, |codegen, cx| {
                if undo {
                    codegen.undo(cx);
@@ -1044,7 +1016,6 @@ pub struct Codegen {
    telemetry: Option<Arc<Telemetry>>,
    terminal: Model<Terminal>,
    generation: Task<()>,
-    message_id: Option<String>,
    transaction: Option<TerminalTransaction>,
 }

@@ -1055,7 +1026,6 @@ impl Codegen {
            telemetry,
            status: CodegenStatus::Idle,
            generation: Task::ready(()),
-            message_id: None,
            transaction: None,
        }
    }
@@ -1065,8 +1035,6 @@ impl Codegen {
            return;
        };

-        let model_api_key = model.api_key(cx);
-        let http_client = cx.http_client();
        let telemetry = self.telemetry.clone();
        self.status = CodegenStatus::Pending;
        self.transaction = Some(TerminalTransaction::start(self.terminal.clone()));
@@ -1075,61 +1043,43 @@ impl Codegen {
            let model_provider_id = model.provider_id();
            let response = model.stream_completion_text(prompt, &cx).await;
            let generate = async {
-                let message_id = response
-                    .as_ref()
-                    .ok()
-                    .and_then(|response| response.message_id.clone());
-
                let (mut hunks_tx, mut hunks_rx) = mpsc::channel(1);

-                let task = cx.background_executor().spawn({
-                    let message_id = message_id.clone();
-                    let executor = cx.background_executor().clone();
-                    async move {
-                        let mut response_latency = None;
-                        let request_start = Instant::now();
-                        let task = async {
-                            let mut chunks = response?.stream;
-                            while let Some(chunk) = chunks.next().await {
-                                if response_latency.is_none() {
-                                    response_latency = Some(request_start.elapsed());
-                                }
-                                let chunk = chunk?;
-                                hunks_tx.send(chunk).await?;
+                let task = cx.background_executor().spawn(async move {
+                    let mut response_latency = None;
+                    let request_start = Instant::now();
+                    let task = async {
+                        let mut chunks = response?;
+                        while let Some(chunk) = chunks.next().await {
+                            if response_latency.is_none() {
+                                response_latency = Some(request_start.elapsed());
                            }
+                            let chunk = chunk?;
+                            hunks_tx.send(chunk).await?;
+                        }

-                            anyhow::Ok(())
-                        };
-
-                        let result = task.await;
-
-                        let error_message = result.as_ref().err().map(|error| error.to_string());
-                        report_assistant_event(
-                            AssistantEvent {
-                                conversation_id: None,
-                                kind: AssistantKind::InlineTerminal,
-                                message_id,
-                                phase: AssistantPhase::Response,
-                                model: model_telemetry_id,
-                                model_provider: model_provider_id.to_string(),
-                                response_latency,
-                                error_message,
-                                language_name: None,
-                            },
-                            telemetry,
-                            http_client,
-                            model_api_key,
-                            &executor,
-                        );
-
-                        result?;
                        anyhow::Ok(())
-                    }
-                });
+                    };

-                this.update(&mut cx, |this, _| {
-                    this.message_id = message_id;
-                })?;
+                    let result = task.await;
+
+                    let error_message = result.as_ref().err().map(|error| error.to_string());
+                    if let Some(telemetry) = telemetry {
+                        telemetry.report_assistant_event(AssistantEvent {
+                            conversation_id: None,
+                            kind: AssistantKind::Inline,
+                            phase: AssistantPhase::Response,
+                            model: model_telemetry_id,
+                            model_provider: model_provider_id.to_string(),
+                            response_latency,
+                            error_message,
+                            language_name: None,
+                        });
+                    }
+
+                    result?;
+                    anyhow::Ok(())
+                });

                while let Some(hunk) = hunks_rx.next().await {
                    this.update(&mut cx, |this, cx| {
--- a/crates/assistant/src/tool_working_set.rs
+++ b/crates/assistant/src/tool_working_set.rs
@@ -1,75 +0,0 @@
-use assistant_tool::{Tool, ToolRegistry};
-use collections::HashMap;
-use gpui::AppContext;
-use parking_lot::Mutex;
-use std::sync::Arc;
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Default)]
-pub struct ToolId(usize);
-
-/// A working set of tools for use in one instance of the Assistant Panel.
-#[derive(Default)]
-pub struct ToolWorkingSet {
-    state: Mutex<WorkingSetState>,
-}
-
-#[derive(Default)]
-struct WorkingSetState {
-    context_server_tools_by_id: HashMap<ToolId, Arc<dyn Tool>>,
-    context_server_tools_by_name: HashMap<String, Arc<dyn Tool>>,
-    next_tool_id: ToolId,
-}
-
-impl ToolWorkingSet {
-    pub fn tool(&self, name: &str, cx: &AppContext) -> Option<Arc<dyn Tool>> {
-        self.state
-            .lock()
-            .context_server_tools_by_name
-            .get(name)
-            .cloned()
-            .or_else(|| ToolRegistry::global(cx).tool(name))
-    }
-
-    pub fn tools(&self, cx: &AppContext) -> Vec<Arc<dyn Tool>> {
-        let mut tools = ToolRegistry::global(cx).tools();
-        tools.extend(
-            self.state
-                .lock()
-                .context_server_tools_by_id
-                .values()
-                .cloned(),
-        );
-
-        tools
-    }
-
-    pub fn insert(&self, command: Arc<dyn Tool>) -> ToolId {
-        let mut state = self.state.lock();
-        let command_id = state.next_tool_id;
-        state.next_tool_id.0 += 1;
-        state
-            .context_server_tools_by_id
-            .insert(command_id, command.clone());
-        state.tools_changed();
-        command_id
-    }
-
-    pub fn remove(&self, command_ids_to_remove: &[ToolId]) {
-        let mut state = self.state.lock();
-        state
-            .context_server_tools_by_id
-            .retain(|id, _| !command_ids_to_remove.contains(id));
-        state.tools_changed();
-    }
-}
-
-impl WorkingSetState {
-    fn tools_changed(&mut self) {
-        self.context_server_tools_by_name.clear();
-        self.context_server_tools_by_name.extend(
-            self.context_server_tools_by_id
-                .values()
-                .map(|command| (command.name(), command.clone())),
-        );
-    }
-}
--- a/crates/assistant/src/tools/context_server_tool.rs
+++ b/crates/assistant/src/tools/context_server_tool.rs
@@ -1,25 +1,17 @@
-use std::sync::Arc;
-
 use anyhow::{anyhow, bail};
 use assistant_tool::Tool;
 use context_servers::manager::ContextServerManager;
 use context_servers::types;
-use gpui::{Model, Task};
+use gpui::Task;

 pub struct ContextServerTool {
-    server_manager: Model<ContextServerManager>,
-    server_id: Arc<str>,
+    server_id: String,
    tool: types::Tool,
 }

 impl ContextServerTool {
-    pub fn new(
-        server_manager: Model<ContextServerManager>,
-        server_id: impl Into<Arc<str>>,
-        tool: types::Tool,
-    ) -> Self {
+    pub fn new(server_id: impl Into<String>, tool: types::Tool) -> Self {
        Self {
-            server_manager,
            server_id: server_id.into(),
            tool,
        }
@@ -53,11 +45,13 @@ impl Tool for ContextServerTool {
        _workspace: gpui::WeakView<workspace::Workspace>,
        cx: &mut ui::WindowContext,
    ) -> gpui::Task<gpui::Result<String>> {
-        if let Some(server) = self.server_manager.read(cx).get_server(&self.server_id) {
+        let manager = ContextServerManager::global(cx);
+        let manager = manager.read(cx);
+        if let Some(server) = manager.get_server(&self.server_id) {
            cx.foreground_executor().spawn({
                let tool_name = self.tool.name.clone();
                async move {
-                    let Some(protocol) = server.client() else {
+                    let Some(protocol) = server.client.read().clone() else {
                        bail!("Context server not initialized");
                    };

--- a/crates/assistant_slash_command/Cargo.toml
+++ b/crates/assistant_slash_command/Cargo.toml
@@ -18,7 +18,6 @@ derive_more.workspace = true
 futures.workspace = true
 gpui.workspace = true
 language.workspace = true
-language_model.workspace = true
 parking_lot.workspace = true
 serde.workspace = true
 serde_json.workspace = true
--- a/crates/assistant_slash_command/src/assistant_slash_command.rs
+++ b/crates/assistant_slash_command/src/assistant_slash_command.rs
@@ -5,7 +5,6 @@ use futures::stream::{self, BoxStream};
 use futures::StreamExt;
 use gpui::{AnyElement, AppContext, ElementId, SharedString, Task, WeakView, WindowContext};
 use language::{BufferSnapshot, CodeLabel, LspAdapterDelegate, OffsetRangeExt};
-pub use language_model::Role;
 use serde::{Deserialize, Serialize};
 pub use slash_command_registry::*;
 use std::{
@@ -104,7 +103,7 @@ pub type RenderFoldPlaceholder = Arc<
        + Fn(ElementId, Arc<dyn Fn(&mut WindowContext)>, &mut WindowContext) -> AnyElement,
 >;

-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum SlashCommandContent {
    Text {
        text: String,
@@ -112,28 +111,17 @@ pub enum SlashCommandContent {
    },
 }

-impl<'a> From<&'a str> for SlashCommandContent {
-    fn from(text: &'a str) -> Self {
-        Self::Text {
-            text: text.into(),
-            run_commands_in_text: false,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum SlashCommandEvent {
-    StartMessage {
-        role: Role,
-        merge_same_roles: bool,
-    },
    StartSection {
        icon: IconName,
        label: SharedString,
        metadata: Option<serde_json::Value>,
    },
    Content(SlashCommandContent),
-    EndSection,
+    EndSection {
+        metadata: Option<serde_json::Value>,
+    },
 }

 #[derive(Debug, Default, PartialEq, Clone)]
@@ -162,37 +150,43 @@ impl SlashCommandOutput {
        self.ensure_valid_section_ranges();

        let mut events = Vec::new();
+        let mut last_section_end = 0;

-        let mut section_endpoints = Vec::new();
        for section in self.sections {
-            section_endpoints.push((
-                section.range.start,
-                SlashCommandEvent::StartSection {
-                    icon: section.icon,
-                    label: section.label,
-                    metadata: section.metadata,
-                },
-            ));
-            section_endpoints.push((section.range.end, SlashCommandEvent::EndSection));
-        }
-        section_endpoints.sort_by_key(|(offset, _)| *offset);
-
-        let mut content_offset = 0;
-        for (endpoint_offset, endpoint) in section_endpoints {
-            if content_offset < endpoint_offset {
+            if last_section_end < section.range.start {
                events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                    text: self.text[content_offset..endpoint_offset].to_string(),
+                    text: self
+                        .text
+                        .get(last_section_end..section.range.start)
+                        .unwrap_or_default()
+                        .to_string(),
                    run_commands_in_text: self.run_commands_in_text,
                })));
-                content_offset = endpoint_offset;
            }

-            events.push(Ok(endpoint));
+            events.push(Ok(SlashCommandEvent::StartSection {
+                icon: section.icon,
+                label: section.label,
+                metadata: section.metadata.clone(),
+            }));
+            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
+                text: self
+                    .text
+                    .get(section.range.start..section.range.end)
+                    .unwrap_or_default()
+                    .to_string(),
+                run_commands_in_text: self.run_commands_in_text,
+            })));
+            events.push(Ok(SlashCommandEvent::EndSection {
+                metadata: section.metadata,
+            }));
+
+            last_section_end = section.range.end;
        }

-        if content_offset < self.text.len() {
+        if last_section_end < self.text.len() {
            events.push(Ok(SlashCommandEvent::Content(SlashCommandContent::Text {
-                text: self.text[content_offset..].to_string(),
+                text: self.text[last_section_end..].to_string(),
                run_commands_in_text: self.run_commands_in_text,
            })));
        }
@@ -232,12 +226,12 @@ impl SlashCommandOutput {
                        section.range.end = output.text.len();
                    }
                }
-                SlashCommandEvent::EndSection => {
-                    if let Some(section) = section_stack.pop() {
+                SlashCommandEvent::EndSection { metadata } => {
+                    if let Some(mut section) = section_stack.pop() {
+                        section.metadata = metadata;
                        output.sections.push(section);
                    }
                }
-                SlashCommandEvent::StartMessage { .. } => {}
            }
        }

@@ -305,7 +299,7 @@ mod tests {
                        text: "Hello, world!".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection
+                    SlashCommandEvent::EndSection { metadata: None }
                ]
            );

@@ -357,7 +351,7 @@ mod tests {
                        text: "Apple\n".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection,
+                    SlashCommandEvent::EndSection { metadata: None },
                    SlashCommandEvent::Content(SlashCommandContent::Text {
                        text: "Cucumber\n".into(),
                        run_commands_in_text: false
@@ -371,7 +365,7 @@ mod tests {
                        text: "Banana\n".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection
+                    SlashCommandEvent::EndSection { metadata: None }
                ]
            );

@@ -435,7 +429,9 @@ mod tests {
                        text: "Line 1".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection,
+                    SlashCommandEvent::EndSection {
+                        metadata: Some(json!({ "a": true }))
+                    },
                    SlashCommandEvent::Content(SlashCommandContent::Text {
                        text: "\n".into(),
                        run_commands_in_text: false
@@ -449,7 +445,9 @@ mod tests {
                        text: "Line 2".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection,
+                    SlashCommandEvent::EndSection {
+                        metadata: Some(json!({ "b": true }))
+                    },
                    SlashCommandEvent::Content(SlashCommandContent::Text {
                        text: "\n".into(),
                        run_commands_in_text: false
@@ -463,7 +461,9 @@ mod tests {
                        text: "Line 3".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection,
+                    SlashCommandEvent::EndSection {
+                        metadata: Some(json!({ "c": true }))
+                    },
                    SlashCommandEvent::Content(SlashCommandContent::Text {
                        text: "\n".into(),
                        run_commands_in_text: false
@@ -477,7 +477,9 @@ mod tests {
                        text: "Line 4".into(),
                        run_commands_in_text: false
                    }),
-                    SlashCommandEvent::EndSection,
+                    SlashCommandEvent::EndSection {
+                        metadata: Some(json!({ "d": true }))
+                    },
                    SlashCommandEvent::Content(SlashCommandContent::Text {
                        text: "\n".into(),
                        run_commands_in_text: false
--- a/crates/auto_update/src/auto_update.rs
+++ b/crates/auto_update/src/auto_update.rs
@@ -432,9 +432,6 @@ impl AutoUpdater {
        cx.notify();
    }

-    // If you are packaging Zed and need to override the place it downloads SSH remotes from,
-    // you can override this function. You should also update get_remote_server_release_url to return
-    // Ok(None).
    pub async fn download_remote_server_release(
        os: &str,
        arch: &str,
@@ -485,7 +482,7 @@ impl AutoUpdater {
        release_channel: ReleaseChannel,
        version: Option<SemanticVersion>,
        cx: &mut AsyncAppContext,
-    ) -> Result<Option<(String, String)>> {
+    ) -> Result<(JsonRelease, String)> {
        let this = cx.update(|cx| {
            cx.default_global::<GlobalAutoUpdate>()
                .0
@@ -507,7 +504,7 @@ impl AutoUpdater {
        let update_request_body = build_remote_server_update_request_body(cx)?;
        let body = serde_json::to_string(&update_request_body)?;

-        Ok(Some((release.url, body)))
+        Ok((release, body))
    }

    async fn get_release(
--- a/crates/call/Cargo.toml
+++ b/crates/call/Cargo.toml
@@ -13,6 +13,7 @@ path = "src/call.rs"
 doctest = false

 [features]
+no-webrtc = ["live_kit_client/no-webrtc"]
 test-support = [
    "client/test-support",
    "collections/test-support",
--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -44,6 +44,7 @@ sha2.workspace = true
 smol.workspace = true
 sysinfo.workspace = true
 telemetry_events.workspace = true
+tempfile.workspace = true
 text.workspace = true
 thiserror.workspace = true
 time.workspace = true
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -13,7 +13,6 @@ use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
 use sha2::{Digest, Sha256};
-use std::fs::File;
 use std::io::Write;
 use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
 use sysinfo::{CpuRefreshKind, Pid, ProcessRefreshKind, RefreshKind, System};
@@ -22,7 +21,10 @@ use telemetry_events::{
    EventRequestBody, EventWrapper, ExtensionEvent, InlineCompletionEvent, MemoryEvent, ReplEvent,
    SettingEvent,
 };
-use util::{ResultExt, TryFutureExt};
+use tempfile::NamedTempFile;
+#[cfg(not(debug_assertions))]
+use util::ResultExt;
+use util::TryFutureExt;
 use worktree::{UpdatedEntriesSet, WorktreeId};

 use self::event_coalescer::EventCoalescer;
@@ -44,7 +46,7 @@ struct TelemetryState {
    architecture: &'static str,
    events_queue: Vec<EventWrapper>,
    flush_events_task: Option<Task<()>>,
-    log_file: Option<File>,
+    log_file: Option<NamedTempFile>,
    is_staff: Option<bool>,
    first_event_date_time: Option<DateTime<Utc>>,
    event_coalescer: EventCoalescer,
@@ -221,13 +223,15 @@ impl Telemetry {
            os_name: os_name(),
            app_version: release_channel::AppVersion::global(cx).to_string(),
        }));
-        Self::log_file_path();

+        #[cfg(not(debug_assertions))]
        cx.background_executor()
            .spawn({
                let state = state.clone();
                async move {
-                    if let Some(tempfile) = File::create(Self::log_file_path()).log_err() {
+                    if let Some(tempfile) =
+                        NamedTempFile::new_in(paths::logs_dir().as_path()).log_err()
+                    {
                        state.lock().log_file = Some(tempfile);
                    }
                }
@@ -276,8 +280,8 @@ impl Telemetry {
        Task::ready(())
    }

-    pub fn log_file_path() -> PathBuf {
-        paths::logs_dir().join("telemetry.log")
+    pub fn log_file_path(&self) -> Option<PathBuf> {
+        Some(self.state.lock().log_file.as_ref()?.path().to_path_buf())
    }

    pub fn start(
@@ -337,13 +341,6 @@ impl Telemetry {
            .detach();
    }

-    pub fn metrics_enabled(self: &Arc<Self>) -> bool {
-        let state = self.state.lock();
-        let enabled = state.settings.metrics;
-        drop(state);
-        return enabled;
-    }
-
    pub fn set_authenticated_user_info(
        self: &Arc<Self>,
        metrics_id: Option<String>,
@@ -641,6 +638,7 @@ impl Telemetry {
                    let mut json_bytes = Vec::new();

                    if let Some(file) = &mut this.state.lock().log_file {
+                        let file = file.as_file_mut();
                        for event in &mut events {
                            json_bytes.clear();
                            serde_json::to_writer(&mut json_bytes, event)?;
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -6,7 +6,7 @@ use crate::{
    },
 };
 use anyhow::{anyhow, Result};
-use assistant::{ContextStore, PromptBuilder, SlashCommandWorkingSet, ToolWorkingSet};
+use assistant::{ContextStore, PromptBuilder};
 use call::{room, ActiveCall, ParticipantLocation, Room};
 use client::{User, RECEIVE_TIMEOUT};
 use collections::{HashMap, HashSet};
@@ -6489,31 +6489,15 @@ async fn test_context_collaboration_with_reconnect(

    let prompt_builder = Arc::new(PromptBuilder::new(None).unwrap());
    let context_store_a = cx_a
-        .update(|cx| {
-            ContextStore::new(
-                project_a.clone(),
-                prompt_builder.clone(),
-                Arc::new(SlashCommandWorkingSet::default()),
-                Arc::new(ToolWorkingSet::default()),
-                cx,
-            )
-        })
+        .update(|cx| ContextStore::new(project_a.clone(), prompt_builder.clone(), cx))
        .await
        .unwrap();
    let context_store_b = cx_b
-        .update(|cx| {
-            ContextStore::new(
-                project_b.clone(),
-                prompt_builder.clone(),
-                Arc::new(SlashCommandWorkingSet::default()),
-                Arc::new(ToolWorkingSet::default()),
-                cx,
-            )
-        })
+        .update(|cx| ContextStore::new(project_b.clone(), prompt_builder.clone(), cx))
        .await
        .unwrap();

-    // Client A creates a new chats.
+    // Client A creates a new context.
    let context_a = context_store_a.update(cx_a, |store, cx| store.create(cx));
    executor.run_until_parked();

--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -3,7 +3,7 @@ use call::ActiveCall;
 use collections::HashSet;
 use fs::{FakeFs, Fs as _};
 use futures::StreamExt as _;
-use gpui::{BackgroundExecutor, Context as _, SemanticVersion, TestAppContext, UpdateGlobal as _};
+use gpui::{BackgroundExecutor, Context as _, TestAppContext, UpdateGlobal as _};
 use http_client::BlockedHttpClient;
 use language::{
    language_settings::{
@@ -31,12 +31,6 @@ async fn test_sharing_an_ssh_remote_project(
    server_cx: &mut TestAppContext,
 ) {
    let executor = cx_a.executor();
-    cx_a.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
-    server_cx.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
    let mut server = TestServer::start(executor.clone()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -205,13 +199,6 @@ async fn test_ssh_collaboration_git_branches(
    cx_b.set_name("b");
    server_cx.set_name("server");

-    cx_a.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
-    server_cx.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
-
    let mut server = TestServer::start(executor.clone()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
@@ -342,13 +329,6 @@ async fn test_ssh_collaboration_formatting_with_prettier(
    cx_b.set_name("b");
    server_cx.set_name("server");

-    cx_a.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
-    server_cx.update(|cx| {
-        release_channel::init(SemanticVersion::default(), cx);
-    });
-
    let mut server = TestServer::start(executor.clone()).await;
    let client_a = server.create_client(cx_a, "user_a").await;
    let client_b = server.create_client(cx_b, "user_b").await;
--- a/crates/context_servers/Cargo.toml
+++ b/crates/context_servers/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/context_servers.rs"

 [dependencies]
 anyhow.workspace = true
-async-trait.workspace = true
 collections.workspace = true
 command_palette_hooks.workspace = true
 futures.workspace = true
@@ -28,3 +27,4 @@ settings.workspace = true
 smol.workspace = true
 url = { workspace = true, features = ["serde"] }
 util.workspace = true
+workspace.workspace = true
--- a/crates/context_servers/src/client.rs
+++ b/crates/context_servers/src/client.rs
@@ -55,20 +55,11 @@ pub struct Client {
 #[repr(transparent)]
 pub struct ContextServerId(pub String);

-fn is_null_value<T: Serialize>(value: &T) -> bool {
-    if let Ok(Value::Null) = serde_json::to_value(value) {
-        true
-    } else {
-        false
-    }
-}
-
 #[derive(Serialize, Deserialize)]
 struct Request<'a, T> {
    jsonrpc: &'static str,
    id: RequestId,
    method: &'a str,
-    #[serde(skip_serializing_if = "is_null_value")]
    params: T,
 }

--- a/crates/context_servers/src/context_servers.rs
+++ b/crates/context_servers/src/context_servers.rs
@@ -1,27 +1,40 @@
+use gpui::{actions, AppContext, Context, ViewContext};
+use manager::ContextServerManager;
+use workspace::Workspace;
+
 pub mod client;
 pub mod manager;
 pub mod protocol;
 mod registry;
 pub mod types;

-use command_palette_hooks::CommandPaletteFilter;
-use gpui::{actions, AppContext};
-use settings::Settings;
-
-pub use crate::manager::ContextServer;
-use crate::manager::ContextServerSettings;
-pub use crate::registry::ContextServerFactoryRegistry;
+pub use registry::*;

 actions!(context_servers, [Restart]);

 /// The namespace for the context servers actions.
-pub const CONTEXT_SERVERS_NAMESPACE: &'static str = "context_servers";
+const CONTEXT_SERVERS_NAMESPACE: &'static str = "context_servers";

 pub fn init(cx: &mut AppContext) {
-    ContextServerSettings::register(cx);
-    ContextServerFactoryRegistry::default_global(cx);
+    log::info!("initializing context server client");
+    manager::init(cx);
+    ContextServerRegistry::register(cx);

-    CommandPaletteFilter::update_global(cx, |filter, _cx| {
-        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
+    cx.observe_new_views(
+        |workspace: &mut Workspace, _cx: &mut ViewContext<Workspace>| {
+            workspace.register_action(restart_servers);
+        },
+    )
+    .detach();
+}
+
+fn restart_servers(_workspace: &mut Workspace, _action: &Restart, cx: &mut ViewContext<Workspace>) {
+    let model = ContextServerManager::global(cx);
+    cx.update_model(&model, |manager, cx| {
+        for server in manager.servers() {
+            manager
+                .restart_server(&server.id, cx)
+                .detach_and_log_err(cx);
+        }
    });
 }
--- a/crates/context_servers/src/manager.rs
+++ b/crates/context_servers/src/manager.rs
@@ -14,21 +14,18 @@
 //! The module also includes initialization logic to set up the context server system
 //! and react to changes in settings.

-use std::path::Path;
-use std::pin::Pin;
-use std::sync::Arc;
-
-use anyhow::Result;
-use async_trait::async_trait;
 use collections::{HashMap, HashSet};
-use futures::{Future, FutureExt};
-use gpui::{AsyncAppContext, EventEmitter, ModelContext, Task};
+use command_palette_hooks::CommandPaletteFilter;
+use gpui::{AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Task};
 use log;
 use parking_lot::RwLock;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use settings::{Settings, SettingsSources};
+use settings::{Settings, SettingsSources, SettingsStore};
+use std::path::Path;
+use std::sync::Arc;

+use crate::CONTEXT_SERVERS_NAMESPACE;
 use crate::{
    client::{self, Client},
    types,
@@ -60,84 +57,51 @@ impl Settings for ContextServerSettings {
    }
 }

-#[async_trait(?Send)]
-pub trait ContextServer: Send + Sync + 'static {
-    fn id(&self) -> Arc<str>;
-    fn config(&self) -> Arc<ServerConfig>;
-    fn client(&self) -> Option<Arc<crate::protocol::InitializedContextServerProtocol>>;
-    fn start<'a>(
-        self: Arc<Self>,
-        cx: &'a AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<()>>>>;
-    fn stop(&self) -> Result<()>;
-}
-
-pub struct NativeContextServer {
-    pub id: Arc<str>,
-    pub config: Arc<ServerConfig>,
+pub struct ContextServer {
+    pub id: String,
+    pub config: ServerConfig,
    pub client: RwLock<Option<Arc<crate::protocol::InitializedContextServerProtocol>>>,
 }

-impl NativeContextServer {
-    pub fn new(config: Arc<ServerConfig>) -> Self {
+impl ContextServer {
+    fn new(config: ServerConfig) -> Self {
        Self {
-            id: config.id.clone().into(),
+            id: config.id.clone(),
            config,
            client: RwLock::new(None),
        }
    }
-}

-#[async_trait(?Send)]
-impl ContextServer for NativeContextServer {
-    fn id(&self) -> Arc<str> {
-        self.id.clone()
+    async fn start(&self, cx: &AsyncAppContext) -> anyhow::Result<()> {
+        log::info!("starting context server {}", self.config.id,);
+        let client = Client::new(
+            client::ContextServerId(self.config.id.clone()),
+            client::ModelContextServerBinary {
+                executable: Path::new(&self.config.executable).to_path_buf(),
+                args: self.config.args.clone(),
+                env: self.config.env.clone(),
+            },
+            cx.clone(),
+        )?;
+
+        let protocol = crate::protocol::ModelContextProtocol::new(client);
+        let client_info = types::Implementation {
+            name: "Zed".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+        let initialized_protocol = protocol.initialize(client_info).await?;
+
+        log::debug!(
+            "context server {} initialized: {:?}",
+            self.config.id,
+            initialized_protocol.initialize,
+        );
+
+        *self.client.write() = Some(Arc::new(initialized_protocol));
+        Ok(())
    }

-    fn config(&self) -> Arc<ServerConfig> {
-        self.config.clone()
-    }
-
-    fn client(&self) -> Option<Arc<crate::protocol::InitializedContextServerProtocol>> {
-        self.client.read().clone()
-    }
-
-    fn start<'a>(
-        self: Arc<Self>,
-        cx: &'a AsyncAppContext,
-    ) -> Pin<Box<dyn 'a + Future<Output = Result<()>>>> {
-        async move {
-            log::info!("starting context server {}", self.config.id,);
-            let client = Client::new(
-                client::ContextServerId(self.config.id.clone()),
-                client::ModelContextServerBinary {
-                    executable: Path::new(&self.config.executable).to_path_buf(),
-                    args: self.config.args.clone(),
-                    env: self.config.env.clone(),
-                },
-                cx.clone(),
-            )?;
-
-            let protocol = crate::protocol::ModelContextProtocol::new(client);
-            let client_info = types::Implementation {
-                name: "Zed".to_string(),
-                version: env!("CARGO_PKG_VERSION").to_string(),
-            };
-            let initialized_protocol = protocol.initialize(client_info).await?;
-
-            log::debug!(
-                "context server {} initialized: {:?}",
-                self.config.id,
-                initialized_protocol.initialize,
-            );
-
-            *self.client.write() = Some(Arc::new(initialized_protocol));
-            Ok(())
-        }
-        .boxed_local()
-    }
-
-    fn stop(&self) -> Result<()> {
+    async fn stop(&self) -> anyhow::Result<()> {
        let mut client = self.client.write();
        if let Some(protocol) = client.take() {
            drop(protocol);
@@ -151,15 +115,16 @@ impl ContextServer for NativeContextServer {
 /// must go through the `GlobalContextServerManager` which holds
 /// a model to the ContextServerManager.
 pub struct ContextServerManager {
-    servers: HashMap<Arc<str>, Arc<dyn ContextServer>>,
-    pending_servers: HashSet<Arc<str>>,
+    servers: HashMap<String, Arc<ContextServer>>,
+    pending_servers: HashSet<String>,
 }

 pub enum Event {
-    ServerStarted { server_id: Arc<str> },
-    ServerStopped { server_id: Arc<str> },
+    ServerStarted { server_id: String },
+    ServerStopped { server_id: String },
 }

+impl Global for ContextServerManager {}
 impl EventEmitter<Event> for ContextServerManager {}

 impl Default for ContextServerManager {
@@ -175,13 +140,16 @@ impl ContextServerManager {
            pending_servers: HashSet::default(),
        }
    }
+    pub fn global(cx: &AppContext) -> Model<Self> {
+        cx.global::<GlobalContextServerManager>().0.clone()
+    }

    pub fn add_server(
        &mut self,
-        server: Arc<dyn ContextServer>,
-        cx: &ModelContext<Self>,
+        config: ServerConfig,
+        cx: &mut ModelContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        let server_id = server.id();
+        let server_id = config.id.clone();

        if self.servers.contains_key(&server_id) || self.pending_servers.contains(&server_id) {
            return Task::ready(Ok(()));
@@ -190,7 +158,8 @@ impl ContextServerManager {
        let task = {
            let server_id = server_id.clone();
            cx.spawn(|this, mut cx| async move {
-                server.clone().start(&cx).await?;
+                let server = Arc::new(ContextServer::new(config));
+                server.start(&cx).await?;
                this.update(&mut cx, |this, cx| {
                    this.servers.insert(server_id.clone(), server);
                    this.pending_servers.remove(&server_id);
@@ -206,24 +175,22 @@ impl ContextServerManager {
        task
    }

-    pub fn get_server(&self, id: &str) -> Option<Arc<dyn ContextServer>> {
+    pub fn get_server(&self, id: &str) -> Option<Arc<ContextServer>> {
        self.servers.get(id).cloned()
    }

    pub fn remove_server(
        &mut self,
-        id: &Arc<str>,
-        cx: &ModelContext<Self>,
+        id: &str,
+        cx: &mut ModelContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        let id = id.clone();
+        let id = id.to_string();
        cx.spawn(|this, mut cx| async move {
-            if let Some(server) =
-                this.update(&mut cx, |this, _cx| this.servers.remove(id.as_ref()))?
-            {
-                server.stop()?;
+            if let Some(server) = this.update(&mut cx, |this, _cx| this.servers.remove(&id))? {
+                server.stop().await?;
            }
            this.update(&mut cx, |this, cx| {
-                this.pending_servers.remove(id.as_ref());
+                this.pending_servers.remove(&id);
                cx.emit(Event::ServerStopped {
                    server_id: id.clone(),
                })
@@ -234,16 +201,16 @@ impl ContextServerManager {

    pub fn restart_server(
        &mut self,
-        id: &Arc<str>,
+        id: &str,
        cx: &mut ModelContext<Self>,
    ) -> Task<anyhow::Result<()>> {
-        let id = id.clone();
+        let id = id.to_string();
        cx.spawn(|this, mut cx| async move {
            if let Some(server) = this.update(&mut cx, |this, _cx| this.servers.remove(&id))? {
-                server.stop()?;
-                let config = server.config();
-                let new_server = Arc::new(NativeContextServer::new(config));
-                new_server.clone().start(&cx).await?;
+                server.stop().await?;
+                let config = server.config.clone();
+                let new_server = Arc::new(ContextServer::new(config));
+                new_server.start(&cx).await?;
                this.update(&mut cx, |this, cx| {
                    this.servers.insert(id.clone(), new_server);
                    cx.emit(Event::ServerStopped {
@@ -258,43 +225,79 @@ impl ContextServerManager {
        })
    }

-    pub fn servers(&self) -> Vec<Arc<dyn ContextServer>> {
+    pub fn servers(&self) -> Vec<Arc<ContextServer>> {
        self.servers.values().cloned().collect()
    }

-    pub fn maintain_servers(&mut self, settings: &ContextServerSettings, cx: &ModelContext<Self>) {
-        let current_servers = self
-            .servers()
-            .into_iter()
-            .map(|server| (server.id(), server.config()))
-            .collect::<HashMap<_, _>>();
-
-        let new_servers = settings
-            .servers
-            .iter()
-            .map(|config| (config.id.clone(), config.clone()))
-            .collect::<HashMap<_, _>>();
-
-        let servers_to_add = new_servers
-            .values()
-            .filter(|config| !current_servers.contains_key(config.id.as_str()))
-            .cloned()
-            .collect::<Vec<_>>();
-
-        let servers_to_remove = current_servers
-            .keys()
-            .filter(|id| !new_servers.contains_key(id.as_ref()))
-            .cloned()
-            .collect::<Vec<_>>();
-
-        log::trace!("servers_to_add={:?}", servers_to_add);
-        for config in servers_to_add {
-            let server = Arc::new(NativeContextServer::new(Arc::new(config)));
-            self.add_server(server, cx).detach_and_log_err(cx);
-        }
-
-        for id in servers_to_remove {
-            self.remove_server(&id, cx).detach_and_log_err(cx);
-        }
+    pub fn model(cx: &mut AppContext) -> Model<Self> {
+        cx.new_model(|_cx| ContextServerManager::new())
    }
 }
+
+pub struct GlobalContextServerManager(Model<ContextServerManager>);
+impl Global for GlobalContextServerManager {}
+
+impl GlobalContextServerManager {
+    fn register(cx: &mut AppContext) {
+        let model = ContextServerManager::model(cx);
+        cx.set_global(Self(model));
+    }
+}
+
+pub fn init(cx: &mut AppContext) {
+    ContextServerSettings::register(cx);
+    GlobalContextServerManager::register(cx);
+
+    CommandPaletteFilter::update_global(cx, |filter, _cx| {
+        filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
+    });
+
+    cx.observe_global::<SettingsStore>(|cx| {
+        let manager = ContextServerManager::global(cx);
+        cx.update_model(&manager, |manager, cx| {
+            let settings = ContextServerSettings::get_global(cx);
+            let current_servers = manager
+                .servers()
+                .into_iter()
+                .map(|server| (server.id.clone(), server.config.clone()))
+                .collect::<HashMap<_, _>>();
+
+            let new_servers = settings
+                .servers
+                .iter()
+                .map(|config| (config.id.clone(), config.clone()))
+                .collect::<HashMap<_, _>>();
+
+            let servers_to_add = new_servers
+                .values()
+                .filter(|config| !current_servers.contains_key(&config.id))
+                .cloned()
+                .collect::<Vec<_>>();
+
+            let servers_to_remove = current_servers
+                .keys()
+                .filter(|id| !new_servers.contains_key(*id))
+                .cloned()
+                .collect::<Vec<_>>();
+
+            log::trace!("servers_to_add={:?}", servers_to_add);
+            for config in servers_to_add {
+                manager.add_server(config, cx).detach_and_log_err(cx);
+            }
+
+            for id in servers_to_remove {
+                manager.remove_server(&id, cx).detach_and_log_err(cx);
+            }
+
+            let has_any_context_servers = !manager.servers().is_empty();
+            CommandPaletteFilter::update_global(cx, |filter, _cx| {
+                if has_any_context_servers {
+                    filter.show_namespace(CONTEXT_SERVERS_NAMESPACE);
+                } else {
+                    filter.hide_namespace(CONTEXT_SERVERS_NAMESPACE);
+                }
+            });
+        })
+    })
+    .detach();
+}
--- a/crates/context_servers/src/protocol.rs
+++ b/crates/context_servers/src/protocol.rs
@@ -113,10 +113,7 @@ impl InitializedContextServerProtocol {

        let response: types::PromptsListResponse = self
            .inner
-            .request(
-                types::RequestType::PromptsList.as_str(),
-                serde_json::json!({}),
-            )
+            .request(types::RequestType::PromptsList.as_str(), ())
            .await?;

        Ok(response.prompts)
@@ -128,10 +125,7 @@ impl InitializedContextServerProtocol {

        let response: types::ResourcesListResponse = self
            .inner
-            .request(
-                types::RequestType::ResourcesList.as_str(),
-                serde_json::json!({}),
-            )
+            .request(types::RequestType::ResourcesList.as_str(), ())
            .await?;

        Ok(response)
--- a/crates/context_servers/src/registry.rs
+++ b/crates/context_servers/src/registry.rs
@@ -1,72 +1,69 @@
 use std::sync::Arc;

-use anyhow::Result;
 use collections::HashMap;
-use gpui::{AppContext, AsyncAppContext, ReadGlobal};
-use gpui::{Global, Task};
+use gpui::{AppContext, Global, ReadGlobal};
 use parking_lot::RwLock;

-use crate::ContextServer;
+struct GlobalContextServerRegistry(Arc<ContextServerRegistry>);

-pub type ContextServerFactory =
-    Arc<dyn Fn(&AsyncAppContext) -> Task<Result<Arc<dyn ContextServer>>> + Send + Sync + 'static>;
+impl Global for GlobalContextServerRegistry {}

-#[derive(Default)]
-struct GlobalContextServerFactoryRegistry(Arc<ContextServerFactoryRegistry>);
-
-impl Global for GlobalContextServerFactoryRegistry {}
-
-#[derive(Default)]
-struct ContextServerFactoryRegistryState {
-    context_servers: HashMap<Arc<str>, ContextServerFactory>,
+pub struct ContextServerRegistry {
+    command_registry: RwLock<HashMap<String, Vec<Arc<str>>>>,
+    tool_registry: RwLock<HashMap<String, Vec<Arc<str>>>>,
 }

-#[derive(Default)]
-pub struct ContextServerFactoryRegistry {
-    state: RwLock<ContextServerFactoryRegistryState>,
-}
-
-impl ContextServerFactoryRegistry {
-    /// Returns the global [`ContextServerFactoryRegistry`].
+impl ContextServerRegistry {
    pub fn global(cx: &AppContext) -> Arc<Self> {
-        GlobalContextServerFactoryRegistry::global(cx).0.clone()
+        GlobalContextServerRegistry::global(cx).0.clone()
    }

-    /// Returns the global [`ContextServerFactoryRegistry`].
-    ///
-    /// Inserts a default [`ContextServerFactoryRegistry`] if one does not yet exist.
-    pub fn default_global(cx: &mut AppContext) -> Arc<Self> {
-        cx.default_global::<GlobalContextServerFactoryRegistry>()
-            .0
-            .clone()
+    pub fn register(cx: &mut AppContext) {
+        cx.set_global(GlobalContextServerRegistry(Arc::new(
+            ContextServerRegistry {
+                command_registry: RwLock::new(HashMap::default()),
+                tool_registry: RwLock::new(HashMap::default()),
+            },
+        )))
    }

-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            state: RwLock::new(ContextServerFactoryRegistryState {
-                context_servers: HashMap::default(),
-            }),
-        })
+    pub fn register_command(&self, server_id: String, command_name: &str) {
+        let mut registry = self.command_registry.write();
+        registry
+            .entry(server_id)
+            .or_default()
+            .push(command_name.into());
    }

-    pub fn context_server_factories(&self) -> Vec<(Arc<str>, ContextServerFactory)> {
-        self.state
-            .read()
-            .context_servers
-            .iter()
-            .map(|(id, factory)| (id.clone(), factory.clone()))
-            .collect()
+    pub fn unregister_command(&self, server_id: &str, command_name: &str) {
+        let mut registry = self.command_registry.write();
+        if let Some(commands) = registry.get_mut(server_id) {
+            commands.retain(|name| name.as_ref() != command_name);
+        }
    }

-    /// Registers the provided [`ContextServerFactory`].
-    pub fn register_server_factory(&self, id: Arc<str>, factory: ContextServerFactory) {
-        let mut state = self.state.write();
-        state.context_servers.insert(id, factory);
+    pub fn get_commands(&self, server_id: &str) -> Option<Vec<Arc<str>>> {
+        let registry = self.command_registry.read();
+        registry.get(server_id).cloned()
    }

-    /// Unregisters the [`ContextServerFactory`] for the server with the given ID.
-    pub fn unregister_server_factory_by_id(&self, server_id: &str) {
-        let mut state = self.state.write();
-        state.context_servers.remove(server_id);
+    pub fn register_tool(&self, server_id: String, tool_name: &str) {
+        let mut registry = self.tool_registry.write();
+        registry
+            .entry(server_id)
+            .or_default()
+            .push(tool_name.into());
+    }
+
+    pub fn unregister_tool(&self, server_id: &str, tool_name: &str) {
+        let mut registry = self.tool_registry.write();
+        if let Some(tools) = registry.get_mut(server_id) {
+            tools.retain(|name| name.as_ref() != tool_name);
+        }
+    }
+
+    pub fn get_tools(&self, server_id: &str) -> Option<Vec<Arc<str>>> {
+        let registry = self.tool_registry.read();
+        registry.get(server_id).cloned()
    }
 }
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -35,30 +35,14 @@ pub enum Model {
    Gpt4,
    #[serde(alias = "gpt-3.5-turbo", rename = "gpt-3.5-turbo")]
    Gpt3_5Turbo,
-    #[serde(alias = "o1-preview", rename = "o1-preview-2024-09-12")]
-    O1Preview,
-    #[serde(alias = "o1-mini", rename = "o1-mini-2024-09-12")]
-    O1Mini,
-    #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
-    Claude3_5Sonnet,
 }

 impl Model {
-    pub fn uses_streaming(&self) -> bool {
-        match self {
-            Self::Gpt4o | Self::Gpt4 | Self::Gpt3_5Turbo | Self::Claude3_5Sonnet => true,
-            Self::O1Mini | Self::O1Preview => false,
-        }
-    }
-
    pub fn from_id(id: &str) -> Result<Self> {
        match id {
            "gpt-4o" => Ok(Self::Gpt4o),
            "gpt-4" => Ok(Self::Gpt4),
            "gpt-3.5-turbo" => Ok(Self::Gpt3_5Turbo),
-            "o1-preview" => Ok(Self::O1Preview),
-            "o1-mini" => Ok(Self::O1Mini),
-            "claude-3-5-sonnet" => Ok(Self::Claude3_5Sonnet),
            _ => Err(anyhow!("Invalid model id: {}", id)),
        }
    }
@@ -68,9 +52,6 @@ impl Model {
            Self::Gpt3_5Turbo => "gpt-3.5-turbo",
            Self::Gpt4 => "gpt-4",
            Self::Gpt4o => "gpt-4o",
-            Self::O1Mini => "o1-mini",
-            Self::O1Preview => "o1-preview",
-            Self::Claude3_5Sonnet => "claude-3-5-sonnet",
        }
    }

@@ -79,20 +60,14 @@ impl Model {
            Self::Gpt3_5Turbo => "GPT-3.5",
            Self::Gpt4 => "GPT-4",
            Self::Gpt4o => "GPT-4o",
-            Self::O1Mini => "o1-mini",
-            Self::O1Preview => "o1-preview",
-            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
        }
    }

    pub fn max_token_count(&self) -> usize {
        match self {
-            Self::Gpt4o => 64000,
-            Self::Gpt4 => 32768,
-            Self::Gpt3_5Turbo => 12288,
-            Self::O1Mini => 20000,
-            Self::O1Preview => 20000,
-            Self::Claude3_5Sonnet => 200_000,
+            Self::Gpt4o => 128000,
+            Self::Gpt4 => 8192,
+            Self::Gpt3_5Turbo => 16385,
        }
    }
 }
@@ -112,7 +87,7 @@ impl Request {
        Self {
            intent: true,
            n: 1,
-            stream: model.uses_streaming(),
+            stream: true,
            temperature: 0.1,
            model,
            messages,
@@ -138,8 +113,7 @@ pub struct ResponseEvent {
 pub struct ResponseChoice {
    pub index: usize,
    pub finish_reason: Option<String>,
-    pub delta: Option<ResponseDelta>,
-    pub message: Option<ResponseDelta>,
+    pub delta: ResponseDelta,
 }

 #[derive(Debug, Deserialize)]
@@ -359,23 +333,9 @@ async fn stream_completion(
    if let Some(low_speed_timeout) = low_speed_timeout {
        request_builder = request_builder.read_timeout(low_speed_timeout);
    }
-    let is_streaming = request.stream;
-
    let request = request_builder.body(AsyncBody::from(serde_json::to_string(&request)?))?;
    let mut response = client.send(request).await?;
-
-    if !response.status().is_success() {
-        let mut body = Vec::new();
-        response.body_mut().read_to_end(&mut body).await?;
-        let body_str = std::str::from_utf8(&body)?;
-        return Err(anyhow!(
-            "Failed to connect to API: {} {}",
-            response.status(),
-            body_str
-        ));
-    }
-
-    if is_streaming {
+    if response.status().is_success() {
        let reader = BufReader::new(response.into_body());
        Ok(reader
            .lines()
@@ -407,9 +367,19 @@ async fn stream_completion(
    } else {
        let mut body = Vec::new();
        response.body_mut().read_to_end(&mut body).await?;
-        let body_str = std::str::from_utf8(&body)?;
-        let response: ResponseEvent = serde_json::from_str(body_str)?;

-        Ok(futures::stream::once(async move { Ok(response) }).boxed())
+        let body_str = std::str::from_utf8(&body)?;
+
+        match serde_json::from_str::<ResponseEvent>(body_str) {
+            Ok(_) => Err(anyhow!(
+                "Unexpected success response while expecting an error: {}",
+                body_str,
+            )),
+            Err(_) => Err(anyhow!(
+                "Failed to connect to API: {} {}",
+                response.status(),
+                body_str,
+            )),
+        }
    }
 }
--- a/crates/diagnostics/Cargo.toml
+++ b/crates/diagnostics/Cargo.toml
@@ -18,6 +18,7 @@ collections.workspace = true
 ctor.workspace = true
 editor.workspace = true
 env_logger.workspace = true
+futures.workspace = true
 gpui.workspace = true
 language.workspace = true
 log.workspace = true
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -14,6 +14,10 @@ use editor::{
    scroll::Autoscroll,
    Editor, EditorEvent, ExcerptId, ExcerptRange, MultiBuffer, ToOffset,
 };
+use futures::{
+    channel::mpsc::{self, UnboundedSender},
+    StreamExt as _,
+};
 use gpui::{
    actions, div, svg, AnyElement, AnyView, AppContext, Context, EventEmitter, FocusHandle,
    FocusableView, HighlightStyle, InteractiveElement, IntoElement, Model, ParentElement, Render,
@@ -58,10 +62,11 @@ struct ProjectDiagnosticsEditor {
    summary: DiagnosticSummary,
    excerpts: Model<MultiBuffer>,
    path_states: Vec<PathState>,
-    paths_to_update: BTreeSet<(ProjectPath, Option<LanguageServerId>)>,
+    paths_to_update: BTreeSet<(ProjectPath, LanguageServerId)>,
    include_warnings: bool,
    context: u32,
-    update_excerpts_task: Option<Task<Result<()>>>,
+    update_paths_tx: UnboundedSender<(ProjectPath, Option<LanguageServerId>)>,
+    _update_excerpts_task: Task<Result<()>>,
    _subscription: Subscription,
 }

@@ -124,14 +129,14 @@ impl ProjectDiagnosticsEditor {
                }
                project::Event::DiskBasedDiagnosticsFinished { language_server_id } => {
                    log::debug!("disk based diagnostics finished for server {language_server_id}");
-                    this.update_stale_excerpts(cx);
+                    this.enqueue_update_stale_excerpts(Some(*language_server_id));
                }
                project::Event::DiagnosticsUpdated {
                    language_server_id,
                    path,
                } => {
                    this.paths_to_update
-                        .insert((path.clone(), Some(*language_server_id)));
+                        .insert((path.clone(), *language_server_id));
                    this.summary = project.read(cx).diagnostic_summary(false, cx);
                    cx.emit(EditorEvent::TitleChanged);

@@ -139,7 +144,7 @@ impl ProjectDiagnosticsEditor {
                        log::debug!("diagnostics updated for server {language_server_id}, path {path:?}. recording change");
                    } else {
                        log::debug!("diagnostics updated for server {language_server_id}, path {path:?}. updating excerpts");
-                        this.update_stale_excerpts(cx);
+                        this.enqueue_update_stale_excerpts(Some(*language_server_id));
                    }
                }
                _ => {}
@@ -166,12 +171,14 @@ impl ProjectDiagnosticsEditor {
                        cx.focus(&this.focus_handle);
                    }
                }
-                EditorEvent::Blurred => this.update_stale_excerpts(cx),
+                EditorEvent::Blurred => this.enqueue_update_stale_excerpts(None),
                _ => {}
            }
        })
        .detach();

+        let (update_excerpts_tx, mut update_excerpts_rx) = mpsc::unbounded();
+
        let project = project_handle.read(cx);
        let mut this = Self {
            project: project_handle.clone(),
@@ -184,45 +191,27 @@ impl ProjectDiagnosticsEditor {
            path_states: Default::default(),
            paths_to_update: Default::default(),
            include_warnings: ProjectDiagnosticsSettings::get_global(cx).include_warnings,
-            update_excerpts_task: None,
+            update_paths_tx: update_excerpts_tx,
+            _update_excerpts_task: cx.spawn(move |this, mut cx| async move {
+                while let Some((path, language_server_id)) = update_excerpts_rx.next().await {
+                    if let Some(buffer) = project_handle
+                        .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))?
+                        .await
+                        .log_err()
+                    {
+                        this.update(&mut cx, |this, cx| {
+                            this.update_excerpts(path, language_server_id, buffer, cx);
+                        })?;
+                    }
+                }
+                anyhow::Ok(())
+            }),
            _subscription: project_event_subscription,
        };
-        this.update_all_excerpts(cx);
+        this.enqueue_update_all_excerpts(cx);
        this
    }

-    fn update_stale_excerpts(&mut self, cx: &mut ViewContext<Self>) {
-        if self.update_excerpts_task.is_some() {
-            return;
-        }
-        let project_handle = self.project.clone();
-        self.update_excerpts_task = Some(cx.spawn(|this, mut cx| async move {
-            loop {
-                let Some((path, language_server_id)) = this.update(&mut cx, |this, _| {
-                    let Some((path, language_server_id)) = this.paths_to_update.pop_first() else {
-                        this.update_excerpts_task.take();
-                        return None;
-                    };
-                    Some((path, language_server_id))
-                })?
-                else {
-                    break;
-                };
-
-                if let Some(buffer) = project_handle
-                    .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))?
-                    .await
-                    .log_err()
-                {
-                    this.update(&mut cx, |this, cx| {
-                        this.update_excerpts(path, language_server_id, buffer, cx);
-                    })?;
-                }
-            }
-            Ok(())
-        }));
-    }
-
    fn new(
        project_handle: Model<Project>,
        workspace: WeakView<Workspace>,
@@ -250,7 +239,7 @@ impl ProjectDiagnosticsEditor {

    fn toggle_warnings(&mut self, _: &ToggleWarnings, cx: &mut ViewContext<Self>) {
        self.include_warnings = !self.include_warnings;
-        self.update_all_excerpts(cx);
+        self.enqueue_update_all_excerpts(cx);
        cx.notify();
    }

@@ -262,28 +251,37 @@ impl ProjectDiagnosticsEditor {

    fn focus_out(&mut self, cx: &mut ViewContext<Self>) {
        if !self.focus_handle.is_focused(cx) && !self.editor.focus_handle(cx).is_focused(cx) {
-            self.update_stale_excerpts(cx);
+            self.enqueue_update_stale_excerpts(None);
        }
    }

    /// Enqueue an update of all excerpts. Updates all paths that either
    /// currently have diagnostics or are currently present in this view.
-    fn update_all_excerpts(&mut self, cx: &mut ViewContext<Self>) {
+    fn enqueue_update_all_excerpts(&mut self, cx: &mut ViewContext<Self>) {
        self.project.update(cx, |project, cx| {
            let mut paths = project
                .diagnostic_summaries(false, cx)
-                .map(|(path, _, _)| (path, None))
+                .map(|(path, _, _)| path)
                .collect::<BTreeSet<_>>();
-            paths.extend(
-                self.path_states
-                    .iter()
-                    .map(|state| (state.path.clone(), None)),
-            );
-            let paths_to_update = std::mem::take(&mut self.paths_to_update);
-            paths.extend(paths_to_update.into_iter().map(|(path, _)| (path, None)));
-            self.paths_to_update = paths;
+            paths.extend(self.path_states.iter().map(|state| state.path.clone()));
+            for path in paths {
+                self.update_paths_tx.unbounded_send((path, None)).unwrap();
+            }
        });
-        self.update_stale_excerpts(cx);
+    }
+
+    /// Enqueue an update of the excerpts for any path whose diagnostics are known
+    /// to have changed. If a language server id is passed, then only the excerpts for
+    /// that language server's diagnostics will be updated. Otherwise, all stale excerpts
+    /// will be refreshed.
+    fn enqueue_update_stale_excerpts(&mut self, language_server_id: Option<LanguageServerId>) {
+        for (path, server_id) in &self.paths_to_update {
+            if language_server_id.map_or(true, |id| id == *server_id) {
+                self.update_paths_tx
+                    .unbounded_send((path.clone(), Some(*server_id)))
+                    .unwrap();
+            }
+        }
    }

    fn update_excerpts(
@@ -293,6 +291,11 @@ impl ProjectDiagnosticsEditor {
        buffer: Model<Buffer>,
        cx: &mut ViewContext<Self>,
    ) {
+        self.paths_to_update.retain(|(path, server_id)| {
+            *path != path_to_update
+                || server_to_update.map_or(false, |to_update| *server_id != to_update)
+        });
+
        let was_empty = self.path_states.is_empty();
        let snapshot = buffer.read(cx).snapshot();
        let path_ix = match self
--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -800,7 +800,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
    }

    log::info!("updating mutated diagnostics view");
-    mutated_view.update(cx, |view, cx| view.update_stale_excerpts(cx));
+    mutated_view.update(cx, |view, _| view.enqueue_update_stale_excerpts(None));
    cx.run_until_parked();

    log::info!("constructing reference diagnostics view");
--- a/crates/diagnostics/src/toolbar_controls.rs
+++ b/crates/diagnostics/src/toolbar_controls.rs
@@ -14,12 +14,12 @@ impl Render for ToolbarControls {
        let mut has_stale_excerpts = false;
        let mut is_updating = false;

-        if let Some(editor) = self.diagnostics() {
-            let diagnostics = editor.read(cx);
-            include_warnings = diagnostics.include_warnings;
-            has_stale_excerpts = !diagnostics.paths_to_update.is_empty();
-            is_updating = diagnostics.update_excerpts_task.is_some()
-                || diagnostics
+        if let Some(editor) = self.editor() {
+            let editor = editor.read(cx);
+            include_warnings = editor.include_warnings;
+            has_stale_excerpts = !editor.paths_to_update.is_empty();
+            is_updating = !editor.update_paths_tx.is_empty()
+                || editor
                    .project
                    .read(cx)
                    .language_servers_running_disk_based_diagnostics(cx)
@@ -49,9 +49,9 @@ impl Render for ToolbarControls {
                        .disabled(is_updating)
                        .tooltip(move |cx| Tooltip::text("Update excerpts", cx))
                        .on_click(cx.listener(|this, _, cx| {
-                            if let Some(diagnostics) = this.diagnostics() {
-                                diagnostics.update(cx, |diagnostics, cx| {
-                                    diagnostics.update_all_excerpts(cx);
+                            if let Some(editor) = this.editor() {
+                                editor.update(cx, |editor, _| {
+                                    editor.enqueue_update_stale_excerpts(None);
                                });
                            }
                        })),
@@ -63,7 +63,7 @@ impl Render for ToolbarControls {
                    .shape(IconButtonShape::Square)
                    .tooltip(move |cx| Tooltip::text(tooltip, cx))
                    .on_click(cx.listener(|this, _, cx| {
-                        if let Some(editor) = this.diagnostics() {
+                        if let Some(editor) = this.editor() {
                            editor.update(cx, |editor, cx| {
                                editor.toggle_warnings(&Default::default(), cx);
                            });
@@ -105,7 +105,7 @@ impl ToolbarControls {
        ToolbarControls { editor: None }
    }

-    fn diagnostics(&self) -> Option<View<ProjectDiagnosticsEditor>> {
+    fn editor(&self) -> Option<View<ProjectDiagnosticsEditor>> {
        self.editor.as_ref()?.upgrade()
    }
 }
--- a/crates/editor/Cargo.toml
+++ b/crates/editor/Cargo.toml
@@ -77,7 +77,6 @@ tree-sitter-html = { workspace = true, optional = true }
 tree-sitter-rust = { workspace = true, optional = true }
 tree-sitter-typescript = { workspace = true, optional = true }
 unicode-segmentation.workspace = true
-unicode-script.workspace = true
 unindent = { workspace = true, optional = true }
 ui.workspace = true
 url.workspace = true
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -36,7 +36,7 @@ use block_map::{BlockRow, BlockSnapshot};
 use collections::{HashMap, HashSet};
 pub use crease_map::*;
 pub use fold_map::{Fold, FoldId, FoldPlaceholder, FoldPoint};
-use fold_map::{FoldMap, FoldMapWriter, FoldOffset, FoldSnapshot};
+use fold_map::{FoldMap, FoldSnapshot};
 use gpui::{
    AnyElement, Font, HighlightStyle, LineLayout, Model, ModelContext, Pixels, UnderlineStyle,
 };
@@ -65,7 +65,7 @@ use std::{
 };
 use sum_tree::{Bias, TreeMap};
 use tab_map::{TabMap, TabSnapshot};
-use text::{Edit, LineIndent};
+use text::LineIndent;
 use ui::{div, px, IntoElement, ParentElement, SharedString, Styled, WindowContext};
 use unicode_segmentation::UnicodeSegmentation;
 use wrap_map::{WrapMap, WrapSnapshot};
@@ -206,41 +206,10 @@ impl DisplayMap {
        );
    }

-    /// Creates folds for the given ranges.
    pub fn fold<T: ToOffset>(
        &mut self,
        ranges: impl IntoIterator<Item = (Range<T>, FoldPlaceholder)>,
        cx: &mut ModelContext<Self>,
-    ) {
-        self.update_fold_map(cx, |fold_map| fold_map.fold(ranges))
-    }
-
-    /// Removes any folds with the given ranges.
-    pub fn remove_folds_with_type<T: ToOffset>(
-        &mut self,
-        ranges: impl IntoIterator<Item = Range<T>>,
-        type_id: TypeId,
-        cx: &mut ModelContext<Self>,
-    ) {
-        self.update_fold_map(cx, |fold_map| fold_map.remove_folds(ranges, type_id))
-    }
-
-    /// Removes any folds whose ranges intersect any of the given ranges.
-    pub fn unfold_intersecting<T: ToOffset>(
-        &mut self,
-        ranges: impl IntoIterator<Item = Range<T>>,
-        inclusive: bool,
-        cx: &mut ModelContext<Self>,
-    ) {
-        self.update_fold_map(cx, |fold_map| {
-            fold_map.unfold_intersecting(ranges, inclusive)
-        })
-    }
-
-    fn update_fold_map(
-        &mut self,
-        cx: &mut ModelContext<Self>,
-        callback: impl FnOnce(&mut FoldMapWriter) -> (FoldSnapshot, Vec<Edit<FoldOffset>>),
    ) {
        let snapshot = self.buffer.read(cx).snapshot(cx);
        let edits = self.buffer_subscription.consume().into_inner();
@@ -252,7 +221,31 @@ impl DisplayMap {
            .wrap_map
            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
        self.block_map.read(snapshot, edits);
-        let (snapshot, edits) = callback(&mut fold_map);
+        let (snapshot, edits) = fold_map.fold(ranges);
+        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
+        let (snapshot, edits) = self
+            .wrap_map
+            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
+        self.block_map.read(snapshot, edits);
+    }
+
+    pub fn unfold<T: ToOffset>(
+        &mut self,
+        ranges: impl IntoIterator<Item = Range<T>>,
+        inclusive: bool,
+        cx: &mut ModelContext<Self>,
+    ) {
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let edits = self.buffer_subscription.consume().into_inner();
+        let tab_size = Self::tab_size(&self.buffer, cx);
+        let (snapshot, edits) = self.inlay_map.sync(snapshot, edits);
+        let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
+        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
+        let (snapshot, edits) = self
+            .wrap_map
+            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
+        self.block_map.read(snapshot, edits);
+        let (snapshot, edits) = fold_map.unfold(ranges, inclusive);
        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
        let (snapshot, edits) = self
            .wrap_map
@@ -667,7 +660,7 @@ impl DisplaySnapshot {
        new_start..new_end
    }

-    pub fn point_to_display_point(&self, point: MultiBufferPoint, bias: Bias) -> DisplayPoint {
+    fn point_to_display_point(&self, point: MultiBufferPoint, bias: Bias) -> DisplayPoint {
        let inlay_point = self.inlay_snapshot.to_inlay_point(point);
        let fold_point = self.fold_snapshot.to_fold_point(inlay_point, bias);
        let tab_point = self.tab_snapshot.to_tab_point(fold_point);
@@ -676,7 +669,7 @@ impl DisplaySnapshot {
        DisplayPoint(block_point)
    }

-    pub fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
+    fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
        self.inlay_snapshot
            .to_buffer_point(self.display_point_to_inlay_point(point, bias))
    }
@@ -698,7 +691,7 @@ impl DisplaySnapshot {

    fn display_point_to_inlay_point(&self, point: DisplayPoint, bias: Bias) -> InlayPoint {
        let block_point = point.0;
-        let wrap_point = self.block_snapshot.to_wrap_point(block_point, bias);
+        let wrap_point = self.block_snapshot.to_wrap_point(block_point);
        let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
        let fold_point = self.tab_snapshot.to_fold_point(tab_point, bias).0;
        fold_point.to_inlay_point(&self.fold_snapshot)
@@ -706,7 +699,7 @@ impl DisplaySnapshot {

    pub fn display_point_to_fold_point(&self, point: DisplayPoint, bias: Bias) -> FoldPoint {
        let block_point = point.0;
-        let wrap_point = self.block_snapshot.to_wrap_point(block_point, bias);
+        let wrap_point = self.block_snapshot.to_wrap_point(block_point);
        let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
        self.tab_snapshot.to_fold_point(tab_point, bias).0
    }
@@ -949,6 +942,14 @@ impl DisplaySnapshot {
        DisplayPoint(clipped)
    }

+    pub fn clip_point_2(&self, point: DisplayPoint, bias: Bias, skip_blocks: bool) -> DisplayPoint {
+        let mut clipped = self.block_snapshot.clip_point_2(point.0, bias, skip_blocks);
+        if self.clip_at_line_ends {
+            clipped = self.clip_at_line_end(DisplayPoint(clipped)).0
+        }
+        DisplayPoint(clipped)
+    }
+
    pub fn clip_ignoring_line_ends(&self, point: DisplayPoint, bias: Bias) -> DisplayPoint {
        DisplayPoint(self.block_snapshot.clip_point(point.0, bias))
    }
@@ -997,7 +998,7 @@ impl DisplaySnapshot {
    pub fn soft_wrap_indent(&self, display_row: DisplayRow) -> Option<u32> {
        let wrap_row = self
            .block_snapshot
-            .to_wrap_point(BlockPoint::new(display_row.0, 0), Bias::Left)
+            .to_wrap_point(BlockPoint::new(display_row.0, 0))
            .row();
        self.wrap_snapshot.soft_wrap_indent(wrap_row)
    }
@@ -1179,7 +1180,7 @@ impl Sub for DisplayPoint {
 #[serde(transparent)]
 pub struct DisplayRow(pub u32);

-impl Add<DisplayRow> for DisplayRow {
+impl Add for DisplayRow {
    type Output = Self;

    fn add(self, other: Self) -> Self::Output {
@@ -1187,15 +1188,7 @@ impl Add<DisplayRow> for DisplayRow {
    }
 }

-impl Add<u32> for DisplayRow {
-    type Output = Self;
-
-    fn add(self, other: u32) -> Self::Output {
-        DisplayRow(self.0 + other)
-    }
-}
-
-impl Sub<DisplayRow> for DisplayRow {
+impl Sub for DisplayRow {
    type Output = Self;

    fn sub(self, other: Self) -> Self::Output {
@@ -1203,14 +1196,6 @@ impl Sub<DisplayRow> for DisplayRow {
    }
 }

-impl Sub<u32> for DisplayRow {
-    type Output = Self;
-
-    fn sub(self, other: u32) -> Self::Output {
-        DisplayRow(self.0 - other)
-    }
-}
-
 impl DisplayPoint {
    pub fn new(row: DisplayRow, column: u32) -> Self {
        Self(BlockPoint(Point::new(row.0, column)))
@@ -1245,7 +1230,7 @@ impl DisplayPoint {
    }

    pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize {
-        let wrap_point = map.block_snapshot.to_wrap_point(self.0, bias);
+        let wrap_point = map.block_snapshot.to_wrap_point(self.0);
        let tab_point = map.wrap_snapshot.to_tab_point(wrap_point);
        let fold_point = map.tab_snapshot.to_fold_point(tab_point, bias).0;
        let inlay_point = fold_point.to_inlay_point(&map.fold_snapshot);
@@ -1449,7 +1434,7 @@ pub mod tests {
                    if rng.gen() && fold_count > 0 {
                        log::info!("unfolding ranges: {:?}", ranges);
                        map.update(cx, |map, cx| {
-                            map.unfold_intersecting(ranges, true, cx);
+                            map.unfold(ranges, true, cx);
                        });
                    } else {
                        log::info!("folding ranges: {:?}", ranges);
@@ -2071,112 +2056,6 @@ pub mod tests {
        );
    }

-    #[gpui::test]
-    async fn test_point_translation_with_replace_blocks(cx: &mut gpui::TestAppContext) {
-        cx.background_executor
-            .set_block_on_ticks(usize::MAX..=usize::MAX);
-
-        cx.update(|cx| init_test(cx, |_| {}));
-
-        let buffer = cx.update(|cx| MultiBuffer::build_simple("abcde\nfghij\nklmno\npqrst", cx));
-        let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
-        let map = cx.new_model(|cx| {
-            DisplayMap::new(
-                buffer.clone(),
-                font("Courier"),
-                px(16.0),
-                None,
-                true,
-                1,
-                1,
-                0,
-                FoldPlaceholder::test(),
-                cx,
-            )
-        });
-
-        let snapshot = map.update(cx, |map, cx| {
-            map.insert_blocks(
-                [BlockProperties {
-                    placement: BlockPlacement::Replace(
-                        buffer_snapshot.anchor_before(Point::new(1, 2))
-                            ..buffer_snapshot.anchor_after(Point::new(2, 3)),
-                    ),
-                    height: 4,
-                    style: BlockStyle::Fixed,
-                    render: Box::new(|_| div().into_any()),
-                    priority: 0,
-                }],
-                cx,
-            );
-            map.snapshot(cx)
-        });
-
-        assert_eq!(snapshot.text(), "abcde\n\n\n\n\npqrst");
-
-        let point_to_display_points = [
-            (Point::new(1, 0), DisplayPoint::new(DisplayRow(1), 0)),
-            (Point::new(2, 0), DisplayPoint::new(DisplayRow(1), 0)),
-            (Point::new(3, 0), DisplayPoint::new(DisplayRow(5), 0)),
-        ];
-        for (buffer_point, display_point) in point_to_display_points {
-            assert_eq!(
-                snapshot.point_to_display_point(buffer_point, Bias::Left),
-                display_point,
-                "point_to_display_point({:?}, Bias::Left)",
-                buffer_point
-            );
-            assert_eq!(
-                snapshot.point_to_display_point(buffer_point, Bias::Right),
-                display_point,
-                "point_to_display_point({:?}, Bias::Right)",
-                buffer_point
-            );
-        }
-
-        let display_points_to_points = [
-            (
-                DisplayPoint::new(DisplayRow(1), 0),
-                Point::new(1, 0),
-                Point::new(2, 5),
-            ),
-            (
-                DisplayPoint::new(DisplayRow(2), 0),
-                Point::new(1, 0),
-                Point::new(2, 5),
-            ),
-            (
-                DisplayPoint::new(DisplayRow(3), 0),
-                Point::new(1, 0),
-                Point::new(2, 5),
-            ),
-            (
-                DisplayPoint::new(DisplayRow(4), 0),
-                Point::new(1, 0),
-                Point::new(2, 5),
-            ),
-            (
-                DisplayPoint::new(DisplayRow(5), 0),
-                Point::new(3, 0),
-                Point::new(3, 0),
-            ),
-        ];
-        for (display_point, left_buffer_point, right_buffer_point) in display_points_to_points {
-            assert_eq!(
-                snapshot.display_point_to_point(display_point, Bias::Left),
-                left_buffer_point,
-                "display_point_to_point({:?}, Bias::Left)",
-                display_point
-            );
-            assert_eq!(
-                snapshot.display_point_to_point(display_point, Bias::Right),
-                right_buffer_point,
-                "display_point_to_point({:?}, Bias::Right)",
-                display_point
-            );
-        }
-    }
-
    // todo(linux) fails due to pixel differences in text rendering
    #[cfg(target_os = "macos")]
    #[gpui::test]
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1298,6 +1298,68 @@ impl BlockSnapshot {
        cursor.item().map_or(false, |t| t.block.is_some())
    }

+    pub fn clip_point_2(&self, point: BlockPoint, bias: Bias, skip_blocks: bool) -> BlockPoint {
+        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
+        cursor.seek(&BlockRow(point.row), Bias::Right, &());
+
+        let max_input_row = WrapRow(self.transforms.summary().input_rows);
+        let mut search_left =
+            (bias == Bias::Left && cursor.start().1 .0 > 0) || cursor.end(&()).1 == max_input_row;
+        let mut reversed = false;
+
+        loop {
+            if let Some(transform) = cursor.item() {
+                let (output_start_row, input_start_row) = cursor.start();
+                let (output_end_row, input_end_row) = cursor.end(&());
+                let output_start = Point::new(output_start_row.0, 0);
+                let output_end = Point::new(output_end_row.0, 0);
+                let input_start = Point::new(input_start_row.0, 0);
+                let input_end = Point::new(input_end_row.0, 0);
+
+                match transform.block.as_ref() {
+                    Some(Block::Custom(block))
+                        if matches!(block.placement, BlockPlacement::Replace(_)) =>
+                    {
+                        if bias == Bias::Left {
+                            return BlockPoint(output_start);
+                        } else {
+                            return BlockPoint(Point::new(output_end.row - 1, 0));
+                        }
+                    }
+                    None => {
+                        let input_point = if point.row >= output_end_row.0 {
+                            let line_len = self.wrap_snapshot.line_len(input_end_row.0 - 1);
+                            self.wrap_snapshot
+                                .clip_point(WrapPoint::new(input_end_row.0 - 1, line_len), bias)
+                        } else {
+                            let output_overshoot = point.0.saturating_sub(output_start);
+                            self.wrap_snapshot
+                                .clip_point(WrapPoint(input_start + output_overshoot), bias)
+                        };
+
+                        if (input_start..input_end).contains(&input_point.0) {
+                            let input_overshoot = input_point.0.saturating_sub(input_start);
+                            return BlockPoint(output_start + input_overshoot);
+                        }
+                    }
+                    _ => {}
+                }
+
+                if search_left {
+                    cursor.prev(&());
+                } else {
+                    cursor.next(&());
+                }
+            } else if reversed {
+                return self.max_point();
+            } else {
+                reversed = true;
+                search_left = !search_left;
+                cursor.seek(&BlockRow(point.row), Bias::Right, &());
+            }
+        }
+    }
+
    pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
        cursor.seek(&BlockRow(point.row), Bias::Right, &());
@@ -1312,6 +1374,7 @@ impl BlockSnapshot {
                let (output_start_row, input_start_row) = cursor.start();
                let (output_end_row, input_end_row) = cursor.end(&());
                let output_start = Point::new(output_start_row.0, 0);
+                let output_end = Point::new(output_end_row.0, 0);
                let input_start = Point::new(input_start_row.0, 0);
                let input_end = Point::new(input_end_row.0, 0);

@@ -1319,10 +1382,10 @@ impl BlockSnapshot {
                    Some(Block::Custom(block))
                        if matches!(block.placement, BlockPlacement::Replace(_)) =>
                    {
-                        if ((bias == Bias::Left || search_left) && output_start <= point.0)
-                            || (!search_left && output_start >= point.0)
-                        {
+                        if bias == Bias::Left {
                            return BlockPoint(output_start);
+                        } else {
+                            return BlockPoint(Point::new(output_end.row - 1, 0));
                        }
                    }
                    None => {
@@ -1364,7 +1427,12 @@ impl BlockSnapshot {
        cursor.seek(&WrapRow(wrap_point.row()), Bias::Right, &());
        if let Some(transform) = cursor.item() {
            if transform.block.is_some() {
-                BlockPoint::new(cursor.start().1 .0, 0)
+                let wrap_start = WrapPoint::new(cursor.start().0 .0, 0);
+                if wrap_start == wrap_point {
+                    BlockPoint::new(cursor.start().1 .0, 0)
+                } else {
+                    BlockPoint::new(cursor.end(&()).1 .0 - 1, 0)
+                }
            } else {
                let (input_start_row, output_start_row) = cursor.start();
                let input_start = Point::new(input_start_row.0, 0);
@@ -1377,7 +1445,7 @@ impl BlockSnapshot {
        }
    }

-    pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint {
+    pub fn to_wrap_point(&self, block_point: BlockPoint) -> WrapPoint {
        let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
        cursor.seek(&BlockRow(block_point.row), Bias::Right, &());
        if let Some(transform) = cursor.item() {
@@ -1386,9 +1454,7 @@ impl BlockSnapshot {
                    if block.place_below() {
                        let wrap_row = cursor.start().1 .0 - 1;
                        WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
-                    } else if block.place_above() {
-                        WrapPoint::new(cursor.start().1 .0, 0)
-                    } else if bias == Bias::Left {
+                    } else if block.place_above() || block_point.row == cursor.start().0 .0 {
                        WrapPoint::new(cursor.start().1 .0, 0)
                    } else {
                        let wrap_row = cursor.end(&()).1 .0 - 1;
@@ -1763,19 +1829,19 @@ mod tests {
        );

        assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(0, 3), Bias::Left),
+            snapshot.to_wrap_point(BlockPoint::new(0, 3)),
            WrapPoint::new(0, 3)
        );
        assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(1, 0), Bias::Left),
+            snapshot.to_wrap_point(BlockPoint::new(1, 0)),
            WrapPoint::new(1, 0)
        );
        assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(3, 0), Bias::Left),
+            snapshot.to_wrap_point(BlockPoint::new(3, 0)),
            WrapPoint::new(1, 0)
        );
        assert_eq!(
-            snapshot.to_wrap_point(BlockPoint::new(7, 0), Bias::Left),
+            snapshot.to_wrap_point(BlockPoint::new(7, 0)),
            WrapPoint::new(3, 3)
        );

@@ -2613,15 +2679,10 @@ mod tests {

            // Ensure that conversion between block points and wrap points is stable.
            for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row() {
-                let wrap_point = WrapPoint::new(row, 0);
-                let block_point = blocks_snapshot.to_block_point(wrap_point);
-                let left_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Left);
-                let right_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Right);
-                assert_eq!(blocks_snapshot.to_block_point(left_wrap_point), block_point);
-                assert_eq!(
-                    blocks_snapshot.to_block_point(right_wrap_point),
-                    block_point
-                );
+                let original_wrap_point = WrapPoint::new(row, 0);
+                let block_point = blocks_snapshot.to_block_point(original_wrap_point);
+                let wrap_point = blocks_snapshot.to_wrap_point(block_point);
+                assert_eq!(blocks_snapshot.to_block_point(wrap_point), block_point);
            }

            let mut block_point = BlockPoint::new(0, 0);
@@ -2629,12 +2690,10 @@ mod tests {
                let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
                let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
                assert_eq!(
-                    blocks_snapshot
-                        .to_block_point(blocks_snapshot.to_wrap_point(left_point, Bias::Left)),
+                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(left_point)),
                    left_point,
-                    "block point: {:?}, wrap point: {:?}",
-                    block_point,
-                    blocks_snapshot.to_wrap_point(left_point, Bias::Left)
+                    "wrap point: {:?}",
+                    blocks_snapshot.to_wrap_point(left_point)
                );
                assert_eq!(
                    left_buffer_point,
@@ -2646,12 +2705,10 @@ mod tests {
                let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
                let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
                assert_eq!(
-                    blocks_snapshot
-                        .to_block_point(blocks_snapshot.to_wrap_point(right_point, Bias::Right)),
+                    blocks_snapshot.to_block_point(blocks_snapshot.to_wrap_point(right_point)),
                    right_point,
-                    "block point: {:?}, wrap point: {:?}",
-                    block_point,
-                    blocks_snapshot.to_wrap_point(right_point, Bias::Right)
+                    "wrap point: {:?}",
+                    blocks_snapshot.to_wrap_point(right_point)
                );
                assert_eq!(
                    right_buffer_point,
@@ -2687,8 +2744,7 @@ mod tests {

    impl BlockSnapshot {
        fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
-            self.wrap_snapshot
-                .to_point(self.to_wrap_point(point, bias), bias)
+            self.wrap_snapshot.to_point(self.to_wrap_point(point), bias)
        }
    }
 }
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -6,14 +6,12 @@ use gpui::{AnyElement, ElementId, WindowContext};
 use language::{Chunk, ChunkRenderer, Edit, Point, TextSummary};
 use multi_buffer::{Anchor, AnchorRangeExt, MultiBufferRow, MultiBufferSnapshot, ToOffset};
 use std::{
-    any::TypeId,
    cmp::{self, Ordering},
    fmt, iter,
    ops::{Add, AddAssign, Deref, DerefMut, Range, Sub},
    sync::Arc,
 };
 use sum_tree::{Bias, Cursor, FilterCursor, SumTree, Summary};
-use ui::IntoElement as _;
 use util::post_inc;

 #[derive(Clone)]
@@ -24,29 +22,17 @@ pub struct FoldPlaceholder {
    pub constrain_width: bool,
    /// If true, merges the fold with an adjacent one.
    pub merge_adjacent: bool,
-    /// Category of the fold. Useful for carefully removing from overlapping folds.
-    pub type_tag: Option<TypeId>,
-}
-
-impl Default for FoldPlaceholder {
-    fn default() -> Self {
-        Self {
-            render: Arc::new(|_, _, _| gpui::Empty.into_any_element()),
-            constrain_width: true,
-            merge_adjacent: true,
-            type_tag: None,
-        }
-    }
 }

 impl FoldPlaceholder {
    #[cfg(any(test, feature = "test-support"))]
    pub fn test() -> Self {
+        use gpui::IntoElement;
+
        Self {
            render: Arc::new(|_id, _range, _cx| gpui::Empty.into_any_element()),
            constrain_width: true,
            merge_adjacent: true,
-            type_tag: None,
        }
    }
 }
@@ -187,34 +173,9 @@ impl<'a> FoldMapWriter<'a> {
        (self.0.snapshot.clone(), edits)
    }

-    /// Removes any folds with the given ranges.
-    pub(crate) fn remove_folds<T: ToOffset>(
+    pub(crate) fn unfold<T: ToOffset>(
        &mut self,
        ranges: impl IntoIterator<Item = Range<T>>,
-        type_id: TypeId,
-    ) -> (FoldSnapshot, Vec<FoldEdit>) {
-        self.remove_folds_with(
-            ranges,
-            |fold| fold.placeholder.type_tag == Some(type_id),
-            false,
-        )
-    }
-
-    /// Removes any folds whose ranges intersect the given ranges.
-    pub(crate) fn unfold_intersecting<T: ToOffset>(
-        &mut self,
-        ranges: impl IntoIterator<Item = Range<T>>,
-        inclusive: bool,
-    ) -> (FoldSnapshot, Vec<FoldEdit>) {
-        self.remove_folds_with(ranges, |_| true, inclusive)
-    }
-
-    /// Removes any folds that intersect the given ranges and for which the given predicate
-    /// returns true.
-    fn remove_folds_with<T: ToOffset>(
-        &mut self,
-        ranges: impl IntoIterator<Item = Range<T>>,
-        should_unfold: impl Fn(&Fold) -> bool,
        inclusive: bool,
    ) -> (FoldSnapshot, Vec<FoldEdit>) {
        let mut edits = Vec::new();
@@ -222,23 +183,21 @@ impl<'a> FoldMapWriter<'a> {
        let snapshot = self.0.snapshot.inlay_snapshot.clone();
        let buffer = &snapshot.buffer;
        for range in ranges.into_iter() {
-            let range = range.start.to_offset(buffer)..range.end.to_offset(buffer);
+            // Remove intersecting folds and add their ranges to edits that are passed to sync.
            let mut folds_cursor =
-                intersecting_folds(&snapshot, &self.0.snapshot.folds, range.clone(), inclusive);
+                intersecting_folds(&snapshot, &self.0.snapshot.folds, range, inclusive);
            while let Some(fold) = folds_cursor.item() {
                let offset_range =
                    fold.range.start.to_offset(buffer)..fold.range.end.to_offset(buffer);
-                if should_unfold(fold) {
-                    if offset_range.end > offset_range.start {
-                        let inlay_range = snapshot.to_inlay_offset(offset_range.start)
-                            ..snapshot.to_inlay_offset(offset_range.end);
-                        edits.push(InlayEdit {
-                            old: inlay_range.clone(),
-                            new: inlay_range,
-                        });
-                    }
-                    fold_ixs_to_delete.push(*folds_cursor.start());
+                if offset_range.end > offset_range.start {
+                    let inlay_range = snapshot.to_inlay_offset(offset_range.start)
+                        ..snapshot.to_inlay_offset(offset_range.end);
+                    edits.push(InlayEdit {
+                        old: inlay_range.clone(),
+                        new: inlay_range,
+                    });
                }
+                fold_ixs_to_delete.push(*folds_cursor.start());
                folds_cursor.next(buffer);
            }
        }
@@ -706,8 +665,6 @@ impl FoldSnapshot {
    where
        T: ToOffset,
    {
-        let buffer = &self.inlay_snapshot.buffer;
-        let range = range.start.to_offset(buffer)..range.end.to_offset(buffer);
        let mut folds = intersecting_folds(&self.inlay_snapshot, &self.folds, range, false);
        iter::from_fn(move || {
            let item = folds.item();
@@ -864,12 +821,15 @@ fn push_isomorphic(transforms: &mut SumTree<Transform>, summary: TextSummary) {
    }
 }

-fn intersecting_folds<'a>(
+fn intersecting_folds<'a, T>(
    inlay_snapshot: &'a InlaySnapshot,
    folds: &'a SumTree<Fold>,
-    range: Range<usize>,
+    range: Range<T>,
    inclusive: bool,
-) -> FilterCursor<'a, impl 'a + FnMut(&FoldSummary) -> bool, Fold, usize> {
+) -> FilterCursor<'a, impl 'a + FnMut(&FoldSummary) -> bool, Fold, usize>
+where
+    T: ToOffset,
+{
    let buffer = &inlay_snapshot.buffer;
    let start = buffer.anchor_before(range.start.to_offset(buffer));
    let end = buffer.anchor_after(range.end.to_offset(buffer));
@@ -1459,12 +1419,12 @@ mod tests {
        assert_eq!(snapshot4.text(), "123a⋯c123456eee");

        let (mut writer, _, _) = map.write(inlay_snapshot.clone(), vec![]);
-        writer.unfold_intersecting(Some(Point::new(0, 4)..Point::new(0, 4)), false);
+        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), false);
        let (snapshot5, _) = map.read(inlay_snapshot.clone(), vec![]);
        assert_eq!(snapshot5.text(), "123a⋯c123456eee");

        let (mut writer, _, _) = map.write(inlay_snapshot.clone(), vec![]);
-        writer.unfold_intersecting(Some(Point::new(0, 4)..Point::new(0, 4)), true);
+        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), true);
        let (snapshot6, _) = map.read(inlay_snapshot, vec![]);
        assert_eq!(snapshot6.text(), "123aaaaa\nbbbbbb\nccc123456eee");
    }
@@ -1953,7 +1913,7 @@ mod tests {
                    log::info!("unfolding {:?} (inclusive: {})", to_unfold, inclusive);
                    let (mut writer, snapshot, edits) = self.write(inlay_snapshot, vec![]);
                    snapshot_edits.push((snapshot, edits));
-                    let (snapshot, edits) = writer.unfold_intersecting(to_unfold, inclusive);
+                    let (snapshot, edits) = writer.unfold(to_unfold, inclusive);
                    snapshot_edits.push((snapshot, edits));
                }
                _ => {
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -49,7 +49,6 @@ pub mod test;

 use ::git::diff::DiffHunkStatus;
 pub(crate) use actions::*;
-pub use actions::{OpenExcerpts, OpenExcerptsSplit};
 use aho_corasick::AhoCorasick;
 use anyhow::{anyhow, Context as _, Result};
 use blink_manager::BlinkManager;
@@ -76,9 +75,9 @@ use gpui::{
    AppContext, AsyncWindowContext, AvailableSpace, BackgroundExecutor, Bounds, ClipboardEntry,
    ClipboardItem, Context, DispatchPhase, ElementId, EventEmitter, FocusHandle, FocusOutEvent,
    FocusableView, FontId, FontWeight, HighlightStyle, Hsla, InteractiveText, KeyContext,
-    ListSizingBehavior, Model, ModelContext, MouseButton, PaintQuad, ParentElement, Pixels, Render,
-    ScrollStrategy, SharedString, Size, StrikethroughStyle, Styled, StyledText, Subscription, Task,
-    TextStyle, TextStyleRefinement, UTF16Selection, UnderlineStyle, UniformListScrollHandle, View,
+    ListSizingBehavior, Model, MouseButton, PaintQuad, ParentElement, Pixels, Render, SharedString,
+    Size, StrikethroughStyle, Styled, StyledText, Subscription, Task, TextStyle,
+    TextStyleRefinement, UTF16Selection, UnderlineStyle, UniformListScrollHandle, View,
    ViewContext, ViewInputHandler, VisualContext, WeakFocusHandle, WeakView, WindowContext,
 };
 use highlight_matching_bracket::refresh_matching_bracket_highlights;
@@ -104,7 +103,6 @@ pub use proposed_changes_editor::{
    ProposedChangeLocation, ProposedChangesEditor, ProposedChangesEditorToolbar,
 };
 use similar::{ChangeTag, TextDiff};
-use std::iter::Peekable;
 use task::{ResolvedTask, TaskTemplate, TaskVariables};

 use hover_links::{find_file, HoverLink, HoveredLinkState, InlayHighlight};
@@ -133,9 +131,7 @@ use project::{
 use rand::prelude::*;
 use rpc::{proto::*, ErrorExt};
 use scroll::{Autoscroll, OngoingScroll, ScrollAnchor, ScrollManager, ScrollbarAutoHide};
-use selections_collection::{
-    resolve_selections, MutableSelectionsCollection, SelectionsCollection,
-};
+use selections_collection::{resolve_multiple, MutableSelectionsCollection, SelectionsCollection};
 use serde::{Deserialize, Serialize};
 use settings::{update_settings_file, Settings, SettingsLocation, SettingsStore};
 use smallvec::SmallVec;
@@ -1017,8 +1013,7 @@ impl CompletionsMenu {
        cx: &mut ViewContext<Editor>,
    ) {
        self.selected_item = 0;
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        self.attempt_resolve_selected_completion_documentation(provider, cx);
        cx.notify();
    }
@@ -1033,8 +1028,7 @@ impl CompletionsMenu {
        } else {
            self.selected_item = self.matches.len() - 1;
        }
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        self.attempt_resolve_selected_completion_documentation(provider, cx);
        cx.notify();
    }
@@ -1049,8 +1043,7 @@ impl CompletionsMenu {
        } else {
            self.selected_item = 0;
        }
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        self.attempt_resolve_selected_completion_documentation(provider, cx);
        cx.notify();
    }
@@ -1061,8 +1054,7 @@ impl CompletionsMenu {
        cx: &mut ViewContext<Editor>,
    ) {
        self.selected_item = self.matches.len() - 1;
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        self.attempt_resolve_selected_completion_documentation(provider, cx);
        cx.notify();
    }
@@ -1359,22 +1351,22 @@ impl CompletionsMenu {
                // Strong matches are the ones with a high fuzzy-matcher score (the "obvious" matches)
                // and the Weak matches are the rest.
                //
-                // For the strong matches, we sort by our fuzzy-finder score first and for the weak
-                // matches, we prefer language-server sort_text first.
+                // For the strong matches, we sort by the language-servers score first and for the weak
+                // matches, we prefer our fuzzy finder first.
                //
-                // The thinking behind that: we want to show strong matches first in order of relevance(fuzzy score).
-                // Rest of the matches(weak) can be sorted as language-server expects.
+                // The thinking behind that: it's useless to take the sort_text the language-server gives
+                // us into account when it's obviously a bad match.

                #[derive(PartialEq, Eq, PartialOrd, Ord)]
                enum MatchScore<'a> {
                    Strong {
-                        score: Reverse<OrderedFloat<f64>>,
                        sort_text: Option<&'a str>,
+                        score: Reverse<OrderedFloat<f64>>,
                        sort_key: (usize, &'a str),
                    },
                    Weak {
-                        sort_text: Option<&'a str>,
                        score: Reverse<OrderedFloat<f64>>,
+                        sort_text: Option<&'a str>,
                        sort_key: (usize, &'a str),
                    },
                }
@@ -1386,14 +1378,14 @@ impl CompletionsMenu {

                if mat.score >= 0.2 {
                    MatchScore::Strong {
-                        score,
                        sort_text,
+                        score,
                        sort_key,
                    }
                } else {
                    MatchScore::Weak {
-                        sort_text,
                        score,
+                        sort_text,
                        sort_key,
                    }
                }
@@ -1543,8 +1535,7 @@ struct CodeActionsMenu {
 impl CodeActionsMenu {
    fn select_first(&mut self, cx: &mut ViewContext<Editor>) {
        self.selected_item = 0;
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        cx.notify()
    }

@@ -1554,8 +1545,7 @@ impl CodeActionsMenu {
        } else {
            self.selected_item = self.actions.len() - 1;
        }
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        cx.notify();
    }

@@ -1565,15 +1555,13 @@ impl CodeActionsMenu {
        } else {
            self.selected_item = 0;
        }
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        cx.notify();
    }

    fn select_last(&mut self, cx: &mut ViewContext<Editor>) {
        self.selected_item = self.actions.len() - 1;
-        self.scroll_handle
-            .scroll_to_item(self.selected_item, ScrollStrategy::Top);
+        self.scroll_handle.scroll_to_item(self.selected_item);
        cx.notify()
    }

@@ -1858,7 +1846,7 @@ impl Editor {
                        editor
                            .update(cx, |editor, cx| {
                                editor.unfold_ranges(
-                                    &[fold_range.start..fold_range.end],
+                                    [fold_range.start..fold_range.end],
                                    true,
                                    false,
                                    cx,
@@ -1870,7 +1858,6 @@ impl Editor {
                    .into_any()
            }),
            merge_adjacent: true,
-            ..Default::default()
        };
        let display_map = cx.new_model(|cx| {
            DisplayMap::new(
@@ -2499,10 +2486,6 @@ impl Editor {
        buffer_position: language::Anchor,
        cx: &AppContext,
    ) -> bool {
-        if !self.snippet_stack.is_empty() {
-            return false;
-        }
-
        if let Some(provider) = self.inline_completion_provider() {
            if let Some(show_inline_completions) = self.show_inline_completions_override {
                show_inline_completions
@@ -3501,8 +3484,8 @@ impl Editor {
            }
            let new_anchor_selections = new_selections.iter().map(|e| &e.0);
            let new_selection_deltas = new_selections.iter().map(|e| e.1);
-            let map = this.display_map.update(cx, |map, cx| map.snapshot(cx));
-            let new_selections = resolve_selections::<usize, _>(new_anchor_selections, &map)
+            let snapshot = this.buffer.read(cx).read(cx);
+            let new_selections = resolve_multiple::<usize, _>(new_anchor_selections, &snapshot)
                .zip(new_selection_deltas)
                .map(|(selection, delta)| Selection {
                    id: selection.id,
@@ -3515,20 +3498,18 @@ impl Editor {

            let mut i = 0;
            for (position, delta, selection_id, pair) in new_autoclose_regions {
-                let position = position.to_offset(&map.buffer_snapshot) + delta;
-                let start = map.buffer_snapshot.anchor_before(position);
-                let end = map.buffer_snapshot.anchor_after(position);
+                let position = position.to_offset(&snapshot) + delta;
+                let start = snapshot.anchor_before(position);
+                let end = snapshot.anchor_after(position);
                while let Some(existing_state) = this.autoclose_regions.get(i) {
-                    match existing_state.range.start.cmp(&start, &map.buffer_snapshot) {
+                    match existing_state.range.start.cmp(&start, &snapshot) {
                        Ordering::Less => i += 1,
                        Ordering::Greater => break,
-                        Ordering::Equal => {
-                            match end.cmp(&existing_state.range.end, &map.buffer_snapshot) {
-                                Ordering::Less => i += 1,
-                                Ordering::Equal => break,
-                                Ordering::Greater => break,
-                            }
-                        }
+                        Ordering::Equal => match end.cmp(&existing_state.range.end, &snapshot) {
+                            Ordering::Less => i += 1,
+                            Ordering::Equal => break,
+                            Ordering::Greater => break,
+                        },
                    }
                }
                this.autoclose_regions.insert(
@@ -3541,6 +3522,7 @@ impl Editor {
                );
            }

+            drop(snapshot);
            let had_active_inline_completion = this.has_active_inline_completion(cx);
            this.change_selections_inner(Some(Autoscroll::fit()), false, cx, |s| {
                s.select(new_selections)
@@ -4056,7 +4038,7 @@ impl Editor {
                }
            }

-            (selection, enclosing)
+            (selection.clone(), enclosing)
        })
    }

@@ -6824,7 +6806,7 @@ impl Editor {
        }

        self.transact(cx, |this, cx| {
-            this.unfold_ranges(&unfold_ranges, true, true, cx);
+            this.unfold_ranges(unfold_ranges, true, true, cx);
            this.buffer.update(cx, |buffer, cx| {
                for (range, text) in edits {
                    buffer.edit([(range, text)], None, cx);
@@ -6918,7 +6900,7 @@ impl Editor {
        }

        self.transact(cx, |this, cx| {
-            this.unfold_ranges(&unfold_ranges, true, true, cx);
+            this.unfold_ranges(unfold_ranges, true, true, cx);
            this.buffer.update(cx, |buffer, cx| {
                for (range, text) in edits {
                    buffer.edit([(range, text)], None, cx);
@@ -7023,8 +7005,6 @@ impl Editor {
                }
            }

-            let tab_size = buffer.settings_at(selection.head(), cx).tab_size;
-
            // Since not all lines in the selection may be at the same indent
            // level, choose the indent size that is the most common between all
            // of the lines.
@@ -7042,7 +7022,7 @@ impl Editor {

                let indent_size = indent_size_occurrences
                    .into_iter()
-                    .max_by_key(|(indent, count)| (*count, indent.len_with_expanded_tabs(tab_size)))
+                    .max_by_key(|(indent, count)| (*count, indent.len))
                    .map(|(indent, _)| indent)
                    .unwrap_or_default();
                let row = rows_by_indent_size[&indent_size][0];
@@ -7068,10 +7048,6 @@ impl Editor {
                should_rewrap = true;
            }

-            if !should_rewrap {
-                continue;
-            }
-
            if selection.is_empty() {
                'expand_upwards: while start_row > 0 {
                    let prev_row = start_row - 1;
@@ -7096,6 +7072,10 @@ impl Editor {
                }
            }

+            if !should_rewrap {
+                continue;
+            }
+
            let start = Point::new(start_row, 0);
            let end = Point::new(end_row, buffer.line_len(MultiBufferRow(end_row)));
            let selection_text = buffer.text_for_range(start..end).collect::<String>();
@@ -7114,15 +7094,29 @@ impl Editor {
                continue;
            };

+            let unwrapped_text = lines_without_prefixes.join(" ");
            let wrap_column = buffer
                .settings_at(Point::new(start_row, 0), cx)
                .preferred_line_length as usize;
-            let wrapped_text = wrap_with_prefix(
-                line_prefix,
-                lines_without_prefixes.join(" "),
-                wrap_column,
-                tab_size,
-            );
+            let mut wrapped_text = String::new();
+            let mut current_line = line_prefix.clone();
+            for word in unwrapped_text.split_whitespace() {
+                if current_line.len() + word.len() >= wrap_column {
+                    wrapped_text.push_str(&current_line);
+                    wrapped_text.push('\n');
+                    current_line.truncate(line_prefix.len());
+                }
+
+                if current_line.len() > line_prefix.len() {
+                    current_line.push(' ');
+                }
+
+                current_line.push_str(word);
+            }
+
+            if !current_line.is_empty() {
+                wrapped_text.push_str(&current_line);
+            }

            let diff = TextDiff::from_lines(&selection_text, &wrapped_text);
            let mut offset = start.to_offset(&buffer);
@@ -7283,14 +7277,9 @@ impl Editor {
                if clipboard_selections.len() != old_selections.len() {
                    clipboard_selections.drain(..);
                }
-                let cursor_offset = this.selections.last::<usize>(cx).head();
-                let mut auto_indent_on_paste = true;

                this.buffer.update(cx, |buffer, cx| {
                    let snapshot = buffer.read(cx);
-                    auto_indent_on_paste =
-                        snapshot.settings_at(cursor_offset, cx).auto_indent_on_paste;
-
                    let mut start_offset = 0;
                    let mut edits = Vec::new();
                    let mut original_indent_columns = Vec::new();
@@ -7329,13 +7318,9 @@ impl Editor {

                    buffer.edit(
                        edits,
-                        if auto_indent_on_paste {
-                            Some(AutoindentMode::Block {
-                                original_indent_columns,
-                            })
-                        } else {
-                            None
-                        },
+                        Some(AutoindentMode::Block {
+                            original_indent_columns,
+                        }),
                        cx,
                    );
                });
@@ -7478,11 +7463,12 @@ impl Editor {
                if !selection.is_empty() && !line_mode {
                    selection.goal = SelectionGoal::None;
                }
-                let (cursor, goal) = movement::up(
+                let (cursor, goal) = movement::up2(
                    map,
                    selection.start,
                    selection.goal,
                    false,
+                    false,
                    text_layout_details,
                );
                selection.collapse_to(cursor, goal);
@@ -7643,8 +7629,16 @@ impl Editor {
    pub fn select_up(&mut self, _: &SelectUp, cx: &mut ViewContext<Self>) {
        let text_layout_details = &self.text_layout_details(cx);
        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
-            s.move_heads_with(|map, head, goal| {
-                movement::up(map, head, goal, false, text_layout_details)
+            s.move_with(|map, selection| {
+                let (head, goal) = movement::up2(
+                    map,
+                    selection.head(),
+                    selection.goal,
+                    false,
+                    !selection.reversed,
+                    text_layout_details,
+                );
+                selection.set_head(head, goal);
            })
        })
    }
@@ -8270,7 +8264,7 @@ impl Editor {
                to_unfold.push(selection.start..selection.end);
            }
        }
-        self.unfold_ranges(&to_unfold, true, true, cx);
+        self.unfold_ranges(to_unfold, true, true, cx);
        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
            s.select_ranges(new_selection_ranges);
        });
@@ -8401,7 +8395,7 @@ impl Editor {
            auto_scroll: Option<Autoscroll>,
            cx: &mut ViewContext<Editor>,
        ) {
-            this.unfold_ranges(&[range.clone()], false, true, cx);
+            this.unfold_ranges([range.clone()], false, true, cx);
            this.change_selections(auto_scroll, cx, |s| {
                if replace_newest {
                    s.delete(s.newest_anchor().id);
@@ -8612,10 +8606,7 @@ impl Editor {

        select_next_state.done = true;
        self.unfold_ranges(
-            &new_selections
-                .iter()
-                .map(|selection| selection.range())
-                .collect::<Vec<_>>(),
+            new_selections.iter().map(|selection| selection.range()),
            false,
            false,
            cx,
@@ -8684,7 +8675,7 @@ impl Editor {
                }

                if let Some(next_selected_range) = next_selected_range {
-                    self.unfold_ranges(&[next_selected_range.clone()], false, true, cx);
+                    self.unfold_ranges([next_selected_range.clone()], false, true, cx);
                    self.change_selections(Some(Autoscroll::newest()), cx, |s| {
                        if action.replace_newest {
                            s.delete(s.newest_anchor().id);
@@ -8761,7 +8752,7 @@ impl Editor {
                }

                self.unfold_ranges(
-                    &selections.iter().map(|s| s.range()).collect::<Vec<_>>(),
+                    selections.iter().map(|s| s.range()).collect::<Vec<_>>(),
                    false,
                    true,
                    cx,
@@ -11003,7 +10994,7 @@ impl Editor {
            })
            .collect::<Vec<_>>();

-        self.unfold_ranges(&ranges, true, true, cx);
+        self.unfold_ranges(ranges, true, true, cx);
    }

    pub fn unfold_recursive(&mut self, _: &UnfoldRecursive, cx: &mut ViewContext<Self>) {
@@ -11021,7 +11012,7 @@ impl Editor {
            })
            .collect::<Vec<_>>();

-        self.unfold_ranges(&ranges, true, true, cx);
+        self.unfold_ranges(ranges, true, true, cx);
    }

    pub fn unfold_at(&mut self, unfold_at: &UnfoldAt, cx: &mut ViewContext<Self>) {
@@ -11039,13 +11030,13 @@ impl Editor {
            .iter()
            .any(|selection| RangeExt::overlaps(&selection.range(), &intersection_range));

-        self.unfold_ranges(&[intersection_range], true, autoscroll, cx)
+        self.unfold_ranges(std::iter::once(intersection_range), true, autoscroll, cx)
    }

    pub fn unfold_all(&mut self, _: &actions::UnfoldAll, cx: &mut ViewContext<Self>) {
        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
        self.unfold_ranges(
-            &[Point::zero()..display_map.max_point().to_point(&display_map)],
+            [Point::zero()..display_map.max_point().to_point(&display_map)],
            true,
            true,
            cx,
@@ -11121,63 +11112,39 @@ impl Editor {
        }
    }

-    /// Removes any folds whose ranges intersect any of the given ranges.
    pub fn unfold_ranges<T: ToOffset + Clone>(
        &mut self,
-        ranges: &[Range<T>],
+        ranges: impl IntoIterator<Item = Range<T>>,
        inclusive: bool,
        auto_scroll: bool,
        cx: &mut ViewContext<Self>,
    ) {
-        self.remove_folds_with(ranges, auto_scroll, cx, |map, cx| {
-            map.unfold_intersecting(ranges.iter().cloned(), inclusive, cx)
-        });
-    }
-
-    /// Removes any folds with the given ranges.
-    pub fn remove_folds_with_type<T: ToOffset + Clone>(
-        &mut self,
-        ranges: &[Range<T>],
-        type_id: TypeId,
-        auto_scroll: bool,
-        cx: &mut ViewContext<Self>,
-    ) {
-        self.remove_folds_with(ranges, auto_scroll, cx, |map, cx| {
-            map.remove_folds_with_type(ranges.iter().cloned(), type_id, cx)
-        });
-    }
-
-    fn remove_folds_with<T: ToOffset + Clone>(
-        &mut self,
-        ranges: &[Range<T>],
-        auto_scroll: bool,
-        cx: &mut ViewContext<Self>,
-        update: impl FnOnce(&mut DisplayMap, &mut ModelContext<DisplayMap>),
-    ) {
-        if ranges.is_empty() {
-            return;
-        }
-
+        let mut unfold_ranges = Vec::new();
        let mut buffers_affected = HashMap::default();
        let multi_buffer = self.buffer().read(cx);
        for range in ranges {
            if let Some((_, buffer, _)) = multi_buffer.excerpt_containing(range.start.clone(), cx) {
                buffers_affected.insert(buffer.read(cx).remote_id(), buffer);
            };
+            unfold_ranges.push(range);
        }

-        self.display_map.update(cx, update);
-        if auto_scroll {
-            self.request_autoscroll(Autoscroll::fit(), cx);
-        }
+        let mut ranges = unfold_ranges.into_iter().peekable();
+        if ranges.peek().is_some() {
+            self.display_map
+                .update(cx, |map, cx| map.unfold(ranges, inclusive, cx));
+            if auto_scroll {
+                self.request_autoscroll(Autoscroll::fit(), cx);
+            }

-        for buffer in buffers_affected.into_values() {
-            self.sync_expanded_diff_hunks(buffer, cx);
-        }
+            for buffer in buffers_affected.into_values() {
+                self.sync_expanded_diff_hunks(buffer, cx);
+            }

-        cx.notify();
-        self.scrollbar_marker_state.dirty = true;
-        self.active_indent_guides_state.dirty = true;
+            cx.notify();
+            self.scrollbar_marker_state.dirty = true;
+            self.active_indent_guides_state.dirty = true;
+        }
    }

    pub fn default_fold_placeholder(&self, cx: &AppContext) -> FoldPlaceholder {
@@ -12580,11 +12547,11 @@ impl Editor {
        });
    }

-    pub fn open_excerpts_in_split(&mut self, _: &OpenExcerptsSplit, cx: &mut ViewContext<Self>) {
+    fn open_excerpts_in_split(&mut self, _: &OpenExcerptsSplit, cx: &mut ViewContext<Self>) {
        self.open_excerpts_common(true, cx)
    }

-    pub fn open_excerpts(&mut self, _: &OpenExcerpts, cx: &mut ViewContext<Self>) {
+    fn open_excerpts(&mut self, _: &OpenExcerpts, cx: &mut ViewContext<Self>) {
        self.open_excerpts_common(false, cx)
    }

@@ -13086,289 +13053,6 @@ impl Editor {
    }
 }

-fn char_len_with_expanded_tabs(offset: usize, text: &str, tab_size: NonZeroU32) -> usize {
-    let tab_size = tab_size.get() as usize;
-    let mut width = offset;
-
-    for ch in text.chars() {
-        width += if ch == '\t' {
-            tab_size - (width % tab_size)
-        } else {
-            1
-        };
-    }
-
-    width - offset
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_string_size_with_expanded_tabs() {
-        let nz = |val| NonZeroU32::new(val).unwrap();
-        assert_eq!(char_len_with_expanded_tabs(0, "", nz(4)), 0);
-        assert_eq!(char_len_with_expanded_tabs(0, "hello", nz(4)), 5);
-        assert_eq!(char_len_with_expanded_tabs(0, "\thello", nz(4)), 9);
-        assert_eq!(char_len_with_expanded_tabs(0, "abc\tab", nz(4)), 6);
-        assert_eq!(char_len_with_expanded_tabs(0, "hello\t", nz(4)), 8);
-        assert_eq!(char_len_with_expanded_tabs(0, "\t\t", nz(8)), 16);
-        assert_eq!(char_len_with_expanded_tabs(0, "x\t", nz(8)), 8);
-        assert_eq!(char_len_with_expanded_tabs(7, "x\t", nz(8)), 9);
-    }
-}
-
-/// Tokenizes a string into runs of text that should stick together, or that is whitespace.
-struct WordBreakingTokenizer<'a> {
-    input: &'a str,
-}
-
-impl<'a> WordBreakingTokenizer<'a> {
-    fn new(input: &'a str) -> Self {
-        Self { input }
-    }
-}
-
-fn is_char_ideographic(ch: char) -> bool {
-    use unicode_script::Script::*;
-    use unicode_script::UnicodeScript;
-    matches!(ch.script(), Han | Tangut | Yi)
-}
-
-fn is_grapheme_ideographic(text: &str) -> bool {
-    text.chars().any(is_char_ideographic)
-}
-
-fn is_grapheme_whitespace(text: &str) -> bool {
-    text.chars().any(|x| x.is_whitespace())
-}
-
-fn should_stay_with_preceding_ideograph(text: &str) -> bool {
-    text.chars().next().map_or(false, |ch| {
-        matches!(ch, '。' | '、' | '，' | '？' | '！' | '：' | '；' | '…')
-    })
-}
-
-#[derive(PartialEq, Eq, Debug, Clone, Copy)]
-struct WordBreakToken<'a> {
-    token: &'a str,
-    grapheme_len: usize,
-    is_whitespace: bool,
-}
-
-impl<'a> Iterator for WordBreakingTokenizer<'a> {
-    /// Yields a span, the count of graphemes in the token, and whether it was
-    /// whitespace. Note that it also breaks at word boundaries.
-    type Item = WordBreakToken<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        use unicode_segmentation::UnicodeSegmentation;
-        if self.input.is_empty() {
-            return None;
-        }
-
-        let mut iter = self.input.graphemes(true).peekable();
-        let mut offset = 0;
-        let mut graphemes = 0;
-        if let Some(first_grapheme) = iter.next() {
-            let is_whitespace = is_grapheme_whitespace(first_grapheme);
-            offset += first_grapheme.len();
-            graphemes += 1;
-            if is_grapheme_ideographic(first_grapheme) && !is_whitespace {
-                if let Some(grapheme) = iter.peek().copied() {
-                    if should_stay_with_preceding_ideograph(grapheme) {
-                        offset += grapheme.len();
-                        graphemes += 1;
-                    }
-                }
-            } else {
-                let mut words = self.input[offset..].split_word_bound_indices().peekable();
-                let mut next_word_bound = words.peek().copied();
-                if next_word_bound.map_or(false, |(i, _)| i == 0) {
-                    next_word_bound = words.next();
-                }
-                while let Some(grapheme) = iter.peek().copied() {
-                    if next_word_bound.map_or(false, |(i, _)| i == offset) {
-                        break;
-                    };
-                    if is_grapheme_whitespace(grapheme) != is_whitespace {
-                        break;
-                    };
-                    offset += grapheme.len();
-                    graphemes += 1;
-                    iter.next();
-                }
-            }
-            let token = &self.input[..offset];
-            self.input = &self.input[offset..];
-            if is_whitespace {
-                Some(WordBreakToken {
-                    token: " ",
-                    grapheme_len: 1,
-                    is_whitespace: true,
-                })
-            } else {
-                Some(WordBreakToken {
-                    token,
-                    grapheme_len: graphemes,
-                    is_whitespace: false,
-                })
-            }
-        } else {
-            None
-        }
-    }
-}
-
-#[test]
-fn test_word_breaking_tokenizer() {
-    let tests: &[(&str, &[(&str, usize, bool)])] = &[
-        ("", &[]),
-        ("  ", &[(" ", 1, true)]),
-        ("Ʒ", &[("Ʒ", 1, false)]),
-        ("Ǽ", &[("Ǽ", 1, false)]),
-        ("⋑", &[("⋑", 1, false)]),
-        ("⋑⋑", &[("⋑⋑", 2, false)]),
-        (
-            "原理，进而",
-            &[
-                ("原", 1, false),
-                ("理，", 2, false),
-                ("进", 1, false),
-                ("而", 1, false),
-            ],
-        ),
-        (
-            "hello world",
-            &[("hello", 5, false), (" ", 1, true), ("world", 5, false)],
-        ),
-        (
-            "hello, world",
-            &[("hello,", 6, false), (" ", 1, true), ("world", 5, false)],
-        ),
-        (
-            "  hello world",
-            &[
-                (" ", 1, true),
-                ("hello", 5, false),
-                (" ", 1, true),
-                ("world", 5, false),
-            ],
-        ),
-        (
-            "这是什么 \n 钢笔",
-            &[
-                ("这", 1, false),
-                ("是", 1, false),
-                ("什", 1, false),
-                ("么", 1, false),
-                (" ", 1, true),
-                ("钢", 1, false),
-                ("笔", 1, false),
-            ],
-        ),
-        (" mutton", &[(" ", 1, true), ("mutton", 6, false)]),
-    ];
-
-    for (input, result) in tests {
-        assert_eq!(
-            WordBreakingTokenizer::new(input).collect::<Vec<_>>(),
-            result
-                .iter()
-                .copied()
-                .map(|(token, grapheme_len, is_whitespace)| WordBreakToken {
-                    token,
-                    grapheme_len,
-                    is_whitespace,
-                })
-                .collect::<Vec<_>>()
-        );
-    }
-}
-
-fn wrap_with_prefix(
-    line_prefix: String,
-    unwrapped_text: String,
-    wrap_column: usize,
-    tab_size: NonZeroU32,
-) -> String {
-    let line_prefix_len = char_len_with_expanded_tabs(0, &line_prefix, tab_size);
-    let mut wrapped_text = String::new();
-    let mut current_line = line_prefix.clone();
-
-    let tokenizer = WordBreakingTokenizer::new(&unwrapped_text);
-    let mut current_line_len = line_prefix_len;
-    for WordBreakToken {
-        token,
-        grapheme_len,
-        is_whitespace,
-    } in tokenizer
-    {
-        if current_line_len + grapheme_len > wrap_column && current_line_len != line_prefix_len {
-            wrapped_text.push_str(current_line.trim_end());
-            wrapped_text.push('\n');
-            current_line.truncate(line_prefix.len());
-            current_line_len = line_prefix_len;
-            if !is_whitespace {
-                current_line.push_str(token);
-                current_line_len += grapheme_len;
-            }
-        } else if !is_whitespace {
-            current_line.push_str(token);
-            current_line_len += grapheme_len;
-        } else if current_line_len != line_prefix_len {
-            current_line.push(' ');
-            current_line_len += 1;
-        }
-    }
-
-    if !current_line.is_empty() {
-        wrapped_text.push_str(&current_line);
-    }
-    wrapped_text
-}
-
-#[test]
-fn test_wrap_with_prefix() {
-    assert_eq!(
-        wrap_with_prefix(
-            "# ".to_string(),
-            "abcdefg".to_string(),
-            4,
-            NonZeroU32::new(4).unwrap()
-        ),
-        "# abcdefg"
-    );
-    assert_eq!(
-        wrap_with_prefix(
-            "".to_string(),
-            "\thello world".to_string(),
-            8,
-            NonZeroU32::new(4).unwrap()
-        ),
-        "hello\nworld"
-    );
-    assert_eq!(
-        wrap_with_prefix(
-            "// ".to_string(),
-            "xx \nyy zz aa bb cc".to_string(),
-            12,
-            NonZeroU32::new(4).unwrap()
-        ),
-        "// xx yy zz\n// aa bb cc"
-    );
-    assert_eq!(
-        wrap_with_prefix(
-            String::new(),
-            "这是什么 \n 钢笔".to_string(),
-            3,
-            NonZeroU32::new(4).unwrap()
-        ),
-        "这是什\n么 钢\n笔"
-    );
-}
-
 fn hunks_for_selections(
    multi_buffer_snapshot: &MultiBufferSnapshot,
    selections: &[Selection<Anchor>],
@@ -13868,7 +13552,7 @@ fn consume_contiguous_rows(
    contiguous_row_selections: &mut Vec<Selection<Point>>,
    selection: &Selection<Point>,
    display_map: &DisplaySnapshot,
-    selections: &mut Peekable<std::slice::Iter<Selection<Point>>>,
+    selections: &mut std::iter::Peekable<std::slice::Iter<Selection<Point>>>,
 ) -> (MultiBufferRow, MultiBufferRow) {
    contiguous_row_selections.push(selection.clone());
    let start_row = MultiBufferRow(selection.start.row);
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -169,12 +169,8 @@ fn test_undo_redo_with_selection_restoration(cx: &mut TestAppContext) {
    init_test(cx, |_| {});

    let mut now = Instant::now();
-    let group_interval = Duration::from_millis(1);
-    let buffer = cx.new_model(|cx| {
-        let mut buf = language::Buffer::local("123456", cx);
-        buf.set_group_interval(group_interval);
-        buf
-    });
+    let buffer = cx.new_model(|cx| language::Buffer::local("123456", cx));
+    let group_interval = buffer.update(cx, |buffer, _| buffer.transaction_group_interval());
    let buffer = cx.new_model(|cx| MultiBuffer::singleton(buffer, cx));
    let editor = cx.add_window(|cx| build_editor(buffer.clone(), cx));

@@ -3993,76 +3989,6 @@ fn test_move_line_up_down_with_blocks(cx: &mut TestAppContext) {
    });
 }

-#[gpui::test]
-async fn test_selections_and_replace_blocks(cx: &mut TestAppContext) {
-    init_test(cx, |_| {});
-
-    let mut cx = EditorTestContext::new(cx).await;
-    cx.set_state(
-        &"
-            ˇzero
-            one
-            two
-            three
-            four
-            five
-        "
-        .unindent(),
-    );
-
-    // Create a four-line block that replaces three lines of text.
-    cx.update_editor(|editor, cx| {
-        let snapshot = editor.snapshot(cx);
-        let snapshot = &snapshot.buffer_snapshot;
-        let placement = BlockPlacement::Replace(
-            snapshot.anchor_after(Point::new(1, 0))..snapshot.anchor_after(Point::new(3, 0)),
-        );
-        editor.insert_blocks(
-            [BlockProperties {
-                placement,
-                height: 4,
-                style: BlockStyle::Sticky,
-                render: Box::new(|_| gpui::div().into_any_element()),
-                priority: 0,
-            }],
-            None,
-            cx,
-        );
-    });
-
-    // Move down so that the cursor touches the block.
-    cx.update_editor(|editor, cx| {
-        editor.move_down(&Default::default(), cx);
-    });
-    cx.assert_editor_state(
-        &"
-            zero
-            «one
-            two
-            threeˇ»
-            four
-            five
-        "
-        .unindent(),
-    );
-
-    // Move down past the block.
-    cx.update_editor(|editor, cx| {
-        editor.move_down(&Default::default(), cx);
-    });
-    cx.assert_editor_state(
-        &"
-            zero
-            one
-            two
-            three
-            ˇfour
-            five
-        "
-        .unindent(),
-    );
-}
-
 #[gpui::test]
 fn test_transpose(cx: &mut TestAppContext) {
    init_test(cx, |_| {});
@@ -4256,7 +4182,7 @@ async fn test_rewrap(cx: &mut TestAppContext) {
            // et porta nunc laoreet in. Integer sit amet scelerisque nisi. Lorem ipsum
            // dolor sit amet, consectetur adipiscing elit. Cras egestas porta metus, eu
            // viverra ipsum efficitur quis. Donec luctus eros turpis, id vulputate turpis
-            // porttitor id. Aliquam id accumsan eros.ˇ
+            // porttitor id. Aliquam id accumsan eros.ˇˇˇˇ
        "};

        cx.set_state(unwrapped_text);
@@ -4286,7 +4212,7 @@ async fn test_rewrap(cx: &mut TestAppContext) {
        let wrapped_text = indoc! {"
            // Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus mollis elit
            // purus, a ornare lacus gravida vitae. Proin consectetur felis vel purus
-            // auctor, eu lacinia sapien scelerisque.ˇ
+            // auctor, eu lacinia sapien scelerisque.ˇˇ
            //
            // Vivamus sit amet neque et quam tincidunt hendrerit. Praesent semper egestas
            // tellus id dignissim. Pellentesque odio lectus, iaculis ac volutpat et,
@@ -4294,7 +4220,7 @@ async fn test_rewrap(cx: &mut TestAppContext) {
            // molestie blandit quam, et porta nunc laoreet in. Integer sit amet scelerisque
            // nisi. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras egestas
            // porta metus, eu viverra ipsum efficitur quis. Donec luctus eros turpis, id
-            // vulputate turpis porttitor id. Aliquam id accumsan eros.ˇ
+            // vulputate turpis porttitor id. Aliquam id accumsan eros.ˇˇ
        "};

        cx.set_state(unwrapped_text);
@@ -8389,74 +8315,6 @@ async fn test_completion_page_up_down_keys(cx: &mut gpui::TestAppContext) {
    });
 }

-#[gpui::test]
-async fn test_completion_sort(cx: &mut gpui::TestAppContext) {
-    init_test(cx, |_| {});
-    let mut cx = EditorLspTestContext::new_rust(
-        lsp::ServerCapabilities {
-            completion_provider: Some(lsp::CompletionOptions {
-                trigger_characters: Some(vec![".".to_string()]),
-                ..Default::default()
-            }),
-            ..Default::default()
-        },
-        cx,
-    )
-    .await;
-    cx.lsp
-        .handle_request::<lsp::request::Completion, _, _>(move |_, _| async move {
-            Ok(Some(lsp::CompletionResponse::Array(vec![
-                lsp::CompletionItem {
-                    label: "Range".into(),
-                    sort_text: Some("a".into()),
-                    ..Default::default()
-                },
-                lsp::CompletionItem {
-                    label: "r".into(),
-                    sort_text: Some("b".into()),
-                    ..Default::default()
-                },
-                lsp::CompletionItem {
-                    label: "ret".into(),
-                    sort_text: Some("c".into()),
-                    ..Default::default()
-                },
-                lsp::CompletionItem {
-                    label: "return".into(),
-                    sort_text: Some("d".into()),
-                    ..Default::default()
-                },
-                lsp::CompletionItem {
-                    label: "slice".into(),
-                    sort_text: Some("d".into()),
-                    ..Default::default()
-                },
-            ])))
-        });
-    cx.set_state("rˇ");
-    cx.executor().run_until_parked();
-    cx.update_editor(|editor, cx| {
-        editor.show_completions(
-            &ShowCompletions {
-                trigger: Some("r".into()),
-            },
-            cx,
-        );
-    });
-    cx.executor().run_until_parked();
-
-    cx.update_editor(|editor, _| {
-        if let Some(ContextMenu::Completions(menu)) = editor.context_menu.read().as_ref() {
-            assert_eq!(
-                menu.matches.iter().map(|m| &m.string).collect::<Vec<_>>(),
-                &["r", "ret", "Range", "return"]
-            );
-        } else {
-            panic!("expected completion menu to be open");
-        }
-    });
-}
-
 #[gpui::test]
 async fn test_no_duplicated_completion_requests(cx: &mut gpui::TestAppContext) {
    init_test(cx, |_| {});
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -25,7 +25,7 @@ use crate::{
    MULTI_BUFFER_EXCERPT_HEADER_HEIGHT,
 };
 use client::ParticipantIndex;
-use collections::{BTreeMap, HashMap, HashSet};
+use collections::{BTreeMap, HashMap};
 use git::{blame::BlameEntry, diff::DiffHunkStatus, Oid};
 use gpui::Subscription;
 use gpui::{
@@ -809,12 +809,10 @@ impl EditorElement {
        cx.notify()
    }

-    #[allow(clippy::too_many_arguments)]
    fn layout_selections(
        &self,
        start_anchor: Anchor,
        end_anchor: Anchor,
-        local_selections: &[Selection<Point>],
        snapshot: &EditorSnapshot,
        start_row: DisplayRow,
        end_row: DisplayRow,
@@ -829,9 +827,13 @@ impl EditorElement {
        let mut newest_selection_head = None;
        self.editor.update(cx, |editor, cx| {
            if editor.show_local_selections {
+                let mut local_selections: Vec<Selection<Point>> = editor
+                    .selections
+                    .disjoint_in_range(start_anchor..end_anchor, cx);
+                local_selections.extend(editor.selections.pending(cx));
                let mut layouts = Vec::new();
                let newest = editor.selections.newest(cx);
-                for selection in local_selections.iter().cloned() {
+                for selection in local_selections.drain(..) {
                    let is_empty = selection.start == selection.end;
                    let is_newest = selection == newest;

@@ -994,7 +996,6 @@ impl EditorElement {
        &self,
        snapshot: &EditorSnapshot,
        selections: &[(PlayerColor, Vec<SelectionLayout>)],
-        block_start_rows: &HashSet<DisplayRow>,
        visible_display_row_range: Range<DisplayRow>,
        line_layouts: &[LineWithInvisibles],
        text_hitbox: &Hitbox,
@@ -1014,10 +1015,7 @@ impl EditorElement {
                    let cursor_position = selection.head;

                    let in_range = visible_display_row_range.contains(&cursor_position.row());
-                    if (selection.is_local && !editor.show_local_cursors(cx))
-                        || !in_range
-                        || block_start_rows.contains(&cursor_position.row())
-                    {
+                    if (selection.is_local && !editor.show_local_cursors(cx)) || !in_range {
                        continue;
                    }

@@ -1968,10 +1966,10 @@ impl EditorElement {

    fn layout_lines(
        rows: Range<DisplayRow>,
+        line_number_layouts: &[Option<ShapedLine>],
        snapshot: &EditorSnapshot,
        style: &EditorStyle,
        editor_width: Pixels,
-        is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
        cx: &mut WindowContext,
    ) -> Vec<LineWithInvisibles> {
        if rows.start >= rows.end {
@@ -2020,9 +2018,9 @@ impl EditorElement {
                &style.text,
                MAX_LINE_LEN,
                rows.len(),
+                line_number_layouts,
                snapshot.mode,
                editor_width,
-                is_row_soft_wrapped,
                cx,
            )
        }
@@ -2070,43 +2068,24 @@ impl EditorElement {
        editor_width: Pixels,
        scroll_width: &mut Pixels,
        resized_blocks: &mut HashMap<CustomBlockId, u32>,
-        selections: &[Selection<Point>],
-        is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
+        active_rows: &BTreeMap<DisplayRow, bool>,
        cx: &mut WindowContext,
    ) -> (AnyElement, Size<Pixels>) {
        let mut element = match block {
            Block::Custom(block) => {
-                let block_start = block.start().to_point(&snapshot.buffer_snapshot);
-                let block_end = block.end().to_point(&snapshot.buffer_snapshot);
-                let align_to = block_start.to_display_point(snapshot);
+                let align_to = block
+                    .start()
+                    .to_point(&snapshot.buffer_snapshot)
+                    .to_display_point(snapshot);
                let anchor_x = text_x
                    + if rows.contains(&align_to.row()) {
                        line_layouts[align_to.row().minus(rows.start) as usize]
                            .x_for_index(align_to.column() as usize)
                    } else {
-                        layout_line(
-                            align_to.row(),
-                            snapshot,
-                            &self.style,
-                            editor_width,
-                            is_row_soft_wrapped,
-                            cx,
-                        )
-                        .x_for_index(align_to.column() as usize)
+                        layout_line(align_to.row(), snapshot, &self.style, editor_width, cx)
+                            .x_for_index(align_to.column() as usize)
                    };

-                let selected = selections
-                    .binary_search_by(|selection| {
-                        if selection.end <= block_start {
-                            Ordering::Less
-                        } else if selection.start >= block_end {
-                            Ordering::Greater
-                        } else {
-                            Ordering::Equal
-                        }
-                    })
-                    .is_ok();
-
                div()
                    .size_full()
                    .child(block.render(&mut BlockContext {
@@ -2116,7 +2095,7 @@ impl EditorElement {
                        line_height,
                        em_width,
                        block_id,
-                        selected,
+                        selected: active_rows.contains_key(&block_row_start),
                        max_width: text_hitbox.size.width.max(*scroll_width),
                        editor_style: &self.style,
                    }))
@@ -2454,8 +2433,7 @@ impl EditorElement {
        text_x: Pixels,
        line_height: Pixels,
        line_layouts: &[LineWithInvisibles],
-        selections: &[Selection<Point>],
-        is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
+        active_rows: &BTreeMap<DisplayRow, bool>,
        cx: &mut WindowContext,
    ) -> Result<Vec<BlockLayout>, HashMap<CustomBlockId, u32>> {
        let (fixed_blocks, non_fixed_blocks) = snapshot
@@ -2492,8 +2470,7 @@ impl EditorElement {
                editor_width,
                scroll_width,
                &mut resized_blocks,
-                selections,
-                is_row_soft_wrapped,
+                active_rows,
                cx,
            );
            fixed_block_max_width = fixed_block_max_width.max(element_size.width + em_width);
@@ -2538,8 +2515,7 @@ impl EditorElement {
                editor_width,
                scroll_width,
                &mut resized_blocks,
-                selections,
-                is_row_soft_wrapped,
+                active_rows,
                cx,
            );

@@ -2585,8 +2561,7 @@ impl EditorElement {
                            editor_width,
                            scroll_width,
                            &mut resized_blocks,
-                            selections,
-                            is_row_soft_wrapped,
+                            active_rows,
                            cx,
                        );

@@ -2615,7 +2590,6 @@ impl EditorElement {
    fn layout_blocks(
        &self,
        blocks: &mut Vec<BlockLayout>,
-        block_starts: &mut HashSet<DisplayRow>,
        hitbox: &Hitbox,
        line_height: Pixels,
        scroll_pixel_position: gpui::Point<Pixels>,
@@ -2623,7 +2597,6 @@ impl EditorElement {
    ) {
        for block in blocks {
            let mut origin = if let Some(row) = block.row {
-                block_starts.insert(row);
                hitbox.origin
                    + point(
                        Pixels::ZERO,
@@ -4371,9 +4344,9 @@ impl LineWithInvisibles {
        text_style: &TextStyle,
        max_line_len: usize,
        max_line_count: usize,
+        line_number_layouts: &[Option<ShapedLine>],
        editor_mode: EditorMode,
        text_width: Pixels,
-        is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
        cx: &mut WindowContext,
    ) -> Vec<Self> {
        let mut layouts = Vec::with_capacity(max_line_count);
@@ -4501,9 +4474,12 @@ impl LineWithInvisibles {
                        if editor_mode == EditorMode::Full {
                            // Line wrap pads its contents with fake whitespaces,
                            // avoid printing them
-                            let is_soft_wrapped = is_row_soft_wrapped(row);
+                            let inside_wrapped_string = line_number_layouts
+                                .get(row)
+                                .and_then(|layout| layout.as_ref())
+                                .is_none();
                            if highlighted_chunk.is_tab {
-                                if non_whitespace_added || !is_soft_wrapped {
+                                if non_whitespace_added || !inside_wrapped_string {
                                    invisibles.push(Invisible::Tab {
                                        line_start_offset: line.len(),
                                        line_end_offset: line.len() + line_chunk.len(),
@@ -4519,7 +4495,7 @@ impl LineWithInvisibles {
                                                (*line_byte as char).is_whitespace();
                                            non_whitespace_added |= !is_whitespace;
                                            is_whitespace
-                                                && (non_whitespace_added || !is_soft_wrapped)
+                                                && (non_whitespace_added || !inside_wrapped_string)
                                        })
                                        .map(|(whitespace_index, _)| Invisible::Whitespace {
                                            line_offset: line.len() + whitespace_index,
@@ -4882,10 +4858,10 @@ impl Element for EditorElement {
                                    editor_handle.update(cx, |editor, cx| editor.snapshot(cx));
                                let line = Self::layout_lines(
                                    DisplayRow(0)..DisplayRow(1),
+                                    &[],
                                    &editor_snapshot,
                                    &style,
                                    px(f32::MAX),
-                                    |_| false, // Single lines never soft wrap
                                    cx,
                                )
                                .pop()
@@ -5094,8 +5070,6 @@ impl Element for EditorElement {
                        .buffer_rows(start_row)
                        .take((start_row..end_row).len())
                        .collect::<Vec<_>>();
-                    let is_row_soft_wrapped =
-                        |row| buffer_rows.get(row).copied().flatten().is_none();

                    let start_anchor = if start_row == Default::default() {
                        Anchor::min()
@@ -5133,19 +5107,9 @@ impl Element for EditorElement {
                        cx,
                    );

-                    let local_selections: Vec<Selection<Point>> =
-                        self.editor.update(cx, |editor, cx| {
-                            let mut selections = editor
-                                .selections
-                                .disjoint_in_range(start_anchor..end_anchor, cx);
-                            selections.extend(editor.selections.pending(cx));
-                            selections
-                        });
-
                    let (selections, active_rows, newest_selection_head) = self.layout_selections(
                        start_anchor,
                        end_anchor,
-                        &local_selections,
                        &snapshot,
                        start_row,
                        end_row,
@@ -5187,10 +5151,10 @@ impl Element for EditorElement {
                    let mut max_visible_line_width = Pixels::ZERO;
                    let mut line_layouts = Self::layout_lines(
                        start_row..end_row,
+                        &line_numbers,
                        &snapshot,
                        &self.style,
                        editor_width,
-                        is_row_soft_wrapped,
                        cx,
                    );
                    for line_with_invisibles in &line_layouts {
@@ -5199,15 +5163,9 @@ impl Element for EditorElement {
                        }
                    }

-                    let longest_line_width = layout_line(
-                        snapshot.longest_row(),
-                        &snapshot,
-                        &style,
-                        editor_width,
-                        is_row_soft_wrapped,
-                        cx,
-                    )
-                    .width;
+                    let longest_line_width =
+                        layout_line(snapshot.longest_row(), &snapshot, &style, editor_width, cx)
+                            .width;
                    let mut scroll_width =
                        longest_line_width.max(max_visible_line_width) + overscroll.width;

@@ -5224,8 +5182,7 @@ impl Element for EditorElement {
                            gutter_dimensions.full_width(),
                            line_height,
                            &line_layouts,
-                            &local_selections,
-                            is_row_soft_wrapped,
+                            &active_rows,
                            cx,
                        )
                    });
@@ -5365,11 +5322,9 @@ impl Element for EditorElement {
                        cx,
                    );

-                    let mut block_start_rows = HashSet::default();
                    cx.with_element_namespace("blocks", |cx| {
                        self.layout_blocks(
                            &mut blocks,
-                            &mut block_start_rows,
                            &hitbox,
                            line_height,
                            scroll_pixel_position,
@@ -5386,7 +5341,6 @@ impl Element for EditorElement {
                    let visible_cursors = self.layout_visible_cursors(
                        &snapshot,
                        &selections,
-                        &block_start_rows,
                        start_row..end_row,
                        &line_layouts,
                        &text_hitbox,
@@ -5984,7 +5938,6 @@ fn layout_line(
    snapshot: &EditorSnapshot,
    style: &EditorStyle,
    text_width: Pixels,
-    is_row_soft_wrapped: impl Copy + Fn(usize) -> bool,
    cx: &mut WindowContext,
 ) -> LineWithInvisibles {
    let chunks = snapshot.highlighted_chunks(row..row + DisplayRow(1), true, style);
@@ -5993,9 +5946,9 @@ fn layout_line(
        &style.text,
        MAX_LINE_LEN,
        1,
+        &[],
        snapshot.mode,
        text_width,
-        is_row_soft_wrapped,
        cx,
    )
    .pop()
@@ -6680,22 +6633,15 @@ mod tests {
            "Hardcoded expected invisibles differ from the actual ones in '{input_text}'"
        );

-        for show_line_numbers in [true, false] {
-            init_test(cx, |s| {
-                s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
-                s.defaults.tab_size = NonZeroU32::new(TAB_SIZE);
-            });
+        init_test(cx, |s| {
+            s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
+            s.defaults.tab_size = NonZeroU32::new(TAB_SIZE);
+        });

-            let actual_invisibles = collect_invisibles_from_new_editor(
-                cx,
-                EditorMode::Full,
-                input_text,
-                px(500.0),
-                show_line_numbers,
-            );
+        let actual_invisibles =
+            collect_invisibles_from_new_editor(cx, EditorMode::Full, input_text, px(500.0));

-            assert_eq!(expected_invisibles, actual_invisibles);
-        }
+        assert_eq!(expected_invisibles, actual_invisibles);
    }

    #[gpui::test]
@@ -6709,17 +6655,14 @@ mod tests {
            EditorMode::SingleLine { auto_width: false },
            EditorMode::AutoHeight { max_lines: 100 },
        ] {
-            for show_line_numbers in [true, false] {
-                let invisibles = collect_invisibles_from_new_editor(
-                    cx,
-                    editor_mode_without_invisibles,
-                    "\t\t\t| | a b",
-                    px(500.0),
-                    show_line_numbers,
-                );
-                assert!(invisibles.is_empty(),
+            let invisibles = collect_invisibles_from_new_editor(
+                cx,
+                editor_mode_without_invisibles,
+                "\t\t\t| | a b",
+                px(500.0),
+            );
+            assert!(invisibles.is_empty(),
                    "For editor mode {editor_mode_without_invisibles:?} no invisibles was expected but got {invisibles:?}");
-            }
        }
    }

@@ -6770,48 +6713,43 @@ mod tests {
        let resize_step = 10.0;
        let mut editor_width = 200.0;
        while editor_width <= 1000.0 {
-            for show_line_numbers in [true, false] {
-                update_test_language_settings(cx, |s| {
-                    s.defaults.tab_size = NonZeroU32::new(tab_size);
-                    s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
-                    s.defaults.preferred_line_length = Some(editor_width as u32);
-                    s.defaults.soft_wrap = Some(language_settings::SoftWrap::PreferredLineLength);
-                });
+            update_test_language_settings(cx, |s| {
+                s.defaults.tab_size = NonZeroU32::new(tab_size);
+                s.defaults.show_whitespaces = Some(ShowWhitespaceSetting::All);
+                s.defaults.preferred_line_length = Some(editor_width as u32);
+                s.defaults.soft_wrap = Some(language_settings::SoftWrap::PreferredLineLength);
+            });

-                let actual_invisibles = collect_invisibles_from_new_editor(
-                    cx,
-                    EditorMode::Full,
-                    &input_text,
-                    px(editor_width),
-                    show_line_numbers,
-                );
+            let actual_invisibles = collect_invisibles_from_new_editor(
+                cx,
+                EditorMode::Full,
+                &input_text,
+                px(editor_width),
+            );

-                // Whatever the editor size is, ensure it has the same invisible kinds in the same order
-                // (no good guarantees about the offsets: wrapping could trigger padding and its tests should check the offsets).
-                let mut i = 0;
-                for (actual_index, actual_invisible) in actual_invisibles.iter().enumerate() {
-                    i = actual_index;
-                    match expected_invisibles.get(i) {
-                        Some(expected_invisible) => match (expected_invisible, actual_invisible) {
-                            (Invisible::Whitespace { .. }, Invisible::Whitespace { .. })
-                            | (Invisible::Tab { .. }, Invisible::Tab { .. }) => {}
-                            _ => {
-                                panic!("At index {i}, expected invisible {expected_invisible:?} does not match actual {actual_invisible:?} by kind. Actual invisibles: {actual_invisibles:?}")
-                            }
-                        },
-                        None => {
-                            panic!("Unexpected extra invisible {actual_invisible:?} at index {i}")
+            // Whatever the editor size is, ensure it has the same invisible kinds in the same order
+            // (no good guarantees about the offsets: wrapping could trigger padding and its tests should check the offsets).
+            let mut i = 0;
+            for (actual_index, actual_invisible) in actual_invisibles.iter().enumerate() {
+                i = actual_index;
+                match expected_invisibles.get(i) {
+                    Some(expected_invisible) => match (expected_invisible, actual_invisible) {
+                        (Invisible::Whitespace { .. }, Invisible::Whitespace { .. })
+                        | (Invisible::Tab { .. }, Invisible::Tab { .. }) => {}
+                        _ => {
+                            panic!("At index {i}, expected invisible {expected_invisible:?} does not match actual {actual_invisible:?} by kind. Actual invisibles: {actual_invisibles:?}")
                        }
-                    }
+                    },
+                    None => panic!("Unexpected extra invisible {actual_invisible:?} at index {i}"),
                }
-                let missing_expected_invisibles = &expected_invisibles[i + 1..];
-                assert!(
-                    missing_expected_invisibles.is_empty(),
-                    "Missing expected invisibles after index {i}: {missing_expected_invisibles:?}"
-                );
-
-                editor_width += resize_step;
            }
+            let missing_expected_invisibles = &expected_invisibles[i + 1..];
+            assert!(
+                missing_expected_invisibles.is_empty(),
+                "Missing expected invisibles after index {i}: {missing_expected_invisibles:?}"
+            );
+
+            editor_width += resize_step;
        }
    }

@@ -6820,7 +6758,6 @@ mod tests {
        editor_mode: EditorMode,
        input_text: &str,
        editor_width: Pixels,
-        show_line_numbers: bool,
    ) -> Vec<Invisible> {
        info!(
            "Creating editor with mode {editor_mode:?}, width {}px and text '{input_text}'",
@@ -6832,13 +6769,11 @@ mod tests {
        });
        let cx = &mut VisualTestContext::from_window(*window, cx);
        let editor = window.root(cx).unwrap();
-
        let style = cx.update(|cx| editor.read(cx).style().unwrap().clone());
        window
            .update(cx, |editor, cx| {
                editor.set_soft_wrap_mode(language_settings::SoftWrap::EditorWidth, cx);
                editor.set_wrap_width(Some(editor_width), cx);
-                editor.set_show_line_numbers(show_line_numbers, cx);
            })
            .unwrap();
        let (_, state) = cx.draw(point(px(500.), px(500.)), size(px(500.), px(500.)), |_| {
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -7,7 +7,7 @@ use crate::{
 };
 use gpui::{
    div, px, AnyElement, AsyncWindowContext, FontWeight, Hsla, InteractiveElement, IntoElement,
-    MouseButton, ParentElement, Pixels, ScrollHandle, Size, Stateful, StatefulInteractiveElement,
+    MouseButton, ParentElement, Pixels, ScrollHandle, Size, StatefulInteractiveElement,
    StyleRefinement, Styled, Task, TextStyleRefinement, View, ViewContext,
 };
 use itertools::Itertools;
@@ -21,7 +21,7 @@ use std::rc::Rc;
 use std::{borrow::Cow, cell::RefCell};
 use std::{ops::Range, sync::Arc, time::Duration};
 use theme::ThemeSettings;
-use ui::{prelude::*, window_is_transparent, Scrollbar, ScrollbarState};
+use ui::{prelude::*, window_is_transparent};
 use util::TryFutureExt;
 pub const HOVER_DELAY_MILLIS: u64 = 350;
 pub const HOVER_REQUEST_DELAY_MILLIS: u64 = 200;
@@ -144,12 +144,10 @@ pub fn hover_at_inlay(editor: &mut Editor, inlay_hover: InlayHover, cx: &mut Vie
                let blocks = vec![inlay_hover.tooltip];
                let parsed_content = parse_blocks(&blocks, &language_registry, None, &mut cx).await;

-                let scroll_handle = ScrollHandle::new();
                let hover_popover = InfoPopover {
                    symbol_range: RangeInEditor::Inlay(inlay_hover.range.clone()),
                    parsed_content,
-                    scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
-                    scroll_handle,
+                    scroll_handle: ScrollHandle::new(),
                    keyboard_grace: Rc::new(RefCell::new(false)),
                    anchor: None,
                };
@@ -437,14 +435,12 @@ fn show_hover(
                let language = hover_result.language;
                let parsed_content =
                    parse_blocks(&blocks, &language_registry, language, &mut cx).await;
-                let scroll_handle = ScrollHandle::new();
                info_popover_tasks.push((
                    range.clone(),
                    InfoPopover {
                        symbol_range: RangeInEditor::Text(range),
                        parsed_content,
-                        scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
-                        scroll_handle,
+                        scroll_handle: ScrollHandle::new(),
                        keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
                        anchor: Some(anchor),
                    },
@@ -615,7 +611,7 @@ impl HoverState {
        !self.info_popovers.is_empty() || self.diagnostic_popover.is_some()
    }

-    pub(crate) fn render(
+    pub fn render(
        &mut self,
        snapshot: &EditorSnapshot,
        visible_rows: Range<DisplayRow>,
@@ -684,25 +680,25 @@ impl HoverState {
 }

 #[derive(Debug, Clone)]
-pub(crate) struct InfoPopover {
-    pub(crate) symbol_range: RangeInEditor,
-    pub(crate) parsed_content: Option<View<Markdown>>,
-    pub(crate) scroll_handle: ScrollHandle,
-    pub(crate) scrollbar_state: ScrollbarState,
-    pub(crate) keyboard_grace: Rc<RefCell<bool>>,
-    pub(crate) anchor: Option<Anchor>,
+
+pub struct InfoPopover {
+    pub symbol_range: RangeInEditor,
+    pub parsed_content: Option<View<Markdown>>,
+    pub scroll_handle: ScrollHandle,
+    pub keyboard_grace: Rc<RefCell<bool>>,
+    pub anchor: Option<Anchor>,
 }

 impl InfoPopover {
-    pub(crate) fn render(
-        &mut self,
-        max_size: Size<Pixels>,
-        cx: &mut ViewContext<Editor>,
-    ) -> AnyElement {
+    pub fn render(&mut self, max_size: Size<Pixels>, cx: &mut ViewContext<Editor>) -> AnyElement {
        let keyboard_grace = Rc::clone(&self.keyboard_grace);
        let mut d = div()
            .id("info_popover")
            .elevation_2(cx)
+            .overflow_y_scroll()
+            .track_scroll(&self.scroll_handle)
+            .max_w(max_size.width)
+            .max_h(max_size.height)
            // Prevent a mouse down/move on the popover from being propagated to the editor,
            // because that would dismiss the popover.
            .on_mouse_move(|_, cx| cx.stop_propagation())
@@ -710,21 +706,11 @@ impl InfoPopover {
                let mut keyboard_grace = keyboard_grace.borrow_mut();
                *keyboard_grace = false;
                cx.stop_propagation();
-            });
+            })
+            .p_2();

        if let Some(markdown) = &self.parsed_content {
-            d = d
-                .child(
-                    div()
-                        .id("info-md-container")
-                        .overflow_y_scroll()
-                        .max_w(max_size.width)
-                        .max_h(max_size.height)
-                        .p_2()
-                        .track_scroll(&self.scroll_handle)
-                        .child(markdown.clone()),
-                )
-                .child(self.render_vertical_scrollbar(cx));
+            d = d.child(markdown.clone());
        }
        d.into_any_element()
    }
@@ -738,38 +724,6 @@ impl InfoPopover {
        cx.notify();
        self.scroll_handle.set_offset(current);
    }
-    fn render_vertical_scrollbar(&self, cx: &mut ViewContext<Editor>) -> Stateful<Div> {
-        div()
-            .occlude()
-            .id("info-popover-vertical-scroll")
-            .on_mouse_move(cx.listener(|_, _, cx| {
-                cx.notify();
-                cx.stop_propagation()
-            }))
-            .on_hover(|_, cx| {
-                cx.stop_propagation();
-            })
-            .on_any_mouse_down(|_, cx| {
-                cx.stop_propagation();
-            })
-            .on_mouse_up(
-                MouseButton::Left,
-                cx.listener(|_, _, cx| {
-                    cx.stop_propagation();
-                }),
-            )
-            .on_scroll_wheel(cx.listener(|_, _, cx| {
-                cx.notify();
-            }))
-            .h_full()
-            .absolute()
-            .right_1()
-            .top_1()
-            .bottom_0()
-            .w(px(12.))
-            .cursor_default()
-            .children(Scrollbar::vertical(self.scrollbar_state.clone()))
-    }
 }

 #[derive(Debug, Clone)]
@@ -1397,61 +1351,6 @@ mod tests {
        });
    }

-    #[gpui::test]
-    // https://github.com/zed-industries/zed/issues/15498
-    async fn test_info_hover_with_hrs(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
-        let mut cx = EditorLspTestContext::new_rust(
-            lsp::ServerCapabilities {
-                hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
-                ..Default::default()
-            },
-            cx,
-        )
-        .await;
-
-        cx.set_state(indoc! {"
-            fn fuˇnc(abc def: i32) -> u32 {
-            }
-        "});
-
-        cx.lsp.handle_request::<lsp::request::HoverRequest, _, _>({
-            |_, _| async move {
-                Ok(Some(lsp::Hover {
-                    contents: lsp::HoverContents::Markup(lsp::MarkupContent {
-                        kind: lsp::MarkupKind::Markdown,
-                        value: indoc!(
-                            r#"
-                    ### function `errands_data_read`
-
-                    ---
-                    → `char *`
-                    Function to read a file into a string
-
-                    ---
-                    ```cpp
-                    static char *errands_data_read()
-                    ```
-                    "#
-                        )
-                        .to_string(),
-                    }),
-                    range: None,
-                }))
-            }
-        });
-        cx.update_editor(|editor, cx| hover(editor, &Default::default(), cx));
-        cx.run_until_parked();
-
-        cx.update_editor(|editor, cx| {
-            let popover = editor.hover_state.info_popovers.first().unwrap();
-            let content = popover.get_rendered_text(cx);
-
-            assert!(content.contains("Function to read a file"));
-        });
-    }
-
    #[gpui::test]
    async fn test_hover_inlay_label_parts(cx: &mut gpui::TestAppContext) {
        init_test(cx, |settings| {
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -992,15 +992,12 @@ impl SerializableItem for Editor {
                    };

                    // First create the empty buffer
-                    let buffer = project
-                        .update(&mut cx, |project, cx| project.create_buffer(cx))?
-                        .await?;
+                    let buffer = project.update(&mut cx, |project, cx| {
+                        project.create_local_buffer("", language, cx)
+                    })?;

                    // Then set the text so that the dirty bit is set correctly
                    buffer.update(&mut cx, |buffer, cx| {
-                        if let Some(language) = language {
-                            buffer.set_language(Some(language), cx);
-                        }
                        buffer.set_text(contents, cx);
                    })?;

@@ -1280,7 +1277,7 @@ impl SearchableItem for Editor {
        matches: &[Range<Anchor>],
        cx: &mut ViewContext<Self>,
    ) {
-        self.unfold_ranges(&[matches[index].clone()], false, true, cx);
+        self.unfold_ranges([matches[index].clone()], false, true, cx);
        let range = self.range_for_match(&matches[index]);
        self.change_selections(Some(Autoscroll::fit()), cx, |s| {
            s.select_ranges([range]);
@@ -1288,7 +1285,7 @@ impl SearchableItem for Editor {
    }

    fn select_matches(&mut self, matches: &[Self::Match], cx: &mut ViewContext<Self>) {
-        self.unfold_ranges(matches, false, false, cx);
+        self.unfold_ranges(matches.to_vec(), false, false, cx);
        let mut ranges = Vec::new();
        for m in matches {
            ranges.push(self.range_for_match(m))
--- a/crates/editor/src/linked_editing_ranges.rs
+++ b/crates/editor/src/linked_editing_ranges.rs
@@ -1,4 +1,4 @@
-use std::{ops::Range, time::Duration};
+use std::ops::Range;

 use collections::HashMap;
 use itertools::Itertools;
@@ -36,53 +36,35 @@ impl LinkedEditingRanges {
        self.0.is_empty()
    }
 }
-
-const UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
-
-// TODO do not refresh anything at all, if the settings/capabilities do not have it enabled.
-pub(super) fn refresh_linked_ranges(
-    editor: &mut Editor,
-    cx: &mut ViewContext<Editor>,
-) -> Option<()> {
-    if editor.pending_rename.is_some() {
+pub(super) fn refresh_linked_ranges(this: &mut Editor, cx: &mut ViewContext<Editor>) -> Option<()> {
+    if this.pending_rename.is_some() {
        return None;
    }
-    let project = editor.project.as_ref()?.downgrade();
-
-    editor.linked_editing_range_task = Some(cx.spawn(|editor, mut cx| async move {
-        cx.background_executor().timer(UPDATE_DEBOUNCE).await;
-
-        let mut applicable_selections = Vec::new();
-        editor
-            .update(&mut cx, |editor, cx| {
-                let selections = editor.selections.all::<usize>(cx);
-                let snapshot = editor.buffer.read(cx).snapshot(cx);
-                let buffer = editor.buffer.read(cx);
-                for selection in selections {
-                    let cursor_position = selection.head();
-                    let start_position = snapshot.anchor_before(cursor_position);
-                    let end_position = snapshot.anchor_after(selection.tail());
-                    if start_position.buffer_id != end_position.buffer_id
-                        || end_position.buffer_id.is_none()
-                    {
-                        // Throw away selections spanning multiple buffers.
-                        continue;
-                    }
-                    if let Some(buffer) = end_position.buffer_id.and_then(|id| buffer.buffer(id)) {
-                        applicable_selections.push((
-                            buffer,
-                            start_position.text_anchor,
-                            end_position.text_anchor,
-                        ));
-                    }
-                }
-            })
-            .ok()?;
-
-        if applicable_selections.is_empty() {
-            return None;
+    let project = this.project.clone()?;
+    let selections = this.selections.all::<usize>(cx);
+    let buffer = this.buffer.read(cx);
+    let mut applicable_selections = vec![];
+    let snapshot = buffer.snapshot(cx);
+    for selection in selections {
+        let cursor_position = selection.head();
+        let start_position = snapshot.anchor_before(cursor_position);
+        let end_position = snapshot.anchor_after(selection.tail());
+        if start_position.buffer_id != end_position.buffer_id || end_position.buffer_id.is_none() {
+            // Throw away selections spanning multiple buffers.
+            continue;
        }
-
+        if let Some(buffer) = end_position.buffer_id.and_then(|id| buffer.buffer(id)) {
+            applicable_selections.push((
+                buffer,
+                start_position.text_anchor,
+                end_position.text_anchor,
+            ));
+        }
+    }
+    if applicable_selections.is_empty() {
+        return None;
+    }
+    this.linked_editing_range_task = Some(cx.spawn(|this, mut cx| async move {
        let highlights = project
            .update(&mut cx, |project, cx| {
                let mut linked_edits_tasks = vec![];
@@ -128,38 +110,37 @@ pub(super) fn refresh_linked_ranges(
                }
                linked_edits_tasks
            })
-            .ok()?;
+            .log_err()?;

        let highlights = futures::future::join_all(highlights).await;

-        editor
-            .update(&mut cx, |this, cx| {
-                this.linked_edit_ranges.0.clear();
-                if this.pending_rename.is_some() {
-                    return;
-                }
-                for (buffer_id, ranges) in highlights.into_iter().flatten() {
-                    this.linked_edit_ranges
-                        .0
-                        .entry(buffer_id)
-                        .or_default()
-                        .extend(ranges);
-                }
-                for (buffer_id, values) in this.linked_edit_ranges.0.iter_mut() {
-                    let Some(snapshot) = this
-                        .buffer
-                        .read(cx)
-                        .buffer(*buffer_id)
-                        .map(|buffer| buffer.read(cx).snapshot())
-                    else {
-                        continue;
-                    };
-                    values.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0, &snapshot));
-                }
+        this.update(&mut cx, |this, cx| {
+            this.linked_edit_ranges.0.clear();
+            if this.pending_rename.is_some() {
+                return;
+            }
+            for (buffer_id, ranges) in highlights.into_iter().flatten() {
+                this.linked_edit_ranges
+                    .0
+                    .entry(buffer_id)
+                    .or_default()
+                    .extend(ranges);
+            }
+            for (buffer_id, values) in this.linked_edit_ranges.0.iter_mut() {
+                let Some(snapshot) = this
+                    .buffer
+                    .read(cx)
+                    .buffer(*buffer_id)
+                    .map(|buffer| buffer.read(cx).snapshot())
+                else {
+                    continue;
+                };
+                values.sort_by(|lhs, rhs| lhs.0.cmp(&rhs.0, &snapshot));
+            }

-                cx.notify();
-            })
-            .ok()?;
+            cx.notify();
+        })
+        .log_err();

        Some(())
    }));
--- a/crates/editor/src/movement.rs
+++ b/crates/editor/src/movement.rs
@@ -76,6 +76,26 @@ pub fn saturating_right(map: &DisplaySnapshot, mut point: DisplayPoint) -> Displ
    map.clip_point(point, Bias::Right)
 }

+/// Returns a display point for the preceding displayed line (which might be a soft-wrapped line).
+pub fn up2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    goal: SelectionGoal,
+    preserve_column_at_start: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    up_by_rows2(
+        map,
+        start,
+        1,
+        goal,
+        preserve_column_at_start,
+        skip_replace_blocks,
+        text_layout_details,
+    )
+}
+
 /// Returns a display point for the preceding displayed line (which might be a soft-wrapped line).
 pub fn up(
    map: &DisplaySnapshot,
@@ -112,6 +132,26 @@ pub fn down(
    )
 }

+/// Returns a display point for the next displayed line (which might be a soft-wrapped line).
+pub fn down2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    goal: SelectionGoal,
+    preserve_column_at_end: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    down_by_rows2(
+        map,
+        start,
+        1,
+        goal,
+        preserve_column_at_end,
+        skip_replace_blocks,
+        text_layout_details,
+    )
+}
+
 pub(crate) fn up_by_rows(
    map: &DisplaySnapshot,
    start: DisplayPoint,
@@ -151,6 +191,46 @@ pub(crate) fn up_by_rows(
    )
 }

+pub(crate) fn up_by_rows2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    row_count: u32,
+    goal: SelectionGoal,
+    preserve_column_at_start: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    let mut goal_x = match goal {
+        SelectionGoal::HorizontalPosition(x) => x.into(),
+        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
+        SelectionGoal::HorizontalRange { end, .. } => end.into(),
+        _ => map.x_for_display_point(start, text_layout_details),
+    };
+
+    let prev_row = DisplayRow(start.row().0.saturating_sub(row_count));
+    let mut point = map.clip_point(
+        DisplayPoint::new(prev_row, map.line_len(prev_row)),
+        Bias::Left,
+    );
+    if point.row() < start.row() {
+        *point.column_mut() = map.display_column_for_x(point.row(), goal_x, text_layout_details)
+    } else if preserve_column_at_start {
+        return (start, goal);
+    } else {
+        point = DisplayPoint::new(DisplayRow(0), 0);
+        goal_x = px(0.);
+    }
+
+    let mut clipped_point = map.clip_point_2(point, Bias::Left, skip_replace_blocks);
+    if clipped_point.row() < point.row() {
+        clipped_point = map.clip_point_2(point, Bias::Right, skip_replace_blocks);
+    }
+    (
+        clipped_point,
+        SelectionGoal::HorizontalPosition(goal_x.into()),
+    )
+}
+
 pub(crate) fn down_by_rows(
    map: &DisplaySnapshot,
    start: DisplayPoint,
@@ -187,6 +267,43 @@ pub(crate) fn down_by_rows(
    )
 }

+pub(crate) fn down_by_rows2(
+    map: &DisplaySnapshot,
+    start: DisplayPoint,
+    row_count: u32,
+    goal: SelectionGoal,
+    preserve_column_at_end: bool,
+    skip_replace_blocks: bool,
+    text_layout_details: &TextLayoutDetails,
+) -> (DisplayPoint, SelectionGoal) {
+    let mut goal_x = match goal {
+        SelectionGoal::HorizontalPosition(x) => x.into(),
+        SelectionGoal::WrappedHorizontalPosition((_, x)) => x.into(),
+        SelectionGoal::HorizontalRange { end, .. } => end.into(),
+        _ => map.x_for_display_point(start, text_layout_details),
+    };
+
+    let new_row = DisplayRow(start.row().0 + row_count);
+    let mut point = map.clip_point(DisplayPoint::new(new_row, 0), Bias::Right);
+    if point.row() > start.row() {
+        *point.column_mut() = map.display_column_for_x(point.row(), goal_x, text_layout_details)
+    } else if preserve_column_at_end {
+        return (start, goal);
+    } else {
+        point = map.max_point();
+        goal_x = map.x_for_display_point(point, text_layout_details)
+    }
+
+    let mut clipped_point = map.clip_point_2(point, Bias::Right, skip_replace_blocks);
+    if clipped_point.row() > point.row() {
+        clipped_point = map.clip_point_2(point, Bias::Left, skip_replace_blocks);
+    }
+    (
+        clipped_point,
+        SelectionGoal::HorizontalPosition(goal_x.into()),
+    )
+}
+
 /// Returns a position of the start of line.
 /// If `stop_at_soft_boundaries` is true, the returned position is that of the
 /// displayed line (e.g. it could actually be in the middle of a text line if that line is soft-wrapped).
--- a/crates/editor/src/selections_collection.rs
+++ b/crates/editor/src/selections_collection.rs
@@ -1,6 +1,6 @@
 use std::{
    cell::Ref,
-    cmp, iter, mem,
+    iter, mem,
    ops::{Deref, DerefMut, Range, Sub},
    sync::Arc,
 };
@@ -98,9 +98,9 @@ impl SelectionsCollection {
        &self,
        cx: &mut AppContext,
    ) -> Option<Selection<D>> {
-        let map = self.display_map(cx);
-        let selection = resolve_selections(self.pending_anchor().as_ref(), &map).next();
-        selection
+        self.pending_anchor()
+            .as_ref()
+            .map(|pending| pending.map(|p| p.summary::<D>(&self.buffer(cx))))
    }

    pub(crate) fn pending_mode(&self) -> Option<SelectMode> {
@@ -111,10 +111,12 @@ impl SelectionsCollection {
    where
        D: 'a + TextDimension + Ord + Sub<D, Output = D>,
    {
-        let map = self.display_map(cx);
        let disjoint_anchors = &self.disjoint;
-        let mut disjoint = resolve_selections::<D, _>(disjoint_anchors.iter(), &map).peekable();
+        let mut disjoint =
+            resolve_multiple::<D, _>(disjoint_anchors.iter(), &self.buffer(cx)).peekable();
+
        let mut pending_opt = self.pending::<D>(cx);
+
        iter::from_fn(move || {
            if let Some(pending) = pending_opt.as_mut() {
                while let Some(next_selection) = disjoint.peek() {
@@ -197,57 +199,34 @@ impl SelectionsCollection {
    where
        D: 'a + TextDimension + Ord + Sub<D, Output = D> + std::fmt::Debug,
    {
-        let map = self.display_map(cx);
+        let buffer = self.buffer(cx);
        let start_ix = match self
            .disjoint
-            .binary_search_by(|probe| probe.end.cmp(&range.start, &map.buffer_snapshot))
+            .binary_search_by(|probe| probe.end.cmp(&range.start, &buffer))
        {
            Ok(ix) | Err(ix) => ix,
        };
        let end_ix = match self
            .disjoint
-            .binary_search_by(|probe| probe.start.cmp(&range.end, &map.buffer_snapshot))
+            .binary_search_by(|probe| probe.start.cmp(&range.end, &buffer))
        {
            Ok(ix) => ix + 1,
            Err(ix) => ix,
        };
-        resolve_selections(&self.disjoint[start_ix..end_ix], &map).collect()
+        resolve_multiple(&self.disjoint[start_ix..end_ix], &buffer).collect()
    }

    pub fn all_display(
        &self,
        cx: &mut AppContext,
    ) -> (DisplaySnapshot, Vec<Selection<DisplayPoint>>) {
-        let map = self.display_map(cx);
-        let disjoint_anchors = &self.disjoint;
-        let mut disjoint = resolve_selections_display(disjoint_anchors.iter(), &map).peekable();
-        let mut pending_opt =
-            resolve_selections_display(self.pending_anchor().as_ref(), &map).next();
-        let selections = iter::from_fn(move || {
-            if let Some(pending) = pending_opt.as_mut() {
-                while let Some(next_selection) = disjoint.peek() {
-                    if pending.start <= next_selection.end && pending.end >= next_selection.start {
-                        let next_selection = disjoint.next().unwrap();
-                        if next_selection.start < pending.start {
-                            pending.start = next_selection.start;
-                        }
-                        if next_selection.end > pending.end {
-                            pending.end = next_selection.end;
-                        }
-                    } else if next_selection.end < pending.start {
-                        return disjoint.next();
-                    } else {
-                        break;
-                    }
-                }
-
-                pending_opt.take()
-            } else {
-                disjoint.next()
-            }
-        })
-        .collect();
-        (map, selections)
+        let display_map = self.display_map(cx);
+        let selections = self
+            .all::<Point>(cx)
+            .into_iter()
+            .map(|selection| selection.map(|point| point.to_display_point(&display_map)))
+            .collect();
+        (display_map, selections)
    }

    pub fn newest_anchor(&self) -> &Selection<Anchor> {
@@ -262,18 +241,15 @@ impl SelectionsCollection {
        &self,
        cx: &mut AppContext,
    ) -> Selection<D> {
-        let map = self.display_map(cx);
-        let selection = resolve_selections([self.newest_anchor()], &map)
-            .next()
-            .unwrap();
-        selection
+        let buffer = self.buffer(cx);
+        self.newest_anchor().map(|p| p.summary::<D>(&buffer))
    }

    pub fn newest_display(&self, cx: &mut AppContext) -> Selection<DisplayPoint> {
-        let map = self.display_map(cx);
-        let selection = resolve_selections_display([self.newest_anchor()], &map)
-            .next()
-            .unwrap();
+        let display_map = self.display_map(cx);
+        let selection = self
+            .newest_anchor()
+            .map(|point| point.to_display_point(&display_map));
        selection
    }

@@ -289,11 +265,8 @@ impl SelectionsCollection {
        &self,
        cx: &mut AppContext,
    ) -> Selection<D> {
-        let map = self.display_map(cx);
-        let selection = resolve_selections([self.oldest_anchor()], &map)
-            .next()
-            .unwrap();
-        selection
+        let buffer = self.buffer(cx);
+        self.oldest_anchor().map(|p| p.summary::<D>(&buffer))
    }

    pub fn first_anchor(&self) -> Selection<Anchor> {
@@ -565,9 +538,9 @@ impl<'a> MutableSelectionsCollection<'a> {
    }

    pub fn select_anchors(&mut self, selections: Vec<Selection<Anchor>>) {
-        let map = self.display_map();
+        let buffer = self.buffer.read(self.cx).snapshot(self.cx);
        let resolved_selections =
-            resolve_selections::<usize, _>(&selections, &map).collect::<Vec<_>>();
+            resolve_multiple::<usize, _>(&selections, &buffer).collect::<Vec<_>>();
        self.select(resolved_selections);
    }

@@ -677,16 +650,20 @@ impl<'a> MutableSelectionsCollection<'a> {
    ) {
        let mut changed = false;
        let display_map = self.display_map();
-        let (_, selections) = self.collection.all_display(self.cx);
-        let selections = selections
+        let selections = self
+            .collection
+            .all::<Point>(self.cx)
            .into_iter()
            .map(|selection| {
-                let mut moved_selection = selection.clone();
+                let mut moved_selection =
+                    selection.map(|point| point.to_display_point(&display_map));
                move_selection(&display_map, &mut moved_selection);
+                let moved_selection =
+                    moved_selection.map(|display_point| display_point.to_point(&display_map));
                if selection != moved_selection {
                    changed = true;
                }
-                moved_selection.map(|display_point| display_point.to_point(&display_map))
+                moved_selection
            })
            .collect();

@@ -827,8 +804,8 @@ impl<'a> MutableSelectionsCollection<'a> {
            .collect();

        if !adjusted_disjoint.is_empty() {
-            let map = self.display_map();
-            let resolved_selections = resolve_selections(adjusted_disjoint.iter(), &map).collect();
+            let resolved_selections =
+                resolve_multiple(adjusted_disjoint.iter(), &self.buffer()).collect();
            self.select::<usize>(resolved_selections);
        }

@@ -872,76 +849,27 @@ impl<'a> DerefMut for MutableSelectionsCollection<'a> {
 }

 // Panics if passed selections are not in order
-fn resolve_selections_display<'a>(
-    selections: impl 'a + IntoIterator<Item = &'a Selection<Anchor>>,
-    map: &'a DisplaySnapshot,
-) -> impl 'a + Iterator<Item = Selection<DisplayPoint>> {
-    let (to_summarize, selections) = selections.into_iter().tee();
-    let mut summaries = map
-        .buffer_snapshot
-        .summaries_for_anchors::<Point, _>(to_summarize.flat_map(|s| [&s.start, &s.end]))
-        .into_iter();
-    let mut selections = selections
-        .map(move |s| {
-            let start = summaries.next().unwrap();
-            let end = summaries.next().unwrap();
-
-            let display_start = map.point_to_display_point(start, Bias::Left);
-            let display_end = if start == end {
-                map.point_to_display_point(end, Bias::Right)
-            } else {
-                map.point_to_display_point(end, Bias::Left)
-            };
-
-            Selection {
-                id: s.id,
-                start: display_start,
-                end: display_end,
-                reversed: s.reversed,
-                goal: s.goal,
-            }
-        })
-        .peekable();
-    iter::from_fn(move || {
-        let mut selection = selections.next()?;
-        while let Some(next_selection) = selections.peek() {
-            if selection.end >= next_selection.start {
-                selection.end = cmp::max(selection.end, next_selection.end);
-                selections.next();
-            } else {
-                break;
-            }
-        }
-        Some(selection)
-    })
-}
-
-// Panics if passed selections are not in order
-pub(crate) fn resolve_selections<'a, D, I>(
+pub(crate) fn resolve_multiple<'a, D, I>(
    selections: I,
-    map: &'a DisplaySnapshot,
+    snapshot: &MultiBufferSnapshot,
 ) -> impl 'a + Iterator<Item = Selection<D>>
 where
-    D: TextDimension + Clone + Ord + Sub<D, Output = D>,
+    D: TextDimension + Ord + Sub<D, Output = D>,
    I: 'a + IntoIterator<Item = &'a Selection<Anchor>>,
 {
-    let (to_convert, selections) = resolve_selections_display(selections, map).tee();
-    let mut converted_endpoints =
-        map.buffer_snapshot
-            .dimensions_from_points::<D>(to_convert.flat_map(|s| {
-                let start = map.display_point_to_point(s.start, Bias::Left);
-                let end = map.display_point_to_point(s.end, Bias::Right);
-                [start, end]
-            }));
-    selections.map(move |s| {
-        let start = converted_endpoints.next().unwrap();
-        let end = converted_endpoints.next().unwrap();
-        Selection {
-            id: s.id,
-            start,
-            end,
-            reversed: s.reversed,
-            goal: s.goal,
-        }
+    let (to_summarize, selections) = selections.into_iter().tee();
+    let mut summaries = snapshot
+        .summaries_for_anchors::<D, _>(
+            to_summarize
+                .flat_map(|s| [&s.start, &s.end])
+                .collect::<Vec<_>>(),
+        )
+        .into_iter();
+    selections.map(move |s| Selection {
+        id: s.id,
+        start: summaries.next().unwrap(),
+        end: summaries.next().unwrap(),
+        reversed: s.reversed,
+        goal: s.goal,
    })
 }
--- a/crates/extension/Cargo.toml
+++ b/crates/extension/Cargo.toml
@@ -9,23 +9,59 @@ license = "GPL-3.0-or-later"
 workspace = true

 [lib]
-path = "src/extension.rs"
+path = "src/extension_store.rs"
+doctest = false
+
+[features]
+no-webrtc = ["workspace/no-webrtc"]

 [dependencies]
 anyhow.workspace = true
+assistant_slash_command.workspace = true
 async-compression.workspace = true
 async-tar.workspace = true
+async-trait.workspace = true
+client.workspace = true
 collections.workspace = true
 fs.workspace = true
 futures.workspace = true
+gpui.workspace = true
 http_client.workspace = true
+indexed_docs.workspace = true
 language.workspace = true
 log.workspace = true
 lsp.workspace = true
+node_runtime.workspace = true
+paths.workspace = true
+project.workspace = true
+release_channel.workspace = true
+schemars.workspace = true
 semantic_version.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+serde_json_lenient.workspace = true
+settings.workspace = true
+snippet_provider.workspace = true
+task.workspace = true
+theme.workspace = true
 toml.workspace = true
+ui.workspace = true
+url.workspace = true
+util.workspace = true
 wasm-encoder.workspace = true
 wasmparser.workspace = true
+wasmtime-wasi.workspace = true
+wasmtime.workspace = true
 wit-component.workspace = true
+workspace.workspace = true
+
+[dev-dependencies]
+ctor.workspace = true
+env_logger.workspace = true
+fs = { workspace = true, features = ["test-support"] }
+gpui = { workspace = true, features = ["test-support"] }
+language = { workspace = true, features = ["test-support"] }
+parking_lot.workspace = true
+project = { workspace = true, features = ["test-support"] }
+reqwest_client.workspace = true
+workspace = { workspace = true, features = ["test-support"] }
--- a/crates/extension_host/build.rs
+++ b/crates/extension_host/build.rs
--- a/crates/extension/src/extension.rs
+++ b/crates/extension/src/extension.rs
@@ -1,50 +0,0 @@
-pub mod extension_builder;
-mod extension_manifest;
-
-use anyhow::{anyhow, bail, Context as _, Result};
-use semantic_version::SemanticVersion;
-
-pub use crate::extension_manifest::*;
-
-pub fn parse_wasm_extension_version(
-    extension_id: &str,
-    wasm_bytes: &[u8],
-) -> Result<SemanticVersion> {
-    let mut version = None;
-
-    for part in wasmparser::Parser::new(0).parse_all(wasm_bytes) {
-        if let wasmparser::Payload::CustomSection(s) =
-            part.context("error parsing wasm extension")?
-        {
-            if s.name() == "zed:api-version" {
-                version = parse_wasm_extension_version_custom_section(s.data());
-                if version.is_none() {
-                    bail!(
-                        "extension {} has invalid zed:api-version section: {:?}",
-                        extension_id,
-                        s.data()
-                    );
-                }
-            }
-        }
-    }
-
-    // The reason we wait until we're done parsing all of the Wasm bytes to return the version
-    // is to work around a panic that can happen inside of Wasmtime when the bytes are invalid.
-    //
-    // By parsing the entirety of the Wasm bytes before we return, we're able to detect this problem
-    // earlier as an `Err` rather than as a panic.
-    version.ok_or_else(|| anyhow!("extension {} has no zed:api-version section", extension_id))
-}
-
-fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVersion> {
-    if data.len() == 6 {
-        Some(SemanticVersion::new(
-            u16::from_be_bytes([data[0], data[1]]) as _,
-            u16::from_be_bytes([data[2], data[3]]) as _,
-            u16::from_be_bytes([data[4], data[5]]) as _,
-        ))
-    } else {
-        None
-    }
-}
--- a/crates/extension/src/extension_builder.rs
+++ b/crates/extension/src/extension_builder.rs
@@ -1,6 +1,6 @@
-use crate::{
-    parse_wasm_extension_version, ExtensionLibraryKind, ExtensionManifest, GrammarManifestEntry,
-};
+use crate::wasm_host::parse_wasm_extension_version;
+use crate::ExtensionManifest;
+use crate::{extension_manifest::ExtensionLibraryKind, GrammarManifestEntry};
 use anyhow::{anyhow, bail, Context as _, Result};
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
@@ -135,8 +135,6 @@ impl ExtensionBuilder {
            .args(options.release.then_some("--release"))
            .arg("--target-dir")
            .arg(extension_dir.join("target"))
-            // WASI builds do not work with sccache and just stuck, so disable it.
-            .env("RUSTC_WRAPPER", "")
            .current_dir(extension_dir)
            .output()
            .context("failed to run `cargo`")?;
@@ -365,15 +363,12 @@ impl ExtensionBuilder {

        let output = Command::new("rustup")
            .args(["target", "add", RUST_TARGET])
-            .stderr(Stdio::piped())
+            .stderr(Stdio::inherit())
            .stdout(Stdio::inherit())
            .output()
            .context("failed to run `rustup target add`")?;
        if !output.status.success() {
-            bail!(
-                "failed to install the `{RUST_TARGET}` target: {}",
-                String::from_utf8_lossy(&rustc_output.stderr)
-            );
+            bail!("failed to install the `{RUST_TARGET}` target");
        }

        Ok(())
--- a/crates/extensions_ui/src/extension_indexed_docs_provider.rs
+++ b/crates/extensions_ui/src/extension_indexed_docs_provider.rs
@@ -7,7 +7,7 @@ use futures::FutureExt;
 use indexed_docs::{IndexedDocsDatabase, IndexedDocsProvider, PackageName, ProviderId};
 use wasmtime_wasi::WasiView;

-use extension_host::wasm_host::{WasmExtension, WasmHost};
+use crate::wasm_host::{WasmExtension, WasmHost};

 pub struct ExtensionIndexedDocsProvider {
    pub(crate) extension: WasmExtension,
@@ -58,7 +58,7 @@ impl IndexedDocsProvider for ExtensionIndexedDocsProvider {
                let id = self.id.clone();
                |extension, store| {
                    async move {
-                        let database_resource = store.data_mut().table().push(database as _)?;
+                        let database_resource = store.data_mut().table().push(database)?;
                        extension
                            .call_index_docs(
                                store,
--- a/crates/extension_host/src/extension_lsp_adapter.rs
+++ b/crates/extension_host/src/extension_lsp_adapter.rs
@@ -387,7 +387,6 @@ impl From<lsp::CompletionItem> for wit::Completion {
    fn from(value: lsp::CompletionItem) -> Self {
        Self {
            label: value.label,
-            label_details: value.label_details.map(Into::into),
            detail: value.detail,
            kind: value.kind.map(Into::into),
            insert_text_format: value.insert_text_format.map(Into::into),
@@ -395,15 +394,6 @@ impl From<lsp::CompletionItem> for wit::Completion {
    }
 }

-impl From<lsp::CompletionItemLabelDetails> for wit::CompletionLabelDetails {
-    fn from(value: lsp::CompletionItemLabelDetails) -> Self {
-        Self {
-            detail: value.detail,
-            description: value.description,
-        }
-    }
-}
-
 impl From<lsp::CompletionItemKind> for wit::CompletionKind {
    fn from(value: lsp::CompletionItemKind) -> Self {
        match value {
--- a/crates/extension/src/extension_manifest.rs
+++ b/crates/extension/src/extension_manifest.rs
@@ -75,8 +75,6 @@ pub struct ExtensionManifest {
    #[serde(default)]
    pub language_servers: BTreeMap<LanguageServerName, LanguageServerManifestEntry>,
    #[serde(default)]
-    pub context_servers: BTreeMap<Arc<str>, ContextServerManifestEntry>,
-    #[serde(default)]
    pub slash_commands: BTreeMap<Arc<str>, SlashCommandManifestEntry>,
    #[serde(default)]
    pub indexed_docs_providers: BTreeMap<Arc<str>, IndexedDocsProviderEntry>,
@@ -136,9 +134,6 @@ impl LanguageServerManifestEntry {
    }
 }

-#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
-pub struct ContextServerManifestEntry {}
-
 #[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
 pub struct SlashCommandManifestEntry {
    pub description: String,
@@ -210,7 +205,6 @@ fn manifest_from_old_manifest(
            .map(|grammar_name| (grammar_name, Default::default()))
            .collect(),
        language_servers: Default::default(),
-        context_servers: BTreeMap::default(),
        slash_commands: BTreeMap::default(),
        indexed_docs_providers: BTreeMap::default(),
        snippets: None,
--- a/crates/extension_host/src/extension_settings.rs
+++ b/crates/extension_host/src/extension_settings.rs
--- a/crates/extensions_ui/src/extension_slash_command.rs
+++ b/crates/extensions_ui/src/extension_slash_command.rs
@@ -5,20 +5,20 @@ use assistant_slash_command::{
    ArgumentCompletion, SlashCommand, SlashCommandOutput, SlashCommandOutputSection,
    SlashCommandResult,
 };
-use futures::FutureExt as _;
+use futures::FutureExt;
 use gpui::{Task, WeakView, WindowContext};
 use language::{BufferSnapshot, LspAdapterDelegate};
 use ui::prelude::*;
 use wasmtime_wasi::WasiView;
 use workspace::Workspace;

-use extension_host::wasm_host::{WasmExtension, WasmHost};
+use crate::wasm_host::{WasmExtension, WasmHost};

 pub struct ExtensionSlashCommand {
    pub(crate) extension: WasmExtension,
    #[allow(unused)]
    pub(crate) host: Arc<WasmHost>,
-    pub(crate) command: extension_host::wasm_host::SlashCommand,
+    pub(crate) command: crate::wit::SlashCommand,
 }

 impl SlashCommand for ExtensionSlashCommand {
--- a/crates/extension_host/src/extension_host.rs
+++ b/crates/extension_host/src/extension_host.rs
@@ -1,15 +1,25 @@
-pub mod extension_lsp_adapter;
-pub mod extension_settings;
-pub mod wasm_host;
+pub mod extension_builder;
+mod extension_indexed_docs_provider;
+mod extension_lsp_adapter;
+mod extension_manifest;
+mod extension_settings;
+mod extension_slash_command;
+mod wasm_host;

+#[cfg(test)]
+mod extension_store_test;
+
+use crate::extension_indexed_docs_provider::ExtensionIndexedDocsProvider;
+use crate::extension_manifest::SchemaVersion;
+use crate::extension_slash_command::ExtensionSlashCommand;
 use crate::{extension_lsp_adapter::ExtensionLspAdapter, wasm_host::wit};
 use anyhow::{anyhow, bail, Context as _, Result};
+use assistant_slash_command::SlashCommandRegistry;
 use async_compression::futures::bufread::GzipDecoder;
 use async_tar::Archive;
 use client::{telemetry::Telemetry, Client, ExtensionMetadata, GetExtensionsResponse};
 use collections::{btree_map, BTreeMap, HashSet};
-use extension::extension_builder::{CompileExtensionOptions, ExtensionBuilder};
-pub use extension::ExtensionManifest;
+use extension_builder::{CompileExtensionOptions, ExtensionBuilder};
 use fs::{Fs, RemoveOptions};
 use futures::{
    channel::{
@@ -20,13 +30,14 @@ use futures::{
    select_biased, AsyncReadExt as _, Future, FutureExt as _, StreamExt as _,
 };
 use gpui::{
-    actions, AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext,
-    SharedString, Task, WeakModel,
+    actions, AppContext, AsyncAppContext, Context, EventEmitter, Global, Model, ModelContext, Task,
+    WeakModel,
 };
 use http_client::{AsyncBody, HttpClient, HttpClientWithUrl};
+use indexed_docs::{IndexedDocsRegistry, ProviderId};
 use language::{
-    LanguageConfig, LanguageMatcher, LanguageName, LanguageQueries, LoadedLanguage,
-    QUERY_FILENAME_PREFIXES,
+    LanguageConfig, LanguageMatcher, LanguageName, LanguageQueries, LanguageRegistry,
+    LoadedLanguage, QUERY_FILENAME_PREFIXES,
 };
 use node_runtime::NodeRuntime;
 use project::ContextProviderWithTasks;
@@ -34,6 +45,7 @@ use release_channel::ReleaseChannel;
 use semantic_version::SemanticVersion;
 use serde::{Deserialize, Serialize};
 use settings::Settings;
+use snippet_provider::SnippetRegistry;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 use std::{
@@ -42,19 +54,20 @@ use std::{
    sync::Arc,
    time::{Duration, Instant},
 };
+use theme::{ThemeRegistry, ThemeSettings};
 use url::Url;
-use util::ResultExt;
+use util::{maybe, ResultExt};
 use wasm_host::{
    wit::{is_supported_wasm_api_version, wasm_api_version_range},
    WasmExtension, WasmHost,
 };

-pub use extension::{
-    ExtensionLibraryKind, GrammarManifestEntry, OldExtensionManifest, SchemaVersion,
+pub use extension_manifest::{
+    ExtensionLibraryKind, ExtensionManifest, GrammarManifestEntry, OldExtensionManifest,
 };
 pub use extension_settings::ExtensionSettings;

-pub const RELOAD_DEBOUNCE_DURATION: Duration = Duration::from_millis(200);
+const RELOAD_DEBOUNCE_DURATION: Duration = Duration::from_millis(200);
 const FS_WATCH_LATENCY: Duration = Duration::from_millis(100);

 /// The current extension [`SchemaVersion`] supported by Zed.
@@ -89,106 +102,26 @@ pub fn is_version_compatible(
    true
 }

-pub trait DocsDatabase: Send + Sync + 'static {
-    fn insert(&self, key: String, docs: String) -> Task<Result<()>>;
-}
-
-pub trait ExtensionRegistrationHooks: Send + Sync + 'static {
-    fn remove_user_themes(&self, _themes: Vec<SharedString>) {}
-
-    fn load_user_theme(&self, _theme_path: PathBuf, _fs: Arc<dyn Fs>) -> Task<Result<()>> {
-        Task::ready(Ok(()))
-    }
-
-    fn list_theme_names(
-        &self,
-        _theme_path: PathBuf,
-        _fs: Arc<dyn Fs>,
-    ) -> Task<Result<Vec<String>>> {
-        Task::ready(Ok(Vec::new()))
-    }
-
-    fn reload_current_theme(&self, _cx: &mut AppContext) {}
-
-    fn register_language(
-        &self,
-        _language: LanguageName,
-        _grammar: Option<Arc<str>>,
-        _matcher: language::LanguageMatcher,
-        _load: Arc<dyn Fn() -> Result<LoadedLanguage> + 'static + Send + Sync>,
-    ) {
-    }
-
-    fn register_lsp_adapter(&self, _language: LanguageName, _adapter: ExtensionLspAdapter) {}
-
-    fn remove_lsp_adapter(
-        &self,
-        _language: &LanguageName,
-        _server_name: &language::LanguageServerName,
-    ) {
-    }
-
-    fn register_wasm_grammars(&self, _grammars: Vec<(Arc<str>, PathBuf)>) {}
-
-    fn remove_languages(
-        &self,
-        _languages_to_remove: &[LanguageName],
-        _grammars_to_remove: &[Arc<str>],
-    ) {
-    }
-
-    fn register_slash_command(
-        &self,
-        _slash_command: wit::SlashCommand,
-        _extension: WasmExtension,
-        _host: Arc<WasmHost>,
-    ) {
-    }
-
-    fn register_context_server(
-        &self,
-        _id: Arc<str>,
-        _extension: WasmExtension,
-        _host: Arc<WasmHost>,
-    ) {
-    }
-
-    fn register_docs_provider(
-        &self,
-        _extension: WasmExtension,
-        _host: Arc<WasmHost>,
-        _provider_id: Arc<str>,
-    ) {
-    }
-
-    fn register_snippets(&self, _path: &PathBuf, _snippet_contents: &str) -> Result<()> {
-        Ok(())
-    }
-
-    fn update_lsp_status(
-        &self,
-        _server_name: language::LanguageServerName,
-        _status: language::LanguageServerBinaryStatus,
-    ) {
-    }
-}
-
 pub struct ExtensionStore {
-    pub registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
-    pub builder: Arc<ExtensionBuilder>,
-    pub extension_index: ExtensionIndex,
-    pub fs: Arc<dyn Fs>,
-    pub http_client: Arc<HttpClientWithUrl>,
-    pub telemetry: Option<Arc<Telemetry>>,
-    pub reload_tx: UnboundedSender<Option<Arc<str>>>,
-    pub reload_complete_senders: Vec<oneshot::Sender<()>>,
-    pub installed_dir: PathBuf,
-    pub outstanding_operations: BTreeMap<Arc<str>, ExtensionOperation>,
-    pub index_path: PathBuf,
-    pub modified_extensions: HashSet<Arc<str>>,
-    pub wasm_host: Arc<WasmHost>,
-    pub wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
-    pub tasks: Vec<Task<()>>,
+    builder: Arc<ExtensionBuilder>,
+    extension_index: ExtensionIndex,
+    fs: Arc<dyn Fs>,
+    http_client: Arc<HttpClientWithUrl>,
+    telemetry: Option<Arc<Telemetry>>,
+    reload_tx: UnboundedSender<Option<Arc<str>>>,
+    reload_complete_senders: Vec<oneshot::Sender<()>>,
+    installed_dir: PathBuf,
+    outstanding_operations: BTreeMap<Arc<str>, ExtensionOperation>,
+    index_path: PathBuf,
+    language_registry: Arc<LanguageRegistry>,
+    theme_registry: Arc<ThemeRegistry>,
+    slash_command_registry: Arc<SlashCommandRegistry>,
+    indexed_docs_registry: Arc<IndexedDocsRegistry>,
+    snippet_registry: Arc<SnippetRegistry>,
+    modified_extensions: HashSet<Arc<str>>,
+    wasm_host: Arc<WasmHost>,
+    wasm_extensions: Vec<(Arc<ExtensionManifest>, WasmExtension)>,
+    tasks: Vec<Task<()>>,
 }

 #[derive(Clone, Copy)]
@@ -227,25 +160,26 @@ pub struct ExtensionIndexEntry {

 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
 pub struct ExtensionIndexThemeEntry {
-    pub extension: Arc<str>,
-    pub path: PathBuf,
+    extension: Arc<str>,
+    path: PathBuf,
 }

 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Deserialize, Serialize)]
 pub struct ExtensionIndexLanguageEntry {
-    pub extension: Arc<str>,
-    pub path: PathBuf,
-    pub matcher: LanguageMatcher,
-    pub grammar: Option<Arc<str>>,
+    extension: Arc<str>,
+    path: PathBuf,
+    matcher: LanguageMatcher,
+    grammar: Option<Arc<str>>,
 }

 actions!(zed, [ReloadExtensions]);

 pub fn init(
-    registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
    fs: Arc<dyn Fs>,
    client: Arc<Client>,
    node_runtime: NodeRuntime,
+    language_registry: Arc<LanguageRegistry>,
+    theme_registry: Arc<ThemeRegistry>,
    cx: &mut AppContext,
 ) {
    ExtensionSettings::register(cx);
@@ -254,12 +188,16 @@ pub fn init(
        ExtensionStore::new(
            paths::extensions_dir().clone(),
            None,
-            registration_hooks,
            fs,
            client.http_client().clone(),
            client.http_client().clone(),
            Some(client.telemetry().clone()),
            node_runtime,
+            language_registry,
+            theme_registry,
+            SlashCommandRegistry::global(cx),
+            IndexedDocsRegistry::global(cx),
+            SnippetRegistry::global(cx),
            cx,
        )
    });
@@ -286,12 +224,16 @@ impl ExtensionStore {
    pub fn new(
        extensions_dir: PathBuf,
        build_dir: Option<PathBuf>,
-        extension_api: Arc<dyn ExtensionRegistrationHooks>,
        fs: Arc<dyn Fs>,
        http_client: Arc<HttpClientWithUrl>,
        builder_client: Arc<dyn HttpClient>,
        telemetry: Option<Arc<Telemetry>>,
        node_runtime: NodeRuntime,
+        language_registry: Arc<LanguageRegistry>,
+        theme_registry: Arc<ThemeRegistry>,
+        slash_command_registry: Arc<SlashCommandRegistry>,
+        indexed_docs_registry: Arc<IndexedDocsRegistry>,
+        snippet_registry: Arc<SnippetRegistry>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
        let work_dir = extensions_dir.join("work");
@@ -301,7 +243,6 @@ impl ExtensionStore {

        let (reload_tx, mut reload_rx) = unbounded();
        let mut this = Self {
-            registration_hooks: extension_api.clone(),
            extension_index: Default::default(),
            installed_dir,
            index_path,
@@ -313,7 +254,7 @@ impl ExtensionStore {
                fs.clone(),
                http_client.clone(),
                node_runtime,
-                extension_api,
+                language_registry.clone(),
                work_dir,
                cx,
            ),
@@ -321,6 +262,11 @@ impl ExtensionStore {
            fs,
            http_client,
            telemetry,
+            language_registry,
+            theme_registry,
+            slash_command_registry,
+            indexed_docs_registry,
+            snippet_registry,
            reload_tx,
            tasks: Vec::new(),
        };
@@ -381,7 +327,6 @@ impl ExtensionStore {
            async move {
                load_initial_extensions.await;

-                let mut index_changed = false;
                let mut debounce_timer = cx
                    .background_executor()
                    .spawn(futures::future::pending())
@@ -389,21 +334,17 @@ impl ExtensionStore {
                loop {
                    select_biased! {
                        _ = debounce_timer => {
-                            if index_changed {
-                                let index = this
-                                    .update(&mut cx, |this, cx| this.rebuild_extension_index(cx))?
-                                    .await;
-                                this.update(&mut cx, |this, cx| this.extensions_updated(index, cx))?
-                                    .await;
-                                index_changed = false;
-                            }
+                            let index = this
+                                .update(&mut cx, |this, cx| this.rebuild_extension_index(cx))?
+                                .await;
+                            this.update(&mut cx, |this, cx| this.extensions_updated(index, cx))?
+                                .await;
                        }
                        extension_id = reload_rx.next() => {
                            let Some(extension_id) = extension_id else { break; };
                            this.update(&mut cx, |this, _| {
                                this.modified_extensions.extend(extension_id);
                            })?;
-                            index_changed = true;
                            debounce_timer = cx
                                .background_executor()
                                .timer(RELOAD_DEBOUNCE_DURATION)
@@ -447,7 +388,7 @@ impl ExtensionStore {
        this
    }

-    pub fn reload(
+    fn reload(
        &mut self,
        modified_extension: Option<Arc<str>>,
        cx: &mut ModelContext<Self>,
@@ -1100,7 +1041,7 @@ impl ExtensionStore {
            grammars_to_remove.extend(extension.manifest.grammars.keys().cloned());
            for (language_server_name, config) in extension.manifest.language_servers.iter() {
                for language in config.languages() {
-                    self.registration_hooks
+                    self.language_registry
                        .remove_lsp_adapter(&language, language_server_name);
                }
            }
@@ -1108,8 +1049,8 @@ impl ExtensionStore {

        self.wasm_extensions
            .retain(|(extension, _)| !extensions_to_unload.contains(&extension.id));
-        self.registration_hooks.remove_user_themes(themes_to_remove);
-        self.registration_hooks
+        self.theme_registry.remove_user_themes(&themes_to_remove);
+        self.language_registry
            .remove_languages(&languages_to_remove, &grammars_to_remove);

        let languages_to_add = new_index
@@ -1144,7 +1085,7 @@ impl ExtensionStore {
            }));
        }

-        self.registration_hooks
+        self.language_registry
            .register_wasm_grammars(grammars_to_add);

        for (language_name, language) in languages_to_add {
@@ -1153,11 +1094,11 @@ impl ExtensionStore {
                Path::new(language.extension.as_ref()),
                language.path.as_path(),
            ]);
-            self.registration_hooks.register_language(
+            self.language_registry.register_language(
                language_name.clone(),
                language.grammar.clone(),
                language.matcher.clone(),
-                Arc::new(move || {
+                move || {
                    let config = std::fs::read_to_string(language_path.join("config.toml"))?;
                    let config: LanguageConfig = ::toml::from_str(&config)?;
                    let queries = load_plugin_queries(&language_path);
@@ -1176,14 +1117,15 @@ impl ExtensionStore {
                        context_provider,
                        toolchain_provider: None,
                    })
-                }),
+                },
            );
        }

        let fs = self.fs.clone();
        let wasm_host = self.wasm_host.clone();
        let root_dir = self.installed_dir.clone();
-        let api = self.registration_hooks.clone();
+        let theme_registry = self.theme_registry.clone();
+        let snippet_registry = self.snippet_registry.clone();
        let extension_entries = extensions_to_load
            .iter()
            .filter_map(|name| new_index.extensions.get(name).cloned())
@@ -1198,14 +1140,18 @@ impl ExtensionStore {
                .spawn({
                    let fs = fs.clone();
                    async move {
-                        for theme_path in themes_to_add.into_iter() {
-                            api.load_user_theme(theme_path, fs.clone()).await.log_err();
+                        for theme_path in &themes_to_add {
+                            theme_registry
+                                .load_user_theme(theme_path, fs.clone())
+                                .await
+                                .log_err();
                        }

                        for snippets_path in &snippets_to_add {
                            if let Some(snippets_contents) = fs.load(snippets_path).await.log_err()
                            {
-                                api.register_snippets(snippets_path, &snippets_contents)
+                                snippet_registry
+                                    .register_snippets(snippets_path, &snippets_contents)
                                    .log_err();
                            }
                        }
@@ -1219,13 +1165,30 @@ impl ExtensionStore {
                    continue;
                };

-                let extension_path = root_dir.join(extension.manifest.id.as_ref());
-                let wasm_extension = WasmExtension::load(
-                    extension_path,
-                    &extension.manifest,
-                    wasm_host.clone(),
-                    &cx,
-                )
+                let wasm_extension = maybe!(async {
+                    let mut path = root_dir.clone();
+                    path.extend([extension.manifest.clone().id.as_ref(), "extension.wasm"]);
+                    let mut wasm_file = fs
+                        .open_sync(&path)
+                        .await
+                        .context("failed to open wasm file")?;
+
+                    let mut wasm_bytes = Vec::new();
+                    wasm_file
+                        .read_to_end(&mut wasm_bytes)
+                        .context("failed to read wasm")?;
+
+                    wasm_host
+                        .load_extension(
+                            wasm_bytes,
+                            extension.manifest.clone().clone(),
+                            cx.background_executor().clone(),
+                        )
+                        .await
+                        .with_context(|| {
+                            format!("failed to load wasm extension {}", extension.manifest.id)
+                        })
+                })
                .await;

                if let Some(wasm_extension) = wasm_extension.log_err() {
@@ -1244,9 +1207,9 @@ impl ExtensionStore {
                for (manifest, wasm_extension) in &wasm_extensions {
                    for (language_server_id, language_server_config) in &manifest.language_servers {
                        for language in language_server_config.languages() {
-                            this.registration_hooks.register_lsp_adapter(
+                            this.language_registry.register_lsp_adapter(
                                language.clone(),
-                                ExtensionLspAdapter {
+                                Arc::new(ExtensionLspAdapter {
                                    extension: wasm_extension.clone(),
                                    host: this.wasm_host.clone(),
                                    language_server_id: language_server_id.clone(),
@@ -1254,46 +1217,43 @@ impl ExtensionStore {
                                        name: language_server_id.0.to_string(),
                                        language_name: language.to_string(),
                                    },
-                                },
+                                }),
                            );
                        }
                    }

                    for (slash_command_name, slash_command) in &manifest.slash_commands {
-                        this.registration_hooks.register_slash_command(
-                            crate::wit::SlashCommand {
-                                name: slash_command_name.to_string(),
-                                description: slash_command.description.to_string(),
-                                // We don't currently expose this as a configurable option, as it currently drives
-                                // the `menu_text` on the `SlashCommand` trait, which is not used for slash commands
-                                // defined in extensions, as they are not able to be added to the menu.
-                                tooltip_text: String::new(),
-                                requires_argument: slash_command.requires_argument,
+                        this.slash_command_registry.register_command(
+                            ExtensionSlashCommand {
+                                command: crate::wit::SlashCommand {
+                                    name: slash_command_name.to_string(),
+                                    description: slash_command.description.to_string(),
+                                    // We don't currently expose this as a configurable option, as it currently drives
+                                    // the `menu_text` on the `SlashCommand` trait, which is not used for slash commands
+                                    // defined in extensions, as they are not able to be added to the menu.
+                                    tooltip_text: String::new(),
+                                    requires_argument: slash_command.requires_argument,
+                                },
+                                extension: wasm_extension.clone(),
+                                host: this.wasm_host.clone(),
                            },
-                            wasm_extension.clone(),
-                            this.wasm_host.clone(),
-                        );
-                    }
-
-                    for (id, _context_server_entry) in &manifest.context_servers {
-                        this.registration_hooks.register_context_server(
-                            id.clone(),
-                            wasm_extension.clone(),
-                            this.wasm_host.clone(),
+                            false,
                        );
                    }

                    for (provider_id, _provider) in &manifest.indexed_docs_providers {
-                        this.registration_hooks.register_docs_provider(
-                            wasm_extension.clone(),
-                            this.wasm_host.clone(),
-                            provider_id.clone(),
-                        );
+                        this.indexed_docs_registry.register_provider(Box::new(
+                            ExtensionIndexedDocsProvider {
+                                extension: wasm_extension.clone(),
+                                host: this.wasm_host.clone(),
+                                id: ProviderId(provider_id.clone()),
+                            },
+                        ));
                    }
                }

                this.wasm_extensions.extend(wasm_extensions);
-                this.registration_hooks.reload_current_theme(cx);
+                ThemeSettings::reload_current_theme(cx)
            })
            .ok();
        })
@@ -1304,7 +1264,6 @@ impl ExtensionStore {
        let work_dir = self.wasm_host.work_dir.clone();
        let extensions_dir = self.installed_dir.clone();
        let index_path = self.index_path.clone();
-        let extension_api = self.registration_hooks.clone();
        cx.background_executor().spawn(async move {
            let start_time = Instant::now();
            let mut index = ExtensionIndex::default();
@@ -1326,14 +1285,9 @@ impl ExtensionStore {
                        continue;
                    }

-                    Self::add_extension_to_index(
-                        fs.clone(),
-                        extension_dir,
-                        &mut index,
-                        extension_api.clone(),
-                    )
-                    .await
-                    .log_err();
+                    Self::add_extension_to_index(fs.clone(), extension_dir, &mut index)
+                        .await
+                        .log_err();
                }
            }

@@ -1353,7 +1307,6 @@ impl ExtensionStore {
        fs: Arc<dyn Fs>,
        extension_dir: PathBuf,
        index: &mut ExtensionIndex,
-        extension_api: Arc<dyn ExtensionRegistrationHooks>,
    ) -> Result<()> {
        let mut extension_manifest = ExtensionManifest::load(fs.clone(), &extension_dir).await?;
        let extension_id = extension_manifest.id.clone();
@@ -1405,8 +1358,7 @@ impl ExtensionStore {
                    continue;
                };

-                let Some(theme_families) = extension_api
-                    .list_theme_names(theme_path.clone(), fs.clone())
+                let Some(theme_family) = ThemeRegistry::read_user_theme(&theme_path, fs.clone())
                    .await
                    .log_err()
                else {
@@ -1418,9 +1370,9 @@ impl ExtensionStore {
                    extension_manifest.themes.push(relative_path.clone());
                }

-                for theme_name in theme_families {
+                for theme in theme_family.themes {
                    index.themes.insert(
-                        theme_name.into(),
+                        theme.name.into(),
                        ExtensionIndexThemeEntry {
                            extension: extension_id.clone(),
                            path: relative_path.clone(),
--- a/crates/extensions_ui/src/extension_store_test.rs
+++ b/crates/extensions_ui/src/extension_store_test.rs
@@ -1,14 +1,13 @@
-use assistant_slash_command::SlashCommandRegistry;
-use async_compression::futures::bufread::GzipEncoder;
-use collections::BTreeMap;
-use context_servers::ContextServerFactoryRegistry;
-use extension_host::ExtensionSettings;
-use extension_host::SchemaVersion;
-use extension_host::{
+use crate::extension_manifest::SchemaVersion;
+use crate::extension_settings::ExtensionSettings;
+use crate::{
    Event, ExtensionIndex, ExtensionIndexEntry, ExtensionIndexLanguageEntry,
    ExtensionIndexThemeEntry, ExtensionManifest, ExtensionStore, GrammarManifestEntry,
    RELOAD_DEBOUNCE_DURATION,
 };
+use assistant_slash_command::SlashCommandRegistry;
+use async_compression::futures::bufread::GzipEncoder;
+use collections::BTreeMap;
 use fs::{FakeFs, Fs, RealFs};
 use futures::{io::BufReader, AsyncReadExt, StreamExt};
 use gpui::{Context, SemanticVersion, TestAppContext};
@@ -162,7 +161,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        .into_iter()
                        .collect(),
                        language_servers: BTreeMap::default(),
-                        context_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
                        snippets: None,
@@ -189,7 +187,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                        languages: Default::default(),
                        grammars: BTreeMap::default(),
                        language_servers: BTreeMap::default(),
-                        context_servers: BTreeMap::default(),
                        slash_commands: BTreeMap::default(),
                        indexed_docs_providers: BTreeMap::default(),
                        snippets: None,
@@ -267,34 +264,27 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = ContextServerFactoryRegistry::new();
    let node_runtime = NodeRuntime::unavailable();

    let store = cx.new_model(|cx| {
-        let extension_registration_hooks = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry.clone(),
-            indexed_docs_registry.clone(),
-            snippet_registry.clone(),
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_registration_hooks,
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
            None,
            node_runtime.clone(),
+            language_registry.clone(),
+            theme_registry.clone(),
+            slash_command_registry.clone(),
+            indexed_docs_registry.clone(),
+            snippet_registry.clone(),
            cx,
        )
    });

-    cx.executor().advance_clock(RELOAD_DEBOUNCE_DURATION);
+    cx.executor().advance_clock(super::RELOAD_DEBOUNCE_DURATION);
    store.read_with(cx, |store, _| {
        let index = &store.extension_index;
        assert_eq!(index.extensions, expected_index.extensions);
@@ -306,7 +296,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            ["ERB", "Plain Text", "Ruby"]
        );
        assert_eq!(
-            theme_registry.list_names(),
+            theme_registry.list_names(false),
            [
                "Monokai Dark",
                "Monokai Light",
@@ -361,7 +351,6 @@ async fn test_extension_store(cx: &mut TestAppContext) {
                languages: Default::default(),
                grammars: BTreeMap::default(),
                language_servers: BTreeMap::default(),
-                context_servers: BTreeMap::default(),
                slash_commands: BTreeMap::default(),
                indexed_docs_providers: BTreeMap::default(),
                snippets: None,
@@ -388,7 +377,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
        assert_eq!(index.themes, expected_index.themes);

        assert_eq!(
-            theme_registry.list_names(),
+            theme_registry.list_names(false),
            [
                "Gruvbox",
                "Monokai Dark",
@@ -406,25 +395,19 @@ async fn test_extension_store(cx: &mut TestAppContext) {
    // Create new extension store, as if Zed were restarting.
    drop(store);
    let store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
-
        ExtensionStore::new(
            PathBuf::from("/the-extension-dir"),
            None,
-            extension_api,
            fs.clone(),
            http_client.clone(),
            http_client.clone(),
            None,
            node_runtime.clone(),
+            language_registry.clone(),
+            theme_registry.clone(),
+            slash_command_registry,
+            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
@@ -441,7 +424,7 @@ async fn test_extension_store(cx: &mut TestAppContext) {
            ["embedded_template".into(), "ruby".into()]
        );
        assert_eq!(
-            theme_registry.list_names(),
+            theme_registry.list_names(false),
            [
                "Gruvbox",
                "Monokai Dark",
@@ -507,7 +490,6 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let slash_command_registry = SlashCommandRegistry::new();
    let indexed_docs_registry = Arc::new(IndexedDocsRegistry::new(cx.executor()));
    let snippet_registry = Arc::new(SnippetRegistry::new());
-    let context_server_factory_registry = ContextServerFactoryRegistry::new();
    let node_runtime = NodeRuntime::unavailable();

    let mut status_updates = language_registry.language_server_binary_statuses();
@@ -598,24 +580,19 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
        Arc::new(ReqwestClient::user_agent(&user_agent).expect("Could not create HTTP client"));

    let extension_store = cx.new_model(|cx| {
-        let extension_api = crate::ConcreteExtensionRegistrationHooks::new(
-            theme_registry.clone(),
-            slash_command_registry,
-            indexed_docs_registry,
-            snippet_registry,
-            language_registry.clone(),
-            context_server_factory_registry.clone(),
-            cx,
-        );
        ExtensionStore::new(
            extensions_dir.clone(),
            Some(cache_dir),
-            extension_api,
            fs.clone(),
            extension_client.clone(),
            builder_client,
            None,
            node_runtime,
+            language_registry.clone(),
+            theme_registry.clone(),
+            slash_command_registry,
+            indexed_docs_registry,
+            snippet_registry,
            cx,
        )
    });
@@ -625,7 +602,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
    let executor = cx.executor();
    let _task = cx.executor().spawn(async move {
        while let Some(event) = events.next().await {
-            if let extension_host::Event::StartedReloading = event {
+            if let crate::Event::StartedReloading = event {
                executor.advance_clock(RELOAD_DEBOUNCE_DURATION);
            }
        }
--- a/crates/extension_host/src/wasm_host.rs
+++ b/crates/extension_host/src/wasm_host.rs
@@ -1,6 +1,6 @@
-pub mod wit;
+pub(crate) mod wit;

-use crate::{ExtensionManifest, ExtensionRegistrationHooks};
+use crate::ExtensionManifest;
 use anyhow::{anyhow, bail, Context as _, Result};
 use fs::{normalize_path, Fs};
 use futures::future::LocalBoxFuture;
@@ -14,6 +14,7 @@ use futures::{
 };
 use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};
 use http_client::HttpClient;
+use language::LanguageRegistry;
 use node_runtime::NodeRuntime;
 use release_channel::ReleaseChannel;
 use semantic_version::SemanticVersion;
@@ -27,16 +28,15 @@ use wasmtime::{
 };
 use wasmtime_wasi as wasi;
 use wit::Extension;
-pub use wit::SlashCommand;

-pub struct WasmHost {
+pub(crate) struct WasmHost {
    engine: Engine,
    release_channel: ReleaseChannel,
    http_client: Arc<dyn HttpClient>,
    node_runtime: NodeRuntime,
-    pub registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+    pub(crate) language_registry: Arc<LanguageRegistry>,
    fs: Arc<dyn Fs>,
-    pub work_dir: PathBuf,
+    pub(crate) work_dir: PathBuf,
    _main_thread_message_task: Task<()>,
    main_thread_message_tx: mpsc::UnboundedSender<MainThreadCall>,
 }
@@ -44,16 +44,16 @@ pub struct WasmHost {
 #[derive(Clone)]
 pub struct WasmExtension {
    tx: UnboundedSender<ExtensionCall>,
-    pub manifest: Arc<ExtensionManifest>,
+    pub(crate) manifest: Arc<ExtensionManifest>,
    #[allow(unused)]
    pub zed_api_version: SemanticVersion,
 }

-pub struct WasmState {
+pub(crate) struct WasmState {
    manifest: Arc<ExtensionManifest>,
-    pub table: ResourceTable,
+    pub(crate) table: ResourceTable,
    ctx: wasi::WasiCtx,
-    pub host: Arc<WasmHost>,
+    pub(crate) host: Arc<WasmHost>,
 }

 type MainThreadCall =
@@ -81,7 +81,7 @@ impl WasmHost {
        fs: Arc<dyn Fs>,
        http_client: Arc<dyn HttpClient>,
        node_runtime: NodeRuntime,
-        registration_hooks: Arc<dyn ExtensionRegistrationHooks>,
+        language_registry: Arc<LanguageRegistry>,
        work_dir: PathBuf,
        cx: &mut AppContext,
    ) -> Arc<Self> {
@@ -97,7 +97,7 @@ impl WasmHost {
            work_dir,
            http_client,
            node_runtime,
-            registration_hooks,
+            language_registry,
            release_channel: ReleaseChannel::global(cx),
            _main_thread_message_task: task,
            main_thread_message_tx: tx,
@@ -107,11 +107,10 @@ impl WasmHost {
    pub fn load_extension(
        self: &Arc<Self>,
        wasm_bytes: Vec<u8>,
-        manifest: &Arc<ExtensionManifest>,
+        manifest: Arc<ExtensionManifest>,
        executor: BackgroundExecutor,
    ) -> Task<Result<WasmExtension>> {
        let this = self.clone();
-        let manifest = manifest.clone();
        executor.clone().spawn(async move {
            let zed_api_version = parse_wasm_extension_version(&manifest.id, &wasm_bytes)?;

@@ -151,7 +150,7 @@ impl WasmHost {
                .detach();

            Ok(WasmExtension {
-                manifest: manifest.clone(),
+                manifest,
                tx,
                zed_api_version,
            })
@@ -242,31 +241,6 @@ fn parse_wasm_extension_version_custom_section(data: &[u8]) -> Option<SemanticVe
 }

 impl WasmExtension {
-    pub async fn load(
-        extension_dir: PathBuf,
-        manifest: &Arc<ExtensionManifest>,
-        wasm_host: Arc<WasmHost>,
-        cx: &AsyncAppContext,
-    ) -> Result<Self> {
-        let path = extension_dir.join("extension.wasm");
-
-        let mut wasm_file = wasm_host
-            .fs
-            .open_sync(&path)
-            .await
-            .context("failed to open wasm file")?;
-
-        let mut wasm_bytes = Vec::new();
-        wasm_file
-            .read_to_end(&mut wasm_bytes)
-            .context("failed to read wasm")?;
-
-        wasm_host
-            .load_extension(wasm_bytes, manifest, cx.background_executor().clone())
-            .await
-            .with_context(|| format!("failed to load wasm extension {}", manifest.id))
-    }
-
    pub async fn call<T, Fn>(&self, f: Fn) -> T
    where
        T: 'static + Send,
--- a/crates/extension_host/src/wasm_host/wit.rs
+++ b/crates/extension_host/src/wasm_host/wit.rs
@@ -3,12 +3,10 @@ mod since_v0_0_4;
 mod since_v0_0_6;
 mod since_v0_1_0;
 mod since_v0_2_0;
-// use indexed_docs::IndexedDocsDatabase;
+use indexed_docs::IndexedDocsDatabase;
 use release_channel::ReleaseChannel;
 use since_v0_2_0 as latest;

-use crate::DocsDatabase;
-
 use super::{wasm_engine, WasmState};
 use anyhow::{anyhow, Context, Result};
 use language::{LanguageServerName, LspAdapterDelegate};
@@ -22,9 +20,7 @@ use wasmtime::{
 #[cfg(test)]
 pub use latest::CodeLabelSpanLiteral;
 pub use latest::{
-    zed::extension::lsp::{
-        Completion, CompletionKind, CompletionLabelDetails, InsertTextFormat, Symbol, SymbolKind,
-    },
+    zed::extension::lsp::{Completion, CompletionKind, InsertTextFormat, Symbol, SymbolKind},
    zed::extension::slash_command::{SlashCommandArgumentCompletion, SlashCommandOutput},
    CodeLabel, CodeLabelSpan, Command, Range, SlashCommand,
 };
@@ -80,20 +76,13 @@ impl Extension {
        version: SemanticVersion,
        component: &Component,
    ) -> Result<Self> {
-        if version >= latest::MIN_VERSION {
-            // Note: The release channel can be used to stage a new version of the extension API.
-            // We always allow the latest in tests so that the extension tests pass on release branches.
-            let allow_latest_version = match release_channel {
-                ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
-                ReleaseChannel::Stable | ReleaseChannel::Preview => {
-                    cfg!(any(test, feature = "test-support"))
-                }
-            };
-            if !allow_latest_version {
-                Err(anyhow!(
-                    "unreleased versions of the extension API can only be used on development builds of Zed"
-                ))?;
-            }
+        // Note: The release channel can be used to stage a new version of the extension API.
+        let allow_latest_version = match release_channel {
+            ReleaseChannel::Dev | ReleaseChannel::Nightly => true,
+            ReleaseChannel::Stable | ReleaseChannel::Preview => false,
+        };
+
+        if allow_latest_version && version >= latest::MIN_VERSION {
            let extension =
                latest::Extension::instantiate_async(store, component, latest::linker())
                    .await
@@ -273,11 +262,7 @@ impl Extension {
                    .await
            }
            Extension::V010(ext) => Ok(ext
-                .call_labels_for_completions(
-                    store,
-                    &language_server_id.0,
-                    &completions.into_iter().map(Into::into).collect::<Vec<_>>(),
-                )
+                .call_labels_for_completions(store, &language_server_id.0, &completions)
                .await?
                .map(|labels| {
                    labels
@@ -286,11 +271,7 @@ impl Extension {
                        .collect()
                })),
            Extension::V006(ext) => Ok(ext
-                .call_labels_for_completions(
-                    store,
-                    &language_server_id.0,
-                    &completions.into_iter().map(Into::into).collect::<Vec<_>>(),
-                )
+                .call_labels_for_completions(store, &language_server_id.0, &completions)
                .await?
                .map(|labels| {
                    labels
@@ -314,11 +295,7 @@ impl Extension {
                    .await
            }
            Extension::V010(ext) => Ok(ext
-                .call_labels_for_symbols(
-                    store,
-                    &language_server_id.0,
-                    &symbols.into_iter().map(Into::into).collect::<Vec<_>>(),
-                )
+                .call_labels_for_symbols(store, &language_server_id.0, &symbols)
                .await?
                .map(|labels| {
                    labels
@@ -327,11 +304,7 @@ impl Extension {
                        .collect()
                })),
            Extension::V006(ext) => Ok(ext
-                .call_labels_for_symbols(
-                    store,
-                    &language_server_id.0,
-                    &symbols.into_iter().map(Into::into).collect::<Vec<_>>(),
-                )
+                .call_labels_for_symbols(store, &language_server_id.0, &symbols)
                .await?
                .map(|labels| {
                    labels
@@ -384,24 +357,6 @@ impl Extension {
        }
    }

-    pub async fn call_context_server_command(
-        &self,
-        store: &mut Store<WasmState>,
-        context_server_id: Arc<str>,
-    ) -> Result<Result<Command, String>> {
-        match self {
-            Extension::V020(ext) => {
-                ext.call_context_server_command(store, &context_server_id)
-                    .await
-            }
-            Extension::V001(_) | Extension::V004(_) | Extension::V006(_) | Extension::V010(_) => {
-                Err(anyhow!(
-                    "`context_server_command` not available prior to v0.2.0"
-                ))
-            }
-        }
-    }
-
    pub async fn call_suggest_docs_packages(
        &self,
        store: &mut Store<WasmState>,
@@ -421,7 +376,7 @@ impl Extension {
        store: &mut Store<WasmState>,
        provider: &str,
        package_name: &str,
-        database: Resource<Arc<dyn DocsDatabase>>,
+        database: Resource<Arc<IndexedDocsDatabase>>,
    ) -> Result<Result<(), String>> {
        match self {
            Extension::V020(ext) => {
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
@@ -148,7 +148,7 @@ impl ExtensionImports for WasmState {
        };

        self.host
-            .registration_hooks
+            .language_registry
            .update_lsp_status(language::LanguageServerName(server_name.into()), status);
        Ok(())
    }
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_4.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_4.rs
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_6.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_6.rs
@@ -1,4 +1,4 @@
-use super::{latest, since_v0_1_0};
+use super::latest;
 use crate::wasm_host::WasmState;
 use anyhow::Result;
 use async_trait::async_trait;
@@ -16,7 +16,7 @@ wasmtime::component::bindgen!({
    with: {
         "worktree": ExtensionWorktree,
         "zed:extension/github": latest::zed::extension::github,
-         "zed:extension/lsp": since_v0_1_0::zed::extension::lsp,
+         "zed:extension/lsp": latest::zed::extension::lsp,
         "zed:extension/nodejs": latest::zed::extension::nodejs,
         "zed:extension/platform": latest::zed::extension::platform,
    },
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Antonio Scandurra	02701b49f2	WIP	2024-10-31 15:53:24 +01:00
Antonio Scandurra	b338475855	WIP	2024-10-31 15:02:21 +01:00
Antonio Scandurra	a27369c42c	WIP: start using replace blocks for patches	2024-10-31 15:02:06 +01:00
Antonio Scandurra	d4099eed3a	Introduce a new `selected` field to `BlockContext`	2024-10-31 15:01:43 +01:00
				`@@ -1 +0,0 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-file-search"><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"/><path d="m9 18-1.5-1.5"/><circle cx="5" cy="14" r="3"/></svg>`