Refactor multibuffer methods for multibuffer range -> buffer range

* Renames `excerpts_for_ranges` to `disjoint_ranges_to_buffer_ranges`, and modifies it to return `MultiBufferExcerpt` since it provides more information and was already being built. * `range_to_buffer_ranges` now returns an iterator, should improve efficiency in a few places. Now implemented by just calling `disjoint_ranges_to_buffer_ranges`.
Remove unnecessary lifetimes on Buffer::diagnostic_group (#22698 )
2025-01-06 19:05:57 -07:00 · 2025-01-06 06:12:35 +00:00 · 2025-01-06 06:08:17 +00:00 · 2025-01-06 05:22:28 +00:00 · 2025-01-06 05:18:56 +00:00 · 2025-01-06 04:32:30 +00:00
274 changed files with 7673 additions and 4541 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,13 +29,18 @@ jobs:
    outputs:
      docs_only: ${{ steps.check_changes.outputs.docs_only }}
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
        with:
          fetch-depth: 0
      - name: Check for non-docs changes
        id: check_changes
        run: |
-          if git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.sha }} | grep -qvE '^docs/'; then
+          if [ "${{ github.event_name }}" == "merge_group" ]; then
+            # When we're running in a merge queue, never assume that the changes
+            # are docs-only, as there could be other PRs in the group that
+            # contain non-docs changes.
+            echo "docs_only=false" >> $GITHUB_OUTPUT
+          elif git diff --name-only ${{ github.event.pull_request.base.sha }} ${{ github.sha }} | grep -qvE '^docs/'; then
            echo "docs_only=false" >> $GITHUB_OUTPUT
          else
            echo "docs_only=true" >> $GITHUB_OUTPUT
@@ -175,7 +180,7 @@ jobs:

      - name: Cache dependencies
        if: needs.check_docs_only.outputs.docs_only == 'false'
-        uses: swatinem/rust-cache@82a92a6e8fbeee089604da2575dc567ae9ddeaab # v2
+        uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
          cache-provider: "buildjet"
@@ -216,7 +221,7 @@ jobs:

      - name: Cache dependencies
        if: needs.check_docs_only.outputs.docs_only == 'false'
-        uses: swatinem/rust-cache@82a92a6e8fbeee089604da2575dc567ae9ddeaab # v2
+        uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
          cache-provider: "buildjet"
@@ -247,7 +252,7 @@ jobs:

      - name: Cache dependencies
        if: needs.check_docs_only.outputs.docs_only == 'false'
-        uses: swatinem/rust-cache@82a92a6e8fbeee089604da2575dc567ae9ddeaab # v2
+        uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
          cache-provider: "github"
--- a/.github/workflows/publish_extension_cli.yml
+++ b/.github/workflows/publish_extension_cli.yml
@@ -21,7 +21,7 @@ jobs:
          clean: false

      - name: Cache dependencies
-        uses: swatinem/rust-cache@82a92a6e8fbeee089604da2575dc567ae9ddeaab # v2
+        uses: swatinem/rust-cache@f0deed1e0edfc6a9be95417288c0e1099b1eeec3 # v2
        with:
          save-if: ${{ github.ref == 'refs/heads/main' }}
          cache-provider: "github"
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -149,12 +149,9 @@ members = [
    # Extensions
    #

-    "extensions/astro",
-    "extensions/clojure",
    "extensions/csharp",
    "extensions/deno",
    "extensions/elixir",
-    "extensions/elm",
    "extensions/emmet",
    "extensions/erlang",
    "extensions/glsl",
@@ -355,9 +352,9 @@ async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "091a8401033847bb9b6ace3fcf70448d069621c5" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "091a8401033847bb9b6ace3fcf70448d069621c5" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "091a8401033847bb9b6ace3fcf70448d069621c5" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -392,7 +389,7 @@ hyper = "0.14"
 http = "1.1"
 ignore = "0.4.22"
 image = "0.25.1"
-indexmap = { version = "1.6.2", features = ["serde"] }
+indexmap = { version = "2.7.0", features = ["serde"] }
 indoc = "2"
 itertools = "0.13.0"
 jsonwebtoken = "9.3"
@@ -401,14 +398,13 @@ jupyter-websocket-client = { version = "0.8.0" }
 libc = "0.2"
 libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
 linkify = "0.10.0"
-livekit = { git = "https://github.com/zed-industries/rust-sdks", rev="799f10133d93ba2a88642cd480d01ec4da53408c", features = ["dispatcher", "services-dispatcher", "rustls-tls-native-roots"], default-features = false }
+livekit = { git = "https://github.com/zed-industries/livekit-rust-sdks", rev="060964da10574cd9bf06463a53bf6e0769c5c45e", features = ["dispatcher", "services-dispatcher", "rustls-tls-native-roots"], default-features = false }
 log = { version = "0.4.16", features = ["kv_unstable_serde", "serde"] }
 markup5ever_rcdom = "0.3.0"
 nanoid = "0.4"
 nbformat = { version = "0.9.0" }
 nix = "0.29"
 num-format = "0.4.4"
-once_cell = "1.19.0"
 ordered-float = "2.1.1"
 palette = { version = "0.7.5", default-features = false, features = ["std"] }
 parking_lot = "0.12.1"
@@ -444,9 +440,10 @@ runtimelib = { version = "0.24.0", default-features = false, features = [
 ] }
 rustc-demangle = "0.1.23"
 rust-embed = { version = "8.4", features = ["include-exclude"] }
+rustc-hash = "2.1.0"
 rustls = "0.21.12"
 rustls-native-certs = "0.8.0"
-schemars = { version = "0.8", features = ["impl_json_schema"] }
+schemars = { version = "0.8", features = ["impl_json_schema", "indexmap2"] }
 semver = "1.0"
 serde = { version = "1.0", features = ["derive", "rc"] }
 serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
@@ -466,7 +463,7 @@ smallvec = { version = "1.6", features = ["union"] }
 smol = "1.2"
 sqlformat = "0.2"
 strsim = "0.11"
-strum = { version = "0.25.0", features = ["derive"] }
+strum = { version = "0.26.0", features = ["derive"] }
 subtle = "2.5.0"
 sys-locale = "0.3.1"
 sysinfo = "0.31.0"
@@ -525,12 +522,7 @@ wasmtime-wasi = "24"
 which = "6.0.0"
 wit-component = "0.201"
 zstd = "0.11"
-# Custom metal-rs is only needed for "macos-blade" feature of GPUI
-#TODO: switch to crates once these are published:
-# - https://github.com/gfx-rs/metal-rs/pull/335
-# - https://github.com/gfx-rs/metal-rs/pull/336
-# - https://github.com/gfx-rs/metal-rs/pull/337
-metal = { git = "https://github.com/gfx-rs/metal-rs", rev = "ef768ff9d742ae6a0f4e83ddc8031264e7d460c4" }
+metal = "0.30"

 [workspace.dependencies.async-stripe]
 git = "https://github.com/zed-industries/async-stripe"
--- a/assets/icons/file_search.svg
+++ b/assets/icons/file_search.svg
@@ -1 +1,5 @@
-<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>
+<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M5.2345 20.1C5.38772 20.373 5.60794 20.5998 5.87313 20.7577C6.13832 20.9157 6.43919 20.9992 6.74562 21H17.25C17.7141 21 18.1592 20.8104 18.4874 20.4728C18.8156 20.1352 19 19.6774 19 19.2V7.5L14.625 3H6.75C6.28587 3 5.84075 3.18964 5.51256 3.52721C5.18437 3.86477 5 4.32261 5 4.8V6.5" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M10 16.8182L8.5 15.3182" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+<path d="M6 15.8182C7.65685 15.8182 9 14.475 9 12.8182C9 11.1613 7.65685 9.81818 6 9.81818C4.34315 9.81818 3 11.1613 3 12.8182C3 14.475 4.34315 15.8182 6 15.8182Z" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -260,6 +260,8 @@
      "ctrl-f4": "pane::CloseActiveItem",
      "alt-ctrl-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
      "alt-ctrl-shift-w": "workspace::CloseInactiveTabsAndPanes",
+      "ctrl-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
+      "ctrl-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
      "ctrl-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
      "ctrl-k w": ["pane::CloseAllItems", { "close_pinned": false }],
      "ctrl-shift-f": "project_search::ToggleFocus",
@@ -375,6 +377,7 @@
      // Change the default action on `menu::Confirm` by setting the parameter
      // "alt-ctrl-o": ["projects::OpenRecent", { "create_new_window": true }],
      "alt-ctrl-o": "projects::OpenRecent",
+      "alt-ctrl-shift-o": "projects::OpenRemote",
      "alt-ctrl-shift-b": "branches::OpenRecent",
      "ctrl-~": "workspace::NewTerminal",
      "ctrl-s": "workspace::Save",
@@ -432,6 +435,13 @@
      // "foo-bar": ["task::Spawn", { "task_name": "MyTask", "reveal_target": "dock" }]
    }
  },
+  {
+    "context": "ApplicationMenu",
+    "bindings": {
+      "left": ["app_menu::NavigateApplicationMenuInDirection", "Left"],
+      "right": ["app_menu::NavigateApplicationMenuInDirection", "Right"]
+    }
+  },
  // Bindings from Sublime Text
  {
    "context": "Editor",
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -327,6 +327,8 @@
      "cmd-w": "pane::CloseActiveItem",
      "alt-cmd-t": ["pane::CloseInactiveItems", { "close_pinned": false }],
      "ctrl-alt-cmd-w": "workspace::CloseInactiveTabsAndPanes",
+      "cmd-k e": ["pane::CloseItemsToTheLeft", { "close_pinned": false }],
+      "cmd-k t": ["pane::CloseItemsToTheRight", { "close_pinned": false }],
      "cmd-k u": ["pane::CloseCleanItems", { "close_pinned": false }],
      "cmd-k cmd-w": ["pane::CloseAllItems", { "close_pinned": false }],
      "cmd-f": "project_search::ToggleFocus",
--- a/assets/keymaps/linux/emacs.json
+++ b/assets/keymaps/linux/emacs.json
@@ -4,55 +4,70 @@
 // 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",
-      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
-      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
-      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
-      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
-      "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"
+      "ctrl-g": "menu::Cancel"
    }
  },
  {
-    "context": "Workspace",
+    "context": "Editor",
    "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"
+      "ctrl-g": "editor::Cancel",
+      "ctrl-x b": "tab_switcher::Toggle", // switch-to-buffer
+      "alt-g g": "go_to_line::Toggle", // goto-line
+      "alt-g alt-g": "go_to_line::Toggle", // goto-line
+      //"ctrl-space": "editor::SetMark",
+      "ctrl-f": "editor::MoveRight", // forward-char
+      "ctrl-b": "editor::MoveLeft", // backward-char
+      "ctrl-n": "editor::MoveDown", // next-line
+      "ctrl-p": "editor::MoveUp", // previous-line
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
+      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
+      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
+      "alt-f": "editor::MoveToNextSubwordEnd", // forward-word
+      "alt-b": "editor::MoveToPreviousSubwordStart", // backward-word
+      "alt-u": "editor::ConvertToUpperCase", // upcase-word
+      "alt-l": "editor::ConvertToLowerCase", // downcase-word
+      "alt-c": "editor::ConvertToUpperCamelCase", // capitalize-word
+      "alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
+      "ctrl-x ctrl-;": "editor::ToggleComments",
+      "alt-.": "editor::GoToDefinition", // xref-find-definitions
+      "alt-,": "pane::GoBack", // xref-pop-marker-stack
+      "ctrl-x h": "editor::SelectAll", // mark-whole-buffer
+      "ctrl-d": "editor::Delete", // delete-char
+      "alt-d": "editor::DeleteToNextWordEnd", // kill-word
+      "ctrl-k": "editor::KillRingCut", // kill-line
+      "ctrl-w": "editor::Cut", // kill-region
+      "alt-w": "editor::Copy", // kill-ring-save
+      "ctrl-y": "editor::KillRingYank", // yank
+      "ctrl-_": "editor::Undo", // undo
+      "ctrl-/": "editor::Undo", // undo
+      "ctrl-x u": "editor::Undo", // undo
+      "ctrl-v": "editor::MovePageDown", // scroll-up
+      "alt-v": "editor::MovePageUp", // scroll-down
+      "ctrl-x [": "editor::MoveToBeginning", // beginning-of-buffer
+      "ctrl-x ]": "editor::MoveToEnd", // end-of-buffer
+      "alt-<": "editor::MoveToBeginning", // beginning-of-buffer
+      "alt->": "editor::MoveToEnd", // end-of-buffer
+      "ctrl-l": "editor::ScrollCursorCenterTopBottom", // recenter-top-bottom
+      "ctrl-s": "buffer_search::Deploy", // isearch-forward
+      "alt-^": "editor::JoinLines" // join-line
+    }
+  },
+  {
+    "context": "Workspace && !Terminal",
+    "bindings": {
+      "ctrl-x ctrl-c": "workspace::CloseWindow", // kill-emacs
+      "ctrl-x o": "workspace::ActivateNextPane", // other-window
+      "ctrl-x k": "pane::CloseActiveItem", // kill-buffer
+      "ctrl-x 0": "pane::CloseActiveItem", // delete-window
+      "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows
+      "ctrl-x 2": "pane::SplitDown", // split-window-below
+      "ctrl-x 3": "pane::SplitRight", // split-window-right
+      "ctrl-x ctrl-f": "file_finder::Toggle", // find-file
+      "ctrl-x ctrl-s": "workspace::Save", // save-buffer
+      "ctrl-x ctrl-w": "workspace::SaveAs", // write-file
+      "ctrl-x s": "workspace::SaveAll" // save-some-buffers
    }
  },
  {
--- a/assets/keymaps/macos/emacs.json
+++ b/assets/keymaps/macos/emacs.json
@@ -4,55 +4,70 @@
 // 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",
-      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
-      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
-      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }],
-      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }],
-      "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"
+      "ctrl-g": "menu::Cancel"
    }
  },
  {
-    "context": "Workspace",
+    "context": "Editor",
    "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"
+      "ctrl-g": "editor::Cancel",
+      "ctrl-x b": "tab_switcher::Toggle", // switch-to-buffer
+      "alt-g g": "go_to_line::Toggle", // goto-line
+      "alt-g alt-g": "go_to_line::Toggle", // goto-line
+      //"ctrl-space": "editor::SetMark",
+      "ctrl-f": "editor::MoveRight", // forward-char
+      "ctrl-b": "editor::MoveLeft", // backward-char
+      "ctrl-n": "editor::MoveDown", // next-line
+      "ctrl-p": "editor::MoveUp", // previous-line
+      "home": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
+      "end": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
+      "ctrl-a": ["editor::MoveToBeginningOfLine", { "stop_at_soft_wraps": false }], // move-beginning-of-line
+      "ctrl-e": ["editor::MoveToEndOfLine", { "stop_at_soft_wraps": false }], // move-end-of-line
+      "alt-f": "editor::MoveToNextSubwordEnd", // forward-word
+      "alt-b": "editor::MoveToPreviousSubwordStart", // backward-word
+      "alt-u": "editor::ConvertToUpperCase", // upcase-word
+      "alt-l": "editor::ConvertToLowerCase", // downcase-word
+      "alt-c": "editor::ConvertToUpperCamelCase", // capitalize-word
+      "alt-;": ["editor::ToggleComments", { "advance_downwards": false }],
+      "ctrl-x ctrl-;": "editor::ToggleComments",
+      "alt-.": "editor::GoToDefinition", // xref-find-definitions
+      "alt-,": "pane::GoBack", // xref-pop-marker-stack
+      "ctrl-x h": "editor::SelectAll", // mark-whole-buffer
+      "ctrl-d": "editor::Delete", // delete-char
+      "alt-d": "editor::DeleteToNextWordEnd", // kill-word
+      "ctrl-k": "editor::KillRingCut", // kill-line
+      "ctrl-w": "editor::Cut", // kill-region
+      "alt-w": "editor::Copy", // kill-ring-save
+      "ctrl-y": "editor::KillRingYank", // yank
+      "ctrl-_": "editor::Undo", // undo
+      "ctrl-/": "editor::Undo", // undo
+      "ctrl-x u": "editor::Undo", // undo
+      "ctrl-v": "editor::MovePageDown", // scroll-up
+      "alt-v": "editor::MovePageUp", // scroll-down
+      "ctrl-x [": "editor::MoveToBeginning", // beginning-of-buffer
+      "ctrl-x ]": "editor::MoveToEnd", // end-of-buffer
+      "alt-<": "editor::MoveToBeginning", // beginning-of-buffer
+      "alt->": "editor::MoveToEnd", // end-of-buffer
+      "ctrl-l": "editor::ScrollCursorCenterTopBottom", // recenter-top-bottom
+      "ctrl-s": "buffer_search::Deploy", // isearch-forward
+      "alt-^": "editor::JoinLines" // join-line
+    }
+  },
+  {
+    "context": "Workspace && !Terminal",
+    "bindings": {
+      "ctrl-x ctrl-c": "workspace::CloseWindow", // kill-emacs
+      "ctrl-x o": "workspace::ActivateNextPane", // other-window
+      "ctrl-x k": "pane::CloseActiveItem", // kill-buffer
+      "ctrl-x 0": "pane::CloseActiveItem", // delete-window
+      "ctrl-x 1": "pane::CloseInactiveItems", // delete-other-windows
+      "ctrl-x 2": "pane::SplitDown", // split-window-below
+      "ctrl-x 3": "pane::SplitRight", // split-window-right
+      "ctrl-x ctrl-f": "file_finder::Toggle", // find-file
+      "ctrl-x ctrl-s": "workspace::Save", // save-buffer
+      "ctrl-x ctrl-w": "workspace::SaveAs", // write-file
+      "ctrl-x s": "workspace::SaveAll" // save-some-buffers
    }
  },
  {
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -389,9 +389,6 @@
    "bindings": {
      "w": "vim::Word",
      "shift-w": ["vim::Word", { "ignorePunctuation": true }],
-      // Subword TextObject
-      // "w": "vim::Subword",
-      // "shift-w": ["vim::Subword", { "ignorePunctuation": true }],
      "t": "vim::Tag",
      "s": "vim::Sentence",
      "p": "vim::Paragraph",
--- a/assets/settings/default.json
+++ b/assets/settings/default.json
@@ -256,8 +256,13 @@
    "search_results": true,
    // Whether to show selected symbol occurrences in the scrollbar.
    "selected_symbol": true,
-    // Whether to show diagnostic indicators in the scrollbar.
-    "diagnostics": true,
+    // Which diagnostic indicators to show in the scrollbar:
+    //  - "none" or false: do not show diagnostics
+    //  - "error": show only errors
+    //  - "warning": show only errors and warnings
+    //  - "information": show only errors, warnings, and information
+    //  - "all" or true: show all diagnostics
+    "diagnostics": "all",
    /// Forcefully enable or disable the scrollbar for each axis
    "axes": {
      /// When false, forcefully disables the horizontal scrollbar. Otherwise, obey other settings.
@@ -741,7 +746,7 @@
      // Delay is restarted with every cursor movement.
      // "delay_ms": 600
      //
-      // Whether or not do display the git commit summary on the same line.
+      // Whether or not to display the git commit summary on the same line.
      // "show_commit_summary": false
      //
      // The minimum column number to show the inline blame information at
@@ -1103,6 +1108,9 @@
      "prettier": {
        "allowed": true
      }
+    },
+    "Zig": {
+      "language_servers": ["zls", "..."]
    }
  },
  // Different settings for specific language models.
--- a/crates/anthropic/src/anthropic.rs
+++ b/crates/anthropic/src/anthropic.rs
@@ -30,6 +30,8 @@ pub enum Model {
    #[default]
    #[serde(rename = "claude-3-5-sonnet", alias = "claude-3-5-sonnet-latest")]
    Claude3_5Sonnet,
+    #[serde(rename = "claude-3-5-haiku", alias = "claude-3-5-haiku-latest")]
+    Claude3_5Haiku,
    #[serde(rename = "claude-3-opus", alias = "claude-3-opus-latest")]
    Claude3Opus,
    #[serde(rename = "claude-3-sonnet", alias = "claude-3-sonnet-latest")]
@@ -48,6 +50,8 @@ pub enum Model {
        cache_configuration: Option<AnthropicModelCacheConfiguration>,
        max_output_tokens: Option<u32>,
        default_temperature: Option<f32>,
+        #[serde(default)]
+        extra_beta_headers: Vec<String>,
    },
 }

@@ -55,6 +59,8 @@ impl Model {
    pub fn from_id(id: &str) -> Result<Self> {
        if id.starts_with("claude-3-5-sonnet") {
            Ok(Self::Claude3_5Sonnet)
+        } else if id.starts_with("claude-3-5-haiku") {
+            Ok(Self::Claude3_5Haiku)
        } else if id.starts_with("claude-3-opus") {
            Ok(Self::Claude3Opus)
        } else if id.starts_with("claude-3-sonnet") {
@@ -69,6 +75,7 @@ impl Model {
    pub fn id(&self) -> &str {
        match self {
            Model::Claude3_5Sonnet => "claude-3-5-sonnet-latest",
+            Model::Claude3_5Haiku => "claude-3-5-haiku-latest",
            Model::Claude3Opus => "claude-3-opus-latest",
            Model::Claude3Sonnet => "claude-3-sonnet-latest",
            Model::Claude3Haiku => "claude-3-haiku-latest",
@@ -79,6 +86,7 @@ impl Model {
    pub fn display_name(&self) -> &str {
        match self {
            Self::Claude3_5Sonnet => "Claude 3.5 Sonnet",
+            Self::Claude3_5Haiku => "Claude 3.5 Haiku",
            Self::Claude3Opus => "Claude 3 Opus",
            Self::Claude3Sonnet => "Claude 3 Sonnet",
            Self::Claude3Haiku => "Claude 3 Haiku",
@@ -90,11 +98,13 @@ impl Model {

    pub fn cache_configuration(&self) -> Option<AnthropicModelCacheConfiguration> {
        match self {
-            Self::Claude3_5Sonnet | Self::Claude3Haiku => Some(AnthropicModelCacheConfiguration {
-                min_total_token: 2_048,
-                should_speculate: true,
-                max_cache_anchors: 4,
-            }),
+            Self::Claude3_5Sonnet | Self::Claude3_5Haiku | Self::Claude3Haiku => {
+                Some(AnthropicModelCacheConfiguration {
+                    min_total_token: 2_048,
+                    should_speculate: true,
+                    max_cache_anchors: 4,
+                })
+            }
            Self::Custom {
                cache_configuration,
                ..
@@ -106,6 +116,7 @@ impl Model {
    pub fn max_token_count(&self) -> usize {
        match self {
            Self::Claude3_5Sonnet
+            | Self::Claude3_5Haiku
            | Self::Claude3Opus
            | Self::Claude3Sonnet
            | Self::Claude3Haiku => 200_000,
@@ -116,7 +127,7 @@ impl Model {
    pub fn max_output_tokens(&self) -> u32 {
        match self {
            Self::Claude3Opus | Self::Claude3Sonnet | Self::Claude3Haiku => 4_096,
-            Self::Claude3_5Sonnet => 8_192,
+            Self::Claude3_5Sonnet | Self::Claude3_5Haiku => 8_192,
            Self::Custom {
                max_output_tokens, ..
            } => max_output_tokens.unwrap_or(4_096),
@@ -126,6 +137,7 @@ impl Model {
    pub fn default_temperature(&self) -> f32 {
        match self {
            Self::Claude3_5Sonnet
+            | Self::Claude3_5Haiku
            | Self::Claude3Opus
            | Self::Claude3Sonnet
            | Self::Claude3Haiku => 1.0,
@@ -136,6 +148,24 @@ impl Model {
        }
    }

+    pub fn beta_headers(&self) -> String {
+        let mut headers = vec!["prompt-caching-2024-07-31".to_string()];
+
+        if let Self::Custom {
+            extra_beta_headers, ..
+        } = self
+        {
+            headers.extend(
+                extra_beta_headers
+                    .iter()
+                    .filter(|header| !header.trim().is_empty())
+                    .cloned(),
+            );
+        }
+
+        headers.join(",")
+    }
+
    pub fn tool_model_id(&self) -> &str {
        if let Self::Custom {
            tool_override: Some(tool_override),
@@ -156,11 +186,12 @@ pub async fn complete(
    request: Request,
 ) -> Result<Response, AnthropicError> {
    let uri = format!("{api_url}/v1/messages");
+    let model = Model::from_id(&request.model)?;
    let request_builder = HttpRequest::builder()
        .method(Method::POST)
        .uri(uri)
        .header("Anthropic-Version", "2023-06-01")
-        .header("Anthropic-Beta", "prompt-caching-2024-07-31")
+        .header("Anthropic-Beta", model.beta_headers())
        .header("X-Api-Key", api_key)
        .header("Content-Type", "application/json");

@@ -271,14 +302,12 @@ pub async fn stream_completion_with_rate_limit_info(
        stream: true,
    };
    let uri = format!("{api_url}/v1/messages");
+    let model = Model::from_id(&request.base.model)?;
    let request_builder = HttpRequest::builder()
        .method(Method::POST)
        .uri(uri)
        .header("Anthropic-Version", "2023-06-01")
-        .header(
-            "Anthropic-Beta",
-            "tools-2024-04-04,prompt-caching-2024-07-31,max-tokens-3-5-sonnet-2024-07-15",
-        )
+        .header("Anthropic-Beta", model.beta_headers())
        .header("X-Api-Key", api_key)
        .header("Content-Type", "application/json");
    let serialized_request =
--- a/crates/assistant/src/assistant.rs
+++ b/crates/assistant/src/assistant.rs
@@ -37,7 +37,7 @@ pub use prompts::PromptBuilder;
 use prompts::PromptLoadingParams;
 use semantic_index::{CloudEmbeddingProvider, SemanticDb};
 use serde::{Deserialize, Serialize};
-use settings::{update_settings_file, Settings, SettingsStore};
+use settings::{Settings, SettingsStore};
 use slash_command::search_command::SearchSlashCommandFeatureFlag;
 use slash_command::{
    auto_command, cargo_workspace_command, default_command, delta_command, diagnostics_command,
@@ -199,16 +199,6 @@ pub fn init(
    AssistantSettings::register(cx);
    SlashCommandSettings::register(cx);

-    // TODO: remove this when 0.148.0 is released.
-    if AssistantSettings::get_global(cx).using_outdated_settings_version {
-        update_settings_file::<AssistantSettings>(fs.clone(), cx, {
-            let fs = fs.clone();
-            |content, cx| {
-                content.update_file(fs, cx);
-            }
-        });
-    }
-
    cx.spawn(|mut cx| {
        let client = client.clone();
        async move {
--- a/crates/assistant/src/assistant_panel.rs
+++ b/crates/assistant/src/assistant_panel.rs
@@ -122,7 +122,7 @@ pub fn init(cx: &mut AppContext) {
    cx.observe_new_views(
        |terminal_panel: &mut TerminalPanel, cx: &mut ViewContext<TerminalPanel>| {
            let settings = AssistantSettings::get_global(cx);
-            terminal_panel.asssistant_enabled(settings.enabled, cx);
+            terminal_panel.set_assistant_enabled(settings.enabled, cx);
        },
    )
    .detach();
@@ -1458,6 +1458,10 @@ impl Panel for AssistantPanel {
    fn toggle_action(&self) -> Box<dyn Action> {
        Box::new(ToggleFocus)
    }
+
+    fn activation_priority(&self) -> u32 {
+        4
+    }
 }

 impl EventEmitter<PanelEvent> for AssistantPanel {}
@@ -4966,8 +4970,8 @@ fn fold_toggle(
 ) -> impl Fn(
    MultiBufferRow,
    bool,
-    Arc<dyn Fn(bool, &mut WindowContext<'_>) + Send + Sync>,
-    &mut WindowContext<'_>,
+    Arc<dyn Fn(bool, &mut WindowContext) + Send + Sync>,
+    &mut WindowContext,
 ) -> AnyElement {
    move |row, is_folded, fold, _cx| {
        Disclosure::new((name, row.0 as u64), !is_folded)
--- a/crates/assistant/src/assistant_settings.rs
+++ b/crates/assistant/src/assistant_settings.rs
@@ -3,18 +3,12 @@ use std::sync::Arc;
 use ::open_ai::Model as OpenAiModel;
 use anthropic::Model as AnthropicModel;
 use feature_flags::FeatureFlagAppExt;
-use fs::Fs;
 use gpui::{AppContext, Pixels};
 use language_model::{CloudModel, LanguageModel};
-use language_models::{
-    provider::open_ai, AllLanguageModelSettings, AnthropicSettingsContent,
-    AnthropicSettingsContentV1, OllamaSettingsContent, OpenAiSettingsContent,
-    OpenAiSettingsContentV1, VersionedAnthropicSettingsContent, VersionedOpenAiSettingsContent,
-};
 use ollama::Model as OllamaModel;
 use schemars::{schema::Schema, JsonSchema};
 use serde::{Deserialize, Serialize};
-use settings::{update_settings_file, Settings, SettingsSources};
+use settings::{Settings, SettingsSources};

 #[derive(Copy, Clone, Default, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
@@ -106,96 +100,6 @@ impl AssistantSettingsContent {
        }
    }

-    pub fn update_file(&mut self, fs: Arc<dyn Fs>, cx: &AppContext) {
-        if let AssistantSettingsContent::Versioned(settings) = self {
-            if let VersionedAssistantSettingsContent::V1(settings) = settings {
-                if let Some(provider) = settings.provider.clone() {
-                    match provider {
-                        AssistantProviderContentV1::Anthropic { api_url, .. } => {
-                            update_settings_file::<AllLanguageModelSettings>(
-                                fs,
-                                cx,
-                                move |content, _| {
-                                    if content.anthropic.is_none() {
-                                        content.anthropic =
-                                            Some(AnthropicSettingsContent::Versioned(
-                                                VersionedAnthropicSettingsContent::V1(
-                                                    AnthropicSettingsContentV1 {
-                                                        api_url,
-                                                        available_models: None,
-                                                    },
-                                                ),
-                                            ));
-                                    }
-                                },
-                            )
-                        }
-                        AssistantProviderContentV1::Ollama { api_url, .. } => {
-                            update_settings_file::<AllLanguageModelSettings>(
-                                fs,
-                                cx,
-                                move |content, _| {
-                                    if content.ollama.is_none() {
-                                        content.ollama = Some(OllamaSettingsContent {
-                                            api_url,
-                                            available_models: None,
-                                        });
-                                    }
-                                },
-                            )
-                        }
-                        AssistantProviderContentV1::OpenAi {
-                            api_url,
-                            available_models,
-                            ..
-                        } => update_settings_file::<AllLanguageModelSettings>(
-                            fs,
-                            cx,
-                            move |content, _| {
-                                if content.openai.is_none() {
-                                    let available_models = available_models.map(|models| {
-                                        models
-                                            .into_iter()
-                                            .filter_map(|model| match model {
-                                                OpenAiModel::Custom {
-                                                    name,
-                                                    display_name,
-                                                    max_tokens,
-                                                    max_output_tokens,
-                                                    max_completion_tokens: None,
-                                                } => Some(open_ai::AvailableModel {
-                                                    name,
-                                                    display_name,
-                                                    max_tokens,
-                                                    max_output_tokens,
-                                                    max_completion_tokens: None,
-                                                }),
-                                                _ => None,
-                                            })
-                                            .collect::<Vec<_>>()
-                                    });
-                                    content.openai = Some(OpenAiSettingsContent::Versioned(
-                                        VersionedOpenAiSettingsContent::V1(
-                                            OpenAiSettingsContentV1 {
-                                                api_url,
-                                                available_models,
-                                            },
-                                        ),
-                                    ));
-                                }
-                            },
-                        ),
-                        _ => {}
-                    }
-                }
-            }
-        }
-
-        *self = AssistantSettingsContent::Versioned(VersionedAssistantSettingsContent::V2(
-            self.upgrade(),
-        ));
-    }
-
    fn upgrade(&self) -> AssistantSettingsContentV2 {
        match self {
            AssistantSettingsContent::Versioned(settings) => match settings {
@@ -534,6 +438,7 @@ fn merge<T>(target: &mut T, value: Option<T>) {

 #[cfg(test)]
 mod tests {
+    use fs::Fs;
    use gpui::{ReadGlobal, TestAppContext};

    use super::*;
--- a/crates/assistant/src/inline_assistant.rs
+++ b/crates/assistant/src/inline_assistant.rs
@@ -133,7 +133,7 @@ impl InlineAssistant {
            };
            let enabled = AssistantSettings::get_global(cx).enabled;
            terminal_panel.update(cx, |terminal_panel, cx| {
-                terminal_panel.asssistant_enabled(enabled, cx)
+                terminal_panel.set_assistant_enabled(enabled, cx)
            });
        })
        .detach();
@@ -228,19 +228,20 @@ impl InlineAssistant {
        let newest_selection = newest_selection.unwrap();

        let mut codegen_ranges = Vec::new();
-        for (excerpt_id, buffer, buffer_range) in
-            snapshot.excerpts_in_ranges(selections.iter().map(|selection| {
+        for (excerpt, buffer_range) in
+            snapshot.disjoint_ranges_to_buffer_ranges(selections.iter().map(|selection| {
                snapshot.anchor_before(selection.start)..snapshot.anchor_after(selection.end)
            }))
        {
+            let buffer = excerpt.buffer();
            let start = Anchor {
                buffer_id: Some(buffer.remote_id()),
-                excerpt_id,
+                excerpt_id: excerpt.id(),
                text_anchor: buffer.anchor_before(buffer_range.start),
            };
            let end = Anchor {
                buffer_id: Some(buffer.remote_id()),
-                excerpt_id,
+                excerpt_id: excerpt.id(),
                text_anchor: buffer.anchor_after(buffer_range.end),
            };
            codegen_ranges.push(start..end);
@@ -797,10 +798,12 @@ impl InlineAssistant {
            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);
+                    let multibuffer_snapshot = multibuffer.snapshot(cx);
+                    let mut ranges =
+                        multibuffer_snapshot.range_to_buffer_ranges(assist.range.clone());
                    ranges
-                        .first()
-                        .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                        .next()
+                        .and_then(|(excerpt, _)| excerpt.buffer().language())
                        .map(|language| language.name())
                });
                report_assistant_event(
@@ -2615,26 +2618,30 @@ impl EventEmitter<CodegenEvent> for CodegenAlternative {}

 impl CodegenAlternative {
    pub fn new(
-        buffer: Model<MultiBuffer>,
+        multi_buffer: Model<MultiBuffer>,
        range: Range<Anchor>,
        active: bool,
        telemetry: Option<Arc<Telemetry>>,
        builder: Arc<PromptBuilder>,
        cx: &mut ModelContext<Self>,
    ) -> Self {
-        let snapshot = buffer.read(cx).snapshot(cx);
+        let snapshot = multi_buffer.read(cx).snapshot(cx);

-        let (old_buffer, _, _) = buffer
-            .read(cx)
-            .range_to_buffer_ranges(range.clone(), cx)
-            .pop()
+        // TODO: Could be made more efficient by using a reverse iterator.
+        let (old_excerpt, _) = snapshot
+            .range_to_buffer_ranges(range.clone())
+            .last()
            .unwrap();
        let old_buffer = cx.new_model(|cx| {
-            let old_buffer = old_buffer.read(cx);
-            let text = old_buffer.as_rope().clone();
-            let line_ending = old_buffer.line_ending();
-            let language = old_buffer.language().cloned();
-            let language_registry = old_buffer.language_registry();
+            let text = old_excerpt.buffer().as_rope().clone();
+            let line_ending = old_excerpt.buffer().line_ending();
+            let language = old_excerpt.buffer().language().cloned();
+            let language_registry = multi_buffer
+                .read(cx)
+                .buffer(old_excerpt.buffer_id())
+                .unwrap()
+                .read(cx)
+                .language_registry();

            let mut buffer = Buffer::local_normalized(text, line_ending, cx);
            buffer.set_language(language, cx);
@@ -2645,7 +2652,7 @@ impl CodegenAlternative {
        });

        Self {
-            buffer: buffer.clone(),
+            buffer: multi_buffer.clone(),
            old_buffer,
            edit_position: None,
            message_id: None,
@@ -2656,7 +2663,7 @@ impl CodegenAlternative {
            generation: Task::ready(()),
            diff: Diff::default(),
            telemetry,
-            _subscription: cx.subscribe(&buffer, Self::handle_buffer_event),
+            _subscription: cx.subscribe(&multi_buffer, Self::handle_buffer_event),
            builder,
            active,
            edits: Vec::new(),
@@ -2867,10 +2874,11 @@ impl CodegenAlternative {
        let telemetry = self.telemetry.clone();
        let language_name = {
            let multibuffer = self.buffer.read(cx);
-            let ranges = multibuffer.range_to_buffer_ranges(self.range.clone(), cx);
+            let snapshot = multibuffer.snapshot(cx);
+            let mut ranges = snapshot.range_to_buffer_ranges(self.range.clone());
            ranges
-                .first()
-                .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                .next()
+                .and_then(|(excerpt, _)| excerpt.buffer().language())
                .map(|language| language.name())
        };

--- a/crates/assistant/src/slash_command.rs
+++ b/crates/assistant/src/slash_command.rs
@@ -149,6 +149,7 @@ impl SlashCommandCompletionProvider {
                            server_id: LanguageServerId(0),
                            lsp_completion: Default::default(),
                            confirm,
+                            resolved: true,
                        })
                    })
                    .collect()
@@ -242,6 +243,7 @@ impl SlashCommandCompletionProvider {
                            server_id: LanguageServerId(0),
                            lsp_completion: Default::default(),
                            confirm,
+                            resolved: true,
                        }
                    })
                    .collect())
@@ -330,16 +332,6 @@ impl CompletionProvider for SlashCommandCompletionProvider {
        Task::ready(Ok(true))
    }

-    fn apply_additional_edits_for_completion(
-        &self,
-        _: Model<Buffer>,
-        _: project::Completion,
-        _: bool,
-        _: &mut ViewContext<Editor>,
-    ) -> Task<Result<Option<language::Transaction>>> {
-        Task::ready(Ok(None))
-    }
-
    fn is_completion_trigger(
        &self,
        buffer: &Model<Buffer>,
--- a/crates/assistant/src/slash_command/auto_command.rs
+++ b/crates/assistant/src/slash_command/auto_command.rs
@@ -5,7 +5,7 @@ use assistant_slash_command::{
 };
 use feature_flags::FeatureFlag;
 use futures::StreamExt;
-use gpui::{AppContext, AsyncAppContext, Task, WeakView};
+use gpui::{AppContext, AsyncAppContext, AsyncWindowContext, Task, WeakView, WindowContext};
 use language::{CodeLabel, LspAdapterDelegate};
 use language_model::{
    LanguageModelCompletionEvent, LanguageModelRegistry, LanguageModelRequest,
@@ -14,7 +14,7 @@ use language_model::{
 use semantic_index::{FileSummary, SemanticDb};
 use smol::channel;
 use std::sync::{atomic::AtomicBool, Arc};
-use ui::{prelude::*, BorrowAppContext, WindowContext};
+use ui::{prelude::*, BorrowAppContext};
 use util::ResultExt;
 use workspace::Workspace;

@@ -115,7 +115,7 @@ impl SlashCommand for AutoCommand {
            return Task::ready(Err(anyhow!("no project indexer")));
        };

-        let task = cx.spawn(|cx: gpui::AsyncWindowContext| async move {
+        let task = cx.spawn(|cx: AsyncWindowContext| async move {
            let summaries = project_index
                .read_with(&cx, |project_index, cx| project_index.all_summaries(cx))?
                .await?;
--- a/crates/assistant/src/slash_command/tab_command.rs
+++ b/crates/assistant/src/slash_command/tab_command.rs
@@ -281,7 +281,7 @@ fn tab_items_for_queries(

 fn active_item_buffer(
    workspace: &mut Workspace,
-    cx: &mut ui::ViewContext<Workspace>,
+    cx: &mut ViewContext<Workspace>,
 ) -> anyhow::Result<BufferSnapshot> {
    let active_editor = workspace
        .active_item(cx)
--- a/crates/assistant/src/slash_command_picker.rs
+++ b/crates/assistant/src/slash_command_picker.rs
@@ -27,8 +27,8 @@ enum SlashCommandEntry {
    Info(SlashCommandInfo),
    Advert {
        name: SharedString,
-        renderer: fn(&mut WindowContext<'_>) -> AnyElement,
-        on_confirm: fn(&mut WindowContext<'_>),
+        renderer: fn(&mut WindowContext) -> AnyElement,
+        on_confirm: fn(&mut WindowContext),
    },
 }

--- a/crates/assistant2/Cargo.toml
+++ b/crates/assistant2/Cargo.toml
@@ -50,7 +50,6 @@ parking_lot.workspace = true
 picker.workspace = true
 project.workspace = true
 proto.workspace = true
-release_channel.workspace = true
 rope.workspace = true
 schemars.workspace = true
 serde.workspace = true
--- a/crates/assistant2/src/active_thread.rs
+++ b/crates/assistant2/src/active_thread.rs
@@ -3,9 +3,9 @@ use std::sync::Arc;
 use assistant_tool::ToolWorkingSet;
 use collections::HashMap;
 use gpui::{
-    list, AbsoluteLength, AnyElement, AppContext, CornersRefinement, DefiniteLength,
-    EdgesRefinement, Empty, Length, ListAlignment, ListState, Model, StyleRefinement, Subscription,
-    TextStyleRefinement, View, WeakView,
+    list, AbsoluteLength, AnyElement, AppContext, DefiniteLength, EdgesRefinement, Empty, Length,
+    ListAlignment, ListOffset, ListState, Model, StyleRefinement, Subscription,
+    TextStyleRefinement, UnderlineStyle, View, WeakView,
 };
 use language::LanguageRegistry;
 use language_model::Role;
@@ -22,7 +22,7 @@ pub struct ActiveThread {
    workspace: WeakView<Workspace>,
    language_registry: Arc<LanguageRegistry>,
    tools: Arc<ToolWorkingSet>,
-    thread: Model<Thread>,
+    pub(crate) thread: Model<Thread>,
    messages: Vec<MessageId>,
    list_state: ListState,
    rendered_messages_by_id: HashMap<MessageId, View<Markdown>>,
@@ -108,7 +108,7 @@ impl ActiveThread {
            selection_background_color: cx.theme().players().local().selection,
            code_block: StyleRefinement {
                margin: EdgesRefinement {
-                    top: Some(Length::Definite(rems(0.5).into())),
+                    top: Some(Length::Definite(rems(1.0).into())),
                    left: Some(Length::Definite(rems(0.).into())),
                    right: Some(Length::Definite(rems(0.).into())),
                    bottom: Some(Length::Definite(rems(1.).into())),
@@ -120,19 +120,13 @@ impl ActiveThread {
                    bottom: Some(DefiniteLength::Absolute(AbsoluteLength::Pixels(Pixels(8.)))),
                },
                background: Some(colors.editor_foreground.opacity(0.01).into()),
-                border_color: Some(colors.border_variant.opacity(0.25)),
+                border_color: Some(colors.border_variant.opacity(0.3)),
                border_widths: EdgesRefinement {
                    top: Some(AbsoluteLength::Pixels(Pixels(1.0))),
                    left: Some(AbsoluteLength::Pixels(Pixels(1.))),
                    right: Some(AbsoluteLength::Pixels(Pixels(1.))),
                    bottom: Some(AbsoluteLength::Pixels(Pixels(1.))),
                },
-                corner_radii: CornersRefinement {
-                    top_left: Some(AbsoluteLength::Pixels(Pixels(2.))),
-                    top_right: Some(AbsoluteLength::Pixels(Pixels(2.))),
-                    bottom_right: Some(AbsoluteLength::Pixels(Pixels(2.))),
-                    bottom_left: Some(AbsoluteLength::Pixels(Pixels(2.))),
-                },
                text: Some(TextStyleRefinement {
                    font_family: Some(theme_settings.buffer_font.family.clone()),
                    font_size: Some(buffer_font_size.into()),
@@ -146,6 +140,15 @@ impl ActiveThread {
                background_color: Some(colors.editor_foreground.opacity(0.01)),
                ..Default::default()
            },
+            link: TextStyleRefinement {
+                background_color: Some(colors.editor_foreground.opacity(0.025)),
+                underline: Some(UnderlineStyle {
+                    color: Some(colors.text_accent.opacity(0.5)),
+                    thickness: px(1.),
+                    ..Default::default()
+                }),
+                ..Default::default()
+            },
            ..Default::default()
        };

@@ -159,6 +162,10 @@ impl ActiveThread {
            )
        });
        self.rendered_messages_by_id.insert(*id, markdown);
+        self.list_state.scroll_to(ListOffset {
+            item_ix: old_len,
+            offset_in_item: Pixels(0.0),
+        });
    }

    fn handle_thread_event(
@@ -272,15 +279,19 @@ impl ActiveThread {
                                    ),
                            ),
                    )
-                    .child(v_flex().p_2p5().text_ui(cx).child(markdown.clone()))
+                    .child(div().p_2p5().text_ui(cx).child(markdown.clone()))
                    .when_some(context, |parent, context| {
-                        parent.child(
-                            h_flex().flex_wrap().gap_1().p_1p5().children(
-                                context
-                                    .iter()
-                                    .map(|context| ContextPill::new(context.clone())),
-                            ),
-                        )
+                        if !context.is_empty() {
+                            parent.child(
+                                h_flex().flex_wrap().gap_1().px_1p5().pb_1p5().children(
+                                    context
+                                        .iter()
+                                        .map(|context| ContextPill::new(context.clone())),
+                                ),
+                            )
+                        } else {
+                            parent
+                        }
                    }),
            )
            .into_any()
--- a/crates/assistant2/src/assistant_panel.rs
+++ b/crates/assistant2/src/assistant_panel.rs
@@ -19,7 +19,7 @@ use workspace::Workspace;
 use crate::active_thread::ActiveThread;
 use crate::assistant_settings::{AssistantDockPosition, AssistantSettings};
 use crate::message_editor::MessageEditor;
-use crate::thread::{ThreadError, ThreadId};
+use crate::thread::{Thread, ThreadError, ThreadId};
 use crate::thread_history::{PastThread, ThreadHistory};
 use crate::thread_store::ThreadStore;
 use crate::{NewThread, OpenHistory, ToggleFocus};
@@ -206,6 +206,10 @@ impl AssistantPanel {
        self.message_editor.focus_handle(cx).focus(cx);
    }

+    pub(crate) fn active_thread(&self, cx: &AppContext) -> Model<Thread> {
+        self.thread.read(cx).thread.clone()
+    }
+
    pub(crate) fn delete_thread(&mut self, thread_id: &ThreadId, cx: &mut ViewContext<Self>) {
        self.thread_store
            .update(cx, |this, cx| this.delete_thread(thread_id, cx));
@@ -286,6 +290,10 @@ impl Panel for AssistantPanel {
    fn toggle_action(&self) -> Box<dyn Action> {
        Box::new(ToggleFocus)
    }
+
+    fn activation_priority(&self) -> u32 {
+        3
+    }
 }

 impl AssistantPanel {
--- a/crates/assistant2/src/buffer_codegen.rs
+++ b/crates/assistant2/src/buffer_codegen.rs
@@ -257,17 +257,21 @@ impl CodegenAlternative {
    ) -> Self {
        let snapshot = buffer.read(cx).snapshot(cx);

-        let (old_buffer, _, _) = buffer
-            .read(cx)
-            .range_to_buffer_ranges(range.clone(), cx)
-            .pop()
+        // TODO: Could be more efficient by using a reverse iterator.
+        let (old_excerpt, _) = snapshot
+            .range_to_buffer_ranges(range.clone())
+            .last()
            .unwrap();
        let old_buffer = cx.new_model(|cx| {
-            let old_buffer = old_buffer.read(cx);
-            let text = old_buffer.as_rope().clone();
-            let line_ending = old_buffer.line_ending();
-            let language = old_buffer.language().cloned();
-            let language_registry = old_buffer.language_registry();
+            let text = old_excerpt.buffer().as_rope().clone();
+            let line_ending = old_excerpt.buffer().line_ending();
+            let language = old_excerpt.buffer().language().cloned();
+            let language_registry = buffer
+                .read(cx)
+                .buffer(old_excerpt.buffer_id())
+                .unwrap()
+                .read(cx)
+                .language_registry();

            let mut buffer = Buffer::local_normalized(text, line_ending, cx);
            buffer.set_language(language, cx);
@@ -471,10 +475,11 @@ impl CodegenAlternative {
        let telemetry = self.telemetry.clone();
        let language_name = {
            let multibuffer = self.buffer.read(cx);
-            let ranges = multibuffer.range_to_buffer_ranges(self.range.clone(), cx);
+            let snapshot = multibuffer.snapshot(cx);
+            let mut ranges = snapshot.range_to_buffer_ranges(self.range.clone());
            ranges
-                .first()
-                .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                .next()
+                .and_then(|(excerpt, _)| excerpt.buffer().language())
                .map(|language| language.name())
        };

--- a/crates/assistant2/src/context.rs
+++ b/crates/assistant2/src/context.rs
@@ -1,8 +1,11 @@
 use gpui::SharedString;
 use language_model::{LanguageModelRequestMessage, MessageContent};
+use project::ProjectEntryId;
 use serde::{Deserialize, Serialize};
 use util::post_inc;

+use crate::thread::ThreadId;
+
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy, Serialize, Deserialize)]
 pub struct ContextId(pub(crate) usize);

@@ -23,10 +26,10 @@ pub struct Context {

 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ContextKind {
-    File,
+    File(ProjectEntryId),
    Directory,
    FetchedUrl,
-    Thread,
+    Thread(ThreadId),
 }

 pub fn attach_context_to_message(
@@ -40,7 +43,7 @@ pub fn attach_context_to_message(

    for context in context.into_iter() {
        match context.kind {
-            ContextKind::File => {
+            ContextKind::File(_) => {
                file_context.push_str(&context.text);
                file_context.push('\n');
            }
@@ -54,7 +57,7 @@ pub fn attach_context_to_message(
                fetch_context.push_str(&context.text);
                fetch_context.push('\n');
            }
-            ContextKind::Thread => {
+            ContextKind::Thread(_) => {
                thread_context.push_str(&context.name);
                thread_context.push('\n');
                thread_context.push_str(&context.text);
--- a/crates/assistant2/src/context_picker.rs
+++ b/crates/assistant2/src/context_picker.rs
@@ -10,12 +10,10 @@ use gpui::{
    WeakModel, WeakView,
 };
 use picker::{Picker, PickerDelegate};
-use release_channel::ReleaseChannel;
 use ui::{prelude::*, ListItem, ListItemSpacing};
 use util::ResultExt;
 use workspace::Workspace;

-use crate::context::ContextKind;
 use crate::context_picker::directory_context_picker::DirectoryContextPicker;
 use crate::context_picker::fetch_context_picker::FetchContextPicker;
 use crate::context_picker::file_context_picker::FileContextPicker;
@@ -54,29 +52,24 @@ impl ContextPicker {
        let mut entries = Vec::new();
        entries.push(ContextPickerEntry {
            name: "File".into(),
-            kind: ContextKind::File,
+            kind: ContextPickerEntryKind::File,
            icon: IconName::File,
        });
-        let release_channel = ReleaseChannel::global(cx);
-        // The directory context picker isn't fully implemented yet, so limit it
-        // to development builds.
-        if release_channel == ReleaseChannel::Dev {
-            entries.push(ContextPickerEntry {
-                name: "Folder".into(),
-                kind: ContextKind::Directory,
-                icon: IconName::Folder,
-            });
-        }
+        entries.push(ContextPickerEntry {
+            name: "Folder".into(),
+            kind: ContextPickerEntryKind::Directory,
+            icon: IconName::Folder,
+        });
        entries.push(ContextPickerEntry {
            name: "Fetch".into(),
-            kind: ContextKind::FetchedUrl,
+            kind: ContextPickerEntryKind::FetchedUrl,
            icon: IconName::Globe,
        });

        if thread_store.is_some() {
            entries.push(ContextPickerEntry {
                name: "Thread".into(),
-                kind: ContextKind::Thread,
+                kind: ContextPickerEntryKind::Thread,
                icon: IconName::MessageCircle,
            });
        }
@@ -140,10 +133,18 @@ impl Render for ContextPicker {
 #[derive(Clone)]
 struct ContextPickerEntry {
    name: SharedString,
-    kind: ContextKind,
+    kind: ContextPickerEntryKind,
    icon: IconName,
 }

+#[derive(Debug, Clone)]
+enum ContextPickerEntryKind {
+    File,
+    Directory,
+    FetchedUrl,
+    Thread,
+}
+
 pub(crate) struct ContextPickerDelegate {
    context_picker: WeakView<ContextPicker>,
    workspace: WeakView<Workspace>,
@@ -183,7 +184,7 @@ impl PickerDelegate for ContextPickerDelegate {
            self.context_picker
                .update(cx, |this, cx| {
                    match entry.kind {
-                        ContextKind::File => {
+                        ContextPickerEntryKind::File => {
                            this.mode = ContextPickerMode::File(cx.new_view(|cx| {
                                FileContextPicker::new(
                                    self.context_picker.clone(),
@@ -194,7 +195,7 @@ impl PickerDelegate for ContextPickerDelegate {
                                )
                            }));
                        }
-                        ContextKind::Directory => {
+                        ContextPickerEntryKind::Directory => {
                            this.mode = ContextPickerMode::Directory(cx.new_view(|cx| {
                                DirectoryContextPicker::new(
                                    self.context_picker.clone(),
@@ -205,7 +206,7 @@ impl PickerDelegate for ContextPickerDelegate {
                                )
                            }));
                        }
-                        ContextKind::FetchedUrl => {
+                        ContextPickerEntryKind::FetchedUrl => {
                            this.mode = ContextPickerMode::Fetch(cx.new_view(|cx| {
                                FetchContextPicker::new(
                                    self.context_picker.clone(),
@@ -216,7 +217,7 @@ impl PickerDelegate for ContextPickerDelegate {
                                )
                            }));
                        }
-                        ContextKind::Thread => {
+                        ContextPickerEntryKind::Thread => {
                            if let Some(thread_store) = self.thread_store.as_ref() {
                                this.mode = ContextPickerMode::Thread(cx.new_view(|cx| {
                                    ThreadContextPicker::new(
--- a/crates/assistant2/src/context_picker/directory_context_picker.rs
+++ b/crates/assistant2/src/context_picker/directory_context_picker.rs
@@ -1,19 +1,18 @@
-// TODO: Remove this when we finish the implementation.
-#![allow(unused)]
-
 use std::path::Path;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;

+use anyhow::anyhow;
 use fuzzy::PathMatch;
 use gpui::{AppContext, DismissEvent, FocusHandle, FocusableView, Task, View, WeakModel, WeakView};
 use picker::{Picker, PickerDelegate};
-use project::{PathMatchCandidateSet, WorktreeId};
+use project::{PathMatchCandidateSet, ProjectPath, Worktree, WorktreeId};
 use ui::{prelude::*, ListItem};
 use util::ResultExt as _;
 use workspace::Workspace;

 use crate::context::ContextKind;
+use crate::context_picker::file_context_picker::codeblock_fence_for_path;
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::ContextStore;

@@ -193,14 +192,61 @@ impl PickerDelegate for DirectoryContextPickerDelegate {
        let worktree_id = WorktreeId::from_usize(mat.worktree_id);
        let confirm_behavior = self.confirm_behavior;
        cx.spawn(|this, mut cx| async move {
+            let worktree = project.update(&mut cx, |project, cx| {
+                project
+                    .worktree_for_id(worktree_id, cx)
+                    .ok_or_else(|| anyhow!("no worktree found for {worktree_id:?}"))
+            })??;
+
+            let files = worktree.update(&mut cx, |worktree, _cx| {
+                collect_files_in_path(worktree, &path)
+            })?;
+
+            let open_buffer_tasks = project.update(&mut cx, |project, cx| {
+                files
+                    .into_iter()
+                    .map(|file_path| {
+                        project.open_buffer(
+                            ProjectPath {
+                                worktree_id,
+                                path: file_path.clone(),
+                            },
+                            cx,
+                        )
+                    })
+                    .collect::<Vec<_>>()
+            })?;
+
+            let open_all_buffers_tasks = cx.background_executor().spawn(async move {
+                let mut buffers = Vec::with_capacity(open_buffer_tasks.len());
+
+                for open_buffer_task in open_buffer_tasks {
+                    let buffer = open_buffer_task.await?;
+
+                    buffers.push(buffer);
+                }
+
+                anyhow::Ok(buffers)
+            });
+
+            let buffers = open_all_buffers_tasks.await?;
+
            this.update(&mut cx, |this, cx| {
                let mut text = String::new();

-                // TODO: Add the files from the selected directory.
+                for buffer in buffers {
+                    text.push_str(&codeblock_fence_for_path(Some(&path), None));
+                    text.push_str(&buffer.read(cx).text());
+                    if !text.ends_with('\n') {
+                        text.push('\n');
+                    }
+
+                    text.push_str("```\n");
+                }

                this.delegate
                    .context_store
-                    .update(cx, |context_store, cx| {
+                    .update(cx, |context_store, _cx| {
                        context_store.insert_context(
                            ContextKind::Directory,
                            path.to_string_lossy().to_string(),
@@ -247,3 +293,17 @@ impl PickerDelegate for DirectoryContextPickerDelegate {
        )
    }
 }
+
+fn collect_files_in_path(worktree: &Worktree, path: &Path) -> Vec<Arc<Path>> {
+    let mut files = Vec::new();
+
+    for entry in worktree.child_entries(path) {
+        if entry.is_dir() {
+            files.extend(collect_files_in_path(worktree, &entry.path));
+        } else if entry.is_file() {
+            files.push(entry.path.clone());
+        }
+    }
+
+    files
+}
--- a/crates/assistant2/src/context_picker/fetch_context_picker.rs
+++ b/crates/assistant2/src/context_picker/fetch_context_picker.rs
@@ -176,7 +176,7 @@ impl PickerDelegate for FetchContextPickerDelegate {

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

-    fn placeholder_text(&self, _cx: &mut ui::WindowContext) -> Arc<str> {
+    fn placeholder_text(&self, _cx: &mut WindowContext) -> Arc<str> {
        "Enter a URL…".into()
    }

--- a/crates/assistant2/src/context_picker/file_context_picker.rs
+++ b/crates/assistant2/src/context_picker/file_context_picker.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use fuzzy::PathMatch;
 use gpui::{AppContext, DismissEvent, FocusHandle, FocusableView, Task, View, WeakModel, WeakView};
 use picker::{Picker, PickerDelegate};
-use project::{PathMatchCandidateSet, WorktreeId};
+use project::{PathMatchCandidateSet, ProjectPath, WorktreeId};
 use ui::{prelude::*, ListItem};
 use util::ResultExt as _;
 use workspace::Workspace;
@@ -207,11 +207,20 @@ impl PickerDelegate for FileContextPickerDelegate {
        let worktree_id = WorktreeId::from_usize(mat.worktree_id);
        let confirm_behavior = self.confirm_behavior;
        cx.spawn(|this, mut cx| async move {
-            let Some(open_buffer_task) = project
+            let Some((entry_id, open_buffer_task)) = project
                .update(&mut cx, |project, cx| {
-                    project.open_buffer((worktree_id, path.clone()), cx)
+                    let project_path = ProjectPath {
+                        worktree_id,
+                        path: path.clone(),
+                    };
+
+                    let entry_id = project.entry_for_path(&project_path, cx)?.id;
+                    let task = project.open_buffer(project_path, cx);
+
+                    Some((entry_id, task))
                })
                .ok()
+                .flatten()
            else {
                return anyhow::Ok(());
            };
@@ -232,7 +241,7 @@ impl PickerDelegate for FileContextPickerDelegate {
                        text.push_str("```\n");

                        context_store.insert_context(
-                            ContextKind::File,
+                            ContextKind::File(entry_id),
                            path.to_string_lossy().to_string(),
                            text,
                        );
@@ -307,7 +316,10 @@ impl PickerDelegate for FileContextPickerDelegate {
    }
 }

-fn codeblock_fence_for_path(path: Option<&Path>, row_range: Option<RangeInclusive<u32>>) -> String {
+pub(crate) fn codeblock_fence_for_path(
+    path: Option<&Path>,
+    row_range: Option<RangeInclusive<u32>>,
+) -> String {
    let mut text = String::new();
    write!(text, "```").unwrap();

--- a/crates/assistant2/src/context_picker/thread_context_picker.rs
+++ b/crates/assistant2/src/context_picker/thread_context_picker.rs
@@ -169,25 +169,11 @@ impl PickerDelegate for ThreadContextPickerDelegate {

        self.context_store
            .update(cx, |context_store, cx| {
-                let text = thread.update(cx, |thread, _cx| {
-                    let mut text = String::new();
-
-                    for message in thread.messages() {
-                        text.push_str(match message.role {
-                            language_model::Role::User => "User:",
-                            language_model::Role::Assistant => "Assistant:",
-                            language_model::Role::System => "System:",
-                        });
-                        text.push('\n');
-
-                        text.push_str(&message.text);
-                        text.push('\n');
-                    }
-
-                    text
-                });
-
-                context_store.insert_context(ContextKind::Thread, entry.summary.clone(), text);
+                context_store.insert_context(
+                    ContextKind::Thread(thread.read(cx).id().clone()),
+                    entry.summary.clone(),
+                    thread.read(cx).text(),
+                );
            })
            .ok();

--- a/crates/assistant2/src/context_store.rs
+++ b/crates/assistant2/src/context_store.rs
@@ -1,6 +1,10 @@
 use gpui::SharedString;
+use project::ProjectEntryId;

-use crate::context::{Context, ContextId, ContextKind};
+use crate::{
+    context::{Context, ContextId, ContextKind},
+    thread::ThreadId,
+};

 pub struct ContextStore {
    context: Vec<Context>,
@@ -44,4 +48,18 @@ impl ContextStore {
    pub fn remove_context(&mut self, id: &ContextId) {
        self.context.retain(|context| context.id != *id);
    }
+
+    pub fn contains_project_entry(&self, entry_id: ProjectEntryId) -> bool {
+        self.context.iter().any(|probe| match probe.kind {
+            ContextKind::File(probe_entry_id) => probe_entry_id == entry_id,
+            ContextKind::Directory | ContextKind::FetchedUrl | ContextKind::Thread(_) => false,
+        })
+    }
+
+    pub fn contains_thread(&self, thread_id: &ThreadId) -> bool {
+        self.context.iter().any(|probe| match probe.kind {
+            ContextKind::Thread(ref probe_thread_id) => probe_thread_id == thread_id,
+            ContextKind::File(_) | ContextKind::Directory | ContextKind::FetchedUrl => false,
+        })
+    }
 }
--- a/crates/assistant2/src/context_strip.rs
+++ b/crates/assistant2/src/context_strip.rs
@@ -1,20 +1,27 @@
 use std::rc::Rc;

-use gpui::{FocusHandle, Model, View, WeakModel, WeakView};
-use ui::{prelude::*, PopoverMenu, PopoverMenuHandle, Tooltip};
+use editor::Editor;
+use gpui::{AppContext, FocusHandle, Model, View, WeakModel, WeakView};
+use language::Buffer;
+use project::ProjectEntryId;
+use ui::{prelude::*, KeyBinding, PopoverMenu, PopoverMenuHandle, Tooltip};
 use workspace::Workspace;

+use crate::context::ContextKind;
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::ContextStore;
+use crate::thread::{Thread, ThreadId};
 use crate::thread_store::ThreadStore;
 use crate::ui::ContextPill;
-use crate::ToggleContextPicker;
+use crate::{AssistantPanel, ToggleContextPicker};

 pub struct ContextStrip {
    context_store: Model<ContextStore>,
    context_picker: View<ContextPicker>,
    context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
    focus_handle: FocusHandle,
+    suggest_context_kind: SuggestContextKind,
+    workspace: WeakView<Workspace>,
 }

 impl ContextStrip {
@@ -24,6 +31,7 @@ impl ContextStrip {
        thread_store: Option<WeakModel<ThreadStore>>,
        focus_handle: FocusHandle,
        context_picker_menu_handle: PopoverMenuHandle<ContextPicker>,
+        suggest_context_kind: SuggestContextKind,
        cx: &mut ViewContext<Self>,
    ) -> Self {
        Self {
@@ -39,16 +47,76 @@ impl ContextStrip {
            }),
            context_picker_menu_handle,
            focus_handle,
+            suggest_context_kind,
+            workspace,
        }
    }
+
+    fn suggested_context(&self, cx: &ViewContext<Self>) -> Option<SuggestedContext> {
+        match self.suggest_context_kind {
+            SuggestContextKind::File => self.suggested_file(cx),
+            SuggestContextKind::Thread => self.suggested_thread(cx),
+        }
+    }
+
+    fn suggested_file(&self, cx: &ViewContext<Self>) -> Option<SuggestedContext> {
+        let workspace = self.workspace.upgrade()?;
+        let active_item = workspace.read(cx).active_item(cx)?;
+        let entry_id = *active_item.project_entry_ids(cx).first()?;
+
+        if self.context_store.read(cx).contains_project_entry(entry_id) {
+            return None;
+        }
+
+        let editor = active_item.to_any().downcast::<Editor>().ok()?.read(cx);
+        let active_buffer = editor.buffer().read(cx).as_singleton()?;
+
+        let file = active_buffer.read(cx).file()?;
+        let title = file.path().to_string_lossy().into_owned().into();
+
+        Some(SuggestedContext::File {
+            entry_id,
+            title,
+            buffer: active_buffer.downgrade(),
+        })
+    }
+
+    fn suggested_thread(&self, cx: &ViewContext<Self>) -> Option<SuggestedContext> {
+        let workspace = self.workspace.upgrade()?;
+        let active_thread = workspace
+            .read(cx)
+            .panel::<AssistantPanel>(cx)?
+            .read(cx)
+            .active_thread(cx);
+        let weak_active_thread = active_thread.downgrade();
+
+        let active_thread = active_thread.read(cx);
+
+        if self
+            .context_store
+            .read(cx)
+            .contains_thread(active_thread.id())
+        {
+            return None;
+        }
+
+        Some(SuggestedContext::Thread {
+            id: active_thread.id().clone(),
+            title: active_thread.summary().unwrap_or("Active Thread".into()),
+            thread: weak_active_thread,
+        })
+    }
 }

 impl Render for ContextStrip {
    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
-        let context = self.context_store.read(cx).context();
+        let context_store = self.context_store.read(cx);
+        let context = context_store.context().clone();
        let context_picker = self.context_picker.clone();
        let focus_handle = self.focus_handle.clone();

+        let suggested_context = self.suggested_context(cx);
+
        h_flex()
            .flex_wrap()
            .gap_1()
@@ -59,13 +127,17 @@ impl Render for ContextStrip {
                        IconButton::new("add-context", IconName::Plus)
                            .icon_size(IconSize::Small)
                            .style(ui::ButtonStyle::Filled)
-                            .tooltip(move |cx| {
-                                Tooltip::for_action_in(
-                                    "Add Context",
-                                    &ToggleContextPicker,
-                                    &focus_handle,
-                                    cx,
-                                )
+                            .tooltip({
+                                let focus_handle = focus_handle.clone();
+
+                                move |cx| {
+                                    Tooltip::for_action_in(
+                                        "Add Context",
+                                        &ToggleContextPicker,
+                                        &focus_handle,
+                                        cx,
+                                    )
+                                }
                            }),
                    )
                    .attach(gpui::Corner::TopLeft)
@@ -76,6 +148,25 @@ impl Render for ContextStrip {
                    })
                    .with_handle(self.context_picker_menu_handle.clone()),
            )
+            .when(context.is_empty() && suggested_context.is_none(), {
+                |parent| {
+                    parent.child(
+                        h_flex()
+                            .ml_1p5()
+                            .gap_2()
+                            .child(
+                                Label::new("Add Context")
+                                    .size(LabelSize::Small)
+                                    .color(Color::Muted),
+                            )
+                            .opacity(0.5)
+                            .children(
+                                KeyBinding::for_action_in(&ToggleContextPicker, &focus_handle, cx)
+                                    .map(|binding| binding.into_any_element()),
+                            ),
+                    )
+                }
+            })
            .children(context.iter().map(|context| {
                ContextPill::new(context.clone()).on_remove({
                    let context = context.clone();
@@ -88,19 +179,105 @@ impl Render for ContextStrip {
                    }))
                })
            }))
-            .when(!context.is_empty(), |parent| {
-                parent.child(
-                    IconButton::new("remove-all-context", IconName::Eraser)
-                        .icon_size(IconSize::Small)
-                        .tooltip(move |cx| Tooltip::text("Remove All Context", cx))
+            .when_some(suggested_context, |el, suggested| {
+                el.child(
+                    Button::new("add-suggested-context", suggested.title().clone())
                        .on_click({
                            let context_store = self.context_store.clone();
+
                            cx.listener(move |_this, _event, cx| {
-                                context_store.update(cx, |this, _cx| this.clear());
+                                context_store.update(cx, |context_store, cx| {
+                                    suggested.accept(context_store, cx);
+                                });
                                cx.notify();
                            })
+                        })
+                        .icon(IconName::Plus)
+                        .icon_position(IconPosition::Start)
+                        .icon_size(IconSize::XSmall)
+                        .icon_color(Color::Muted)
+                        .label_size(LabelSize::Small)
+                        .style(ButtonStyle::Filled)
+                        .tooltip(|cx| {
+                            Tooltip::with_meta("Suggested Context", None, "Click to add it", cx)
                        }),
                )
            })
+            .when(!context.is_empty(), {
+                move |parent| {
+                    parent.child(
+                        IconButton::new("remove-all-context", IconName::Eraser)
+                            .icon_size(IconSize::Small)
+                            .tooltip(move |cx| Tooltip::text("Remove All Context", cx))
+                            .on_click({
+                                let context_store = self.context_store.clone();
+                                cx.listener(move |_this, _event, cx| {
+                                    context_store.update(cx, |this, _cx| this.clear());
+                                    cx.notify();
+                                })
+                            }),
+                    )
+                }
+            })
+    }
+}
+
+pub enum SuggestContextKind {
+    File,
+    Thread,
+}
+
+#[derive(Clone)]
+pub enum SuggestedContext {
+    File {
+        entry_id: ProjectEntryId,
+        title: SharedString,
+        buffer: WeakModel<Buffer>,
+    },
+    Thread {
+        id: ThreadId,
+        title: SharedString,
+        thread: WeakModel<Thread>,
+    },
+}
+
+impl SuggestedContext {
+    pub fn title(&self) -> &SharedString {
+        match self {
+            Self::File { title, .. } => title,
+            Self::Thread { title, .. } => title,
+        }
+    }
+
+    pub fn accept(&self, context_store: &mut ContextStore, cx: &mut AppContext) {
+        match self {
+            Self::File {
+                entry_id,
+                title,
+                buffer,
+            } => {
+                let Some(buffer) = buffer.upgrade() else {
+                    return;
+                };
+                let text = buffer.read(cx).text();
+
+                context_store.insert_context(
+                    ContextKind::File(*entry_id),
+                    title.clone(),
+                    text.clone(),
+                );
+            }
+            Self::Thread { id, title, thread } => {
+                let Some(thread) = thread.upgrade() else {
+                    return;
+                };
+
+                context_store.insert_context(
+                    ContextKind::Thread(id.clone()),
+                    title.clone(),
+                    thread.read(cx).text(),
+                );
+            }
+        }
    }
 }
--- a/crates/assistant2/src/inline_assistant.rs
+++ b/crates/assistant2/src/inline_assistant.rs
@@ -118,7 +118,7 @@ impl InlineAssistant {
            };
            let enabled = AssistantSettings::get_global(cx).enabled;
            terminal_panel.update(cx, |terminal_panel, cx| {
-                terminal_panel.asssistant_enabled(enabled, cx)
+                terminal_panel.set_assistant_enabled(enabled, cx)
            });
        })
        .detach();
@@ -294,19 +294,20 @@ impl InlineAssistant {
        let newest_selection = newest_selection.unwrap();

        let mut codegen_ranges = Vec::new();
-        for (excerpt_id, buffer, buffer_range) in
-            snapshot.excerpts_in_ranges(selections.iter().map(|selection| {
+        for (excerpt, buffer_range) in
+            snapshot.disjoint_ranges_to_buffer_ranges(selections.iter().map(|selection| {
                snapshot.anchor_before(selection.start)..snapshot.anchor_after(selection.end)
            }))
        {
+            let buffer = excerpt.buffer();
            let start = Anchor {
                buffer_id: Some(buffer.remote_id()),
-                excerpt_id,
+                excerpt_id: excerpt.id(),
                text_anchor: buffer.anchor_before(buffer_range.start),
            };
            let end = Anchor {
                buffer_id: Some(buffer.remote_id()),
-                excerpt_id,
+                excerpt_id: excerpt.id(),
                text_anchor: buffer.anchor_after(buffer_range.end),
            };
            codegen_ranges.push(start..end);
@@ -871,10 +872,11 @@ impl InlineAssistant {
            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);
+                    let snapshot = multibuffer.snapshot(cx);
+                    let mut ranges = snapshot.range_to_buffer_ranges(assist.range.clone());
                    ranges
-                        .first()
-                        .and_then(|(buffer, _, _)| buffer.read(cx).language())
+                        .next()
+                        .and_then(|(excerpt, _)| excerpt.buffer().language())
                        .map(|language| language.name())
                });
                report_assistant_event(
--- a/crates/assistant2/src/inline_prompt_editor.rs
+++ b/crates/assistant2/src/inline_prompt_editor.rs
@@ -2,7 +2,7 @@ use crate::assistant_model_selector::AssistantModelSelector;
 use crate::buffer_codegen::BufferCodegen;
 use crate::context_picker::ContextPicker;
 use crate::context_store::ContextStore;
-use crate::context_strip::ContextStrip;
+use crate::context_strip::{ContextStrip, SuggestContextKind};
 use crate::terminal_codegen::TerminalCodegen;
 use crate::thread_store::ThreadStore;
 use crate::{CycleNextInlineAssist, CyclePreviousInlineAssist};
@@ -793,6 +793,7 @@ impl PromptEditor<BufferCodegen> {
                    thread_store.clone(),
                    prompt_editor.focus_handle(cx),
                    context_picker_menu_handle.clone(),
+                    SuggestContextKind::Thread,
                    cx,
                )
            }),
@@ -932,6 +933,7 @@ impl PromptEditor<TerminalCodegen> {
                    thread_store.clone(),
                    prompt_editor.focus_handle(cx),
                    context_picker_menu_handle.clone(),
+                    SuggestContextKind::Thread,
                    cx,
                )
            }),
--- a/crates/assistant2/src/message_editor.rs
+++ b/crates/assistant2/src/message_editor.rs
@@ -20,7 +20,7 @@ use workspace::Workspace;
 use crate::assistant_model_selector::AssistantModelSelector;
 use crate::context_picker::{ConfirmBehavior, ContextPicker};
 use crate::context_store::ContextStore;
-use crate::context_strip::ContextStrip;
+use crate::context_strip::{ContextStrip, SuggestContextKind};
 use crate::thread::{RequestKind, Thread};
 use crate::thread_store::ThreadStore;
 use crate::{Chat, ToggleContextPicker, ToggleModelSelector};
@@ -54,7 +54,7 @@ impl MessageEditor {

        let editor = cx.new_view(|cx| {
            let mut editor = Editor::auto_height(10, cx);
-            editor.set_placeholder_text("Ask anything, @ to add context", cx);
+            editor.set_placeholder_text("Ask anything…", cx);
            editor.set_show_indent_guides(false, cx);

            editor
@@ -87,6 +87,7 @@ impl MessageEditor {
                    Some(thread_store.clone()),
                    editor.focus_handle(cx),
                    context_picker_menu_handle.clone(),
+                    SuggestContextKind::File,
                    cx,
                )
            }),
@@ -220,67 +221,73 @@ impl Render for MessageEditor {
            .p_2()
            .bg(bg_color)
            .child(self.context_strip.clone())
-            .child({
-                let settings = ThemeSettings::get_global(cx);
-                let text_style = TextStyle {
-                    color: cx.theme().colors().editor_foreground,
-                    font_family: settings.ui_font.family.clone(),
-                    font_features: settings.ui_font.features.clone(),
-                    font_size: font_size.into(),
-                    font_weight: settings.ui_font.weight,
-                    line_height: line_height.into(),
-                    ..Default::default()
-                };
+            .child(
+                v_flex()
+                    .gap_4()
+                    .child({
+                        let settings = ThemeSettings::get_global(cx);
+                        let text_style = TextStyle {
+                            color: cx.theme().colors().text,
+                            font_family: settings.ui_font.family.clone(),
+                            font_features: settings.ui_font.features.clone(),
+                            font_size: font_size.into(),
+                            font_weight: settings.ui_font.weight,
+                            line_height: line_height.into(),
+                            ..Default::default()
+                        };

-                EditorElement::new(
-                    &self.editor,
-                    EditorStyle {
-                        background: bg_color,
-                        local_player: cx.theme().players().local(),
-                        text: text_style,
-                        ..Default::default()
-                    },
-                )
-            })
-            .child(
-                PopoverMenu::new("inline-context-picker")
-                    .menu(move |_cx| Some(inline_context_picker.clone()))
-                    .attach(gpui::Corner::TopLeft)
-                    .anchor(gpui::Corner::BottomLeft)
-                    .offset(gpui::Point {
-                        x: px(0.0),
-                        y: px(-16.0),
+                        EditorElement::new(
+                            &self.editor,
+                            EditorStyle {
+                                background: bg_color,
+                                local_player: cx.theme().players().local(),
+                                text: text_style,
+                                ..Default::default()
+                            },
+                        )
                    })
-                    .with_handle(self.inline_context_picker_menu_handle.clone()),
-            )
-            .child(
-                h_flex()
-                    .justify_between()
-                    .child(SwitchWithLabel::new(
-                        "use-tools",
-                        Label::new("Tools"),
-                        self.use_tools.into(),
-                        cx.listener(|this, selection, _cx| {
-                            this.use_tools = match selection {
-                                ToggleState::Selected => true,
-                                ToggleState::Unselected | ToggleState::Indeterminate => false,
-                            };
-                        }),
-                    ))
                    .child(
-                        h_flex().gap_1().child(self.model_selector.clone()).child(
-                            ButtonLike::new("chat")
-                                .style(ButtonStyle::Filled)
-                                .layer(ElevationIndex::ModalSurface)
-                                .child(Label::new("Submit"))
-                                .children(
-                                    KeyBinding::for_action_in(&Chat, &focus_handle, cx)
-                                        .map(|binding| binding.into_any_element()),
-                                )
-                                .on_click(move |_event, cx| {
-                                    focus_handle.dispatch_action(&Chat, cx);
+                        PopoverMenu::new("inline-context-picker")
+                            .menu(move |_cx| Some(inline_context_picker.clone()))
+                            .attach(gpui::Corner::TopLeft)
+                            .anchor(gpui::Corner::BottomLeft)
+                            .offset(gpui::Point {
+                                x: px(0.0),
+                                y: px(-16.0),
+                            })
+                            .with_handle(self.inline_context_picker_menu_handle.clone()),
+                    )
+                    .child(
+                        h_flex()
+                            .justify_between()
+                            .child(SwitchWithLabel::new(
+                                "use-tools",
+                                Label::new("Tools"),
+                                self.use_tools.into(),
+                                cx.listener(|this, selection, _cx| {
+                                    this.use_tools = match selection {
+                                        ToggleState::Selected => true,
+                                        ToggleState::Unselected | ToggleState::Indeterminate => {
+                                            false
+                                        }
+                                    };
                                }),
-                        ),
+                            ))
+                            .child(
+                                h_flex().gap_1().child(self.model_selector.clone()).child(
+                                    ButtonLike::new("chat")
+                                        .style(ButtonStyle::Filled)
+                                        .layer(ElevationIndex::ModalSurface)
+                                        .child(Label::new("Submit"))
+                                        .children(
+                                            KeyBinding::for_action_in(&Chat, &focus_handle, cx)
+                                                .map(|binding| binding.into_any_element()),
+                                        )
+                                        .on_click(move |_event, cx| {
+                                            focus_handle.dispatch_action(&Chat, cx);
+                                        }),
+                                ),
+                            ),
                    ),
            )
    }
--- a/crates/assistant2/src/thread.rs
+++ b/crates/assistant2/src/thread.rs
@@ -164,6 +164,27 @@ impl Thread {
        id
    }

+    /// Returns the representation of this [`Thread`] in a textual form.
+    ///
+    /// This is the representation we use when attaching a thread as context to another thread.
+    pub fn text(&self) -> String {
+        let mut text = String::new();
+
+        for message in &self.messages {
+            text.push_str(match message.role {
+                language_model::Role::User => "User:",
+                language_model::Role::Assistant => "Assistant:",
+                language_model::Role::System => "System:",
+            });
+            text.push('\n');
+
+            text.push_str(&message.text);
+            text.push('\n');
+        }
+
+        text
+    }
+
    pub fn to_completion_request(
        &self,
        _request_kind: RequestKind,
--- a/crates/assistant2/src/thread_store.rs
+++ b/crates/assistant2/src/thread_store.rs
@@ -238,5 +238,46 @@ impl ThreadStore {
        Async programming in Rust provides a powerful way to write concurrent code that's both safe and efficient. It's particularly useful for servers, network programming, and any application that deals with many concurrent operations.".unindent(), cx);
            thread
        }));
+
+        self.threads.push(cx.new_model(|cx| {
+            let mut thread = Thread::new(self.tools.clone(), cx);
+            thread.set_summary("Rust code with long lines", cx);
+            thread.insert_user_message("Could you write me some Rust code with long lines?", Vec::new(), cx);
+            thread.insert_message(Role::Assistant, r#"Here's some Rust code with some intentionally long lines:
+            ```rust
+            use std::collections::{HashMap, HashSet};
+            use std::sync::{Arc, Mutex};
+            use std::thread;
+
+            fn main() {
+                let very_long_vector = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25];
+
+                let complicated_hashmap: HashMap<String, Vec<(i32, f64, String)>> = [("key1".to_string(), vec![(1, 1.1, "value1".to_string()), (2, 2.2, "value2".to_string())]), ("key2".to_string(), vec![(3, 3.3, "value3".to_string()), (4, 4.4, "value4".to_string())])].iter().cloned().collect();
+
+                let nested_structure = Arc::new(Mutex::new(HashMap::new()));
+
+                let long_closure = |x: i32, y: i32, z: i32| -> i32 { let result = x * y + z; println!("The result of the long closure calculation is: {}", result); result };
+
+                let thread_handles: Vec<_> = (0..10).map(|i| {
+                    let nested_structure_clone = Arc::clone(&nested_structure);
+                    thread::spawn(move || {
+                        let mut lock = nested_structure_clone.lock().unwrap();
+                        lock.entry(format!("thread_{}", i)).or_insert_with(|| HashSet::new()).insert(i * i);
+                    })
+                }).collect();
+
+                for handle in thread_handles {
+                    handle.join().unwrap();
+                }
+
+                println!("The final state of the nested structure is: {:?}", nested_structure.lock().unwrap());
+
+                let complex_expression = very_long_vector.iter().filter(|&&x| x % 2 == 0).map(|&x| x * x).fold(0, |acc, x| acc + x) + long_closure(5, 10, 15);
+
+                println!("The result of the complex expression is: {}", complex_expression);
+            }
+            ```"#.unindent(), cx);
+            thread
+        }));
    }
 }
--- a/crates/assistant2/src/ui/context_pill.rs
+++ b/crates/assistant2/src/ui/context_pill.rs
@@ -3,7 +3,7 @@ use std::rc::Rc;
 use gpui::ClickEvent;
 use ui::{prelude::*, IconButtonShape};

-use crate::context::Context;
+use crate::context::{Context, ContextKind};

 #[derive(IntoElement)]
 pub struct ContextPill {
@@ -27,15 +27,28 @@ impl ContextPill {

 impl RenderOnce for ContextPill {
    fn render(self, cx: &mut WindowContext) -> impl IntoElement {
+        let padding_right = if self.on_remove.is_some() {
+            px(2.)
+        } else {
+            px(4.)
+        };
+        let icon = match self.context.kind {
+            ContextKind::File(_) => IconName::File,
+            ContextKind::Directory => IconName::Folder,
+            ContextKind::FetchedUrl => IconName::Globe,
+            ContextKind::Thread(_) => IconName::MessageCircle,
+        };
+
        h_flex()
            .gap_1()
-            .pl_1p5()
-            .pr_0p5()
+            .pl_1()
+            .pr(padding_right)
            .pb(px(1.))
            .border_1()
            .border_color(cx.theme().colors().border.opacity(0.5))
            .bg(cx.theme().colors().element_background)
            .rounded_md()
+            .child(Icon::new(icon).size(IconSize::XSmall).color(Color::Muted))
            .child(Label::new(self.context.name.clone()).size(LabelSize::Small))
            .when_some(self.on_remove, |parent, on_remove| {
                parent.child(
--- a/crates/auto_update_ui/src/update_notification.rs
+++ b/crates/auto_update_ui/src/update_notification.rs
@@ -18,7 +18,7 @@ pub struct UpdateNotification {
 impl EventEmitter<DismissEvent> for UpdateNotification {}

 impl Render for UpdateNotification {
-    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> impl IntoElement {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
        let app_name = ReleaseChannel::global(cx).display_name();

        v_flex()
--- a/crates/breadcrumbs/Cargo.toml
+++ b/crates/breadcrumbs/Cargo.toml
@@ -16,10 +16,10 @@ doctest = false
 editor.workspace = true
 gpui.workspace = true
 itertools.workspace = true
-outline.workspace = true
 theme.workspace = true
 ui.workspace = true
 workspace.workspace = true
+zed_actions.workspace = true

 [dev-dependencies]
 editor = { workspace = true, features = ["test-support"] }
--- a/crates/breadcrumbs/src/breadcrumbs.rs
+++ b/crates/breadcrumbs/src/breadcrumbs.rs
@@ -102,8 +102,11 @@ impl Render for Breadcrumbs {
                    .on_click({
                        let editor = editor.clone();
                        move |_, cx| {
-                            if let Some(editor) = editor.upgrade() {
-                                outline::toggle(editor, &editor::actions::ToggleOutline, cx)
+                            if let Some((editor, callback)) = editor
+                                .upgrade()
+                                .zip(zed_actions::outline::TOGGLE_OUTLINE.get())
+                            {
+                                callback(editor.to_any(), cx);
                            }
                        }
                    })
@@ -112,14 +115,14 @@ impl Render for Breadcrumbs {
                            let focus_handle = editor.read(cx).focus_handle(cx);
                            Tooltip::for_action_in(
                                "Show Symbol Outline",
-                                &editor::actions::ToggleOutline,
+                                &zed_actions::outline::ToggleOutline,
                                &focus_handle,
                                cx,
                            )
                        } else {
                            Tooltip::for_action(
                                "Show Symbol Outline",
-                                &editor::actions::ToggleOutline,
+                                &zed_actions::outline::ToggleOutline,
                                cx,
                            )
                        }
--- a/crates/cli/Cargo.toml
+++ b/crates/cli/Cargo.toml
@@ -25,7 +25,6 @@ anyhow.workspace = true
 clap.workspace = true
 collections.workspace = true
 ipc-channel = "0.19"
-once_cell.workspace = true
 parking_lot.workspace = true
 paths.workspace = true
 release_channel.workspace = true
--- a/crates/cli/build.rs
+++ b/crates/cli/build.rs
@@ -2,4 +2,10 @@ fn main() {
    if std::env::var("ZED_UPDATE_EXPLANATION").is_ok() {
        println!(r#"cargo:rustc-cfg=feature="no-bundled-uninstall""#);
    }
+
+    if cfg!(target_os = "macos") {
+        println!("cargo:rustc-env=MACOSX_DEPLOYMENT_TARGET=10.15.7");
+        // Weakly link ScreenCaptureKit to ensure can be used on macOS 10.15+.
+        println!("cargo:rustc-link-arg=-Wl,-weak_framework,ScreenCaptureKit");
+    }
 }
--- a/crates/cli/src/main.rs
+++ b/crates/cli/src/main.rs
@@ -79,7 +79,7 @@ fn parse_path_with_position(argument_str: &str) -> anyhow::Result<String> {
        Ok(existing_path) => PathWithPosition::from_path(existing_path),
        Err(_) => {
            let path = PathWithPosition::parse_str(argument_str);
-            let curdir = env::current_dir().context("reteiving current directory")?;
+            let curdir = env::current_dir().context("retrieving current directory")?;
            path.map_path(|path| match fs::canonicalize(&path) {
                Ok(path) => Ok(path),
                Err(e) => {
@@ -277,6 +277,7 @@ mod linux {
        os::unix::net::{SocketAddr, UnixDatagram},
        path::{Path, PathBuf},
        process::{self, ExitStatus},
+        sync::LazyLock,
        thread,
        time::Duration,
    };
@@ -284,12 +285,11 @@ mod linux {
    use anyhow::anyhow;
    use cli::FORCE_CLI_MODE_ENV_VAR_NAME;
    use fork::Fork;
-    use once_cell::sync::Lazy;

    use crate::{Detect, InstalledApp};

-    static RELEASE_CHANNEL: Lazy<String> =
-        Lazy::new(|| include_str!("../../zed/RELEASE_CHANNEL").trim().to_string());
+    static RELEASE_CHANNEL: LazyLock<String> =
+        LazyLock::new(|| include_str!("../../zed/RELEASE_CHANNEL").trim().to_string());

    struct App(PathBuf);

--- a/crates/client/Cargo.toml
+++ b/crates/client/Cargo.toml
@@ -27,7 +27,6 @@ futures.workspace = true
 gpui.workspace = true
 http_client.workspace = true
 log.workspace = true
-once_cell.workspace = true
 paths.workspace = true
 parking_lot.workspace = true
 postage.workspace = true
--- a/crates/client/src/telemetry.rs
+++ b/crates/client/src/telemetry.rs
@@ -8,7 +8,6 @@ use futures::channel::mpsc;
 use futures::{Future, StreamExt};
 use gpui::{AppContext, BackgroundExecutor, Task};
 use http_client::{self, AsyncBody, HttpClient, HttpClientWithUrl, Method, Request};
-use once_cell::sync::Lazy;
 use parking_lot::Mutex;
 use release_channel::ReleaseChannel;
 use settings::{Settings, SettingsStore};
@@ -16,7 +15,12 @@ use sha2::{Digest, Sha256};
 use std::fs::File;
 use std::io::Write;
 use std::time::Instant;
-use std::{env, mem, path::PathBuf, sync::Arc, time::Duration};
+use std::{
+    env, mem,
+    path::PathBuf,
+    sync::{Arc, LazyLock},
+    time::Duration,
+};
 use telemetry_events::{
    AppEvent, AssistantEvent, CallEvent, EditEvent, Event, EventRequestBody, EventWrapper,
    InlineCompletionEvent,
@@ -84,7 +88,7 @@ const FLUSH_INTERVAL: Duration = Duration::from_secs(1);

 #[cfg(not(debug_assertions))]
 const FLUSH_INTERVAL: Duration = Duration::from_secs(60 * 5);
-static ZED_CLIENT_CHECKSUM_SEED: Lazy<Option<Vec<u8>>> = Lazy::new(|| {
+static ZED_CLIENT_CHECKSUM_SEED: LazyLock<Option<Vec<u8>>> = LazyLock::new(|| {
    option_env!("ZED_CLIENT_CHECKSUM_SEED")
        .map(|s| s.as_bytes().into())
        .or_else(|| {
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -106,6 +106,22 @@ CREATE TABLE "worktree_repositories" (
 CREATE INDEX "index_worktree_repositories_on_project_id" ON "worktree_repositories" ("project_id");
 CREATE INDEX "index_worktree_repositories_on_project_id_and_worktree_id" ON "worktree_repositories" ("project_id", "worktree_id");

+CREATE TABLE "worktree_repository_statuses" (
+    "project_id" INTEGER NOT NULL,
+    "worktree_id" INT8 NOT NULL,
+    "work_directory_id" INT8 NOT NULL,
+    "repo_path" VARCHAR NOT NULL,
+    "status" INT8 NOT NULL,
+    "scan_id" INT8 NOT NULL,
+    "is_deleted" BOOL NOT NULL,
+    PRIMARY KEY(project_id, worktree_id, work_directory_id, repo_path),
+    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
+    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
+);
+CREATE INDEX "index_wt_repos_statuses_on_project_id" ON "worktree_repository_statuses" ("project_id");
+CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id" ON "worktree_repository_statuses" ("project_id", "worktree_id");
+CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id_and_wd_id" ON "worktree_repository_statuses" ("project_id", "worktree_id", "work_directory_id");
+
 CREATE TABLE "worktree_settings_files" (
    "project_id" INTEGER NOT NULL,
    "worktree_id" INTEGER NOT NULL,
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -1,4 +1,5 @@
 use anyhow::Context as _;
+
 use util::ResultExt;

 use super::*;
@@ -274,8 +275,8 @@ impl Database {
                        mtime_nanos: ActiveValue::set(mtime.nanos as i32),
                        canonical_path: ActiveValue::set(entry.canonical_path.clone()),
                        is_ignored: ActiveValue::set(entry.is_ignored),
+                        git_status: ActiveValue::set(None),
                        is_external: ActiveValue::set(entry.is_external),
-                        git_status: ActiveValue::set(entry.git_status.map(|status| status as i64)),
                        is_deleted: ActiveValue::set(false),
                        scan_id: ActiveValue::set(update.scan_id as i64),
                        is_fifo: ActiveValue::set(entry.is_fifo),
@@ -295,7 +296,6 @@ impl Database {
                        worktree_entry::Column::MtimeNanos,
                        worktree_entry::Column::CanonicalPath,
                        worktree_entry::Column::IsIgnored,
-                        worktree_entry::Column::GitStatus,
                        worktree_entry::Column::ScanId,
                    ])
                    .to_owned(),
@@ -349,6 +349,79 @@ impl Database {
                )
                .exec(&*tx)
                .await?;
+
+                let has_any_statuses = update
+                    .updated_repositories
+                    .iter()
+                    .any(|repository| !repository.updated_statuses.is_empty());
+
+                if has_any_statuses {
+                    worktree_repository_statuses::Entity::insert_many(
+                        update.updated_repositories.iter().flat_map(
+                            |repository: &proto::RepositoryEntry| {
+                                repository.updated_statuses.iter().map(|status_entry| {
+                                    worktree_repository_statuses::ActiveModel {
+                                        project_id: ActiveValue::set(project_id),
+                                        worktree_id: ActiveValue::set(worktree_id),
+                                        work_directory_id: ActiveValue::set(
+                                            repository.work_directory_id as i64,
+                                        ),
+                                        scan_id: ActiveValue::set(update.scan_id as i64),
+                                        is_deleted: ActiveValue::set(false),
+                                        repo_path: ActiveValue::set(status_entry.repo_path.clone()),
+                                        status: ActiveValue::set(status_entry.status as i64),
+                                    }
+                                })
+                            },
+                        ),
+                    )
+                    .on_conflict(
+                        OnConflict::columns([
+                            worktree_repository_statuses::Column::ProjectId,
+                            worktree_repository_statuses::Column::WorktreeId,
+                            worktree_repository_statuses::Column::WorkDirectoryId,
+                            worktree_repository_statuses::Column::RepoPath,
+                        ])
+                        .update_columns([
+                            worktree_repository_statuses::Column::ScanId,
+                            worktree_repository_statuses::Column::Status,
+                        ])
+                        .to_owned(),
+                    )
+                    .exec(&*tx)
+                    .await?;
+                }
+
+                let has_any_removed_statuses = update
+                    .updated_repositories
+                    .iter()
+                    .any(|repository| !repository.removed_statuses.is_empty());
+
+                if has_any_removed_statuses {
+                    worktree_repository_statuses::Entity::update_many()
+                        .filter(
+                            worktree_repository_statuses::Column::ProjectId
+                                .eq(project_id)
+                                .and(
+                                    worktree_repository_statuses::Column::WorktreeId
+                                        .eq(worktree_id),
+                                )
+                                .and(
+                                    worktree_repository_statuses::Column::RepoPath.is_in(
+                                        update.updated_repositories.iter().flat_map(|repository| {
+                                            repository.removed_statuses.iter()
+                                        }),
+                                    ),
+                                ),
+                        )
+                        .set(worktree_repository_statuses::ActiveModel {
+                            is_deleted: ActiveValue::Set(true),
+                            scan_id: ActiveValue::Set(update.scan_id as i64),
+                            ..Default::default()
+                        })
+                        .exec(&*tx)
+                        .await?;
+                }
            }

            if !update.removed_repositories.is_empty() {
@@ -643,7 +716,6 @@ impl Database {
                        canonical_path: db_entry.canonical_path,
                        is_ignored: db_entry.is_ignored,
                        is_external: db_entry.is_external,
-                        git_status: db_entry.git_status.map(|status| status as i32),
                        // This is only used in the summarization backlog, so if it's None,
                        // that just means we won't be able to detect when to resummarize
                        // based on total number of backlogged bytes - instead, we'd go
@@ -657,23 +729,49 @@ impl Database {

        // Populate repository entries.
        {
-            let mut db_repository_entries = worktree_repository::Entity::find()
+            let db_repository_entries = worktree_repository::Entity::find()
                .filter(
                    Condition::all()
                        .add(worktree_repository::Column::ProjectId.eq(project.id))
                        .add(worktree_repository::Column::IsDeleted.eq(false)),
                )
-                .stream(tx)
+                .all(tx)
                .await?;
-            while let Some(db_repository_entry) = db_repository_entries.next().await {
-                let db_repository_entry = db_repository_entry?;
+            for db_repository_entry in db_repository_entries {
                if let Some(worktree) = worktrees.get_mut(&(db_repository_entry.worktree_id as u64))
                {
+                    let mut repository_statuses = worktree_repository_statuses::Entity::find()
+                        .filter(
+                            Condition::all()
+                                .add(worktree_repository_statuses::Column::ProjectId.eq(project.id))
+                                .add(
+                                    worktree_repository_statuses::Column::WorktreeId
+                                        .eq(worktree.id),
+                                )
+                                .add(
+                                    worktree_repository_statuses::Column::WorkDirectoryId
+                                        .eq(db_repository_entry.work_directory_id),
+                                )
+                                .add(worktree_repository_statuses::Column::IsDeleted.eq(false)),
+                        )
+                        .stream(tx)
+                        .await?;
+                    let mut updated_statuses = Vec::new();
+                    while let Some(status_entry) = repository_statuses.next().await {
+                        let status_entry: worktree_repository_statuses::Model = status_entry?;
+                        updated_statuses.push(proto::StatusEntry {
+                            repo_path: status_entry.repo_path,
+                            status: status_entry.status as i32,
+                        });
+                    }
+
                    worktree.repository_entries.insert(
                        db_repository_entry.work_directory_id as u64,
                        proto::RepositoryEntry {
                            work_directory_id: db_repository_entry.work_directory_id as u64,
                            branch: db_repository_entry.branch,
+                            updated_statuses,
+                            removed_statuses: Vec::new(),
                        },
                    );
                }
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -662,7 +662,6 @@ impl Database {
                            canonical_path: db_entry.canonical_path,
                            is_ignored: db_entry.is_ignored,
                            is_external: db_entry.is_external,
-                            git_status: db_entry.git_status.map(|status| status as i32),
                            // This is only used in the summarization backlog, so if it's None,
                            // that just means we won't be able to detect when to resummarize
                            // based on total number of backlogged bytes - instead, we'd go
@@ -682,26 +681,69 @@ impl Database {
                    worktree_repository::Column::IsDeleted.eq(false)
                };

-                let mut db_repositories = worktree_repository::Entity::find()
+                let db_repositories = worktree_repository::Entity::find()
                    .filter(
                        Condition::all()
                            .add(worktree_repository::Column::ProjectId.eq(project.id))
                            .add(worktree_repository::Column::WorktreeId.eq(worktree.id))
                            .add(repository_entry_filter),
                    )
-                    .stream(tx)
+                    .all(tx)
                    .await?;

-                while let Some(db_repository) = db_repositories.next().await {
-                    let db_repository = db_repository?;
+                for db_repository in db_repositories.into_iter() {
                    if db_repository.is_deleted {
                        worktree
                            .removed_repositories
                            .push(db_repository.work_directory_id as u64);
                    } else {
+                        let status_entry_filter = if let Some(rejoined_worktree) = rejoined_worktree
+                        {
+                            worktree_repository_statuses::Column::ScanId
+                                .gt(rejoined_worktree.scan_id)
+                        } else {
+                            worktree_repository_statuses::Column::IsDeleted.eq(false)
+                        };
+
+                        let mut db_statuses = worktree_repository_statuses::Entity::find()
+                            .filter(
+                                Condition::all()
+                                    .add(
+                                        worktree_repository_statuses::Column::ProjectId
+                                            .eq(project.id),
+                                    )
+                                    .add(
+                                        worktree_repository_statuses::Column::WorktreeId
+                                            .eq(worktree.id),
+                                    )
+                                    .add(
+                                        worktree_repository_statuses::Column::WorkDirectoryId
+                                            .eq(db_repository.work_directory_id),
+                                    )
+                                    .add(status_entry_filter),
+                            )
+                            .stream(tx)
+                            .await?;
+                        let mut removed_statuses = Vec::new();
+                        let mut updated_statuses = Vec::new();
+
+                        while let Some(db_status) = db_statuses.next().await {
+                            let db_status: worktree_repository_statuses::Model = db_status?;
+                            if db_status.is_deleted {
+                                removed_statuses.push(db_status.repo_path);
+                            } else {
+                                updated_statuses.push(proto::StatusEntry {
+                                    repo_path: db_status.repo_path,
+                                    status: db_status.status as i32,
+                                });
+                            }
+                        }
+
                        worktree.updated_repositories.push(proto::RepositoryEntry {
                            work_directory_id: db_repository.work_directory_id as u64,
                            branch: db_repository.branch,
+                            updated_statuses,
+                            removed_statuses,
                        });
                    }
                }
--- a/crates/collab/src/tests/integration_tests.rs
+++ b/crates/collab/src/tests/integration_tests.rs
@@ -2925,8 +2925,6 @@ async fn test_git_status_sync(
        assert_eq!(snapshot.status_for_file(file), status);
    }

-    // Smoke test status reading
-
    project_local.read_with(cx_a, |project, cx| {
        assert_status(&Path::new(A_TXT), Some(GitFileStatus::Added), project, cx);
        assert_status(&Path::new(B_TXT), Some(GitFileStatus::Added), project, cx);
@@ -4067,7 +4065,7 @@ async fn test_collaborating_with_diagnostics(
                DiagnosticEntry {
                    range: Point::new(0, 4)..Point::new(0, 7),
                    diagnostic: Diagnostic {
-                        group_id: 2,
+                        group_id: 3,
                        message: "message 1".to_string(),
                        severity: lsp::DiagnosticSeverity::ERROR,
                        is_primary: true,
@@ -4077,7 +4075,7 @@ async fn test_collaborating_with_diagnostics(
                DiagnosticEntry {
                    range: Point::new(0, 10)..Point::new(0, 13),
                    diagnostic: Diagnostic {
-                        group_id: 3,
+                        group_id: 4,
                        severity: lsp::DiagnosticSeverity::WARNING,
                        message: "message 2".to_string(),
                        is_primary: true,
@@ -6669,6 +6667,10 @@ async fn test_remote_git_branches(
    client_a
        .fs()
        .insert_branches(Path::new("/project/.git"), &branches);
+    let branches_set = branches
+        .into_iter()
+        .map(ToString::to_string)
+        .collect::<HashSet<_>>();

    let (project_a, worktree_id) = client_a.build_local_project("/project", cx_a).await;
    let project_id = active_call_a
@@ -6690,10 +6692,10 @@ async fn test_remote_git_branches(

    let branches_b = branches_b
        .into_iter()
-        .map(|branch| branch.name)
-        .collect::<Vec<_>>();
+        .map(|branch| branch.name.to_string())
+        .collect::<HashSet<_>>();

-    assert_eq!(&branches_b, &branches);
+    assert_eq!(branches_b, branches_set);

    cx_b.update(|cx| {
        project_b.update(cx, |project, cx| {
--- a/crates/collab/src/tests/remote_editing_collaboration_tests.rs
+++ b/crates/collab/src/tests/remote_editing_collaboration_tests.rs
@@ -229,6 +229,10 @@ async fn test_ssh_collaboration_git_branches(
        .await;

    let branches = ["main", "dev", "feature-1"];
+    let branches_set = branches
+        .iter()
+        .map(ToString::to_string)
+        .collect::<HashSet<_>>();
    remote_fs.insert_branches(Path::new("/project/.git"), &branches);

    // User A connects to the remote project via SSH.
@@ -281,10 +285,10 @@ async fn test_ssh_collaboration_git_branches(

    let branches_b = branches_b
        .into_iter()
-        .map(|branch| branch.name)
-        .collect::<Vec<_>>();
+        .map(|branch| branch.name.to_string())
+        .collect::<HashSet<_>>();

-    assert_eq!(&branches_b, &branches);
+    assert_eq!(&branches_b, &branches_set);

    cx_b.update(|cx| {
        project_b.update(cx, |project, cx| {
--- a/crates/collab_ui/src/chat_panel.rs
+++ b/crates/collab_ui/src/chat_panel.rs
@@ -1096,7 +1096,7 @@ impl FocusableView for ChatPanel {
 }

 impl Panel for ChatPanel {
-    fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
+    fn position(&self, cx: &WindowContext) -> DockPosition {
        ChatPanelSettings::get_global(cx).dock
    }

@@ -1112,7 +1112,7 @@ impl Panel for ChatPanel {
        );
    }

-    fn size(&self, cx: &gpui::WindowContext) -> Pixels {
+    fn size(&self, cx: &WindowContext) -> Pixels {
        self.width
            .unwrap_or_else(|| ChatPanelSettings::get_global(cx).default_width)
    }
@@ -1135,14 +1135,20 @@ impl Panel for ChatPanel {
    }

    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName> {
-        match ChatPanelSettings::get_global(cx).button {
-            ChatPanelButton::Never => None,
-            ChatPanelButton::Always => Some(ui::IconName::MessageBubbles),
-            ChatPanelButton::WhenInCall => ActiveCall::global(cx)
-                .read(cx)
-                .room()
-                .map(|_| ui::IconName::MessageBubbles),
-        }
+        let show_icon = match ChatPanelSettings::get_global(cx).button {
+            ChatPanelButton::Never => false,
+            ChatPanelButton::Always => true,
+            ChatPanelButton::WhenInCall => {
+                let is_in_call = ActiveCall::global(cx)
+                    .read(cx)
+                    .room()
+                    .map_or(false, |room| room.read(cx).contains_guests());
+
+                self.active || is_in_call
+            }
+        };
+
+        show_icon.then(|| ui::IconName::MessageBubbles)
    }

    fn icon_tooltip(&self, _cx: &WindowContext) -> Option<&'static str> {
@@ -1159,6 +1165,10 @@ impl Panel for ChatPanel {
            .room()
            .is_some_and(|room| room.read(cx).contains_guests())
    }
+
+    fn activation_priority(&self) -> u32 {
+        7
+    }
 }

 impl EventEmitter<PanelEvent> for ChatPanel {}
--- a/crates/collab_ui/src/chat_panel/message_editor.rs
+++ b/crates/collab_ui/src/chat_panel/message_editor.rs
@@ -79,16 +79,6 @@ impl CompletionProvider for MessageEditorCompletionProvider {
        Task::ready(Ok(false))
    }

-    fn apply_additional_edits_for_completion(
-        &self,
-        _buffer: Model<Buffer>,
-        _completion: Completion,
-        _push_to_history: bool,
-        _cx: &mut ViewContext<Editor>,
-    ) -> Task<Result<Option<language::Transaction>>> {
-        Task::ready(Ok(None))
-    }
-
    fn is_completion_trigger(
        &self,
        _buffer: &Model<Buffer>,
@@ -319,6 +309,7 @@ impl MessageEditor {
                    server_id: LanguageServerId(0), // TODO: Make this optional or something?
                    lsp_completion: Default::default(), // TODO: Make this optional or something?
                    confirm: None,
+                    resolved: true,
                }
            })
            .collect()
--- a/crates/collab_ui/src/collab_panel.rs
+++ b/crates/collab_ui/src/collab_panel.rs
@@ -2719,7 +2719,7 @@ impl Render for CollabPanel {
 impl EventEmitter<PanelEvent> for CollabPanel {}

 impl Panel for CollabPanel {
-    fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
+    fn position(&self, cx: &WindowContext) -> DockPosition {
        CollaborationPanelSettings::get_global(cx).dock
    }

@@ -2735,7 +2735,7 @@ impl Panel for CollabPanel {
        );
    }

-    fn size(&self, cx: &gpui::WindowContext) -> Pixels {
+    fn size(&self, cx: &WindowContext) -> Pixels {
        self.width
            .unwrap_or_else(|| CollaborationPanelSettings::get_global(cx).default_width)
    }
@@ -2746,7 +2746,7 @@ impl Panel for CollabPanel {
        cx.notify();
    }

-    fn icon(&self, cx: &gpui::WindowContext) -> Option<ui::IconName> {
+    fn icon(&self, cx: &WindowContext) -> Option<ui::IconName> {
        CollaborationPanelSettings::get_global(cx)
            .button
            .then_some(ui::IconName::UserGroup)
@@ -2763,6 +2763,10 @@ impl Panel for CollabPanel {
    fn persistent_name() -> &'static str {
        "CollabPanel"
    }
+
+    fn activation_priority(&self) -> u32 {
+        6
+    }
 }

 impl FocusableView for CollabPanel {
--- a/crates/collab_ui/src/notification_panel.rs
+++ b/crates/collab_ui/src/notification_panel.rs
@@ -662,7 +662,7 @@ impl Panel for NotificationPanel {
        "NotificationPanel"
    }

-    fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
+    fn position(&self, cx: &WindowContext) -> DockPosition {
        NotificationPanelSettings::get_global(cx).dock
    }

@@ -678,7 +678,7 @@ impl Panel for NotificationPanel {
        );
    }

-    fn size(&self, cx: &gpui::WindowContext) -> Pixels {
+    fn size(&self, cx: &WindowContext) -> Pixels {
        self.width
            .unwrap_or_else(|| NotificationPanelSettings::get_global(cx).default_width)
    }
@@ -702,7 +702,7 @@ impl Panel for NotificationPanel {
        }
    }

-    fn icon(&self, cx: &gpui::WindowContext) -> Option<IconName> {
+    fn icon(&self, cx: &WindowContext) -> Option<IconName> {
        let show_button = NotificationPanelSettings::get_global(cx).button;
        if !show_button {
            return None;
@@ -731,6 +731,10 @@ impl Panel for NotificationPanel {
    fn toggle_action(&self) -> Box<dyn gpui::Action> {
        Box::new(ToggleFocus)
    }
+
+    fn activation_priority(&self) -> u32 {
+        8
+    }
 }

 pub struct NotificationToast {
--- a/crates/collections/Cargo.toml
+++ b/crates/collections/Cargo.toml
@@ -16,4 +16,5 @@ doctest = false
 test-support = []

 [dependencies]
-rustc-hash = "1.1"
+indexmap.workspace = true
+rustc-hash.workspace = true
--- a/crates/collections/src/collections.rs
+++ b/crates/collections/src/collections.rs
@@ -4,12 +4,24 @@ pub type HashMap<K, V> = FxHashMap<K, V>;
 #[cfg(feature = "test-support")]
 pub type HashSet<T> = FxHashSet<T>;

+#[cfg(feature = "test-support")]
+pub type IndexMap<K, V> = indexmap::IndexMap<K, V, rustc_hash::FxBuildHasher>;
+
+#[cfg(feature = "test-support")]
+pub type IndexSet<T> = indexmap::IndexSet<T, rustc_hash::FxBuildHasher>;
+
 #[cfg(not(feature = "test-support"))]
 pub type HashMap<K, V> = std::collections::HashMap<K, V>;

 #[cfg(not(feature = "test-support"))]
 pub type HashSet<T> = std::collections::HashSet<T>;

+#[cfg(not(feature = "test-support"))]
+pub type IndexMap<K, V> = indexmap::IndexMap<K, V>;
+
+#[cfg(not(feature = "test-support"))]
+pub type IndexSet<T> = indexmap::IndexSet<T>;
+
 pub use rustc_hash::FxHasher;
 pub use rustc_hash::{FxHashMap, FxHashSet};
 pub use std::collections::*;
--- a/crates/context_server/Cargo.toml
+++ b/crates/context_server/Cargo.toml
@@ -28,7 +28,6 @@ serde.workspace = true
 serde_json.workspace = true
 settings.workspace = true
 smol.workspace = true
-ui.workspace = true
 url = { workspace = true, features = ["serde"] }
 util.workspace = true
 workspace.workspace = true
--- a/crates/context_server/src/context_server_tool.rs
+++ b/crates/context_server/src/context_server_tool.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;

 use anyhow::{anyhow, bail};
 use assistant_tool::Tool;
-use gpui::{Model, Task};
+use gpui::{Model, Task, WindowContext};

 use crate::manager::ContextServerManager;
 use crate::types;
@@ -52,7 +52,7 @@ impl Tool for ContextServerTool {
        self: std::sync::Arc<Self>,
        input: serde_json::Value,
        _workspace: gpui::WeakView<workspace::Workspace>,
-        cx: &mut ui::WindowContext,
+        cx: &mut WindowContext,
    ) -> gpui::Task<gpui::Result<String>> {
        if let Some(server) = self.server_manager.read(cx).get_server(&self.server_id) {
            cx.foreground_executor().spawn({
--- a/crates/copilot/src/copilot_chat.rs
+++ b/crates/copilot/src/copilot_chat.rs
@@ -34,9 +34,9 @@ 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")]
+    #[serde(alias = "o1-preview", rename = "o1")]
    O1Preview,
-    #[serde(alias = "o1-mini", rename = "o1-mini-2024-09-12")]
+    #[serde(alias = "o1-mini", rename = "o1-mini")]
    O1Mini,
    #[serde(alias = "claude-3-5-sonnet", rename = "claude-3.5-sonnet")]
    Claude3_5Sonnet,
--- a/crates/diagnostics/src/diagnostics.rs
+++ b/crates/diagnostics/src/diagnostics.rs
@@ -166,7 +166,7 @@ impl ProjectDiagnosticsEditor {
        let excerpts = cx.new_model(|cx| MultiBuffer::new(project_handle.read(cx).capability()));
        let editor = cx.new_view(|cx| {
            let mut editor =
-                Editor::for_multibuffer(excerpts.clone(), Some(project_handle.clone()), false, cx);
+                Editor::for_multibuffer(excerpts.clone(), Some(project_handle.clone()), true, cx);
            editor.set_vertical_scroll_margin(5, cx);
            editor
        });
@@ -836,65 +836,76 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
    let (message, code_ranges) = highlight_diagnostic_message(&diagnostic, None);
    let message: SharedString = message;
    Arc::new(move |cx| {
-        let highlight_style: HighlightStyle = cx.theme().colors().text_accent.into();
+        let color = cx.theme().colors();
+        let highlight_style: HighlightStyle = color.text_accent.into();
+
        h_flex()
            .id(DIAGNOSTIC_HEADER)
-            .block_mouse_down()
-            .h(2. * cx.line_height())
-            .pl_10()
-            .pr_5()
            .w_full()
-            .justify_between()
-            .gap_2()
+            .relative()
            .child(
-                h_flex()
-                    .gap_3()
-                    .map(|stack| {
-                        stack.child(
-                            svg()
-                                .size(cx.text_style().font_size)
-                                .flex_none()
-                                .map(|icon| {
-                                    if diagnostic.severity == DiagnosticSeverity::ERROR {
-                                        icon.path(IconName::XCircle.path())
-                                            .text_color(Color::Error.color(cx))
-                                    } else {
-                                        icon.path(IconName::Warning.path())
-                                            .text_color(Color::Warning.color(cx))
-                                    }
-                                }),
-                        )
-                    })
-                    .child(
-                        h_flex()
-                            .gap_1()
-                            .child(
-                                StyledText::new(message.clone()).with_highlights(
-                                    &cx.text_style(),
-                                    code_ranges
-                                        .iter()
-                                        .map(|range| (range.clone(), highlight_style)),
-                                ),
-                            )
-                            .when_some(diagnostic.code.as_ref(), |stack, code| {
-                                stack.child(
-                                    div()
-                                        .child(SharedString::from(format!("({code})")))
-                                        .text_color(cx.theme().colors().text_muted),
-                                )
-                            }),
-                    ),
+                div()
+                    .top(px(0.))
+                    .absolute()
+                    .w_full()
+                    .h_px()
+                    .bg(color.border_variant),
            )
            .child(
                h_flex()
-                    .gap_1()
-                    .when_some(diagnostic.source.as_ref(), |stack, source| {
-                        stack.child(
-                            div()
-                                .child(SharedString::from(source.clone()))
-                                .text_color(cx.theme().colors().text_muted),
-                        )
-                    }),
+                    .block_mouse_down()
+                    .h(2. * cx.line_height())
+                    .pl_10()
+                    .pr_5()
+                    .w_full()
+                    .justify_between()
+                    .gap_2()
+                    .child(
+                        h_flex()
+                            .gap_3()
+                            .map(|stack| {
+                                stack.child(svg().size(cx.text_style().font_size).flex_none().map(
+                                    |icon| {
+                                        if diagnostic.severity == DiagnosticSeverity::ERROR {
+                                            icon.path(IconName::XCircle.path())
+                                                .text_color(Color::Error.color(cx))
+                                        } else {
+                                            icon.path(IconName::Warning.path())
+                                                .text_color(Color::Warning.color(cx))
+                                        }
+                                    },
+                                ))
+                            })
+                            .child(
+                                h_flex()
+                                    .gap_1()
+                                    .child(
+                                        StyledText::new(message.clone()).with_highlights(
+                                            &cx.text_style(),
+                                            code_ranges
+                                                .iter()
+                                                .map(|range| (range.clone(), highlight_style)),
+                                        ),
+                                    )
+                                    .when_some(diagnostic.code.as_ref(), |stack, code| {
+                                        stack.child(
+                                            div()
+                                                .child(SharedString::from(format!("({code})")))
+                                                .text_color(cx.theme().colors().text_muted),
+                                        )
+                                    }),
+                            ),
+                    )
+                    .child(h_flex().gap_1().when_some(
+                        diagnostic.source.as_ref(),
+                        |stack, source| {
+                            stack.child(
+                                div()
+                                    .child(SharedString::from(source.clone()))
+                                    .text_color(cx.theme().colors().text_muted),
+                            )
+                        },
+                    )),
            )
            .into_any_element()
    })
--- a/crates/diagnostics/src/diagnostics_tests.rs
+++ b/crates/diagnostics/src/diagnostics_tests.rs
@@ -82,7 +82,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::INFORMATION,
                            is_primary: false,
                            is_disk_based: true,
-                            group_id: 1,
+                            group_id: 2,
                            ..Default::default()
                        },
                    },
@@ -95,7 +95,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::INFORMATION,
                            is_primary: false,
                            is_disk_based: true,
-                            group_id: 0,
+                            group_id: 1,
                            ..Default::default()
                        },
                    },
@@ -106,7 +106,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::INFORMATION,
                            is_primary: false,
                            is_disk_based: true,
-                            group_id: 1,
+                            group_id: 2,
                            ..Default::default()
                        },
                    },
@@ -117,7 +117,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::INFORMATION,
                            is_primary: false,
                            is_disk_based: true,
-                            group_id: 0,
+                            group_id: 1,
                            ..Default::default()
                        },
                    },
@@ -128,7 +128,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::ERROR,
                            is_primary: true,
                            is_disk_based: true,
-                            group_id: 0,
+                            group_id: 1,
                            ..Default::default()
                        },
                    },
@@ -139,7 +139,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::ERROR,
                            is_primary: true,
                            is_disk_based: true,
-                            group_id: 1,
+                            group_id: 2,
                            ..Default::default()
                        },
                    },
@@ -167,10 +167,10 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(15), EXCERPT_HEADER.into()),
-            (DisplayRow(16), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(25), EXCERPT_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(16), EXCERPT_HEADER.into()),
+            (DisplayRow(18), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(27), EXCERPT_HEADER.into()),
        ]
    );
    assert_eq!(
@@ -184,6 +184,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
            "    let x = vec![];\n",
            "    let y = vec![];\n",
            "\n", // supporting diagnostic
@@ -195,6 +196,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            "    c(y);\n",
            "\n", // supporting diagnostic
            "    d(x);\n",
+            "\n", // expand
            "\n", // context ellipsis
            // diagnostic group 2
            "\n", // primary message
@@ -206,11 +208,13 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            "    a(x);\n",
            "\n", // supporting diagnostic
            "    b(y);\n",
+            "\n", // expand
            "\n", // context ellipsis
            "    c(y);\n",
            "    d(x);\n",
            "\n", // supporting diagnostic
-            "}"
+            "}",
+            "\n", // expand
        )
    );

@@ -218,7 +222,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
    editor.update(cx, |editor, cx| {
        assert_eq!(
            editor.selections.display_ranges(cx),
-            [DisplayPoint::new(DisplayRow(12), 6)..DisplayPoint::new(DisplayRow(12), 6)]
+            [DisplayPoint::new(DisplayRow(13), 6)..DisplayPoint::new(DisplayRow(13), 6)]
        );
    });

@@ -237,7 +241,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                        severity: DiagnosticSeverity::ERROR,
                        is_primary: true,
                        is_disk_based: true,
-                        group_id: 0,
+                        group_id: 1,
                        ..Default::default()
                    },
                }],
@@ -253,12 +257,12 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(7), FILE_HEADER.into()),
-            (DisplayRow(9), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(22), EXCERPT_HEADER.into()),
-            (DisplayRow(23), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(32), EXCERPT_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(8), FILE_HEADER.into()),
+            (DisplayRow(12), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(25), EXCERPT_HEADER.into()),
+            (DisplayRow(27), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(36), EXCERPT_HEADER.into()),
        ]
    );

@@ -273,6 +277,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
            "const a: i32 = 'a';\n",
            "\n", // supporting diagnostic
            "const b: i32 = c;\n",
@@ -284,6 +289,8 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
+            "\n", // expand
            "    let x = vec![];\n",
            "    let y = vec![];\n",
            "\n", // supporting diagnostic
@@ -299,6 +306,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 2
            "\n", // primary message
            "\n", // filename
+            "\n", // expand
            "fn main() {\n",
            "    let x = vec![];\n",
            "\n", // supporting diagnostic
@@ -306,11 +314,13 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            "    a(x);\n",
            "\n", // supporting diagnostic
            "    b(y);\n",
+            "\n", // expand
            "\n", // context ellipsis
            "    c(y);\n",
            "    d(x);\n",
            "\n", // supporting diagnostic
-            "}"
+            "}",
+            "\n", // expand
        )
    );

@@ -318,7 +328,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
    editor.update(cx, |editor, cx| {
        assert_eq!(
            editor.selections.display_ranges(cx),
-            [DisplayPoint::new(DisplayRow(19), 6)..DisplayPoint::new(DisplayRow(19), 6)]
+            [DisplayPoint::new(DisplayRow(22), 6)..DisplayPoint::new(DisplayRow(22), 6)]
        );
    });

@@ -338,7 +348,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::ERROR,
                            is_primary: true,
                            is_disk_based: true,
-                            group_id: 0,
+                            group_id: 1,
                            ..Default::default()
                        },
                    },
@@ -349,7 +359,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
                            severity: DiagnosticSeverity::ERROR,
                            is_primary: true,
                            is_disk_based: true,
-                            group_id: 1,
+                            group_id: 2,
                            ..Default::default()
                        },
                    },
@@ -366,14 +376,14 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(7), EXCERPT_HEADER.into()),
-            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(13), FILE_HEADER.into()),
-            (DisplayRow(15), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(28), EXCERPT_HEADER.into()),
-            (DisplayRow(29), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(38), EXCERPT_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(8), EXCERPT_HEADER.into()),
+            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(15), FILE_HEADER.into()),
+            (DisplayRow(19), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(32), EXCERPT_HEADER.into()),
+            (DisplayRow(34), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(43), EXCERPT_HEADER.into()),
        ]
    );

@@ -388,6 +398,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
            "const a: i32 = 'a';\n",
            "\n", // supporting diagnostic
            "const b: i32 = c;\n",
@@ -395,6 +406,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 2
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
            "const a: i32 = 'a';\n",
            "const b: i32 = c;\n",
            "\n", // supporting diagnostic
@@ -406,6 +418,8 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n", // primary message
            "\n", // padding
+            "\n", // expand
+            "\n", // expand
            "    let x = vec![];\n",
            "    let y = vec![];\n",
            "\n", // supporting diagnostic
@@ -421,6 +435,7 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            // diagnostic group 2
            "\n", // primary message
            "\n", // filename
+            "\n", // expand
            "fn main() {\n",
            "    let x = vec![];\n",
            "\n", // supporting diagnostic
@@ -428,11 +443,13 @@ async fn test_diagnostics(cx: &mut TestAppContext) {
            "    a(x);\n",
            "\n", // supporting diagnostic
            "    b(y);\n",
+            "\n", // expand
            "\n", // context ellipsis
            "    c(y);\n",
            "    d(x);\n",
            "\n", // supporting diagnostic
-            "}"
+            "}",
+            "\n", // expand
        )
    );
 }
@@ -513,7 +530,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
        ]
    );
    assert_eq!(
@@ -524,8 +541,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n",     // primary message
            "\n",     // padding
+            "\n",     // expand
            "a();\n", //
-            "b();",
+            "b();", "\n", // expand
        )
    );

@@ -561,9 +579,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(6), EXCERPT_HEADER.into()),
-            (DisplayRow(7), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(7), EXCERPT_HEADER.into()),
+            (DisplayRow(9), DIAGNOSTIC_HEADER.into()),
        ]
    );
    assert_eq!(
@@ -574,8 +592,10 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n",     // primary message
            "\n",     // padding
+            "\n",     // expand
            "a();\n", // location
            "b();\n", //
+            "\n",     // expand
            "\n",     // collapsed context
            // diagnostic group 2
            "\n",     // primary message
@@ -583,6 +603,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            "a();\n", // context
            "b();\n", //
            "c();",   // context
+            "\n",     // expand
        )
    );

@@ -629,9 +650,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(7), EXCERPT_HEADER.into()),
-            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(8), EXCERPT_HEADER.into()),
+            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
        ]
    );
    assert_eq!(
@@ -642,9 +663,11 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n",     // primary message
            "\n",     // padding
+            "\n",     // expand
            "a();\n", // location
            "b();\n", //
            "c();\n", // context
+            "\n",     // expand
            "\n",     // collapsed context
            // diagnostic group 2
            "\n",     // primary message
@@ -652,6 +675,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            "b();\n", // context
            "c();\n", //
            "d();",   // context
+            "\n",     // expand
        )
    );

@@ -687,9 +711,9 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
        editor_blocks(&editor, cx),
        [
            (DisplayRow(0), FILE_HEADER.into()),
-            (DisplayRow(2), DIAGNOSTIC_HEADER.into()),
-            (DisplayRow(7), EXCERPT_HEADER.into()),
-            (DisplayRow(8), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(3), DIAGNOSTIC_HEADER.into()),
+            (DisplayRow(8), EXCERPT_HEADER.into()),
+            (DisplayRow(10), DIAGNOSTIC_HEADER.into()),
        ]
    );
    assert_eq!(
@@ -700,9 +724,11 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            // diagnostic group 1
            "\n",     // primary message
            "\n",     // padding
+            "\n",     // expand
            "b();\n", // location
            "c();\n", //
            "d();\n", // context
+            "\n",     // expand
            "\n",     // collapsed context
            // diagnostic group 2
            "\n",     // primary message
@@ -710,6 +736,7 @@ async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
            "c();\n", // context
            "d();\n", //
            "e();",   // context
+            "\n",     // expand
        )
    );
 }
@@ -748,7 +775,7 @@ async fn test_random_diagnostics(cx: &mut TestAppContext, mut rng: StdRng) {
        assert!(view.focus_handle.is_focused(cx));
    });

-    let mut next_group_id = 0;
+    let mut next_group_id = 1;
    let mut next_filename = 0;
    let mut language_server_ids = vec![LanguageServerId(0)];
    let mut updated_language_servers = HashSet::default();
--- a/crates/diagnostics/src/items.rs
+++ b/crates/diagnostics/src/items.rs
@@ -1,11 +1,11 @@
 use std::time::Duration;

-use editor::Editor;
+use editor::{AnchorRangeExt, Editor};
 use gpui::{
    EventEmitter, IntoElement, ParentElement, Render, Styled, Subscription, Task, View,
    ViewContext, WeakView,
 };
-use language::Diagnostic;
+use language::{Diagnostic, DiagnosticEntry};
 use ui::{h_flex, prelude::*, Button, ButtonLike, Color, Icon, IconName, Label, Tooltip};
 use workspace::{item::ItemHandle, StatusItemView, ToolbarItemEvent, Workspace};

@@ -148,7 +148,11 @@ impl DiagnosticIndicator {
            (buffer, cursor_position)
        });
        let new_diagnostic = buffer
-            .diagnostics_in_range::<_, usize>(cursor_position..cursor_position, false)
+            .diagnostics_in_range(cursor_position..cursor_position, false)
+            .map(|DiagnosticEntry { diagnostic, range }| DiagnosticEntry {
+                diagnostic,
+                range: range.to_offset(&buffer),
+            })
            .filter(|entry| !entry.range.is_empty())
            .min_by_key(|entry| (entry.diagnostic.severity, entry.range.len()))
            .map(|entry| entry.diagnostic);
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -388,6 +388,4 @@ gpui::actions!(
    ]
 );

-action_as!(outline, ToggleOutline as Toggle);
-
 action_as!(go_to_line, ToggleGoToLine as Toggle);
--- a/crates/editor/src/clangd_ext.rs
+++ b/crates/editor/src/clangd_ext.rs
@@ -16,7 +16,7 @@ fn is_c_language(language: &Language) -> bool {
 pub fn switch_source_header(
    editor: &mut Editor,
    _: &SwitchSourceHeader,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) {
    let Some(project) = &editor.project else {
        return;
--- a/crates/editor/src/code_context_menus.rs
+++ b/crates/editor/src/code_context_menus.rs
@@ -224,6 +224,7 @@ impl CompletionsMenu {
                documentation: None,
                lsp_completion: Default::default(),
                confirm: None,
+                resolved: true,
            })
            .collect();

--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -32,6 +32,7 @@ use crate::{
 pub use block_map::{
    Block, BlockBufferRows, BlockChunks as DisplayChunks, BlockContext, BlockId, BlockMap,
    BlockPlacement, BlockPoint, BlockProperties, BlockStyle, CustomBlockId, RenderBlock,
+    StickyHeaderExcerpt,
 };
 use block_map::{BlockRow, BlockSnapshot};
 use collections::{HashMap, HashSet};
@@ -1105,6 +1106,10 @@ impl DisplaySnapshot {
            .map(|(row, block)| (DisplayRow(row), block))
    }

+    pub fn sticky_header_excerpt(&self, row: DisplayRow) -> Option<StickyHeaderExcerpt<'_>> {
+        self.block_snapshot.sticky_header_excerpt(row.0)
+    }
+
    pub fn block_for_id(&self, id: BlockId) -> Option<Block> {
        self.block_snapshot.block_for_id(id)
    }
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1411,6 +1411,66 @@ impl BlockSnapshot {
        })
    }

+    pub fn sticky_header_excerpt(&self, top_row: u32) -> Option<StickyHeaderExcerpt<'_>> {
+        let mut cursor = self.transforms.cursor::<BlockRow>(&());
+        cursor.seek(&BlockRow(top_row), Bias::Left, &());
+
+        while let Some(transform) = cursor.item() {
+            let start = cursor.start().0;
+            let end = cursor.end(&()).0;
+
+            match &transform.block {
+                Some(Block::ExcerptBoundary {
+                    prev_excerpt,
+                    next_excerpt,
+                    starts_new_buffer,
+                    show_excerpt_controls,
+                    ..
+                }) => {
+                    let matches_start = if *show_excerpt_controls && prev_excerpt.is_some() {
+                        start < top_row
+                    } else {
+                        start <= top_row
+                    };
+
+                    if matches_start && top_row <= end {
+                        return next_excerpt.as_ref().map(|excerpt| StickyHeaderExcerpt {
+                            next_buffer_row: None,
+                            next_excerpt_controls_present: *show_excerpt_controls,
+                            excerpt,
+                        });
+                    }
+
+                    let next_buffer_row = if *starts_new_buffer { Some(end) } else { None };
+
+                    return prev_excerpt.as_ref().map(|excerpt| StickyHeaderExcerpt {
+                        excerpt,
+                        next_buffer_row,
+                        next_excerpt_controls_present: *show_excerpt_controls,
+                    });
+                }
+                Some(Block::FoldedBuffer {
+                    prev_excerpt: Some(excerpt),
+                    ..
+                }) if top_row <= start => {
+                    return Some(StickyHeaderExcerpt {
+                        next_buffer_row: Some(end),
+                        next_excerpt_controls_present: false,
+                        excerpt,
+                    });
+                }
+                Some(Block::FoldedBuffer { .. }) | Some(Block::Custom(_)) | None => {}
+            }
+
+            // This is needed to iterate past None / FoldedBuffer / Custom blocks. For FoldedBuffer,
+            // if scrolled slightly past the header of a folded block, the next block is needed for
+            // the sticky header.
+            cursor.next(&());
+        }
+
+        None
+    }
+
    pub fn block_for_id(&self, block_id: BlockId) -> Option<Block> {
        let buffer = self.wrap_snapshot.buffer_snapshot();
        let wrap_point = match block_id {
@@ -1694,6 +1754,13 @@ impl<'a> BlockChunks<'a> {
    }
 }

+pub struct StickyHeaderExcerpt<'a> {
+    pub excerpt: &'a ExcerptInfo,
+    pub next_excerpt_controls_present: bool,
+    // TODO az remove option
+    pub next_buffer_row: Option<u32>,
+}
+
 impl<'a> Iterator for BlockChunks<'a> {
    type Item = Chunk<'a>;

@@ -2681,7 +2748,7 @@ mod tests {
                .iter()
                .filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
                .count(),
-            "Should have one folded block, prodicing a header of the second buffer"
+            "Should have one folded block, producing a header of the second buffer"
        );
        assert_eq!(
            blocks_snapshot.text(),
@@ -2927,7 +2994,7 @@ mod tests {
                    }
                })
                .count(),
-            "Should have one folded block, prodicing a header of the second buffer"
+            "Should have one folded block, producing a header of the second buffer"
        );
        assert_eq!(blocks_snapshot.text(), "\n");
        assert_eq!(
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -99,8 +99,8 @@ use itertools::Itertools;
 use language::{
    language_settings::{self, all_language_settings, language_settings, InlayHintSettings},
    markdown, point_from_lsp, AutoindentMode, BracketPair, Buffer, Capability, CharKind, CodeLabel,
-    CursorShape, Diagnostic, Documentation, IndentKind, IndentSize, Language, OffsetRangeExt,
-    Point, Selection, SelectionGoal, TransactionId,
+    CursorShape, Diagnostic, DiagnosticEntry, Documentation, IndentKind, IndentSize, Language,
+    OffsetRangeExt, Point, Selection, SelectionGoal, TransactionId,
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
@@ -109,7 +109,7 @@ pub use proposed_changes_editor::{
    ProposedChangeLocation, ProposedChangesEditor, ProposedChangesEditorToolbar,
 };
 use similar::{ChangeTag, TextDiff};
-use std::iter::Peekable;
+use std::iter::{self, Peekable};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};

 use hover_links::{find_file, HoverLink, HoveredLinkState, InlayHighlight};
@@ -992,12 +992,17 @@ pub(crate) struct FocusedBlock {
 }

 #[derive(Clone)]
-struct JumpData {
-    excerpt_id: ExcerptId,
-    position: Point,
-    anchor: text::Anchor,
-    path: Option<project::ProjectPath>,
-    line_offset_from_top: u32,
+enum JumpData {
+    MultiBufferRow {
+        row: MultiBufferRow,
+        line_offset_from_top: u32,
+    },
+    MultiBufferPoint {
+        excerpt_id: ExcerptId,
+        position: Point,
+        anchor: text::Anchor,
+        line_offset_from_top: u32,
+    },
 }

 impl Editor {
@@ -3513,7 +3518,7 @@ impl Editor {
        }
    }

-    fn visible_inlay_hints(&self, cx: &ViewContext<'_, Editor>) -> Vec<Inlay> {
+    fn visible_inlay_hints(&self, cx: &ViewContext<Editor>) -> Vec<Inlay> {
        self.display_map
            .read(cx)
            .current_inlays()
@@ -3544,13 +3549,11 @@ impl Editor {
            Bias::Left,
        );
        let multi_buffer_visible_range = multi_buffer_visible_start..multi_buffer_visible_end;
-        multi_buffer
-            .range_to_buffer_ranges(multi_buffer_visible_range, cx)
-            .into_iter()
-            .filter(|(_, excerpt_visible_range, _)| !excerpt_visible_range.is_empty())
-            .filter_map(|(buffer_handle, excerpt_visible_range, excerpt_id)| {
-                let buffer = buffer_handle.read(cx);
-                let buffer_file = project::File::from_dyn(buffer.file())?;
+        multi_buffer_snapshot
+            .disjoint_ranges_to_buffer_ranges(iter::once(multi_buffer_visible_range))
+            .filter(|(_, excerpt_visible_range)| !excerpt_visible_range.is_empty())
+            .filter_map(|(excerpt, excerpt_visible_range)| {
+                let buffer_file = project::File::from_dyn(excerpt.buffer().file())?;
                let buffer_worktree = project.worktree_for_id(buffer_file.worktree_id(cx), cx)?;
                let worktree_entry = buffer_worktree
                    .read(cx)
@@ -3559,17 +3562,17 @@ impl Editor {
                    return None;
                }

-                let language = buffer.language()?;
+                let language = excerpt.buffer().language()?;
                if let Some(restrict_to_languages) = restrict_to_languages {
                    if !restrict_to_languages.contains(language) {
                        return None;
                    }
                }
                Some((
-                    excerpt_id,
+                    excerpt.id(),
                    (
-                        buffer_handle,
-                        buffer.version().clone(),
+                        multi_buffer.buffer(excerpt.buffer_id()).unwrap(),
+                        excerpt.buffer().version().clone(),
                        excerpt_visible_range,
                    ),
                ))
@@ -3830,8 +3833,11 @@ impl Editor {
        };

        let buffer_handle = completions_menu.buffer;
-        let completions = completions_menu.completions.borrow_mut();
-        let completion = completions.get(mat.candidate_id)?;
+        let completion = completions_menu
+            .completions
+            .borrow()
+            .get(mat.candidate_id)?
+            .clone();
        cx.stop_propagation();

        let snippet;
@@ -3975,9 +3981,11 @@ impl Editor {
        }

        let provider = self.completion_provider.as_ref()?;
+        drop(completion);
        let apply_edits = provider.apply_additional_edits_for_completion(
            buffer_handle,
-            completion.clone(),
+            completions_menu.completions.clone(),
+            mat.candidate_id,
            true,
            cx,
        );
@@ -5087,7 +5095,7 @@ impl Editor {
            }))
    }

-    #[cfg(feature = "test-support")]
+    #[cfg(any(feature = "test-support", test))]
    pub fn context_menu_visible(&self) -> bool {
        self.context_menu
            .borrow()
@@ -6004,7 +6012,7 @@ impl Editor {
    fn gather_revert_changes(
        &mut self,
        selections: &[Selection<Point>],
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> HashMap<BufferId, Vec<(Range<text::Anchor>, Rope)>> {
        let mut revert_changes = HashMap::default();
        let snapshot = self.snapshot(cx);
@@ -8931,7 +8939,7 @@ impl Editor {
    fn templates_with_tags(
        project: &Model<Project>,
        runnable: &mut Runnable,
-        cx: &WindowContext<'_>,
+        cx: &WindowContext,
    ) -> Vec<(TaskSourceKind, TaskTemplate)> {
        let (inventory, worktree_id, file) = project.read_with(cx, |project, cx| {
            let (worktree_id, file) = project
@@ -9139,11 +9147,12 @@ impl Editor {
        // If there is an active Diagnostic Popover jump to its diagnostic instead.
        if direction == Direction::Next {
            if let Some(popover) = self.hover_state.diagnostic_popover.as_ref() {
-                let (group_id, jump_to) = popover.activation_info();
-                if self.activate_diagnostics(group_id, cx) {
+                self.activate_diagnostics(popover.group_id(), cx);
+                if let Some(active_diagnostics) = self.active_diagnostics.as_ref() {
+                    let primary_range_start = active_diagnostics.primary_range.start;
                    self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                        let mut new_selection = s.newest_anchor().clone();
-                        new_selection.collapse_to(jump_to, SelectionGoal::None);
+                        new_selection.collapse_to(primary_range_start, SelectionGoal::None);
                        s.select_anchors(vec![new_selection.clone()]);
                    });
                }
@@ -9169,10 +9178,23 @@ impl Editor {
        let snapshot = self.snapshot(cx);
        loop {
            let diagnostics = if direction == Direction::Prev {
-                buffer.diagnostics_in_range::<_, usize>(0..search_start, true)
+                buffer
+                    .diagnostics_in_range(0..search_start, true)
+                    .map(|DiagnosticEntry { diagnostic, range }| DiagnosticEntry {
+                        diagnostic,
+                        range: range.to_offset(&buffer),
+                    })
+                    .collect::<Vec<_>>()
            } else {
-                buffer.diagnostics_in_range::<_, usize>(search_start..buffer.len(), false)
+                buffer
+                    .diagnostics_in_range(search_start..buffer.len(), false)
+                    .map(|DiagnosticEntry { diagnostic, range }| DiagnosticEntry {
+                        diagnostic,
+                        range: range.to_offset(&buffer),
+                    })
+                    .collect::<Vec<_>>()
            }
+            .into_iter()
            .filter(|diagnostic| !snapshot.intersects_fold(diagnostic.range.start));
            let group = diagnostics
                // relies on diagnostics_in_range to return diagnostics with the same starting range to
@@ -9202,7 +9224,8 @@ impl Editor {
                });

            if let Some((primary_range, group_id)) = group {
-                if self.activate_diagnostics(group_id, cx) {
+                self.activate_diagnostics(group_id, cx);
+                if self.active_diagnostics.is_some() {
                    self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                        s.select(vec![Selection {
                            id: selection.id,
@@ -9243,7 +9266,7 @@ impl Editor {
        &mut self,
        snapshot: &EditorSnapshot,
        position: Point,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> Option<MultiBufferDiffHunk> {
        for (ix, position) in [position, Point::zero()].into_iter().enumerate() {
            if let Some(hunk) = self.go_to_next_hunk_in_direction(
@@ -9272,7 +9295,7 @@ impl Editor {
        &mut self,
        snapshot: &EditorSnapshot,
        position: Point,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> Option<MultiBufferDiffHunk> {
        for (ix, position) in [position, snapshot.buffer_snapshot.max_point()]
            .into_iter()
@@ -10279,11 +10302,12 @@ impl Editor {
            let buffer = self.buffer.read(cx).snapshot(cx);
            let primary_range_start = active_diagnostics.primary_range.start.to_offset(&buffer);
            let is_valid = buffer
-                .diagnostics_in_range::<_, usize>(active_diagnostics.primary_range.clone(), false)
+                .diagnostics_in_range(active_diagnostics.primary_range.clone(), false)
                .any(|entry| {
+                    let range = entry.range.to_offset(&buffer);
                    entry.diagnostic.is_primary
-                        && !entry.range.is_empty()
-                        && entry.range.start == primary_range_start
+                        && !range.is_empty()
+                        && range.start == primary_range_start
                        && entry.diagnostic.message == active_diagnostics.primary_message
                });

@@ -10303,7 +10327,7 @@ impl Editor {
        }
    }

-    fn activate_diagnostics(&mut self, group_id: usize, cx: &mut ViewContext<Self>) -> bool {
+    fn activate_diagnostics(&mut self, group_id: usize, cx: &mut ViewContext<Self>) {
        self.dismiss_diagnostics(cx);
        let snapshot = self.snapshot(cx);
        self.active_diagnostics = self.display_map.update(cx, |display_map, cx| {
@@ -10313,16 +10337,18 @@ impl Editor {
            let mut primary_message = None;
            let mut group_end = Point::zero();
            let diagnostic_group = buffer
-                .diagnostic_group::<MultiBufferPoint>(group_id)
+                .diagnostic_group(group_id)
                .filter_map(|entry| {
-                    if snapshot.is_line_folded(MultiBufferRow(entry.range.start.row))
-                        && (entry.range.start.row == entry.range.end.row
-                            || snapshot.is_line_folded(MultiBufferRow(entry.range.end.row)))
+                    let start = entry.range.start.to_point(&buffer);
+                    let end = entry.range.end.to_point(&buffer);
+                    if snapshot.is_line_folded(MultiBufferRow(start.row))
+                        && (start.row == end.row
+                            || snapshot.is_line_folded(MultiBufferRow(end.row)))
                    {
                        return None;
                    }
-                    if entry.range.end > group_end {
-                        group_end = entry.range.end;
+                    if end > group_end {
+                        group_end = end;
                    }
                    if entry.diagnostic.is_primary {
                        primary_range = Some(entry.range.clone());
@@ -10333,8 +10359,6 @@ impl Editor {
                .collect::<Vec<_>>();
            let primary_range = primary_range?;
            let primary_message = primary_message?;
-            let primary_range =
-                buffer.anchor_after(primary_range.start)..buffer.anchor_before(primary_range.end);

            let blocks = display_map
                .insert_blocks(
@@ -10365,7 +10389,6 @@ impl Editor {
                is_valid: true,
            })
        });
-        self.active_diagnostics.is_some()
    }

    fn dismiss_diagnostics(&mut self, cx: &mut ViewContext<Self>) {
@@ -10474,13 +10497,13 @@ impl Editor {
        } else {
            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);
            let mut toggled_buffers = HashSet::default();
-            for (_, buffer_snapshot, _) in multi_buffer_snapshot.excerpts_in_ranges(
+            for (excerpt, _) in multi_buffer_snapshot.disjoint_ranges_to_buffer_ranges(
                self.selections
                    .disjoint_anchors()
                    .into_iter()
                    .map(|selection| selection.range()),
            ) {
-                let buffer_id = buffer_snapshot.remote_id();
+                let buffer_id = excerpt.buffer().remote_id();
                if toggled_buffers.insert(buffer_id) {
                    if self.buffer_folded(buffer_id, cx) {
                        self.unfold_buffer(buffer_id, cx);
@@ -10560,13 +10583,13 @@ impl Editor {
        } else {
            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);
            let mut folded_buffers = HashSet::default();
-            for (_, buffer_snapshot, _) in multi_buffer_snapshot.excerpts_in_ranges(
+            for (excerpt, _) in multi_buffer_snapshot.disjoint_ranges_to_buffer_ranges(
                self.selections
                    .disjoint_anchors()
                    .into_iter()
                    .map(|selection| selection.range()),
            ) {
-                let buffer_id = buffer_snapshot.remote_id();
+                let buffer_id = excerpt.buffer().remote_id();
                if folded_buffers.insert(buffer_id) {
                    self.fold_buffer(buffer_id, cx);
                }
@@ -10726,13 +10749,13 @@ impl Editor {
        } else {
            let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);
            let mut unfolded_buffers = HashSet::default();
-            for (_, buffer_snapshot, _) in multi_buffer_snapshot.excerpts_in_ranges(
+            for (excerpt, _) in multi_buffer_snapshot.disjoint_ranges_to_buffer_ranges(
                self.selections
                    .disjoint_anchors()
                    .into_iter()
                    .map(|selection| selection.range()),
            ) {
-                let buffer_id = buffer_snapshot.remote_id();
+                let buffer_id = excerpt.buffer().remote_id();
                if unfolded_buffers.insert(buffer_id) {
                    self.unfold_buffer(buffer_id, cx);
                }
@@ -11476,34 +11499,36 @@ impl Editor {
    }

    fn get_permalink_to_line(&mut self, cx: &mut ViewContext<Self>) -> Task<Result<url::Url>> {
-        let buffer_and_selection = maybe!({
-            let selection = self.selections.newest::<Point>(cx);
+        let buffer_and_selection_rows = maybe!({
+            let multi_buffer = self.buffer().read(cx);
+            let multi_buffer_snapshot = multi_buffer.snapshot(cx);
+            let selection = self.selections.newest_anchor();
            let selection_range = selection.range();

-            let (buffer, selection) = if let Some(buffer) = self.buffer().read(cx).as_singleton() {
-                (buffer, selection_range.start.row..selection_range.end.row)
+            let (buffer, selection_rows) = if let Some(buffer) = multi_buffer.as_singleton() {
+                (
+                    buffer,
+                    selection_range.start.to_point(&multi_buffer_snapshot).row
+                        ..selection_range.end.to_point(&multi_buffer_snapshot).row,
+                )
            } else {
-                let buffer_ranges = self
-                    .buffer()
-                    .read(cx)
-                    .range_to_buffer_ranges(selection_range, cx);
-
-                let (buffer, range, _) = if selection.reversed {
-                    buffer_ranges.first()
-                } else {
-                    buffer_ranges.last()
-                }?;
-
-                let snapshot = buffer.read(cx).snapshot();
-                let selection = text::ToPoint::to_point(&range.start, &snapshot).row
-                    ..text::ToPoint::to_point(&range.end, &snapshot).row;
-                (buffer.clone(), selection)
+                let selection_head = selection.head();
+                let excerpt =
+                    multi_buffer_snapshot.excerpt_containing(selection_head..selection_head)?;
+                let range =
+                    excerpt.map_range_to_buffer(selection_range.to_offset(&multi_buffer_snapshot));
+                let snapshot = excerpt.buffer();
+                (
+                    multi_buffer.buffer(excerpt.buffer_id()).unwrap().clone(),
+                    text::ToPoint::to_point(&range.start, &snapshot).row
+                        ..text::ToPoint::to_point(&range.end, &snapshot).row,
+                )
            };

-            Some((buffer, selection))
+            Some((buffer, selection_rows))
        });

-        let Some((buffer, selection)) = buffer_and_selection else {
+        let Some((buffer, selection_rows)) = buffer_and_selection_rows else {
            return Task::ready(Err(anyhow!("failed to determine buffer and selection")));
        };

@@ -11512,7 +11537,7 @@ impl Editor {
        };

        project.update(cx, |project, cx| {
-            project.get_permalink_to_line(&buffer, selection, cx)
+            project.get_permalink_to_line(&buffer, selection_rows, cx)
        })
    }

@@ -11755,7 +11780,7 @@ impl Editor {
    }

    /// Merges all anchor ranges for all context types ever set, picking the last highlight added in case of a row conflict.
-    /// Rerturns a map of display rows that are highlighted and their corresponding highlight color.
+    /// Returns a map of display rows that are highlighted and their corresponding highlight color.
    /// Allows to ignore certain kinds of highlights.
    pub fn highlighted_display_rows(
        &mut self,
@@ -12389,17 +12414,18 @@ impl Editor {
        };

        let selections = self.selections.all::<usize>(cx);
-        let buffer = self.buffer.read(cx);
+        let multi_buffer = self.buffer.read(cx);
+        let multi_buffer_snapshot = multi_buffer.snapshot(cx);
        let mut new_selections_by_buffer = HashMap::default();
        for selection in selections {
-            for (buffer, range, _) in
-                buffer.range_to_buffer_ranges(selection.start..selection.end, cx)
+            for (excerpt, range) in
+                multi_buffer_snapshot.range_to_buffer_ranges(selection.start..selection.end)
            {
-                let mut range = range.to_point(buffer.read(cx));
+                let mut range = range.to_point(excerpt.buffer());
                range.start.column = 0;
-                range.end.column = buffer.read(cx).line_len(range.end.row);
+                range.end.column = excerpt.buffer().line_len(range.end.row);
                new_selections_by_buffer
-                    .entry(buffer)
+                    .entry(multi_buffer.buffer(excerpt.buffer_id()).unwrap())
                    .or_insert(Vec::new())
                    .push(range)
            }
@@ -12453,37 +12479,60 @@ impl Editor {

        let mut new_selections_by_buffer = HashMap::default();
        match &jump_data {
-            Some(jump_data) => {
+            Some(JumpData::MultiBufferPoint {
+                excerpt_id,
+                position,
+                anchor,
+                line_offset_from_top,
+            }) => {
                let multi_buffer_snapshot = self.buffer.read(cx).snapshot(cx);
                if let Some(buffer) = multi_buffer_snapshot
-                    .buffer_id_for_excerpt(jump_data.excerpt_id)
+                    .buffer_id_for_excerpt(*excerpt_id)
                    .and_then(|buffer_id| self.buffer.read(cx).buffer(buffer_id))
                {
                    let buffer_snapshot = buffer.read(cx).snapshot();
-                    let jump_to_point = if buffer_snapshot.can_resolve(&jump_data.anchor) {
-                        language::ToPoint::to_point(&jump_data.anchor, &buffer_snapshot)
+                    let jump_to_point = if buffer_snapshot.can_resolve(anchor) {
+                        language::ToPoint::to_point(anchor, &buffer_snapshot)
                    } else {
-                        buffer_snapshot.clip_point(jump_data.position, Bias::Left)
+                        buffer_snapshot.clip_point(*position, Bias::Left)
                    };
                    let jump_to_offset = buffer_snapshot.point_to_offset(jump_to_point);
                    new_selections_by_buffer.insert(
                        buffer,
                        (
                            vec![jump_to_offset..jump_to_offset],
-                            Some(jump_data.line_offset_from_top),
+                            Some(*line_offset_from_top),
                        ),
                    );
                }
            }
+            Some(JumpData::MultiBufferRow {
+                row,
+                line_offset_from_top,
+            }) => {
+                let point = MultiBufferPoint::new(row.0, 0);
+                if let Some((buffer, buffer_point, _)) =
+                    self.buffer.read(cx).point_to_buffer_point(point, cx)
+                {
+                    let buffer_offset = buffer.read(cx).point_to_offset(buffer_point);
+                    new_selections_by_buffer
+                        .entry(buffer)
+                        .or_insert((Vec::new(), Some(*line_offset_from_top)))
+                        .0
+                        .push(buffer_offset..buffer_offset)
+                }
+            }
            None => {
                let selections = self.selections.all::<usize>(cx);
-                let buffer = self.buffer.read(cx);
+                let multi_buffer = self.buffer.read(cx);
                for selection in selections {
-                    for (mut buffer_handle, mut range, _) in
-                        buffer.range_to_buffer_ranges(selection.range(), cx)
+                    for (excerpt, mut range) in multi_buffer
+                        .snapshot(cx)
+                        .range_to_buffer_ranges(selection.range())
                    {
                        // When editing branch buffers, jump to the corresponding location
                        // in their base buffer.
+                        let mut buffer_handle = multi_buffer.buffer(excerpt.buffer_id()).unwrap();
                        let buffer = buffer_handle.read(cx);
                        if let Some(base_buffer) = buffer.base_buffer() {
                            range = buffer.range_to_version(range, &base_buffer.read(cx).version());
@@ -12524,7 +12573,7 @@ impl Editor {
                        .file()
                        .is_none()
                        .then(|| {
-                            // Handle file-less buffers separately: those are not really the project items, so won't have a paroject path or entity id,
+                            // Handle file-less buffers separately: those are not really the project items, so won't have a project path or entity id,
                            // so `workspace.open_project_item` will never find them, always opening a new editor.
                            // Instead, we try to activate the existing editor in the pane first.
                            let (editor, pane_item_index) =
@@ -13447,11 +13496,14 @@ pub trait CompletionProvider {

    fn apply_additional_edits_for_completion(
        &self,
-        buffer: Model<Buffer>,
-        completion: Completion,
-        push_to_history: bool,
-        cx: &mut ViewContext<Editor>,
-    ) -> Task<Result<Option<language::Transaction>>>;
+        _buffer: Model<Buffer>,
+        _completions: Rc<RefCell<Box<[Completion]>>>,
+        _completion_index: usize,
+        _push_to_history: bool,
+        _cx: &mut ViewContext<Editor>,
+    ) -> Task<Result<Option<language::Transaction>>> {
+        Task::ready(Ok(None))
+    }

    fn is_completion_trigger(
        &self,
@@ -13610,6 +13662,7 @@ fn snippet_completions(
                Some(Completion {
                    old_range: range,
                    new_text: snippet.body.clone(),
+                    resolved: false,
                    label: CodeLabel {
                        text: matching_prefix.clone(),
                        runs: vec![],
@@ -13675,19 +13728,30 @@ impl CompletionProvider for Model<Project> {
        cx: &mut ViewContext<Editor>,
    ) -> Task<Result<bool>> {
        self.update(cx, |project, cx| {
-            project.resolve_completions(buffer, completion_indices, completions, cx)
+            project.lsp_store().update(cx, |lsp_store, cx| {
+                lsp_store.resolve_completions(buffer, completion_indices, completions, cx)
+            })
        })
    }

    fn apply_additional_edits_for_completion(
        &self,
        buffer: Model<Buffer>,
-        completion: Completion,
+        completions: Rc<RefCell<Box<[Completion]>>>,
+        completion_index: usize,
        push_to_history: bool,
        cx: &mut ViewContext<Editor>,
    ) -> Task<Result<Option<language::Transaction>>> {
        self.update(cx, |project, cx| {
-            project.apply_additional_edits_for_completion(buffer, completion, push_to_history, cx)
+            project.lsp_store().update(cx, |lsp_store, cx| {
+                lsp_store.apply_additional_edits_for_completion(
+                    buffer,
+                    completions,
+                    completion_index,
+                    push_to_history,
+                    cx,
+                )
+            })
        })
    }

@@ -13822,7 +13886,7 @@ impl SemanticsProvider for Model<Project> {
 fn inlay_hint_settings(
    location: Anchor,
    snapshot: &MultiBufferSnapshot,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) -> InlayHintSettings {
    let file = snapshot.file_at(location);
    let language = snapshot.language_at(location).map(|l| l.name());
--- a/crates/editor/src/editor_settings.rs
+++ b/crates/editor/src/editor_settings.rs
@@ -105,7 +105,7 @@ pub struct Scrollbar {
    pub git_diff: bool,
    pub selected_symbol: bool,
    pub search_results: bool,
-    pub diagnostics: bool,
+    pub diagnostics: ScrollbarDiagnostics,
    pub cursors: bool,
    pub axes: ScrollbarAxes,
 }
@@ -150,6 +150,73 @@ pub struct ScrollbarAxes {
    pub vertical: bool,
 }

+/// Which diagnostic indicators to show in the scrollbar.
+///
+/// Default: all
+#[derive(Copy, Clone, Debug, Serialize, JsonSchema, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ScrollbarDiagnostics {
+    /// Show all diagnostic levels: hint, information, warnings, error.
+    All,
+    /// Show only the following diagnostic levels: information, warning, error.
+    Information,
+    /// Show only the following diagnostic levels: warning, error.
+    Warning,
+    /// Show only the following diagnostic level: error.
+    Error,
+    /// Do not show diagnostics.
+    None,
+}
+
+impl<'de> Deserialize<'de> for ScrollbarDiagnostics {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> serde::de::Visitor<'de> for Visitor {
+            type Value = ScrollbarDiagnostics;
+
+            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                write!(
+                    f,
+                    r#"a boolean or one of "all", "information", "warning", "error", "none""#
+                )
+            }
+
+            fn visit_bool<E>(self, b: bool) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match b {
+                    false => Ok(ScrollbarDiagnostics::None),
+                    true => Ok(ScrollbarDiagnostics::All),
+                }
+            }
+
+            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                match s {
+                    "all" => Ok(ScrollbarDiagnostics::All),
+                    "information" => Ok(ScrollbarDiagnostics::Information),
+                    "warning" => Ok(ScrollbarDiagnostics::Warning),
+                    "error" => Ok(ScrollbarDiagnostics::Error),
+                    "none" => Ok(ScrollbarDiagnostics::None),
+                    _ => Err(E::unknown_variant(
+                        s,
+                        &["all", "information", "warning", "error", "none"],
+                    )),
+                }
+            }
+        }
+
+        deserializer.deserialize_any(Visitor)
+    }
+}
+
 /// The key to use for adding multiple cursors
 ///
 /// Default: alt
@@ -348,10 +415,10 @@ pub struct ScrollbarContent {
    ///
    /// Default: true
    pub selected_symbol: Option<bool>,
-    /// Whether to show diagnostic indicators in the scrollbar.
+    /// Which diagnostic indicators to show in the scrollbar:
    ///
-    /// Default: true
-    pub diagnostics: Option<bool>,
+    /// Default: all
+    pub diagnostics: Option<ScrollbarDiagnostics>,
    /// Whether to show cursor positions in the scrollbar.
    ///
    /// Default: true
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -8402,7 +8402,6 @@ async fn test_completion(cx: &mut gpui::TestAppContext) {
        additional edit
    "});

-    handle_resolve_completion_request(&mut cx, None).await;
    apply_additional_edits.await.unwrap();

    update_test_language_settings(&mut cx, |settings| {
@@ -10698,10 +10697,14 @@ async fn test_completions_resolve_updates_labels_if_filter_text_matches(
        ..lsp::CompletionItem::default()
    };

-    cx.handle_request::<lsp::request::Completion, _, _>(move |_, _, _| {
+    let item1 = item1.clone();
+    cx.handle_request::<lsp::request::Completion, _, _>({
        let item1 = item1.clone();
-        let item2 = item2.clone();
-        async move { Ok(Some(lsp::CompletionResponse::Array(vec![item1, item2]))) }
+        move |_, _, _| {
+            let item1 = item1.clone();
+            let item2 = item2.clone();
+            async move { Ok(Some(lsp::CompletionResponse::Array(vec![item1, item2]))) }
+        }
    })
    .next()
    .await;
@@ -10728,43 +10731,41 @@ async fn test_completions_resolve_updates_labels_if_filter_text_matches(
        }
    });

-    cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>(move |_, _, _| async move {
-        Ok(lsp::CompletionItem {
-            label: "method id()".to_string(),
-            filter_text: Some("id".to_string()),
-            detail: Some("Now resolved!".to_string()),
-            documentation: Some(lsp::Documentation::String("Docs".to_string())),
-            text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                range: lsp::Range::new(lsp::Position::new(0, 22), lsp::Position::new(0, 22)),
-                new_text: ".id".to_string(),
-            })),
-            ..lsp::CompletionItem::default()
-        })
+    cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>({
+        let item1 = item1.clone();
+        move |_, item_to_resolve, _| {
+            let item1 = item1.clone();
+            async move {
+                if item1 == item_to_resolve {
+                    Ok(lsp::CompletionItem {
+                        label: "method id()".to_string(),
+                        filter_text: Some("id".to_string()),
+                        detail: Some("Now resolved!".to_string()),
+                        documentation: Some(lsp::Documentation::String("Docs".to_string())),
+                        text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+                            range: lsp::Range::new(
+                                lsp::Position::new(0, 22),
+                                lsp::Position::new(0, 22),
+                            ),
+                            new_text: ".id".to_string(),
+                        })),
+                        ..lsp::CompletionItem::default()
+                    })
+                } else {
+                    Ok(item_to_resolve)
+                }
+            }
+        }
    })
    .next()
-    .await;
+    .await
+    .unwrap();
    cx.run_until_parked();

    cx.update_editor(|editor, cx| {
        editor.context_menu_next(&Default::default(), cx);
    });

-    cx.handle_request::<lsp::request::ResolveCompletionItem, _, _>(move |_, _, _| async move {
-        Ok(lsp::CompletionItem {
-            label: "invalid changed label".to_string(),
-            detail: Some("Now resolved!".to_string()),
-            documentation: Some(lsp::Documentation::String("Docs".to_string())),
-            text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
-                range: lsp::Range::new(lsp::Position::new(0, 22), lsp::Position::new(0, 22)),
-                new_text: ".id".to_string(),
-            })),
-            ..lsp::CompletionItem::default()
-        })
-    })
-    .next()
-    .await;
-    cx.run_until_parked();
-
    cx.update_editor(|editor, _| {
        let context_menu = editor.context_menu.borrow_mut();
        let context_menu = context_menu
@@ -10787,6 +10788,172 @@ async fn test_completions_resolve_updates_labels_if_filter_text_matches(
    });
 }

+#[gpui::test]
+async fn test_completions_resolve_happens_once(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()]),
+                resolve_provider: Some(true),
+                ..Default::default()
+            }),
+            ..Default::default()
+        },
+        cx,
+    )
+    .await;
+
+    cx.set_state(indoc! {"fn main() { let a = 2ˇ; }"});
+    cx.simulate_keystroke(".");
+
+    let unresolved_item_1 = lsp::CompletionItem {
+        label: "id".to_string(),
+        filter_text: Some("id".to_string()),
+        detail: None,
+        documentation: None,
+        text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+            range: lsp::Range::new(lsp::Position::new(0, 22), lsp::Position::new(0, 22)),
+            new_text: ".id".to_string(),
+        })),
+        ..lsp::CompletionItem::default()
+    };
+    let resolved_item_1 = lsp::CompletionItem {
+        additional_text_edits: Some(vec![lsp::TextEdit {
+            range: lsp::Range::new(lsp::Position::new(0, 20), lsp::Position::new(0, 22)),
+            new_text: "!!".to_string(),
+        }]),
+        ..unresolved_item_1.clone()
+    };
+    let unresolved_item_2 = lsp::CompletionItem {
+        label: "other".to_string(),
+        filter_text: Some("other".to_string()),
+        detail: None,
+        documentation: None,
+        text_edit: Some(lsp::CompletionTextEdit::Edit(lsp::TextEdit {
+            range: lsp::Range::new(lsp::Position::new(0, 22), lsp::Position::new(0, 22)),
+            new_text: ".other".to_string(),
+        })),
+        ..lsp::CompletionItem::default()
+    };
+    let resolved_item_2 = lsp::CompletionItem {
+        additional_text_edits: Some(vec![lsp::TextEdit {
+            range: lsp::Range::new(lsp::Position::new(0, 20), lsp::Position::new(0, 22)),
+            new_text: "??".to_string(),
+        }]),
+        ..unresolved_item_2.clone()
+    };
+
+    let resolve_requests_1 = Arc::new(AtomicUsize::new(0));
+    let resolve_requests_2 = Arc::new(AtomicUsize::new(0));
+    cx.lsp
+        .server
+        .on_request::<lsp::request::ResolveCompletionItem, _, _>({
+            let unresolved_item_1 = unresolved_item_1.clone();
+            let resolved_item_1 = resolved_item_1.clone();
+            let unresolved_item_2 = unresolved_item_2.clone();
+            let resolved_item_2 = resolved_item_2.clone();
+            let resolve_requests_1 = resolve_requests_1.clone();
+            let resolve_requests_2 = resolve_requests_2.clone();
+            move |unresolved_request, _| {
+                let unresolved_item_1 = unresolved_item_1.clone();
+                let resolved_item_1 = resolved_item_1.clone();
+                let unresolved_item_2 = unresolved_item_2.clone();
+                let resolved_item_2 = resolved_item_2.clone();
+                let resolve_requests_1 = resolve_requests_1.clone();
+                let resolve_requests_2 = resolve_requests_2.clone();
+                async move {
+                    if unresolved_request == unresolved_item_1 {
+                        resolve_requests_1.fetch_add(1, atomic::Ordering::Release);
+                        Ok(resolved_item_1.clone())
+                    } else if unresolved_request == unresolved_item_2 {
+                        resolve_requests_2.fetch_add(1, atomic::Ordering::Release);
+                        Ok(resolved_item_2.clone())
+                    } else {
+                        panic!("Unexpected completion item {unresolved_request:?}")
+                    }
+                }
+            }
+        })
+        .detach();
+
+    cx.handle_request::<lsp::request::Completion, _, _>(move |_, _, _| {
+        let unresolved_item_1 = unresolved_item_1.clone();
+        let unresolved_item_2 = unresolved_item_2.clone();
+        async move {
+            Ok(Some(lsp::CompletionResponse::Array(vec![
+                unresolved_item_1,
+                unresolved_item_2,
+            ])))
+        }
+    })
+    .next()
+    .await;
+
+    cx.condition(|editor, _| editor.context_menu_visible())
+        .await;
+    cx.update_editor(|editor, _| {
+        let context_menu = editor.context_menu.borrow_mut();
+        let context_menu = context_menu
+            .as_ref()
+            .expect("Should have the context menu deployed");
+        match context_menu {
+            CodeContextMenu::Completions(completions_menu) => {
+                let completions = completions_menu.completions.borrow_mut();
+                assert_eq!(
+                    completions
+                        .iter()
+                        .map(|completion| &completion.label.text)
+                        .collect::<Vec<_>>(),
+                    vec!["id", "other"]
+                )
+            }
+            CodeContextMenu::CodeActions(_) => panic!("Should show the completions menu"),
+        }
+    });
+    cx.run_until_parked();
+
+    cx.update_editor(|editor, cx| {
+        editor.context_menu_next(&ContextMenuNext, cx);
+    });
+    cx.run_until_parked();
+    cx.update_editor(|editor, cx| {
+        editor.context_menu_prev(&ContextMenuPrev, cx);
+    });
+    cx.run_until_parked();
+    cx.update_editor(|editor, cx| {
+        editor.context_menu_next(&ContextMenuNext, cx);
+    });
+    cx.run_until_parked();
+    cx.update_editor(|editor, cx| {
+        editor
+            .compose_completion(&ComposeCompletion::default(), cx)
+            .expect("No task returned")
+    })
+    .await
+    .expect("Completion failed");
+    cx.run_until_parked();
+
+    cx.update_editor(|editor, cx| {
+        assert_eq!(
+            resolve_requests_1.load(atomic::Ordering::Acquire),
+            1,
+            "Should always resolve once despite multiple selections"
+        );
+        assert_eq!(
+            resolve_requests_2.load(atomic::Ordering::Acquire),
+            1,
+            "Should always resolve once after multiple selections and applying the completion"
+        );
+        assert_eq!(
+            editor.text(cx),
+            "fn main() { let a = ??.other; }",
+            "Should use resolved data when applying the completion"
+        );
+    });
+}
+
 #[gpui::test]
 async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppContext) {
    init_test(cx, |_| {});
@@ -10950,15 +11117,10 @@ async fn test_completions_default_resolve_data_handling(cx: &mut gpui::TestAppCo
    // Completions that have already been resolved are skipped.
    assert_eq!(
        *resolved_items.lock(),
-        [
-            // Selected item is always resolved even if it was resolved before.
-            &items_out[items_out.len() - 1..items_out.len()],
-            &items_out[items_out.len() - 16..items_out.len() - 4]
-        ]
-        .concat()
-        .iter()
-        .cloned()
-        .collect::<Vec<lsp::CompletionItem>>()
+        items_out[items_out.len() - 16..items_out.len() - 4]
+            .iter()
+            .cloned()
+            .collect::<Vec<lsp::CompletionItem>>()
    );
    resolved_items.lock().clear();
 }
@@ -11098,7 +11260,7 @@ async fn test_document_format_with_prettier(cx: &mut gpui::TestAppContext) {
            },
            ..Default::default()
        },
-        Some(tree_sitter_rust::LANGUAGE.into()),
+        Some(tree_sitter_typescript::LANGUAGE_TYPESCRIPT.into()),
    )));
    update_test_language_settings(cx, |settings| {
        settings.defaults.prettier = Some(PrettierSettings {
@@ -14570,6 +14732,62 @@ fn test_inline_completion_text_with_deletions(cx: &mut TestAppContext) {
    }
 }

+#[gpui::test]
+async fn test_rename_with_duplicate_edits(cx: &mut gpui::TestAppContext) {
+    init_test(cx, |_| {});
+    let mut cx = EditorLspTestContext::new_rust(lsp::ServerCapabilities::default(), cx).await;
+
+    cx.set_state(indoc! {"
+        struct Fˇoo {}
+    "});
+
+    cx.update_editor(|editor, cx| {
+        let highlight_range = Point::new(0, 7)..Point::new(0, 10);
+        let highlight_range = highlight_range.to_anchors(&editor.buffer().read(cx).snapshot(cx));
+        editor.highlight_background::<DocumentHighlightRead>(
+            &[highlight_range],
+            |c| c.editor_document_highlight_read_background,
+            cx,
+        );
+    });
+
+    cx.update_editor(|e, cx| e.rename(&Rename, cx))
+        .expect("Rename was not started")
+        .await
+        .expect("Rename failed");
+    let mut rename_handler =
+        cx.handle_request::<lsp::request::Rename, _, _>(move |url, _, _| async move {
+            let edit = lsp::TextEdit {
+                range: lsp::Range {
+                    start: lsp::Position {
+                        line: 0,
+                        character: 7,
+                    },
+                    end: lsp::Position {
+                        line: 0,
+                        character: 10,
+                    },
+                },
+                new_text: "FooRenamed".to_string(),
+            };
+            Ok(Some(lsp::WorkspaceEdit::new(
+                // Specify the same edit twice
+                std::collections::HashMap::from_iter(Some((url, vec![edit.clone(), edit]))),
+            )))
+        });
+    cx.update_editor(|e, cx| e.confirm_rename(&ConfirmRename, cx))
+        .expect("Confirm rename was not started")
+        .await
+        .expect("Confirm rename failed");
+    rename_handler.next().await.unwrap();
+    cx.run_until_parked();
+
+    // Despite two edits, only one is actually applied as those are identical
+    cx.assert_editor_state(indoc! {"
+        struct FooRenamedˇ {}
+    "});
+}
+
 fn empty_range(row: usize, column: usize) -> Range<DisplayPoint> {
    let point = DisplayPoint::new(DisplayRow(row as u32), column as u32);
    point..point
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
--- a/crates/editor/src/git/project_diff.rs
+++ b/crates/editor/src/git/project_diff.rs
@@ -194,14 +194,24 @@ impl ProjectDiffEditor {
                let open_tasks = project
                    .update(&mut cx, |project, cx| {
                        let worktree = project.worktree_for_id(id, cx)?;
-                        let applicable_entries = worktree
-                            .read(cx)
-                            .entries(false, 0)
-                            .filter(|entry| !entry.is_external)
-                            .filter(|entry| entry.is_file())
-                            .filter_map(|entry| Some((entry.git_status?, entry)))
-                            .filter_map(|(git_status, entry)| {
-                                Some((git_status, entry.id, project.path_for_entry(entry.id, cx)?))
+                        let snapshot = worktree.read(cx).snapshot();
+                        let applicable_entries = snapshot
+                            .repositories()
+                            .flat_map(|entry| {
+                                entry.status().map(|git_entry| {
+                                    (git_entry.status, entry.join(git_entry.repo_path))
+                                })
+                            })
+                            .filter_map(|(status, path)| {
+                                let id = snapshot.entry_for_path(&path)?.id;
+                                Some((
+                                    status,
+                                    id,
+                                    ProjectPath {
+                                        worktree_id: snapshot.id(),
+                                        path: path.into(),
+                                    },
+                                ))
                            })
                            .collect::<Vec<_>>();
                        Some(
--- a/crates/editor/src/hover_links.rs
+++ b/crates/editor/src/hover_links.rs
@@ -266,7 +266,7 @@ pub fn update_inlay_link_and_hover_points(
    editor: &mut Editor,
    secondary_held: bool,
    shift_held: bool,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) {
    let hovered_offset = if point_for_position.column_overshoot_after_line_end == 0 {
        Some(snapshot.display_point_to_inlay_offset(point_for_position.exact_unclipped, Bias::Left))
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -3,7 +3,7 @@ use crate::{
    hover_links::{InlayHighlight, RangeInEditor},
    scroll::ScrollAmount,
    Anchor, AnchorRangeExt, DisplayPoint, DisplayRow, Editor, EditorSettings, EditorSnapshot,
-    Hover, RangeToAnchorExt,
+    Hover,
 };
 use gpui::{
    div, px, AnyElement, AsyncWindowContext, FontWeight, Hsla, InteractiveElement, IntoElement,
@@ -263,29 +263,7 @@ fn show_hover(
                delay.await;
            }

-            // If there's a diagnostic, assign it on the hover state and notify
-            let mut local_diagnostic = snapshot
-                .buffer_snapshot
-                .diagnostics_in_range::<_, usize>(anchor..anchor, false)
-                // Find the entry with the most specific range
-                .min_by_key(|entry| entry.range.end - entry.range.start)
-                .map(|entry| DiagnosticEntry {
-                    diagnostic: entry.diagnostic,
-                    range: entry.range.to_anchors(&snapshot.buffer_snapshot),
-                });
-
-            // Pull the primary diagnostic out so we can jump to it if the popover is clicked
-            let primary_diagnostic = local_diagnostic.as_ref().and_then(|local_diagnostic| {
-                snapshot
-                    .buffer_snapshot
-                    .diagnostic_group::<usize>(local_diagnostic.diagnostic.group_id)
-                    .find(|diagnostic| diagnostic.diagnostic.is_primary)
-                    .map(|entry| DiagnosticEntry {
-                        diagnostic: entry.diagnostic,
-                        range: entry.range.to_anchors(&snapshot.buffer_snapshot),
-                    })
-            });
-            if let Some(invisible) = snapshot
+            let local_diagnostic = if let Some(invisible) = snapshot
                .buffer_snapshot
                .chars_at(anchor)
                .next()
@@ -294,7 +272,7 @@ fn show_hover(
                let after = snapshot.buffer_snapshot.anchor_after(
                    anchor.to_offset(&snapshot.buffer_snapshot) + invisible.len_utf8(),
                );
-                local_diagnostic = Some(DiagnosticEntry {
+                Some(DiagnosticEntry {
                    diagnostic: Diagnostic {
                        severity: DiagnosticSeverity::HINT,
                        message: format!("Unicode character U+{:02X}", invisible as u32),
@@ -311,7 +289,7 @@ fn show_hover(
                let before = snapshot.buffer_snapshot.anchor_before(
                    anchor.to_offset(&snapshot.buffer_snapshot) - invisible.len_utf8(),
                );
-                local_diagnostic = Some(DiagnosticEntry {
+                Some(DiagnosticEntry {
                    diagnostic: Diagnostic {
                        severity: DiagnosticSeverity::HINT,
                        message: format!("Unicode character U+{:02X}", invisible as u32),
@@ -319,7 +297,16 @@ fn show_hover(
                    },
                    range: before..anchor,
                })
-            }
+            } else {
+                snapshot
+                    .buffer_snapshot
+                    .diagnostics_in_range(anchor..anchor, false)
+                    // Find the entry with the most specific range
+                    .min_by_key(|entry| {
+                        let range = entry.range.to_offset(&snapshot.buffer_snapshot);
+                        range.end - range.start
+                    })
+            };

            let diagnostic_popover = if let Some(local_diagnostic) = local_diagnostic {
                let text = match local_diagnostic.diagnostic.source {
@@ -388,7 +375,6 @@ fn show_hover(

                Some(DiagnosticPopover {
                    local_diagnostic,
-                    primary_diagnostic,
                    parsed_content,
                    border_color,
                    background_color,
@@ -783,7 +769,6 @@ impl InfoPopover {
 #[derive(Debug, Clone)]
 pub struct DiagnosticPopover {
    local_diagnostic: DiagnosticEntry<Anchor>,
-    primary_diagnostic: Option<DiagnosticEntry<Anchor>>,
    parsed_content: Option<View<Markdown>>,
    border_color: Option<Hsla>,
    background_color: Option<Hsla>,
@@ -837,13 +822,8 @@ impl DiagnosticPopover {
        diagnostic_div.into_any_element()
    }

-    pub fn activation_info(&self) -> (usize, Anchor) {
-        let entry = self
-            .primary_diagnostic
-            .as_ref()
-            .unwrap_or(&self.local_diagnostic);
-
-        (entry.diagnostic.group_id, entry.range.start)
+    pub fn group_id(&self) -> usize {
+        self.local_diagnostic.diagnostic.group_id
    }
 }

--- a/crates/editor/src/hunk_diff.rs
+++ b/crates/editor/src/hunk_diff.rs
@@ -365,7 +365,7 @@ impl Editor {
        &mut self,
        diff_base_buffer: Option<Model<Buffer>>,
        hunk: &HoveredHunk,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> Option<()> {
        let buffer = self.buffer.clone();
        let multi_buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -454,18 +454,18 @@ impl Editor {
    fn apply_diff_hunks_in_range(
        &mut self,
        range: Range<Anchor>,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> Option<()> {
-        let (buffer, range, _) = self
-            .buffer
-            .read(cx)
-            .range_to_buffer_ranges(range, cx)
-            .into_iter()
-            .next()?;
+        let multi_buffer = self.buffer.read(cx);
+        let multi_buffer_snapshot = multi_buffer.snapshot(cx);
+        let (excerpt, range) = multi_buffer_snapshot.range_to_buffer_ranges(range).next()?;

-        buffer.update(cx, |branch_buffer, cx| {
-            branch_buffer.merge_into_base(vec![range], cx);
-        });
+        multi_buffer
+            .buffer(excerpt.buffer_id())
+            .unwrap()
+            .update(cx, |branch_buffer, cx| {
+                branch_buffer.merge_into_base(vec![range], cx);
+            });

        if let Some(project) = self.project.clone() {
            self.save(true, project, cx).detach_and_log_err(cx);
@@ -530,7 +530,7 @@ impl Editor {
    fn hunk_header_block(
        &self,
        hunk: &HoveredHunk,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> BlockProperties<Anchor> {
        let is_branch_buffer = self
            .buffer
@@ -801,7 +801,7 @@ impl Editor {
        hunk: &HoveredHunk,
        diff_base_buffer: Model<Buffer>,
        deleted_text_height: u32,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) -> BlockProperties<Anchor> {
        let gutter_color = match hunk.status {
            DiffHunkStatus::Added => unreachable!(),
@@ -864,7 +864,7 @@ impl Editor {
        }
    }

-    pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut ViewContext<'_, Editor>) -> bool {
+    pub(super) fn clear_expanded_diff_hunks(&mut self, cx: &mut ViewContext<Editor>) -> bool {
        if self.diff_map.expand_all {
            return false;
        }
@@ -887,7 +887,7 @@ impl Editor {
    pub(super) fn sync_expanded_diff_hunks(
        diff_map: &mut DiffMap,
        buffer_id: BufferId,
-        cx: &mut ViewContext<'_, Self>,
+        cx: &mut ViewContext<Self>,
    ) {
        let diff_base_state = diff_map.diff_bases.get_mut(&buffer_id);
        let mut diff_base_buffer = None;
@@ -1134,7 +1134,7 @@ fn editor_with_deleted_text(
    diff_base_buffer: Model<Buffer>,
    deleted_color: Hsla,
    hunk: &HoveredHunk,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) -> (u32, View<Editor>) {
    let parent_editor = cx.view().downgrade();
    let editor = cx.new_view(|cx| {
--- a/crates/editor/src/inlay_hint_cache.rs
+++ b/crates/editor/src/inlay_hint_cache.rs
@@ -36,6 +36,7 @@ pub struct InlayHintCache {
    allowed_hint_kinds: HashSet<Option<InlayHintKind>>,
    version: usize,
    pub(super) enabled: bool,
+    enabled_in_settings: bool,
    update_tasks: HashMap<ExcerptId, TasksForRanges>,
    refresh_task: Option<Task<()>>,
    invalidate_debounce: Option<Duration>,
@@ -268,6 +269,7 @@ impl InlayHintCache {
        Self {
            allowed_hint_kinds: inlay_hint_settings.enabled_inlay_hint_kinds(),
            enabled: inlay_hint_settings.enabled,
+            enabled_in_settings: inlay_hint_settings.enabled,
            hints: HashMap::default(),
            update_tasks: HashMap::default(),
            refresh_task: None,
@@ -288,10 +290,21 @@ impl InlayHintCache {
        visible_hints: Vec<Inlay>,
        cx: &mut ViewContext<Editor>,
    ) -> ControlFlow<Option<InlaySplice>> {
+        let old_enabled = self.enabled;
+        // If the setting for inlay hints has changed, update `enabled`. This condition avoids inlay
+        // hint visibility changes when other settings change (such as theme).
+        //
+        // Another option might be to store whether the user has manually toggled inlay hint
+        // visibility, and prefer this. This could lead to confusion as it means inlay hint
+        // visibility would not change when updating the setting if they were ever toggled.
+        if new_hint_settings.enabled != self.enabled_in_settings {
+            self.enabled = new_hint_settings.enabled;
+        };
+        self.enabled_in_settings = new_hint_settings.enabled;
        self.invalidate_debounce = debounce_value(new_hint_settings.edit_debounce_ms);
        self.append_debounce = debounce_value(new_hint_settings.scroll_debounce_ms);
        let new_allowed_hint_kinds = new_hint_settings.enabled_inlay_hint_kinds();
-        match (self.enabled, new_hint_settings.enabled) {
+        match (old_enabled, self.enabled) {
            (false, false) => {
                self.allowed_hint_kinds = new_allowed_hint_kinds;
                ControlFlow::Break(None)
@@ -314,7 +327,6 @@ impl InlayHintCache {
                }
            }
            (true, false) => {
-                self.enabled = new_hint_settings.enabled;
                self.allowed_hint_kinds = new_allowed_hint_kinds;
                if self.hints.is_empty() {
                    ControlFlow::Break(None)
@@ -327,7 +339,6 @@ impl InlayHintCache {
                }
            }
            (false, true) => {
-                self.enabled = new_hint_settings.enabled;
                self.allowed_hint_kinds = new_allowed_hint_kinds;
                ControlFlow::Continue(())
            }
@@ -579,7 +590,7 @@ impl InlayHintCache {
        buffer_id: BufferId,
        excerpt_id: ExcerptId,
        id: InlayId,
-        cx: &mut ViewContext<'_, Editor>,
+        cx: &mut ViewContext<Editor>,
    ) {
        if let Some(excerpt_hints) = self.hints.get(&excerpt_id) {
            let mut guard = excerpt_hints.write();
@@ -640,7 +651,7 @@ fn spawn_new_update_tasks(
    excerpts_to_query: HashMap<ExcerptId, (Model<Buffer>, Global, Range<usize>)>,
    invalidate: InvalidationStrategy,
    update_cache_version: usize,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) {
    for (excerpt_id, (excerpt_buffer, new_task_buffer_version, excerpt_visible_range)) in
        excerpts_to_query
@@ -797,7 +808,7 @@ fn new_update_task(
    query: ExcerptQuery,
    query_ranges: QueryRanges,
    excerpt_buffer: Model<Buffer>,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) -> Task<()> {
    cx.spawn(move |editor, mut cx| async move {
        let visible_range_update_results = future::join_all(
@@ -1129,7 +1140,7 @@ fn apply_hint_update(
    invalidate: bool,
    buffer_snapshot: BufferSnapshot,
    multi_buffer_snapshot: MultiBufferSnapshot,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) {
    let cached_excerpt_hints = editor
        .inlay_hint_cache
@@ -3434,7 +3445,7 @@ pub mod tests {
        labels
    }

-    pub fn visible_hint_labels(editor: &Editor, cx: &ViewContext<'_, Editor>) -> Vec<String> {
+    pub fn visible_hint_labels(editor: &Editor, cx: &ViewContext<Editor>) -> Vec<String> {
        let mut hints = editor
            .visible_inlay_hints(cx)
            .into_iter()
--- a/crates/editor/src/items.rs
+++ b/crates/editor/src/items.rs
@@ -615,9 +615,20 @@ impl Item for Editor {
                .read(cx)
                .as_singleton()
                .and_then(|buffer| buffer.read(cx).project_path(cx))
-                .and_then(|path| self.project.as_ref()?.read(cx).entry_for_path(&path, cx))
-                .map(|entry| {
-                    entry_git_aware_label_color(entry.git_status, entry.is_ignored, params.selected)
+                .and_then(|path| {
+                    let project = self.project.as_ref()?.read(cx);
+                    let entry = project.entry_for_path(&path, cx)?;
+                    let git_status = project
+                        .worktree_for_id(path.worktree_id, cx)?
+                        .read(cx)
+                        .snapshot()
+                        .status_for_file(path.path);
+
+                    Some(entry_git_aware_label_color(
+                        git_status,
+                        entry.is_ignored,
+                        params.selected,
+                    ))
                })
                .unwrap_or_else(|| entry_label_color(params.selected))
        } else {
@@ -1457,10 +1468,11 @@ impl SearchableItem for Editor {
                    search_within_ranges
                };

-                for (excerpt_id, search_buffer, search_range) in
-                    buffer.excerpts_in_ranges(search_within_ranges)
+                for (excerpt, search_range) in
+                    buffer.disjoint_ranges_to_buffer_ranges(search_within_ranges)
                {
                    if !search_range.is_empty() {
+                        let search_buffer = excerpt.buffer();
                        ranges.extend(
                            query
                                .search(search_buffer, Some(search_range.clone()))
@@ -1471,8 +1483,8 @@ impl SearchableItem for Editor {
                                        .anchor_after(search_range.start + match_range.start);
                                    let end = search_buffer
                                        .anchor_before(search_range.start + match_range.end);
-                                    buffer.anchor_in_excerpt(excerpt_id, start).unwrap()
-                                        ..buffer.anchor_in_excerpt(excerpt_id, end).unwrap()
+                                    buffer.anchor_in_excerpt(excerpt.id(), start).unwrap()
+                                        ..buffer.anchor_in_excerpt(excerpt.id(), end).unwrap()
                                }),
                        );
                    }
@@ -1559,10 +1571,10 @@ pub fn entry_git_aware_label_color(
        Color::Ignored
    } else {
        match git_status {
-            Some(GitFileStatus::Added) => Color::Created,
+            Some(GitFileStatus::Added) | Some(GitFileStatus::Untracked) => Color::Created,
            Some(GitFileStatus::Modified) => Color::Modified,
            Some(GitFileStatus::Conflict) => Color::Conflict,
-            None => entry_label_color(selected),
+            Some(GitFileStatus::Deleted) | None => entry_label_color(selected),
        }
    }
 }
--- a/crates/editor/src/proposed_changes_editor.rs
+++ b/crates/editor/src/proposed_changes_editor.rs
@@ -288,7 +288,7 @@ impl EventEmitter<EditorEvent> for ProposedChangesEditor {}
 impl Item for ProposedChangesEditor {
    type Event = EditorEvent;

-    fn tab_icon(&self, _cx: &ui::WindowContext) -> Option<Icon> {
+    fn tab_icon(&self, _cx: &WindowContext) -> Option<Icon> {
        Some(Icon::new(IconName::Diff))
    }

--- a/crates/editor/src/rust_analyzer_ext.rs
+++ b/crates/editor/src/rust_analyzer_ext.rs
@@ -33,7 +33,7 @@ pub fn apply_related_actions(editor: &View<Editor>, cx: &mut WindowContext) {
 pub fn expand_macro_recursively(
    editor: &mut Editor,
    _: &ExpandMacroRecursively,
-    cx: &mut ViewContext<'_, Editor>,
+    cx: &mut ViewContext<Editor>,
 ) {
    if editor.selections.count() == 0 {
        return;
@@ -98,7 +98,7 @@ pub fn expand_macro_recursively(
    .detach_and_log_err(cx);
 }

-pub fn open_docs(editor: &mut Editor, _: &OpenDocs, cx: &mut ViewContext<'_, Editor>) {
+pub fn open_docs(editor: &mut Editor, _: &OpenDocs, cx: &mut ViewContext<Editor>) {
    if editor.selections.count() == 0 {
        return;
    }
--- a/crates/editor/src/scroll/actions.rs
+++ b/crates/editor/src/scroll/actions.rs
@@ -4,7 +4,7 @@ use crate::{
    ScrollAnchor, ScrollCursorBottom, ScrollCursorCenter, ScrollCursorCenterTopBottom,
    ScrollCursorTop, SCROLL_CENTER_TOP_BOTTOM_DEBOUNCE_TIMEOUT,
 };
-use gpui::{Point, ViewContext};
+use gpui::{AsyncWindowContext, Point, ViewContext};

 impl Editor {
    pub fn next_screen(&mut self, _: &NextScreen, cx: &mut ViewContext<Editor>) {
@@ -75,7 +75,7 @@ impl Editor {

        self.next_scroll_position = self.next_scroll_position.next();
        self._scroll_cursor_center_top_bottom_task =
-            cx.spawn(|editor, mut cx: gpui::AsyncWindowContext| async move {
+            cx.spawn(|editor, mut cx: AsyncWindowContext| async move {
                cx.background_executor()
                    .timer(SCROLL_CENTER_TOP_BOTTOM_DEBOUNCE_TIMEOUT)
                    .await;
--- a/crates/editor/src/tasks.rs
+++ b/crates/editor/src/tasks.rs
@@ -8,7 +8,7 @@ use workspace::Workspace;

 fn task_context_with_editor(
    editor: &mut Editor,
-    cx: &mut WindowContext<'_>,
+    cx: &mut WindowContext,
 ) -> AsyncTask<Option<TaskContext>> {
    let Some(project) = editor.project.clone() else {
        return AsyncTask::ready(None);
@@ -74,7 +74,7 @@ fn task_context_with_editor(
    })
 }

-pub fn task_context(workspace: &Workspace, cx: &mut WindowContext<'_>) -> AsyncTask<TaskContext> {
+pub fn task_context(workspace: &Workspace, cx: &mut WindowContext) -> AsyncTask<TaskContext> {
    let Some(editor) = workspace
        .active_item(cx)
        .and_then(|item| item.act_as::<Editor>(cx))
--- a/crates/editor/src/test/editor_lsp_test_context.rs
+++ b/crates/editor/src/test/editor_lsp_test_context.rs
@@ -257,7 +257,8 @@ impl EditorLspTestContext {
        Self::new(language, Default::default(), cx).await
    }

-    // Constructs lsp range using a marked string with '[', ']' range delimiters
+    /// Constructs lsp range using a marked string with '[', ']' range delimiters
+    #[track_caller]
    pub fn lsp_range(&mut self, marked_text: &str) -> lsp::Range {
        let ranges = self.ranges(marked_text);
        self.to_lsp_range(ranges[0].clone())
--- a/crates/editor/src/test/editor_test_context.rs
+++ b/crates/editor/src/test/editor_test_context.rs
@@ -230,6 +230,7 @@ impl EditorTestContext {
        self.cx.background_executor.run_until_parked();
    }

+    #[track_caller]
    pub fn ranges(&mut self, marked_text: &str) -> Vec<Range<usize>> {
        let (unmarked_text, ranges) = marked_text_ranges(marked_text, false);
        assert_eq!(self.buffer_text(), unmarked_text);
--- a/crates/extensions_ui/src/extensions_ui.rs
+++ b/crates/extensions_ui/src/extensions_ui.rs
@@ -843,7 +843,7 @@ impl ExtensionsPage {
        }
    }

-    fn fetch_extensions_debounced(&mut self, cx: &mut ViewContext<'_, ExtensionsPage>) {
+    fn fetch_extensions_debounced(&mut self, cx: &mut ViewContext<ExtensionsPage>) {
        self.extension_fetch_task = Some(cx.spawn(|this, mut cx| async move {
            let search = this
                .update(&mut cx, |this, cx| this.search_query(cx))
--- a/crates/feedback/src/system_specs.rs
+++ b/crates/feedback/src/system_specs.rs
@@ -1,11 +1,10 @@
 use client::telemetry;
-use gpui::Task;
+use gpui::{Task, WindowContext};
 use human_bytes::human_bytes;
 use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
 use serde::Serialize;
 use std::{env, fmt::Display};
 use sysinfo::{MemoryRefreshKind, RefreshKind, System};
-use ui::WindowContext;

 #[derive(Clone, Debug, Serialize)]
 pub struct SystemSpecs {
--- a/crates/file_finder/src/file_finder.rs
+++ b/crates/file_finder/src/file_finder.rs
@@ -884,7 +884,7 @@ impl FileFinderDelegate {
    fn lookup_absolute_path(
        &self,
        query: FileSearchQuery,
-        cx: &mut ViewContext<'_, Picker<Self>>,
+        cx: &mut ViewContext<Picker<Self>>,
    ) -> Task<()> {
        cx.spawn(|picker, mut cx| async move {
            let Some(project) = picker
--- a/crates/fs/src/fs.rs
+++ b/crates/fs/src/fs.rs
@@ -720,7 +720,16 @@ impl Fs for RealFs {
        }

        // Check if path is a symlink and follow the target parent
-        if let Some(target) = self.read_link(&path).await.ok() {
+        if let Some(mut target) = self.read_link(&path).await.ok() {
+            // Check if symlink target is relative path, if so make it absolute
+            if target.is_relative() {
+                if let Some(parent) = path.parent() {
+                    target = parent.join(target);
+                    if let Ok(canonical) = self.canonicalize(&target).await {
+                        target = canonical;
+                    }
+                }
+            }
            watcher.add(&target).ok();
            if let Some(parent) = target.parent() {
                watcher.add(parent).log_err();
--- a/crates/fuzzy/src/matcher.rs
+++ b/crates/fuzzy/src/matcher.rs
@@ -14,7 +14,6 @@ pub struct Matcher<'a> {
    lowercase_query: &'a [char],
    query_char_bag: CharBag,
    smart_case: bool,
-    max_results: usize,
    min_score: f64,
    match_positions: Vec<usize>,
    last_positions: Vec<usize>,
@@ -22,11 +21,6 @@ pub struct Matcher<'a> {
    best_position_matrix: Vec<usize>,
 }

-pub trait Match: Ord {
-    fn score(&self) -> f64;
-    fn set_positions(&mut self, positions: Vec<usize>);
-}
-
 pub trait MatchCandidate {
    fn has_chars(&self, bag: CharBag) -> bool;
    fn to_string(&self) -> Cow<'_, str>;
@@ -38,7 +32,6 @@ impl<'a> Matcher<'a> {
        lowercase_query: &'a [char],
        query_char_bag: CharBag,
        smart_case: bool,
-        max_results: usize,
    ) -> Self {
        Self {
            query,
@@ -50,10 +43,11 @@ impl<'a> Matcher<'a> {
            score_matrix: Vec::new(),
            best_position_matrix: Vec::new(),
            smart_case,
-            max_results,
        }
    }

+    /// Filter and score fuzzy match candidates. Results are returned unsorted, in the same order as
+    /// the input candidates.
    pub fn match_candidates<C: MatchCandidate, R, F>(
        &mut self,
        prefix: &[char],
@@ -63,8 +57,7 @@ impl<'a> Matcher<'a> {
        cancel_flag: &AtomicBool,
        build_match: F,
    ) where
-        R: Match,
-        F: Fn(&C, f64) -> R,
+        F: Fn(&C, f64, &Vec<usize>) -> R,
    {
        let mut candidate_chars = Vec::new();
        let mut lowercase_candidate_chars = Vec::new();
@@ -103,20 +96,7 @@ impl<'a> Matcher<'a> {
            );

            if score > 0.0 {
-                let mut mat = build_match(&candidate, score);
-                if let Err(i) = results.binary_search_by(|m| mat.cmp(m)) {
-                    if results.len() < self.max_results {
-                        mat.set_positions(self.match_positions.clone());
-                        results.insert(i, mat);
-                    } else if i < results.len() {
-                        results.pop();
-                        mat.set_positions(self.match_positions.clone());
-                        results.insert(i, mat);
-                    }
-                    if results.len() == self.max_results {
-                        self.min_score = results.last().unwrap().score();
-                    }
-                }
+                results.push(build_match(&candidate, score, &self.match_positions));
            }
        }
    }
@@ -325,18 +305,18 @@ mod tests {
    #[test]
    fn test_get_last_positions() {
        let mut query: &[char] = &['d', 'c'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let mut matcher = Matcher::new(query, query, query.into(), false);
        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
        assert!(!result);

        query = &['c', 'd'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let mut matcher = Matcher::new(query, query, query.into(), false);
        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
        assert!(result);
        assert_eq!(matcher.last_positions, vec![2, 4]);

        query = &['z', '/', 'z', 'f'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let mut matcher = Matcher::new(query, query, query.into(), false);
        let result = matcher.find_last_positions(&['z', 'e', 'd', '/'], &['z', 'e', 'd', '/', 'f']);
        assert!(result);
        assert_eq!(matcher.last_positions, vec![0, 3, 4, 8]);
@@ -451,7 +431,7 @@ mod tests {
            });
        }

-        let mut matcher = Matcher::new(&query, &lowercase_query, query_chars, smart_case, 100);
+        let mut matcher = Matcher::new(&query, &lowercase_query, query_chars, smart_case);

        let cancel_flag = AtomicBool::new(false);
        let mut results = Vec::new();
@@ -462,16 +442,17 @@ mod tests {
            path_entries.into_iter(),
            &mut results,
            &cancel_flag,
-            |candidate, score| PathMatch {
+            |candidate, score, positions| PathMatch {
                score,
                worktree_id: 0,
-                positions: Vec::new(),
+                positions: positions.clone(),
                path: Arc::from(candidate.path),
                path_prefix: "".into(),
                distance_to_relative_ancestor: usize::MAX,
                is_dir: false,
            },
        );
+        results.sort_by(|a, b| b.cmp(a));

        results
            .into_iter()
--- a/crates/fuzzy/src/paths.rs
+++ b/crates/fuzzy/src/paths.rs
@@ -3,11 +3,14 @@ use std::{
    borrow::Cow,
    cmp::{self, Ordering},
    path::Path,
-    sync::{atomic::AtomicBool, Arc},
+    sync::{
+        atomic::{self, AtomicBool},
+        Arc,
+    },
 };

 use crate::{
-    matcher::{Match, MatchCandidate, Matcher},
+    matcher::{MatchCandidate, Matcher},
    CharBag,
 };

@@ -42,16 +45,6 @@ pub trait PathMatchCandidateSet<'a>: Send + Sync {
    fn candidates(&'a self, start: usize) -> Self::Candidates;
 }

-impl Match for PathMatch {
-    fn score(&self) -> f64 {
-        self.score
-    }
-
-    fn set_positions(&mut self, positions: Vec<usize>) {
-        self.positions = positions;
-    }
-}
-
 impl<'a> MatchCandidate for PathMatchCandidate<'a> {
    fn has_chars(&self, bag: CharBag) -> bool {
        self.char_bag.is_superset(bag)
@@ -102,13 +95,7 @@ pub fn match_fixed_path_set(
    let query = query.chars().collect::<Vec<_>>();
    let query_char_bag = CharBag::from(&lowercase_query[..]);

-    let mut matcher = Matcher::new(
-        &query,
-        &lowercase_query,
-        query_char_bag,
-        smart_case,
-        max_results,
-    );
+    let mut matcher = Matcher::new(&query, &lowercase_query, query_char_bag, smart_case);

    let mut results = Vec::new();
    matcher.match_candidates(
@@ -117,16 +104,17 @@ pub fn match_fixed_path_set(
        candidates.into_iter(),
        &mut results,
        &AtomicBool::new(false),
-        |candidate, score| PathMatch {
+        |candidate, score, positions| PathMatch {
            score,
            worktree_id,
-            positions: Vec::new(),
+            positions: positions.clone(),
            is_dir: candidate.is_dir,
            path: Arc::from(candidate.path),
            path_prefix: Arc::default(),
            distance_to_relative_ancestor: usize::MAX,
        },
    );
+    util::truncate_to_bottom_n_sorted_by(&mut results, max_results, &|a, b| b.cmp(a));
    results
 }

@@ -164,16 +152,15 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
                scope.spawn(async move {
                    let segment_start = segment_idx * segment_size;
                    let segment_end = segment_start + segment_size;
-                    let mut matcher = Matcher::new(
-                        query,
-                        lowercase_query,
-                        query_char_bag,
-                        smart_case,
-                        max_results,
-                    );
+                    let mut matcher =
+                        Matcher::new(query, lowercase_query, query_char_bag, smart_case);

                    let mut tree_start = 0;
                    for candidate_set in candidate_sets {
+                        if cancel_flag.load(atomic::Ordering::Relaxed) {
+                            break;
+                        }
+
                        let tree_end = tree_start + candidate_set.len();

                        if tree_start < segment_end && segment_start < tree_end {
@@ -193,10 +180,10 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
                                candidates,
                                results,
                                cancel_flag,
-                                |candidate, score| PathMatch {
+                                |candidate, score, positions| PathMatch {
                                    score,
                                    worktree_id,
-                                    positions: Vec::new(),
+                                    positions: positions.clone(),
                                    path: Arc::from(candidate.path),
                                    is_dir: candidate.is_dir,
                                    path_prefix: candidate_set.prefix(),
@@ -222,14 +209,12 @@ pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
        })
        .await;

-    let mut results = Vec::new();
-    for segment_result in segment_results {
-        if results.is_empty() {
-            results = segment_result;
-        } else {
-            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
-        }
+    if cancel_flag.load(atomic::Ordering::Relaxed) {
+        return Vec::new();
    }
+
+    let mut results = segment_results.concat();
+    util::truncate_to_bottom_n_sorted_by(&mut results, max_results, &|a, b| b.cmp(a));
    results
 }

--- a/crates/fuzzy/src/strings.rs
+++ b/crates/fuzzy/src/strings.rs
@@ -1,5 +1,5 @@
 use crate::{
-    matcher::{Match, MatchCandidate, Matcher},
+    matcher::{MatchCandidate, Matcher},
    CharBag,
 };
 use gpui::BackgroundExecutor;
@@ -8,7 +8,7 @@ use std::{
    cmp::{self, Ordering},
    iter,
    ops::Range,
-    sync::atomic::AtomicBool,
+    sync::atomic::{self, AtomicBool},
 };

 #[derive(Clone, Debug)]
@@ -46,16 +46,6 @@ pub struct StringMatch {
    pub string: String,
 }

-impl Match for StringMatch {
-    fn score(&self) -> f64 {
-        self.score
-    }
-
-    fn set_positions(&mut self, positions: Vec<usize>) {
-        self.positions = positions;
-    }
-}
-
 impl StringMatch {
    pub fn ranges(&self) -> impl '_ + Iterator<Item = Range<usize>> {
        let mut positions = self.positions.iter().peekable();
@@ -167,13 +157,8 @@ pub async fn match_strings(
                scope.spawn(async move {
                    let segment_start = cmp::min(segment_idx * segment_size, candidates.len());
                    let segment_end = cmp::min(segment_start + segment_size, candidates.len());
-                    let mut matcher = Matcher::new(
-                        query,
-                        lowercase_query,
-                        query_char_bag,
-                        smart_case,
-                        max_results,
-                    );
+                    let mut matcher =
+                        Matcher::new(query, lowercase_query, query_char_bag, smart_case);

                    matcher.match_candidates(
                        &[],
@@ -181,10 +166,10 @@ pub async fn match_strings(
                        candidates[segment_start..segment_end].iter(),
                        results,
                        cancel_flag,
-                        |candidate, score| StringMatch {
+                        |candidate, score, positions| StringMatch {
                            candidate_id: candidate.id,
                            score,
-                            positions: Vec::new(),
+                            positions: positions.clone(),
                            string: candidate.string.to_string(),
                        },
                    );
@@ -193,13 +178,11 @@ pub async fn match_strings(
        })
        .await;

-    let mut results = Vec::new();
-    for segment_result in segment_results {
-        if results.is_empty() {
-            results = segment_result;
-        } else {
-            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
-        }
+    if cancel_flag.load(atomic::Ordering::Relaxed) {
+        return Vec::new();
    }
+
+    let mut results = segment_results.concat();
+    util::truncate_to_bottom_n_sorted_by(&mut results, max_results, &|a, b| b.cmp(a));
    results
 }
--- a/crates/git/src/git.rs
+++ b/crates/git/src/git.rs
@@ -16,6 +16,7 @@ use std::sync::LazyLock;
 pub use crate::hosting_provider::*;
 pub use crate::remote::*;
 pub use git2 as libgit;
+pub use repository::WORK_DIRECTORY_REPO_PATH;

 pub static DOT_GIT: LazyLock<&'static OsStr> = LazyLock::new(|| OsStr::new(".git"));
 pub static COOKIES: LazyLock<&'static OsStr> = LazyLock::new(|| OsStr::new("cookies"));
--- a/crates/git/src/repository.rs
+++ b/crates/git/src/repository.rs
@@ -7,6 +7,8 @@ use gpui::SharedString;
 use parking_lot::Mutex;
 use rope::Rope;
 use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
+use std::sync::LazyLock;
 use std::{
    cmp::Ordering,
    path::{Component, Path, PathBuf},
@@ -37,7 +39,8 @@ pub trait GitRepository: Send + Sync {
    /// Returns the SHA of the current HEAD.
    fn head_sha(&self) -> Option<String>;

-    fn status(&self, path_prefixes: &[PathBuf]) -> Result<GitStatus>;
+    /// Returns the list of git statuses, sorted by path
+    fn status(&self, path_prefixes: &[RepoPath]) -> Result<GitStatus>;

    fn branches(&self) -> Result<Vec<Branch>>;
    fn change_branch(&self, _: &str) -> Result<()>;
@@ -132,7 +135,7 @@ impl GitRepository for RealGitRepository {
        Some(self.repository.lock().head().ok()?.target()?.to_string())
    }

-    fn status(&self, path_prefixes: &[PathBuf]) -> Result<GitStatus> {
+    fn status(&self, path_prefixes: &[RepoPath]) -> Result<GitStatus> {
        let working_directory = self
            .repository
            .lock()
@@ -289,8 +292,9 @@ impl GitRepository for FakeGitRepository {
        state.dot_git_dir.clone()
    }

-    fn status(&self, path_prefixes: &[PathBuf]) -> Result<GitStatus> {
+    fn status(&self, path_prefixes: &[RepoPath]) -> Result<GitStatus> {
        let state = self.state.lock();
+
        let mut entries = state
            .worktree_statuses
            .iter()
@@ -306,6 +310,7 @@ impl GitRepository for FakeGitRepository {
            })
            .collect::<Vec<_>>();
        entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+
        Ok(GitStatus {
            entries: entries.into(),
        })
@@ -394,6 +399,8 @@ pub enum GitFileStatus {
    Added,
    Modified,
    Conflict,
+    Deleted,
+    Untracked,
 }

 impl GitFileStatus {
@@ -421,20 +428,34 @@ impl GitFileStatus {
    }
 }

+pub static WORK_DIRECTORY_REPO_PATH: LazyLock<RepoPath> =
+    LazyLock::new(|| RepoPath(Path::new("").into()));
+
 #[derive(Clone, Debug, Ord, Hash, PartialOrd, Eq, PartialEq)]
-pub struct RepoPath(pub PathBuf);
+pub struct RepoPath(pub Arc<Path>);

 impl RepoPath {
    pub fn new(path: PathBuf) -> Self {
        debug_assert!(path.is_relative(), "Repo paths must be relative");

-        RepoPath(path)
+        RepoPath(path.into())
+    }
+
+    pub fn from_str(path: &str) -> Self {
+        let path = Path::new(path);
+        debug_assert!(path.is_relative(), "Repo paths must be relative");
+
+        RepoPath(path.into())
+    }
+
+    pub fn to_proto(&self) -> String {
+        self.0.to_string_lossy().to_string()
    }
 }

 impl From<&Path> for RepoPath {
    fn from(value: &Path) -> Self {
-        RepoPath::new(value.to_path_buf())
+        RepoPath::new(value.into())
    }
 }

@@ -444,9 +465,15 @@ impl From<PathBuf> for RepoPath {
    }
 }

+impl From<&str> for RepoPath {
+    fn from(value: &str) -> Self {
+        Self::from_str(value)
+    }
+}
+
 impl Default for RepoPath {
    fn default() -> Self {
-        RepoPath(PathBuf::new())
+        RepoPath(Path::new("").into())
    }
 }

@@ -457,13 +484,19 @@ impl AsRef<Path> for RepoPath {
 }

 impl std::ops::Deref for RepoPath {
-    type Target = PathBuf;
+    type Target = Path;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
 }

+impl Borrow<Path> for RepoPath {
+    fn borrow(&self) -> &Path {
+        self.0.as_ref()
+    }
+}
+
 #[derive(Debug)]
 pub struct RepoPathDescendants<'a>(pub &'a Path);

--- a/crates/git/src/status.rs
+++ b/crates/git/src/status.rs
@@ -1,10 +1,6 @@
 use crate::repository::{GitFileStatus, RepoPath};
 use anyhow::{anyhow, Result};
-use std::{
-    path::{Path, PathBuf},
-    process::Stdio,
-    sync::Arc,
-};
+use std::{path::Path, process::Stdio, sync::Arc};

 #[derive(Clone)]
 pub struct GitStatus {
@@ -15,7 +11,7 @@ impl GitStatus {
    pub(crate) fn new(
        git_binary: &Path,
        working_directory: &Path,
-        path_prefixes: &[PathBuf],
+        path_prefixes: &[RepoPath],
    ) -> Result<Self> {
        let child = util::command::new_std_command(git_binary)
            .current_dir(working_directory)
@@ -27,7 +23,7 @@ impl GitStatus {
                "-z",
            ])
            .args(path_prefixes.iter().map(|path_prefix| {
-                if *path_prefix == Path::new("") {
+                if path_prefix.0.as_ref() == Path::new("") {
                    Path::new(".")
                } else {
                    path_prefix
@@ -55,10 +51,12 @@ impl GitStatus {
                    let (status, path) = entry.split_at(3);
                    let status = status.trim();
                    Some((
-                        RepoPath(PathBuf::from(path)),
+                        RepoPath(Path::new(path).into()),
                        match status {
-                            "A" | "??" => GitFileStatus::Added,
+                            "A" => GitFileStatus::Added,
                            "M" => GitFileStatus::Modified,
+                            "D" => GitFileStatus::Deleted,
+                            "??" => GitFileStatus::Untracked,
                            _ => return None,
                        },
                    ))
@@ -75,7 +73,7 @@ impl GitStatus {

    pub fn get(&self, path: &Path) -> Option<GitFileStatus> {
        self.entries
-            .binary_search_by(|(repo_path, _)| repo_path.0.as_path().cmp(path))
+            .binary_search_by(|(repo_path, _)| repo_path.0.as_ref().cmp(path))
            .ok()
            .map(|index| self.entries[index].1)
    }
--- a/crates/git_ui/Cargo.toml
+++ b/crates/git_ui/Cargo.toml
@@ -14,9 +14,11 @@ path = "src/git_ui.rs"

 [dependencies]
 anyhow.workspace = true
+collections.workspace = true
 db.workspace = true
 editor.workspace = true
 futures.workspace = true
+git.workspace = true
 gpui.workspace = true
 language.workspace = true
 menu.workspace = true
@@ -29,8 +31,7 @@ settings.workspace = true
 ui.workspace = true
 util.workspace = true
 workspace.workspace = true
-git.workspace = true
-collections.workspace = true
+worktree.workspace = true

 [target.'cfg(windows)'.dependencies]
 windows.workspace = true
--- a/crates/git_ui/src/git_panel.rs
+++ b/crates/git_ui/src/git_panel.rs
@@ -1,11 +1,16 @@
+use crate::{git_status_icon, settings::GitPanelSettings};
+use crate::{CommitAllChanges, CommitStagedChanges, DiscardAll, StageAll, UnstageAll};
 use anyhow::{Context as _, Result};
-use collections::HashMap;
 use db::kvp::KEY_VALUE_STORE;
 use editor::{
    scroll::{Autoscroll, AutoscrollStrategy},
    Editor, MultiBuffer, DEFAULT_MULTIBUFFER_CONTEXT,
 };
-use git::{diff::DiffHunk, repository::GitFileStatus};
+use git::{
+    diff::DiffHunk,
+    repository::{GitFileStatus, RepoPath},
+};
+use gpui::*;
 use gpui::{
    actions, prelude::*, uniform_list, Action, AppContext, AsyncWindowContext, ClickEvent,
    CursorStyle, EventEmitter, FocusHandle, FocusableView, KeyContext,
@@ -14,7 +19,7 @@ use gpui::{
 };
 use language::{Buffer, BufferRow, OffsetRangeExt};
 use menu::{SelectNext, SelectPrev};
-use project::{Entry, EntryKind, Fs, Project, ProjectEntryId, WorktreeId};
+use project::{EntryKind, Fs, Project, ProjectEntryId, ProjectPath, WorktreeId};
 use serde::{Deserialize, Serialize};
 use settings::Settings as _;
 use std::{
@@ -22,7 +27,7 @@ use std::{
    collections::HashSet,
    ffi::OsStr,
    ops::{Deref, Range},
-    path::{Path, PathBuf},
+    path::PathBuf,
    rc::Rc,
    sync::Arc,
    time::Duration,
@@ -37,9 +42,7 @@ use workspace::{
    dock::{DockPosition, Panel, PanelEvent},
    ItemHandle, Workspace,
 };
-
-use crate::{git_status_icon, settings::GitPanelSettings};
-use crate::{CommitAllChanges, CommitStagedChanges, DiscardAll, StageAll, UnstageAll};
+use worktree::StatusEntry;

 actions!(git_panel, [ToggleFocus]);

@@ -69,7 +72,7 @@ pub struct GitStatusEntry {}
 struct EntryDetails {
    filename: String,
    display_name: String,
-    path: Arc<Path>,
+    path: RepoPath,
    kind: EntryKind,
    depth: usize,
    is_expanded: bool,
@@ -101,13 +104,14 @@ pub struct GitPanel {
    scrollbar_state: ScrollbarState,
    selected_item: Option<usize>,
    show_scrollbar: bool,
-    expanded_dir_ids: HashMap<WorktreeId, Vec<ProjectEntryId>>,
+    // TODO Reintroduce expanded directories, once we're deriving directories from paths
+    // expanded_dir_ids: HashMap<WorktreeId, Vec<ProjectEntryId>>,

    // The entries that are currently shown in the panel, aka
    // not hidden by folding or such
    visible_entries: Vec<WorktreeEntries>,
    width: Option<Pixels>,
-    git_diff_editor: View<Editor>,
+    git_diff_editor: Option<View<Editor>>,
    git_diff_editor_updates: Task<()>,
    reveal_in_editor: Task<()>,
 }
@@ -115,18 +119,20 @@ pub struct GitPanel {
 #[derive(Debug, Clone)]
 struct WorktreeEntries {
    worktree_id: WorktreeId,
+    // TODO support multiple repositories per worktree
+    work_directory: worktree::WorkDirectory,
    visible_entries: Vec<GitPanelEntry>,
-    paths: Rc<OnceCell<HashSet<Arc<Path>>>>,
+    paths: Rc<OnceCell<HashSet<RepoPath>>>,
 }

 #[derive(Debug, Clone)]
 struct GitPanelEntry {
-    entry: Entry,
+    entry: worktree::StatusEntry,
    hunks: Rc<OnceCell<Vec<DiffHunk>>>,
 }

 impl Deref for GitPanelEntry {
-    type Target = Entry;
+    type Target = worktree::StatusEntry;

    fn deref(&self) -> &Self::Target {
        &self.entry
@@ -134,11 +140,11 @@ impl Deref for GitPanelEntry {
 }

 impl WorktreeEntries {
-    fn paths(&self) -> &HashSet<Arc<Path>> {
+    fn paths(&self) -> &HashSet<RepoPath> {
        self.paths.get_or_init(|| {
            self.visible_entries
                .iter()
-                .map(|e| (e.entry.path.clone()))
+                .map(|e| (e.entry.repo_path.clone()))
                .collect()
        })
    }
@@ -149,11 +155,7 @@ impl GitPanel {
        workspace: WeakView<Workspace>,
        cx: AsyncWindowContext,
    ) -> Task<Result<View<Self>>> {
-        cx.spawn(|mut cx| async move {
-            // Clippy incorrectly classifies this as a redundant closure
-            #[allow(clippy::redundant_closure)]
-            workspace.update(&mut cx, |workspace, cx| Self::new(workspace, cx))
-        })
+        cx.spawn(|mut cx| async move { workspace.update(&mut cx, Self::new) })
    }

    pub fn new(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> View<Self> {
@@ -168,9 +170,12 @@ impl GitPanel {
                this.hide_scrollbar(cx);
            })
            .detach();
-            cx.subscribe(&project, |this, project, event, cx| match event {
-                project::Event::WorktreeRemoved(id) => {
-                    this.expanded_dir_ids.remove(id);
+            cx.subscribe(&project, |this, _, event, cx| match event {
+                project::Event::GitRepositoryUpdated => {
+                    this.update_visible_entries(None, None, cx);
+                }
+                project::Event::WorktreeRemoved(_id) => {
+                    // this.expanded_dir_ids.remove(id);
                    this.update_visible_entries(None, None, cx);
                    cx.notify();
                }
@@ -186,9 +191,10 @@ impl GitPanel {
                }
                project::Event::Closed => {
                    this.git_diff_editor_updates = Task::ready(());
-                    this.expanded_dir_ids.clear();
+                    this.reveal_in_editor = Task::ready(());
+                    // this.expanded_dir_ids.clear();
                    this.visible_entries.clear();
-                    this.git_diff_editor = diff_display_editor(project.clone(), cx);
+                    this.git_diff_editor = None;
                }
                _ => {}
            })
@@ -196,28 +202,27 @@ impl GitPanel {

            let scroll_handle = UniformListScrollHandle::new();

-            let mut this = Self {
+            let mut git_panel = Self {
                workspace: weak_workspace,
                focus_handle: cx.focus_handle(),
                fs,
                pending_serialization: Task::ready(None),
                visible_entries: Vec::new(),
                current_modifiers: cx.modifiers(),
-                expanded_dir_ids: Default::default(),
-
+                // expanded_dir_ids: Default::default(),
                width: Some(px(360.)),
                scrollbar_state: ScrollbarState::new(scroll_handle.clone()).parent_view(cx.view()),
                scroll_handle,
                selected_item: None,
                show_scrollbar: !Self::should_autohide_scrollbar(cx),
                hide_scrollbar_task: None,
-                git_diff_editor: diff_display_editor(project.clone(), cx),
+                git_diff_editor: Some(diff_display_editor(cx)),
                git_diff_editor_updates: Task::ready(()),
                reveal_in_editor: Task::ready(()),
                project,
            };
-            this.update_visible_entries(None, None, cx);
-            this
+            git_panel.update_visible_entries(None, None, cx);
+            git_panel
        });

        git_panel
@@ -291,16 +296,16 @@ impl GitPanel {
    }

    fn calculate_depth_and_difference(
-        entry: &Entry,
-        visible_worktree_entries: &HashSet<Arc<Path>>,
+        entry: &StatusEntry,
+        visible_worktree_entries: &HashSet<RepoPath>,
    ) -> (usize, usize) {
        let (depth, difference) = entry
-            .path
+            .repo_path
            .ancestors()
            .skip(1) // Skip the entry itself
            .find_map(|ancestor| {
                if let Some(parent_entry) = visible_worktree_entries.get(ancestor) {
-                    let entry_path_components_count = entry.path.components().count();
+                    let entry_path_components_count = entry.repo_path.components().count();
                    let parent_path_components_count = parent_entry.components().count();
                    let difference = entry_path_components_count - parent_path_components_count;
                    let depth = parent_entry
@@ -435,13 +440,7 @@ impl GitPanel {
    fn entry_count(&self) -> usize {
        self.visible_entries
            .iter()
-            .map(|worktree_entries| {
-                worktree_entries
-                    .visible_entries
-                    .iter()
-                    .filter(|entry| entry.git_status.is_some())
-                    .count()
-            })
+            .map(|worktree_entries| worktree_entries.visible_entries.len())
            .sum()
    }

@@ -449,7 +448,7 @@ impl GitPanel {
        &self,
        range: Range<usize>,
        cx: &mut ViewContext<Self>,
-        mut callback: impl FnMut(ProjectEntryId, EntryDetails, &mut ViewContext<Self>),
+        mut callback: impl FnMut(usize, EntryDetails, &mut ViewContext<Self>),
    ) {
        let mut ix = 0;
        for worktree_entries in &self.visible_entries {
@@ -471,11 +470,11 @@ impl GitPanel {
            {
                let snapshot = worktree.read(cx).snapshot();
                let root_name = OsStr::new(snapshot.root_name());
-                let expanded_entry_ids = self
-                    .expanded_dir_ids
-                    .get(&snapshot.id())
-                    .map(Vec::as_slice)
-                    .unwrap_or(&[]);
+                // let expanded_entry_ids = self
+                //     .expanded_dir_ids
+                //     .get(&snapshot.id())
+                //     .map(Vec::as_slice)
+                //     .unwrap_or(&[]);

                let entry_range = range.start.saturating_sub(ix)..end_ix - ix;
                let entries = worktree_entries.paths();
@@ -486,22 +485,22 @@ impl GitPanel {
                    .enumerate()
                {
                    let index = index_start + i;
-                    let status = entry.git_status;
-                    let is_expanded = expanded_entry_ids.binary_search(&entry.id).is_ok();
+                    let status = entry.status;
+                    let is_expanded = true; //expanded_entry_ids.binary_search(&entry.id).is_ok();

                    let (depth, difference) = Self::calculate_depth_and_difference(entry, entries);

                    let filename = match difference {
                        diff if diff > 1 => entry
-                            .path
+                            .repo_path
                            .iter()
-                            .skip(entry.path.components().count() - diff)
+                            .skip(entry.repo_path.components().count() - diff)
                            .collect::<PathBuf>()
                            .to_str()
                            .unwrap_or_default()
                            .to_string(),
                        _ => entry
-                            .path
+                            .repo_path
                            .file_name()
                            .map(|name| name.to_string_lossy().into_owned())
                            .unwrap_or_else(|| root_name.to_string_lossy().to_string()),
@@ -509,16 +508,17 @@ impl GitPanel {

                    let details = EntryDetails {
                        filename,
-                        display_name: entry.path.to_string_lossy().into_owned(),
-                        kind: entry.kind,
+                        display_name: entry.repo_path.to_string_lossy().into_owned(),
+                        // TODO get it from StatusEntry?
+                        kind: EntryKind::File,
                        is_expanded,
-                        path: entry.path.clone(),
-                        status,
+                        path: entry.repo_path.clone(),
+                        status: Some(status),
                        hunks: entry.hunks.clone(),
                        depth,
                        index,
                    };
-                    callback(entry.id, details, cx);
+                    callback(ix, details, cx);
                }
            }
            ix = end_ix;
@@ -530,7 +530,7 @@ impl GitPanel {
    fn update_visible_entries(
        &mut self,
        for_worktree: Option<WorktreeId>,
-        new_selected_entry: Option<(WorktreeId, ProjectEntryId)>,
+        _new_selected_entry: Option<(WorktreeId, ProjectEntryId)>,
        cx: &mut ViewContext<Self>,
    ) {
        let project = self.project.read(cx);
@@ -552,24 +552,36 @@ impl GitPanel {
                None => false,
            });
        for worktree in project.visible_worktrees(cx) {
-            let worktree_id = worktree.read(cx).id();
+            let snapshot = worktree.read(cx).snapshot();
+            let worktree_id = snapshot.id();
+
            if for_worktree.is_some() && for_worktree != Some(worktree_id) {
                continue;
            }
-            let snapshot = worktree.read(cx).snapshot();

-            let mut visible_worktree_entries = snapshot
-                .entries(false, 0)
-                .filter(|entry| !entry.is_external)
-                .filter(|entry| entry.git_status.is_some())
-                .cloned()
-                .collect::<Vec<_>>();
-            snapshot.propagate_git_statuses(&mut visible_worktree_entries);
-            project::sort_worktree_entries(&mut visible_worktree_entries);
+            let mut visible_worktree_entries = Vec::new();
+            // Only use the first repository for now
+            let repositories = snapshot.repositories().take(1);
+            let mut work_directory = None;
+            for repository in repositories {
+                visible_worktree_entries.extend(repository.status());
+                work_directory = Some(worktree::WorkDirectory::clone(repository));
+            }
+
+            // TODO use the GitTraversal
+            // let mut visible_worktree_entries = snapshot
+            //     .entries(false, 0)
+            //     .filter(|entry| !entry.is_external)
+            //     .filter(|entry| entry.git_status.is_some())
+            //     .cloned()
+            //     .collect::<Vec<_>>();
+            // snapshot.propagate_git_statuses(&mut visible_worktree_entries);
+            // project::sort_worktree_entries(&mut visible_worktree_entries);

            if !visible_worktree_entries.is_empty() {
                self.visible_entries.push(WorktreeEntries {
                    worktree_id,
+                    work_directory: work_directory.unwrap(),
                    visible_entries: visible_worktree_entries
                        .into_iter()
                        .map(|entry| GitPanelEntry {
@@ -583,26 +595,27 @@ impl GitPanel {
        }
        self.visible_entries.extend(after_update);

-        if let Some((worktree_id, entry_id)) = new_selected_entry {
-            self.selected_item = self.visible_entries.iter().enumerate().find_map(
-                |(worktree_index, worktree_entries)| {
-                    if worktree_entries.worktree_id == worktree_id {
-                        worktree_entries
-                            .visible_entries
-                            .iter()
-                            .position(|entry| entry.id == entry_id)
-                            .map(|entry_index| {
-                                worktree_index * worktree_entries.visible_entries.len()
-                                    + entry_index
-                            })
-                    } else {
-                        None
-                    }
-                },
-            );
-        }
+        // TODO re-implement this
+        // if let Some((worktree_id, entry_id)) = new_selected_entry {
+        //     self.selected_item = self.visible_entries.iter().enumerate().find_map(
+        //         |(worktree_index, worktree_entries)| {
+        //             if worktree_entries.worktree_id == worktree_id {
+        //                 worktree_entries
+        //                     .visible_entries
+        //                     .iter()
+        //                     .position(|entry| entry.id == entry_id)
+        //                     .map(|entry_index| {
+        //                         worktree_index * worktree_entries.visible_entries.len()
+        //                             + entry_index
+        //                     })
+        //             } else {
+        //                 None
+        //             }
+        //         },
+        //     );
+        // }

-        let project = self.project.clone();
+        let project = self.project.downgrade();
        self.git_diff_editor_updates = cx.spawn(|git_panel, mut cx| async move {
            cx.background_executor()
                .timer(UPDATE_DEBOUNCE)
@@ -610,17 +623,19 @@ impl GitPanel {
            let Some(project_buffers) = git_panel
                .update(&mut cx, |git_panel, cx| {
                    futures::future::join_all(git_panel.visible_entries.iter_mut().flat_map(
-                        move |worktree_entries| {
+                        |worktree_entries| {
                            worktree_entries
                                .visible_entries
                                .iter()
                                .filter_map(|entry| {
-                                    let git_status = entry.git_status()?;
+                                    let git_status = entry.status;
                                    let entry_hunks = entry.hunks.clone();
                                    let (entry_path, unstaged_changes_task) =
                                        project.update(cx, |project, cx| {
-                                            let entry_path =
-                                                project.path_for_entry(entry.id, cx)?;
+                                            let entry_path = ProjectPath {
+                                                worktree_id: worktree_entries.worktree_id,
+                                                path: worktree_entries.work_directory.unrelativize(&entry.repo_path)?,
+                                            };
                                            let open_task =
                                                project.open_path(entry_path.clone(), cx);
                                            let unstaged_changes_task =
@@ -685,8 +700,8 @@ impl GitPanel {
                                                                                )
                                                                                .collect()
                                                                    }
-                                                                    // TODO support conflicts display
-                                                                    GitFileStatus::Conflict => Vec::new(),
+                                                                    // TODO support these
+                                                                    GitFileStatus::Conflict | GitFileStatus::Deleted | GitFileStatus::Untracked => Vec::new(),
                                                                }
                                                            }).clone()
                                                    })?;
@@ -694,7 +709,7 @@ impl GitPanel {
                                                    anyhow::Ok((buffer, unstaged_changes, hunks))
                                                });
                                            Some((entry_path, unstaged_changes_task))
-                                        })?;
+                                        }).ok()??;
                                    Some((entry_path, unstaged_changes_task))
                                })
                                .map(|(entry_path, open_task)| async move {
@@ -716,7 +731,7 @@ impl GitPanel {
            let mut change_sets = Vec::with_capacity(project_buffers.len());
            if let Some(buffer_update_task) = git_panel
                .update(&mut cx, |git_panel, cx| {
-                    let editor = git_panel.git_diff_editor.clone();
+                    let editor = git_panel.git_diff_editor.clone()?;
                    let multi_buffer = editor.read(cx).buffer().clone();
                    let mut buffers_with_ranges = Vec::with_capacity(project_buffers.len());
                    for (buffer_path, open_result) in project_buffers {
@@ -735,25 +750,27 @@ impl GitPanel {
                        }
                    }

-                    multi_buffer.update(cx, |multi_buffer, cx| {
+                    Some(multi_buffer.update(cx, |multi_buffer, cx| {
                        multi_buffer.clear(cx);
                        multi_buffer.push_multiple_excerpts_with_context_lines(
                            buffers_with_ranges,
                            DEFAULT_MULTIBUFFER_CONTEXT,
                            cx,
                        )
-                    })
+                    }))
                })
-                .ok()
+                .ok().flatten()
            {
                buffer_update_task.await;
                git_panel
                    .update(&mut cx, |git_panel, cx| {
-                        git_panel.git_diff_editor.update(cx, |editor, cx| {
-                            for change_set in change_sets {
-                                editor.add_change_set(change_set, cx);
-                            }
-                        })
+                        if let Some(diff_editor) = git_panel.git_diff_editor.as_ref() {
+                            diff_editor.update(cx, |editor, cx| {
+                                for change_set in change_sets {
+                                    editor.add_change_set(change_set, cx);
+                                }
+                            });
+                        }
                    })
                    .ok();
            }
@@ -993,18 +1010,17 @@ impl GitPanel {

    fn render_entry(
        &self,
-        id: ProjectEntryId,
+        ix: usize,
        selected: bool,
        details: EntryDetails,
        cx: &ViewContext<Self>,
    ) -> impl IntoElement {
-        let id = id.to_proto() as usize;
-        let checkbox_id = ElementId::Name(format!("checkbox_{}", id).into());
+        let checkbox_id = ElementId::Name(format!("checkbox_{}", ix).into());
        let is_staged = ToggleState::Selected;
-        let handle = cx.view().clone();
+        let handle = cx.view().downgrade();

        h_flex()
-            .id(id)
+            .id(("git-panel-entry", ix))
            .h(px(28.))
            .w_full()
            .pl(px(12. + 12. * details.depth as f32))
@@ -1020,20 +1036,22 @@ impl GitPanel {
                this.child(git_status_icon(status))
            })
            .child(
-                ListItem::new(("label", id))
+                ListItem::new(details.path.0.clone())
                    .toggle_state(selected)
                    .child(h_flex().gap_1p5().child(details.display_name.clone()))
                    .on_click(move |e, cx| {
-                        handle.update(cx, |git_panel, cx| {
-                            git_panel.selected_item = Some(details.index);
-                            let change_focus = e.down.click_count > 1;
-                            git_panel.reveal_entry_in_git_editor(
-                                details.hunks.clone(),
-                                change_focus,
-                                None,
-                                cx,
-                            );
-                        });
+                        handle
+                            .update(cx, |git_panel, cx| {
+                                git_panel.selected_item = Some(details.index);
+                                let change_focus = e.down.click_count > 1;
+                                git_panel.reveal_entry_in_git_editor(
+                                    details.hunks.clone(),
+                                    change_focus,
+                                    None,
+                                    cx,
+                                );
+                            })
+                            .ok();
                    }),
            )
    }
@@ -1043,10 +1061,12 @@ impl GitPanel {
        hunks: Rc<OnceCell<Vec<DiffHunk>>>,
        change_focus: bool,
        debounce: Option<Duration>,
-        cx: &mut ViewContext<'_, Self>,
+        cx: &mut ViewContext<Self>,
    ) {
        let workspace = self.workspace.clone();
-        let diff_editor = self.git_diff_editor.clone();
+        let Some(diff_editor) = self.git_diff_editor.clone() else {
+            return;
+        };
        self.reveal_in_editor = cx.spawn(|_, mut cx| async move {
            if let Some(debounce) = debounce {
                cx.background_executor().timer(debounce).await;
@@ -1196,7 +1216,7 @@ impl Panel for GitPanel {
        "GitPanel"
    }

-    fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
+    fn position(&self, cx: &WindowContext) -> DockPosition {
        GitPanelSettings::get_global(cx).dock
    }

@@ -1212,7 +1232,7 @@ impl Panel for GitPanel {
        );
    }

-    fn size(&self, cx: &gpui::WindowContext) -> Pixels {
+    fn size(&self, cx: &WindowContext) -> Pixels {
        self.width
            .unwrap_or_else(|| GitPanelSettings::get_global(cx).default_width)
    }
@@ -1234,14 +1254,18 @@ impl Panel for GitPanel {
    fn toggle_action(&self) -> Box<dyn Action> {
        Box::new(ToggleFocus)
    }
+
+    fn activation_priority(&self) -> u32 {
+        2
+    }
 }

-fn diff_display_editor(project: Model<Project>, cx: &mut WindowContext) -> View<Editor> {
+fn diff_display_editor(cx: &mut WindowContext) -> View<Editor> {
    cx.new_view(|cx| {
-        let multi_buffer = cx.new_model(|cx| {
-            MultiBuffer::new(project.read(cx).capability()).with_title("Project diff".to_string())
+        let multi_buffer = cx.new_model(|_| {
+            MultiBuffer::new(language::Capability::ReadWrite).with_title("Project diff".to_string())
        });
-        let mut editor = Editor::for_multibuffer(multi_buffer, Some(project), true, cx);
+        let mut editor = Editor::for_multibuffer(multi_buffer, None, true, cx);
        editor.set_expand_all_diff_hunks();
        editor
    })
--- a/crates/git_ui/src/git_ui.rs
+++ b/crates/git_ui/src/git_ui.rs
@@ -44,10 +44,13 @@ const REMOVED_COLOR: Hsla = Hsla {
 // TODO: Add updated status colors to theme
 pub fn git_status_icon(status: GitFileStatus) -> impl IntoElement {
    match status {
-        GitFileStatus::Added => Icon::new(IconName::SquarePlus).color(Color::Custom(ADDED_COLOR)),
+        GitFileStatus::Added | GitFileStatus::Untracked => {
+            Icon::new(IconName::SquarePlus).color(Color::Custom(ADDED_COLOR))
+        }
        GitFileStatus::Modified => {
            Icon::new(IconName::SquareDot).color(Color::Custom(MODIFIED_COLOR))
        }
        GitFileStatus::Conflict => Icon::new(IconName::Warning).color(Color::Custom(REMOVED_COLOR)),
+        GitFileStatus::Deleted => Icon::new(IconName::Warning).color(Color::Custom(REMOVED_COLOR)),
    }
 }
--- a/crates/gpui/Cargo.toml
+++ b/crates/gpui/Cargo.toml
@@ -22,7 +22,7 @@ test-support = [
    "x11",
 ]
 runtime_shaders = []
-macos-blade = ["blade-graphics", "blade-macros", "blade-util", "bytemuck"]
+macos-blade = ["blade-graphics", "blade-macros", "blade-util", "bytemuck", "objc2", "objc2-metal"]
 wayland = [
    "blade-graphics",
    "blade-macros",
@@ -132,11 +132,14 @@ core-foundation.workspace = true
 core-foundation-sys = "0.8"
 core-graphics = "0.23"
 core-text = "20.1"
-font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7", optional = true}
+font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7", optional = true }
 foreign-types = "0.5"
 log.workspace = true
 media.workspace = true
 objc = "0.2"
+objc2 = { version = "0.5", optional = true }
+objc2-metal = { version = "0.2", optional = true }
+#TODO: replace with "objc2"
 metal.workspace = true

 [target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))'.dependencies]
--- a/crates/gpui/examples/shadow.rs
+++ b/crates/gpui/examples/shadow.rs
@@ -1,25 +1,574 @@
 use gpui::{
-    div, prelude::*, px, rgb, size, App, AppContext, Bounds, ViewContext, WindowBounds,
-    WindowOptions,
+    div, hsla, point, prelude::*, px, relative, rgb, size, App, AppContext, Bounds, BoxShadow, Div,
+    SharedString, ViewContext, WindowBounds, WindowOptions,
 };

+use smallvec::smallvec;
+
 struct Shadow {}

+impl Shadow {
+    fn base() -> Div {
+        div()
+            .size_16()
+            .bg(rgb(0xffffff))
+            .rounded_full()
+            .border_1()
+            .border_color(hsla(0.0, 0.0, 0.0, 0.1))
+    }
+
+    fn square() -> Div {
+        div()
+            .size_16()
+            .bg(rgb(0xffffff))
+            .border_1()
+            .border_color(hsla(0.0, 0.0, 0.0, 0.1))
+    }
+
+    fn rounded_small() -> Div {
+        div()
+            .size_16()
+            .bg(rgb(0xffffff))
+            .rounded(px(4.))
+            .border_1()
+            .border_color(hsla(0.0, 0.0, 0.0, 0.1))
+    }
+
+    fn rounded_medium() -> Div {
+        div()
+            .size_16()
+            .bg(rgb(0xffffff))
+            .rounded(px(8.))
+            .border_1()
+            .border_color(hsla(0.0, 0.0, 0.0, 0.1))
+    }
+
+    fn rounded_large() -> Div {
+        div()
+            .size_16()
+            .bg(rgb(0xffffff))
+            .rounded(px(12.))
+            .border_1()
+            .border_color(hsla(0.0, 0.0, 0.0, 0.1))
+    }
+}
+
+fn example(label: impl Into<SharedString>, example: impl IntoElement) -> impl IntoElement {
+    let label = label.into();
+
+    div()
+        .flex()
+        .flex_col()
+        .justify_center()
+        .items_center()
+        .w(relative(1. / 6.))
+        .border_r_1()
+        .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+        .child(
+            div()
+                .flex()
+                .items_center()
+                .justify_center()
+                .flex_1()
+                .py_12()
+                .child(example),
+        )
+        .child(
+            div()
+                .w_full()
+                .border_t_1()
+                .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                .p_1()
+                .flex()
+                .items_center()
+                .child(label),
+        )
+}
+
 impl Render for Shadow {
    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
        div()
-            .flex()
+            .id("shadow-example")
+            .overflow_y_scroll()
            .bg(rgb(0xffffff))
            .size_full()
-            .justify_center()
-            .items_center()
-            .child(div().size_8().shadow_sm())
+            .text_xs()
+            .child(div().flex().flex_col().w_full().children(vec![
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .flex_row()
+                    .children(vec![
+                        example(
+                            "Square",
+                            Shadow::square()
+                                .shadow(smallvec![BoxShadow {
+                                    color: hsla(0.0, 0.5, 0.5, 0.3),
+                                    offset: point(px(0.), px(8.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(0.),
+                                }]),
+                        ),
+                        example(
+                            "Rounded 4",
+                            Shadow::rounded_small()
+                                .shadow(smallvec![BoxShadow {
+                                    color: hsla(0.0, 0.5, 0.5, 0.3),
+                                    offset: point(px(0.), px(8.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(0.),
+                                }]),
+                        ),
+                        example(
+                            "Rounded 8",
+                            Shadow::rounded_medium()
+                                .shadow(smallvec![BoxShadow {
+                                    color: hsla(0.0, 0.5, 0.5, 0.3),
+                                    offset: point(px(0.), px(8.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(0.),
+                                }]),
+                        ),
+                        example(
+                            "Rounded 16",
+                            Shadow::rounded_large()
+                                .shadow(smallvec![BoxShadow {
+                                    color: hsla(0.0, 0.5, 0.5, 0.3),
+                                    offset: point(px(0.), px(8.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(0.),
+                                }]),
+                        ),
+                        example(
+                            "Circle",
+                            Shadow::base()
+                                .shadow(smallvec![BoxShadow {
+                                    color: hsla(0.0, 0.5, 0.5, 0.3),
+                                    offset: point(px(0.), px(8.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(0.),
+                                }]),
+                        ),
+                    ]),
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .w_full()
+                    .children(vec![
+                        example("None", Shadow::base()),
+                        // Small shadow
+                        example("Small", Shadow::base().shadow_sm()),
+                        // Medium shadow
+                        example("Medium", Shadow::base().shadow_md()),
+                        // Large shadow
+                        example("Large", Shadow::base().shadow_lg()),
+                        example("Extra Large", Shadow::base().shadow_xl()),
+                        example("2X Large", Shadow::base().shadow_2xl()),
+                    ]),
+                // Horizontal list of increasing blur radii
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Blur 0",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(0.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Blur 2",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(2.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Blur 4",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(4.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Blur 8",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Blur 16",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(16.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                    ]),
+                // Horizontal list of increasing spread radii
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Spread 0",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Spread 2",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(2.),
+                            }]),
+                        ),
+                        example(
+                            "Spread 4",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(4.),
+                            }]),
+                        ),
+                        example(
+                            "Spread 8",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(8.),
+                            }]),
+                        ),
+                        example(
+                            "Spread 16",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(16.),
+                            }]),
+                        ),
+                    ]),
+                // Square spread examples
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Square Spread 0",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Square Spread 8",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(8.),
+                            }]),
+                        ),
+                        example(
+                            "Square Spread 16",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(16.),
+                            }]),
+                        ),
+                    ]),
+                // Rounded large spread examples
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Rounded Large Spread 0",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Rounded Large Spread 8",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(8.),
+                            }]),
+                        ),
+                        example(
+                            "Rounded Large Spread 16",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.0, 0.0, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(16.),
+                            }]),
+                        ),
+                    ]),
+                // Directional shadows
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Left",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(-8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Right",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Top",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(-8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Bottom",
+                            Shadow::base().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                    ]),
+                // Square directional shadows
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Square Left",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(-8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Square Right",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Square Top",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(-8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Square Bottom",
+                            Shadow::square().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                    ]),
+                // Rounded large directional shadows
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Rounded Large Left",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(-8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Rounded Large Right",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(8.), px(0.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Rounded Large Top",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(-8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                        example(
+                            "Rounded Large Bottom",
+                            Shadow::rounded_large().shadow(smallvec![BoxShadow {
+                                color: hsla(0.0, 0.5, 0.5, 0.3),
+                                offset: point(px(0.), px(8.)),
+                                blur_radius: px(8.),
+                                spread_radius: px(0.),
+                            }]),
+                        ),
+                    ]),
+                // Multiple shadows for different shapes
+                div()
+                    .border_b_1()
+                    .border_color(hsla(0.0, 0.0, 0.0, 1.0))
+                    .flex()
+                    .children(vec![
+                        example(
+                            "Circle Multiple",
+                            Shadow::base().shadow(smallvec![
+                                BoxShadow {
+                                    color: hsla(0.0 / 360., 1.0, 0.5, 0.3), // Red
+                                    offset: point(px(0.), px(-12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(60.0 / 360., 1.0, 0.5, 0.3), // Yellow
+                                    offset: point(px(12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(120.0 / 360., 1.0, 0.5, 0.3), // Green
+                                    offset: point(px(0.), px(12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(240.0 / 360., 1.0, 0.5, 0.3), // Blue
+                                    offset: point(px(-12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                            ]),
+                        ),
+                        example(
+                            "Square Multiple",
+                            Shadow::square().shadow(smallvec![
+                                BoxShadow {
+                                    color: hsla(0.0 / 360., 1.0, 0.5, 0.3), // Red
+                                    offset: point(px(0.), px(-12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(60.0 / 360., 1.0, 0.5, 0.3), // Yellow
+                                    offset: point(px(12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(120.0 / 360., 1.0, 0.5, 0.3), // Green
+                                    offset: point(px(0.), px(12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(240.0 / 360., 1.0, 0.5, 0.3), // Blue
+                                    offset: point(px(-12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                            ]),
+                        ),
+                        example(
+                            "Rounded Large Multiple",
+                            Shadow::rounded_large().shadow(smallvec![
+                                BoxShadow {
+                                    color: hsla(0.0 / 360., 1.0, 0.5, 0.3), // Red
+                                    offset: point(px(0.), px(-12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(60.0 / 360., 1.0, 0.5, 0.3), // Yellow
+                                    offset: point(px(12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(120.0 / 360., 1.0, 0.5, 0.3), // Green
+                                    offset: point(px(0.), px(12.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                                BoxShadow {
+                                    color: hsla(240.0 / 360., 1.0, 0.5, 0.3), // Blue
+                                    offset: point(px(-12.), px(0.)),
+                                    blur_radius: px(8.),
+                                    spread_radius: px(2.),
+                                },
+                            ]),
+                        ),
+                    ]),
+            ]))
    }
 }

 fn main() {
    App::new().run(|cx: &mut AppContext| {
-        let bounds = Bounds::centered(None, size(px(300.0), px(300.0)), cx);
+        let bounds = Bounds::centered(None, size(px(1000.0), px(800.0)), cx);
        cx.open_window(
            WindowOptions {
                window_bounds: Some(WindowBounds::Windowed(bounds)),
@@ -28,5 +577,7 @@ fn main() {
            |cx| cx.new_view(|_cx| Shadow {}),
        )
        .unwrap();
+
+        cx.activate(true);
    });
 }
--- a/crates/gpui/src/action.rs
+++ b/crates/gpui/src/action.rs
@@ -185,8 +185,7 @@ macro_rules! actions {
            #[doc = "The `"]
            #[doc = stringify!($name)]
            #[doc = "` action, see [`gpui::actions!`]"]
-            #[derive(::std::cmp::PartialEq, ::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug, gpui::private::serde_derive::Deserialize)]
-            #[serde(crate = "gpui::private::serde")]
+            #[derive(::std::clone::Clone,::std::cmp::PartialEq, ::std::default::Default)]
            pub struct $name;

            gpui::__impl_action!($namespace, $name, $name,
@@ -211,14 +210,7 @@ macro_rules! action_as {
        #[doc = "The `"]
        #[doc = stringify!($name)]
        #[doc = "` action, see [`gpui::actions!`]"]
-        #[derive(
-            ::std::cmp::PartialEq,
-            ::std::clone::Clone,
-            ::std::default::Default,
-            ::std::fmt::Debug,
-            gpui::private::serde_derive::Deserialize,
-        )]
-        #[serde(crate = "gpui::private::serde")]
+        #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
        pub struct $name;

        gpui::__impl_action!(
--- a/Show More
+++ b/Show More